From Infinitywiki

Jump to: navigation, search



The CNS file of a player serves two purposes:

First, it defines the variables of that player, such as walking speed, drawing scale factor, and so on.

Second, it contains the states of the player, which describe all the moves that the player can do. States are the building blocks that you can use to create simple as well as complicated moves.

Like many other character files, the CNS is a text file that you can edit with any text editor.

In the CNS file, a semicolon (;) is considered a "comment" character. Any text on the same line after the semicolon will be ignored by the program. The CNS is mostly case-insensitive, i.e. "MyName" is treated the same as "myname" and "mYnAMe". The one exception is the command trigger (covered in detail in the CMD documentation).

Some terminology

When we say "group", we mean any block of lines of text beginning with something that looks like [groupname], and ending before the next group. For example, the group Foo consists of the first three lines in the following:

[Group 2]
more lines

Within a group, the parameters can appear in any order. So,

value1 = 1234
value2 = "A string"

is equivalent to:

value2 = "A string"
value1 = 1234

Player Variables

Player variables make up the top section of a CNS file. A complete list of player variables can be found here.


Animations and sounds are the most immediately noticeable manifestations of a MUGEN character, but the true "heart" of the character is its CNS file(s). The CNS file, also known as the character's "states" file, contains the code that actually gives the character its functionality -- allowing it to perform moves when commanded, to hit its opponent, or to obey the law of gravity.

The structure of a CNS file is simple. Code is organized into logical groups called [StateDef]s. [StateDef] blocks are numbered, and a typical character may contain hundreds of them. Within each [StateDef] is a number of [State] blocks, also known as state controllers. Each state controller is a trigger-action pair: it specifies some action for the character to take, and the conditions under which that action should be performed.

At each instant ("tick") of game time, the character executes the code in some [StateDef] block. For instance, if the character is standing idly, then it is typically executing in the [StateDef 0] block. For brevity, we say that the character is "in state 0". At each tick that the character is in state 0, it will evaluate the state controllers in the [StateDef 0] block from top to bottom, checking the conditions and taking any actions that are specified. If the character needs to change to some other [StateDef] block, let's say to state 417 because it is performing a move, it can execute a ChangeState state controller to make the switch. The character will then start executing the code in [StateDef 417], in exactly the same fashion.

Each MUGEN character additionally has three special states, numbered -1, -2, and -3. These are the only allowable states with negative numbers. State -1 generally contains state controllers that determine state transition rules based on user input (commands). State -2 contains other state controllers that need to be checked every tick. State -3 contains state controllers which are checked every tick unless the player is temporarily using another player's state data (for instance, when the player is being thrown).

There is one exception to rule. If the on screen character is actually a "helper", i.e., spawned by the main character through the Helper state controller, that character will not have the special states -3 and -2. The helper character will not have the special state -1 either, unless it has keyboard input enabled which is controlled by the Helper state controller when the character is created.

Introduction to States

Programming states is the hardest part of creating a character. It entails a lot of work, testing, and sometimes trial-and-error. In this section, we'll often refer the player being programmed, and to his opponent as well. Let us call the player whose states we are editing P1, and his opponent P2.

Do not be discouraged if you do not understand a lot of this document on your first reading. The best way to learn about states is to first play around with values in the CNS of a completed character, and see what effects they have on him or her. There's nothing to fear from "tweaking" the CNS; M.U.G.E.N is designed to detect syntax errors and report them.

Included with the M.U.G.E.N distribution package is a character named Kung Fu Man (KFM for short.) You can find him in the directory chars/kfm.

The CMD file contains declarations of command names and the definition of State -1, a special state which is used to control how the character responds to user input. See the CMD document for more information.

Below are some concepts that will be useful for you to know.

Life and power

A player's life bar is the yellow bar at the top of the screen on his side of the screen. When the life bar reaches zero, the player is knocked out. His power bar is the blue bar, and that increases with each attack he gives or takes. When the power bar reaches certain values, he can do super moves.


When we say a player "has control", we mean that he is ready to walk or jump or attack. A player who does not have control will not respond to your input (from keyboard or joystick). For example, when P1 is in his stand state, he has control, and will walk forward if you press the forward button. A player will typically not have control when he is in an attack state, otherwise you could just walk away halfway through a punch.

There is an exception to the rule, however. Sometimes you can let the player respond to certain moves even if he has no control. That is called a "move interrupt", or a "move cancel". See the CMD documentation for details.

We will frequently refer to a player's "control flag". A "flag" is a value that is either true, or false. If we say the player's control flag is true, then it means he has control.

Game-time and state-time

M.U.G.E.N keeps track of the time that has passed in the game. Every time the game is updated (this includes updating the players, checking collisions, and drawing to the screen), we say game-time has increased by one. The time a player has spent in a state is known as the "state-time". The state-time starts at 0 at the beginning of a state, and increases by one tick for every tick of game-time.

Position, velocity and acceleration

Those of you with basic knowledge of math should understand these concepts. M.U.G.E.N uses the following coordinate system. The greater the x-position, the farther right the player is. The less the x-position, the closer he is to the left. A y-position of zero is at ground level. As the player's y-position gets larger he moves downwards. For example, a negative y-position means he is in the air. Similarly, when we say a player has positive x-velocity, it means he is moving forward, and if he as negative x-velocity, he is moving backwards. A player with positive y-velocity is moving downward, and a negative y-velocity means he is moving up. A positive x-acceleration means the player's x-velocity is increasing, a negative x-acceleration means his x-velocity is decreasing. Likewise for y-acceleration.


M.U.G.E.N allows for certain moves to "juggle", that is, to hit opponents who have been knocked into the air, or are lying down on the ground. The juggling system works this way: each person starts with a set number of juggle "points" on the first hit that makes them fall, typically 15.

Some quick terminology: when we say a player is "falling", then we mean he does not recover control in the air, and will fall onto the ground.

If a player is hit while he is in the falling in the air or lying down on the ground, then his juggle points will decrease by an amount depending on the attack. When an attack requires more juggle points than the opponent has left, then the attack will miss. Any move that causes the opponent to fall immediately subtracts its juggle points on the first hit.

For example, an attack that requires 7 juggle points could theoretically be used to juggle the opponent twice (assuming you started with 15 points), leaving the opponent with 1 point left. Subsequent such attacks will miss.

The reason for this juggle system is to prevent infinite combos in the air.

Basic Parts of a State

Note: This section assumes you have at least browsed the documentation of AIR files, and understand the concepts of animation, as know the meaning of key words and phrases such as action and element of an action.

Here is a short example state for P1:

[Statedef 200]
type = S
physics = S
movetype = I
ctrl = 0
anim = 200
velset = 0

[State 200, 1]
type = ChangeState
trigger1 = AnimTime = 0
value = 0
ctrl = 1

This state plays back the Action 200 of P1's animation, and returns P1 to his standing state after the animation has ended. In this case, assume Action 200 has a finite looptime. That is, Action 200 does not have any elements with time equal to -1.

At this point, you do not need to worry about the details. Let us begin by knowing what a state consists of.

All states must have a single Statedef section and one or more State sections.

Statedef contains the starting information of a state, such as what kind of state it is (standing, crouching, in the air) and what kind of move he is doing (attacking, idling.)

Each State section is referred to as a state controller, or a controller for short. Controllers tell the program what to do to P1, and when to do it. There are many kinds of controllers, each with its own function. For example, there are controllers to change the players position or velocity, define the effects of attacks, create projectiles, switch between animation Actions, change states, and so on. Each controller must have at least one trigger. A trigger is an event that causes the controller to be activated. Examples are: trigger at the start of the state, trigger at the end of the animation (as seen in the example State above), trigger on an element of an animation Action, trigger when P2 is within a certain range of P1, and so on.

Details on StateDef

Every state must begin with exactly one StateDef group, also known as a Statedef section. A StateDef group must look like this (put in one or more parameters where the dots are):

[Statedef state_number]
. state_parameters

Replace state_number with the number of the state you are programming. With the exception of the special group numbers (see Appendix A) you are allowed to use any state number you choose. To avoid choosing a special group number, do not choose numbers from 0-199, and from 5000-5999.

The lines that follow should include the following basic parameters:

• type

• movetype

• physics

• anim

There are also additional optional parameters that may be included:

• velset

• ctrl

• poweradd

• juggle

• facep2

• hitdefpersist

• movehitpersist

• hitcountpersist

• sprpriority


This is the state type of P1 in that state. It defines if he is standing, crouching, in the air, or lying down. The corresponding values are "S", "C" , "A" and "L" respectively (without the quotation marks). To leave the type unchanged from the previous state, use a value of "U". If this line is omitted, it assumes the type is "S". You will most commonly use "S", "C" and "A". For example, a crouching state type would require the line:

type = C

The type is used to determine several factors, most importantly, how P1 will react to being hit. For example, being in a "stand"-type state, P1 will react as if he is standing on the ground. If the type was "air", then P1 would react to the hit accordingly.


This is the type of move P1 is doing: "A" for attack, "I" for idle and "H" for being hit. To leave the movetype unchanged from the previous state, use a value of "U". The value is assumed to be "I" if this line is omitted. "A" and "H" should be self-explanatory. "I" is used for states where P1 is neither attacking, nor being hit. For example, an attack state should have the line:

movetype = A

You need to specify the movetype so the program will know how to process the state. Incorrectly specifying the movetype may cause P1 to act incorrectly.


You need to specify what physics to use in that state. Valid values are "S" for stand, "C" for crouch, "A" for air, and "N" for none. To leave the physics unchanged from the previous state, use a value of "U". If omitted, the value of "N" is assumed. The kind of physics is used to determine how P1 behaves.

•For "S" physics, P1 will experience friction with the ground. The value for the friction coefficient is set in the Player Variables.

•For "C" physics, P1 will experience friction, just like in the "S" state.

•For "A" physics, P1 will accelerate downwards, and if his y-position is greater than 0 (ie. he touches the ground) he will immediately go into his landing state.

•If you use "N" P1 will not use any of these pre-programmed physics.

Do not confuse "physics" with the state "type". They are usually the same, but you are given the choice if you want more control. For instance, you may choose to use "N" (no physics), and specify your own acceleration and landing detection for an aerial state.


This parameter changes the Animation Action of P1. Specify the action number as the value. If you do not want P1 to change animation at the start of the state, omit this parameter.

So to have a state with number 400, where the player is doing a crouching attack with Action 400, the typical parameters would be:

[Statedef 400]
type = c
movetype = a
physics = c
anim = 400


You can use velset to set P1's velocity at the beginning of the state. The format is a number pair, representing the x velocity and the y velocity respectively. Omitting this line will leave P1's velocity unchanged. For example,

velset = 4,-8

makes P1 start moving diagonally up and forwards.

There is an exception to this. Even if you have velset = 0, attacking P2 in the corner will push P1 away.


This parameter will set P1's control. A value of "0" sets the flag to false, "1" sets it to true. If omitted, P1's control flag is left unchanged. For example, to give P1 control, use

ctrl = 1


When included, the poweradd parameter adds to the player's power bar. The value is a number, and can be positive or negative. This parameter is typically used in attack moves, where you want the player to gain power just by performing the attack. For example, to add 40 power, type

poweradd = 40


The juggle parameter is useful only for attacks. It specifies how many points of juggling the move requires. If omitted for an attack, that attack will juggle if the previous attacking state successfully juggled. You should include the juggle parameter for all attacks. If an attack spans more than one state, include the juggle parameter only in the first state of that attack. See also Juggling.


When you include the line facep2 = 1, the player will be turned, if necessary, to face the opponent at the beginning of the state. facep2 has the default value of "0" if omitted.


If set to 1, any HitDefs which are active at the time of a state transition to this state will remain active. If set to 0, the default, any such HitDefs will be disabled when the state transition is made.


If set to 1, the move hit information from the previous state (whether the attack hit or missed, guarded, etc; see "Move*" triggers in trigger docs) will be carried over into this state. If set to 0 (the default), this information will be reset upon entry into this state.


If set to 1, the hit counter (how many hits this attack has done) will be carried over from the previous state to this state. If set to 0 (the default), the hit counter will be reset upon state transition. This parameter does not affect the combo counter which is displayed on the screen. See the HitCount and UniqHitCount trigger documentation for how to check the hit counter.


If this parameter is present, the player's sprite layering priority will be set to the value specified. If omitted, the sprite priority will be left unchanged. common1.cns (the CNS file that is inherited by every player) defines the sprite priority of standing or crouching players to be 0, and jumping players to be 1. For most attack states, you will want to set sprpriority = 2, so that the attacker appears in front.

See SprPriority in the sctrl documentation for how to change sprite priority using a controller.

Details on State Controllers

Each state group contains at least one state controller or sctrl. A complete list of sctrls can be found here.

Controller Format

All states must have at least one state controller, otherwise it will cause an error. State controller groups have the following format:

[State state_number, some_number]
type = controller_type
trigger1 = condition_exp
<universal optional parameters>
<additional parameters depending on controller>

The state_number must be the same number of the state from the StateDef. some_number can be any number you choose; it is the number that is reported when an error is found, so you know which controller needs to be fixed.

The universal (applicable to all state controllers) optional parameters are the ignorehitpause and persistency parameters. If ignorehitpause is set to 1, MUGEN will check this state controller even if the character is paused by a hit. Otherwise, this state controller will not be checked during a hit pause. The default is 0, which is recommended for all but exceptional situations. For an explanation of the persistency parameter, see Trigger Persistency.

controller_type is the name of the controller you are using. Each type of controller has a different effect, and requires different parameters. See sctrls.txt for a full list of state controllers.

The order of the controllers is significant. Controllers listed first are the ones checked and, if necessary, activated first.

Here is an example of a controller that gives P1 control at the start of the state (the same effect as putting ctrl = 1 as a parameter in the StateDef):

[State 300, 1] ;State 300. 1 is just an arbitrary number.
type = CtrlSet ;Changes the control flag.
trigger1 = Time = 0
value = 1

In this example, the CtrlSet type lets you change the control flag of P1. The line that reads trigger1 = Time = 0 means that this controller is activated when the state-time is 0, i.e., at the start of that state. The line value = 1 says that we want to set the value of the control flag to 1, which means true. If we want to make P1 start the state with no control, then we just need to change the last line to value = 0.

Let's look another example. This controller moves P1 forwards by 10 pixels twice: on the second and third element of his current Animation Action. Don't worry if you don't know what parameters go with which controller types. You can learn more about them from the state controller documentation (sctrls).

[State 300, 2]
type = PosAdd ;Adds to P1's position
trigger1 = AnimElem = 2 ;Trigger on 2nd element.
trigger2 = AnimElem = 3 ;Trigger on 3rd element.
x = 10

As you see above, each controller must have at least one trigger. A trigger is a condition that causes the controller to be activated. This example has two triggers, and the controller is activated when either one is true.


Trigger Logic

The first trigger should always be trigger1, and subsequent triggers should be trigger2, then trigger3 and so on. The logic for deciding if a controller should be activated is:

1.Are all conditions of trigger1 true? If so, then yes, activate the controller.

2.Otherwise, repeat the test for trigger2, and so on, until no more triggers are found.

This can be thought of as "OR" logic.

Be careful; skipping numbers will cause some triggers to be ignored. For example, if you have triggers trigger1, trigger2 and trigger4 without a trigger3, then trigger4 will be ignored.

Now what if you want more than one condition to be met before the controller is activated? Here is an commonly-used example for testing if a player in the air has reached the ground. The triggers used are:

trigger1 = Vel Y > 0 ; True if Y-velocity is > 0 (going down)
trigger1 = Pos Y > 0 ; True if Y-position is > 0 (below ground)

At this point, you may be confused by the format of the trigger. Do not worry about it for now. We will get to it soon.

As you can see above, both the triggers have the same number. When several triggers have the same number, it implements "AND" logic. That is, the controller is activated if every one of the triggers with the same number is true, but not if one or more of them is false.

You can combine both ideas. For example:

trigger1 = Vel Y > 0 ; True if Y-velocity is > 0 (going down)
trigger1 = Pos Y > 0 ; True if Y-position is > 0 (below ground)
trigger2 = Time = 5  ; True if state-time is 5

The controller for this would be activated if the player landed on the ground (y-velocity and y-Position are both > 0), OR if his state time was 5.

Here is a summary:

•Triggers with the same number activate the controller only if all of them are true.

•Triggers with different numbers activate the controller if any one or more of them are true.

The format of a trigger is:

trigger? = condition_exp

condition_exp is an arithmetic expression to be checked for equality to 0. If condition_exp is 0, then the trigger is false. If condition_exp is nonzero, then the trigger is true. The condition_exp is usually a simple relational expression as in the examples above, but can be as simple or as complicated as required.

It is possible to use logical operators between expressions. For instance, this is equivalent to the previous example above.

trigger1 = ((Vel Y > 0) && (Pos Y > 0)) || Time = 5

See Expressions for a detailed explanation of arithmetic expressions.

A useful shortcut you might use is triggerall. It specifies a condition that must be true for all triggers. For instance, consider:

triggerall = Vel X = 0
trigger1 = Pos Y > -2
trigger2 = AnimElem = 3
trigger3 = Time = [2,9]

For any of trigger1 to trigger3 to be checked, the triggerall condition must be true too. In this case, as long as the x-velocity is not 0, then the state controller will not be activated. You can have more than one triggerall condition if you need. Note that at least one trigger1 must be present, even if you specify triggerall.

Trigger Persistency

In the case where you do not want the trigger to activate every single time the condition is true, you will need to add a persistent parameter. Let us begin with an example:

[State 310, 1]
type = PosAdd
trigger1 = Vel Y > 1
x = 10

This state controller moves P1 forwards by 10 pixels for every tick of game time where P1's y-velocity is greater than 1. That is, the controller is being activated everytime the trigger condition is true. If we want the controller to be activated only once, we will need to add a line:

[State 310, 1]
type = PosAdd
trigger1 = Vel Y > 1
persistent = 0       ;<-- Added this line
x = 10

persistent has a default value of 1, meaning that the controller is activated everytime the trigger is true. Setting persistent to 0 allows the controller to be activated only once during that state. This holds true until P1 leaves that state. If P1 returns to that state later, the controller can be activated once again.

The persistent parameter can also take values other than 0 and 1:

[State 310, 1]
type = PosAdd
trigger1 = Vel Y > 1
persistent = 2       ;<-- Modified this line
x = 10

In this case, setting persistent to 2 means the controller will be activated once of every two times the trigger is true. Setting persistent to 3 activates the controller every 3rd time, and so on.

Trigger redirection

One might wish to check the statetime of the player's target, or the player's parent (if the player is a helper), etc. This is possible using so-called trigger redirection. See Expressions for details.

Commonly-used controllers The null controller will be useful for debugging. A null controller basically does nothing. You can use it to temporarily turn off certain controllers, instead of commenting out the entire section. For example, you might want to disable this:

[State 300, 1] ;Controller that accelerates P1 forwards
type = VelAdd
trigger1 = Time >= 0
x = .8

Simply comment out the type and put in null:

[State 300, 1] ;Controller that accelerates P1 forwards
type = null ;VelAdd
trigger1 = Time >= 0
x = .8

Later, when you want to reenable the controller, just change the type back to what it used to be.

Now let us look back at the example:

[Statedef 200]
type = S
physics = S
movetype = I
ctrl = 0
anim = 200
velset = 0

[State 200, 1]
type = ChangeState
trigger1 = AnimTime = 0
value = 0
ctrl = 1

[State 200, 1] is a ChangeState controller. As the name implies, it changes P1's state number (i.e., the [StateDef] block from which P1 executes). The value parameter should have the number of the state to change to. The optional ctrl parameter can be set P1's control flag as he changes states.

Now let's make this an attack state. First of all, the animation action needs attack collision boxes. A quick review from the AIR documentation: Clsn1 is for attack and Clsn2 is where the player can be hit. So P1 will hit P2 if any one of P1's Clsn1 boxes intersects with any of P2's Clsn2 boxes.

As an example, let's assume the animation action in P1's AIR file looks like this:

[Begin Action 200]
200,0, 0,0, 3
200,1, 0,0, 4
200,2, 0,0, 4
200,3, 0,0, 3

After defining the bounding boxes, it looks like:

[Begin Action 200]
Clsn2: 1
  Clsn2[0] = -10,0, 10,-80
200,0, 0,0, 3
Clsn1: 1
  Clsn1[0] =  10,-70, 40,-60
Clsn2: 2
  Clsn2[0] = -10,  0, 10,-80
  Clsn2[1] =  10,-70, 40,-60
200,1, 0,0, 4
Clsn2Default: 1 ;Use this box for the last two frames
  Clsn2[0] = -10,0, 10,-80
200,2, 0,0, 4
200,3, 0,0, 3

As you can see, each element has a Clsn2 box defined for it (the last two elements are using the same boxes). The second element is the only one with a Clsn1 box.

Note: It is all right to define Clsn1 boxes for any elements in an Animation Action, but if you put a Clsn1 box in the very first element, the attack will be instantaneous, and become unblockable. Therefore, it is recommended that you define Clsn1 boxes only for elements after the first one.

Now we are ready to set up the state in the CNS. We will explain the changes below.

[Statedef 200]
type = S
physics = S
movetype = A  ;<-- changed from "I" to "A"
ctrl = 0
anim = 200
velset = 0

[State 200, 1] ;<-- Added this state controller
type = HitDef
trigger1 = AnimElem = 2
attr = S, NA
animtype  = Light
damage    = 10
guardflag = MA
pausetime = 12,12
sparkxy = 0,-55
hitsound   = 5,0
guardsound = 6,0
ground.type = High
ground.slidetime = 12
ground.hittime  = 15
ground.velocity = -5
air.velocity = -2.5,-3.5

[State 200, 2]
type = ChangeState
trigger1 = AnimTime = 0
value = 0
ctrl = 1

The movetype parameter in the StateDef is set to A for "attack". Remember to do this for all attack states. As before, P1 changes back to his standing state after his animation is over.

That HitDef controller looks like a monster! Do not worry, we will go through it slowly.

type = HitDef
trigger1 = AnimElem = 2

This specifies the controller type as HitDef, which stands for "Hit Definition". It is triggered on the second element of animation. Any Clsn2 box from the time the trigger was activated will take on this hit definition.

If, for example, you had a Clsn1 in both the second and third element of animation, triggering a single HitDef at the second element makes it apply to both elements of animation. So P1 will hit at most once: if the second element hits, the third will miss. If the second element misses, the third can still hit. To make the attack hit twice, you must trigger a HitDef for each of the two elements.

attr = S, NA

This is the attribute of the attack. It is used to determine if the attack can hit P2. In this case, it is a Standing Normal Attack.

attr 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.

animtype = Light

This refers to the type of animation that P2 will go into when hit by the attack. Choose from light, medium, hard or back. The first three should be self-explanatory. Back is the animation where P2 is knocked off her feet.

damage = 10

This is the damage that P2 takes when hit, and it does no damage if guarded. If we changed that line to damage = 10, 1, then it would do 1 point of damage if guarded.

guardflag = MA

guardflag determines how P2 may guard the attack. Here, it may be guarded high(standing), low (crouching) and in the air. The argument must be a string of characters that includes any of the following: H for "high", L for "low" or A for air. M (mid) is equivalent to saying HL.

pausetime = 12,12

This is the time that each player will pause on the hit. The first argument is the time to freeze P1, measured in game-ticks. The second is the time to make P2 shake before recoiling from the hit.

sparkxy = 0,-55

This is where to make the hit/guard spark. The arguments must be in the form x, y. x is relative to the front of P2. A negative x makes a spark deeper inside P2. y is relative to P1. A negative y makes a spark higher up.

hitsound = 5,0

This is the sound to play on hit (from fight.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.

guardsound = 6,0

This is the sound to play on guard (from fight.snd). Right now all we have is 6,0. To play a sound from the player's own SND file, precede the first number with an S.

ground.type = High

This is the kind of attack for ground attacks (it also defaults to air attacks if you do not specify an air.type parameter). In this case, it is a high attack. Choose from High for attacks that make P2's head snap backwards, Low for attacks that look like they hit in the stomach, Trip for low sweep attacks, or None to not do anything to P2. High and Low attacks are the same on P2 if the AnimType is Back.

ground.slidetime = 12

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.

ground.hittime = 15

Time that P2 stays in the hit state after being hit. Applicable only to hits that keep P2 on the ground.

ground.velocity = -5

Initial x-velocity to give P2 after being hit, if P2 is in a standing or crouching state on the ground. You can specify a y-velocity as the second argument if you want P2 to be knocked into the air, eg. ground.velocity = -3, -2.

air.velocity = -2.5,-3.5

Initial velocity to give P2 if P2 is hit in the air.

There are more things that you can control in a HitDef. See the sctrls documentation for details.

Common state (common1.cns)

If you look at a player's DEF file, you will see the line:

stcommon = common1.cns  ;Common states

Every player shares some common states, which are the basic parts of the game engine. These common states are found in data/common1.cns. Some examples are states for running and getting hit. A full list is available in Special State Numbers.

If there is a common state that you would like to override for a certain player, all you need to do is make a state in that player's CNS with the same number as the one you would like to override. Then, when the player changes to that certain state number, he will enter that new state, instead of the one in common1.cns.

You should remember that when overriding certain states that have special properties coded inside M.U.G.E.N, the new states you make will still have the same special properties as the ones you overrode. For example, the run state (state 100) sets the player's velocity to whatever values you specified in his player variables. If you override state 100, the new state will still have the property of setting that player's velocity.

A common example is overriding the running state. M.U.G.E.N's default behaviour for the running state is to have the player continue moving forward at a constant speed, until you let go of the forward key. At that point he returns to the stand state.

Now, let's say we want that player (let us call him P1) to instead hop forward, just like the default double-tap back hop. You can make a state in P1's CNS:

; RUN_FWD (overridden to dash-type)
[Statedef 100]
type    = S   ;Running is on the ground
physics = N   ;We'll define our own physics
anim = 100    ;Anim action 100
ctrl = 0      ;No control for duration of dash

[State 100, 1] ;To start dashing forwards
type = VelSet
trigger1 = Time = [0,5]
x = 6

[State 100, 2] ;Friction after initial dash
type = VelMul
trigger1 = Time > 5
x = .85

[State 100, 3] ;
type = ChangeState
trigger1 = AnimTime = 0
value = 0
ctrl = 1

Here, we assume that Action 100 has a finite looptime. The velocity in run.fwd under [Velocity] of the player variables is not really ignored, but [State 100,1] overrides that detail by setting the x-velocity to 6.

Special State Numbers

Unless you plan to override a common state, avoid choosing state numbers in the range 0-199 and 5000-5999. Here is a list of states in common1.cns.

Number Description 0 Stand 10 Stand to crouch 11 Crouching 12 Crouch to stand 20 Walk 40 Jump start 45 Air jump start 50 Jump up 52 Jump land 100 Run forward 105 Hop backwards 106 Hop backwards (land) 120 Guard (start) 130 Stand guard (guarding) 131 Crouch guard (guarding) 132 Air guard (guarding) 140 Guard (end) 150 Stand guard hit (shaking) 151 Stand guard hit (knocked back) 152 Crouch guard hit (shaking) 153 Crouch guard hit (knocked back) 154 Air guard hit (shaking) 155 Air guard hit (knocked away) 170 Lose (time over) 175 Draw game (time over) 190 Pre-intro 191 Intro (override this state to give character an intro) 5000 Stand get-hit (shaking) 5001 Stand get-hit (knocked back) 5010 Crouch get-hit (shaking) 5011 Crouch get-hit (knocked back) 5020 Air get-hit (shaking) 5030 Air get-hit (knocked away) 5035 Air get-hit (transition) 5040 Air get-hit (recovering in air, not falling) 5050 Air get-hit (falling) 5070 Tripped get-hit (shaking) 5071 Tripped get-hit (knocked away) 5080 Downed get-hit (shaking) 5081 Downed get-hit (knocked back) 5100 Downed get-hit (hit ground from fall) 5101 Downed get-hit (bounce off ground) 5110 Downed get-hit (lying down) 5120 Downed get-hit (getting up) 5150 Downed get-hit (lying defeated) 5200 Air get-hit (fall recovery on ground; still falling) 5201 Air get-hit (fall recovery on ground) 5210 Air get-hit (fall recovery in air) 5500 Continue screen animation 5900 Initialize (at the start of the round)

Personal tools
Infinity Network