Mugen-México III Rematch

Todo lo referente a este motor de peleas en 2d en españoll
 
ÍndicePortalCalendarioFAQBuscarRegistrarseConectarse

Comparte | 
 

 Traducción de los cns por "Villena"

Ver el tema anterior Ver el tema siguiente Ir abajo 
AutorMensaje
shammahomega
Admin
Admin
avatar

Mensajes : 643
Fecha de inscripción : 23/01/2010

MensajeTema: Traducción de los cns por "Villena"   Dom Ene 31 2010, 11:26

"El formato cns" 1ra parte.

El formato CNS
==============
M.U.G.E.N, (c) Elecbyte 2002
Documentación para la versión 2002.04.14

Documentación para la Publicación Beta (Incompleta)
Actualizada el 8 de Enero del 2002


====================================================================
0. Contenidos
====================================================================
Sección I. Introducción
Sección II. Variables del Player
Sección III. States (Estados)
Sección IV. Expresiones
Apéndice A. Números especiales de States



====================================================================
I. Introducción
====================================================================

¿Qué es el archivo CNS?
-----------------------
El archivo CNS de un player sirve para dos propósitos:

1. Define las variables de ese player, tales como la velocidad al caminar, factor de escala del
dibujo y otras cosas más.

2. Contiene los states de un player, el cual describe todos los movimientos que el player puede
hacer. Los States son los ladrillos con los que construyes movimientos simples como también
complicados.

Como muchos otros archivos de chars, el CNS es un archivo de texto que puedes editar con cualquier
editor de texto.

En el archivo CNS, un punto y coma es considerado como un caracter de "comentario". Cualquier
texto en la misma linea después de un punto y coma será ignorada por el programa.

El CNS no distingue entre mayúsculas y minúsculas. Por ejemplo, "MiNombre" es igual que poner
"minombre" y "mInOMBe".

La única excepción es el "comando" (command) Trigger (gatillo, iniciador), pero no tienes que
preocuparte de eso por el momento.

Algo de Terminología.
---------------------
Cuando decimos "grupo" (group), nos referimos a cualquier bloque de lineas de texto que inicia
con algo parecido a esto [groupname] (nombregrupo), y al final antes del siguiente grupo.

Por ejemplo, el grupo "Blah" consiste en de tres primeras lineas en el siguiente orden:

[Blah]
line1
line2
[Group 2]
más lineas

Dentro de un grupo, los parámetros pueden aparecer en cualquier orden. Entonces,

[SomeGroup]
value1 = 1234
value2 = "A string" (Una cadena)

Es equivalente a:

[SomeGroup]
value2 = "A string"
value1 = 1234


====================================================================
II. Variables de Player
====================================================================

Aún no hay documentación completa. Ve el archivo chars/kfm/kfm.cns para leer los comentarios de
cada variable.

Algunas notas importantes:

- La variable [Size] (tamaño), puedes usar "xscale" y "yscale" para cambiar el Ancho y Alto de
tu char. Esto ahorra el problea de escalar cada uno de los sprites.
- Para ajustar la velocidad del player está la variable [Velocity].
- Para ajustar la disminución de aceleración de un char, coloca la instrucción "yaccel" en la
variable [Movement] (Movimiento)

====================================================================
III. States (Estados)
====================================================================
a. Perspectiva general de la "Máquina de Estado Finito" en los States en MUGEN.
b. Introducción a los States
c. Partes básicas de un State.
d. Detalles en un StateDef (Definiciones de Estado)
e. Detalles en los controladores de State
f. States comúnes (common1.cns)


--------------------------------------------------------------------------
III.a. Perspectiva general de la "Máquina de Estado Finito" en los States en MUGEN.
--------------------------------------------------------------------------

Para conocer más sobre el término "Máquina de Estado Finito", favor de visitar el link: http://es.wikipedia.org/wiki/Aut%C3%B3mata_finito http://en.wikipedia.org/wiki/Finite_state_machines

Esta sección representa un trabajo de comprensión sobre la "Máquina de Estado Finito" de los
States, que se encuentra en MUGEN.

Esto no es específicamente técnico, pero está enfocado al lector de mente analítica.
Siéntete libre de saltar toda esta sección si tu ya estás familiarizado con las "Máquinas de
Estado Finito", o si no estás interesado en los detalles.

Una "Máquina de Estado Finito" (Finite State Machine) (apartir de ahora MEF) es un autómata con
un limitado conjunto de subrutinas, cada una ejecuta una función y entonces emplea un criterio
a elegir, ya sea la siguiente subrutina o saltarla.

Cada subrutina es llamada "State" (Estado), y la MEF actúa en un State que se encuentra en proceso
de directivas en ese State. Una MEF sólo pude estar en un State en un momento dado.

Lo siguiente es un ejemplo trivial de una MEF, dado en un pseudocódigo.

State 0:
1. Lee (Read in) un número.
2. Si (If) el número es 0, ve (Go to) al State 0. De lo contrario (Else), ve al State 1.

State 1:
1. Imprime (Print) "Woohoo!"
2. Ve (Go to) al State 3.

State 2:
1. Ve (Go to) al State 0.

State 3:
1. Salir (Quit)

Se supone que esta MEF inicia en el State 0 y lee el valor 0. Entonces regresará al inicio del
State 0, y leerá otro número. Esto continuará hasta que el MEF lea un número distinto a cero,
al hacerlo, se irá al State 1.

En el State 1, la MEF imprime "Woohoo!" y entonces cambia al State 3. El State 3 hace que la MEF
salga. El State 2 nunca es alcanzado en este ejemplo.

Aquí hay un State fuera de un MEF el cual puede ser usado para un personaje de un juego de peleas.

State 555:
1. El Personaje intenta golpear al otro personaje.
2. Si se consigue con éxito el golpe, y el usuario mantiene presionado el botón de puño, ve al
State 555 (Movimiento en cadena).
3. Si se consigue con éxito el golpe, y el usuario no mantiene presionado el botón de puño,
comienza animación de recuperación.
4. Si no se consigue con éxito el golpe, comienza animación de golpe perdído.
5. Cuando la animación de recuperación o golpe perdído termina, ir al State 0.
5. When the recovery or miss animation ends, go to state 0 (State en reposo).

Los chars en MUGEN son Máquinas de Estado Finito. El archivo CNS de un char define un número de
States, los cuales contienen uno o más controladores de estados.

STATE CONTROLLERS
-----------------
Los controladores de States (State Controllers) son los que dan al char su funcionalidad,
similar a la instrucción que le dimos a nuestros chars en el MEF dado arriba, el controlador
HitDef permite al char golpear a su oponente, el controlador ChangeState permite al char hacer
una transición de State, y el controlador ChangeAnim permite al char hacer una animación
específica. Cada controlador de State es especificado junto con una o más condiciones de
prueba (Test Conditions), llamados "Triggers" o "condition-type triggers" (Gatillos/iniciadores
de tipo de condición), los cuales deben ser cumplidos en orden para que el controlador pueda ser
ejecutado.

SPECIAL STATES
--------------
Cada char de MUGEN tiene tres States especiales, numerados -1, -2, y -3.
Estos son los únicos states permitibles con números negativos.

State -1 generalmente contiene los controladores de State que determinan la transición de reglas
de State basadas en las entradas de un usuario (commandos).

State -2 contiene otros controladores de State que necesitan ser revisados cada segundo de juego.

State -3 contiene controladores de State los cuales son revisados cada segundo de juego a menos
que el jugador esté usando otro State de datos del jugador. (Por ejemplo, cuando el jugador está
siendo arrojado)

Para cada segundo de juego, MUGEN hace un simple paso através de cada State especial, del más alto
al más bajo, con tal de incrementar el número de State (-3, -2, y -1).

Para cada controlador de State encontrado, se evalúa su Trigger de tipo de condición y, si están
cumplidos, el controlador es ejecutado.

Entonces el procesamiento continua al siguiente controlador de State. Una transición de State
(ChangeState) en cualquier State especial actualizará el número de State actual del jugador,
pero no abortará el procesamiento de los States especiales.

Después de que todos los controlares de State en States especiales han sido revisados, el State
actual del jugador es procesado, de nueva cuenta del más alto al más bajo.

Si la transición del State es realizada fuera del State actual, el resto de los controladores de
State (si hay) en el actual State serán saltados, y el procesamiento continua desde el inicio de
un nuevo State.

Cuando el final de un State actual es alcanzado y la transición del State no está hecha, el
procesamiento se detiene en ese segundo de juego.

Hay una excepción a lo discutido arriba. Si un char es un char "ayudante" (helper), generado por
el Controlador de State Ayudante (Helper State Controller), ese char no tendrá los States
especiales -3 y -2. El char ayudante no tendrá el States especial -1, a menos que tenga habilitado
el control por medio del teclado.

(Normalmente el char Ayudante es controlado por el Helper State Controller cuando es creado)

Nota para los lectores de pensamiento técnico:
----------------------------------------------
Una máquina de estado de un char puede ser considerada como una MEF "impura", ya que tienen un
número implícito de reglas de transición de States los cuales no son especificados por el usuario.

Por ejemplo, golpear al char causa un State de transición el cual no es explícitamente codificado
en el CNS del char.

Además, un sólo State de CNS es por lo general mucho más complejo que un state en una MEF típica
como es considerada en las matemáticas o ciencias de la computación.

En cualquier caso, no encontrarás una rigurosa definición de una MEF específicamente aplicada al
trabajo con MUGEN


Última edición por shammahomega1 el Jue Ago 19 2010, 13:40, editado 2 veces
Volver arriba Ir abajo
shammahomega
Admin
Admin
avatar

Mensajes : 643
Fecha de inscripción : 23/01/2010

MensajeTema: Re: Traducción de los cns por "Villena"   Dom Ene 31 2010, 11:32

2da. parte
--------------------------------
III.b. Introducción a los States
--------------------------------

Programar States es la parte más difícil de crear un char. Esto implica mucho trabajo, probar,
y a veces ensayo y error.

En esta sección, nos referiremos a menudo al jugador siendo programado, así como a sus oponentes.
Llamemos P1 al jugador cuyos States estamos editando, y P2 a su oponente.

No te desalientes si no entiendes mucho de este documento si es la primera vez que lees.
La mejor forma de aprender sobre States es primero jugar con los valores en el CNS de char
, y ver qué efectos ocurren en el mismo.

No hay nada que temer al experimentar con el CNS; M.U.G.E.N está diseñado para detectar errores
de sintaxis y reportarlos.

Hay un char distribuido dentro de M.U.G.E.N llamado Kung Fu Man (KFM para abreviar).
Puedes encontrarlo en la carpeta CHARS/KFM.

El archivo CMD
--------------
Contiene declaraciones de nombres de comandos y definiciones del State -1,
un State especial el cual es usado para controlar cómo el personaje responde a las órdenes
del usuario.

Consulta el documento sobre CMD para más información.


Conceptos que serán útiles y que deberías conocer:
--------------------------------------------------

1. Vida y poder
2. Control
3. Tiempo de Juego (Game-Time) y Tiempo de Estado (State-Time)
4. Posición, velocidad y aceleración
5. Malabareando


1. Vida y poder (Life Bar y Power Bar)
---------------
La vida de un jugador es una barra amarilla en lo alto de la pantalla ubicada sobre él en su respectivo lado.
Cuando la barra de vida (Life Bar) alcanza Cero. El jugador es knoqueado.

Su barra de poder es la barra azúl, que incrementa con cada ataque que él da o recibe.
Cuando la barra de poder alcanza cierto valor, él puede realizar super movimientos (Super Moves).


2. Control
----------
Cuando decimos que el jugador "tiene el control", nos referimos que está listo para caminar,
saltar o atacar. Un jugador que no tiene el control, no responderá a la entrada (input) de órdenes
(del teclado o del joystick).

Por ejemplo, cuando P1 está en su State de pié, tiene el control, y caminará hacia adelante si
presionas el botón de avanzar. Un jugador no tendrá control cuando está en State de ataque, de
otra manera caminarías a través de un puño.


MOVE CANCEL
-----------
Hay una excepción a la regla.

A veces puedes permitir que el jugador responda a ciertos movimientos incluso si no tiene control.
A esto se le llama "interrupción de movimiento" (Move Interrupt) o una "Cancelación de Movimiento"
(Move Cancel). Para más información, consulta la documentación del archivo CMD.


CONTROL FLAG
------------
Frecuentemente nos referiremos al "Señalador de Control" de un jugador (Control Flag).
Un "Señalador" (Flag) es un valor que puede ser verdadero o falso. Si decimos que el señalador
de control del jugador es verdadero, significa que él tiene el control.


3. Tiempo de Juego (Game-Time) y Tiempo de State (State-Time)
------------------------------------------------
M.U.G.E.N mantiene marcado el tiempo que ha pasado en el juego. Cada vez que el juego es
actualizado (esto incluye actualizar a los jugadores, revisar colisiones y establecer las
pantallas), decimos que el tiempo de juego (Game-Time) ha incrementado a uno.

El tiempo que un jugador a gastado en un State es conocido como Tiempo de State (State-Time).
El Tiempo de State comienza en 0 al inicio de un state, e incrementa a un segundo por cada segundo de Tiempo de Juego.


4. Posición, velocidad y aceleración
------------------------------------
Si tienes conocimientos básicos en matemáticas, entonces deberás entender estos conceptos.
M.U.G.E.N. usa el siguiente sistema de coordenadas.

Más grande que la Posición-X (X-Position), es la posición más lejana que puede estar el jugador
a la Derecha. Menos que la Posición-X, es lo más cerca que puede estar a la Izquierda.

Una Posición-Y (Y-Position) es el nivel del jugador parado en el suelo, tiene un valor de 0. La Posición-Y del jugador se hace
mayor cuando él se mueve hacia abajo.

Por ejemplo, una Posición-Y Negativa significa que el jugador está en el aire.
Similarmente, cuando decimos que el jugador tiene una Velocidad-X (X-Velocity) positiva,
significa que él se está moviendo hacia adelante, y si él tiene una Velocidad-X negativa, él
se está moviendo hacia atrás.

Un jugador con Velocidad-Y (Y-Velocity) positiva es cuando se mueve hacia abajo, una
Velocidad-Y negativa significa que se mueve hacia arriba.

Una Aceleración-X (X-Acceleration) positiva significa que la Velocidad-X del jugador se está
incrementando, una Aceleración-X negativa significa que su Velocidad-X está disminuyendo.
De la misma manera ocurre con la Aceleración-Y (Y-Acceleration).


5. Malabareando (Juggling)
---------------
M.U.G.E.N. permite ciertos movimientos de "malabarista" (Juggle), esto es, golpear a los oponentes
que han sido golpeados en el aire, o yacen en el suelo.

El sistema sistema de malabares trabaja de la siguiente manera: Cada oponente comienza con un
cierto número de "puntos" de malabarista (Juggle "Points" en el primer golpe que los hace caer,
normalmente son 15.


Algo terminología rápida:
-------------------------
Cuando decimos que un jugador está "cayendo", nos referimos que él no recupera el control en el
aire, y caerá en el suelo.

Si un jugador es golpeado mientras está cayendo en el aire o yace en el suelo, entonces sus Juggle
Pontis comenzarán a disminuir cierta cantidad dependiendo del ataque. Cuando un ataque requiere
más Juggle Points del que poseé, entonces la secuencia de ataque se perderá. Cualquier movimiento
que cause que el oponente caiga, inmediatamente substrae sus Juggle Points en el primer golpe.

Por ejemplo, un ataque que requiere 7 Juggle Points pudiera ser teóricamente usado para malabarear
al oponente un par de veces (asumiendo que comenzaste con 15 puntos), dejando al oponente con 1
punto menos. Las siguientes secuencias de ataques se perderán.

La razón del sistema de Juggle es prevenir la realización de Combos en el Aire.


----------------------------------
III.c. Partes básicas de un State.
----------------------------------

Noa: Esta sección asume que ya leíste la documentación sobre Archivos AIR, y entiendes los
conceptos de animación, así como el significado de palabras clave y frases tales como "Acción"
(Action) y Elemento de una Acción (Element of an Action).

Aquí hay un corto ejemplo de State para 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


Este State realiza la acción 200 de la animación de P1, y regresa a P1 a su State de posición de
pie después de que la animación ha terminado.

En este caso, se asume que la Acción 200 tiene un Tiempo de Bucle limitado (Finite Looptime).
Esto es que la Acción 200 no tiene ningún elemento con un tiempo igual a -1.

Hasta este punto, no necesitas preocuparte por los detalles. Comencemos por conocer en qué
consiste un State.

Todos los States deben tener una simple sección de Statedef y una o más secciones de State.


STATEDEF (Definición de State)
------------------------------
Un Statedef contiene la información de inicio de un State, tales como qué clase de State es
(De pié, Agachado, en el aire) y qué clase de movimiento está haciendo (atacando, o permaneciendo quieto)

Cada sección de un State es referido como Controlador de State (State Controller), o Controlador
para abreviar.

Los Controladores le dicen al programa lo que hace tiene que hacer P1, y cuando hacerlo.
Hay muchas clases de Controladores, cada un con su propia función. Por ejemplo, hay Controladores
para cambiar la posición del jugador o su velocidad, define los efectos de los ataques, crea
proyectiles, cambia entre animaciones de Acciones, cambia de States, y demás.

Cada Controlador debe tener al menos un Trigger (Gatillo/Iniciador). Un Trigger es un evento que
provoca que el Controlador sea activado. Ejemplos: Trigger al inicio del State, Trigger al final
de una animación (como es visto en el ejemplo de arriba), Trigger en un Elemento de Acción de
Animación (Element of Animation Action), Trigger cuando P2 está dentro de un cierto rango de P1,
y demás.


--------------------------
III.d. Detalles en un StateDef (Definiciones de Estado)
--------------------------

Cada State debe comenzar exactamente con un grupo de StateDef (StateDef Group), también conocido
como Sección de StateDef (Statedef section).

Un StateDef Group de verse como esto (pon uno o más parámetres donde van los puntos):

[Statedef state_number]
. state_parameters
.
.

Reemplaza "state_number" con el número del State que estás programando. Con la excepción del
grupo de números especiales (special group numbers) (Ver Apéndice A), estás permitido a usar
cualquier número de State que elijas.

Evita elegir grupos de números especiales, no elijas números del 0 al 199, y del 5000 al 5999.

Las líneas de un StateDef deberían incluír los siguientes parámetros:

1. type (Tipo)
2. movetype (Tipo de Movimiento)
3. physics (Física)
4. anim (Animación)


1. TYPE
-------
Este es el State TYPE de P1. Define si P1 está de pié, agachado, en el aire, o si yace en el suelo.

Los valores que maneja son:

"S" para "De Pié"
"C" para "Agachado"
"A" para "En el Aire"
"L" para "Yacer en el suelo"

(No se usan las comillas)

Para dejar un Type sin cambios del proceso de un State anterior, usa el valor "U" (Unchanged =
Sin cambios). Si es omitido, TYPE asumirá el valor como "S".

Cuando trabajes TYPE, usarás mucho los valores "S", "C" "A". Por ejemplo, un State de agacharse
requeriría la siguiente linea:

type = C

TYPE es usado para determinar varios factores, muchos de ellos de suma importancia, tales como
que P1 reaccionará tras ser golpeado. Otro ejemplo, estar en un State del Tipo "De pié", P1
reaccionará como si estuviera parado en el suelo. Y si el TYPE fuera "Aire", entonces P1
reaccionará como si estuviera en medio del aire.


2. MOVETYPE
-----------
Este parámetro se refiere al tipo de movimiento que realiza P1:

"A" para Ataque
"I" para Idle*
"H" para "Ser golpeado".

Los valores "A" y "H" deberían ser fáciles de entender.

*NOTA DEL TRADUCTOR: La palabra IDLE tiene muchos significados al español y es difícil ubicar
un contexto exacto para dicha palabra en lo que a término de peleas se refiere. De acuerdo con el
diccionario OXFORD SUPERLEX, IDLE significa Desocupado, Sin hacer nada, Flojo, Estar detenido)

Dejar MOVETYPE sin cambios del State previo, usa el valor "U".

Si omitimos este parámetro, debemos usar el valor "I".

El Valor "I" es usado para un State donde P1 no ataca ni es atacado. Por ejemplo, un State de Ataque
(Attack State) debería tener la siguiente línea:

movetype = A

Necesitas especificar el MOVETYPE, así el programa sabrá cómo procesar el State. Especificar incorrectamente el MOVETYPE
puede causar que P1 actúe incorrectamente.


3. PHYSICS
----------
Necesitas especificar qué física usarás en ese State. Los valores válidos a usar son:


"S" para De pié
"C" para Agachado
"A" para Aire
"N" para Ninguna Acción.

Para dejar PHYSICS sin cambios del State previo, usa el valor "U". Si es omitido, el valor "N" será
asumido. PHYSICS es usado para determinar como se comportará P1.

El Valor "S", hará que P1 experimente fricción con el suelo. El valor del coeficiente
de fricción es asignado en las variables del Player. (Para más información ver la Sección II)

El Valor "C", hará que P1 experimente fricción, igual que en el State "S".

El Valor "A", hará en P1 una aceleración hacia abajo, si su Y-Position es más grande que 0
(Esto es, Tocar el suelo),inmediatamente irá a su State de aterrizaje (Landing State)

Si usas el valor "N", P1 no usará ninguna de éstas físicas pre-programadas.

No confundas PHYSICS con el State TYPE. Normalmente son lo mismo, PERO son dados para que elijas
en caso de que quieres más control. Por ejemplo, puedes elegir usar "N" (Sin Física), y especificar
tu propia detección de aceleración y aterrizaje para un State aereo (Aerial State).

4. ANIM
-------
Este parámetro se encarga de las Acciones de Animación (Animation Action) de P1. Especifica el
número de acción (Action Number) como valor. Si no quieres que P1 cambie de animación al inicio
del State, omite este parámetro.

Para tener un State con el número 400, donde el player está haciendo un ataque agachado con una
Action 400, el parámetro típico debería ser:

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


Última edición por shammahomega1 el Jue Ago 19 2010, 13:43, editado 1 vez
Volver arriba Ir abajo
shammahomega
Admin
Admin
avatar

Mensajes : 643
Fecha de inscripción : 23/01/2010

MensajeTema: El Formato CNS 3ra Parte   Dom Ene 31 2010, 11:32

El Formato CNS 3ra Parte

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

Antes que nada una disculpa, esta última sección estuvo llena de terminología sobre la Lógica de la Programación y cuya adaptación a los términos en español fue toda una verdadera odisea. Hice todo lo posible para que se entendiera al contexto de nuestro idioma.

Espero no crear confusión en su lectura, disfruten de este trabajo.



ATTE: David Villena Hernández

NOTA: El VBulletin no me permitió meter toda la tercera parte así que dividí y hay una 4ta parte disponible. Desafortunadamente
el editor no me permite cambiar el título del post. ¬¬

TERCERA PARTE


Código:

Puedes usar otros valores opcionales:

5. velset (Fijar Velocidad)
6. ctrl (Control)
7. poweradd (Agregar Poder)
8. juggle (Malabar)
9. facep2 (Enfrentar a P2)
10. hitdefpersist (Definir golpe persistente)
11. movehitpersist (Golpe persistente en movimiento)
12. hitcountpersist (Conteo de golpes persistentes)
13. sprpriority (Prioridad de sprite)

(NOTA DEL TRADUCTOR: Una disculpa para todos los lectores si se llegan a confundir en esta sección,
he intentado hacerlo lo más comprensible posible, desafortunadamente muchas de los términos
que se manejan aquí tienen un significado y un uso muy ambigüo para el español)


5. VELSET
---------
Puedes usar VELSET para fijar la velocidad de P1 al inicio del State. El formato es un número par,
representando la Velocidad X y la Velocidad Y respectivamente. Omitir esta linea dejará a la
velocidad de P1 sin cambios. Por ejemplo:

velset = 4,-8

Esto hace que P1 comience moviéndose diagonalmente hacia arriba y hacia adelante.

Hay una excepción para hacer esto. Incluso si tienes velset = 0, atacar a P2 en la esquina
retirará a P1 de su lugar.


6. CTRL
-------
Este parámetro fijará el control sobre P1. Un valor de "0" fija el señalador (flag) como falso,
"1" lo fija como verdadero. Si es omitido, el señalador de control de P1 quedará sin cambios. Por
ejemplo, para darle el control a P1, usa:

ctrl = 1


7. POWERADD
-----------
Cuando es incluído, el parámetro POWERADD agrega un valor a las Barras de Poder (Power Bar) del
Player. El valor es un número, y puede ser positivo o negativo. Este parámetro es normalmente
usado en movimientos de ataque, donde el player adquiere poder al ejecutar los ataques.
Por ejemplo, para agregar un poder de 40, escribe:

poweradd = 40

8. JUGGLE
---------
El parámetro de JUGGLE es útil únicamente para los ataques. Especifica cuántos puntos de Juggling
requiere la técnica de ataque. Si es omitido para un ataque, el ataque hará Juggle si el previo
State de ataque lo realizó exitosamente. Deberías incluir el parámetro Juggle para todos los
ataques. Si un ataque se prolonga más de un State, incluye únicamente el parámetro Juggle en el
primer State de ese ataque.

El Término Juggling fue explicado con detalle en la sección: "Conceptos que serán útiles y que
deberías conocer" dentro de la parte "III.b. Introducción a los States" de este texto.

9. FACEP2
---------
Cuando incluyes la linea "facep2 = 1", el jugador se volteará, si es necesario, para enfrentarse
con el oponente al inicio de el State. "facep2" tiene el valor de "0" si es omitido.

10. HITDEFPERSIST
-----------------
Si este parámetro es fijado con el valor de 1, cualquier HitDef el cual esté activo al momento de
una transición de State, permanecerá activo. Si es fijado en 0, predeterminado, cualquier HitDef
será deshabilitado cuando la transición de State esté hecha.


11. MOVEHITPERSIST
------------------
Si es fijado con valor de 1, la información del golpe del movimiento (Move Hit) del State anterior
(tanto si el ataque impactó, se perdió o fue bloqueado, etc; Ver Gatillos de Movimiento
(Move Triggers) en el documento referente a Triggers en la carpeta de DOCS)
será transferido a ese State. Si es fijado con el valor de 0 (Predeterminado), esta información
será reemplazada por la entrada de ese State.


12. HITCOUNTPERSIST
-------------------
Si es fijado con valor de 1, el contador de golpes (Hit Counter) (Cuántos golpes fueron recibidos
por el oponente durante un ataque) será transferido al State anterior al que se está ejecutando.
Si es fijado con valor de 0, (Predeterminado), el Hit Counter será reemplazado por el
State Transition (Transición de State)

Este parámetro no afecta el Combo Counter (Contador de Combos) el cual es mostrado en pantalla.

Para más información, consulta la sección HitCount (Contador de Golpes) y UniqHitCount (Contador
de GOlpe Único) del Documento sobre Triggers para revisar acerca del Hit Counter.


13. SPRPRIORITY
---------------
Si este parámetro está presente, la prioridad de Capa (Layering Priority) de los sprites del
Player será colocada a un valor especificado. Si es omitido, la Prioridad de los Sprites
permanecerá sin cambios.

El archivo COMMON1.CNS (El archivo CNS que es heredado a cada Player) define la prioridad de los
Sprites de Agacharse o Estar de Pie con un valor de 0, y de saltar de 1.

Para muchos de los States de Ataque (Attack States), tendrás que asignar el valor sprpriority = 2,
así ese ataque aparecerá en frente.

Para más información consulta la sección SprPriority en la documentación de SCTRLS para cambiar
la prioridad de Sprites usando controladores.


------------------------------------
III.e. Detalles en State Controllers (Controladores de State)
------------------------------------

d.1 Formato de un Controlador (Cotroller Format)
d.2 Triggers (Gatillos/Iniciadores)
d.3 Controladores de Uso Común (Commonly-used controllers)


III.d.1 Formato de un Controlador
---------------------------------

Todos los States deben tener al menos un State Controller, de otra manera causaría un error. Los
Grupos de State Controllers tienen el siguiente formato:

[State state_number, some_number]
type = controller_type
trigger1 = condition_exp
. universal optional parameters (Parámetros Universales opcionales)
. additional parameters depending on controller (Parámetros adicionales dependiendo del controlador)
.
.


STATE_NUMBER
------------
State_number (Número de State) debe ser del mismo número del State del StateDef.


SOME_NUMBER
-----------
Some_number (Algún Número) puede ser cualquier número a elegir; Ese es el número que es reportado
cuando es encontrado un error, así que sabrás que controlador necesita ser arreglado.


UNIVERSAL OPTIONAL PARAMETERS
-----------------------------
Los Parámetros Universales (aplicable a todos los State Controllers) Opcionales son el
ignorehitpause (Ignorar Pausa en Golpe) y los Parámetros de Persistencia (Persistency Parameters).

Si ignorehitpause le es asignado el valor de 1, MUGEN revisará si el State Controller e incluso
revisará al Char también es pausado por un golpe. De otra manera, este State Controller no será
revisado durante una Pausa en Golpe.

El valor Predeterminado es 0, el cual es siempre recomendado salvo en situaciones excepcionales.
Para ver ejemplos y explicaciones de los Parámetros de Persistencia, consulta la sección de
Trigger Persistency (Gatillos Persistentes)


CONTROLLER_TYPE (Tipo de Controlador)
---------------

El controller_type es el nombre de el Controlador que estás usando. Cada tipo de controlador tiene
efecto diferente, y requiere diferentes parámetros. Consulta el archivo SCTRLS.TXT para una
ver una lista amplia de State Controllers.

El orden de los Controladores es significativo. Los controladores que se enlisten primero serán
los primeros en ser revisados y, si es necesario, son los primeros en activarse.

Aquí hay un ejemplo de un Controlador que le da a P1 el Control al inicio de un State (el mismo
efecto ocurre al poner "ctrl = 1" como parámetro en el StateDef):


[State 300, 1] ;State 300. 1 is just an arbitrary number. (En el State 300. 1 es sólo un número arbitrario)
type = CtrlSet ;Changes the control flag. (Cambia el Señalador de COntrol)
trigger1 = Time = 0
value = 1

En este ejemplo, el tipo de CtrlSet (Asignar Control) te permite cambiar el señalador de control de
P1. La linea que lee "trigger1 = Time = 0" significa que este controlador es activado cuando el
State-Time (Estado-Tiempo) tiene un valor de 0, esto es, el inicio de ese State.

La linea "value = 1" dice que queremos asignar al Señalador de Control el valor de 1, el cual
significa que es Verdadero. Si queremos hacer que P1 inicie el State sin ningún control, entonces
necesitaremos cambiar la última linea por "value = 0".

Veamos otro ejemplo. Este controlador mueve a P1 hacia adelante cada 10 Pixeles: en el segundo y
tercer elemento de la Acción de Animación (Animation Action) actual. No te preocupes si no sabes
qué controladores van con cada Tipo de Controlador (Controller Types). Puedes aprender más de
ellos en la documentación sobre State Controllers (SCTRLS.TXT)

[State 300, 2]
type = PosAdd ;Adds to P1's position (Agrega la posición de P1)
trigger1 = AnimElem = 2 ;Trigger on 2nd element. (Gatillo en el 2do elemento)
trigger2 = AnimElem = 3 ;Trigger on 3rd element. (Gatillo en el 3er elemento)
x = 10

Como pudiste ver arriba, cada controlador debe tener al menos un Trigger. Un Trigger es una
condición que causa que controlador sea activado. Este ejemplo tiene dos triggers, y el controlador
es activado cuando cuando CUALQUIERA de los dos es Verdadero.


III.d.2 Triggers
================

I. Trigger Lógico
=================

El primer Trigger debería ser siempre "trigger1", y los Triggers subsecuentes deberían ser
"trigger2", y entonces "trigger3" y así.

La lógica para decidir si un controlador debería ser activado es:

1.- ¿Son Verdaderas todas las condiciones de "trigger1"? Si es así, entonces la respuesta es sí,
y se activa el controlador.
2.- De otra manera, se repite la prueba para "trigger2" y así sucesivamente, hasta que no haya
más Triggers.

2. Otherwise, repeat the test for "trigger2", and so on, until no more triggers are found.
This can be thought of as "OR" logic.

Se puede pensar en esto como: Lógica de "OR" (O)

Cuidado, saltarse números causará que algunos triggers sean ignorados. Por ejemplo, si tienes
los triggers "trigger1", "trigger2" y "trigger4" sin tener un "trigger3", entonces "trigger4"
será ignorado.

Ahora, ¿Qué si quieres más de una condición antes de que el controlador esté activado?

Aquí hay un ejemplo de uso común para probar si un Player en el aire ha alcanzado el suelo.

Los Triggers usados son:
trigger1 = Vel Y > 0 ; Verdadero si Y-velocity es mayor que 0 (Yendo hacia abajo)
trigger1 = Pos Y > 0 ; Verdadero si Y-position es mayor que 0 (Debajo del suelo)

En este punto, puedes confundirte por el formato del Trigger. No te preocupes acerca de eso
por ahora. Nos encargaremos de eso pronto.

Cómo puedes ver arriba, ambos triggers tiene el mismo número. Cuando varios Triggers tienen el
mismo número, se les implementa la Lógica de "AND". Esto es cuando el controlador es activado
si cada uno de los Triggers con el mísmo número son Verdaderos, pero no si uno más de ellos son
Falsos.

Puedes combinar ambas ideas. Por ejemplo:
trigger1 = Vel Y > 0 ; Verdadero si Y-velocity es Mayor que 0 (Yendo hacia abajo)
trigger1 = Pos Y > 0 ; Verdadero si Y-position es Mayor que 0 (Debajo del suelo)
trigger2 = Time = 5 ; Verdadero si el Tiempo de Estado (State-time) es 5
El controlador para esto debería ser activado si el jugador aterriza en el suelo (Y-velocity
y Y-Position son mayor que 0), O (OR) si su Tiempo de Estado fue de 5.

En Resumen:
- Los Triggers con el mismo número activan el controlador sólo si todos ellos son Verdaderos.
- Los Triggers con diferentes números activan el controlador si uno o más de ellos son verdaderos.

El Formato de un Trigger es:
trigger? = trigger_type trigger_test (Tipo de Trigger, Trigger de Prueba)


trigger_type
------------
Es el nombre del Trigger (Consulta el archivo triggers.txt para conocer la lista completa)


condition_exp (Condición de la Expresión)
-------------
Es una expresión Aritmética que revisa la igualdad a 0. Si el valor de condition_exp es 0,
entonces el Trigger es Falso. Si condition_exp es un número superior a 0, entonces el Trigger es
Verdadero. Condition_exp es normalmente una Expresión Relacional Simple como en los ejemplos de
arriba, pero puede ser tan simple o tan complicado como sea requerido.

Es posible usar los Operadores Lógicos entre expresiones. Por ejemplo, este es equivalente al
ejemplo anterior que fue visto arriba.

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

Para una detallada explicación de las Expresiones Aritméticas en M.U.G.E.N., consulta el archivo
EXP.TXT


triggerall (Gatillo a todo/Inicio a todo)
----------
Un atajo útil que puedes usar es "triggerall". Este determina una condición que debe ser Verdadera
para todos los Triggers. Por ejemplo en:

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

Para que cada trigger1 a trigger3 sean revisados, la condición triggerall debe ser verdadera
también. En este caso, mientras X-velocity no sea 0, entonces el State Controller no será activado.
Puedes tiene más de una condición Triggerall si lo necesitas. Nota que al menos un trigger1 debe
estar presente, incluso si especificas triggeralls.


II. Persistencia del Trigger
============================

En el caso de que no quieras usar Triggers para activar cada condición una vez que sean correctas,
necesitarás agregar un parámetro "persistente". Comenzaremos con un ejemplo:

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

Este State Controller mueve P1 hacia adelante cada 10 pixeles por cada segundo del tiempo de juego
donde la Y-Velocity de P1 es más grande que 1. El controlador está siendo activado cada vez que la
Condición Detonante (Trigger Condition) es Verdadera. Si queremos que el controlador sea activado
sólo una vez, necesitaremos agregar una línea:

[State 310, 1]
type = PosAdd
trigger1 = Vel Y > 1
persistent = 0 ;<-- Agrega esta línea.
x = 10


PERSISTENT (Persistente)
----------
"Persistent" tiene un valor predeterminado de 1, significa que el controlador es activado cada vez
que el Trigger es Verdadero.

Asignar a "Persistent" el valor de 0, permite al controlador ser activado al menos una vez durante
ese State. Esto permanece Verdadero hasta que P1 deje ese State. Si P1 regresa a ese State después,
el controlador puede ser activado una vez más.

El Parámetro "Persistent" también puede tomar valores diferentes a 0 y a 1:

[State 310, 1]
type = PosAdd
trigger1 = Vel Y > 1
persistent = 2 ;<-- Línea modificada
x = 10

En este caso, asignar "Persistent" a 2 significa que el controlador será activado una de cada dos
veces cuando el Trigger sea Verdadero. Asignando "Persistent" a 3 activa el controlador cada 3ra
vez, y así sucesivamente.


iii. Redirección del Trigger
============================

Uno puede desear revisar el State Tiem de un objetivo (Target) del Player, o del padre del
Player (si el Player es un Helper (ayudante)), etc.


III.d.3 Controladores de Uso Común
==================================

NULL (Nulo)
----
El controlador "Null" será útil para Depuración (Debugging). Un controlador "Null" básicamente
hace nada. Puedes usarlo para apagar temporalmente ciertos controladores en vez de bloquear con
comentarios ( toda una sección.
Por ejemplo, puedes querer deshabilitar esto:

[State 300, 1] ;Controlador que acelera a P1 hacia adelante
type = VelAdd
trigger1 = Time >= 0
x = .8

Simplemente comenta el tipo y pon un "Null":

[State 300, 1] ;Controlador que acelera a P1 hacia adelante
type = null ;VelAdd
trigger1 = Time >= 0
x = .8

Después, cuando quieras rehabilitar el controlador, sólo cambia de vuelta el tipo que se estaba
usado.

Ahora veamos de nuevo el ejemplo:

[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]
--------------
Es un controlador "ChangeState" (Cambia Estado). Como su nombre lo dice, cambia el número de State
de P1. El parámetro de "valor" que debería tener el número del State que cambia. El parámetro
opcional "CTRL" puede asignar el Señalador de Control (Control Flag) de P1 cuando él cambia de
States.

Ahora hagamos de este un State de Ataque. Lo primero de todo, la acción de animación necesita
Cajas de Colisión de Ataque (Attack Collision Boxes). Una rápida revisión al documento del
Formato AIR: Clsn1 es para Ataque y Clsn2 es donde el jugador puede ser golpeado.

Así P1 golpeará a P2 si una de las cajas Clsn1 de P1 intersecta cualquiera de las cajas de Clsn2
de P2.

Con en el ejemplo, asumamos que la Acción de Animación en el archivo AIR de P1 luce como esto:

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

Después de definir las cajas vinculadas, debería verse así:

[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 ;Usa esta caja para los últimos dos cuadros
Clsn2[0] = -10,0, 10,-80
200,2, 0,0, 4
200,3, 0,0, 3

Como puedes ver, cada elemento tiene una caja Clsn2 definida para eso (los dos últimos elementos
están usando las mísmas cajas). El segundo elemento es el único con caja Clsn1.

Nota: Es es todo lo correcto para definir cajas de Clsn1 por cada elemento de la Acción de
Animación, pero si pones una caja Clsn1 en cada primer elemento, el ataque será instantáneo, y
llegará a ser inbloqueable con guarda.
Por lo tanto, es recomendado que definas las cajas Clsn1 únicamente para elementos que le siguen
a los primeros elementos.


Última edición por shammahomega1 el Jue Ago 19 2010, 13:48, editado 1 vez
Volver arriba Ir abajo
shammahomega
Admin
Admin
avatar

Mensajes : 643
Fecha de inscripción : 23/01/2010

MensajeTema: Re: Traducción de los cns por "Villena"   Dom Ene 31 2010, 11:34

4ta parte


Ahora estamos listos para dar de alta el State en el CNS. Explicaremos los cambios aquí abajo.

[Statedef 200]
type = S
physics = S
movetype = A ;<-- Cambiado de "I" a "A"
ctrl = 0
anim = 200
velset = 0

[State 200, 1] ;<-- State Controller agredado
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

El parámetro "movetype" en el StateDef es fijado en "A" para "Ataque". Recuerda hacer esto para
todos los States de Ataque (Attack States). Como antes, P1 regresa a su estado de pie cuando su
animación termina.

¡Este controlador de HitDef es monstruoso! No te preocupes, lo explicaremos parte por parte.

L1: type = HitDef

L2: trigger1 = AnimElem = 2
---------------------------
Este especifica el tipo de controlado como "HitDef", el cual permanece para "Hit Definition"
(Definición del Golpe). Está Triggeriado en un segundo elemento de animación. Cada Clsn2 caja
(Caja de Colisión 2) al momento que el Trigger fue activado tomará esa Definición de Golpe.

Si, por ejemplo, tienes un Clsn1 tanto en el segundo como en el tercer elemento de animación que
están Triggeriando un HitDef sencillo en el segundo elemento, esto hará que se aplique en ambos
elementos de animación.

Entonces P1 golpeará más de una vez: Si el segundo elemento golpea, el tercero se perderá.
Si el segundo elemento se pierde, el tercero permanecerá. Para hacer que el ataque pegue dos veces
deber Triggear un HitDef para cada uno de los dos elementos.


L3: attr = S, NA
----------------
Este es el atributo de un ataque. Es usado para determinar si el ataque puede golpear a P2. En
este caso, es el Ataque normal de pié (Standing Normal Attack)

"attr" tiene el siguiente formato:
attr = arg1, arg2 (argumento 1, argumento 2)

Donde:

- arg1 puede ser tanto "S", "C" o "A". Similar a "statetype" en StateDef, este indica si el ataque
es tanto de Pié, Agachado o Aereo.

- arg2 es una cadena de 2 caracteres. El primer caracter puede ser tanto:

"N" para "Normal"
"S" para "Especial"
"H" para "Hiper" (o "Super", como se le conoce comúnmente).

El segundo caracter debe ser tanto:

"A" para "Ataque" (un golpe normal de ataque)
"T" para "Arrolar" (Throw)
"P" para "Projectíl"


L4: animtype = Light
--------------------
Este se refiere al tipo de animación que entrará P2 cuando sea golpeado por un ataque. Elige entre:
"light", "medium", "hard" o "back". Los primeros tres parámetros deberían tenerse por entendidos.
"Back" (atrás) es la animación donde P2 es tirado.


L5: damage = 10
---------------
line to "damage = 10, 1", then it will do 1 point of damage if guarded.
Este es el daño que P2 toma cuando golpea, y no hace daño cuando es detenido por guardia. Si
agregamos a la línea "damage = 10, 1", entonces haremos un punto de daño a quién detiene por
guardia


L6: guardflag = MA
------------------
"Guardflag" determina cómo P2 puede hacer guardia ante el ataque. Aquí, puede hacer guardia alta
(High Guard Standing), baja (Low Guard Crouching) y en el aire (Air GUard). El argumento debe
ser una cadena de caracteres que incluya cualquiera de los siguientes valores:

"H" para "High" (Alto, Fuerte)
"M" para "Mid" (Medio), es equivalente a poner "HL" (High-Low)
"L" para "Low" (Bajo, Débil)
"A" para "Air" (Aire)

L7: pausetime = 12,12
---------------------
Este es el tiempo que cada Player pausará en el golpe. El primer argumento es el tiempo que
congelará a P1, medido en tiempo de juego. El segundo es el tiempo que hace P2 sacudirse antes de
hacerce para atrás por el impacto.

L8: sparkxy = 0,-55
-------------------
Aquí es donde se hace la chispa de golpe/guardia. Los argumentos deben ser en forma de "x, y".
X es relativo al frente de P2. Un X negativo hace que la chispa aparezca dentro de P2. Y es
relativo a P1. Una Y negativa hace que una chispa salga por encima de ellos.


L9: hitsound = 5,0
------------------
Este es el sonido que se escuchará para un golpe (de fight.snd). El sonido incluído en fight.snd
lo elegiremos con el valor 5,0 (sonido de golpe débil) por medio de 5,4 (Golpe Doloroso).
Para reproducir un sonido desde el propio archivo SND del Player precede el primer número con
"S". Por ejemplo: "hitsound = S1,0".


L10: guardsound = 6,0
---------------------
Este es el sonido que se escuchará al poner guardia (de fight.snd). Ahora tenemos este valor 6,0.
Para reproducir un sonido desde el propio archivo SND del Player precede el primer número con
"S".


L11: ground.type = High
-----------------------
Esta es una clase de ataque para ataques en tierra (también está predeterminado para ataques
aereos si no tienes "air.type = ?". En este caso, es un ataque alto (High Attack). Elige "High"
para los ataques que hacen que la cabeza de P2 se haga hacia atrás, "Low" (Bajo) para ataques que
son recibidos en el estómago de P2, "Trip" para ataque de barrida, o "None" para que P2 haga nada.
Los ataques "High" y "Low" son lo mismo en P2 si el AnimType es "Back" (atrás).


L12: ground.slidetime = 12
--------------------------
Este es el tiempo medido en Tiempo de Juego en el que P2 se deslizará hacia atrás después de ser
golpeado (este tiempo no incluye el Tiempo de Pausa (Pausetime) para P2). Aplicable únicamente
para golpes que mantienen a P2 en el suelo.


L13: ground.hittime = 15
------------------------
El tiempo que P2 permanece en el State de golpe (State Hit) después de ser golpeado. Aplicable
únicamente para los golpes que mantienen a P2 en el suelo.


L14: ground.velocity = -5
-------------------------
X-velocity inicial para P2 después de ser golpeado, si P2 está en un State de posición de Pié o
de agachado en el suelo. Puede especificar una Y-velocity como segundo argumento si quieres que
P2 sea knoqueado en el aire, por ejemplo "ground.velocity = -3, -2".


L15: air.velocity = -2.5,-3.5
-----------------------------
Velocidad inicial para P2 si P2 está en el aire.

Son más cosas de las que puedes controlar en un HitDef. Consulta sctrls.txt para más detalles.

----------------------------------------------------
III.f. Common states (Estados Comúnes) (common1.cns)
----------------------------------------------------
Si hechas un vistazo a un archvio DEF de un Player, verás la siguiente linea:

stcommon = common1.cns ;Common states

Cada jugador comparte algunos Common States, los cuales son partes básicas del Motor de Juego
(Game Engine). Estos common states son encontrados en data/common1.cns. Algunos ejemplos son
los States de Correr y Dar Golpes. Una lista completa está disponible en el Apéndice A: Números
Especiales de State Controller.

Si hay un Common State que te gustaría omitir para cierto Player, todo lo que necesitas hacer
es hacer un State en el CNS de ese Player con el mísmo número como en el que te gustaría omitir.

Entonces, cuando el Player cambie a ése cierto State Number, él entrará a un nuevo State, vez de
aquél de common1.cns.

Deberías recordar que cuando omites ciertos states que tienen propiedades especiales codificadas
dentro de M.U.G.E.N, los nuevos states que tu hagas mantendrán las mismas propiedades especiales
que aquellos que omitiste. Por ejemplo, el State que corre (state 100) asigna a la velocidad del
Player cualquier valor que le especifiques en sus variables de Player.

Si omites el State 100, el nuevo State permanecerá teniendo la propiedad de asignación que la
velocidad del Player.

Un ejemplo común es omitiendo el State que se ejecute. La conducta predeterminada de M.U.G.E.N.
para States en ejecución es tener al Player moviéndoe hacia adelante en una velocidad constante,
hasta que sueltes la tecla de adelante. El Player regresará a su State de Posición de Pié.

Ahora. digamos que queremos que ese Player (llamémoslo P1) en vez de que brinque hacia adelante,
justo como en el predeterminado tecleo-doble (Double-Tap) para brinco hacia atrás. Puedes hacer
un State en el CNS del P1:

; RUN_FWD (correr hacia adelante) (omitido para hacer un movimiento tipo Dash)

NOTA DEL TRADUCTOR: La palabra Dash no tiene un significado específico al español, se refiere a
hacer un movimiento rápido y corto o que es hecho a gran velocidad y a corta distancia.

[Statedef 100]
type = S ;Correr en el suelo
physics = N ;Definiremos nuestra propia física
anim = 100 ;Acción de Animación 100
ctrl = 0 ;No hay control para la duración del Dash

[State 100, 1] ;Comenzar a hacer dash hacia adelante
type = VelSet
trigger1 = Time = [0,5]
x = 6

[State 100, 2] ;Fricción después del Dash inicial
type = VelMul
trigger1 = Time > 5
x = .85

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

Aquí, asumimos que la acción 100 tiene un looptime infinito. La velocidad en run.fwd bajo la
etiqueta [Velocity] de las variables del Player no son ignoradas fealmente, pero [State 100,1]
omite ese detalle por la asignación de X-velocity a 6.


====================================================================
IV. Expresiones
====================================================================

MUGEN tiene soporte para expresiones tanto para los archivos CNS como para los CMD. Esta sección
cubrirá brevemente algunos ejemplos de expresiones. No tomes esto como una referencia concisa,
es únicamente una guía rápida para que te adentres.

Para una completa explicación de expresiones, consulta la documentación sobre Expresiones (EXP).

Las expresiones te permiten usar un Trigger como valor de parámetro. El siguiente ejemplo aumenta
la Posición X del Player por un valor que es igual al tiempo de State.

[State 200, 1]
type = PosAdd
trigger1 = Time = 0
x = Time

OPERADORES ARITMÉTICOS
----------------------
La aritmética simple también puede ser usada en expresiones. Algunos operadores básicos son:

+ Suma
- Resta
* Multiplicación
/ División

[State 200, 1]
type = VelSet
trigger1 = 1 ;Nota: esto es lógicamente equivalente a
x = Time + 4 ;"trigger1 = Time >= 0"

RUNTIME (Tiempo de Ejecución)
-------
Las expresiones en los parámetros de un State Controller son evaluados al tiempo que corre,
esto significa que cada vez que un parámetro de un State Controller contiene una expresión, esta
es ejecutada, el valor del parámetro es recalculado durante ese instante. En el ejemplo de arriba
La X-velocity del Player es recomputada por cada cuadro que el permanezca en el State 200.

El orden de la evaluación es generalmente de Izquierda a Derecha, pero la Multiplicación y
la Division toman prioridad sobre la Suma y la Resta. Por ejemplo, en una expresión 5 + 6 / 2,
el resultado es 8 (El Runtime primero dividirá 6 entre 2 y el resultado será sumado con 5).

Para forzar a la Suma para tomar un lugar antes de la división, puedes agregar un paréntesis,
por ejemplo (5 + 6) / 2, el cual da como resultado, 5.5

Las Expresiones pueden ser también usada en la línea de Trigger. Estas expresiones son evaluadas
cada vez que el trigger es revisado. Este siguiente ejemplo cambia el State del Player cuando
su State Time es más grande que el valor guardado en la Variable var(1).

[State 200, 1]
type = ChangeState
trigger1 = Time > var(1)
value = 201

Las variables también pueden tomar expresiones como se puede ser visto aquí abajo.

[State 200, 1]
type = VarSet
trigger1 = Time = [1,5]
var(Time) = Time * 2


Operadores Lógicos "||" y "&&"
------------------------------
Los Operadores Lógicos puede ser usados. || es usado para "OR" (o), y && para "AND" (y). Por
ejemplo, esto cambia el State del Player cuando su State Time es más grande que 90, y si animación
ha terminado.

[State 200, 1]
type = ChangeState
trigger1 = Time > 90 && AnimTime = 0
value = 0

La línea de Trigger de allá arriba es lógicamente equivalente a las 2 líneas:

trigger1 = Time > 90
trigger1 = AnimTime = 0

&& toma prioridad sobre ||. Siempre que uses más de un Operador Lógico en una expresión, intenta
usar paréntesis para aclarar. No es requerido, pero lo hace más fácil de entender. Por ejemplo:

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

No todos los parámetros admiten expresiones. Típicamente, aquellos que son del tipo No-Numéricos
no admiten expresiones. Por ejemplo, esta es una construcción ilegal:

[State 300, 5]
type = HitDef
trigger1 = Time = 0
ground.type = High && Low ; <-- ilegal -- Tipos No-Numéricos!



====================================================================
Apéndice A. Números especiales de States
====================================================================

A menos que planees pasar por alto un Common State, evita elegir números de State en un rango
de 0-199 y 5000-5999.

Aquí hay una lista de States en common1.cns.

Números de State marcados como "reservados" no deberían ser usados, podrían ser asignados para
una función específica en futuras versiones de MUGEN.


Número Descripción
------ -----------
0 De pie
10 De pie-para-agacharse
11 Agachado
12 Agachado-para-De pie
20 Caminar


Esta lista no está completa aún. Por favor sé paciente.

Fin del documento.
Volver arriba Ir abajo
Contenido patrocinado




MensajeTema: Re: Traducción de los cns por "Villena"   

Volver arriba Ir abajo
 
Traducción de los cns por "Villena"
Ver el tema anterior Ver el tema siguiente Volver arriba 
Página 1 de 1.
 Temas similares
-
» Me disculpo por la "publicidad"
» Kaudillo Orko Zroshgathkull "Aplaztakraneoz"
» Nuevo formato "EXTENDACY"
» Autorepetición o "ruedita"
» "horrorizados"?

Permisos de este foro:No puedes responder a temas en este foro.
Mugen-México III Rematch :: Biblioteca del mugen :: Traducciones de los documentos de mugen-
Cambiar a: