GameMaker Studio / Disparando

Bienvenidos sean a este post, hasta el post anterior hicimos un juego basico donde creamos enemigos al azar que nos restan salud y vidas pero ahora les daremos la posibilidad a nosotros y ellos de disparar.

Para lograr esto debemos hacer la primera de las modificaciones en el objeto obj_Cj para crear una variable que sera accedida en nuestro evento Create, en este evento agregaremos la siguiente linea:

var puede_disparar = true;

Esta variable sera basicamente para que el juego sepa si podemos disparar o no pero ya veremos para que nos servira, lo siguiente sera crear dos objetos nuevos, uno para la bala nuestra a la cual llamaremos obj_Bala y le asignaremos el sprite spr_Bala y crearemos otro llamado obj_BalaEnem al cual le asignaremos spr_BalaE, recuerden verificar los Collisions Masks de cada sprite para que chequeen toda la bala y por ultimo que ambos objetos sean solidos, con estos dos objetos creados solo nos resta trabajar con nuestro codigo, vamos a nuestro objeto obj_Cj nuevamente y agregaremos en el evento Step el siguiente bloque:

if (keyboard_check(vk_space))
{
	switch(other.direction)
	{
		case 0:
			equis = other.bbox_right;
			ye = other.bbox_top + (sprite_height / 2);
			break;
		case 90:
			equis = other.bbox_left + (sprite_width / 2);
			ye = other.bbox_top;
			break;
		case 180:
			equis = other.bbox_left;
			ye = other.bbox_top + (sprite_height / 2);
			break;
		case 270:
			equis = other.bbox_left + (sprite_width / 2);
			ye = other.bbox_bottom;
			break;
			
	}
	bala = instance_create_depth(
				equis,
				ye,
				1,obj_Bala);
	with(bala)
	{
		direction = other.direction;
		speed = 10;
	}
}

En este nuevo codigo tenemos un condicional donde verifica si presionamos la barra espaciadora, luego lo primero que vamos a tener es un switch donde verifica cual es el valor de other.direction, la direccion del objeto que nos contiene (obj_Cj), mediante los cuatro case que disponemos (uno por cada direccion donde disparamos) modificaremos dos variables, equis y ye, las cuales usaremos para asignar el valor de los ejes X e Y (respectivamente) de la funcion encargada de crear la instancia, observen que dependiendo el caso saldra de la mitad del lado derecho o izquierdo como asi saldra de la mitad de arriba o de abajo siempre dependiendo desde donde disparemos, con esto tenemos dos datos que usaremos a continuacion.

El siguiente paso sera crear una nueva instancia del objeto obj_Bala la cual almacenara en la variable bala, los primeros dos parametros definen el eje X e Y de la instancia para ello usamos a equis y ye los cuales fueron creados con el switch anterior, luego le decimos el nivel de profundidad y por ultimo le decimos la instancia de que objeto debe crear, una vez creada la instancia por medio de with le agregaremos cual sera su direccion, en este caso como estamos hablando de la bala el other sera para indicarle que utilice el objeto que nos contiene y por ultimo seteamos la velocidad en 10, solo nos resta una modificacion mas que es agregar la direccion de cuando presionamos nuestras teclas, en este caso como dijimos antes el jugador disparara en cuatro direcciones por lo tanto debemos modificar los condicionales de las cuatro flechas (vk_up, vk_down, vk_left y vk_right) para agregar las direcciones correspondientes, debemos modificarlos de la siguiente manera:

else if (keyboard_check(vk_left) && place_free(x - veloc, y))
{
	x -= veloc;
	image_index = 3;
	direction = 180;
} 
else if (keyboard_check(vk_right) && place_free(x + veloc, y))
{
	x += veloc;
	image_index = 2;
	direction = 0;
}
else if (keyboard_check(vk_up) && place_free(x, y - veloc))
{
	y -= veloc;
	image_index = 1;
	direction = 90;
}
else if (keyboard_check(vk_down) && place_free(x, y + veloc))
{
	y += veloc;
	image_index = 0
	direction = 270;
}

Simplemente debemos agregar la variable interna direction y el valor correspondiente, de esto hablamos en este post pero recuerden que la direccion esta basada en un eje donde 0° representa a la derecha, 90° representa la flecha hacia arriba, 180° es a la izquierda y 270° representa hacia abajo, con todos estos valores establecidos podemos probar nuestro juego y veremos que podemos disparar pero por ahora no colisiona con ningun objeto y tenemos multiples disparos pero siempre en la ultima direccion que nos movimos, vamos a modificar la cantidad de disparos seguidos, para ello deben agregar un nuevo evento de tipo Alarm y seleccionen Alarm 0, una vez hecho esto modificaremos el condicional de la barra espaciadora de la siguiente manera:

if (keyboard_check(vk_space) && puede_disparar)
{
	switch(other.direction)
	{
		case 0:
			equis = other.bbox_right;
			ye = other.bbox_top + (sprite_height / 2);
			break;
		case 90:
			equis = other.bbox_left + (sprite_width / 2);
			ye = other.bbox_top;
			break;
		case 180:
			equis = other.bbox_left;
			ye = other.bbox_top + (sprite_height / 2);
			break;
		case 270:
			equis = other.bbox_left + (sprite_width / 2);
			ye = other.bbox_bottom;
			break;
			
	}
	bala = instance_create_depth(
				equis,
				ye,
				1,obj_Bala);
	with(bala)
	{
		direction = other.direction;
		speed = 10;
	}
	puede_disparar = false;
	alarm[0] = 30;
}

En este caso modificamos el condicional al comienzo donde usaremos a puede_disparar donde si presiono la barra y esta variable tiene valor verdadero (true) podra ejecutar el bloque de creacion de la bala y despues del with agregamos una linea para darle un valor de falso (false) a puede_disparar y usamos a alarm para que espere 30 pasos para cambiar el valor de nuevo a verdadero, para ello debemos ir al evento Alarm 0 y agregar la siguiente linea:

puede_disparar = true;

Esto nos permitira una mayor discrecion a la hora de disparar, a comparacion del primer proyecto donde debiamos ser nosotros los que controlabamos los mismos, solo nos resta las colisiones y para ello debemos usar nuevamente a collision_rectangle pero con algunas sutiles diferencias, para ello debemos ir al objeto obj_Bala y agregar un nuevo evento Step -> Step, una vez creado agregaremos el siguiente codigo:

var pared = collision_rectangle(
				x, 
				y, 
				x + sprite_width, 
				y + sprite_height, 
				obj_Prd, false, false);
var enemigo = collision_rectangle(
				x,
				y,
				x + sprite_width,
				y + sprite_height,
				obj_Enemigo, false, false);
if (pared != noone)
{
	instance_destroy();
}
if (enemigo != noone)
{
	instance_destroy(enemigo);
	instance_destroy();
}

Primero crearemos dos variables, en la primera llamada pared almacenaremos el rectangulo de colision de nuestra bala con respecto al objeto de la pared, el siguiente es similar pero con el objeto del enemigo, en ambos casos definimos a la coordenada right con el valor del eje X y el ancho del sprite y la coordenada bottom con el eje Y y el alto del sprite, lo siguiente es un condicional donde verificamos que pared sea distinto de noone, si es cierto llamamos a instance_destroy para destruir a la instancia donde sucedio la colision, el siguiente condicional lo hace con enemigo y en caso de ser cierto procede a destruir la instancia que esta almacenada en enemigo y despues nos destruimos a nosotros mismos, vamos a probar como quedo hasta ahora mediante el siguiente video

Hasta aqui ya tenemos la posibilidad de disparar pero ahora nos falta hacer que nuestros enemigos disparen, para ello debemos ir a nuestro objeto obj_BalaEnem, en este agregaremos un nuevo evento de tipo Step -> Step y una vez creado le agregaremos el siguiente codigo:

var pared = collision_rectangle(
				x,
				y,
				x + sprite_width,
				y + sprite_width,
				obj_Prd,false,false);
if (pared != noone)
{
	instance_destroy();
}

En este caso hacemos algo similar a cuando trabajamos con el otro objeto de bala, creamos una variable para la pared y en esta utilizamos un collision_rectangle, el cual le pasamos el objeto de la pared, despues tenemos un condicional donde verifica si este es distinto de noone y en caso de ser cierto destruye la instancia que coinicidio, el siguiente paso sera ir a nuestro objeto obj_Enemigo y dentro del evento Step agregaremos arriba de todo la siguiente linea:

var alazar = irandom(60);

Esta creara una nueva variable llamada alazar la cual almacenara un numero al azar entre 0 y 59, despues agregaremos el siguiente bloque por fuera del contenido anterior dentro del evento Step:

if (alazar==0)
{
	if (patron_caminata=="horizontal" && mi_veloc==2)
	{
		equis = other.bbox_right;
		ye = other.bbox_top + (sprite_height / 2);
	} 
	else if (patron_caminata=="horizontal" && mi_veloc==-2)
	{
		equis = other.bbox_left;
		ye = other.bbox_top + (sprite_height / 2);
	}
	else if (patron_caminata=="vertical" && mi_veloc==2)
	{
		equis = other.bbox_left + (sprite_width / 2);
		ye = other.bbox_bottom;
	}
	else
	{
		equis = other.bbox_left + (sprite_width / 2);
		ye = other.bbox_bottom;
	}
	var bala = instance_create_depth(equis, ye, 1, 
					obj_BalaEnem);
	with(bala)
	{
		hspeed = other.hspeed;
		vspeed = other.vspeed;
		speed = 10;
	}
}

Primero chequeamos si alazar es igual a 0, en caso de ser cierto tenemos un grupo de condicionales donde verificaremos el patron de la caminata (si es horizontal o vertical) y el signo de mi_veloc (si va a la izquierda o a la derecha), en este caso volveremos a definir dos variables, equis y ye, las cuales usaremos para definir los ejes X e Y de la creacion de la instancia, con los dos valores obtenidos nuestro siguiente paso sera crear una variable llamada bala la cual sera para almacenar la instancia del objeto obj_BalaEnem, le pasamos los parametros antes citados, la profundidad y el objeto, luego por medio de with le modificamos a esta instancia los valores de hspeed y vspeed con los valores de hspeed y vspeed del contenedor de este (entra en accion other) y luego definimos la velocidad en 10, a diferencia del caso del jugador nosotros tenemos dos valores que estan variando en base a su desplazamiento por ende ajustara unicamente la velocidad que se este modificando, con esto tenemos cubierto el desplazamiento de nuestras balas y la colision con las paredes pero nos falta la colision con el jugador.

Para esto debemos ir nuevamente al objeto obj_BalaEnem, al evento Step y agregaremos el siguiente codigo:

var jugador = collision_rectangle(
				x,
				y,
				x + sprite_width,
				y + sprite_height,
				obj_Cj, false, false);
if (jugador != noone)
{
	health -= 10;
	jugador.x = jugador.xstart;
	jugador.y = jugador.ystart;
	instance_destroy();
}

Volvemos a crear una nueva variable para almacenar un rectangulo de colisiones pero ahora contra el jugador, y usamos otro condicional para ver si impacto, en caso de ser cierto, le restaremos a health un valor de 10, volveremos al jugador al punto de inicio y destruiremos la instancia que hizo impacto, con esto tenemos un juego mas operativo, veamos como quedo hasta ahora mediante el siguiente video

Como pueden ver en el video tenemos un juego mucho mas completo donde nuestros enemigos disparan al azar, los mismos desaparecen contra las paredes y tambien cuando impactan contra nosotros y como nos restan vida y volvemos al inicio.

En resumen, hoy hemos agregado como disparar tanto para nosotros como para nuestros enemigos, hemos visto como desaparecerlos y como nos restan energia, como trabajar con los rectangulos de colisiones, tambien como por medio de una alarma generamos un temporizador para distanciar nuestros disparos y vimos como podemos manejar de mejor forma la manera de disparar con respecto al proyecto anterior, espero les haya gustado sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.