combo

// Combo file format and template

//RemapReloadButton("<button>");

//  Since the reload button is generally unused by combo weapons, allow

//   it to be remapped for the soldier.

//  <button> string param; values:

//   "Fire"   - Fire button

//   "FireSecondary" - Secondary fire button

//   "Jump"   - Jump button

//   "Sprint"  - Sprint button

//   "Crouch"  - Crouch button

//   "Reload", "None"- Don't remap the reload button

 RemapReloadButton("FireSecondary"); // remap to FireSecondary so we

                                     // can use the second trigger for our own purposes

//Animation("<animname>")

//{} scope OPTIONAL

//  Defines a combo animation by name to be used below.

//   Since combo animations have custom names, it is sometimes

//   necessary to define them ahead of time so that they can be

//   referenced later in the file.

//  <animname> string param; values: any, does not include a bank name

//   (i.e. without "human_sabre_") and may optionally exclude the

//   the animation scope ("_upper" or "_lower"), in which case both

//   animation scopes are affected.

//  [scope] contains animation data in the same format as the .sanm file.

//   If not present, this tag will simply act as a forward declaration.

 Animation("stand_attack1a_end");// forward declare "stand_attack1a_end_upper" 

                                 // and "stand_attack1_end_lower"

 Animation("stand_attack1a") // declare "stand_attack1a_upper"/"lower"

                             // with the following data:

     {

 //Loop([bLoop]);

 //  Set whether this anim loops; defaults to not looping.

 //  [bLoop] OPTIONAL numeric param; default 1; values: 0, 1

 //  Also may be "FinalFrame" to loop just the last frame.

 Loop();

 //  Set the aiming behavior of this anim; defaults to "None".

 //   NOTE: only used by "_upper" anim scope.

 //  <aimtype> string param; values:

 //   "None"  - body oriented in move direction

 //   "Head"  - body in move direction, head turned to aim

 //   "Torso"  - body in move direction, torso turned to aim

 //   "FullBody" - body in aim direction, override walk/run anims

 AimType("FullBody");

 //SyncType("<name>"[, "ByTime"]);

 //  Sets the sync class of this anim; defaults to no sync class.

 //   When transitioning between two anims in the same sync class,

 //   the new anim will frame sync to the old.

 //  <name> string param; values: any

 //  "ByTime" if specified, sync to same time as previous anim instead

 //   of to same ratio of anim length.

 SyncType("forward");

 //BlendInTime(<time>[, "Frames"|"Seconds"]);

 //  Sets the blend in time of this anim; defaults to 0.0.

 //  <time> numeric param; value in seconds [0.00 - 2.55]

 //  "Frames" specifies that time is in frames.

 BlendInTime(0.15);

 //BlendOutTime(<time>[, "Frames"|"Seconds"]);

 //  Sets the blend out time of this anim; defaults to 0.0.

 //  <time> numeric param; value in seconds [0.00 - 2.55]

 //  "Frames" specifies that time is in frames.

 BlendOutTime(0.15);

 //BlendTimeTo("<animname>", <time>[, "Frames"|"Seconds"]);

 //  Sets the specific blend time from this anim to another, by name.

 //   If no specific blend time exists, the blend time will be set

 //   to the minimum of this anim's BlendOutTime and the destination

 //   anim's BlendInTime.

 //  <animname> string param; values: previously defined animnames.

 //   All basic movement, action, and weapon animations are defined

 //   as well as any animations previously defined in this file with

 //   an Animation() tag.  Animation scope (i.e. "_upper") is ignored.

 //  <time> numeric param; value in seconds [0.00 - 2.55]

 //  "Frames" specifies that time is in frames.

 BlendTimeTo("stand_attack1a_end", 0.00);

 //LowResPose(<time>[, "Frames"|"Seconds"]);

 //  If specified, this animation will be reduced to a single pose

 //  generated from frame <time> when animating low res models.

 //  NOTE: currently this only applies to attack and block anims.

 //  <time> numeric param; value in seconds [0.00 - 2.55]

 //  "Frames" specifies that time is in frames.

 LowResPose(5, "Frames");

}

//State("<statename>")

//{} scope REQUIRED

//  Defines a state in the combo.

//  <statename> is used to reference this state elsewhere in the file.

//  NOTE: all combos must define an initial state called "IDLE"

State("ATTACK1")

{

 //RestartAnimation();  no parameters - tag to tell the system to restart the animation

 //   if coming in from the same one, rather than continuing it.

 RestartAnimation();

 //PlayExplosion();  no parameters - tag to tell the system to play the WeaponMelee's

 //   Explosion, if it has one set.

 PlayExplosion();

 //MustShowOneFrame(); will not exit this state to another without displaying at least

 //   one frame of the soldier's animation for it - which is enough

 //   to allow them to jump, etc, before transitioning.

 MustShowOneFrame();

 //Duration(<time>[, "FromAnim"|"Frames"|"Seconds"]);

 //  Sets the duration of this state; defaults to the anim duration.

 //  <time> numeric param; value in seconds by default [0.00-10.22]

 //   0.0 means infinite

 //  "FromAnim" if specified, duration is a percentage of anim duration.

 //  "Frames" if specified, duration is in frames (30ths of seconds).

 //  "Seconds" if specified, duration is in seconds.

 Duration(-1); // use anim duration

 //Animation("<animname>")

 //{} scope OPTIONAL

 //  Sets the animation associated with this state; defaults to no anim.

 //   Also defines a combo animation by name as above.

 Animation("stand_attack1a");

 //Sound("<soundname>" [, <time>][, "Frames"|"Seconds"]);

 //  Sets the sound played with this state; defaults to no sound.

 //  [time] numeric param; default 0.00; value in seconds: [0.00-10.23]

 //   Sets the time from the start of the state to play the sound.

 //  "Frames" specifies that the time value is in frames.

 Sound("imp_weap_lightsabre", 0.00);

 //AnimatedMove([set])

 //{} scope OPTIONAL

 //  If set, the animation will control the soldier's velocity for the

 //   duration of this state; defaults to false.

 //  [set] numeric param; default 1; values: 0, 1

 //  [scope] contains conditions to disable AnimatedMove

 AnimatedMove()

 {

  //VelocityZ(<velocity>[, "FromAnim"]);

  //  Sets the override z velocity for this animated move; defaults

  //   to the animation velocity (1.0, "FromAnim");

  //  <velocity> numeric param; value in meters per second;

  //   [-40.96-40.94]

  //  "FromAnim" if specified, interpret <velocity> as a multiplier

  //   to apply to the animation velocity.

  VelocityZ(1.0, "FromAnim");  // use animation velocity z

  //VelocityX(<velocity>[, "FromAnim"]);

  //  Sets the override x velocity for this animated move; defaults

  //   to the animation velocity (1.0, "FromAnim");

  //  <velocity> numeric param; value in meters per second;

  //   [-40.96-40.94]

  //  "FromAnim" if specified, interpret <velocity> as a multiplier

  //   to apply to the animation velocity.

  VelocityX(1.0, "FromAnim");  // use animation velocity x

  //VelocityFromThrust(<velocity>);

  //  Sets the thrust dependent (z) velocity for this animated move;

  //   defaults to 0.0.  Multiplied by input thrust (-1 - 1).

  //  <velocity> numeric param; value in meters per second;

  //   [0.00-12.75]

  VelocityFromThrust(0.0);

  //VelocityFromStrafe(<velocity>);

  //  Sets the strafe dependent (x) velocity for this animated move;

  //   defaults to 0.0.  Multiplied by input strafe (-1 - 1).

  //  <velocity> numeric param; value in meters per second;

  //   [0.00-12.75]

  VelocityFromStrafe(0.0);

  //Until/If/Or()

  //{} scope REQUIRED

  //  Defines a condition to break out of AnimatedMove.

  //   All conditions are forced to breaking conditions.

  //  See Transition::If/Or below for details.

  Until() // break out after 0.2 seconds if stick is moved

  {

   Break(0.2);

   Thrust(">", 0.5477);

  }

 }

 //AlignedToThrust([0|1|"Initial"]);

 //  Sets this state to align its aim and VelocityFromThrust direction

 //   to the input thrust direction; defaults to 0.

 //  [0|1] numeric or string param; default 1; values: 0, 1, "Initial"

 //   "Initial" causes this state to align to the initial thrust

 //    direction (i.e. the direction the thrust pointed in when

 //    entering this state).

 AlignedToThrust(0);

 //Gravity(<gravity>);

 //  Sets the gravity during this state in g's; default is 1.0.

 //  <gravity> numeric param; value [-12.7 - 12.7]

 Gravity(1.0);

 //GravityVelocityTarget(<velocity>[, "Impulse"][, "ZeroGravity"]);

 //  Sets a (Y) velocity condition on the Gravity setting; default

 //   is no condition.

 //  <velocity> numeric param; value [-204.7 - 204.7] meters per second.

 //  "Impulse" if specified, instantly accelerate to target velocity.

 //  "ZeroGravity" if specified, gravity resets to 0.0 instead of 1.0

 //   once the velocity condition is met.

 GravityVelocityTarget(0.0);

 //InputLock([<duration>[, "Frames"|"Seconds"]][, "<control>"][, ...]);

 //  Sets the combo to lock controls from going to the soldier in

 //   this state; defaults to none.

 //  [duration] OPTIONAL numeric param; default 0.0; value in seconds

 //   [0.00-10.23].  0.0 or negative means entire state duration.

 //  "Frames" specifies that the duration is in frames.

 //  [control] OPTIONAL string param; default "All"; values:

 //   "All", "Any" - All controls

 //   "Thrust"  - Thrust stick

 //   "Fire"   - Fire button

 //   "FireSecondary" - Secondary fire button

 //   "Jump"   - Jump button

 //   "Sprint"  - Sprint button

 //   "Crouch"  - Crouch button

 //   "Reload"  - Reload button

 //   "!<control>" - except a control

 //    i.e. InputLock(0.0, "All", "!Thrust", "!Sprint");

 //    locks all controls except Thrust and Sprint

 InputLock();   // lock all controls for duration of state

 //ThrustFactor(<factor>);

 //  Set a multiplier to apply to the thrust control while in this state;

 //   defaults to 1.0.  Note that while InputLock("Thrust") is active,

 //   the thrust factor will effectively be 0.0.

 //  <factor> numeric param; value [0.00-12.75]

 ThrustFactor(1.0);  // default thrust speed

 //StrafeFactor(<factor>);

 //  Set a multiplier to apply to the strafe control while in this state;

 //   defaults to 1.0.  Note that while InputLock("Thrust") is active,

 //   the strafe factor will effectively be 0.0.

 //  <factor> numeric param; value [0.00-12.75]

 StrafeFactor(1.0);  // default strafe speed

 //TurnFactor(<factor>);

 //  Set a multiplier to apply to the turn control while in this state;

 //   defaults to 1.0.

 //  <factor> numeric param; value [0.00-12.75]

 TurnFactor(1.0);  // default turn speed

 //PitchFactor(<factor>);

 //  Set a multiplier to apply to the pitch control while in this state;

 //   defaults to 1.0.

 //  <factor> numeric param; value [0.00-12.75]

 PitchFactor(1.0);  // default pitch speed

 //Posture("<posture>"[, "<posture>"][, ...]);

 //  Sets the soldier postures allowed in this state; defaults to "All"

 //   The soldier will be forced into one of the postures, if

 //   possible, and will abort to IDLE state if not.

 //  <posture> string param; values:

 //   "All", "Any" - All postures

 //   "Stand"   - soldier is standing

 //   "Crouch"  - soldier is crouching

 //   "Prone"   - soldier is prone

 //   "Sprint"  - soldier is sprinting

 //   "Jump"   - soldier is jumping

 //   "RollRight"  - soldier is rolling to the right

 //   "RollLeft"  - soldier is rolling to the left

 //   "Jet"   - soldier is jet jumping

 //   "Roll"   - synonym for "RollLeft","RollRight"

 //   "!<posture>" - except a posture

 Posture("Stand");  // must be standing

 //TurnOffLightsaber([weapon#][, weapon#][, ...]);

 //  Causes the lightsabers specified to be turned off while in this

 //   state.  Default is all sabers on.

 //  [weapon#] int param; values [0-3]; the weapon indices from the

 //   melee weapon odf of the lightsabers to turn off.

 //   If no [weapon#] are specified, all will be turned off.

 //TurnOffLightsaber(1); // turn off lightsaber 1

 //EnergyRestoreRate([rate][, "FromSoldier"]);

 //  Sets the soldier energy restore rate in this state; defaults to

 //   normal soldier energy restore rate in current posture

 //   (0.0, "FromSoldier").

 //  [rate] OPTIONAL numeric param; default 0.0, "FromSoldier";

 //   value in energy per second [-102.2-102.2], may be negative

 //  "FromSoldier" if specified, apply <rate> as an offset from the

 //   normal energy restore rate.  Otherwise, use <rate> as an

 //   absolute rate.

 EnergyRestoreRate(0.0); // do not restore energy while attacking

 //Attack()

 //{} scope OPTIONAL

 //  Define attack (damage) parameters for this state; default none.

 //   Multiple Attack's may be defined per state.

 //  [scope] contains data defining this attack; defaults to an attack

 //   with default parameters.

 Attack()

 {

  //AttackId(<id>);

  //  If two attacks within a short period of time share the same

  //   AttackId, only the first to apply damage to a character

  //   will do damage.  This is useful for splitting one attack

  //   across multiple states without potentially creating

  //   double damage.

  //  <id> string param; arbitrary value.

  AttackId("attack1");

  // Specify which edge this damage is attached to, if this

  //   character has multiple blades defined in their weapon odf;

  //   default is 0.

  //  <index> numeric param; value [0-<numedges-1>]

  Edge(0);

  //DamageTime(<time0>, <time1>[, "<option>"]);

  //  Sets the time range from the start of the state during which

  //   damage will be applied; defaults to 0.2-0.3 FromAnim.

  //  <time> numeric param; value in seconds by default

  //  [option] string param; values:

  //   "Seconds" - <time> is in seconds

  //   "Frames" - <time> is in frames (1/30ths of a second)

  //   "FromAnim" - <time> is fraction of state duration in

  //       the range [0.0-1.0]

  DamageTime(2, 5, "Frames"); // do damage from frame 2 to 5

  //Damage([damage]);

  //  Sets the damage inflicted by this attack; defaults to the value

  //   set in the weapon odf with "Damage" or "MaxDamage".

  //  <damage> numeric param; value in health units. [0-4094]

  //   or "Default" for weapon odf value.

  Damage(200);

  //Push(<strength>);

  //  Sets the push effect strength inflicted by this attack;

  //   defaults to 0.0.

  //  <strength> numeric param; value in meters per second [0.0-25.5].

  Push(0.0);

  //DamageLength(<length>[, "FromEdge"]);

  //  Sets the length of the ray used for applying damage;

  //   defaults to 1.0 FromEdge.

  //  <length> numeric param; value in meters by default [0.0-10.23]

  //  "FromEdge" if specified, the distance is a multiplier on the

  //   edge length specified in the weapon odf.

  DamageLength(1.0, "FromEdge");

  //DamageWidth(<width>,[, "FromEdge"]);

  //  Sets the width of the ray used for applying damage;

  //   defaults to 1.0 FromEdge.

  //  <length> numeric param; value in meters by default [0.0-2.55]

  //  "FromEdge" if specified, the distance is a multiplier on the

  //   edge width specified in the weapon odf.

  DamageWidth(1.0, "FromEdge");

 }

 //Deflect()

 //{} scope REQUIRED

 //  Enables ordnance deflection in this state; defauls to none.

 //   Only one Deflect may be defined per state, currently.

 //  [scope] contains deflection parameters.

 Deflect()

 {

  //DeflectAngle(<min>, <max>);

  //  Only attacks in directions within this angular range in the

  //   XZ plane can be deflected.  defaults to all directions.

  //  <min> numeric param; value in degrees [-180-180]

  //  <max> numeric param; value in degrees [-180-180]

  //EnergyCost(<energy>);

  //  Sets the energy cost per attack deflected; defaults to 0.0.

  //  <energy> numeric param; value in energy units [0.0-102.3]

  EnergyCost(0.0);

  //DeflectAnimation("<animname>"[, "<direction>"][, ...][, "Offhand"])

  //{} scope OPTIONAL

  //  Sets a deflection pose to use when an attack is deflected in

  //   a given approximate direction.  If multiple animations

  //   match an incoming attack's direction, one will be randomly

  //   selected.  If none match, the first anim will be used.

  //  <animname> as in Animation tags above.

  //  [direction] string param; values one or more of:

  //   "Forward", "Right", "BackRight",

  //   "Left", "BackLeft", "Back"

  //   "All"   - match any direction

  //   "!<direction>" - disable a direction, useful with "All"

  //  "Offhand" if specified, this is a lefthanded block - use the

  //   left hand or damage edges when attaching effects.  Note

  //   that if you have moved a right handed lightsaber to the

  //   left hand by moving hp_weapons, it still counts as right

  //   handed.

  //  [scope] as in Animation tags above.

  DeflectAnimation("stand_block_front1", "Forward");

  DeflectAnimation("stand_block_right1", "Right");

  DeflectAnimation("stand_block_left1", "Left");

 }

 //Transition("<statename>")

 //{} scope OPTIONAL

 //  Define a transition from this state to another by name;

 //   if no transitions are defined, defaults to an unconditional

 //   transition to IDLE at the end of this state's Duration.

 //   Multiple Transition's may be defined per state, in which case

 //   the final Transition is also considered to be an unconditional

 //   non-breaking transition if no other such transition is defined.

 //  <statename> string param; values: any statename defined elsewhere

 //   in this file by a State tag.

 //  [scope] contains data defining this transition; defaults to

 //   an unconditional transition to the given state at the end of

 //   this state's Duration.

 Transition("ATTACK2")

 {

  //EnergyCost(<energy>);

  //  Sets the energy cost of following this transition, which is

  //   effectively also a condition on the soldier energy to

  //   make this transition; default 0.0.

  //  <energy> numeric param; value in energy units.

  EnergyCost(0.0);

  //If/Or()

  //{} scope REQUIRED

  //  Defines a condition to be met in order to make this transition;

  //   default is unconditional, non-breaking transition.

  //   Multiple conditions may be defined per transition, in which

  //   case the transition will trigger if any of the conditions

  //   are met (hence the optional tag "Or").

  //  <scope> contains a set of conditions to be met; all conditions

  //   in the scope must be met to trigger this transition.

  If() // transition if...

  {

   //Break([time][, "Frames"|"Seconds"]);

   //  After [time] seconds, if the rest of this condition is

   //   met, the transition will break out of the current

   //   state immediately rather than waiting until the state

   //   Duration expires.

   //   NOTE: A TimeStart less than the Break time allows a

   //   breaking condition to depend on earlier button events.

   //   A Break time less than TimeStart won't break until

   //   TimeStart.

   //  [time] numeric param; default 0.0; value in seconds.

   //   [0.00 - 5.11].

   //   This condition will not break until [time] seconds

   //   have passed since the start of the state.

   //  "Frames" specifies that the time is in frames.

   //TimeStart(<time>[, "FromEnd"][, "Frames"|"Seconds"]);

   //  Set the time to start checking this condition; defaults to

   //   0.0, the start of the state.  The start time may be

   //   negative or before the start of the state, in which

   //   case button events still stored from the previous

   //   state may apply.  Button events are checked to see if

   //   they occurred in the time range defined.  Other

   //   conditions only check their current value, if the

   //   current time is in range.

   //  <time> numeric param; value in seconds [-5.12 - 5.11]

   //  "FromEnd" if specified, time is measured from the end

   //   of the current state's Duration.

   //  "Frames" specifies that the time is in frames.

   TimeStart(-1.0); // accept button hits up to 1 second before

   //TimeEnd(<time>[, "FromEnd"][, "Frames"|"Seconds"]);

   //  Set the time to stop checking this condition; defaults to

   //   0.0, FromEnd, the end of the state.  The end time may

   //   be after then end of the state, in which case, if the

   //   combo transitions unconditionally, it will continue

   //   checking the condition to retroactively take this

   //   transition.

   //  <time> numeric param; value in seconds [-5.12 - 5.11]

   //  "FromEnd" if specified, time is measured from the end

   //   of the current state's Duration.

   //  "Frames" specifies that the time is in frames.

   TimeEnd(0.15);  // keep checking this condition for 0.15

                   // seconds into RECOVER1

   //Button("<button>"[, "<action>"]);

   //  Set a button event condition to take this transition.

   //  <button> string param; values:

   //   "Fire"   - Fire button

   //   "FireSecondary" - Secondary fire button

   //   "Jump"   - Jump button

   //   "Sprint"  - Sprint button

   //   "Crouch"  - Crouch button

   //   "Reload"  - Reload button

   //   "FireBoth"  - Fire and FireSecondary together

   //  [action] string param; default "Tap"; values:

   //   "Tap"   - button pressed and released quickly

   //   "DoubleTap"  - button tapped twice quickly

   //   "Hold"   - button pressed, held, and released

   //   "Down"   - button down at any time (matches all

   //        other actions)

   Button("Fire");  // look for a tap on the fire button

   //ButtonsPressed("<button>"[, "<button>"][, ...]);

   //ButtonsReleased("<button>"[, "<button>"][, ...]);

   //  Set a condition on any of a number of buttons being

   //   pressed or released.  This condition differs from

   //   Button in the following ways:

   //   It does not consume button events; this makes it

   //    possible to test a button but leave it in the

   //    queue to trigger a transition from the following

   //    state.

   //   It can test multiple buttons simultaneously.

   //   If both ButtonsPressed and ButtonsReleased conditions

   //    are present, they are evaluated collectively; i.e.

   //    if any button in the ButtonPressed list was

   //    pressed or any button in the ButtonReleased list

   //    was released, this part of the condition passes.

   //  <button> string param; values one or more of:

   //   "Fire"   - Fire button

   //   "FireSecondary" - Secondary fire button

   //   "Jump"   - Jump button

   //   "Sprint"  - Sprint button

   //   "Crouch"  - Crouch button

   //   "Reload"  - Reload button

   //   "All", "Any" - Any button

   //   "!<button>"  - Remove this button from the list;

   //         useful with "Any".

   ButtonsPressed("All", "!Reload"); // any button but reload was pressed

   ButtonsReleased("Fire");   // or fire was released

   //Posture("<posture>"[, "<posture>"][, ...]);

   //  Sets a soldier posture condition to take this transition.

   //  <posture> string param; values:

   //   "All", "Any" - All postures

   //   "Stand"   - soldier is standing

   //   "Crouch"  - soldier is crouching

   //   "Prone"   - soldier is prone

   //   "Sprint"  - soldier is sprinting

   //   "Jump"   - soldier is jumping

   //   "RollRight"  - soldier is rolling to the right

   //   "RollLeft"  - soldier is rolling to the left

   //   "Jet"   - soldier is jet jumping

   //   "Roll"   - synonym for "RollLeft","RollRight"

   //   "!<posture>" - except a posture

   Posture("Stand");

   //TimeInPosture(">"|"<", <time>[, "Frames"|"Seconds"]);

   //  Sets a soldier posture timer condition to make this

   //   transition. i.e. soldier in "Jump" posture for so

   //   many seconds.

   //  ">"|"<" if "<", condition is less than or equal to,

   //   otherwise, condition is greater than or equal to.

   //  <time> numeric param; value in seconds [0.00 - 20.47].

   //  "Frames" specifies that the time is in frames.

   TimeInPosture(">", 0.00); // same as no condition

   //Energy(">"|"<", <energy>);

   //  Sets a condition on the soldier energy required to make

   //   this transition.

   //  ">"|"<" if "<", condition is less than or equal to,

   //   otherwise, condition is greater than or equal to.

   //  <energy> numeric param; value in energy [0.0 - 102.3].

   Energy(">", 0.0);   // same as no condition

   //Thrust(">"|"<", <thrust>);

   //  Sets a condition on the input thrust magnitude.

   //  ">"|"<" if "<", condition is less than or equal to,

   //   otherwise, condition is greater than or equal to.

   //  <thrust> numeric param; value [0.00 - 1.00].

   Thrust(">", 0.00);   // same as no condition

   //ThrustAngle(<anglemin>, <anglemax>);

   //  Sets a condition on the input thrust angle in degrees,

   //   where 0, 360, or -360 is forward,

   //   90 or -270 is left, -90 or 270 is right, and

   //   180 or -180 is back.

   //  <anglemin> numeric param; value in degrees [-360 - 360]

   //  <anglemax> numeric param; value in degrees [-360 - 360]

   //   <anglemax> should be greater than <anglemin> or

   //   the condition will end up inverted.

   ThrustAngle(0, 0);   // same as no condition

   //VelocityXZ(">"|"<", <velocity>);

   //  Sets a condition on the soldier speed in the XZ direction.

   //  ">"|"<" if "<", condition is less than or equal to,

   //   otherwise, condition is greater than or equal to.

   //  <velocity> numeric param; value in meters per second

   //   [0.00 - 20.47].

   VelocityXZ(">", 0.00);  // same as no condition

   //VelocityXZAngle(<anglemin>, <anglemax>);

   //  Sets a condition on the soldier velocity angle in the XZ

   //   direction in degrees, where 0, 360, or -360 is

   //   forward, 90 or -270 is left, -90 or 270 is right, and

   //   180 or -180 is back.

   //  <anglemin> numeric param; value in degrees [-360 - 360]

   //  <anglemax> numeric param; value in degrees [-360 - 360]

   //   <anglemax> should be greater than <anglemin> or

   //   the condition will end up inverted.

   VelocityXZAngle(0, 0);  // same as no condition

   //VelocityYAbs(">"|"<", <velocity>);

   //  Sets a condition on the soldier speed in the Y direction.

   //  ">"|"<" if "<", condition is less than or equal to,

   //   otherwise, condition is greater than or equal to.

   //  <velocity> numeric param; value in meters per second

   //   [0.00 - 15.75].

   VelocityYAbs(">", 0.0);  // same as no condition

   //VelocityY(">"|"<", <velocity>);

   //  Sets a condition on the soldier velocity in the Y

   //   direction, i.e. including sign.

   //  ">"|"<" if "<", condition is less than or equal to,

   //   otherwise, condition is greater than or equal to.

   //  <velocity> numeric param; value in meters per second

   //   [-16.0 - 15.5].

   VelocityY(">", -16.0);  // same as no condition

  }

 }

}