GameMaker Studio / Finalizando

Bienvenidos sean a este post, hoy finalizaremos a los clientes para poder probar nuestro juego.

Nuestra siguiente modiicacion sera agregar un evento Step en nuestro objeto obj_cliente, creado en el post anterior, a este evento le agregaremos el siguiente codigo:

if (conectado)
{
	buffer_seek(buff, buffer_seek_start, 0);
	buffer_write(buff, buffer_f32, obj_Jugador.x);
	buffer_write(buff, buffer_f32, obj_Jugador.y);
	
	if (obj_Jugador.sprite_index == spr_jugador_camina)
	{
		buffer_write(buff, buffer_f32, 0);
	}
	else
	{
		buffer_write(buff, buffer_f32, 1);
	}
	
	buffer_write(buff, buffer_f32, obj_Jugador.image_index);
	buffer_write(buff, buffer_f32, obj_Jugador.image_xscale);
	network_send_packet(socket,
			buff,
			buffer_tell(buff));
}

En este codigo verificamos si conectado es verdadero, recuerden que lo hicimos en el post anterior donde si todas las condiciones se cumplian cambiamos esta variable a true, en este caso volveremos a repetir el proceso de creacion del buffer, primero iremos al principio del mismo tal como hicimos en pasos anteriores, luego comenzamos a escribir el buffer por medio de buffer_write, en el primer caso pasaremos el valor del eje X del jugador, el siguiente es el eje Y del jugador, luego tenemos un condicional donde verificamos si el sprite_index del objeto obj_Jugador es igual a spr_jugador_camina envia el valor de 0 de lo contrario envia el valor de 1, esto es para indicar el sprite de que jugador sera, el siguiente sera enviar cual es el indice de la imagen actual y por ultimo la escala del eje X, con todo esto escrito en el buffer procedemos a enviarlo por medio de network_send_packet tal como vinimos trabajando hasta ahora, el siguiente paso sera agregar un nuevo evento Asynchronous -> Async Networking, con este evento creado agregaremos el siguiente codigo:

if (ds_map_find_value(async_load, "type") == 
		network_type_data)
{
	buffer_recibido = ds_map_find_value(async_load, "buffer");
	buffer_seek(buffer_recibido, buffer_seek_start, 0);
	buff_primer_valor = buffer_read(buffer_recibido, buffer_f32);
	
	if (buff_primer_valor == -2 && 
		instance_exists(obj_Otro_jugador))
	{
		with(jugador_dos)
		{
			instance_destroy();
		}
	}
	else if (buff_primer_valor != -2)
	{
		jugador_dos_x = buff_primer_valor + 30;
		jugador_dos_y = buffer_read(buffer_recibido, 
						buffer_f32);
		
		if (buffer_read(buffer_recibido, buffer_f32) == 0)
		{
			jugador_dos_sprite = spr_jugador_camina_otro;
		}
		else
		{
			jugador_dos_sprite = spr_jugador_salta_otro;
		}
		
		jugador_dos_subimagen = buffer_read(
							buffer_recibido,
							buffer_f32);
		jugador_dos_escalaX = buffer_read(
							buffer_recibido,
							buffer_f32);
		
		if (!instance_exists(obj_Otro_jugador))
		{
			jugador_dos = instance_create_depth(
					jugador_dos_x,
					jugador_dos_y,
					0,
					obj_Otro_jugador);
		}
		
		with(jugador_dos)
		{
			x = other.jugador_dos_x;
			y = other.jugador_dos_y;
			sprite_index = other.jugador_dos_sprite;
			image_index = other.jugador_dos_subimagen;
			image_xscale = other.jugador_dos_escalaX;
		}
		
	}
}

Lo primero que haremos se verificar que el tipo informado en async_load sea igual a network_type_data, es decir que se trate de informacion que debemos manipular, si esto es asi lo primero que haremos es obtener el buffer por medio de ds_map_find_value y lo almacenaremos en buffer_recibido, luego nos ubicaremos al comienzo del buffer como lo venimos haciendo habitualmente, para despues almacenar el primer valor del buffer en una variable, nuestro siguiente paso sera chequear si el valor de buff_primer_valor es igual a -2 y existe una instancia del otro jugador (obj_Otro_jugador) y con el with destruimos la instancia del segundo jugador, esto es asi porque recuerden que si el servidor pasa este valor para indicar que el servidor fue destruido, despues tenemos un caso contrario donde verificamos si buff_primer_valor es distinto de -2 porque esto significa que estamos conectado y funcionando.

Dentro de este bloque lo que haremos primero es obtener cada uno de los datos que enviamos por la red previamente cuando lo vimos en el post anterior, en este caso el eje X del segundo jugador sera el primer dato que conseguimos, luego conseguiremos el eje Y, luego tenemos un condicional que verifica el valor que recibimos, si es 0 asignaremos el sprite para caminar sino el sprite para saltar, en este caso hace una referencia a unos sprites que luego agregaremos pero de esto hablaremos mas adelante, lo siguiente sera obtener la subimagen y la asignamos, por ultimo obtenemos el valor de la escala de X, con esto obtuvimos todos los valores necesarios para el segundo jugador.

Nuestro siguiente paso sera verificar que no exista la instancia del objeto correspondiente al segundo jugador, obj_Otro_jugador, si esto es verdad usaremos todos los datos obtenidos anteriormente para crear a nuestra nueva instancia, para ello usaremos la variable jugador_dos donde almacenara a la nueva instancia, en este caso usaremos a instance_create_depth y le pasaremos los valores del eje X (jugador_dos_x), del eje Y (jugador_dos_y), la profundidad y el objeto para el jugador dos, despues por medio de with le asignaremos el valor a las variables internas x, y, sprite_index, image_index e image_xscale por medio de los valores que obtuvimos anteriormente pero usaremos la palabra other para que no utilice los valores propios sino los que corresponderian a la otra instancia creada, con todo esto ya tenemos casi nuestro cliente terminado solo nos restaria un par de detalles.

Y estos detalles son el objeto y los sprites correspondientes al segundo jugador, para ello les recomiendo utilizar la opcion de Duplicate para duplicar primero al objeto del jugador, obj_Jugador, y deben renombrarlo como obj_Otro_jugador, una vez hecho esto solo nos restan dos modificaciones mas, la primera sera eliminar todo el codigo del evento Step y en el evento Create dejen solo esta linea:

image_speed = 0;

Nota: Esto siempre en el objeto nuevo, obj_Otro_jugador, aunque tambien pueden eliminar el evento Step directamente.

Con esto realizado solo nos resta duplicar a spr_jugador_camina y spr_jugador_salta y cambiar los nombres a spr_jugador_camina_otro y spr_jugador_salta_otro respectivamente, lo siguiente es cambiar en el nuevo objeto al sprite por el de spr_jugador_camina_otro para que quede como una replica del otro, lo ultimo que deberian hacer es modificar ligeramente los sprites para ver las diferencias, les dejo un ejemplo de como lo hice

Como pueden ver le agregue un «candadito» y modifique los colores de la ropa, con esto realizado nuestra ultima modificacion debe ser con el objeto de cliente, obj_Cliente, al cual debemos agregarlo dentro del room principal para que solicite la direccion IP y el puerto para conectarse, vamos a hacer un ejemplo para ver como funciona

En el video podemos ver como se ejecuta el servidor, luego tenemos las notificaciones de cada uno de los clientes que se conectaron, para finalmente ver como el segundo jugador de cada uno de las pantallas actua despendiendo de lo que hace el otro equipo, en este caso pude correr dos virtuales en la misma red emulando la ejecucion la de dos equipos distintos, esto es lo mas recomendable pero tambien pueden ejecutar tres instancias en un mismo equipo que debera funcionar correctamente.

Por ultimo vimos que ejecute los dos proyectos por fuera del editor, esto se hace a traves del creador de ejecutables, para ello desde el menu principal van a Build y seleccionen Create Executable y les aparecera el siguiente cuadro

La primera opcion es ideal para cuando debemos distribuir nuestro juego pero se deben instalar algunos elementos o crear una estructura de directorios, la segunda es una opcion mas interesante para distribuir un juego al cual solo se debe copiar en el disco y se ejecuta directamente, como nuestro caso, para ello seleccionaremos la segunda opcion, nos preguntara donde crear el .zip y con que nombre, una vez seleccionado comenzara a compilarlo y si todo salio bien nos mostrara la carpeta con el archivo generado, abren a este y extraigan los tres archivos que se generaron, les recomiendo hacer tanto para el servidor como el cliente pero al momento de extraerlos lo destinan en carpetas distintas, con esto podran hacer lo mismo que se ve en el video, con todo esto explicado solo me resta mostrarles la notificacion de desconexion

Lo ideal es probarlo con la mayor cantidad de equipos distintos, si pueden hacerlo con tres seria lo ideal pero si hacen los ejecutables pueden probarlos en el mismo equipo, ejecutando siempre el servidor primero y luego dos veces el cliente para conectarse, si lograron lo mismo que se ve en el video: Felicitaciones!!! porque no tienen idea de la magnitud de lo que lograron porque el hecho de poder enviar informacion a traves de la red y que funcione perfectamente no tiene precio, no en balde fue una de las lecciones mas dificiles de explicar, les dejo los dos codigos de este proyecto para que puedan verlos como es el codigo final de ambos:

Con esto termina el proyecto de como crear un juego multijugador de tipo cliente/servidor, queda una modificacion mas pero esa la haremos en el proximo post pero sera opcional porque requiere de un elemento que no todos poseen.

En resumen, hoy hemos concluido con nuestro cliente, hemos agregado un evento que trabaja cuando estemos conectado al servidor, tambien hemos agregado la parte encargada de enviar por la red los datos de nuestro jugador al otro cliente, por ultimo agregamos una representacion del otro jugador en nuestra pantalla, tambien hemos visto como probar la conectividad y como generar archivos ejecutables y tambien los medios para distribuirlo, 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.