GameMaker Studio / Servidor

Bienvenidos sean a este post, en el post anterior hablamos sobre redes pero hoy veremos como las utilizaremos en nuestro servidor.

Para este caso debemos crear un nuevo proyecto al cual llamaremos ServidorPepe, como hasta ahora lo seguiremos haciendo con GML, y si bien podemos crearlo en nuestro proyecto por un tema de practicidad tanto para trabajarlo como explicarlo lo crearemos como un programa independiente, una vez creado nuestro nuevo proyecto comenzaremos creando un nuevo objeto al cual llamaremos obj_datos_red, el cual nos servira para todos los temas de configuracion de red, despues de generado el nuevo objeto agregaremos un evento Create, una vez generado le agregaremos el siguiente codigo:

randomize();
global.puerto_server=irandom_range(49152,65535);

En este primer codigo vamos a generar un valor de puerto para nuestra conexion, primero usaremos el randomize para genere un verdadero efecto de al azar, luego crearemos una variable global llamada puerto_server y por medio de irandom_range le asignaremos un numero al azar en el rango entre 49152 y 65535, recuerden que sobre la razon de estos valores hablamos en el post anterior, nuestro siguiente paso sera crear el servidor en si y para ello agregaremos el siguiente bloque:

servidor = network_create_server(
		network_socket_udp,
		global.puerto_server,
		1);

Para ello creamos una variable llamada servidor en la cual ejecutaremos la funcion network_create_server, la cual es para crear un servidor y para este debemos informar primero el tipo de protocolo de comunicacion (TCP o UDP), luego el valor del puerto y por ultimo la cantidad maxima de conexiones, tambien usaremos a esta funcion para obtener la direccion IP del servidor, para nuestro codigo primero informamos que sera un servidor de tipo UDP (network_socket_udp), luego el puerto que se genero al azar anteriormente y por ultimo admitiremos una sola conexion dado que nuestro servidor sera el unico que utilice esta conexion, nuestro siguiente paso sera agregar el siguiente condicional:

if (servidor < 0)
{
	show_message_async("Fallo la creacion del server");
}

El primer condicional verifica que el valor devuelto por network_create_server sea menor que 0 lo cual implica que el servidor no pudo ser generado y para mostrar la notificacion de este fallo, en este caso usamos a show_message_async, este es similar a show_message pero este es asincronico y esta funcion no interrumpe los procesos esperando una respuesta lo cual no lo hace recomendable para usar en depuracion pero si para lo que haremos ahora, nuestro siguiente paso sera agregar el bloque cuando no falla la creacion del server y para ello modificaremos el condicional de la siguiente forma:

if (servidor < 0)
{
	show_message_async("Fallo la creacion del server");
}
else
{
	sock = network_create_socket(network_socket_udp);
	buff = buffer_create(32, buffer_fixed, 1);
	
	buffer_fill(buff, 0, buffer_bool, 0, 32);
	network_send_broadcast(sock,
			global.puerto_server,
			buff,
			buffer_get_size(buff));
			
	network_destroy(sock);
	buffer_delete(buff);
}

En este caso agregamos el bloque else para cuando si hubo exito al crear el servidor y en este caso primero crearemos el socket que usaremos para el intercambio de datos, para ello usaremos a network_create_socket y le pasaremos el mismo tipo que al momento de crear el server y esto lo asignaremos a la variable sock, luego crearemos una variable llamada buff la cual usaremos como buffer y para ello usaremos a buffer_create la cual esta compuesta de tres partes respectivamente:

• tamaño del buffer
• el tipo de buffer que sera, buffer_fixed es uno que nunca cambiara su tamaño en memoria
• el tipo de alineamiento, esto se refiere a cuanto bytes de datos se pueden alinear para enviar, recibir o escribir

Esto lo que hace es basicamente crear el espacio en memoria que sera utilizado como buffer para el envio o recepcion de informacion sobre la red, nuestro siguiente paso sera llenarlo y para ello usamos a buffer_fill con los siguientes parametros respectivamente:

• el buffer que debemos llenar
• el desplazamiento (en bytes) para comenzar
• el tipo de datos con el cual lo llenaremos, en este caso es de tipo booleano o sea de 1 y 0
• este es el parametro que llenara el resto del buffer, para este caso usaremos a 0
• el tamaño del buffer que debe completar

Una vez hecho esto nos resta hacer el «broadcast» del mismo, cuando hablamos de broadcast es el envio masivo a traves de la red, esta funcion consta de los siguientes parametros respectivamente:

• el socket que debemos usar
• el puerto que debemos usar
• el buffer que debemos enviar
• el tamaño del buffer antes informado

A diferencia del caso anterior no pasamos el valor numerico del tamaño del buffer sino que utilizamos la funcion buffer_get_size para que la obtenga dandonos mejor versatilidad a la hora de implementarlo.

Nota: Esto mismo se podria hacer para el caso anterior.

Por ultimo tenemos dos funciones para primero destruir la conexion de red y la segunda para eliminar el buffer creado en memoria, con esto completamos el evento Create.

Nuestro siguiente paso sera agregar un nuevo evento y en este caso sera Asynchronous -> Async – Networking, una vez creado le agregaremos la siguiente linea:

global.ip_server = ds_map_find_value(async_load, "ip");

Para esta ocasion crearemos una variable global llamada ip_server la cual le asignaremos el valor de la ip de nuestro servidor, para ello usaremos la funcion ds_map_find_value la cual busca un valor en un map por medio de una clave, en este caso es ip, y nuestro mapa sera async_load el cual contiene varios datos internamente entre ellos la direccion IP de nuestro equipo, nuestro ultimo paso sera agregar el siguiente codigo en este evento:

instance_create_depth(0,0,0,obj_servidor);
instance_destroy();

La primera linea sera la encargada de crear una instancia de nuestro proximo objeto, para luego destruir la instancia que se genero del objeto obj_datos_red, con esto concluimos con nuestro primer objeto pasemos al siguiente.

En este caso crearemos un nuevo objeto con el mismo nombre que usamos para la creacion de la instancia, una vez hecho vamos a agregarle un evento Draw, con esto realizado agreguemos el siguiente codigo:

draw_set_alpha(1);
draw_text(20, 20, "IP SERVIDOR: " + global.ip_server);
draw_text(20, 60, "PUERTO: " + string(global.puerto_server));

Podemos resumirlo en que solamente mostrara los datos que obtuvimos con nuestro primer objeto, tanto la direccion IP como el puerto que generamos pero como este ultimo es de tipo numero (o Real) debemos convertirlo a tipo String para poder mostrarlo por medio de draw_text, le damos esa ubicacion de forma temporal, con esto concluimos por el momento con nuestro objeto obj_servidor.

El siguiente paso sera tomar nuestro primer objeto, obj_datos, red, y ubicarlo dentro del room que se genera de manera predeterminada (Room1) para ejecutar todas las acciones que vimos hasta ahora, les dejo un ejemplo de como se ve hasta el momento

Nota: Pueden hacerlo o no pero por un tema de practicidad modifique el tamaño del room a 320 x 128.

Con esto tenemos la primera parte de nuestro servidor creado dado que ya conocemos la direccion que posee el mismo y hemos creado la capacidad de generar un puerto al azar para evitar conflictos con otras aplicaciones pero en el proximo viene lo interesante.

En resumen, hoy hemos dado los primeros pasos sobre nuestro nuevo proyecto, en este caso un servidor encargado de manejar a los distintos clientes que se conecten, en esta ocasion hemos creado las rutinas necesarias para generar un puerto al azar y evitar conflictos con otras aplicaciones en el equipo, tambien hemos desarrollado una forma de poder obtener la direccion IP del equipo que usaremos como server y por ultimo generamos una forma de poder mostrarlo en pantalla, 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.