Command

A command is a sequence of player inputs, typically used to perform special moves.

M.U.G.E.N

M.U.G.E.N provides an implementation for a command parser as well as a buffer. However, both of these have problems.

Command Parser

M.U.G.E.N's command parser has a bug where non-cardinal directions (DF, UB, DB, etc.) will be counted as valid if the individual elements are mashed out[1]. As such, any buffering systems that rely on M.U.G.E.N's command parser for anything other than buttons and cardinal directions (such as Tiny Buffering) will also suffer from this same problem. Deep Buffering solves this issue[2].

Direction charging (which is used for moves such as Guile's Flash Kick and Sonic Boom) is also bugged. In M.U.G.E.N, there is only one variable for the hold timer, regardless of directions. Using Sonic Boom as an example:

[Command]
name = "CB,F,x"
command = ~60$B, F, x
time = 12

Because only one variable is used (rather than one for each direction), this means a player can hold forward for 60 ticks, then quickly input B,F,x to complete the move. For this reason, many developers implement charge timers themselves.

Like Tiny Buffering, a time window encompassing the entire command is used to determine when the entire command sequence input by the player is valid. As long as the entire sequence is completed within this time window, the command is considered valid. This is similar to some commercial implementations. This is defined by the `time` parameter in the command definition.

Command Buffering

M.U.G.E.N's command buffering is limited, but it does do what is expected. When a command is input, it is considered valid for the number of ticks specified in the `buffer.time` parameter of the command. After that, the command is no longer considered active.

Syntax

M.U.G.E.N allows up to 128 unique commands to be defined. The M.U.G.E.N command syntax is very simple and consists of the following tokens:

• Directions: U,UB,B,DB,D,DF,F,UF
• Buttons: x,y,z,a,b,c,s
• Special tokens: /, ~, $, +, >

The format for a command is as follows:

[Command]
name = some_name
command = the_command
time = time (optional)
buffer.time = time (optional)

Strings in commands (both for the name and the command definition) are case-sensitive. This means that "QCB_a" is not the same as "Qcb_a," and having both means that two separate commands are created. Additionally, B (back) is not the same as b (B button).

Special Tokens

/

The / token indicates that the input that immediately follows must be held.

~

The ~ token indicates that the input that immediately follows must be released. This is typically used for Negative Edge commands.

$

The $ token has two uses: defining 4-way directions, and charge motions. A $ followed by a direction indicates that any input that contains that direction will be interpreted as valid. So for instance, $D is valid when the player inputs D, DF, DB, and indeed, DU (even though this is not technically possible on a joystick, it can be done on hitboxes).

+

The + token indicates that two or more inputs must be active at the same time in order for it to register as valid. a+b for instance indicates that a and b must both be pressed at the same time. This, however, does not work for multiple button negative edge (release) commands, so ~a+~b will not work and requires additional logic, usually implemented in a custom buffering system.

Corrections

The M.U.G.E.N CMD documentation makes the following suggestion:

It is recommended that for most "motion" commads, eg. quarter-circle-fwd, you start off with a "release direction". This makes the command easier to do.

However, this is incorrect, at least for Capcom games. In Capcom games, the first direction is always a hold. This is done so that commands input while walking will still work.

Negative Edge

Negative Edge refers to a mechanic in Capcom games where the final input for a special command can be a press or release. For example, in Street Fighter II, Ryu can execute a Hadouken when the player inputs either /D,DF,F,x or /D,DF,F,~x. This was done in order to make executing special commands easier, though when combined with the fact that each basic move allows the user to "cancel" their basic into a special anytime before the first attack box is displayed, this results in the unintentional side effect of having "cancel combos," often referred to simply as "cancels." While Negative Edge is not required for cancels to work, it does make them easier for the player to execute.

Later games which have commands requiring two or more button presses to work (such as the ES and EX commands in the Vampire series and EX commands in the Street Fighter III series) can be activated when either of the buttons is pressed or released. Thus, /D,DF,F,x+y, /D,DF,F,~x+y, /D,DF,F,x+~y, and /D,DF,F,~x+~y will all lead to the same result. However, M.U.G.E.N's command parser does not interpret these release variations, so the developer must implement multiple button Negative Edge themselves. Deep Buffering and Drunk-Fu both handle this scenario.

While it is typically in Capcom fighting games (with the exception of Marvel vs. Capcom 3 and Ultimate Marvel vs. Capcom 3), the Guilty Gear games also utilize Negative Edge.

See Also

• Tiny Buffering
• Deep Buffering