- Unless otherwise specified, P1 is the player who is evaluating the 
trigger, and P2 is his opponent (usually the closest opponent when in 
team mode).
- Most triggers can be "retargeted" to parents or roots of helpers by 
specifying the target before the trigger name. For example,
trigger1 = parent, stateno = 1000
trigger2 = root, stateno = 2000
triggers if the parent of the current character is in state 1000, or if 
the root of the current character is in state 2000.


Alphabetical Trigger Index
--------------------------
-Alive
-Anim
-AnimElem
-AnimExist
-AnimTime
-BackEdgeBodyDist
-BackEdgeDist
-CanRecover
-Command
-Ctrl
-Facing
-FrontEdgeBodyDist
-FrontEdgeDist
-HitCount
-HitDefAttr
-HitFall
-HitOver
-HitShakeOver
-HitVel
-IsHelper
-Life
-Lose
-MatchOver
-MoveContact
-MoveGuarded
-MoveHit
-MoveType
-NumExplod
-NumHelper 
-NumProj
-NumProjID 
-P1Name
-P2BodyDist
-P2Dist
-P2Life
-P2MoveType
-P2Name
-P2StateNo
-P2StateType
-P3Name
-P4Name
-PalNo
-ParentDist
-Pos
-ProjContact
-ProjGuarded
-ProjHit
-Random
-RootDist
-SelfAnimExist
-StateNo
-StateType
-Time
-TimeMod
-Var
-Vel
-Win



------------------------------------------------------------
Alive
------------------------------------------------------------

Returns 1 if the player is still able to fight, 0 if the player has 
been KOed.

Format:
  alive = value1

Arguments:
  (oper)
    =, != (other operators not valid)
  value1 (boolean)
    Value to compare with.

Example:
  trigger1 = alive = 0
    Triggers if the player has been KOed.


------------------------------------------------------------
Anim
------------------------------------------------------------

Returns the current animation action number of the player.

Format:
  Anim (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Value to compare with.

Example:
  trigger1 = Anim = 200
    Triggers if the player is currently in action 200.


------------------------------------------------------------
AnimElem
------------------------------------------------------------

Gets the animation-time elapsed since the start of a specified element 
of the current animation action. Useful for synchronizing events to 
elements of an animation action.
(reminder: first element of an action is element 1, not 0)

Format:
  1.  AnimElem = value1
  2.  AnimElem = value1, (oper) value2

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Element number to check.
  value2 (int)
    Value of animation-time to compare with.

Details:
  Trigger in Format 1 is true if the player's animation is
  at the start of the element number specified by value1.
  In other words, if value1 is equal to n, it is true on the
  first game-tick of the nth element of the animation.
  Trigger in Format 2 compares the player's animation-time
  to t+value2, where t is time of the start of the element
  number specified by value1.
  If value1 is an invalid animation element, M.U.G.E.N may
  crash or behave strangely.  

Examples:
  trigger1 = AnimElem = 2
    True on the first game-tick that the player's animation
    is on element 2. Is equivalent to saying:
      trigger1 = AnimElem = 2, = 0

  trigger1 = AnimElem = 2, = 4
    True 4 game-ticks after the start of the player's
    second animation element.

  trigger1 = AnimElem = 2, >= 0
  trigger1 = AnimElem = 3, < 0
    True for the whole of the second element of the player's
    animation, assuming there is a third element. If a
    third element does not exist, the second line should
    read,
      trigger1 = AnimTime <= 0


------------------------------------------------------------
AnimExist
------------------------------------------------------------

Returns 1 if the specified animation action exists for the player.
The result of this trigger is undefined if the player has been placed 
in a custom state by a successful hit. In this situation, use 
SelfAnimExist.

Format:
  AnimExist (oper) value1

Arguments:
  (oper)
    =, != (other operators not valid)
  value1 (int)
    Value to compare with.

Example:
  trigger1 = AnimExist != 200
    Triggers if the player is missing action 200.


------------------------------------------------------------
AnimTime
------------------------------------------------------------

Gives the difference between the looptime of the current animation 
action and the player's animation-time. Useful for knowing when the end 
of the animation has been reached. 
(animation-time is the time in game-ticks that the player has spent 
within the current animation action)
The name may be confusing. Try to think of it as "time from the end of 
the animation".

Format:
  AnimTime (oper) value

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value (int)
    Value to compare with. Should be 0 or less.

Example:
  trigger1 = AnimTime = 0
    Triggers when the animation-time is equal to the animation
    action's looptime, ie. the end of the action has been
    reached.


------------------------------------------------------------
BackEdgeBodyDist
------------------------------------------------------------

BackEdgeBodyDist gives the distance from the back of the player, as 
determined by the end of his width bar, to the back edge of the screen.

Format:
  BackEdgeBodyDist (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare with.

Example:
  trigger1 = BackEdgeBodyDist < 30
    Triggers if the back of the player's width bar is within 30 pixels
    of the edge of the screen in back of him.


------------------------------------------------------------
BackEdgeDist
------------------------------------------------------------

BackEdgeDist gives the distance between the x-axis of the player and 
the edge of the screen behind of the player.

Format:
  BackEdgeDist (oper) value1


Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare with.

Example:
  trigger1 = BackEdgeBodyDist < 30
    Triggers if the x-axus of the player is within 30 pixels
    of the edge of the screen in back of him.


------------------------------------------------------------
CanRecover
------------------------------------------------------------

If the player is currently in a falling state, returns true if he is 
currently able to recover, and false if he is not currently able to 
recover. If the player is not currently falling, the output of this 
trigger is undefined. 

Format:
  CanRecover (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare with. 0 for false, or 1 for true.


------------------------------------------------------------
Command
------------------------------------------------------------

Triggers if the user has input the specified command.

Format:
  Command (oper) command_name

Arguments:
  (oper)
    =, != (other operators not valid)
  command_name (string)
    Name of the command. Commands are defined in the
    player's CMD file, and are case-sensitive.
    If the CMD has multiple commands with the same name,
    then any one of those commands will work.

Example:
  trigger1 = Command = fireball_motion
    True if the user inputs the command corresponding to the
    command name "fireball_motion".


------------------------------------------------------------
Ctrl
------------------------------------------------------------

Returns the control flag of p1.

Format:
  Ctrl (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare with. Either 0 or 1.

Example:
  trigger1 = Ctrl = 1
    Triggers if the player has control.


------------------------------------------------------------
Facing
------------------------------------------------------------

Returns 1 if the player is facing to the right, and –1 if the player is 
facing to the left.

Format:
  Facing (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value
    Value to compare with. Should be 1 or –1.

Example:
  Trigger = Facing = -1
    Triggers if the player is facing toward the left of the screen.


------------------------------------------------------------
FrontEdgeBodyDist
------------------------------------------------------------

FrontEdgeBodyDist gives the distance between the front of the player 
(as determined by the front edge of his width bar) and the edge of the 
screen.

Format:
  FrontEdgeBodyDist (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare with.

Example:
  trigger1 = FrontEdgeBodyDist < 30
    Triggers if the front of the player is within 30 pixels
    of the edge of the screen in front of him.


------------------------------------------------------------
FrontEdgeDist
------------------------------------------------------------

FrontEdgeDist gives the distance between the x-axis of the player and 
the edge of the screen in front of the player.

Format:
  FrontEdgeDist (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare with.

Example:
  trigger1 = FrontEdgeDist < 30
    Triggers if the x-axis of the player is within 30 pixels
    of the edge of the screen in front of him.


------------------------------------------------------------
HitCount
------------------------------------------------------------

Returns the number of hits the player's current attack move has dealt 
to opponent. This returns the number of hits since the start of the 
move, not the state. For example, if the player is in a multi-state 
attack move, this returns the number of hits since his first state in 
that attack.

Format:
  HitCount (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare with.

Example:
  trigger1 = HitCount > 8
    Triggers when more than 8 hits have been dealt to the
    opponent since the start of the player's attack move.


------------------------------------------------------------
HitDefAttr
------------------------------------------------------------

Gets the attribute parameter of the player's currently-active HitDef. 
If the player is not in an attack state, then the condition does not 
trigger.
Can be used for simple move-interrupts from weaker to stronger attacks 
in the CMD file.

Format:
  HitDefAttr (oper) value1, value2

Arguments:
  (oper)
    =, !=
  value1
    A string that has at least one of the letters "S", "C"
    and "A" for standing, crouching and aerial attacks
    respectively. For example, "SA" is for standing and
    aerial attacks.
  value2
    A set of 2-character strings, separated by commas.
    Each 2-character string must be of the form described:
    The first character is either "N" for "normal", "S" for
    "special", or "H" for "hyper". The second character must
    be either "A" for "attack" (a normal hit attack) or "T"
    for "throw". For example, "NA, ST" is for normal attacks
    and special throws.

    Assuming the attribute of the player's HitDef is in the
    form:
      arg1, arg2
    then the trigger condition is determined to be true only
    if arg1 is a subset of value1, AND arg2 is a subset of
    value2.

    See the "attr" parameter of the HitDef controller in
    Appendix B for details.

Example:
  trigger1 = A, HA
    Triggers when the player is in an attack state, where
    the current HitDef has the following attributes:
        1. is an aerial attack
    and 2. is a hyper (super) attack

  trigger1 = SC, NA, SA
    Triggers when the player is in an attack state, where
    the current HitDef has the following attributes:
        1. is either a standing or a crouching attack
    and 2. is either a normal attack or a special attack

------------------------------------------------------------
HitFall
------------------------------------------------------------

If the player is currently in a gethit state, returns the fall flag of 
the hit. The output of this trigger is undefined if the player is not 
in a gethit state. For an explanation of the fall flag, see the HitDef 
documentation.

Format:
  HitFall (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare with. Either 0 or 1.

Example:
  trigger1 = HitFall = 0
    Triggers if the hit did not put the player into a fall state. 


------------------------------------------------------------
HitOver
------------------------------------------------------------

If the player is in a gethit state, returns true when the hittime has 
expired, and false otherwise. For an explanation of hittime, see the 
HitDef documentation.

Format:
  HitOver (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare with. Either 0 or 1.

Example:
  trigger1 = HitOver = 1
    Triggers when the player's hittime has expired. 


------------------------------------------------------------
HitShakeOver
------------------------------------------------------------

If the player is in a gethit state, returns true if the hit shake (the 
period when he is shaking in place) has ended, and false otherwise. 

Format:
  HitShakeOver (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare with. Either 0 or 1.

Example:
  trigger1 = HitShakeOver = 0
    Triggers if the player is still shaking from the hit. 


------------------------------------------------------------
HitVel
------------------------------------------------------------

Gets the value of the velocity imparted to the player by a hit. 
You must specify the component that you want to check, eg.
"HitVel Y" to check the vertical velocity component.

Format:
  HitVel (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.
  
Details:
  A positive HitVel Y means that the player is moving upward on the 
  screen. A positive HitVel X means that the player is moving  
  backward. Note that the HitVel X trigger behaves in the opposite
  manner to the Vel X trigger.

Example:
  trigger1 = HitVel X > 0.5
    True when the player's gethit x-velocity is greater than 0.5
    pixels per tick.


------------------------------------------------------------
IsHelper
------------------------------------------------------------

This trigger takes an optional ID number as a suffix. If the ID number 
is omitted, IsHelper returns true if the player is a helper character, 
and false otherwise. If the ID number is included, then IsHelper 
returns true if the player is a helper character with the specified ID 
number, and false otherwise.

Format:
1.	IsHelper (oper) bvalue
2.	IsHelper(value1) (oper) bvalue 

Arguments:
  (oper)
    =, != (other operators not valid)
  value1
    Optional ID number.
  bvalue (boolean)
    Value to compare with. Either 0 or 1.
  
Examples:
  1. trigger1 = IsHelper = 0
    Triggers if the player is not a helper-type character.
  2. trigger1 = IsHelper1234 = 1
    Triggers if the player is a helper character with ID number 1234.


------------------------------------------------------------
Life
------------------------------------------------------------

Returns the player's life.

Format:
  Life (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare against. Typically 0-1000.

Example:
  trigger1 = life <= 10
    Triggers if the player has 10 or less life points remaining.  
    

------------------------------------------------------------
Lose
------------------------------------------------------------

Returns true if the player (or the player's team, in team mode) has 
lost the round, false otherwise. Can be suffixed with "KO" or "Time" to 
trigger only when the round has been lost by a KO or by time expiring, 
respectively.

Format:
  1. Lose (oper) value
  2. LoseKO (oper) value
  3. LoseTime (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare against. 0 for false, 1 for true.

Examples:
  1. trigger1 = Lose = 1
    Triggers if the player (or his team) has lost the round.
  2. trigger1 = LoseKO = 0
    Triggers if the player (or his team) has not lost the round by 
    a KO. For example, this will trigger if the player's team has
    not yet lost the round, or if they have lost the round by time
    over.


------------------------------------------------------------
MatchOver
------------------------------------------------------------

Returns true if the match has ended. (For example, in the case of a 
best-of-three match, this will return true when one of the players or 
teams has won two rounds.)

Format:
  MatchOver (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare against. 0 for false, 1 for true.

Details:
  Currently, MatchOver does not return true until the players start
  their win poses (state 180). This behavior may be subject to change
  in future releases.

Example:
  trigger1 = matchover = 1
    Triggers if the match is not over. For instance, the current round
    may not yet have ended, or it may have ended without deciding the
    match.


------------------------------------------------------------
MoveContact
------------------------------------------------------------

This trigger is valid only when the player is in an attack state.
MoveContact gives 1 if P2 has either been hit, or has guarded P1's 
attack. It gives 0 otherwise. P1 is the player, and P2 is his opponent.
Typically used with the "StateNo" and "Command" triggers for detecting 
move-interrupts in the CMD file.

Format:
  MoveContact (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare against. 0 for false, 1 for true.

Example:
  trigger1 = MoveContact = 1
    True if P1's attack did not miss P2.


------------------------------------------------------------
MoveGuarded
------------------------------------------------------------

This trigger is valid only when the player is in an attack state.
MoveGuarded gives 1 if P2 is guarding, or has guarded, P1's attack. It 
gives 0 if the attack missed or successfully hit. P1 is the player, and 
P2 is his opponent.
Typically used with the "StateNo" and "Command" triggers for detecting 
move-interrupts in the CMD file.

Format:
  MoveGuarded (oper) value1

Arguments:
  (oper)
    =, !=
  value1 (boolean)
    Either 0 or 1.

Example:
  trigger1 = MoveGuarded = 1
    True if P1's attack was blocked by P2.


------------------------------------------------------------
MoveHit
------------------------------------------------------------

This trigger is valid only when the player is in an attack state.
MoveHit gives 1 if P2 has been hit by P1's attack. It gives 0 if the 
attack missed or was guarded.
Typically used with the "StateNo" and "Command" triggers for detecting 
move-interrupts in the CMD file.

Format:
  MoveHit (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare against. 0 for false, 1 for true.

Example:
  trigger1 = MoveHit = 1
    True if P1's attack connected successfully with P2.


------------------------------------------------------------
MoveType
------------------------------------------------------------

MoveType gives the player's move-type. Refer to the section
on StateDef in the CNS documentation for more details on MoveType.
Useful for "move interrupts" in the CMD file.

Format:
  MoveType (oper) move_type

Arguments:
  (oper)
    =, !=   (other operators not valid)
  move_type (char)
    A, I, H
    Attack, Idle and GetHit move-types.

Example:
  trigger1 = movetype != H
    Triggers if the player is not currently in a gethit-type state.


------------------------------------------------------------
NumExplod
------------------------------------------------------------

This trigger takes an optional ID number as a suffix. If the ID number 
is omitted, NumExplod returns the number of explods owned by the 
player. If the ID number is included, then NumExplod returns the number 
of explods with that ID number that are owned by the player.

Format:
  1. NumExplod (oper) value1
  2. NumExplod(ID) (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  (ID)
    Optional nonzero ID number.
  value1
    Value to compare against.

Examples:
  1. trigger1 = NumExplod >= 4
    Triggers if the player currently owns 4 or more explods.
  2. trigger1 = NumExplod1234 >= 4
    Triggers if the player currently owns 4 or more explods with ID
    1234.


------------------------------------------------------------
NumHelper
------------------------------------------------------------

This trigger takes an optional ID number as a suffix. If the ID number 
is omitted, then NumHelper returns the total number of helpers 
currently owned by the player. If the ID number is included, then 
NumHelper returns the total number of helpers with that ID number owned 
by the parent.

Format:
  1. NumHelper (oper) value1
  2. NumHelper(ID) (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  (ID)
    Optional nonzero ID number.
  value1
    Value to compare against.

Examples:
  1. trigger1 = NumHelper < 2
    Triggers if the player now has less than 2 helpers.
  2. trigger1 = NumHelper1234 < 2
    Triggers if the player now has less than 2 helpers with ID 1234.


------------------------------------------------------------
NumProj
------------------------------------------------------------

Returns the total number of projectiles currently owned by the player.

Format:
  NumProj (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare against.

Example:
  trigger1 = NumProj = 0
    Triggers if the player has no currently active projectiles.


------------------------------------------------------------
NumProjID
------------------------------------------------------------

This trigger takes an ID number as a required suffix. It returns the 
number of projectiles currently owned by the player and having the 
specified ID number.

Format:
  NumProjID(number) (oper) value1

Arguments:
  (number)
    Required ID number.
  (oper)
    =, !=, <, >, <=, >=
  value1
    Value to compare against.

Example:
  trigger1 = NumProjID1234 = 1
    Triggers if there the player currently owns exactly 1 projectile
    with the ID number 1234.


------------------------------------------------------------
P1Name
------------------------------------------------------------

Returns the player's name (the internal name specified in the .DEF 
file, which may not be the same as the displayed name).

Format:
  P1Name (oper) name

Arguments:
  (oper)
    =, != (other operators not valid)
  name (string)
    Name to compare against.

Example:
  trigger1 = P1Name = Kumquat
    Returns true if the player is named "Kumquat". 


------------------------------------------------------------
P2BodyDist
------------------------------------------------------------

Gives the distance of P2 from P1, where P1 is the player, and P2 is his 
opponent. P2BodyDist is useful in the CMD for cases where P1 has an 
attack that is different when performed close to P2.

Format:
   P2BodyDist (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.

Details:
  For comparing the Y-distance, P2BodyDist gives the difference in the
  heights of the players' Y-axes. A negative value means that P2 is
  above P1.  
  For comparing the X-distance, P2BodyDist gives the
  X-distance of P2's front from P1's front. So, if the
  players are standing right next to each other, then
  P2BodyDist is 0. Remember that you can set the width of
  the player in "front.width", etc. under [Size] in the
  player variables.
  See also P2Dist.

Example:
  trigger1 = P2BodyDist X < 30
    Triggers if the front of P2 is within 30 pixels of the front of
    P1.  

------------------------------------------------------------
P2Dist
------------------------------------------------------------

Gives the distance of P2 from P1, where P1 is the player, and P2 is his 
opponent.

Format:
  P2Dist (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.

Details:
  For comparing the Y-distance, P2Dist gives the difference in the
  heights of the players' Y-axes. A negative value means that P2 is
  above P1.  
  For comparing the X-distance, P2Dist gives the X-distance
  of P2's axis from P1's axis. A positive value indicates P2
  is in front of P1.
  See also P2BodyDist.

Example:
  trigger1 = P2Dist Y <= -12
    True if P2 is at least 12 pixels higher up than P1.


------------------------------------------------------------
P2Life
------------------------------------------------------------

Same as Life, except that this returns the opponent's life.


------------------------------------------------------------
P2MoveType
------------------------------------------------------------

Same as MoveType, except that this returns the opponent's movetype.


------------------------------------------------------------
P2Name
------------------------------------------------------------

Same as P1Name, except that this returns the name of the primary 
opponent (the opponent in versus mode, or the first opponent in team 
mode).


------------------------------------------------------------
P2StateNo
------------------------------------------------------------

Same as StateNo, except that this returns the opponent's state number.


------------------------------------------------------------
P2StateType
------------------------------------------------------------

Same as StateType, except that this returns the opponent's state type.


------------------------------------------------------------
P3Name
------------------------------------------------------------

Same as P1Name, except that this returns the name of the player's 
teammate, if present (if not present, this will never trigger).


------------------------------------------------------------
P4Name
------------------------------------------------------------

Same as P1Name, except that this returns the name of the secondary 
opponent, if present (if not present, this will never trigger).


------------------------------------------------------------
PalNo
------------------------------------------------------------

Returns the palette number of the player (i.e., the color scheme chosen 
for the character during character select.) 

Format:
  PalNo (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Numerical value to compare against (1-12).

Details:
  The palette ordering is:
  X Y Z
  4 5 6
  A B C
  1 2 3
  Holding start while selecting will add 6 to the palette number.

Example:
  trigger1 = PalNo = 5
    Returns true if the current palette number is 5.


------------------------------------------------------------
ParentDist
------------------------------------------------------------

This trigger is only valid for helper-type characters.
ParentDist returns the distance from the helper to its parent. It works 
similarly to P2Dist.

Format:
  ParentDist (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.

Details:
  For comparing the Y-distance, ParentDist gives the difference in the
  heights of the players' Y-axes. A negative value means that the
  parent is above its child.  
  For comparing the X-distance, ParentDist gives the X-distance
  of the parent's axis from the child's axis. A positive value
  indicates the parent is in front of the child.

Example:
  trigger1 = ParentDist X != 0
    Triggers if the parent is not at the exact same x-position as the
    helper character.


------------------------------------------------------------
Pos
------------------------------------------------------------

Gets the value of the player's position. You must specify the component 
that you want to check, eg. "Pos Y" to check the Y-position.

Format:
  Pos (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.

Details:
  For "Pos X", the value is relative to the center of the
  screen (value 0). Negative is left, positive is right.
  For "Pos Y", the value is relative to the floor. Negative
  is higher up, positive is below the floor.

Example:
  trigger1 = Pos Y >= 0
    True when the player is below the floor.


------------------------------------------------------------
Power
------------------------------------------------------------

Returns the amount of power the player has.

Format:
  Power (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Numerical value to compare with.

Example:
  trigger1 = power >= 1000
    True if player has at least 1000 power (level 1).


------------------------------------------------------------
ProjContact
------------------------------------------------------------

This trigger takes an optional ID number as a suffix. If the ID number 
is omitted, ProjContact returns true if any of the player's projectiles 
either successfully hit the opponent or were guarded by the opponent. 
When the ID number is specified, ProjContact returns true only if any 
of the player's projectiles with the specified ID number either 
successfully hit the opponent or was guarded.

Format:
  1. ProjContact(ID) = value
  2. ProjContact(ID) = value, (oper) value2

Arguments:
  (ID)
    Optional ID number.
  value (boolean)
    Value to compare against. 0 for false, 1 for true.
  (oper)
    =, !=, <, >, <=, >=
  value2
    Time value to compare against.

Details:
  ProjContact will trigger once for each hit of the projectile, so a
  multi-hit projectile can trigger multiple times. 
  The first form of ProjContact shown above is only valid for one tick
  after contact, unlike MoveContact. 
  For the second form, ProjContact returns true if the projectile made 
  contact n ticks ago, where n is a nonnegative number satisfying the 
  relation "n (oper) value2".

Examples:
  1. trigger1 = ProjContact1234 = 1
    Triggers if a projectile with ID 1234 just made contact with the 
    opponent.
  2. trigger1 = ProjContact456 = 0, < 15
    Triggers if no projectile with ID 456 made contact in the last 15 
    ticks.


------------------------------------------------------------
ProjGuarded
------------------------------------------------------------

This trigger takes an optional ID number as a suffix. If the ID number 
is omitted, ProjGuarded returns true if any of the player's projectiles 
were guarded by the opponent. When the ID number is specified, 
ProjGuarded returns true only if one of the player's projectiles with 
the specified ID number was guarded by the opponent.

Format:
  1. ProjGuarded(ID) = value
  2. ProjGuarded(ID) = value, (oper) value2

Arguments:
  (ID)
    Optional ID number.
  value (boolean)
    Value to compare against. 0 for false, 1 for true.
  (oper)
    =, !=, <, >, <=, >=
  value2
    Time value to compare against.

Details:
  ProjGuarded will trigger once for each hit of the projectile, so a
  multi-hit projectile can trigger multiple times. 
  The first form of ProjGuarded shown above is only valid for one tick
  after hit, unlike MoveGuarded. 
  For the second form, ProjGuarded returns true if the projectile was 
  guarded n ticks ago, where n is a nonnegative number satisfying the 
  relation "n (oper) value2".

Examples:
  1. trigger1 = ProjGuarded1234 = 1
    Triggers if the opponent just blocked a projectile with ID 1234. 
  2. trigger1 = ProjGuarded = 1, < 15
    Triggers if the opponent blocked any projectile in the last 15 
    ticks.
 

------------------------------------------------------------
ProjHit
------------------------------------------------------------

This trigger takes an optional positive ID number as a suffix. If the 
ID number is omitted, ProjHit returns true if any of the player's 
projectiles successfully hit the opponent. When the ID number is 
specified, ProjHit returns true only if one of the player's projectiles 
with the specified ID number successfully hit the opponent.

Format:
  1. ProjHit(ID) = value
  2. ProjHit(ID) = value, (oper) value2

Arguments:
  (ID)
    Optional ID number.
  value (boolean)
    Value to compare against. 0 for false, 1 for true.
  (oper)
    =, !=, <, >, <=, >=
  value2
    Time value to compare against.

Details:
  ProjHit will trigger once for each hit of the projectile, so a
  multi-hit projectile can trigger multiple times. 
  The first form of ProjHit shown above is only valid for one tick
  after hit, unlike MoveHit. 
  For the second form, ProjHit returns true if the projectile hit
  n ticks ago, where n is a nonnegative number satisfying the relation 
  "n (oper) value2".

Examples:
  1. trigger1 = ProjHit1234 = 1
    Triggers if a projectile with ID 1234 just made successful 
    contact with the opponent. 
  2. trigger1 = ProjHit1234 = 1, < 15
    Triggers if any of the player's projectiles made successful 
    contact with the opponent within the last 15 ticks.


------------------------------------------------------------
Random
------------------------------------------------------------

Returns a random number between 0 and 999, inclusive.

Format:
  Random (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Numerical value to compare against (0-999).

Example:
  trigger1 = Random <= 249
    Triggers if the random number returned is less than or equal to 
    249. (This occurs with 25% probability.)
    

------------------------------------------------------------
RootDist
------------------------------------------------------------

This trigger is only valid for helper-type characters.
RootDist returns the distance from the helper to its root. The root is 
the main player character who owns the helper: for instance, if you 
select Kumquat to play with, and Kumquat spawns a helper named Kiwi, 
who in turn spawns a helper named Penguin, then Penguin's root is 
Kumquat, and Penguin is a descendant of Kumquat. RootDist works 
similarly to P2Dist.

Format:
  RootDist (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.

Details:
  For comparing the Y-distance, RootDist gives the difference in the
  heights of the players' Y-axes. A negative value means that the
  root is above its descendant.  
  For comparing the X-distance, ParentDist gives the X-distance
  of the root's axis from the descendant's axis. A positive value
  indicates the root is in front of its descendant.

Example:
  trigger1 = RootDist X != 0
    Triggers if the root is not at the exact same x-position as the
    helper character.


------------------------------------------------------------
SelfAnimExist
------------------------------------------------------------

Like AnimExist, except that this only checks P1's animation data. If P1 
has been given P2's animation data by a hit, SelfAnimExist will not 
check P2's animation data to determine whether or not a given action 
exists.


------------------------------------------------------------
StateNo
------------------------------------------------------------

Returns the player's current state number. Useful for "move interrupts" 
in the CMD file.

Format:
  StateNo (oper) value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Numerical value to compare with.

Example:
  trigger1 = stateno = [200,650]
    Returns true if the state number is between 200 and 650, 
    inclusive.


------------------------------------------------------------
StateType
------------------------------------------------------------

StateType gives the player's state-type. Refer to the section
on StateDef in the CNS documentation for more details on StateType.
Useful for "move interrupts" in the CMD file.

Format:
  StateType (oper) state_type

Arguments:
  (oper)
    =, !=   (other operators not valid)
  state_type (char)
    S, C, A
    Stand, Crouch and Air state-types.

Example:
  trigger1 = StateType != A
    Triggers if the player is not in an air-type state.


------------------------------------------------------------
Time
------------------------------------------------------------

Gives the state-time of the player.

Format:
  Time (oper) value

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  value (int)
    Value to compare with.

Example:
  trigger1 = Time = 2
    Triggers when the player's state-time is 2.


------------------------------------------------------------
TimeMod
------------------------------------------------------------

Returns the remainder when the state-time of the player is divided by 
the specified value.

Format:
  TimeMod (oper) divisor, value1

Arguments:
  (oper)
    =, !=, <, >, <=, >=
  divisor (int)
    Positive number to use as a divisor.
  value1 (int)
    Value to compare remainder against.

Example:
  trigger1 = TimeMod = 4, 3
    Triggers when the state-time is 3, 7, 11, 15, ...
  

------------------------------------------------------------
Var
------------------------------------------------------------

This trigger takes a mandatory variable number as a suffix. It returns 
the value of the specified variable.

Format:
  Var(no) (oper) value1

Arguments:
  (no)
    Mandatory variable number. Valid numbers at the time of this 
    writing are 0-31.
  (oper)
    =, !=, <, >, <=, >=
  value1 (int)
    Value to compare against.

Example:
  trigger1 = Var0 = -34
    Triggers if the value of variable 0 is -34.


------------------------------------------------------------
Vel
------------------------------------------------------------

Gets the value of the player's velocity. You must specify the component 
that you want to check, eg. "Vel Y" to check the Y-velocity.

Format:
  Vel (component) (oper) valuef1

Arguments:
  (component)
    X, Y
  (oper)
    =, !=, <, >, <=, >=
  valuef1 (decimal)
    The value to compare with.

Details:
  For Vel X, a positive value indicates that the player is moving 
  forward. (This behavior is the opposite of HitVel X's behavior.) For 
  Vel Y, a positive value indicates that the player is moving 
  downward.

Example:
  trigger1 = Vel Y >= 0
    True when the player is not moving upward.


------------------------------------------------------------
Win
------------------------------------------------------------

Returns true if the player (or the player's team, in team mode) has won 
the round, false otherwise. Can be suffixed with "KO" or "Time" to 
trigger only when the round has been won by a KO or by time expiring, 
respectively.

Format:
  1. Win (oper) value
  2. WinKO (oper) value
  3. WinTime (oper) value

Arguments:
  (oper)
    =, != (other operators not valid)
  value (boolean)
    Value to compare against. 0 for false, 1 for true.

Examples:
  1. trigger1 = Win = 1
    Triggers if the player (or his team) has won the round.
  2. trigger1 = WinKO = 0
    Triggers if the player (or his team) has not won the round by 
    a KO. For example, this will trigger if the player's team has
    not yet won the round, or if they have won the round by time
    over.

