Crearemos el primer enemigo. Los zombies que aparecen nada más empezar el nivel. Y para crearemos una nueva hoja de sprites y lo implentaremos en una unidad que gestionará su comportamiento.
Contenido
Creando enemigos
Crearemos el primer enemigo. Los zombies que aparecen nada más empezar el nivel. Para ello extrae la primera fina del atlas de sprites spritesheet_enemies_level1.
Dentro de la carpeta, sprites crea una nueva carpeta llamada enemigos_level1. Y copia los archivos dentro de ella.
Crea un hoja de sprites en esta misma carpeta.
En la nueva hoja de sprites, crea una nueva animación, pulsando con el botón derecho del ratón en la zona de la ventana frames, selecciona Add..
Selecciona los archivos que contenga al zombie caminando. Y guarda la hoja como zombies.
Aquí tienes una vista de la animación.
También crearemos una animaciones más, que llamaremos salir.
Una vez listo, añade un elemento TcastleScene, cambia su nombre a Zombi1, y añádele el un BoxCollider y un RigidBody3
Y en su propiedad Url selecciona la hoja de sprites que hemos creado.
Comportamiento
La idea es que el zombi salga del suelo camine una distancia, y luego se detenga, y se vuelva a enterrar.
Crear la clase TZombieBehavior
Para ello vamos a crear una nueva unidad, que contendrá una clase que desciende de TcastleBehavior.En la ventanaFiles, dentro de code vamos a crear una carpeta nueva que llamaremos enemigos. Haz click con el botón derecho sobre la ventana que contiene los archivos.
Dentro de este directorio, vuelve a pulsar con el botón derecho del ratón, y crearemos una nueva unidad (New Unit here) clase de tipo Behavior.
En el asistente que aparece, pon el nombre Zombies, en el campo Base Nane, y pulsa Ok
Al pulsar Ok, saldrá un aviso como el siguiente.
El motor gráfico está avisando que el nuevo archivo no está en la ruta del compilador. Esto significa que al compilar el programa, esta unidad no se podrá encontrar, y si el código en alguna parte hace referencia a esta unida, se producirá un error. Además nos indica como podemos solucionarlo.
Al pulsar Aceptar, sale un nuevo aviso indicando preguntando si deseamos empezar a editar (introducir código) en esta nueva unidad. Pulsa sí.
Se abrirá el editor por defecto, y aparecerá la unidad. En el caso de Lazarus, lo primero que debemos hacer es añadir esta unidad al proyecto. Selecciona en el menú Proyecto, Añadir Archivo de editor al proyecto, o el atajo de teclado Shift+F1.
Y pulsa Sí, sobre la ventana de confirmación.
De esta manera, Lazarus, reconoce la unidad como parte de proyecto. Ahora solo queda indicar a CGE, que reconozca la unidad. Vuelve al editor, y selecciona el origen del del árbol de archivos, y localiza el archivo CastleEngineManifiest.xml.
Este es el archivo dónde debemos indicar la ruta, dónde CGE debe localizar el archivo nuevo. Abre la carpeta contenedora, pulsando con el botón derecho del ratón y seleccionando Open Containing Folder.
En el caso que este usando Visual Code, como editor podrás abrir este archivo directamente.
Edita el archivo, añade una entrada nueva dentro de compiler_options. Indicando la nueva ruta. Fíjate en la imagen siguiente.
Programando la clase TzombieBehavior
Para mover el zombie una distancia determinada necesitamos tres datos: velocidad, dirección y distancia máxima. Abre el editor de código, y selecciona el archivo GameZombiesBehavior, sino lo tienes a la vista.
Para ello vamos a crear en la sección public las tres propiedades.
|
1 2 3 4 |
public property Direccion: TVector3 read Fdireccion write Setdireccion; property Velocidad: TVector3 read Fvelocidad write Setvelocidad; property Distancia: single read FDistancia write SetDistancia; |
Fíjate que hay dos procedimientos ya declarados, que son estos:
|
1 2 3 |
public procedure ParentAfterAttach; override; procedure Update(const SecondsPassed: single; var RemoveMe: TRemoveType); override; |
El procedimiento Update es el que se llamará cada vez que se vaya a actualizar el elemento TcastleScene al que pertenece esta clase. Ten en cuenta que en esta unidad estamos declarando una clase comportamiento o Tbehaivor el cual añadirenos a un elemento TcastleScene.
El otro procedimiento, se ejecutará justo cuando se añade esta clase al elemento TcastleScene. Dentro de este procedimiento escribiremos lo siguiente:
|
1 2 3 4 5 6 7 8 9 |
procedure TZombieBehavior.ParentAfterAttach; begin inherited; { Parent is available now. } FOrigen := Parent.Translation; FRigidBody := Parent.RigidBody; FRigidBody.LinearVelocity := Vector3(0, 0, 0); AnimacionSalir; end; |
Tal como indica el comentario, la clase Parent, ya está disponible, por lo tanto aprovechanos para asginar valores a las propiedades que hemos creado antes. Y llamar al procedimiento AnimaciónSalir, dónde vamos a programar la animación que se realiza al principio.
En este procedimiento preparamos la animación
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
procedure TZombieBehavior.AnimacionSalir; var Parameters: TPlayAnimationParameters; begin FPosicionActual := Parent.Translation; Parameters := TPlayAnimationParameters.Create; try Parameters.Loop := False; Parameters.Name := 'salir'; Parameters.Forward := True; Parameters.StopNotification := {$IFDEF FPC} @FinAnimacionSalir; {$ELSE]} FinAnimacionSalir; {$ENDIF} TCastleScene(Parent).PlayAnimation(Parameters); finally FreeAndNil(Parameters); end; end; |
Primero obtenemos la posición actual. El resto del procedimiento, es la creación de la animación.
Cuando la animación termina, llamamos se llama al procedimiento FinAnimacionSalir. El cual contiene el siguiente código
|
1 2 3 4 5 6 7 8 9 10 11 |
procedure TZombieBehavior.FinAnimacionSalir(const Scene: TCastleSceneCore; const Animation: TTimeSensorNode); var Posicion: TVector3; begin TCastleScene(Parent).PlayAnimation('walk', True); FRigidBody.LinearVelocity := FVelocidad * FDireccion; Posicion := Parent.Translation; Posicion.Y := FOrigen.y; Parent.Translation := Posicion; end; |
En este procedimiento, lo primero, es indicar que la animación que se ejecute la animación walk, de manera continua. Le asignamos una velocidad y una dirección. Estos datos son los que hemos guardado anteriormente. Nos aseguramos que la coordenada Y del padre, es la original. Ya que como veremos más adelante, en el evento OnUpdate, la coordenada Y es modificada.
Evento OnUpdate. El centro de todo
Tal como hemos visto anteriomente, el evento OnUpdate, en el que se ejecuta repetidamente y dónde gestionamos todo.
En este caso, el zombie, tiene dos animaciones. Una walk, que es cuando camina, y la otra es salir. Además el zombie se puede enterrar, lo cual es la animación salir, pero ejecutada hacia atrás.
Teniendo eso en cuenta, en el evento OnUpdate debemos gestionar las animaciones. El código no es muy largo, pero si efectivo
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
procedure TZombieBehavior.Update(const SecondsPassed: single; var RemoveMe: TRemoveType); var TiempoActual: TFloatTime; AnimationNode: TTimeSensorNode; FrameActual: integer; Posicion: TVector3; begin inherited; AnimationNode := TCastleScene(Parent).CurrentAnimation; if AnimationNode <> nil then begin if AnimationNode.X3DName = 'walk' then begin FRigidBody.LinearVelocity := FVelocidad * FDireccion; if (PointsDistance(FOrigen, Parent.Translation) > 100) then begin FRigidBody.LinearVelocity := Vector3(0, 0, 0); //Pasar a la animación de enterrarse AnimacionEnterrar; end; end; if AnimationNode.X3DName = 'salir' then begin // FractionIncreasing corresponde a la animación hacia adelante if AnimationNode.FractionIncreasing then begin FrameActual := Floor((AnimationNode.ElapsedTimeInCycle / AnimationNode.CycleInterval) * 7); end else begin TiempoActual := AnimationNode.CycleInterval - AnimationNode.ElapsedTimeInCycle; FrameActual := Floor((TiempoActual / AnimationNode.CycleInterval) * 7); end; Posicion := TCastleScene(Parent).Translation; case FrameActual of 0: Posicion.Y := FOrigen.y - 27; 1: Posicion.Y := FOrigen.y - 25; 2: Posicion.Y := FOrigen.y - 24; 3: Posicion.Y := FOrigen.y - 20; 4: Posicion.Y := FOrigen.y - 17; 5: Posicion.Y := FOrigen.y - 8; else Posicion.Y := FOrigen.y; end; Parent.Translation := Posicion; end; end; end; |
Lo primero es aseguranos que hay alguna animación activa, algo que siempre debería ser así pero no está demás.
Si esta animación es walk, nos aseguremos que el zombie tiene una velocidad, asignándole una. Lo siguiente es comprobar si ha recorrido una distancia. Para ello calculamos la distancia entre el origen y la posición actual. Para ello nos ayudamos de la función PointsDistance, la cual nos da la distancia entre dos puntos. Si esta distancia es mayor de 100, se considera que el zombie debe enterrarse. Por tanto llamamos al procedimiento AnimacionEnterrar.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
procedure TZombieBehavior.AnimacionEnterrar; var Parameters: TPlayAnimationParameters; FPosicionActual := Parent.Translation; Parameters := TPlayAnimationParameters.Create; try Parameters.Loop := False; Parameters.Name := 'salir'; //Realizamos la animación de salir hacia atrás Parameters.Forward := False; Parameters.StopNotification := {$IFDEF FPC} @FinAnimacionEnterrar; {$ELSE]} FinAnimacionEnterrar; {$ENDIF} TCastleScene(Parent).PlayAnimation(Parameters); finally FreeAndNil(Parameters); end; end; |
De nuevo este procedimiento es muy parecido a FinAnimacionSalir. La diferencia está en que se oculta el zombie, se restaura su posición al origen, se vuelve a hacer visible, y llamamos a la animación AnimacionSalir.
Continuando con el evento OnUpdate, con la animación actual es salir. Comprobamos si se está ejecutando hacia adelante o hacia atrás. Dependiendo de ello, lo que hacemos en calcular que frame de la animación se está ejecutando, de esta manera en función del frame actual, iremos cambiando su posición vertical (coordenada Y) para conseguir un efecto de movimiento vertical.
Para calcular el frame actual, debemos obtener el tiempo que lleva la animación ejecutándose, divirlo por el tiempo total de la animación y multiplicarlo con el número de animaciones. El motico por el cual debemos saber en que sentido se está ejecutando la animación, es que la forma de obtener el tiempo actual varia.
Con esto tenemos el comportamiento del zombi agrupado en una sola unidad, la cual se puede reusar para múltiples zombies.
Añadir el comportamiento al zombie
En la unidad principal, añade en la sección principal el zombi (TcastleScene) que creamos antes.
Y en la sección published añade el TcaslteScene llamado zombie1
Y ahora en el el procedimiento añade este código
|
1 2 3 4 5 6 |
//Crear zombi ZombieBehavior := TZombieBehavior.Create(FreeAtStop); ZombieBehavior.Velocidad:=Vector3(10,0,0); ZombieBehavior.Direccion:=Vector3(-1,0,0); Zombi1.AddBehavior(ZombieBehavior); ZombieBehavior.ParentAfterAttach; |
Creamos un una clase TzombieBehavior. Le asignamos un vector que indicara su velocidad, y hacemos lo mismo para la dirección. Y añadimos este comportamiento al zombi de tipo TcastleScene. Ya por último llamar al método ParentAfterAttach.
Y ya solo queda ejecutar nuestro programa para ver como el zombie, sale del suelo avanza una distancia, y se vuelve a esconder, para reaparecer de nuevo.
Conclusiones
En esta parte, hemos visto como crear unidades y añadirlas. Así como crear un comportamiento para asignarlo a un TCastleScene.
Tienes el código disponible en el github.
Saludos