GameMaker Studio / La conectividad del server

Bienvenidos sean a este post, hoy continuaremos con nuestro servidor y veremos todo el tema de la conectividad con el mismo.

Para poder trabajar con todas las conectividades del servidor volveremos a usar el evento de networking, asi que agreguen el evento Asynchronous -> Async Networking, una vez creado agregaremos el siguiente codigo:

switch(ds_map_find_value(async_load,"type"))
{
	case network_type_connect:
		sockets[network_array_pos] = ds_map_find_value(
					async_load, "socket");
		if (network_array_pos == 0)
			++network_array_pos;
		show_message_async("Cliente conextado");
		break;
		
	case network_type_disconnect:
		if (ds_map_find_value(async_load, "socket") ==
				sockets[0])
		{
			sockets[0] = -1;
			--network_array_pos;
		}
		else
		{
			sockets[1] = -1;
		}
		if (sockets[0] != -1)
		{
			buffer_seek(datos_a_enviar, 
					buffer_seek_start, 0);
			buffer_write(datos_a_enviar, buffer_f32, -2);
			network_send_packet(sockets[0],
					datos_a_enviar,
					buffer_tell(datos_a_enviar));
		}
		else if (sockets[1] != -1)
		{
			buffer_seek(datos_a_enviar, 
				buffer_seek_start, 0);
			buffer_write(datos_a_enviar, buffer_f32, -2);
			network_send_packet(sockets[1],
					datos_a_enviar,
					buffer_tell(datos_a_enviar));
		}
		show_message_async("Cliente desconectado");
		break;

	case network_type_data:
		if (ds_map_find_value(async_load, "id") == sockets[0]
			&& sockets[1]!= -1)
		{
			scr_maneja_datos(ds_map_find_value(
					async_load,"buffer"),1);
		}
		else if (ds_map_find_value(async_load, "id") == 
			sockets[1] && sockets[0]!= -1)
		{
			scr_maneja_datos(ds_map_find_value(
					async_load,"buffer"),0);
		}
		break;
}

Si observan todo este switch es para detectar los tres tipos de estado sobre nuestra conexion, basicamente en el comienzo le informamos que verifica el type de async_load por medio de ds_map_find_value del resultado obtenido por esta funcion lo chequearemos en tres case, veamos el primero:

case network_type_connect:
	sockets[network_array_pos] = ds_map_find_value(
				async_load, "socket");
	if (network_array_pos == 0)
		++network_array_pos;
	show_message_async("Cliente conextado");
	break;

En este caso verificamos si status tiene este valor, si es asi nos indica que estamos solicitando la conexion, observen que usamos a sockets y pasamos en la posicion el valor de network_array_pos y por medio de ds_map_find_value le asignaremos el valor del socket a esta posicion del array, luego chequeamos si el valor de network_array_pos es igual a 0, en caso de ser verdadero lo incrementamos para la proxima vuelta, luego mostramos que el cliente se conecto, pasemos al siguiente case:

case network_type_disconnect:
	if (ds_map_find_value(async_load, "socket") ==
			sockets[0])
	{
		sockets[0] = -1;
		--network_array_pos;
	}
	else
	{
		sockets[1] = -1;
	}
	if (sockets[0] != -1)
	{
		buffer_seek(datos_a_enviar, 
				buffer_seek_start, 0);
		buffer_write(datos_a_enviar, buffer_f32, -2);
		network_send_packet(sockets[0],
				datos_a_enviar,
				buffer_tell(datos_a_enviar));
	}
	else if (sockets[1] != -1)
	{
		buffer_seek(datos_a_enviar, 
			buffer_seek_start, 0);
		buffer_write(datos_a_enviar, buffer_f32, -2);
		network_send_packet(sockets[1],
				datos_a_enviar,
				buffer_tell(datos_a_enviar));
	}
	show_message_async("Cliente desconectado");
	break;

En este case manejamos la accion de descoectarnos, por ello primero tenemos un condicional donde verificamos que el socket en async_load sea igual al que almacenamos en la psosicion 0 de sockets, en caso de ser verdadero le establecemos el valor de -1 y decrementaremos a network_array_pos, en caso contrario estableceremos solamente a -1 la posicion de sockets, lo siguiente sera un condicional donde verifica si la posicion 0 de sockets es distinta de -1, en caso de ser verdadero usaremos a buffer_seek para buscar el comienzo de nuestro buffer, datos_a_enviar, primero pasamos el buffer, luego la constante para indicar que buscamos el comienzo de este y por ultimo el offset con 0 para indicar que siempre debe ser el comienzo del mismo.

Nota: Esto fue sencillo porque utilizamos a buffer_fixed y tiene siempre un valor fijo.

Lo siguiente sera escribir el buffer, para ello usamos a buffer_write donde pasaremos el buffer, luego el tipo de buffer (buffer_f32 para uno de 32 bits pero si usan uno de 16 bits deben pasar a buff_f16) y por ultimo el valor de -2, este ultimo se encargara de decirle al otro cliente que solo el esta conectado, por ultimo enviamos el paquete por la red por medio de network_send_packet y para ello enviaremos el socket que estamos verificando, luego pasamos el buffer y por ulitmo debemos enviarle el tamaño pero a diferencia de casos anterior no usaremos la funcion para obtener el tamaño, ya que no estamos constantemente borrando la informacion del mismo y puede suceder que enviemos informacion vieja ocasionando una incongruencia.

Por esta razon usamos a buffer_tell ya que esta funcion solo manda los bytes en nuestro «cursor» o lo mismo que decir el comienzo del buffer, lo unico que deben tener cuidado es que no se manipule al buffer cuando hacemos esto para que no mande otra posicion del buffer en lugar del comienzo y envie informacion incorrecta, con todo esto nos aseguramos que se envie el valor de -2 que configuramos antes, por ultimo tenemos un else if para verificar la otra posicion del socket y volvemos a hacer exactamente lo mismo pero esta vez usaremos a la otra posicion del socket no solo para verificarlo sino tambien para enviarlo pasemos al ultimo case:

case network_type_data:
	if (ds_map_find_value(async_load, "id") == sockets[0]
		&& sockets[1]!= -1)
	{
		scr_maneja_datos(ds_map_find_value(
				async_load,"buffer"),1);
	}
	else if (ds_map_find_value(async_load, "id") == 
		sockets[1] && sockets[0]!= -1)
	{
		scr_maneja_datos(ds_map_find_value(
				async_load,"buffer"),0);
	}
	break;

Este caso sera para manejar la informacion que mandemos a un cliente u otro, para ello tenemos un condicional donde verificamos si id es igual a la posicion 0 de sockets y la otra posicion es distinta de -1, en caso de ser verdadero llamaremos a un script llamado scr_maneja_datos donde le pasaremos el buffer y el valor de 1 luego tenemos otro condicional pero que ahora verifica si id es igual a la primera posicion del sockets y que la otra posicion sea distinta de -1 en caso de ser verdadero volvemos a llamar al script y esta vez le pasaremos el buffer y el valor 0, si se preguntan de que se trata este script deberan esperar al proximo post.

En resumen, hoy hemos visto como podemos trabajar sobre tres de los posibles estados de nuestra red, usamos un switch para verificar los tipos, el primer case lo usamos para verificar que se hayan conectado los clientes, el segundo case lo usamos para verificar que se hayan desconectado y en caso de que solo uno lo haya hecho le avisamos al otro cliente que esta desconectado, por ultimo tenemos el case encargado de manejar la informacion que se envia y recibe a traves de un script pero de esta script hablaremos en el proximo post, 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.