Proyecto Informático 2018

SEGUNDO JUEGO: 1945

Vamos a diseñar un juego típico del estilo arcade. En este juego aprenderemos el uso de variables.
En este tipo de juegos, el jugador controlará un objeto, puede ser un avión, una nave espacial, un
coche, que se mueve sobre un fondo que se va desplazando. Los obstáculos aparecen en el fondo,
que tienen que ser evitados y los enemigos aparecerán, y estos deben ser eliminados. Por cada
enemigo que eliminamos el juego nos otorgará un puntaje. A medida que el juego avanza, será más
difícil sobrevivir.

La idea del juego

Nuestro juego consistirá en volar un avión sobre el mar, y nos atacarán aviones enemigos, a los
cuales tendremos que derribar.

Variables y propiedades
Este simple concepto proporcionará un mecanismo muy poderoso para permitir mucho más
interesante el juego. Entonces, ¿qué es una variable? Podemos decir que es una propiedad de una
instancia de un objeto. Como sabemos, hay ciertas propiedades que se pueden indicar cuando
definimos un objeto. Por ejemplo podemos establecer si es visible o si es sólida. También hay una
serie de acciones que cambian ciertas propiedades. Por ejemplo hay una acción para cambiar la
posición o la velocidad del objeto. Cada instancia tiene una serie de propiedades y también hay una
serie de propiedades globales, como la puntuación, que no están relacionados a los casos
individuales. Todas las propiedades se almacenan en las llamadas variables que tienen un nombre.

Propiedades / variables de cada instancia:

X: la coordenada x de la instancia
Y: la coordenada y de la instancia
Hspeed: la velocidad horizontal (en píxeles por paso)
Vspeed: la velocidad vertical (en píxeles por paso)
Direction: de la dirección actual del movimiento en grados (0-360; 0 es horizontal hacia la derecha)
Speed: la velocidad actual en esa dirección
Visible: si el objeto es visible (1) invisible (0)
Solid: si el objeto es sólido (1) no sólido (0)

Variables globales:

Score: el valor actual de la puntuación

Lives: el actual número de vidas
mouse_x: x-posición del mouse
mouse_y: y-posición del mouse
room_speed: velocidad actual de la pantalla (en pasos por segundo)
room_caption: título que se muestra en la ventana
room_width: ancho de la pantalla en píxeles
room_height: alto de la pantalla en píxeles

Hay muchas más variables, tanto individuales como globales. Como así también podrás definir tus
propias variables. Por ejemplo, si queremos que solo pueda disparar una vez que se complete un
ciclo de 5 pasos, nuestro avión necesitará una propiedad que pueda indicar si puede o no disparar.
Para ello usaremos una variable llamada disparo. Un nombre de variables consiste en letras,
números y el símbolo de subrayado, ojo que distingue entre mayúsculas y minúsculas. En este caso,
cuando creamos el avión (Evento Create), estableceremos esta variable en 1.
17
Proyecto Informático 2018

Siempre usaremos 1 para verdadero y 0 para Falso. Cuando el jugador quiera disparar, tendremos
que chequear que esta variable se encuentre en 1, y una vez que efectúa el disparo, esta variable
tendrá que colocarse en 0. Luego generaremos un evento de Alarma (Alarm) para establecer
nuevamente la variable var_disparo en 1 luego de 5 pasos. También podremos usar una variable
para indicar si tiene un escudo activo o no nuestro avión. Lo mismo si queremos usar armas
especiales.
Hay dos cosas que tenemos que tener en cuenta, esto lo encontramos en:

Set Variable: Establezca el valor de una variable. Con esta acción se puede cambiar el valor de
una variable dada. Esto puede ser una de las variables incorporadas o una variable propia. Se
especifica el nombre de la variable y el valor nuevo. Al marcar la casilla relativa al valor dado se
añade al valor actual de la variable. Tenga en cuenta que esto sólo se puede hacer si la variable ya
tiene un valor asignado. En lugar de proporcionar un valor simple para la variable también se puede
dar una expresión. Por ejemplo, para duplicar el puntaje que podría establecer el valor de la variable
score escribimos 2*score.

Test Variable: Chequear una variable: Con esta acción se puede comprobar cuál es el valor de
una variable en particular es. Si el valor de la variable es igual al número dado, la pregunta devuelve
verdadero y se lleva a cabo la siguiente acción o bloque de acciones. Si no es igual, no se lleva a
cabo la siguiente acción o bloque de acciones. También puede indicar que el chequeo debe ser si el
valor de la variable es menor que el valor dado o mayor que el valor dado. En realidad, no se limitan
al uso de variables, pero podemos comprobar cualquier expresión que desee.

A continuación vamos a ver una serie de ejemplos de la utilización de estas acciones.

Atención tenemos que saber una cosa más acerca de las variables. Indicamos que, hay variables
locales que "pertenecen" a una instancia y hay variables globales. Cuando creamos nuestras propias
variables son siempre las variables locales que sólo existen para la instancia en cuyas acciones se
usan. Si queremos crear variables globales hay que anteponerle al nombre la palabra global y un
punto. Así, por ejemplo, se puede utilizar un [Link] variable para indicar el número de puntos
de bonificación que se le dieron al jugador. Siempre tenemos que tener cuidado de utilizar nombres
de variables que aún no existen y sean diferentes a los nombres de los sprites, sonidos, etc Una
forma de lograr esto es tener en cuenta que los nombre de éstas comiencen con var_.

1945 (Primera Parte)

Veamos ahora en el juego que vamos crear. Antes de crear un juego que tenemos que escribir un
documento de diseño. A medida que el juego de 1945 que vamos a desarrollar se complique un
documento de diseño completo suele consistir en un par de páginas. Nos limitaremos a dar una
breve descripción. El juego se verá algo como esto:

18
Proyecto Informático 2018

1945 - Documento de Diseño

Descripción:

En este juego controlas un avión volando sobre un mar . Te encontrarás con aviones enemigos que
intentaran destruirte. Debes evitar estos o dispararles. El objetivo es permanecer vivo el mayor
tiempo que puedas y destruir a tantos aviones enemigos como puedas.

Objetos del Juego:

El fondo está formado por un mar desplazándose con algunas islas. El avión del jugador vuela sobre
este mar. Podemos disparar balas que destruyen los aviones enemigos. Hay cuatro tipos de aviones
enemigos: un avión que se encuentra y debe ser destruido, un avión que dispara balas hacia abajo,
un avión que dispara balas hacia el avión del jugador, y un avión enemigo rápido que viene de atrás
en lugar de venir desde el frente.

Sonidos:

Hay algunos sonidos de explosión y hay un poco de música de fondo.

Controles:

El jugador controla el juego con las teclas de las flechas. Con la tecla barra espaciadora dispara una
bala. Sólo una bala puede ser disparada cada cinco pasos.

Flujo del Juego:

El jugador comienza de inmediato el juego. El jugador tiene tres vidas. Cuando utilizó todas las vidas
se muestra una tabla de puntuaciones máximas. Al pulsar la tecla <F1> (ayuda) le dará una breve
explicación. Al pulsar la tecla <Esc> terminará el juego.

Niveles:

Hay un solo nivel, pero cada vez más aviones enemigos llegarán, primero sólo el tipo fácil, pero más
tarde los tipos más difíciles.

El jugador controla el avión amarillo grande que vuela hacia arriba. Los cuatro tipos de aviones
enemigos se muestran en la imagen de arriba. En la parte inferior de la pantalla se muestra la
puntuación, el número de vidas que quedan, y el daño que tiene nuestro avión (en la forma de la
barra verde).

La ilusión del Movimiento

En el juego 1945 los mundos se moverán verticalmente. A pesar de que el plano de los controles del
reproductor estarán fijos en la pantalla se va a tener la impresión como si vuela sobre el fondo que
se va a estar desplazando. Podemos controlar la posición del plano moviéndolo por la pantalla. Esto
va a dar la impresión de que el avión está acelerando, cuando se mueve hacia delante, o reduciendo
la velocidad cuando se mueve hacia atrás.

¿Cómo lo creamos?

Tenemos dos posibilidades.

 La primera y más sencilla posibilidad es usar una imagen de fondo de mosaico que se mueve
hacia abajo a través de la pantalla..

19
Proyecto Informático 2018

 La segunda más complicado, cierto, es la construcción de una pantalla mucho más grande,
pero sólo muestra una parte de la misma, usando una parte de ella. Este parte se mueve
lentamente hacia arriba sobre la ventana.
Vamos a comenzar con el uso de un fondo en movimiento.
 Armamos la Pantalla de nuestro juego, a éste lo llamaremos pant_ppal. (Room)
 Necesitamos una imagen, agregamos la siguiente imagen pequeña como un recurso de

fondo, es decir opción Backgrounds y le damos el nombre back_agua: , la cual se

encuentra en la carpeta Juego2. Recorda que para
poder armar esto tenés que generar el sprite, y luego
el objeto, denominándolo back_agua.
 Vamos a generar la pantalla del juego. Opción
Rooms. Destiladamos en la solapa Background la
opción Draw background color debido a que
nosotros vamos a rellenar totalmente el fondo con el
objeto.
 En la zona inferior, elegimos la imagen de fondo, que
en nuestro caso es back_agua. Chequeamos tener
tildadas las opciones Tile Hor. Y Tile Vert. Con lo
que la imagen se va a repetir por todo el fondo.
 Movimiento del fondo: Como queremos que se mueva en forma vertical, en la sola
Background, donde dice Vert. Speed escribimos 2.
 Probamos nuestro juego. Opción RUN.
 Agregando Islas. Para poder tener una mejor sensación de movimiento agregaremos unas
islas a nuestro fondo, por lo tanto, recordamos que para poder agregar estos objetos al fondo,
primero tenemos que definir los sprites correspondientes, y luego los objetos, una vez que
tenemos esto podemos agregarlos a nuestro fondo. Los archivos que poseen las imágenes
de las islas son: [Link], [Link] e [Link].
o Si las colocamos directamente sobre el fondo, podremos observar que se mueve el fondo
y las islas no, probalo.
o Si generamos una imagen de fondo con las islas, y utilizamos ésta como fondo de
nuestra pantalla, van a aparecer siempre en el mismo lugar.
o Lo que haremos es al objeto que generamos otorgarles Eventos y Acciones para
independizar a cada una de nuestras islas en nuestra pantall.
o Evento Colission: Como nunca vamos a utilizarlas para comprobar la colisión es mejor
desactiva la comprobación de colisión precisa caja.
o Evento Create:

 Velocidad Vertical: Es la misma que la velocidad de desplazamiento del fondo

(2). De esta manera, parece como si las islas son parte del fondo, ya que se quedan
en la misma posición con respecto al mar de desplazamiento.
 Depth: Cuando creamos los demás objetos, y que tenga la sensación de que están
por arriba de las islas, tendremos que definirle a las islas una profundidad (Depth) de
10.000. Los objetos se dibujan en el orden de la profundidad. Los que tienen mayor
profundidad se dibujan primero. Los objetos menor profundidad se dibujan en la parte
superior de ellos.
o Evento Step: Cuando la isla desaparece debajo de la parte inferior de la pantalla, tendría
que volver a aparecer en la parte superior.
 Creamos el Evento Step de la isla en él tenemos que chequear si la isla desapareció
debajo de la pantalla y, si es así, que vuelva a aparecer en la parte superior.
Recordando las variables, la variable Y indica la posición vertical del objeto. (Un valor
de 0 corresponde a la parte superior de la pantalla) La variable room_height indica la
altura de la pantalla. Así que la isla desaparece debajo de la parte inferior de la
pantalla cuando y > room_height. Así que podemos utilizar la acción Test para
chequear los valores de variables, y ver si la isla se encuentra debajo de la pantalla.

20
Proyecto Informático 2018

Seleccionamos la Solapa Control. Seleccionamos la Acción Test Variable. En

variable completamos con “y”, en value “room_height”, y en operation con “larger
than” (mayor que).
 Queremos que aparezca nuevamente en la parte superior de la pantalla, para ello

vamos a usar la Acción de Jump to a position . Queremos que esta posición no

sea siempre la misma, es decir que sea a azar. Pero esto un puede ser en cualquier
lugar como si apareciera de la nada, es decir tiene que aparecer de la parte superior.
Por lo tanto el número al azar tiene que ser bastante particular. Usaremos la función
random(). En esta función dentro de los paréntesis tenemos que colocar el
argumento, es decir hasta que valor puede elegir. Por lo tanto, nosotros en el valor de
X, usaremos random(room_width) como valor de la coordenada para X. y en el valor
de Y escribimos el número -65 para asegurarnos que va a tomar como coordenada de
Y un valor seguro que por arriba de la pantalla.
o Esto lo hacemos para las tres islas.
o Agregamos los objetos en nuestra pantalla.
o Ejecutamos el juego.
o Vamos grabando el mismo con el nombre de 1945 inicial en nuestra carpeta de trabajo.

El avión principal

Ahora estamos en condiciones de poder crear el avión que manejará nuestro jugador. Vamos a
utilizar un avión con hélices, para dar la ilusión de que las hélices giran,
utilizamos un sprite que consta de tres imágenes que son exactamente
iguales excepto las hélices:

Creamos el sprite: spr_miavion

Buscamos en nuestra carpeta de Juego2, la imagen myplane_strip3.png donde ese número 3 al
final del mismo es para orientarnos que tiene 3 subimágenes.
Establecemos el X e Y del origen a 32. Esto significa que el origen del sprite es el centro del plano.
Así que cada vez que tengamos que ubicar el avión en una posición o evaluar la posición, nos
referimos a la posición del centro de éste, y que no es el punto superior izquierdo (0,0), que se utiliza
normalmente como el origen. Esto es importante para tener en cuenta, por ejemplo que las balas
vienen desde el centro del avión, y no desde el lado izquierdo.

Creamos el objeto: obj_miavion

Elegimos el sprite que creamos: spr_miavion
Le damos una profundidad (Depth) de -100 para asegurarnos que va a estar por encima de las
balas, que vamos a crear más adelante.
Por el momento sólo tenemos que especificar el movimiento del avión. Cuando el jugador no hace
nada, el avión no se moverá. (Recordamos, el fondo se mueve, no el avión). Si el jugador presiona
una de las cuatro teclas de las flechitas el avión deberá moverse en la dirección correspondiente.
Nuestra principal preocupación es evitar que el avión se mueva fuera de la pantalla. Para ello vamos
a controlar el movimiento, en lugar de darle al avión una velocidad.

Programando las teclas de control del Avión

En el objeto del avión, obj_avion, vamos a agregar el Evento de la teclas:

 Agregamos el Evento Keyboard, y dentro de éste, el de la tecla izquierda (Left)
 Tenemos que comprobar que no esté demasiado a la izquierda de la pantalla. Esto significa que
tenemos que evaluar la variable X que no sea mayor que 40.
o Solapa Control, Seleccionamos Test Variable, completamos: Variable: X, Value: 40,
Operation: larger than.
o Si esta comprobación devuelve true (verdadero) queremos mover el avión una pequeña
distancia a la izquierda en relación a su posición actual.

21
Proyecto Informático 2018

o Para ello utilizamos la acción “Jump to a position” (saltar a una posición), de la solapa Move
para moverse con relación -4 para x y 0 para y. No nos olvides de activar la casilla Relative.
 Para la flecha hacia la derecha que hacemos lo mismo, pero agregando el evento cuando
presionamos la tecla de la derecha (Right). Tenemos que comprobar si x es menor que
room_width - 40 y, en caso afirmativo, saltamos en relación con una x de 4 e y de 0 Relativo.
o Para las flechas hacia arriba (Up). Seleccionamos Test Variable, completamos: Variable: y,
Value: 40, Operation: larger tan y un “Jump to a position” x de 0 e y de -2. Relativo.
y hacia abajo (Down) Seleccionamos Test Variable, completamos: Variable: y, Value:
room_height-120, Operation: es menor que y un “Jump to a position” x de 0 e y de 2.
Relativo
 Agregamos el objeto del avión en algún lugar de nuestra pantalla.
 Lo volvemos a guardar y tenemos nuestra primera parte del juego terminada. Esto es armamos
un fondo que se mueve, colocamos objetos que aparecerán en lugares diferentes de la pantalla,
y colocamos a nuestro protagonista, nuestro avión, pudiendo tener el control de éste.

Enemigos y armas (Segunda Parte)

Ampliaremos nuestro juego, de forma tal que aparezcan aviones enemigos y que podamos
dispararles, para ello abrimos nuestro archivo 1945_inicial.gmk y lo guardamos con el nombre
1945_ataques.gmk en nuestra carpeta de trabajo. A partir de ahora trabajaremos con este
segundo archivo.

Necesitamos un sprite que nos represente la bala. Lo armamos teniendo en cuenta que su
origen no sea el vértice superior izquierdo sino el centro, el mismo que usamos para nuestro avión, lo
llamamos spr_bala.
Creamos el objeto con este sprite, obj_bala, le damos una profundidad (Depth) de 0 (cero),
aparecerá debajo del avión pero por encima de las islas.

En el OBJETO DE LA BALA:
EVENTO DE CREACIÓN
o Acción (Set the vertical speed) le damos una velocidad vertical de -8, esto hará que la bala
se mueva hacia arriba.
Tenemos que evitar que las balas sigan volando por todos lados, tenemos que destruirlas una vez
que salen de la pantalla.
En el Evento Step, tenemos que chequear que la variable y sea menos que -16. Si esto
sucede destruimos el objeto
o If a variable has a value para evaluar que la coordenada y sea menor a -16.

o , Destroy the Instance. (Esto también lo podíamos realizar utilizando el Evento que se
encuentra dentro de Other, Outside Room).

La bala tiene que salir de nuestro avión, cuando el jugador presiona la tecla [Barra Espaciadora].
Cada vez que el jugador presione dicha tecla, tendrá que disparar una bala, pero como no queremos
que sea algo continuo, permitiremos que el jugador pueda disparar dos balas por segundo, es decir
una bala cada 15 pasos.
Para esto utilizaremos una variable puedo_disparar.

En el OBJETO DE NUESTRO AVION:

EVENTO DE CREACIÓN
o Acción , establecemos esta variable en 1, es decir que es verdadero, que podemos
disparar una bala.
EVENTO: Cuando se presiona la tecla [Barra Espaciadora]:
o Tenemos que comprobar si la variable puedo_disparar es igual a 1. Si es así tiene que
hacer todo lo que sigue, para lo cual vamos a crear un bloque (block) con estos pasos:

22
Proyecto Informático 2018

 Iniciamos el bloque, solapa Control, acción Start of a block.

 Si es así creamos una bala en frente de la nave, solapa Main1, acción Create
Instance, relativa a la posición (0,-16)
 Colocamos la variable puedo_disparar en 0, que indica que no podemos disparar.

 Configuramos la alarma 0 (alarm0) a 15, La acción Alarm se encuentra en la solapa

Main2. Recordamos que una alarma hace una cuenta regresiva a 0 (cero) para el Evento
Alarm.
 Fin de bloque .

 Fijamos la variable puedo_disparar nuevamente a 1, para que pueda disparar nuevamente.

o Evento Alarm

o Acción Colocamos la variable puedo_disparar en 1

PRIMER AVIÓN ENEMIGO: Este avión volará hacia abajo. No va a disparar. Cuando este llega a
nuestro avión, pierde.
 Creamos el sprite, como spr_enemigo1, y el objeto correspondiente, obj_enemigo1, utilizando
el archivo enemy1_strip3.png de la carpeta Juego2.
 En el Evento de Creación, establecemos una velocidad vertical de 4 (positiva porque va a ir
hacia abajo).
 Cuando el avión llega al final de la pantalla, tiene que volver a aparecer en cualquier lugar de la
parte superior de la pantalla (al azar), tal como lo hicimos con las islas.
o Evento Step
 Acción si la variable y es mayor que room_height+32
 Saltar a la posición x=random(room_width) y=-16

 Tenemos que definir dos Eventos de Colisión:

o Con la bala, que debe destruir al avión enemigo.
 Creamos un sonido para la explosión, usando el archivo snd_explosion1.wav.
 Creamos un sprite para la explosión, usando el archivo explosion1_strip6.png, con una
coordenada de origen de (16,16).
 Creamos un objeto para la explosión, con el sprite que armamos. Este no hará nada,
excepto cuando se destruye , que usaremos un Evento denominado Animation End,
que se encuentra dentro de los Eventos denominado Other.
 Podemos armar el Evento Colisión,
para el avión enemigo con la bala: Las
acciones correspondientes serán:
 El Sonido de la explosión, y luego
destruimos la bala.
 Creamos el objeto de la explosión
relativa a la posición (0,0) es decir,
donde se encuentra el avión del
enemigo.
 No destruimos el avión enemigo,
sino que lo ubicamos en forma
aleatoria arriba de la pantalla,
como si otro avión se acercara.
 Incrementamos la puntuación en 5. Es decir la variable score, en forma relativa se
incremente a medida que destruye aviones enemigos.

o Con nuestro avión, que debe destruir nuestro avión, y finalizar el juego.
 Creamos un sonido para la explosión, usando el archivo snd_explosion2.wav.
23
Proyecto Informático 2018

 Creamos un sprite spr_explosion2 para la explosión, usando el archivo

explosion2_strip7.png, con una coordenada de origen de (16,16).
 Creamos un objeto obj_explosion2 para la explosión, con el sprite que armamos, a
diferencia de la explosión anterior, tendrá también que terminar el juego.
 En nuestro OBJETO DE LA EXPLOSIÓN2, agregamos el Evento Animation End, en el
cual se realizarán las siguientes acciones:
 Destruimos el objeto, la instancia.
 Vamos a dejar suspendido, como durmiendo, el juego mientras termina el sonido,
aproximadamente 1000 milisegundos.
 La próxima acción será mostrar la tabla de los puntajes más altos, High-score
List, en ella el jugador podrá escribir su nombre en el lugar correspondiente. Esta tabla
se puede personalizar.
 Luego tendrá que comenzar nuevamente el juego. Solapa Main2, Restart Game.

Hasta ahora tenemos nuestro avión y un solo avión enemigo. Podemos hacer que a medida que
pasa el tiempo se incremente la cantidad de aviones enemigos, para hacer más difícil el juego.
Para ello hacemos lo siguiente:
 Creamos un objeto, el cual llamamos control_enemigo, el cual creará aviones enemigos.
No tendrá ningún sprite.
 Haremos que este objeto sea invisible, porque es de control, para ello destildamos la
casilla Visible.
 En el Evento de Creación:
 Creamos un avión enemigo en una ubicación aleatoria, en la parte superior de la
pantalla. En objeto colocamos el objeto de nuestro avión enemigo, en el valor de X, un
valor al azar del ancho de la pantalla, y en el valor de Y escribimos -16.

 Establecemos la Alarma 0 en 200.

 En el Evento Alarm 0:
 Creamos un avión enemigo en una ubicación aleatoria, en la parte superior de la
pantalla. En objeto colocamos el objeto de nuestro avión enemigo, en el valor de X, un
valor al azar del ancho de la pantalla, y en el valor de Y escribimos -16.

 Establecemos la Alarma 0 en 500.

El efecto es que en el comienzo del juego hay un avión enemigo. Después de 200 pasos, es decir,
unos siete segundos, aparece un segundo avión enemigo. Después de unos 15 segundos, aparece
un tercer avión, etc
Coloque un objeto del control_enemigo en la pantalla, este objeto por ser invisible no se verá pero
será el que genera los diferentes aviones enemigos.
Terminamos la segunda parte. Guardamos nuevamente nuestro archivo en la carpeta de trabajo.

Puntajes, vidas y daños (Tercera Parte)

Ampliaremos nuestro juego, de forma tal que los aviones enemigos nos produzcan daños, y recién
cuando está muy dañado sea destruido, también agregaremos vidas para nuestro avión, y todo esto
visible al jugador. Para ello abrimos nuestro archivo 1945_ataques.gmk y lo guardamos con el
nombre 1945_vidas.gmk en nuestra carpeta de trabajo. A partir de ahora trabajaremos con este
nuevo archivo.
Para crear todo esto, tenemos que generar un nuevo objeto, que lo llamaremos control_vidas. No
necesita que armemos el sprite, porque no controlará ningún dibujo.
Cuando comienza el juego, queremos que aparezca en la zona inferior, un lugar donde aparezca la
cantidad de vidas que tenemos, y el estado de nuestra
vida, como también el puntaje que vamos adquiriendo.
Para ello armaremos un sprite, que funcionará como panel.
24
Proyecto Informático 2018

Este nos informará el puntaje, el daño que nos hicieron, y el número de vidas, representado por
imágenes de aviones. En el evento del objeto control_vidas dibujaremos en el sprite del panel toda
esta información en la ubicación correcta.

Esto colocará el sprite en la parte inferior de la pantalla Para asegurarnos que el panel se encuentra
por encima de todo lo demás le damos al objeto control_vidas una profundidad de -10.000 (Depth)

Evento CREACION ( 'Create event' )

 Colocamos el Puntaje (Score) en 0 (cero) ( Set the score)
 Número de vidas en 3 ( Set the number of lives)
 Estado de salud en 100 ( Set the health)
Evento DIBUJO ( 'Drawing event')
 Dibujamos el sprite del panel ( Draw a sprite image) (los
datos en la imagen anterior)
 Colocamos el color en amarillo ( Set the colors)
 Dibujamos el Puntaje, las coordenadas, x=180 y=440 (
Draw the value of score)
 Dibujamos las vidas, a través de un sprite ( Draw the lives
as image), tenemos que indicar donde queremos que se
ubiquen los sprites (x=16 y=410), y la imagen spr_vida y en
subimage -1). (El uso de -1 para la sub-imagen significa que la
subimagen actual se dibuja. Como sólo hay una subimagen del sprite esto realmente no nos preocupa,
pero si un sprite se compone de varios sub-imágenes que puede indicar aquí la subimagen que desee
ver.)
 Dibujamos el estado de salud o de daño, tenemos que
indicar la posición el tamaño y como se va a ir
completando. ( Set the health) (Completamos: x1=12,
y1=449, x2=138, y2=459, back color=none, bar color=
green to red)
Nos tendría que quedar las propiedades del control_vidas como
lo vemos en la figura.

Ahora tenemos estar chequeando continuamente el daño de nuestro avión y las vidas que tenemos.
Primero tenemos que hacer algunas modificaciones en el EVENTO COLISIÓN, de los aviones enemigos con
nuestro avión. No debe ser destruido nuestro avión, sino que tiene que existir una explosión y disminuir la
salud que le queda, la disminuiremos en forma relativa en -30, así aproximadamente se destruiría nuestro
avión (esa vida) en tres colisiones.

Modificamos los eventos y acciónes en nuestra explosión2. Es decir la explosión de nuestro avión
cuando perdió toda su potencia (salud), para ello:
 En el obj_explosion2 objeto modificamos el Evento de Animación:
o Destruimos el objeto ( Destroy the instance)
o Se hace una pausa de unos 1000 milisegundos ( Sleep for a while)
o Creamos nuevamente nuestro avión, en la posición relativa. ( Create an instance of an
object) elegimos el objeto obj_miavion
o Tenemos que disminuir la cantidad de vidas, es decir restarle 1, por lo tanto indicaremos -1
en forma relative. ( Set the number of lives)

El objeto control_vidas, chequeará cuando la salud sea menor que 0 (cero). Esto sería:
25
Proyecto Informático 2018

Evento OTHERS / NO MORE HEALTH

 Colocamos nuevamente la salud al 100% ( Set the health)
 Se escucha la explosión: ( Play a sound) elegimos el sonido de la explosión y el loop en
falso para que no se repita.
 Cambiamos nuestro avión por la explosión ( Change the instance). Lo completamos de
la siguiente forma:
o Applies, elegimos Object: obj_miavion
o Change into: obj_explosion2
o Perform events: not
Necesitamos saber si se terminaron las vidas, en caso afirmativo el juego finalizaría. Para ello
usaremos el objeto control_vidas.
Evento OTHERS / NO MORE LIVES
 Mostramos la tabla de posiciones: Display the highscore table La ventana que nos
aparece la completamos, utilizando como fondo que fondo_agua, que muestre el borde, y
elegí los colores y la tipografía.
 Que el juego vuelva a comenzar: Restart the game

Finalizamos nuestro juego, su tercera parte.

Más Enemigos (Cuarta Parte)

En esta etapa del juego, agregaremos tres tipos de enemigos nuevos. Uno de ellos nos disparará
balas hacia abajo, el segundo dispara balas hacia el avión principal, y tercero no dispará balas, sino
que viene desde el fondo de la pantalla, y será más difícil dispararle o evitarlo.
Guardamos el archivo con el que estamos trabajando con el nombre de 1945_enemigos.gmk.

SEGUNDO AVION ENEMIGO

Creamos un nuevo sprite, igual al que teníamos hasta el momento pero de otro color, utilizamos el
archivo enemy2_strip3.png.
Crear el sprite: spr_enemigo2
Crear el objeto: obj_enemigo2. Podemos duplicar el obj_enemigo1, y cambiarle el sprite,
ya que todo lo que sucedía con el enemigo1 tiene que suceder con el enemigo 2, y debemos
agregarle acciones. (Botón derecho sobre el objeto, y elegimos DUPLICATE luego
modificamos el nombre y elegimos el sprite que corresponde)
Como este es un avión especial, le modificamos en el evento de colisión de este objeto
con la bala, el puntaje, le colocamos que se incremente en 10. (relative tiene que estar
tildado)

BALA DEL SEGUNDO AVION ENEMIGO

Necesitamos una bala diferente para que dispare el avión enemigo, por lo tanto vamos a armar un
nuevo objeto con el archivo [Link], para la bala de nuestro enemigo.
Crear el sprite: spr_balaenemiga1
Crear el objeto: obj_balaenemiga1. Le armamos la siguiente serie de eventos/acciones:
Evento CREATE
o Le colocamos una Acción de velocidad vertical de 8
Evento STEP
o Chequeamos la variable y, (vertical). Si la variable y es mayor que room_height+16
o Destruidos el objeto (la instancia)
Evento COLISION CON EL OBJETO DE MI AVION
o Emita un sonido de explosión (podemos generar un tercer sonido de explosión)
o Se destruya el objeto (la instancia)
o Le reducimos el nivel de salud en 5, (Set the Health relative en -5)

26
Proyecto Informático 2018

DISPARANDO LAS BALAS

Ahora necesitamos que el avión enemigo dispare las balas de vez en cuando. Esto se hará en el
objeto del avión, a través de un Evento STEP.
Vamos al objeto del Avión del enemigo 2 (obj_enemigo2)
Evento STEP
o Utilizaremos la acción de tirar un dado, y como parámetro colocaremos 30. Esto significa,
que esta acción se realizará, en promedio, cada 30 pasos. ( With a chance perform
next action)
o Acción CREATE INSTANCE ( ). Creamos la bala enemiga, con el objeto
obj_balaenemiga1, en x=0 e y=16, y relativo para que salga del avión.
APARICION DEL SEGUNDO AVION ENEMIGO
Nos falta que aparezcan estos aviones enemigos que recién creamos. Utilizaremos el objeto,
denominado control_enemigo, que ya utilizamos para que aparezca el primer avión enemigo.
Abrimos el objeto: control_enemigo
Evento CREATE
o Establecemos la Alarma 1 en 1000
Evento ALARM 1
o Creamos la instancia para que aparezca el obj_enemigo2, los valores de las coordenadas
serán: x= random(room_width), y=-16 ( Create an instance of an object)
o Establecemos la Alarma 1 en 500. De esta forma aparecerán en tiempos diferentes los
dos aviones enemigos definidos hasta el momento, el primero aparecerá
aproximadamente cada 30 segundos, y este último cada 15 segundos. ( Set an alarm
clock)

TERCER AVION ENEMIGO

Creamos un nuevo sprite, igual al que teníamos hasta el momento pero de otro color, utilizamos el
archivo enemy3_strip3.png.
Crear el sprite: spr_enemigo3
Crear el objeto: obj_enemigo3. Podemos duplicar el obj_enemigo2, y cambiarle el sprite,
ya que todo lo que sucedía con el enemigo2 tiene que suceder con el enemigo 3, y debemos
agregarle acciones. No lo hacemos con el enemigo1 ya que el segundo dispara balas, y el
primero no, y nuestro tercer enemigo también va a disparar balas.
En el Evento STEP
o Modificamos la Acción: With a chance perform next action, donde colocamos que
suceda cada 80 pasos.
o Modificamos la Acción CREATE INSTANCE ( ). Creamos la bala enemiga número 2,
con el objeto obj_balaenemiga2, en x=0 e y=16, y relativo para que salga del avión
o Modificamos el Evento de Colisión de este objeto con la bala, el puntaje, le colocamos
que se incremente en 20. (relative tiene que estar tildado)

BALA DEL TERCER AVION ENEMIGO

Necesitamos una bala diferente para que dispare el avión enemigo, por lo tanto vamos a armar un
nuevo objeto con el archivo [Link], para la bala de nuestro enemigo.
Crear el sprite: spr_balaenemiga2
Crear el objeto: obj_balaenemiga2. Le armamos la siguiente serie de eventos/acciones:
Evento CREATE
o Chequeamos i nuestro avión existe, para ello tenemos que comprobar que la instancia del
avión sea mayor a 1. Usamos la Acción If the number of instances is a value,
completamos:
 Object: obj_miavion // Number: 0 // Operation: larger than

27
Proyecto Informático 2018

o Usamos la Acción: Movimiento hacia un punto, para que la bala se dirija hacia
nuestro avión, por lo tanto colocamos como coordenadas las que tiene actualmente
nuestro avión: x=obj_miavion.x, y=obj_miavion.y, speed= 8.
o Else (En otro caso): Si el avión no se
encuentra, tendría que ir hacia abajo, por lo
tanto:
o Le colocamos una Acción de velocidad
vertical de 8
Evento COLISION CON EL OBJETO DE MI AVION
o Emita un sonido de explosión (podemos generar un tercer sonido de explosión)
o Se destruya el objeto (la instancia)
o Le reducimos el nivel de salud en 5, (Set the Health relative en -5)
Evento OTHER / OUTSIDE ROOM (Si se va de la pantalla, porque no tiene una dirección fija,
usamos esta opción)
o Destruir el objeto (Destroy the Instance)

APARICION DEL TERCER AVION ENEMIGO

Nos falta que aparezcan estos aviones enemigos que recién creamos. Utilizaremos el objeto,
denominado control_enemigo, que ya utilizamos para que aparezcan los otros aviones enemigos.
Abrimos el objeto: control_enemigo
Evento CREATE
o Establecemos la Alarma 2 en 2000
Evento ALARM 2
o Creamos la instancia para que aparezca el obj_enemigo3, los valores de las coordenadas
serán: x= random(room_width), y=-16 ( Create an instance of an object)
o Establecemos la Alarma 2 en 1000. ( Set an alarm clock)

CUARTO AVION ENEMIGO

Creamos un nuevo sprite, igual al que teníamos hasta el momento pero de otro color, utilizamos el
archivo enemy4_strip3.png. Este será el avión que viene de abajo, es decir será igual que nuestro
enemigo1, sin balas, pero viene en sentido contrario.
Crear el sprite: spr_enemigo4
Crear el objeto: obj_enemigo4. Podemos duplicar el obj_enemigo1, y cambiarle el sprite,
ya que todo lo que sucedía con el enemigo1 tiene que suceder con el enemigo 4, y debemos
modificar acciones.
Evento CREATE
o Modificamos la Velocidad y colocamos -4 (para que suba)
Evento STEP
o Modificamos el chequeo de la variable, evaluamos si y es menor que -32.

o Salte a la posición x= random(room_width), y= room_height+16

Evento COLISIÓN CON MI AVION
o Salte a la posición x= random(room_width), y= room_height+16
Evento COLISIÓN CON LA BALA
o Salte a la posición x= random(room_width), y= room_height+16

APARICION DEL CUARTO AVION ENEMIGO

Nos falta que aparezcan estos aviones enemigos que recién creamos. Utilizaremos el objeto,
denominado control_enemigo, que ya utilizamos para que aparezcan los otros aviones enemigos.
Abrimos el objeto: control_enemigo
Evento CREATE
o Establecemos la Alarma 3 en 3000
28
Proyecto Informático 2018

Evento ALARM 3
o Creamos la instancia para que aparezca el obj_enemigo4, las coordenadas serán:
x= random(room_width), y= room_height+16 ( Create an instance of an object)
o Establecemos la Alarma 3 en 300. ( Set an alarm clock)
Finalizamos la cuarta parte del juego.

Más Enemigos (Quinta Parte)

Le agregaremos música de fondo, una imagen mientras se carga nuestro juego, ocupe toda la
pantalla, tenga un bono extra si alcanza un puntaje de 400, y otro si llega a los 1000 puntos.
Con esto podrás agregarle a tu juego, elementos como reparar el daño que tiene, dar una vida más,
puntos extra, poderes especiales, etc. Como así también aviones enemigos más potentes, que
vuelen en forma transversal, etc. Guardamos nuestro archivo con el nombre 1945_5.gmk.
CREANDO EL SONIDO DE FONDO

Vamos a SOUNDS
Cargamos el sonido que queremos de fondo (Botón Load Sound)
Tildamos la opción BACKGROUND MUSIC
Click en OK

OCUPANDO TODA LA PANTALLA

Vamos a GLOBAL GAME SETTINGS

Solapa GRAPHICS
o Tildamos la opción START IN FULL-SCREEN MODE
o Si elegimos KEEP ASPECT RATIO: Se mantiene la proporcionalidad
o Si elegimos FULL SCALE: Se adapta a nuestra pantalla.
Click en OK

IMAGEN MIENTRAS SE CARGA EL JUEGO

Vamos a GLOBAL GAME SETTINGS

Solapa LOADING
o Tildamos la opción SHOW YOUR OWN IMAGE WHILE LOADING
o Hacemos click en CHANGE IMAGE y elegimos la imagen.
o En la zona central: (la barra que indica el progreso de carga)
 NO LOADING PROGRESS BAR: no se muestra la barra.
 DEFAULT LOADING PROGRESS BAR: muestra la barra, que viene en Game Maker.
 OWN LOADING PROGRESS BAR: Armamos nuestra propia barra de progreso, con una
imagen de fondo (Back Image) y una imagen frontal (Front Image)
Click en OK

ICONO DEL JUEGO

Vamos a GLOBAL GAME SETTINGS

Solapa LOADING
En GAME ICON, tenemos un botón CHANGE ICON, donde podemos buscar un Icono que
represente nuestro juego.
Click en OK

AGREGANDO AVIONES, BARCOS, ETC

En la carpeta Juego2, tenemos un archivo llamado 1945_sprites.bmp, en el cual hay una gran
cantidad de sprites, para este juego. Los podes usar para mejorar tu juego, agregando aviones,
barcos, islas, etc.
29
Proyecto Informático 2018

Para poder generar el archivo del sprite tenes que seguir los pasos:
Click en CREATE A SPRITE
Click en EDIT SPRITE
Menú FILE
Click en CREATE FROM SPRIT
Seleccionamos la Imagen de nuestra Carpeta.
Proba modificando los números de NUMBER OF IMAGES, IMAGES PER ROW, IMAGE
WIDTH, IMAGE HEIGHT, etc, Observando lo que sucede con la imagen de la derecha, y luego
hacé click en OK
De esta forma podes armar sprites individuales y sprites que simulen movimiento.
Si tildas la opción SHOW PREVIEW, te muestra cómo quedaría el sprite, en caso de que sea
una serie de imágenes muestra la animación.
BONUS EN EL PUNTAJE

Si queremos que si supera los 400 puntos tenga un

plus, lo mismo si supera los 1000, tenemos que
chequear el puntaje en algún lugar de nuestro juego. Lo
vamos a hacer cuando se dispara es decir cuando se
presiona la [BARRA ESPACIADORA].
Hacemos lo que muestra la imagen:
Si el puntaje es superior a 400, en la Acción
CREATE INSTANCE del obj_bala, las
coordenadas que colocamos son x=24 y=-8, y
tildado relative, para que sea desde donde se
encuentra nuestro avión, y otra en x=-24 y=-8.
Si el puntaje es superior a 1000, en la Acción
CREATE INSTANCE del obj_bala, las
coordenadas que colocamos son x=0 y=-48, y
tildado relative, para que sea desde donde se encuentra nuestro avión.
Si no es ninguna de las dos anteriores, en la Acción CREATE INSTANCE del obj_bala, las
coordenadas que colocamos son x=0 y=-16, y tildado relative, para que sea desde donde se
encuentra nuestro avión.
Probalo ¿Cuál fue el plus? ………………………………………………………………………………

Usando Líneas de Tiempo (Sexta Parte)

Hasta el momento en nuestro juego, la aparición de los aviones enemigos está controlada con el
objeto control_enemigo. Además nunca se destruyen por completo, ya que reaparecen. El juego se
complica ya que la cantidad de aviones que aparecen es cada vez mayor.
Veamos qué cosas complican al programador del juego, o pueden ser mejoradas:
Los aviones aparecen en forma aleatoria, cosa que no podemos controlar.
Podrían aparecer uno arriba de otro, o muy cerca de los límites de nuestra pantalla, lo que hace
que no sea muy atractivo nuestro juego.
El objetivo del juego, no es más que dispararle a los aviones, y evitarlos todo el tiempo.

Para hacer el juego más interesante, el diseñador debe tener un poco más de control sobre que
aviones tienen que aparecer, y en qué momento. Esto permitirá armar por ejemplo, formaciones de
aviones. Para ello usaremos el recurso de la línea de tiempo.
Antes haremos algunas modificaciones, para que los aviones que son destruidos o los que
desaparecieron de la pantalla, por ejemplo no vuelvan a aparecer.
La línea de tiempo será la que controla la creación de los enemigos. Guardamos nuestro archivo
nuevamente con otro nombre: 1945_lineatiempo.gmk.
Modificaremos un poco, y luego ustedes son los encargados de completarlo.

¿Cómo funciona la línea de tiempo?

30
Proyecto Informático 2018

En ella se especifica el número de momentos de tiempo, estos serán los pasos (Evento Step), y
para cada uno de ellos indicamos las Acciones que tienen que ejecutarse en ese momento en
particular.

Agregamos la línea de tiempo: CREATE TIME LINES. Nos aparece una ventana similar a la de
los objetos.
Le colocamos como nombre tl_enemigos
Tenemos botones para agregar momentos ADD, para cambiar CHANGE, para borrar, DELETE,
para limpiar CLEAR.

MOMENTO 0
o En el momento 0 (cero) crearemos un avión enemigo: ADD, nos aparece que indiquemos el
momento escribimos 0 (cero). Luego OK.
o Agregamos la Acción CREATE INSTANCE: elegimos el objeto obj_enemigo1, y le damos
como coordenadas x=320 y=-32.
MOMENTO 100
o Como más o menos se tarda unos 100 pasos, en atravesar toda la pantalla, amamos el
momento 100 (cien) crearemos dos aviones enemigo: ADD, nos aparece que indiquemos el
momento escribimos 100 (cien). Luego OK.
o Agregamos la Acción CREATE INSTANCE dos veces para que aparezcan dos aviones:
elegimos el objeto obj_enemigo1, y le damos como coordenadas x=200 y=-32 y en la otra
x=400 y=-32.
MOMENTO 200
o Armamos el momento 200 (doscientos) crearemos seis aviones enemigos iguales: ADD, nos
aparece que indiquemos el momento escribimos 200 (doscientos). Luego OK.
o Agregamos la Acción CREATE INSTANCE seis veces para que aparezcan seis aviones:
elegimos el objeto obj_enemigo1, damos como coordenadas x=200 y=-32; x=260 y=-64;
x=320 y=-96; x=380 y=-128; x=440 y=-160; x=500 y=-192
MOMENTO 300
o Armamos el momento 300 (trescientos) crearemos nueve aviones enemigos iguales: ADD,
nos aparece que indiquemos el momento escribimos 300 (trescientos). Luego OK.
o Agregamos la Acción CREATE INSTANCE nueve veces para que aparezcan nueve
aviones: elegimos el objeto obj_enemigo1, damos como coordenadas x=100 y=-32; x=132
y=-32; x=200 y=-32; x=250 y=-32; x=300 y=-32; x=350 y=-32; x=400 y=-32; x=450 y=-32;
x=500 y=-32
MOMENTO 400
o Armamos el momento 400 (cuatrocientos) crearemos siete aviones enemigos iguales y dos
aviones que nos van a disparar: ADD, nos aparece que indiquemos el momento escribimos
400 (cuatrocientos). Luego OK.
o Agregamos la Acción CREATE INSTANCE dos veces para que aparezcan nueve aviones:
elegimos el objeto obj_enemigo1, damos como coordenadas x=100 y=-32; x=152 y=-32
o Agregamos la Acción CREATE INSTANCE una vez para que aparezcan nueve aviones:
elegimos el objeto obj_enemigo2, damos como coordenadas x=200 y=-32.
o Agregamos la Acción CREATE INSTANCE tres veces para que aparezcan nueve aviones:
elegimos el objeto obj_enemigo1, damos como coordenadas x=300 y=-32; x=250 y=-32;
x=350 y=-32
o Agregamos la Acción CREATE INSTANCE una veces para que aparezcan nueve aviones:
elegimos el objeto obj_enemigo2, damos como coordenadas x=400 y=-32.
o Agregamos la Acción CREATE INSTANCE dos veces para que aparezcan nueve aviones:
elegimos el objeto obj_enemigo1, damos como coordenadas x=450 y=-32; x=500 y=-32

MOMENTO 500
o Armamos el momento 500 (quinientos) crearemos nueve aviones enemigos iguales: ADD,
nos aparece que indiquemos el momento escribimos 500 (quinientos). Luego OK.
31
Proyecto Informático 2018

o Agregamos la Acción CREATE INSTANCE nueve veces para que aparezcan nueve
aviones: elegimos el objeto obj_enemigo1, damos como coordenadas x=100 y=-32; x=150
y=-32; x=200 y=-32; x=250 y=-32; x=300 y=-32; x=350 y=-32; x=400 y=-32; x=450 y=-32;
x=500 y=-32
MOMENTO 530
o Copiamos el Momento 500
MOMENTO 600
o Armamos el momento 600 (seiscientos) crearemos nueve aviones enemigos iguales: ADD,
nos aparece que indiquemos el momento escribimos 600 (seiscientos). Luego OK.
o Agregamos la Acción CREATE INSTANCE dos veces para que aparezcan nueve aviones:
elegimos el objeto obj_enemigo3, damos como coordenadas x=250 y=-32; x=350 y=-32

MOMENTO 1000
o Armamos el momento 1000 (mil), el cual determinará en nuestro caso el final del juego, así
como armamos el final del juego, podría ser el final de un nivel.
o Aparecerá un mensaje. Display a message, en el escribimos “Sobreviviste!!”
o Mostramos la tabla de posiciones: Display the highscore table
o Comienza el juego nuevamente: Restart the game

Una línea de tiempo no ejecuta automáticamente las acciones definidas, tenemos que asignarle a
algún objeto, que ejecute la Acción de la Línea del Tiempo. Para esto utilizaremos el objeto
control_enemigo.

MODIFICAMOS EL OBJETO control_enemigo

Queremos que se ejecute de inmediato en la posición 0 (cero), y que no vuelva a comenzar, una vez
que terminó, se terminó el nivel y/o juego, en nuestro caso finaliza el juego.
Abrimos el objeto: control_enemigo
Modificamos EVENTO CREATE
o Acción SET TIME LINE, en la solapa MAIN2
o Modificamos la ventana de la siguiente forma:
 Time line: tl_enemigos
 Position: 0
 Start: Start Inmediately
 Loop: Don´t Loop
Hay muchas cosas que puedes hacer con las líneas de tiempo. Nosotros las
usamos para controlar el flujo global del juego pero también se puede utilizar para controlar el comportamiento
de los objetos del juego en el tiempo. También hay muchos trucos que puede utilizar. Por ejemplo, para poner
fin a una línea de tiempo por un tiempo, añadir un momento en el que se prueba una condición y, si es así,
ajuste la posición de la línea de tiempo relativo a -1, es decir, en el paso siguiente en el mismo momento que
está sucediendo y de la condición se prueba de nuevo. De modo que la línea de tiempo no avanzará hasta
que la condición sea falsa. Las instancias también pueden cambiar las líneas de tiempo en función de
determinados eventos, etc También se puede controlar la velocidad de una línea de tiempo.

Armando Vistas en la Pantalla (Séptima Parte)

Hasta ahora engañamos al jugador en el sentido de que no estábamos volando a través de un
océano, el fondo era simplemente un desplazamiento. Esto tiene una gran desventaja. En particular,
el fondo no se puede cambiar con facilidad (por ejemplo, es difícil de volar a mitad de camino por la
tierra. Además, a pesar de que podemos utilizar las líneas de tiempo, es más difícil tener diferentes
acciones que parezcan distribuidas en el tiempo.

Armaremos completa la vista de nuestro juego. Armamos la pantalla (room) pant_ppal

32
Proyecto Informático 2018

En la Solapa SETTINGS
o Medidas: ancho: 640 y altura: 4800
o Nombre: pant_ppal
o Speed: 30
o Caption for the room: Escribimos 1945.
En la Solapa BACKGROUNDS
o Colocamos la imagen del background fondo_agua
o Tildamos las opciones Tile Hor. y Tile Vert.
En la Solapa OBJECTS
o Colocamos varias imágenes de islas, en distintos lugares de la pantalla, recorda que la
pantalla es bastante extensa en altura. Estos serán objetos estáticos, es decir sin movimiento
propio.
o Colocamos nuestro avión en la parte inferior de la pantalla, en el EVENTO CREATE, le
colocamos una velocidad vertical de -2. Para asegurarnos de que vuele aunque el jugador no
presione ninguna tecla.
o Definimos las vistas (VIEWS):
 Solapa VIEWS, en la ventana de la pantalla.
 Tildamos ENABLE THE USE OF VIEWS, para activar el uso de vistas.
 Definimos la primera vista VIEW 0.
 Tildamos la opción VISIBLE WHEN ROOM STARTS
 En los casilleros, colocamos la X en 0 (cero) y la Y en 4320, para asegurarnos que
comience en el final de la pantalla.
o Tenemos que asegurarnos que la vista se mueva a una velocidad constante, para ello vamos
a utilizar “mal” el evento STEP del objeto control_vidas. Abrimos las propiedades del objeto:
o Agregamos el EVENTO STEP

o En éste agregamos la acción de inicializar la variable view_yview en -2 y tildamos la

casilla RELATIVE. La variable view_yview indica la posición superior de la vista en la
pantalla. Si hay varias vistas, esta variable tendrá a continuación el número de la vista a
la que pertenece, por ejemplo, para la View 0, es view_yview[0]. Por lo tanto, con esta
acción, por cada paso la vista se mueve 2 pixeles hacia arriba creando el
desplazamiento.
o Tenemos que comprobar si view_yview es menor
que cero. Si llega a cero, significa que llegamos al
final de la vista, por lo tanto hay que finalizar el
juego.
 En caso de que sea afirmativo, tenemos que
armar un bloque donde mostremos un mensaje
de finalización del juego, la tabla de posiciones
y que el juego recomience.
o Si lo probamos vemos que el panel que tiene toda la información de nuestro juego no
aparece, para ello tendremos que agregar el valor de y de la vista en todo lo que
respecta al panel, por lo tanto tenemos que modificar el EVENTO DRAW:
 En la Acción DRAW SPRITE SPR_PANEL, tenemos que colocar el valor de y como
view_yview+404
 En la Acción DRAW THE VALUE OF SCORE, el valor de y va a ser view_yview+440
 En la Acción DRAW THE HEALTH BAR, el valor de y1 es view_yview+449 y el valor
de y2 es view_yview+459.
 En la Acción DRAW THE LIVES AS IMAGE el valor de y es view_yview+410

33