Tutorial sobre troca de

animações e states

Escrito por SonSon3000

(Emerson Moises Reis Manfron)
 3

Conhecendo os SCTRLs e Triggers ............................................................................. 4

S1.SCTRL – ChangeAnim ................................................................................................................... 4
S2.SCTRL – ChangeAnim2 ................................................................................................................. 4
S3.SCTRL – ChangeState ................................................................................................................... 4
T1.TRIGGER – Time............................................................................................................................ 5
T2.TRIGGER – Anim............................................................................................................................ 5
T3.TRIGGER – AnimTime.................................................................................................................... 6
T4.TRIGGER – AnimElem ................................................................................................................... 6
T5. TRIGGER – AnimElemTime .......................................................................................................... 7
T6. TRIGGER – AnimElemNo.............................................................................................................. 7
T7. TRIGGER – SelfAnimExist............................................................................................................. 7
T8. TRIGGER – StateNo...................................................................................................................... 8
T9. TRIGGER – PrevStateNo .............................................................................................................. 8

Algumas lógicas usando os SCTRLs e Triggers .................................................. 9

L1. LÓGICA - Usando 2 (dois) ou mais ChangeAnim: ......................................................................... 9
L2. LÓGICA - Usando ChangeAnim privados .................................................................................... 10
L3. LÓGICA - Usando ChangeAnim2 privados .................................................................................. 10
L4. LÓGICA - Executando um SCtrl num determinado tempo (em time) ........................................... 11
L5. LÓGICA - Executando um SCtrl num determinado tempo (em AnimElem/AnimElemTime) ........ 11
 4
Conhecendo os SCTRLs e Triggers
S1.SCTRL – ChangeAnim
O SCtrl ChangeAnim é usado para trocas de animações num StateDef específico.
Há vários exemplos de como o usar, e para quê o usar.

Um exemplo bem simples do ChangeAnim:

[State 0, ChangeAnim]
type = ChangeAnim
trigger1 = !time
value = 0
elem = 1

Esse Sctrl tem apenas dois “comandos” abaixo do trigger, que são os Value e Elem.
O Value indica a animação do Air para qual o StateDef irá.
O Elem indica qual AnimElem (que será melhor visto ao decorrer do tutorial) da animação, irá começar a mesma.

ERRO: Quando for usar o SCtrl ChangeAnim, certifique-se que a animação em que você se refere, realmente exista.
Caso contrário o char retornará um erro no Debug do Mugen, e repetirá a ultima animação, até que o char entre numa
animação que realmente exista.

S2.SCTRL – ChangeAnim2
O Sctrl ChangeAnim2 age de forma parecida com o ChangeAnim, mas tem uma única diferença:
- O ChangeAnim procura pela animação do personagem, enquanto o ChangeAnim2 procura pelos sprites do oponente
(em custom states) que fazem essa animação.

Vamos supor que há uma anim com os grupos de sprites:

-5000,0
-5000,10
-5010,10

O ChangeAnim2 iria procurar esses grupos de sprites no oponente, e refazer a animação com os mesmos.

OBS.: Se o oponente não tiver algum(ns) do(s) sprite(s), esse(s) sprite(s) “faltante(s)” não aparecerá(am) na execução
da animação.

ERRO: Se você usar o Sctrl ChangeAnim2 num custom state, sempre o ajuste para usar os sprites que qualquer outro
char possa ter (como por exemplo, as get hits requeridas), para a animação ser executada corretamente. Ou então,
limite no cns, para apenas alguns chars que você tenha certeza que terão os sprites requeridos pela sua animação.

S3.SCTRL – ChangeState
Assim como o ChangeAnim foi feito para trocar de animação, o ChangeState foi feito para trocar de StateDef.

Um exemplo bem simples do ChangeState:

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

Esse Sctrl tem apenas dois “comandos” abaixo do trigger, que são os Value e Ctrl.
O Value indica a qual StateDef do CNS, o char irá.
O Ctrl indica que quando o char for para tal StateDef, se ele vai ser controle sobre si mesmo ou não (muito útil para caso
você queira fazer um StateDef, sem que outros StateDefs atrapalhem a execução do mesmo).

ERRO: Ao usar o SCtrl ChangeState, tenha certeza de indicar a ele, um StateDef que realmente exista. Caso contrário
será retornado um erro no Debug, e o char continuará no StateDef anterior.
 5
T1.TRIGGER – Time
Esse trigger foi usado nos exemplos de SCRTLs: ChangeAnim e ChangeState.
E o mesmo, tem a utilidade de fazer qualquer SCtrl ser executado dependendo do tick* exato de um StateDef (definido
pelo char maker**).

*Quadros por segundo (por padrão o mugen tem 60 ticks num segundo).
**A pessoa que programa chars para o mugen.

Vamos usar um exemplo, no qual o SCtrl Null seria executado no 6º tick do StateDef:
[State 200, Null]
type = Null
trigger1 = time = 5

Como você pode ver, quando quisermos fazer um SCtrl ser chamado no 6º tick, botamos time = 5.
“Por que?”
Porque o esquema de time do mugen é assim:
time = tempo em tick -1

Veja a Figura T1.1:

Figura T1.1
Tabela de tempo comparativo de ticks.
Onde N seria um numero qualquer.

Lembrando que pode-se usar os sinais > (maior que), < (menor que), >= (maior ou igual), <= (menor ou igual), e
!= (diferente de).

Obs: Se você quiser que algo seja executado no primeiro tick, seria time = 0, ou simplesmente, !time.
Quando você usa o !time, indica que o time não existe, sendo assim ele é falso, e sendo falso, ele é igual a zero.
(para saber mais, informe-se sobre valores Booleanos)

T2.TRIGGER – Anim
Esse trigger, tem a utilidade de fazer um SCtrl ser executado, se a Anim que o char maker indicou, seja verdadeira.

Exemplo:
[State 200, ChangeAnim]
type = ChangeAnim
trigger1 = Anim = 230
value = 210
elem = 1

Esse exemplo diz, que se a Animação do char for 230, o StateDef irá para a Anim 210.
 6
T3.TRIGGER – AnimTime
O trigger AnimTime, serve para informar, quando o tempo total da animação, estiver acabado.
[State 200, ChangeAnim]
type = ChangeAnim
trigger1 = !AnimTime ; Ou AnimTime = 0
value = 210
elem = 1

Aqui diz, que se a animação do StateDef estiver acabado, vai para a Anim 210.

Se AnimTime, for maior que zero, como por exemplo AnimTime = 5, ele fará o Sctrl ser executado 5 ticks depois de
acabada a animação.

Se AnimTime, for menor que zero, como por exemplo AnimTime = -5, ele fará o Sctrl ser executado 5 ticks antes de
acabar a animação.

Ou seja, se AnimTime for AnimTime = 10, seria basicamente igual a isso:

time = (tempo total da anim) + 10

Lembrando que aqui também pode-se usar os sinais >, <, >=, <= e !=.

T4.TRIGGER – AnimElem
Esse trigger, é um dos mais usados quando se fala sobre “Quadros de Animação e o Tempo dos mesmos”.
Caso você não tenha entendido, o AnimElem serve para fazer um SCtrl ser executado, se o Quadro de Animação for o
que o char maker queira.

Veja a Figura T4.1

Figura T4.1
Quadro de AnimElem, onde o primeiro sprite da animação é sempre o AnimElem 1.

Exemplo:
[State 200, ChangeState]
type = ChangeState
trigger1 = AnimElem = 3
value = 235
ctrl = 1

Esse trecho de código, diz que quando a Animação estiver no seu 3º quadro de animação, o char irá para o
StateDef 235.

O AnimElem tem a opção além de fazer com que algo seja executado num exato quadro, também seja num exato tick
de um quadro de animação.

Exemplo:
[State 210, ChangeState]
type = ChangeState
trigger1 = AnimElem = 5,= 2
value = 215
ctrl = 1

Veja o AnimElem = 5, logo mais para a esquerda tem uma , (vírgula) e = 2.

Isso significa que o char irá para o StateDef 215, quando estiver no 3º tick do 5º quadro da anim.
 7
Basicamente o AnimElem é feito disso:
AnimElem = (Quadro da Animação), = (time)

OBS.: Quando time não existir, ele será igual a 0 (primeiro tick).

Lembrando que no time do AnimElem pode-se usar os sinais >, <, >=, <= e !=.

T5. TRIGGER – AnimElemTime

O trigger AnimElemTime, é muito semelhante ao AnimElem (devido ao fato de ser uma variação do mesmo), no
quesito funcionalidade.

Se no AnimElem é assim:
AnimElem = 3, =2

No AnimElemTime seria assim:

AnimElemTime(3) = 2

Ou seja:
AnimElemTime(Quadro da Animação) = (time)

Não temos muito o que aprender sobre esse trigger, porque ele é muito semelhante ao AnimElem comum.

T6. TRIGGER – AnimElemNo

Esse trigger é uma outra variação do AnimElem, mas seu funcionamento é um tanto diferente, dos dois triggers acima.

Exemplo:
[State 200, VarAdd]
type = VarAdd
trigger1 = AnimElemNo(0) = 1
var(10) = 5

Esse exemplo, VarAdd irá incrementar a var(10) de 5 em 5, a cada tick do AnimElem 1.

Onde isso:
AnimElemNo(0) = 1

Seria equivalente à:
AnimElem = 1, >= 0 && AnimElem = 2, < 0

Ou então à:
AnimElemTime(1) >= 0 && AnimElemTime(2) < 0

Simplificando, o número entre parênteses é o tick do elem e depois do sinal de igual, o elem em si.
AnimElemNo(time) = elem

O AnimElemNo, faz um SCtrl ser executado a partir do time do elem, até o ultimo time do mesmo elem.

T7. TRIGGER – SelfAnimExist

Esse trigger informa o mugen, se uma anim realmente existe no char.

Código:
[State 0, ChangeAnim]
type = ChangeAnim
triggerall = SelfAnimExist(5325)
trigger1 = !time
value = 5325

Esse código é simples, ele apenas checa no char se a animação 5325 existe, se ela existir, o SCtrl ChangeAnim será
executado e mudará a animação do char para a animação 5325.
 8
T8. TRIGGER – StateNo
O trigger StateNo, é um trigger que retorna o StateDef atual do char (usado muito em ativações de vars,
nos StateDefs -1 (CMD) -2 e -3 (CNS), por exemplo).

Um exemplo do uso dele, no StateDef -2 (mas que pode ser usado nos -1 e -3 também):
[state -2, VarSet]
type = VarSet
trigger1 = StateNo = 1200
var(10) = 5

Aqui nesse exemplo, se o char estiver no StateDef 1200, a var(10) será igual a 5.

Lembrando que pode-se usar os sinais >, < , >= , <= e !=.

ERRO: Se você por algum descuido, deixar algum trigger com o StateNo igual a um StateDef não existente, o SCtrl não
executará, pelo motivo que esse StateDef não será executado, se ele não existir.

T9. TRIGGER – PrevStateNo

O PrevStateNo, é similar ao trigger StateNo, mas retorna o StateDef anterior ao o que está sendo executado.

Exemplo:
[state 210, VarSet]
type = VarSet
trigger1 = PrevStateNo = 200
var(10) = 2

Neste exemplo, o SCtrl está no StateDef 210, e diz que a var(10) será igual a 2, se o StateDef anterior ao o que está
sendo executado, tiver sido o StateDef 200.

Lembrando que pode-se usar os sinais >, < , >= , <= e !=.

ERRO: Assim como no trigger StateNo, ao ser conferido um PrevStateNo onde um StateDef não exista, o SCtrl não
será executado, pelo motivo em que esse StateDef nunca será o anterior, porque o mesmo não existe.
 9
Algumas lógicas usando os SCTRLs e Triggers
L1. LÓGICA - Usando 2 (dois) ou mais ChangeAnim:
Vamos supor que o char tenha que executar duas animações dependendo do que o jogador estiver fazendo com ele.
Que nem num power change, onde o char carrega suas barras de level. Então, quando o jogador estiver executando o
comando, o char executará uma animação e quando soltar o botão, executará outra animação.
Geralmente makers fazem isso usando dois StateDefs, enquanto poderia usar apenas um, com dois ChangeAnim.

Código:
[State 700, Animação do char executando o Power Charge]
type = ChangeAnim
trigger1 = command = “hold_c”
value = 700

[State 700, Animação do char parando de executar o Power Charge]

type = ChangeAnim
triggerall = Anim = 700
trigger1 = command != “hold_c”
value = 705

Neste código não colocamos o elem embaixo de value, por que caso o elem não seja atribuído, ele será igual a 1.
Agora à explicação do código em si:
- Quando o comando hold_c estiver sendo pressionado, a animação do personagem será 700;
- Quando o comando hold_c não estiver sendo pressionado (que nesse caso, está sendo solto), a animação do
personagem será 705.

Mas preste atenção na linha em negrito do código.

Aquele triggerall com a animação anterior à 705, é obrigatório quando uma animação está vindo após a outra, num
mesmo StateDef. Caso contrário, o char travará, e nunca sairá da animação.

Logo após ter feito os dois ChangeAnim, faremos o ChangeState retornando ao StateDef “base” do personagem (sua
pose de luta, sem estar fazendo nenhuma ação):
[State 700, Voltando ao State Base]
type = ChangeState
trigger1 = Anim = 705
trigger1 = !AnimTime
value = 0

Preste bem atenção nas linhas em negrito. Se você prestou bem a atenção no código, verá que o ChangeState só será
executado, logo após a animação 705 ter acabado.

Ficando os três SCtrl juntos, seria assim:

[State 700, Animação do char executando o Power Charge]
type = ChangeAnim
trigger1 = command = “hold_c”
value = 700

[State 700, Animação do char parando de executar o Power Charge]

type = ChangeAnim
triggerall = Anim = 700
trigger1 = command != “hold_c”
value = 705

[State 700, Voltando ao State Base]

type = ChangeState
trigger1 = Anim = 705
trigger1 = !AnimTime
value = 0
 10
Onde: Se o comando for feito, a animação 700 será executada.
Quando o comando for desfeito após ter começado (quando estiver na Animação 700), o char vai para a animação 705.
Quando a animação 705 chegar ao fim, o ChangeState levará o char ao StateDef 0.

L2. LÓGICA - Usando ChangeAnim privados

ChangeAnim privados geralmente são usados em intros/vitórias especiais, ou em “custom anims” (que diferente do
ChangeAnim2, o custom state chamaria a animação do oponente, e não os sprites do mesmo).

E para não causar bugs em custom anims:

[State 6100, Custom Anim]
type = ChangeAnim
triggerall = SelfAnimExist(6100)
trigger1 = !time
value = 6100

[State 6100, Normal Anim]

type = ChangeAnim
triggerall = !SelfAnimExist(6100)
trigger1 = !time
value = 5000

Neste código, o oponente iria para a animação 6100, caso a mesma existir no *.air do oponente.
Caso contrário, iria para a animação 5000.

L3. LÓGICA - Usando ChangeAnim2 privados

Geralmente, quando vamos usar custom states, usamos o ChangeAnim2 pra fazer uma animação
customizada/personalizada.
Mas infelizmente muitos chars não terão os sprites (dependendo do tipo de custom state) que necessita a anim do
ChangeAnim2.

Então para também não causar bugs, podemos “privar” o ChangeAnim2 para chars que temos certeza que tem os tais
sprites requeridos.

Exemplo:
[State 6200, Custom Anim – Para os chars Ryu,Ken,Sub-Zero e Scorpion]
type = ChangeAnim2
triggerall = !time
trigger1 = P1Name = “Ryu”
trigger2 = P1Name = “Ken”
trigger3 = P1Name = “Sub-Zero”
trigger4 = P1Name = “Scorpion”
value = 6200

Esse exemplo executa o ChangeAnim2 no momento exato de inicialização do StateDef, e quando o oponente se
chamar Ryu, Ken, Sub-Zero ou Scorpion.

Obs.: Você poderá adicionar triggers com números diferentes, iguais a enemynear,name = “nome do oponente”.
PS.: Nos triggers você pode notar que está sendo usado o termo P1Name. A resposta disso é simples, esse
ChangeAnim2 está dentro de um custom state, logo o oponente executará esse custom state como se fosse um
StateDef dele.
E para o char se “auto-reconhecer” é usado o trigger P1Name.
 11
Mas privando o ChangeAnim2 dessa forma, quando o oponente não se chamar Ryu, Ken, Sub-Zero ou Scorpion, ele
ficará sem animação, travado no custom state.

Então teremos que criar uma animação no ChangeAnim para os personagens que não são os que o ChangeAnim2
procura:

[State 6200, Custom Anim – Para outros chars]

type = ChangeAnim
triggerall = !time
trigger1 = P1Name != “Ryu”
trigger1 = P1Name != “Ken”
trigger1 = P1Name != “Sub-Zero”
trigger1 = P1Name != “Scorpion”
value = 5000

Nesse exemplo, se os chars se chamarem Ryu, Ken, Sub-Zero ou Scorpion, será executado o
ChangeAnim2 com a animação 6200, caso contrário será executado o ChangeAnim com a animação 5000.

L4. LÓGICA - Executando um SCtrl num determinado tempo (em time)

Para fazer acontecer isso, usaremos time maior que valor mínimo e time menor que valor máximo.

Então, seguiremos o exemplo:

[State 200, Soco do char]
type = ChangeAnim2
triggerall = Anim != 200
trigger1 = time >= 0 && time <= 10
value = 200

Esse simples exemplo diz que quando o time for maior ou igual a 0 (primeiro tick em diante) e menor ou igual a 10
(décimo primeiro tick pra menos), fazendo que o SCtrl seja executado apenas nos primeiros 11 ticks do StateDef.
Já o triggerall ta dizendo que a animação 200 só será executada, quando a mesma não estiver sido executada antes.

L5. LÓGICA - Executando um SCtrl num determinado tempo (em AnimElem/AnimElemTime)

Isso é útil para se fazer algo acontecer entre um AnimElem e outro, ou entre um tick do AnimElem e outro.
[State 200, Soco do char]
type = ChangeAnim2
triggerall = Anim != 200
trigger1 = AnimElem = 3, >= 0
trigger1 = AnimElem = 6, <= 4
value = 200

Isso faria que a Animação estivesse sendo executada entre o AnimElem 3 no primeiro tick, e entre o 5 tick do
AnimElem 6.

Isso em AnimElemTime seria assim:

[State 200, Soco do char]
type = ChangeAnim2
triggerall = Anim != 200
trigger1 = AnimElemTime(3) >= 0
trigger1 = AnimElemTime(6) <= 4
value = 200