Está en la página 1de 17

UNIVERSIDAD POLITÉCNICA DE VALENCIA.

MASTER IARFID.

ANIMACIÓN POR COMPUTADOR Y VIDEOJUEGOS

PROFESOR: DR. RAMÓN MOLLÁ

ALUMNOS: FERNANDO RUIZ.


VLADÍMIR ROBLES.

2008 – 2009

VALENCIA
ACV Pág. 1
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Índice de contenido
1 Introducción. ...................................................................................................................................2
2 Objetivos .........................................................................................................................................2
3 Herramientas Utilizadas. ................................................................................................................ 3
4 Modelado del Problema. .................................................................................................................3
4.1.1Invasores del Espacio para dispositivos móviles................................................................ 3
4.1.2Descripción de las clases desarrolladas.............................................................................. 6
4.1.3Definición de los estados de los elementos de acción........................................................8
4.2.1Invasores del Espacio en Flash......................................................................................... 10
4.2.2Descripción de las Clases Desarrolladas...........................................................................11
4.2.3Definición de los estados de los elementos de acción......................................................14
5 Conclusiones. ...............................................................................................................................16
6 Bibliografía ..................................................................................................................................16
7 Recursos gráficos y de multimedia empleados. .......................................................................... 16
ACV Pág. 2
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

1Introducción.

Si el gran escritor francés Julio Verne viviese aún, se sobrecogería sobremanera al ver que muchas
de sus obras de fantasía, fruto de su fecunda imaginación, se han convertido en una bella realidad.
No hace muchas décadas atrás, aún se soñaba con máquinas inteligentes capaces de reconocer la
voz de las personas, sistemas automatizados que pudiesen planear complejas rutas de tráfco
terrestre y aéreo, naves que surcaran el horizonte a velocidades vertiginosas y muchas otras
fantasías, que hoy son realidades comunes para los seres humanos.
En la actualidad, la ciencia nos invita a ser partícipes del rápido avance que tiene día a día la
informática y gracias a ello, hoy podemos contar con sofsticadas técnicas para resolver los más
variados problemas. Por lo expuesto, es de gran relevancia conocer las herramientas más
importantes con las que es posible contar dentro de la animación por computador, esto es, el
diseño y creación de video – juegos.
El presente trabajo busca crear dos soluciones para el conocido juego de los Invasores del Espacio
(Space Invaders), utilizando las potencialidades de la programación orientada a objetos y los
conocimientos adquiridos en la asignatura de Animación por Computador y Video – Juegos. La
primera versión se implementará sobre Adobe Flash, mientras que la segunda alternativa se la
construye sobre Java Micro Edition.

2Objetivos

General
➢Implementar todos los conocimientos adquiridos en la asignatura de Animación por
Computador y Videjuegos para implementar el juego de invasores del espacio.

Específcos.
➢Crear una solución utilizando como herramienta de desarrollo Adobe Flash.
➢Desarrollar una segunda solución implementada sobre Java Micro Edition.
➢Aplicar el uso de las autómatas fnitos determinísticos para defnir el comportamiento de los
juegos desarrollados.
➢Aplicar las técnicas de modularización y jerarquización a fn de lograr aplicaciones robustas y
escalables.
➢Crear una base estructural y algorítmica que permita implementar cambios a futuro en cada uno
de los elementos de los juegos.

3Herramientas Utilizadas.
Para resolver este problema, se ha decido utilizar dos lenguajes tan diferentes como Adobe Flash y
Java Micro Edition, con el objetivo cubrir áreas tan completas y distintas como lo son las
aplicaciones web y las aplicaciones para dispositivos móviles. En la tabla 1 detallamos las
diferentes librerías y versiones utilizadas.
ACV Pág. 3
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Herramienta Versión Descripción


Adobe Flash CS3 - Este software nos sirve tanto como lenguaje de programación
(ActionScript), como entorno de desarrollo gráfco
(Herramienta de Autor).
- Todo el desarrollo de la versión Flash se ha realizado
utilizando unicamente esta herramienta.
NetBeans 6.5 - Este E. D. I. (Entorno de Desarrollo Integrado) se ha utilizado
para crear el modelo de clases U. M. L. de la versión
desarrollada en Java Micro Edition.
Java Micro Edition 2.2 - Con estas herramientas es posible desarrollar la aplicación de
modo que pueda ser ejecutada en la mayoría de dispositivos
móviles que soportan Java.
- Las librerías de JME2 vienen incluidas en el entorno de
desarrollo de MotoDev.
MotoDev 2008 - Este E. D. I. está basado en Eclipse 3.4
- Permite construir proyectos de aplicativos basados en JME.
- Posee un emulador de dispositivos móviles de la mayoría de
líneas de motorola.
Versión Móvil C. L. D. C. - Connection Limited Device Confguration, estas librerías
permiten crear aplicaciones para dispositivos móviles con
limitaciones de memoria y procesamiento. Esto nos garantiza
que la aplicación desarrollada funcionará con gran holgura en
un dispositivo tipo P. D. A.
G. I. M. P. 2.6 - Esta aplicación de edición de imágenes posee las
potencialidades de herramientas tan completas como Adobe
Photo Shop.

Tabla 1. Herramientas utilizadas para el desarrollo del juego.

4Modelado del Problema.

4.1.1Invasores del Espacio para dispositivos móviles.

A fn de construir una aplicación que pueda ser modifcada y ampliada a posteriori, es de vital
importancia aplicar efcientemente la modularización y herencia. De igual forma, es fundamental
manejar de la forma más efciente posible los limitados recursos que posee un dispositivo móvil de
conectividad limitada.

En las ilustraciones 1 y 2 podemos apreciar el modelo de clases seguido para desarrollar la


solución, de modo que se aproveche de mejor manera la jerarquización de clases y asignación de
tareas.
ACV Pág. 4
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Ilustración 1. Modelo de clases U. M .L. Invasores del Espacio. Parte 11.

1 Se ha utilizado la nomenclatura de modelado de clases U. M. L. introducida en NetBeans para Java.


ACV Pág. 5
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Ilustración 2. Modelo de clases U. M .L. Invasores del Espacio. Parte 2.


ACV Pág. 6
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

4.1.2Descripción de las clases desarrolladas.

En esta sección se detallan las clases que se han desarrollado, así como el funcionamiento de los
métodos más importantes de cada una de ellas:

➢Principal . - Esta clase genera el MIDlet principal de la aplicacion. Dentro de ella se instancia al
Lienzo donde se colocaran los objetos del juego. Sus métodos más importantes son:
◦startApp() . - Método de la clase MIDlet, indica que cuando se cargue la aplicación se deberá
mostrar en pantalla el lienzo e iniciar el juego.
◦mostrarError(String error) . - Método que permite visualizar un error en pantalla. El objetivo del
mismo es ser invocado por el Lienzo
➢Lienzo . - Esta clase representa un lienzo o zona gráfca donde se dibujarán todos los elementos
del juego. Extiende la clase GameCanvas y con ello puede escuchar los eventos del teclado. Esta
clase es la mas importante, ya que instancia a:
◦Los marcianos
◦La nave espacial
◦Las barreras
◦Los disparos
A más de esto, implementa la interfaz java.lang.Runnable con el objetivo de crear un hilo que se
encargue de generar el bucle principal del juego. Sus métodos más importantes son:
◦cargarObjetos() . - Este método privado es el que se encarga de instanciar todos los objetos del
juego. Devuelve true si la operación fue exitosa y false en caso contrario.
◦run() . - Este método se implementa a través de la interface java.lang.Runnable. El objetivo es
poder crear un hilo que lo ejecute. Su tarea principal es:
▪1. Leer el estado de las teclas y determinar que se presionó:
•a. Tecla 4 => La nave se mueve hacia la izquierda.
•b. Tecla 6 => La nave se mueve hacia la derecha.
•c. Tecla 2 => La nave dispara.
▪2. Desplazar los disparos activos (si se ha generado algún disparo va moviéndolos según su tipo).
▪3. Consulta el tipo de colisión que se ha producido, con el fn de restar vidas o sumar puntos. Las
naves que generan más puntos son las de la primera fla, por ser las más difíciles de alcanzar.
▪4. Verifca si es que no existen disparos de los marcianos para generar un nuevo disparo de forma
aleatoria.
▪5. Invoca al método dibujar para actualizar posiciones de los elementos.

◦dibujar() . - Este método se encarga de dibujar los elementos en pantalla. Se encarga de ir


desplazando a los marcianos a través de la pantalla. De igual forma, escribe el total de puntos y
vidas que lleva el jugador.
◦verifcarColisiones() . - Este es el método lógico mas importante, ya que se encarga de detectar la
existencia de todo tipo de colisiones en el juego. Verifca los siguientes tipos de colisiones:
ACV Pág. 7
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

▪Disparo contra nave del héroe


▪Marciano contra barrera
▪Marciano contra nave del héroe
▪Disparo ya se del héroe o de los marcianos contra la barrera.
▪De igual forma, realiza las siguientes tareas:
•1. Muestra secuencia de estallido de la nave del héroe.
•2. Reinicializa los disparos cuando estos salen de la pantalla sin colisionar con naves, marcianos o
barreras.
•3. Verifca cuantos marcianos quedan por matar.
➢Marciano . - Esta clase representa un marciano que se puede colocar sobre la pantalla. Extiende
de ObjetoAbstracto y agrega funcionalidades para indicar el estallido del marciano y funciones
para mover el marciano dentro de la pantalla. Sus métodos más importantes son:
◦mover() . - Este método genera la secuencia de movimiento de los marcianos:
▪1. Se mueven hacia la derecha hasta llegar al borde de la pantalla.
▪2. Se desplazan una fla hacia abajo.
▪3. Inician el movimiento contrario al elegido en el paso 1.
➢ObjetoAbstracto . - Esta clase se constituye en la base abstracta para los marcianos, la nave
defensiva y los disparos. Provee métodos para generar movimiento, indicar el estado y especifcar
que ha entrado en explosión. Extiende de javax.microedition.lcdui.game.Sprite. Sus métodos más
importantes son:
◦moverIzquierda() . - Permite desplazar el objeto hacia la izquierda, previa verifcación que no se
salga de la pantalla.
◦moverAbajo() . - Permite desplazar el objeto hacia abajo, previa verifcación que no se salga
de la pantalla.
◦moverDerecha() . - Permite desplazar el objeto hacia la derecha, previa verifcación que no se
salga de la pantalla.
◦moverAbajo() . - Permite desplazar el objeto hacia abajo, previa verifcación que no se salga de la
pantalla.

4.1.3Defnición de los estados de los elementos de acción.

En esta sección se muestran los diagramas de los autómatas fnitos que se han seguido con el fn de
modelar los estados de los elementos del juego.

Autómata Marcianos.

Como se aprecia en la ilustración 3, tenemos 5 estados de transición. El primer estado se ha


modelado como un super estado, ya que mientras el marciano está activo muestra una pequeña
ACV Pág. 8
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

animación con cambio de tiras de imágenes o frames. Cuando el marciano es alcanzado por un
disparo, entra en el estado en que iniciará su explosión, a continuación para a quemarse, para
fnalmente quedar inactivo.

Ilustración 3. Autómata Finito Determinístico que modela el estado de los marcianos.

En la ilustración 4 podemos observar las imágenes que se han utilizado para modelar los diferentes
estados del marciano:

Ilustración 4. Tira de Imágenes que permite modelar los estados del marciano.

Autómata Nave Espacial.

Como se aprecia en la ilustración 5, tenemos 3 estados de transición. El primer estado de la nave es


activo. Cuando es alcanzada por un disparo de uno de los marcianos pasa a un estado de disparo,
donde entra a la explosión. En el siguiente estado la nave estalla y fnalmente se descuenta una
vida y vuelve a estar activo en caso de tener más vidas.
ACV Pág. 9
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Ilustración 5. Autómata Finito Determinístico que modela el estado de la nave del héroe.

En la ilustración 6 podemos observar las imágenes que se han utilizado para modelar los diferentes
estados de la nave del héroe:

Ilustración 4. Tira de Imágenes que permite modelar los estados del marciano.
ACV Pág. 10
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

4.2.1Invasores del Espacio en Flash.

El entorno Flash puede ser considerada una nueva plataforma, debido a que incluye todo lo
necesario para generar aplicaciones de forma que puedan ser ejecutadas de diversas maneras,
principalmente via internet, destacando la independencia de la plataforma fnal que esto requiere.
En general, una aplicación desarrollada en Flash puede ser ejecutada directamente, sin necesidad
de modifcar ninguna parte del codigo ni recompilar nada, en cualquier entorno que disponga del
reproductor Flash player (de distribución gratuita, y disponible para gran variedad de
dispositivos).

Conforme esta tecnologia ha ido evolucionando, ha pasado de ser una herramienta de autor con
una posibilidad de incluir programación mediante script, a un lenguaje practicamente completo y
adaptado a las estructuras y paradigmas mas generalmente utilizados.
La ultima versión (a la fecha del presente documento) del lenguaje utilizado en Flash es
ActionScript 3, compilable desde las versiones CS3 de la herramienta de creación, y pudiendo ser
ejecutado en los players desde la versión 9.
Nota: para el desarrollo presente podria haber sido sufciente utilizar la versión anterior del
lenguaje (ActionScript2), permitiendo ser ejecutada en players menos actualizados, pero se ha
optado por esta ultima versión por ser mas estricta, pero al mismo tiempo, mas limpia y semejante
a los paradigmas de programación orientada a objetos.

A continuación se muestra el esquema de clases desarrolladas específicamente para “Invasores del


Espacio (flash)” que posteriormente se pasa a comentar con mas detalle.

Juego
(MovieClip)
---------------
Marcador marcadores
--------------- players
ref enemigos
disparos
leerXML() parserNivel

Element
(MovieClip) Controlador
-------------- ---------------
controlador ref

Player Enemigo Disparo CKeyboard CZigZag CDisparo


(Element) (Element) (Element) (Controlador) (Controlador) (Controlador)

herencia de clase referencia a


objeto
ACV Pág. 11
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

4.2.2Descripción de las Clases Desarrolladas.

En general, aprovechamos el entorno de flash, como herramienta de autor, para la gestión de los
recurso (principalmente gráficos), y sirviendonos de “motor de juego”.
La principal carácterística básica del desarrollo en flash se basa en su jerarquia de clases, siendo
MovieClip la de mayor importancia.
Esta clase (de la que se hereda para generar el comportamiento principal de la aplicación)
representa un objeto gráfico que de forma automática es procesado en cada fase de dibujado,
incluye propiedades básicas para su gestión (posición, tamaño, etc) y puede ser conectado para la
recepción de Eventos del sistema.
La clase MovieClip puede ser considerada desde dos puntos de vista:
Como una secuencia de frames, con distintos contenidos gráficos y organizados en “capas de
dibujo”, y que automáticamente se dibujan secuencialmente (como una pelicula = “Movie”) a cada
fase de dibujado durante la ejecución de la aplicación.
O bien, como una secuencia de “estados” (visto el frame como un estado), definiendose en cada uno
de ellos los elementos a mostrar y gestionar de forma continuada, eliminandose o creandose nuevos
según se pase a otro estado (frame).
En base a esta segunda aproximación (que será aprovechada para el presente desarrollo), cabe
destacar otra característica clave de esta clase.
Un objeto MovieClip puede ser utilizado como “contenedor” de otros elementos (heredados de
MovieClip) que mantendrán su estado y propiedades individuales, y que serán procesados tanto
para dibujado como para recepción de eventos, de forma recursiva. (un objeto MovieClip contenido
en un objeto MovieClip superior, puede a su vez contener mas objetos MovieClip hijos).
De esta forma, podemos mantener un estado general “fijo” (sin cambiar a otro frame), mientras que
los MovieClip hijos contenidos en este puedan avanzar en su secuencia de frames, combinando
niveles vistos como “estados” con niveles en que se utilizan los MovieClips como simples
“animaciones gráficas”.
Tras conocer estas características ofrecidas por el entorno flash, y de las cuales sacaremos partido,
pasamos ahora a detallar las clases “propias” que se han definido para el desarrollo de “Invasores
del Espacio (flash)”:
Juego:
Esta clase (heredada de MovieClip) representará por un lado el cuerpo principal de la
aplicación, y por otro lado la representación gráfica del escenario base.
Desde el entorno flash se definen las características gráficas de la aplicación, tales como el
tamaño del area de dibujo, la velocidad de refresco (fps) y una serie de frames (utilizados
aqui como “estados” de la apliación) con su contenido a mostrar.
Quedan definidos 4 estados (frames), etiquetados como “menu”, “jugando”, “ganar” y
“perder”
En los estados “menu”, “ganar” y “perder” quedan definidos desde el entorno flash los
elementos a mostrar, tales como mensajes y botones, dejando el estado “jugando” vacio de
ACV Pág. 12
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

contenido, ya que este será creado dinámicamente por metodos de esta misma clase.
Esta clase representa el juego en sí, almacenando los elementos de forman parte de él.
Para una mayor organización y eficiencia en el acceso de estos elementos se definen tres
propiedades (heredadas de MovieClip) que servirán para almacenar por separado los grupos
referidos a Players, Enemigos y Disparos.
Hacer constar que, al ser contenedores, pueden haber varios Players simultaneamente en el
juego.
Juego() [constructor]: unicamente se llama a la funcion heredada “stop()” que nos asegura
que se mantendrá el estado actual, y se procesaran de forma continuada los elementos
contenidos en el primer frame (avanzando a otros “estados” solo de forma explicita).
FinalizarPartida() y reset(): Funciones auxiliares para iniciar (o reiniciar) los elementos
del juego.
CrearPartida(): Función que crea los elementos del juego, e inicializa el sistema de eventos
para que el juego se ponga en funcionamiento.
LeerXML(): Función que se encarga de crear los elementos en base a lo descrito en un
archivo XML externo.
OnEnterFrame(): Función invocada por el entorno flash, durante la ejecución de la
aplicación, a la llegada de un evento de dibujado. Representa el bucle principal clásico del
juego, apoyandose en las funciones “detectaColisiones()” y “valorarFindejuego()”.
[se omite en este bucle las llamadas explicitas a dibujado de los elementos, ya que al ser esta
clase heredada de MovieClip, todos los elementos MovieClip hijos serán dibujados
automáticamente. Esto es, los elementos incluidos dentro de los tres contenedores: Players,
Enemigos y Disparos]
[así mismo, se omiten las llamadas explicitas a la fase de update de los elementos, ya que
estos podrán recibir igualmente los eventos a los que se hayan suscrito, entre ellos el
“EnterFrame”]
detectaColisiones(): Funciones que comprueba iterativamente la colisión entre los
elementos del grupo Disparos, con los elementos de los grupos Players o Enemigos (según
el flag que indica si es un disparo generado por los “buenos” o los “enemigos”)
valorarFindejuego(): Esta función se encarga de interrumpir el bucle principal si se
considera que el juego a llegado a su fn. En esta version, las condiciones son que no quede
ningún elemento en la lista de Players o Enemigos. Según el resultado, se procede fnalizar
la partida y cambiar el estado general de la aplicación (saltar al frame etiquetado
correspondiente).
ActualizarMarcadores(): Esta función, recorre la lista de objetos “Marcador” llamando a su
metodo “update”, lo que provoca que cada marcador actualice sus datos mostrados.
parserNivel:
Clase auxiliar, utilizada para gestionar la carga de un archivo XML externo, recorrerlo y
crear los elementos defnidos para el juego.
Se basa en crear instancias de los elementos Player y Enemigo que son agregados a las
colecciones correspondientes de la clase Juego.
Los elementos se defnen con sus valores por defecto, que posteriormente son modifcados
ACV Pág. 13
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

si estos se encuentran defnidos en el archivo.


Tambien enlaza un Controlador generico (segun tipo de elemento), aunque puede ser
redefnido (así como los parámetros propios de este) si se encuentra indicado en el archivo
externo.

Element:
Esta clase (directamente heredada de MovieClip), defne las propiedades y metodos básicos
para el resto de elementos que se incluyen en el juego “Invasores del Espacio (fash)”.
Ya por sí, esta clase tiene las propiedades de posición (x,y), quedará vinculada su
representación gráfca dentro del entorno fash, y permitirá que reciban eventos del sistema.
Agrega propiedades propias defnidas para el juego, tales como velocidades y valores
máximos tanto para posición como velocidad. Guarda una referencia al elemento Juego
principal, y una referencia a un objeto (no-grafco) de la clase Controlador (o heredada), que
será la encargada de variar sus propiedades, y por tanto, controlar al elemento.
Defne los metodos basé para las acciones de init, destroy, responder al evento
onEnterFrame, y disparar. Posteriormente, cada clase específca, sobreescribirá estos
metodos para que se comporten acorde a su naturaleza (Player, Enemigo, Disparo, etc).
Player: (Element)
Redefne los metodos de creación (valores por defecto) y destrucción.
Tambien redefne el metodo “disparar”, para que los Disparos creados sean del tipo
BUENO, y se produzcan desde la posición del player, y en la dirección adecuada.
Enemigo: (Element)
Al igual que la clase Player, redefne los metodos de creación, destrucción y disparar,
acorde a su signifcado. Tambien inicializa el valor de la propiedad “modelo” que
determina su apariencia gráfca. (no utilizada por Player, ya que estos solo tienen una
posible representación)
Disparo: (Element)
Igualmente, lo unico que necesita esta clase es redefnir los metodos de creación y
destrucción acorde a su signifcado. Tambien hace uso de la propiedd “modelo”, para
representar de diferente forma los disparos según hayan sido generados por Players o por
Enemigos.
Marcador:
Tiene como representación gráfca un par de elementos TextField (nativos de fash). Se le
agrega una referencia a cualquier objeto heredado de Element (principalmente Player).
A través de su metodo “update”, accede a los valores de “puntos” y “vidas” del elemento
referenciado, para actualizar las cadenas de texto que es muestran en la escena.
Controlador:
Esta clase corresponde al “comportamiento” de un elemento.
Cada elemento tiene asignada una instancia de una clase heredada de Controlador, que se
encargará (a traves de la invocación a su metodo run()) de modifcar las propiedades del
objeto controlado, tales como posicion, velocidad, etc.
El comportamiento estandar (a ser sobreescrito por clases heredadas), modifca la posición
del elemento acorde a los valores de velocidad (es decir, crea un movimiento constante del
elemento), y se asegura que este no exceda los limites de posicion que tiene defnidos.
ACV Pág. 14
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Nota: Cualquier elemento (ya sea Player, Enemigo o Disparo) puede ser controlado por
cualquier clase heredada de Controlador, por lo que extendiendo esta clase y combinandola
con la asignación de los distintos elementos, podemos crear infnidad de comportamientos
para la aplicación. (Desde Enemigos controlados por teclado, como Disparos que no
mantengan direcciones lineales, o incluso que pueden a su vez crear nuevos Disparos.)
Cdisparo: (Controlador)
Defne un comportamiento simple (mantiene el movimiento rectilineo).
Unicamente se agrega la comprobacion de alcanzar los limites de posición, y forzando a la
destrucción automática del elemnto.
Pensado como comportamiento por defecto para los Disparos.
Cplayer: (Controlador)
Defne un comportamiento controlado por teclado.
Defne propiedades referentes a qué codigos de teclado responder.
En su fase de inicializacion, se registra para recibir los eventos de teclado (KeyDown y
KeyUp)
A la llegada de dichos eventos, actualiza los valores de velocidad del elemento controlado
y, en su caso, llama al metodo correspondiente de “disparar”
En su fase de fnalización, se encarga de eliminar su registro en la recepción de eventos.
Pensado como comportamiento por defecto para los Players.
CzigZag: (Controlador)
Defne un comportamiento basado en una maquina de estados.
Se defnen una serie de propiedades del controlador que regulan dicha maquina de estados.
Principalmente, desplazan al elemento controlado “a pasos”, cambiando de dirección, y
disparando (según un indice de probabilidad) cuando llegue el momento adecuado.
Pensado como comportamiento por defecto para los Enemigos.

4.2.3Defnición de los estados de los elementos de acción

El MovieClip que representa el “escenario” principal (y al que se le asigna la clase Juego para
gestionar su comportamiento, metodos y propiedades específcas).
De igual forma, se defne mediante el entorno de fash una serie de MovieClips en la libreria, los
cuales serán la representación gráfca de los objetos creados de la clase indicada para cada uno.
Estos MovieClips son tratados a dos niveles, creando una combinación de “estados”, con
MovieClips que representan “secuencias de animación”.
Player: (representación para la clase Player)
Defne un primer nivel de “estados”: normal, explosion_mini, explosion.
Internamente, en los estados “explosion_mini” y “explosion”, se utiliza un MovieClip a
modo de “secuencia de animación” (anim_explosion).

Disparo: (representación para la clase Disparo)


ACV Pág. 15
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

Defne unicamente la representación gráfca del disparo. (un solo estado)


Utiliza un MovieClip (imagenDisparo) a modo de “estado” (1..2), para poder seleccionar
entre dos modelos de disparos.
Enemigo: (representación para la clase Enemigo)
Defne un primer nivel de “estados”: normal, explosion.
En el estado explosión se hace un uso simple del MovieClip anim_explosion.
Internamente utiliza un MovieClip (imagenMalo) como otro nivel de “estados” (1..3), para
poder seleccionar entre tres modelos de Enemigo.
Finalmente, y dentro de este segundo nivel, encontramos el uso de los MovieClips
animMalo1, animMalo2 y animMalo3, creando un tercer nivel a modode “secuencia de
animación” para cada representación del Enemigo.

Player Enemigo
(estados) (estados)

X X normal X
normal explosion_mini explosion imagenMalo explosion
(image (secuencia) (secuencia) (estados) (secuencia)
)

Disparo
(estados) animMalo1 animMalo2 animMalo3 animMalo4
(secuencia) (secuencia) (secuencia) (secuencia)

imagenDisparo
(estados)

| |
malo bueno
(imagen) (imagen)
ACV Pág. 16
Prof: Ramón Molá Alumnos:
Universidad Politécnica de Valencia Fernando Ruíz - Vladímir Robles

5 Conclusiones.

➢Los autómatas finitos determinísticos han permitido modelar con gran precisión los estados de los
marcianos, disparos y de la nave del héroe.
➢El juego debe mantener una velocidad adecuada, a fin de que no existan tiempos muertos ni se
sobrepase el deadline establecido para los procesos de renderización.
➢Es posible conseguir una ampliación sustancial en cuanto a niveles si se modifican los valores de
los saltos horizontales y verticales de los marcianos, así como la cantidad de disparos que estos
hacen.

6 Bibliografía

[] Alberto García Serrano. Programación de juegos para móviles con J2ME. Bubok. Diciembre del
2008.
[] Ayuda incluida en el paquete Macromedia Flash CS3. (manuales y referencia de ActionScript 3)

7 Recursos gráfcos y de multimedia empleados.

Página Web con varios sprites y elementos decorativos:


➢http://www.panelmonkey.org/category.php?id=1&theme=1