# ----------------------------------------------------
# Created automagically by Herbal 2.0.9
# Date Compiled: Mon Mar 26 12:52:26 EDT 2007
# Compiled By: mcohen
# ----------------------------------------------------

# **** START prescript.soar ****
	watch --level 0
	watch --productions
# **** END prescript.soar ****


#-------------------------------------------------------------------------------
#elaborations to retract completed output...
#-------------------------------------------------------------------------------
sp {apply*global*remove-dtank-types-enemy
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.enemy| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.enemy| <x> -)
}

sp {apply*global*remove-dtank-types-tankHeading
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.tankHeading| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.tankHeading| <x> -)
}

sp {apply*global*remove-dtank-types-friend
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.friend| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.friend| <x> -)
}

sp {apply*global*remove-dtank-types-inTrouble
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.inTrouble| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.inTrouble| <x> -)
}

sp {apply*global*remove-dtank-types-action
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.action| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.action| <x> -)
}

sp {apply*global*remove-dtank-types-me
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.me| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.me| <x> -)
}

sp {apply*global*remove-dtank-types-enemySpotted
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.enemySpotted| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.enemySpotted| <x> -)
}

sp {apply*global*remove-dtank-types-terrain
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.terrain| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.terrain| <x> -)
}

sp {apply*global*remove-dtank-types-throttle
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.throttle| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.throttle| <x> -)
}

sp {apply*global*remove-dtank-types-turretHeading
	(state <s> ^operator <o> ^io.output-link <out>)
	(<out> ^|dtank.types.turretHeading| <x>)
	(<x> ^status complete)
	-->
	(<out> ^|dtank.types.turretHeading| <x> -)
}

#-------------------------------------------------------------------------------
#define topspace
#-------------------------------------------------------------------------------

sp {propose*initialize-topspace
	(state <local> ^type state -^name)
	(<local> ^superstate nil)
	-->
	(<local> ^operator <o> +)
	(<o> ^name initialize-topspace)
	(<o> ^top <local>)
	(<o> ^parent <local>)
}

sp {apply*initialize-topspace
	(state <local> ^operator <o>)
	(<o> ^name initialize-topspace ^top <top> ^parent <parent>)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<local> ^name topspace)
	(<local> ^top <local>)
	(<local> ^parent <local>)
	(<local> ^|tank.types.curDir| <tank-types-curDir1>)
	(<tank-types-curDir1> ^dir 0 )
}

#define the impasses...
sp {propose*topspace*impasse*attackps
	(state <local> ^top <top> ^name topspace)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.enemySpotted| <dtank-types-enemySpotted2>)
	(<dtank-types-enemySpotted2> ^flag <flag2> true )
	(<i2> ^|dtank.types.inTrouble| <dtank-types-inTrouble3>)
	(<dtank-types-inTrouble3> ^flag <flag3> false )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name impasse*attackps)
}

sp {propose*topspace*impasse*wanderps
	(state <local> ^top <top> ^name topspace)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.enemySpotted| <dtank-types-enemySpotted4>)
	(<dtank-types-enemySpotted4> ^flag <flag4> false )
	(<i2> ^|dtank.types.inTrouble| <dtank-types-inTrouble5>)
	(<dtank-types-inTrouble5> ^flag <flag5> false )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name impasse*wanderps)
}

sp {propose*topspace*impasse*retreatps
	(state <local> ^top <top> ^name topspace)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.inTrouble| <dtank-types-inTrouble6>)
	(<dtank-types-inTrouble6> ^flag <flag6> true )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name impasse*retreatps)
}

#-------------------------------------------------------------------------------
#define attack
#-------------------------------------------------------------------------------

sp {propose*initialize-attack
	(state <local> ^type state -^name)
	(<local> ^impasse no-change ^attribute operator)
	(<local> ^superstate <parent>)
	(<parent> ^top <top>)
	(<parent> ^operator <imp>)
	(<imp> ^name impasse*attackps)
	-->
	(<local> ^operator <o> +)
	(<o> ^name initialize-attack)
	(<o> ^top <top>)
	(<o> ^parent <parent>)
}

sp {apply*initialize-attack
	(state <local> ^operator <o>)
	(<o> ^name initialize-attack ^top <top> ^parent <parent>)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<local> ^name attack)
	(<local> ^top <top>)
	(<local> ^parent <parent>)
	(<i2> ^|dtank.types.throttle| <dtank-types-throttle7>)
	(<dtank-types-throttle7> ^value 0 )
	(write |stopping| )
}

#define the rules...
sp {propose*attack*fire
	(state <local> ^top <top> ^parent <parent> ^name attack)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.enemy| <enemy>)
	(<enemy> ^nationality <nationality8>)
	(<enemy> ^y <y9>)
	(<enemy> ^distance <distance10>)
	(<enemy> ^heading <heading11>)
	(<enemy> ^x <x12>)
	-->
	(<local> ^operator <o> + =)
	(<o> ^name fire)
	(<o> ^enemy <enemy>)
}
sp {apply*attack*fire
	(state <local> ^top <top> ^name attack ^operator <o>)
	(<o> ^name fire)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	(<o> ^enemy <enemy>)
	(<enemy> ^x <enemy-x>)
	(<enemy> ^y <enemy-y>)
	(<enemy> ^nationality <enemy-nationality>)
	(<enemy> ^distance <enemy-distance>)
	(<enemy> ^heading <enemy-heading>)
	-->
	(<i2> ^|dtank.types.action| <dtank-types-action13>)
	(<dtank-types-action13> ^value |fire| )
	(write |firing| )
}
sp {propose*attack*aim
	(state <local> ^top <top> ^parent <parent> ^name attack)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.enemy| <enemy>)
	(<enemy> ^nationality <nationality14>)
	(<enemy> ^y <y15>)
	(<enemy> ^distance <distance16>)
	(<enemy> ^heading <heading17>)
	(<enemy> ^x <x18>)
	-->
	(<local> ^operator <o> + =)
	(<o> ^name aim)
	(<o> ^enemy <enemy>)
}
sp {apply*attack*aim
	(state <local> ^top <top> ^name attack ^operator <o>)
	(<o> ^name aim)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	(<o> ^enemy <enemy>)
	(<enemy> ^x <enemy-x>)
	(<enemy> ^y <enemy-y>)
	(<enemy> ^nationality <enemy-nationality>)
	(<enemy> ^distance <enemy-distance>)
	(<enemy> ^heading <enemy-heading>)
	-->
	(<i2> ^|dtank.types.turretHeading| <dtank-types-turretHeading19>)
	(<dtank-types-turretHeading19> ^value <enemy-heading> )
	(write |aiming| )
}
#-------------------------------------------------------------------------------
#define wander
#-------------------------------------------------------------------------------

sp {propose*initialize-wander
	(state <local> ^type state -^name)
	(<local> ^impasse no-change ^attribute operator)
	(<local> ^superstate <parent>)
	(<parent> ^top <top>)
	(<parent> ^operator <imp>)
	(<imp> ^name impasse*wanderps)
	-->
	(<local> ^operator <o> +)
	(<o> ^name initialize-wander)
	(<o> ^top <top>)
	(<o> ^parent <parent>)
}

sp {apply*initialize-wander
	(state <local> ^operator <o>)
	(<o> ^name initialize-wander ^top <top> ^parent <parent>)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<local> ^name wander)
	(<local> ^top <top>)
	(<local> ^parent <parent>)
}

#define the rules...
sp {propose*wander*turnUp
	(state <local> ^top <top> ^parent <parent> ^name wander)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<top> ^|tank.types.curDir| <dir>)
	(<dir> ^dir <dir20> 270 )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name turnUp)
	(<o> ^dir <dir>)
}
sp {apply*wander*turnUp
	(state <local> ^top <top> ^name wander ^operator <o>)
	(<o> ^name turnUp)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	(<o> ^dir <dir>)
	(<dir> ^dir <dir-dir>)
	-->
	(<dir> ^dir <dir-dir> -)
	(<dir> ^dir 0 )
	(<i2> ^|dtank.types.tankHeading| <dtank-types-tankHeading21>)
	(<dtank-types-tankHeading21> ^value <dir-dir> )
}
sp {propose*wander*turnRight
	(state <local> ^top <top> ^parent <parent> ^name wander)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<top> ^|tank.types.curDir| <dir>)
	(<dir> ^dir <dir22> 0 )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name turnRight)
	(<o> ^dir <dir>)
}
sp {apply*wander*turnRight
	(state <local> ^top <top> ^name wander ^operator <o>)
	(<o> ^name turnRight)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	(<o> ^dir <dir>)
	(<dir> ^dir <dir-dir>)
	-->
	(<dir> ^dir <dir-dir> -)
	(<dir> ^dir 90 )
	(<i2> ^|dtank.types.tankHeading| <dtank-types-tankHeading23>)
	(<dtank-types-tankHeading23> ^value <dir-dir> )
}
sp {propose*wander*turnLeft
	(state <local> ^top <top> ^parent <parent> ^name wander)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<top> ^|tank.types.curDir| <dir>)
	(<dir> ^dir <dir24> 180 )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name turnLeft)
	(<o> ^dir <dir>)
}
sp {apply*wander*turnLeft
	(state <local> ^top <top> ^name wander ^operator <o>)
	(<o> ^name turnLeft)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	(<o> ^dir <dir>)
	(<dir> ^dir <dir-dir>)
	-->
	(<dir> ^dir <dir-dir> -)
	(<dir> ^dir 270 )
	(<i2> ^|dtank.types.tankHeading| <dtank-types-tankHeading25>)
	(<dtank-types-tankHeading25> ^value <dir-dir> )
}
sp {propose*wander*turnDown
	(state <local> ^top <top> ^parent <parent> ^name wander)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<top> ^|tank.types.curDir| <dir>)
	(<dir> ^dir <dir26> 90 )
	-->
	(<local> ^operator <o> + =)
	(<o> ^name turnDown)
	(<o> ^dir <dir>)
}
sp {apply*wander*turnDown
	(state <local> ^top <top> ^name wander ^operator <o>)
	(<o> ^name turnDown)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	(<o> ^dir <dir>)
	(<dir> ^dir <dir-dir>)
	-->
	(<dir> ^dir <dir-dir> -)
	(<dir> ^dir 180 )
	(<i2> ^|dtank.types.tankHeading| <dtank-types-tankHeading27>)
	(<dtank-types-tankHeading27> ^value <dir-dir> )
}
sp {propose*wander*move
	(state <local> ^top <top> ^parent <parent> ^name wander)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.me| <dtank-types-me28>)
	(<dtank-types-me28> ^x <x28>)
	(<dtank-types-me28> ^tankHeading <tankHeading29>)
	(<dtank-types-me28> ^speedMPS <speedMPS30>)
	(<dtank-types-me28> ^y <y31>)
	(<dtank-types-me28> ^throttle <throttle32>)
	(<dtank-types-me28> ^ammunition <ammunition33>)
	(<dtank-types-me28> ^turretHeading <turretHeading34>)
	(<dtank-types-me28> ^nationality <nationality35>)
	(<dtank-types-me28> ^fuel <fuel36>)
	(<dtank-types-me28> ^armor <armor37>)
	(<dtank-types-me28> ^speedKPH <speedKPH38>)
	-->
	(<local> ^operator <o> + =)
	(<o> ^name move)
}
sp {apply*wander*move
	(state <local> ^top <top> ^name wander ^operator <o>)
	(<o> ^name move)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<i2> ^|dtank.types.throttle| <dtank-types-throttle39>)
	(<dtank-types-throttle39> ^value 1.0 )
	(write |moving| )
}
sp {propose*wander*scan
	(state <local> ^top <top> ^parent <parent> ^name wander)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.me| <dtank-types-me40>)
	(<dtank-types-me40> ^x <x40>)
	(<dtank-types-me40> ^tankHeading <tankHeading41>)
	(<dtank-types-me40> ^speedMPS <speedMPS42>)
	(<dtank-types-me40> ^y <y43>)
	(<dtank-types-me40> ^throttle <throttle44>)
	(<dtank-types-me40> ^ammunition <ammunition45>)
	(<dtank-types-me40> ^turretHeading <turretHeading46>)
	(<dtank-types-me40> ^nationality <nationality47>)
	(<dtank-types-me40> ^fuel <fuel48>)
	(<dtank-types-me40> ^armor <armor49>)
	(<dtank-types-me40> ^speedKPH <speedKPH50>)
	-->
	(<local> ^operator <o> + =)
	(<o> ^name scan)
}
sp {apply*wander*scan
	(state <local> ^top <top> ^name wander ^operator <o>)
	(<o> ^name scan)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<i2> ^|dtank.types.turretHeading| <dtank-types-turretHeading51>)
	(<dtank-types-turretHeading51> ^value (exec rand |0,90,180,270,|) )
	(write |scanning| )
}
#-------------------------------------------------------------------------------
#define retreat
#-------------------------------------------------------------------------------

sp {propose*initialize-retreat
	(state <local> ^type state -^name)
	(<local> ^impasse no-change ^attribute operator)
	(<local> ^superstate <parent>)
	(<parent> ^top <top>)
	(<parent> ^operator <imp>)
	(<imp> ^name impasse*retreatps)
	-->
	(<local> ^operator <o> +)
	(<o> ^name initialize-retreat)
	(<o> ^top <top>)
	(<o> ^parent <parent>)
}

sp {apply*initialize-retreat
	(state <local> ^operator <o>)
	(<o> ^name initialize-retreat ^top <top> ^parent <parent>)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<local> ^name retreat)
	(<local> ^top <top>)
	(<local> ^parent <parent>)
}

#define the rules...
sp {propose*retreat*dodge
	(state <local> ^top <top> ^parent <parent> ^name retreat)
	(<top> ^io <i1>)
	(<i1> ^input-link <i2>)
	(<i2> ^|dtank.types.me| <dtank-types-me52>)
	(<dtank-types-me52> ^x <x52>)
	(<dtank-types-me52> ^tankHeading <tankHeading53>)
	(<dtank-types-me52> ^speedMPS <speedMPS54>)
	(<dtank-types-me52> ^y <y55>)
	(<dtank-types-me52> ^throttle <throttle56>)
	(<dtank-types-me52> ^ammunition <ammunition57>)
	(<dtank-types-me52> ^turretHeading <turretHeading58>)
	(<dtank-types-me52> ^nationality <nationality59>)
	(<dtank-types-me52> ^fuel <fuel60>)
	(<dtank-types-me52> ^armor <armor61>)
	(<dtank-types-me52> ^speedKPH <speedKPH62>)
	-->
	(<local> ^operator <o> + =)
	(<o> ^name dodge)
}
sp {apply*retreat*dodge
	(state <local> ^top <top> ^name retreat ^operator <o>)
	(<o> ^name dodge)
	(<top> ^io <i1>)
	(<i1> ^output-link <i2>)
	-->
	(<i2> ^|dtank.types.throttle| <dtank-types-throttle63>)
	(<dtank-types-throttle63> ^value (exec rand |1.0,-1.0,|) )
	(write |dodging| )
}