Creates a projectile for the player.

The Projectile controller takes all the parameters of the HitDef controller, which control the HitDef for the projectile.This defines a single hit of the projectile's attack. If the projectile's Clsn1 box (red) comes in contact with his opponent's Clsn2 box (blue), and the HitDef was define on or before that particular point in time, then the specified effect will be applied. A single HitDef is valid only for a single hit. To make a move hit several times, you must trigger more than one HitDef during the attack.

Required parameters:

- attr = hit_attribute (string)
  This is the attribute of the attack. It is used to determine if the attack can hit P2. It has the format:
  attr = arg1, arg2
  Where:
  - arg1 is either "S", "C" or "A". Similar to "statetype" for the StateDef, this says whether the attack is a standing, crouching, or aerial attack.
  - arg2 is a 2-character string. The first character is either "N" for "normal", "S" for "special", or "H" for "hyper" (or "super", as it is commonly known). The second character must be either "A" for "attack" (a normal hit attack), "T" for "throw", or "P" for projectile.
- hitflag = hit_flags (string)
  This determines what type of state P2 must be in for P1 to hit. hit_flags is a string containing a combination of the following characters:
  "H" for "high", "L" for "low" or "A" for air. "M" (mid) is equivalent to saying "HL". "F" is for fall, and if included will allow P1 to juggle falling opponents in the air. "D" is for "lying Down", and if included allows P1 to hit opponents lying down on the ground.
  Two optional characters are "+" and "-". If "+" is added, then the hit only affects people in a gethit state. This may be useful for chain-moves that should not affect opponents who were not hit by the first move in the chain attack. If "-" is added, then the hit only affects players that are NOT in a gethit state. You should use "-" for throws and other moves you do not want P1 to be able to combo into. "+" and "-" are mutually exclusive, ie. cannot be used at the same time.
  If omitted, this defaults to "MAF".
- guardflag = hit_flags (string)
  This determines how P2 may guard the attack. hit_flags is a string containing a combination of the following characters:
  "H" for "high", "L" for "low" or "A" for air. "M" (mid) is equivalent to saying "HL".

Optional parameters:

- ProjID = id_no (int)
  Specifies an ID number to refer to this projectile by. Should be positive, if specified.
- projanim = anim_no (int)
  Specifies the animation action number to use for the projectile's animation. Defaults to 0 if omitted.
- projhitanim = anim_no (int)
  Specifies the animation action number to play when the projectile hits the opponent. Defaults to -1 (no change in animation) if omitted.
- projremanim = anim_no (int)
  Specifies the animation action number to play when the projectile is removed (due to its time expiring or hitting the its removal boundaries, etc.) If omitted, projhitanim is used instead.
- projcancelanim = anim_no (int)
  Specifies the animation action number to play when the projectile is cancelled by hitting another projectile. If omitted, projremanim is used instead.
- projscale = x_scale, y_scale (float, float)
  Specifies the scale factor of the projectile. The final scale of the projectile is affected by both this parameter and the "proj.doscale" parameter in the [Size] group of p1's constants file. Defaults to 1,1 (normal size) if omitted.
- projremove = remove_flag (boolean)
  Set to a non-zero value to have the projectile be removed after it hits, or to 0 to disable this behavior. Defaults to 1.
- projremovetime = remove_time (int)
  Specifies the number of ticks after which the projectile should be removed from the screen. If -1, the projectile will not be removed. Defaults to -1.
- velocity = x_vel, y_vel (float, float)
  Specifies the initial x and y velocities for the projectile to travel at. Defaults to 0,0 if omitted.
- remvelocity = x_vel, y_vel (float, float)
  Specifies the x and y velocities at which the projectile should travel while being removed. Defaults to 0,0 if omitted.
- accel = x_accel, y_accel (float, float)
  Specifies the acceleration to apply to the projectile in the x and y directions. Defaults to 0,0 if omitted.
- velmul = x_mul, y_mul (float, float)
  Specifies x and y velocity multipliers. The projectile's velocity is multiplied by these multipliers on every tick. The multipliers default to 1 if omitted.
- projhits = num_hits (int)
  Specifies the number of hits that the projectile can impart on an opponent before it is removed. Defaults to 1.
- projmisstime = miss_time (int)
  If the projectile is configured for multiple hits, miss_time specifies the number of ticks after each hit before the projectile can hit again. Defaults to 0.
- projpriority = proj_priority (int)
  Specifies the projectile priority. If the projectile collides with another projectile of equal priority, they will cancel. If it collides with another of lower priority, it will cancel the lower- priority projectile, and the higher-priority one will have its priority decreased by 1. Defaults to 1.
- projsprpriority = priority (int)
  Specifies the sprite priority of the projectile. Higher-priority sprites are drawn on top of lower-priority sprites. Defaults to 3.
- projedgebound = value (int)
  Specifies the distance off the edge of the screen before the projectile is automatically removed. Units are in pixels. Defaults to 40 in 240p, 80 in 480p, 160 in 720p.
- projstagebound = value (int)
  Specifies the greatest distance the projectile can travel off the edge of the stage before being it is automatically removed. Defaults to 40 in 240p, 80 in 480p, 160 in 720p.
- projheightbound = lowbound, highbound (int, int)
  Specifies the least and greatest y values the projectile is allowed to reach. If the projectile leaves these boundaries, it is automatically removed. Note: since y values decrease with increasing height on the screen, lowbound actually specifies the greatest height the projectile can attain. lowbound defaults to -240 in 240p, -480 in 480p, -960 in 720p. highbound defaults to 1 in 240p, 2 in 480p, 4 in 720p.
- offset = off_x, off_y (int, int)
  Specifies the x and y offsets at which the projectile should be created. Both parameters default to 0 if omitted. Projectiles are always created facing the same direction as the player. off_x is in relation to the direction the projectile is facing. The exact behavior of the offset parameters is dependent on the postype.
- postype = postype_string (string)
  postype_string specifies the postype -- how to interpret the pos parameters. In all cases, a positive y offset means a downward displacement. In all cases, off_y is relative to the position of the player. Valid values for postype_string are the following:
  - p1 - Interprets offset relative to p1's axis. A positive off_x is toward the front of p1. This is the default value for postype.
  - p2 - Interprets offset relative to p2's axis. A positive off_x is toward the front of p1. If p2 does not exist, the position is calculated with respect to p1 and a warning is logged.
  - front - Interprets off_x relative to the edge of the screen that p1 is facing toward. A positive off_x is toward the front of p1.
  - back - Interprets off_x relative to the edge of the screen that p1 is facing away from. A positive off_x is toward the front of p1.
  - left - Interprets off_x relative to the left edge of the screen. A positive off_x is toward the front of p1.
  - right - Interprets off_x relative to the right edge of the screen. A positive off_x is toward the front of p1.
- projshadow = shadow (int)
  If shadow is not 0, a shadow will be drawn for the explod, else no shadow will be drawn. Defaults to 0.
- supermovetime = move_time (int)
  Specifies the number of ticks that the projectile will be unfrozen during a SuperPause. Defaults to 0.
- pausemovetime = move_time (int)
  Specifies the number of ticks that the projectile will be unfrozen during a Pause. Defaults to 0.
- ownpal = ownpal_flag (boolean)
  If ownpal_flag is 0, the projectile will be affected by subsequent execution of its owner's PalFX and RemapPal controllers. This is the default.
  If ownpal_flag is 1, the projectile will not be affected by its owner's PalFX and RemapPal controllers.
- remappal = dst_pal_grp, dst_pal_item (int, int)
  Forces a palette remap of the projectile's indexed-color sprites to the specified palette. This parameter is used only if ownpal_flag is non-zero. If dst_pal_grp is -1, this parameter will be ignored. Defaults to -1, 0.
- affectteam = team_type (string)
  team_type specifies which team's players can be hit by this HitDef. Use B for both teams (all players), E for enemy team (opponents), or F for friendly team (your own team). The default is E.
- animtype = anim_type (string)
  This refers to the type of animation that P2 will go into when hit by the attack. Choose from "light", "medium", "hard", "back", "up", or "diagup".
  The first three should be self-explanatory. "Back" is the animation where P2 is knocked off her feet. "Up" should be used when the character is knocked straight up in the air (for instance, by an uppercut), and "DiagUp" should be used when the character is knocked up and backwards in the air, eventually landing on his head. The default is "Light".
- air.animtype = anim_type (string)
  Similar to the "animtype" parameter, this is the animtype to set P2 to if P2 is in the air, instead of on the ground. Defaults to the same value as the "animtype" parameter if omitted.
- fall.animtype = anim_type (string)
  Similar to the "animtype" parameter, this is the animtype to set P2 to if P2 is hit while falling. Defaults to Up if air.animtype is Up, or Back otherwise.
- priority = hit_prior (int), hit_type (string)
  Specifies the priority for this hit. Hits with higher priorities take precedence over hits with lower priorities. Valid values for hit_prior are 1-7. Defaults to 4. hit_type, if specified, gives the priority class of the hit. Valid priority classes are Dodge, Hit, and Miss. The priority class determines the tiebreaking behavior when P1 and P2 hit each other simultaneously with equal priorities. The behavior is as follows:
  - Hit vs. Hit: both P1 and P2 are hit
  - Hit vs. Miss: Hit hits, Miss misses
  - Hit vs. Dodge: No hits
  - Dodge vs. Dodge: No hits
  - Dodge vs. Miss: No hits
  - Miss vs. Miss: No hits
  In the case of a no-hit tie, the respective HitDefs stay enabled.
- damage = hit_damage, guard_damage (int)
  hit_damage is the damage that P2 takes when hit by P2. The optional guard_damage parameter is the damage taken by P2 if the hit is guarded. Both default to zero if omitted.
- pausetime = p1_pausetime, p2_shaketime (int)
  This is the time that each player will pause on the hit. p1_pausetime is the time to freeze P1, measured in game-ticks. p2_pausetime is the time to make P2 shake before recoiling from the hit. Defaults to 0,0 if omitted.
- guard.pausetime = p1_pausetime, p2_shaketime (int)
  Similar to the "pausetime" parameter, these are the times to pause each player if the hit was guarded. Defaults to the same values as the "pausetime" parameter if omitted.
- sparkno = action_no (int)
  This is the action number of the spark to display if the hit is successful. To play a spark out of the player's .AIR file, precede the action number with an S. Defaults to the value set in the player variables if omitted.
- guard.sparkno = action_no (int)
  This is the action number of the spark to display if the hit was guarded. To play a spark out of the player's .AIR file, precede the action number with an S. Defaults to the value set in the player variables if omitted.
- sparkxy = spark_x, spark_y (int)
  This is where to make the hit/guard spark.
  spark_x is a coordinate relative to the front of P2. A negative value makes the spark deeper inside P2. "Front" refers to the x-position at P2's axis offset towards P1 by the corresponding width value in the [Size] group in P2's player variables. spark_y is relative to P1. A negative value makes a spark higher up. You can use a tool like AirView to determine this value by positioning the cursor at the "attack spot" and reading off the value of the y-position. Defaults to 0,0 if omitted.
- hitsound = snd_grp, snd_item (int)
  This is the sound to play on hit (from common.snd). The included fight.snd lets you choose from 5,0 (light hit sound) through to 5,4 (painful whack). To play a sound from the player's own SND file, precede the first number with an "S". For example, "hitsound = S1,0". Defaults to the value set in the player variables if omitted.
- guardsound = snd_grp, snd_item (int)
  This is the sound to play on guard (from common.snd). Only 6,0 is available at this time. To play a sound from the player's own SND file, precede the first number with an "S". There is no facility to play a sound from the opponent's SND file. Defaults to the value set in the player variables if omitted.
- ground.type = attack_type (string)
  This is the kind of attack if P2 is on the ground. Choose from "High" for attacks that make P2's head snap backwards, "Low" for attacks that look like that hit in the stomach, "Trip" for low sweep attacks, or "None" to not do anything to P2. "High" and "Low" attacks have no effect on P2 if the AnimType is "Back". If P2 is hit from behind, "High" will be displayed as "Low" and vice-versa. Defaults to "High" if omitted.
- air.type = attack_type (string)
  This is the kind of attack if P2 is in the air. Defaults to the same value as "ground.type" if omitted.
- ground.slidetime = slide_time (int)
  This is the time in game-ticks that P2 will slide back for after being hit (this time does not include the pausetime for P2). Applicable only to hits that keep P2 on the ground. Defaults to 0 if omitted.
- guard.slidetime = slide_time (int)
  Same as "ground.slidetime", but this is the value if P2 guards the hit. Defaults to same value as "guard.hittime".
- ground.hittime = hit_time (int)
  Time that P2 stays in the hit state after being hit. Increase this value to keep P2 in the hit state for a longer time, perhaps to make it easier to combo. Applicable only to hits that keep P2 on the ground. Defaults to 0 if omitted.
- guard.hittime = hit_time (int)
  Same as "ground.hittime", but this is the value if P2 guards the hit. Defaults to same value as "ground.hittime".
- air.hittime = hit_time (int)
  Time that p2 stays in the hit state after being hit in or into the air, before being able to guard again. This parameter has no effect if the "fall" parameter is set to 1. Defaults to 20 if omitted.
- guard.ctrltime = ctrl_time (int)
  This is the time before p2 regains control in the ground guard state. Defaults to the same value as "guard.slidetime" if omitted.
- guard.dist = x_dist (int)
  This is the x-distance from P1 in which P2 will go into a guard state if P2 is holding the direction away from P1. Defaults to the value in the player variables if omitted. You normally do not need to use this parameter.
- yaccel = accel (float)
  Specifies the y acceleration to impart to P2 if the hit connects. Defaults to 0.
- ground.velocity = x_velocity, y_velocity (float)
  Initial velocity to give P2 after being hit, if P2 is on the ground. If y_velocity is not zero, P2 will be knocked into the air. Both values default to 0 if omitted. You can leave out the y_velocity if you want P2 to remain on the ground.
- guard.velocity = x_velocity (float)
  Velocity to give P2 if P2 guards the hit on the ground. Defaults to the x_velocity value of the "ground.velocity" parameter if omitted.
- air.velocity = x_velocity, y_velocity (float)
  Initial velocity to give P2 if P2 is hit in the air. Defaults to 0,0 if omitted.
- airguard.velocity = x_velocity, y_velocity (float)
  Velocity to give P2 if P2 guards the hit in the air. Defaults to x_velocity*1.5, y_velocity/2, where x_velocity and y_velocity are values of the "air.velocity" parameter.
- ground.cornerpush.veloff = x_velocity (float)
  Determines the additional velocity (velocity offset) to impart to the player if he lands a ground hit in the corner. Setting this to a higher value will cause the player to be "pushed back" farther out of the corner. If omitted, default value depends on the attr parameter. If arg1 of attr is "A", default value is 0. Otherwise, defaults to 1.3*guard.velocity.
- air.cornerpush.veloff = x_velocity (float)
  Determines the additional velocity (velocity offset) to impart to the player if he lands a hit to an aerial opponent in the corner. Setting this to a higher value will cause the player to be "pushed back" farther out of the corner. Defaults to ground.cornerpush.veloff if omitted.
- down.cornerpush.veloff = x_velocity (float)
  Determines the additional velocity (velocity offset) to impart to the player if he lands a hit on a downed opponent in the corner. Setting this to a higher value will cause the player to be "pushed back" farther out of the corner. Defaults to ground.cornerpush.veloff if omitted.
- guard.cornerpush.veloff = x_velocity (float)
  Determines the additional velocity (velocity offset) to impart to the player if his hit is guarded in the corner. Setting this to a higher value will cause the player to be "pushed back" farther out of the corner. Defaults to ground.cornerpush.veloff if omitted.
- airguard.cornerpush.veloff = x_velocity (float)
  Determines the additional velocity (velocity offset) to impart to the player if his hit is guarded in the corner. Setting this to a higher value will cause the player to be "pushed back" farther out of the corner. Defaults to guard.cornerpush.veloff if omitted.
- airguard.ctrltime = ctrl_time (int)
  This is the time before p2 regains control in the air guard state. Defaults to the same value as "guard.ctrltime" if omitted.
- air.juggle = juggle_points (int)
  This is the time before p2 regains control in the air guard state. Defaults to the same value as "guard.ctrltime" if omitted.
- mindist = x_pos, y_pos (int)
  Controls the minimum distance of P2 relative to P1, after P2 has been hit. This parameter is not commonly used. Defaults to no change in P2's position if omitted.
- maxdist = x_pos, y_pos (int)
  Controls the maximum distance of P2 relative to P1, after P2 has been hit. This parameter is not commonly used. Defaults to no change in P2's position if omitted.
- snap = x_pos, y_pos (int)
  This moves P2 to the specified position relative to P1 if hit. This controller is not normally used. If you want to snap P2 to a particular position for a throw, it is recommended you use a "TargetBind" controller in P1's throwing state instead. Defaults to no change in P2's position if omitted.
- p1sprpriority = drawing_priority (int)
  This is the drawing priority of P1's sprite if the move hits or is guarded by P2. Together with the p2sprpriority parameter, it controls whether or not P1 is drawn in front of or behind P2. The default value is 1.
- p2sprpriority = drawing_priority (int)
  This is the drawing priority of P2's sprite if the move hits or is guarded by P2. The default value is 0.
- p1facing = facing (int)
  Set to -1 to make P1 turn around if the hit is successful. Usually useful only for throws. The default value is no change in where P1 is facing.
- p1getp2facing = facing (int)
  Set to 1 to have P1 face in the same direction as P2 is facing after the hit connects, and -1 to have P1 face the opposite direction from P2. Defaults to 0 (no change). If nonzero, this parameter takes precedence over p1facing.
- p2facing = facing (int)
  Set to 1 to make P2 face the same direction as P1 if the hit is successful, -1 to make P2 face away. The default value is no change in where P2 is facing.
- p1stateno = state_no (int)
  This is the number of the state to set P1 to if the hit is successful. Used mainly for throws.
- p2stateno = state_no (int)
  This is the number of the state to set P2 to if the hit is successful. P2 will get P1's states and animation data. Used mainly for throws.
- p2getp1state = value (boolean)
  Set to 0 to prevent P2 from getting P1's state and animation data, in case you do not want that default behaviour of the "p2stateno" parameter. Defaults to 1 if the "p2stateno" parameter is used. Ignored otherwise.
- forcestand = value (boolean)
  Set to 1 to force P2 to a standing state-type if the hit is successful, and P2 is in a crouching state. Normally defaults to 0, but if the y_velocity of the "ground.velocity" parameter is non-zero, it defaults to 1.
- fall = value (boolean)
  Set to 1 if you want P2 to go into a "fall" state (where P2 hits the ground without recovering control in the air). Use if you want a move to "knock down" P2.
- fall.xvelocity = x_velocity (float)
  This is the x-velocity that P2 gets when bouncing off the ground in the "fall" state. Defaults to no change if omitted.
- fall.yvelocity = y_velocity (float)
  This is the y-velocity that P2 gets when bouncing off the ground in the "fall" state. Defaults to -4.5 if omitted.
- fall.recover = value (boolean)
  Set to 0 if you do not want P2 to be able to recover from the "fall" state. Defaults to 1 if omitted (can recover).
- fall.recovertime = recover_time (int)
  This is the time that must pass before P2 is able to recover from the "fall" state. Does not include the time that P2 is paused for while shaking from the hit. Defaults to 4 if omitted.
- fall.damage = damage_amt (int)
  Indicates the amount of damage to deal when P2 hits the ground out of a falling state. Defaults to 0 if omitted.
- air.fall = value (int)
  Set to 1 if you want P2 to go into a "fall" state (where P2 hits the ground without recovering control in the air) if hit in the air. Defaults to the same value as fall.
- down.velocity = x_velocity, y_velocity
  This is the velocity to assign P2 if P2 is hit while lying down. If the y_velocity is non-zero, P2 will be hit into the air. If it is zero, then P2 will slide back on the ground. Defaults to the same values as the "air.velocity" parameter if omitted.
- down.hittime = hit_time (int)
  This is the time that P2 will slide back for if P2 is hit while lying down. This parameter is ignored if the y_velocity is non-zero for the "down.velocity" parameter.
- down.bounce = value (boolean)
  Set to 1 if you want P2 to bounce off the ground one time (using the fall.xvelocity and fall.yvelocity values) after hitting the ground from the hit. This parameter is ignored if the y_velocity is zero for the "down.velocity" parameter. Defaults to 0 if omitted (P2 hits the ground and stays there).
- id = id_number (int)
  Main use of this is for chain moves. You can use this number to later detect if a player was last hit by this particular HitDef.
  Valid values are all values >= 1. If omitted, defaults to 0 (no ID).
- chainID = id_number (int)
  Main use of this is for chain moves. If P2 was last hit by a move with this ID, only then can he be hit by the HitDef with this chainID. Use in the following parts of a chain move. Note that chain moves are still possible even without the use of "id" and "chainid".
  Valid values are all values >= 1.
  If omitted, defaults to -1 (chain from any hit).
- nochainID = nochain_1, nochain_2 (int)
  nochainID specifies up to 2 ID numbers of hits which cannot be chained into this hit. If these are -1 (the default), then chaining is not explicitly disabled for any hit ID numbers. nochain_2 can be omitted. Except for -1, the values specified must not coincide with the value for chainID. This parameter has no effect if P2 is hit by a third party between P1's previous HitDef and the current HitDef.
- hitonce = hitonce_flag (boolean)
  If set to 1, the HitDef only affects one opponent. If the hit is successful, all other targets will be dropped. Defaults to 0 most of the time. Only exception is if the "attr" parameter is a throw type, which makes it default to 1.
- kill = kill_flag (int)
  Set to 0 if this hit should not be able to KO the opponent when the hit is successful. Defaults to 1.
- guard.kill = gkill_flag (int)
  Set to 0 if this hit should not be able to KO the opponent when he guards. Defaults to 1.
- fall.kill = fkill_flag (int)
  Set to 0 if this attack should not be able to KO the opponent when he falls on the ground (see fall.damage). Defaults to 1.
- numhits = hit_count (int)
  hit_count indicates how many hits this hitdef should add to the combo counter. Defaults to 1.
- getpower = p1power, p1gpower (int)
  p1power specifies the amount of power to give P1 if this HitDef connects successfully. p1gpower specifies the amount of power to give P1 if this HitDef is guarded. If omitted, p1power defaults to hit_damage (from "damage" parameter) multiplied by the value of Default.Attack.LifeToPowerMul specified in data/mugen.cfg. If p1gpower is omitted, it defaults to the value specified for p1power divided by 2.
- givepower = p2power, p2gpower (int)
  p2power specifies the amount of power to give P2 if this HitDef connects successfully. p2gpower specifies the amount of power to give P2 if this HitDef is guarded. If omitted, p1power defaults to hit_damage (from "damage" parameter) multiplied by the value of Default.GetHit.LifeToPowerMul specified in data/mugen.cfg. If p1gpower is omitted, it defaults to the value specified for p1power divided by 2.
- palfx.time = duration (int)
  If included, this allows for palette effects on P2 if the hit is successful. Time specifies the number of ticks that the palette effects should last. Specify -1 to have the palette effects last indefinitely. Specify 0 to stop any ongoing palette effects.
- palfx.add = add_r, add_g, add_b (int)
- palfx.mul = mul_r, mul_g, mul_b (int)
  Each add component is added to the appropriate component of the player's palette, and the result is multiplied by the appropriate mul component divided by 256. For instance, if pal_r is the red component of the character's original palette, then the new red component is (pal_r + add_r)*mul_r/256. The values for mul must be >= 0.
  The defaults for these parameters are for no change:
  add = 0,0,0
  mul = 256,256,256
- palfx.sinadd = ampl_r, ampl_g, ampl_b, period (int)
  Creates an additional sine-wave palette addition effect. Period specifies the period of the sine wave in game ticks, and the amplitude parameters control the amplitude of the sine wave for the respective components. For instance, if t represents the number of ticks elapsed since the activation of the PalFX controller, and pal_r is the red component of the character's original palette, then the red component of the character's palette at time t is (pal_r + add_r + ampl_r*sin(2*pi*t/period))*mul_r/256.
- palfx.invertall = bvalue (bool)
  If bvalue is non-zero, then the colors in the palette will be inverted, creating a "film negative" effect. Color inversion is applied before effects of add and mul. bvalue defaults to 0.
- palfx.color = value (int)
  This affects the color level of the palette. If value is 0, the palette will be greyscale. If value is 256, there is no change in palette. Values in between will have an intermediate effect. This parameter's effects are applied before invertall, add and mul. Values must be in range 0 to 256.
  Default value is 256.
- envshake.time = shake_time (int)
  If included, this shakes the screen if the hit is successful. Time specifies the number of ticks to shake the screen for.
- envshake.freq = shake_speed (float)
  shake_speed is a float between 0 (slow shake) to 180 (fast shake). Defaults to 60.
- envshake.ampl = shake_amplitude (int)
  The larger the amplitude, the farther the screen shakes up and down. A negative amplitude means that the screen will shake down first. Defaults to -4.
- envshake.phase = phase_offset (float)
  Specifies the phase offset for the shaking. The default is 0, unless the frequency multiplier is 90 or greater. In this case, the default phase offset is 90.
- fall.envshake.time = shake_time (int)
  If included, this shakes the screen if the hit is successful, but only when P2 hits the ground. Time specifies the number of ticks to shake the screen for.
- fall.envshake.freq = shake_speed (float)
  shake_speed is a float between 0 (slow shake) to 180 (fast shake). Defaults to 60.
- fall.envshake.ampl = shake_amplitude (int)
  The larger the amplitude, the farther the screen shakes up and down. A negative amplitude means that the screen will shake down first. Defaults to -4.
- fall.envshake.phase = phase_offset (float)
  Specifies the phase offset for the shaking. The default is 0, unless the frequency multiplier is 90 or greater. In this case, the default phase offset is 90.
- afterimage.time = duration (int)
  If included, add afterimage effects to the projectile. Time specifies the number of ticks that the afterimages should be displayed for. Defaults to 1.
- afterimage.length = no_of_frames (int)
  Sets the capacity of the frame history buffer. The history will hold up to no_of_frames of the character's most recently saved frames. Assuming constant values for timegap and framegap, increasing the length can increase the number and "age" (for lack of a better term) of afterimages displayed at one time. The maximum length is 60, and the default is 20.
- afterimage.palcolor = col (int)
- afterimage.palinvertall = invertall (bool)
- afterimage.palbright = add_r, add_g, add_b (int)
- afterimage.palcontrast = mul_r, mul_g, mul_b (int)
- afterimage.palpostbright = add2_r, add2_g, add2_b (int)
  These parameters determine palette effects to be applied to all afterimages. First the color level is adjusted according to the palcolor value, then if invertall is non-zero the colors are inverted. Afterwards, the palbright components are added to the corresponding component of the player's palette, then each component is multiplied by the corresponding palcontrast component divided by 256, then the palpostbright components are added to the result. The value of palcolor ranges from 0 (greyscale) to 256 (normal color). For instance, if the red component of the character's palette is denoted pal_r, then the red component of the afterimage palette is given by (pal_r+add_r)*mul_r/256 + add2_r, assuming palcolor and palinvert are left at their default values.
  Valid values are 0-256 for palcolor, 0-255 for palbright and palpostbright components, and any non-negative integer for palcontrast components.
  The defaults are:
  palcolor = 256
  palinvertall = 0
  palbright = 30,30,30
  palcontrast = 120,120,220
  palpostbright = 0,0,0
- afterimage.paladd = add_r, add_g, add_b (int)
- afterimage.palmul = mul_r, mul_g, mul_b (float)
  These parameters specify palette effects that are applied repeatedly to successive frames in the afterimage. In one application of these palette effects, first the paladd components are added to the afterimage palette, then the components are multiplied by the palmul multipliers. These effects are applied zero times to the most recent afterimage frame, once to the second-newest afterimage frame, twice in succession to the third-newest afterimage frame, etc.
  Valid values are 0-255 for the paladd components, and any non-negative float value for the palmul multipliers. The defaults are:
  paladd = 10,10,25
  palmul = .65,.65,.75
- afterimage.timegap = value (int)
  This parameter controls how many frames to skip between saving player frames to the history buffer for afterimage display. The default is 1 (skip no frames). To save every third frame (for example), you would use timegap = 3.
- afterimage.framegap = value (int)
  Every value'th frame in the history buffer will be displayed as an afterimage. For instance, if framegap = 4 (the default), then the first, fifth, ninth, ... frames of the history buffer will be displayed as afterimages.
- afterimage.trans = type (string)
  Specifies the transparency type for the afterimages. Valid types are "none" for an opaque afterimage, "add", "add1", and "sub".

Notes:

All projectiles created by helpers immediately become owned by the root.

The behavior of a projectile's HitDef is undefined when executed from a [Statedef -2] block while the player has another player's state and animation data.

Examples:

`none`