The CNS format


M.U.G.E.N, © Elecbyte 2000

Documentation for version 2000.06.27  

Beta-release documentation (incomplete)  

Updated 27 June 2000


0. Contents



Section I.    Introduction

第一节 简介

Section II.   Player Variables

第二节 角色基本变数

Section III.  States

第三节  States介绍

Section IV.   Expressions

第四节 表示式

Appendix A.   Special State Numbers  

附录A  特殊状态编号


I. Introduction



The CNS file of a player serves two  purposes:


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


ii. 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 only exception is the  "command" trigger, but you do not need to worry about this for now.


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 "Blah" 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


II. Player Variables



No full documentation yet. See  chars/kfm/kfm.cns for comments on each variable.


Some importants one to note:


- In [Size], you can use "xscale" and  "yscale" to change the width and height of your character. This saves the  trouble of scaling every single one of the sprites.  


- Set up the speeds of the player in  [Velocity]


- Set the player's downward acceleration --  "yaccel" in [Movement]



III. States



a. Overview of Finite State Machines in  MUGEN

b. Introduction to States

c. Basic Parts of a State

d. Details on StateDef

e. Details on State Controllers

f. Common states (common1.cns)

a. 概述在MUGEN里一些State的机制

b. 介绍States

c. State的基本部分

d. StateDef的详述

e. State Controllers的详述

f. Common states (common1.cns)的说明。


III.a. Overview of Finite State Machines in  MUGEN


This section presents a working (heuristic)  characterization of finite state machines, as found in MUGEN. It is not  especially technical, but it is aimed at the analytically minded reader. Feel  free to skip over this section if you are already familiar with finite state  machines, or if you are not interested in the details.


A finite state machine (henceforth  abbreviated FSM) is an automaton with a finite set of subroutines, each of which  performs some function and then employs some criterion to choose the next  subroutine to jump to. Each subroutine is called a "state", and the FSM is said  to be in a given state when it is currently processing the directives in that  state. A FSM can only be in one state at any given time.

所谓的finite state machine(以下略称为FSM)是由一些子程序(subroutines)所集合而成的自动机制,每一个子程序可以执行一些功能而且可以利用一些判断指标来选择下一步要执行的子程序是什麼,每个子程序就叫做一个”state,所以FSM可以用来处理一个正在执行中的的stateFSM同一个时间只能处理一个state

The following is a trivial example of a FSM,  given in pseudocode.


State 0:

1. Read in a number.

2. If the number is 0, go to state 0. Else,  go to state 1.

State 1:

1. Print "Woohoo!"

2. Go to state 3.

State 2:

1. Go to state 0.

State 3:

1. Quit

state 0:


2.假如这个数字是0,那麼就跳到state 0.如果不是0,就跳到 state 1.

State 1:

1. 显示”Woohoo !

2. 跳到 state 3

State 2:

1. 跳到state 0

state 3:

is not holding punch, play recovery  


4. If not successful, play miss animation.  

5. When the recovery or miss animation ends,  go to state 0 (idle).

State 555

1. 尝试挥拳攻击对方。

2. 如果成功了,而且玩家继续挥拳攻击,就跳到state  555(连续动作)

3. 如果成功了,但是玩家没有继续挥拳攻击,显示回复正常的动作。

4. 如果没有成功,显示没打到敌人的动作。

5. 当回复正常或是没打到敌人的动作显示完,跳到state  0(等待输入的发呆动作)。

Characters in MUGEN are finite state  machines. The character's CNS file defines a number of states, each of which  contains one or more state controllers. State controllers are what actually give  the character its functionality, similarly to the instructions for our  character's FSM given above. For instance, the controller HitDef allows the  character to hit his opponent, the ChangeState controller allows the character  to make a state transition, and the ChangeAnim controller allows the character  to play a specified animation. Each state controller is specified along with one  or more test conditions, called "triggers" or "condition-type triggers," which  must be satisfied in order for that controller to be executed.

MUGEN的人物就是由FSM组合而成。人物的CNS档定义一些states,每个state都包含一个或一个以上的state  controllers(状态控制器)。状态控制器(state controll)是实际让人物有机能,类似之前我们提到的FSM。例如,HitDef这麼控制器允许人物打击对方,而ChangeState控制器则可以让人物显示一个指定的动作画面。每个状态控制器指定一个或一个以上的判断条件(称为触发triggers或是条件型态触发condition-type triggers),必须满足这些触发条件,控制器才会执行它们所要控制的动作。

Each MUGEN character 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).


State 1的状态控制器通常决定由玩家输入的state的转换规则。

State 2包含每个tick要被判断的状态控制器。

State 3的控制器则是每个tick要被判断一次,除非玩家所使用的人物暂时使用另一名玩家的


For each tick of game-time, MUGEN makes a  single pass through each of the special states, from top to bottom, in order of  increasing state number (-3, -2, then -1). For each state controller  encountered, its condition-type triggers are evaluat ed and, if they are  satisfied, the controller is executed. Then processing proceeds to the next  state controller in the state. A state transition (ChangeState) in any of the  special states will update the player's current state number, but will not abort  processing of the special states. After all the state controllers in the special  states have been checked, the player's current state is processed, again from  top to bottom. If a state transition is made out of the current state, the rest  of the state controllers (if any) in the current state are skipped, and  processing continues from the beginning of the new state. When the end of the  current state is reached and no state transition is made, processing halts for  this tick.


每个游戏时间的tickMUGEN会检查这三个特殊的state。检查的顺序是-3,-2,-1。若是在这个检查过程中,若有碰到状态控制器,那麼就评估它的触发条件,如果符合触发条件,就执行执行控制器要控制的内容。然後执行程序到这个state的下一个状态控制器。在这三个特殊state的一个state的转换(ChangeState)会更新人物目前的state number,但是不会更新特殊states的执行动作。在三个特殊state的所有状态控制器都检查完以後,会执行人物目前的sate,然後又检查-3,-2,-1,一直重复这样的动作。如果目前的state里有更换state的动作(ChangeState)那麼目前这个state的其他状态控制器会被跳过不执行,而是会接下去执行新的State的开头。若是执行完目前的state而且没有更换state的动作的话,那麼这个tick的工作就结束了。

There is one exception to the above  scenario. If the character is a "helper" character, i.e., spawned by 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. (This is controlled by the Helper state controller when  the character is created.)

以上的说明有一个例外的情形。如果人物是一个”helper”角色,也就是经由Helper状态控制器所产生的人物,那麼这个helper就没有state 3,-2。这个helper也不会有state 1除非它允许玩家操作(这要在这个Helper建立时透过Helper状态控制器来设定)

Note for the technically minded: A  character's state machine might be considered an "impure" FSM, since there are a  number of implicit state transition rules which are not user-specified. For  instance, hitting the character causes a state transition which is not  explicitly coded into the character's CNS. Furthermore, a single CNS state is  usually much more complex than a state in a typical FSM as considered in  mathematics or computer science. In any case, you will not find the rigorous  definition of an FSM especially applicable to working with MUGEN.

技术层面的提醒:人物的state机制也许看起来是一种不清楚的FSM,因为有一些隐藏的状态转换规则没有办法由使用者指定。例如,击中一名人物所造成的状态转换方式没办法在CNS里头设定。还有,单一的CNS state通常比符合数学和电脑科学的标准FSM来的复杂。不管从那个角度来看,你会发现,使用FSM的观念来制作MUGEN的人物会比较容易。


III.b. 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.

CMD档包含指令名称的宣告和State 1的定义(State 1用於控制当玩家输入指令时,所操作的人物会有什麼要的反应),若需要更详细的说明,请参考CMD文件。

Here are some concepts that will be useful  for you to know:

1. Life and power

2. Control

3. Game-time and state-time

4. Position, velocity and acceleration  

5. Juggling  

译注:Juggling这个字译者想不出应该翻成什麼,以下是查字典的意思,请读者自行揣摩它的意思吧…:p=====1. 杂耍;戏法2.  玩花招;欺骗

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

1. 生命和气

人物的生命棒(life bar)是在萤幕上方那一条黄色的棒,当生命棒下降到零的话,就表示您所操作的人物被击倒啦!


2. Control

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.

2. 操作


There is an exception to the rule, however.  Sometims 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.


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

3. 游戏时间和状态时间



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

4. 位置、速度和加速度







5. Juggling

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 5  juggle points could theoretically be used to juggle the opponent twice, 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.

5. Juggle

MUGEN有一套Juggle系统可以让你攻击已被击上空中的对手或是还躺在地上的对手。我们可以设定juggle points,内定值是15,每次人物进入掉落(fall就例如当人物被打离地面时,并不会恢复可操作状态,而会一直掉落得地面)状态时开始计算。如果人物在空中或是在还躺在地上时被攻击juggle points就会持续下降,而当攻击对方所需要的juggle  points比对方剩馀的还要多时,这次的攻击就会miss掉。任何会使对手进入掉落状态的动作,从刚击中对手时juggle  point就会开始减少。

例如,人物有5juggle点数,有一个需要2juggle  point的攻击动作理论上可以让你击中对方两次,直到对手剩下一个juggle point,接下去的攻击会miss


By Bwhite



III.c. 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.  



III.d. 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 parameters:

1. type

2. movetype

3. physics

4. anim


1. type(型态)

2. movetype(动作型态)

3. physics(物理型态)

4. anim(动画)

1. type

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). 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:

1. type


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.


2. movetype

This is the type of move P1 is doing: "A"  for attack, "I" for idle and "H" for being hit. 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:

2. 动作型态


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.


3. physics

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. If omitted, the value of "N" is assumed. The kind of physics is used  to determine how P1 behaves.

3. 物理型态


For "S" physics, P1 will experience friction  with the ground. The value for the friction coefficient is set in the Player  Variables (see section II).


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.  




4. anim

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.

4. 动画


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

The other optional parameters that you can  use are:

4. velset

5. ctrl

6. poweradd

7. juggle

8. facep2

9. hitdefpersist

10. movehitpersist

11. hitcountpersist


4. velset

5. ctrl

6. poweradd

7. juggle

8. facep2

9. hitdefpersist

10. movehitpersist

11. hitcountpersist

4. velset

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.


velset = 4,-8



5. ctrl

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



ctrl = 1

6. poweradd

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



7. juggle

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. Juggling was explained in detail in "Useful  Concepts" in Section IIIa.


8. facep2

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.



9. hitdefpersist

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.



10. movehitpersist

If set to 1, the move hit information from  the previous state  

(whether the attack hit or missed, was  guarded, etc.) will be  

carried over into this state. If set to 0  (the default), this  

information will be reset upon entry into  this state.  



11. hitcountpersist

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.


如果设为”1,则击中计数(计算这一次的攻击击中几次)会保存之前state的击中计数值,如果设为”0,则再变换state後,击中计数的值会重置。这个值并不会影响连续攻击计数器(combo counter,就是在画面上显示的那个连续攻击的计数直)。


III.e. Details on State Controllers  


d.1 Controller Format

d.2 Triggers

d.3 Commonly-used controllers

III.d.1 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 the section on trigger persistency.



Persistency parameters,这一部份请参阅trigger文件)

The 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, ie. 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".  

在这个例子里,ctrlset状态控制器让您能改变P1的可操作旗标。”trigger1=Time=0这一行表示当状态时间等於0的时候,作动ctrlset控制器,也就是在这个状态开始的时候就作动ctrlset控制器。”value = 1这一行表示我们要让操作旗标改为”1,也就是”真”。如果我们要让P1在状态开始时无法操作,只要把改成”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.


III.d.2 Triggers


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



1. 所有的”trigger1是否为”true”,若是,则作动控制器。

2. 否则,重复测试”trigger2,trigger3…。直到没有其他的触发器。


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 the  "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? = trigger_type trigger_test  

trigger_type is the name of the trigger (see  triggers.txt for the full list).  

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. See exp.txt for a detailed explanation of  arithmetic expressions.


其中trigger type是触发器的名称(请参阅trigger.,txt,有完整的列表)。  



A useful shortcut you might use is  "triggerall". It determines a condition that must be true for all triggers. For  instance in:

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



ii. 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" paramter. 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.



III.d.3 Commonly-used controllers  

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

[State 200,1]是一个”ChangeState”控制器。如同字面意义,它改变P1的状态编号。”value”这个参数应该填入要变更呈的状态编号。”ctrl”这个选择性参数可以设定当状态改变时P1的可操作旗标。

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 ;<-- "I" 改成 "A"

ctrl = 0

anim = 200

velset = 0

[State 200, 1] ;<-- 增加状态控制器

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.


L1: type = HitDef

L2: 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.


L3: 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


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



attr = arg1,arg2


-arg2是两个字元的字串。第一个字元可以是”N=normal, S= special ,or H=hyper(super”也可以)

第二个字元必须是”A=attack  ,T = throw P =  projectile

L4: 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.

设定P2被击中时要显示什麼要的动作。可以选择”light ,  medium , hard,或是”back”。前三个比较容易了解。”Back”是当P2被双脚(双钮重击击)击中时使用。

L5: 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 will do 1 point of damage if guarded.

P2被击中受到的伤害,如果防御就不会有伤害。如果我们把这列改成”damage= 10 ,1第一个数字表击中後的伤害,第二个表防御後的伤害。

L6: 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".

Guardflag”是设定P2如何防御这个攻击。在这里,可能是high(standing),low(crouching)和在空中。後面的参数必须是包含以下字元的字串:”H =  high ,L = low A =  AIR M(mid)  = HL

L7: 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.  


L8: 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.

画面显示的 击中/防御 爆点位置。使用格式要是”x, y”,其中x是相对於P2的前面。若x是负的值表示爆点会更深入P2Y值则是相对於P1Y值是负的会让爆点可高。

L9: 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".  

击中的声音(从fight.snd)。可以选择5,0(轻击)到5,4(重击)。若要使用您自己的声音档,请在前面加上”S”,例如”hitsound = S1,0

L10: 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".


L11: ground.type = High

This is the kind of attack for ground  attacks (it also defaults to air attacks if you do not have "air.type = ?"). 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 that 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".

地面攻击的种类(如果您没有 air.type = ? ,那ground.type 就当作air.type的内定值)。在这里,是一个轻攻击。选择”High”表示击中让P2头往後仰 ,或是选择”None”让P2没有反应。如果AnimType是”Back”那麼”High”和”Low”攻击对P2都是相同的。

L12: 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.


L13: ground.hittime = 15

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


L14: 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".

如果P2正站或蹲在地面,P2被击中後的初始X速度。如果您想要把P2击上空中,您可以指定Y速度当作第二个参数。例如 ground.velocity = -3 , -2

L15: 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 sctrls.txt for details.



III.f. Common states (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 Appendix A, Special State Controller Numbers.


stcommon = common1.cns ;Common states  


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.

请记住若是您覆盖的特殊的stateMUGEN有一些特别的特性,则您自行定义的新states也要有相同的特性。例如,跑步的state(state  100)要设定人物跑步的动作,所以您自己定义的新state也要设定人物的速度。

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 改成向前冲

[Statedef 100]

type = S ;在地面上跑

physics = N ;

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.

在这里我们假设Action 100使有限循环时间的。在[Velocity]里的”run.fwd”并非真的忽略,而是[State 100,1]把原先的X速度改成6


IV. Expressions



MUGEN has support for expressions in both  the CNS and the CMD files. This section will briefly cover some examples of  expressions. Don't take this for a thorough reference; it is only a quick guide  to get you started. For a complete explanation of expressions, please refer to  the expressions documentation (exp).


Expressions allow you to use a trigger as  the value of a parameter. The following example increases the x-position of the  player by a value that is equal to his state time.


[State 200, 1]

type = PosAdd

trigger1 = Time = 0

x = Time

Simple arithmetic is also possible using  expressions. Some basic arithmetic operators are:


+ addition

- subtraction

* multiplication

/ division

[State 200, 1]

type = VelSet

trigger1 = 1 ;Note: this is logically  equivalent to  

x = Time + 4 ;"trigger1 = Time >= 0"  

Expressions in state controller parameters  are evaluated at runtime, meaning that every time a state controller with a  parameter containing an expression is executed, the parameter's value is  recalculated during that instant. In the example above, the player's x-velocity  is recomputed for every frame that he stays in state 200.


The order of evaluation generally  left-to-right, but with multiplication and division taking precedence over  addition and subtraction. For example, in an expression 5 + 6 / 2, the result is  8. To force the addition to take place before the division, you can add in  parentheses, ie. (5 + 6) / 2, which gives a result of 5.5.

先乘除,後加减。 先作刮号内,在作刮号外。(与一般的数学计算相同观念)

Expressions may also be used in the trigger  line. These expressions are evaluated every time the trigger is checked. This  next example changes the player's state when his state time is greater than the  value stored in the variable var(1).


[State 200, 1]

type = ChangeState

trigger1 = Time > var(1)

value = 201

Variables may also take expressions, as seen  below.


[State 200, 1]

type = VarSet

trigger1 = Time = [1,5]

var(Time) = Time * 2

Logical operators may also be used. || is  used for "or", and && for "and". For example, this changes the player's  state when his state time is greater than 90, and his animation has ended.  


[State 200, 1]

type = ChangeState

trigger1 = Time > 90 && AnimTime  = 0

value = 0

The trigger line above is logically  equivalent to these two lines:


trigger1 = Time > 90

trigger1 = AnimTime = 0

&& takes precedence over ||.  Whenever you use more than one logical operator in an expression, try to use  brackets for clarity. It's not required, but it makes it easier to understand.  For instance:


trigger1 = ((Time > 90) &&  (AnimTime = 0) || (var(2) = [5,9]))

Not all parameters support expressions.  Typically, those that are of a non-numeric type do not support expressions. For  example, this is an illegal construct:


[State 300, 5]

type = HitDef

trigger1 = Time = 0

ground.type = High && Low ; <--  illegal -- non-numeric types!


Appendix A. 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. State numbers labeled "reserved" should not be used, as  they may be assigned special functionality in a later version of MUGEN.  


Number Description

------ -----------

0 Stand

10 Stand-to-crouch

11 Crouching

12 Crouch-to-stand

20 Walk

To be finished.