Gemix Photon

[coldev]

Gracias por testear,

podrian probar el ping haber que esta pasando....

[shao]

Añadí la línea:
photon_region_set(photon_region_select, "eu");

Y el ping volvió a ser más normal 50 / 70 en local, dos ejecuciones en mismo PC.
Pero la respuesta de los jugadores tiene más ping del que se indica.
Es decir, si yo soy el cliente y muevo mi personaje, lo que tarda en moverse en el servidor parece no coincidir con el ping que se indica, realmente hay más ping por que tarda demasiado en moverse para el ping que indica.
Además antes no necesitaba especificar la región y todo funcionaba normalmente, ahora si no la especificas obtienes más ping.

[erkosone]

antes estaba preseleccionada la "eu", supongo que ahora no. Solo es eso shao.
Sobre lo que comentas de que no coincide el ping.. pues yo no he notado nara asi pero puede ser, haber que dice COLDEV.

[shao]

Pues no estaría de más que Coldev avisara sobre estos cambios pero no vi nada sobre eso, creo que no ha dicho nada.

[erkosone]

"Supongo" que si no ha avisado de esto es por que no se ha dado cuenta, digo yo..

[shao]

Hola. Una pregunta sobre la tecnología que usa la librería de photon para Gemix.
Si se la quisiera cambiar de modo de enviar los datos, ¿costaría mucho cambiar a otro modo?.
Por ejemplo, creo que ahora usa UDP, ¿costaría mucho cambiar a TCP?.

Esto lo digo por que veo que existe un modo de conexión llamado websocket, como recientemente se ha publicado la librería que permite manejar datos JSON y websocket trabaja únicamente con texto, pensé que quizá era buena idea utilizar websocket ya que parece más avanzado de UDP.
Si no me equivoco websocket garantiza la llegada de paquetes, no habrá pérdidas, sólo trabaja con texto, sólo envía texto que podría ser JSON.
Tú tendrías tus datos a enviar, los empaquetas en JSON y envias esa cadena, después el cliente desempaqueta el JSON y lee los datos.

[erkosone]

web_services creo que quieres decir shao no?
web_services es un sistema normal y corriente de transacciones con la web y algunas cosas mas.

No es lo mismo que photon.

Photon es rapidisima, la web_services no, y no es por que sea mala, es por que son para cosas diferentes, la libreria photon es para real time, la web_services es para consultar bases de datos online en webs.
Si tu problema es que aveces los paquetes no llegan.. hay una solucion limpia y sencilla, un sistema de reenvio de paquetes hasta obtener acuse de recivo ACK y un stack con los id de los ultimos paquetes recividos.

Yo me lo he implementado como un modulo para gemix, funciona muy bien tio, es super facil.

[shao]

Lo más fácil sería que no hubiese perdida de paquetes pero creo que para la tecnología websocket gemix tendría que tener algún modulo oficial de gestión de datos JSON o hacerlo internamente.
No estoy seguro de eso.

[erkosone]

shao que los web sockets o los "sockets" en si mismo no son nada mas que una IP asociada a un puerto.
Los websockets/sockets trabajan tanto en UDP como en TCP, y si.. en ambas tecnologias hay perdida de paquetes, esto no es de gemix ni de algo en particular, perdida de paquetes hay en todo momento y a todas horas en todos los programas que se comunican por red.

Eres tu como programador el encargado de crear un sistema de ACK o "acuse de recivo" y reintentar los envios hasta conseguir que lleguen.

Esto es así en todos los lenguajes y en todas las plataformas, otra cosa es que quieras una libreria "facil y segura" acondicionada a juegos y que se encargue de todo esto ella sola.

Esta libreria la tendras, se llama mod_nertowrk.prg y la publicaré cuando la beta nueva beta sea estable y esté bien probada, antes es tonteria por que como siempre la beta va a traer cambios en nombres de funciones y cambios en funcionamientos que seguro que me obligaran a rehacerla y no tengo tiempo.

Pero vamos.. que el modulo photon está muy bien, solo que es una libreria "a pelo", ahora tenemos que convencer a coldev para que le añada varias cosas jejeejejeje sistema de mensajes, y sistema de CRC internos, aunque ya te digo que con el sistema que tengo montado todo esto ya lo puedes hacer.

Mira te pongo un ejemplo:
- Ahora para enviar un paquete y bla bla bla tienes que picar codigo royo montar el type, rellenarlo, enviarlo a varios o a un destinatario.. etc etc etc..
- Y no es seguro que llegue..

Vale, mira en la imagen como va el codigo para pedir algo al server o a otro player simulando TCP sin perdida de paquetes:

[erkosone]

creas un mensaje.
indicas lo que quieres preguntar..
añades parametros, variables o lo que necesites..
lo lanzas..

El solo se encarga de llegar.. "o reintentarlo hasta que llegue con ACK".. y lo mas importante.. se queda esperando la respuesta..

Para captar este tipo de envios solo necesitas pasar los paquetes tipo net_msg a esta funcion que hace de interprete de mensajes:
[Codebox=gemix file=Untitled.gemix]//===========================================================================
function netMessageReceived( netMsg m )
private
int atenderMensaje = false;
begin
// tener en cuenta que todos los campos del objeto netMessage son STRING!!
// incoluso el ORIGEN que indica el id_player que envia el mensaje..
if(exists(idPlayer))
///* SI EL MENSAJE ES PARA MI POR SLOT */
if( m.destino == PHOTON_PLAYER_ID )
atenderMensaje = true;
end
///* SI EL MENSAJE ES PARA TODOS */
if( m.destino < 0 )
atenderMensaje = true;
end
end
// + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
// + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
// + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
///* SI TOCA ATENDER EL MENSJAE POR UNO DE LOS MOTIVOS ANTERIORES */
if( atenderMensaje )

switch( m.accion )

/* MENSAJES DE CHAT */
case "chat":
if(STRSTR(net_msg_id_stack.str, m.PacketID) > -1)
//idChat.println("Ya existe en stack!");
else
//idChat.println("tag nuevo! se ha añadido al stack!");
net_msg_id_stack.add(m.PacketID);
idChat.println( strGetToken(m.msg, "#", 1) );
end
end

/* MENSAJES DE TILES DE ZONA */
case "getZone":
//idChat2.println("Cliente: " + itoa(m.origen) + " pide world.zone[" + strGetToken(m.msg,'#', 1) + "," + strGetToken(m.msg,'#', 2) + "]" );
// esta funcion esta en modNetwork.prg..
netSendZone( m.origen, atoi( strGetToken(m.msg,'#', 1) ), atoi( strGetToken(m.msg,'#', 2) ), m.PacketID );
end

/* MENSAJES DE OBJETOS DE ZONA */
case "getObjs":
//idChat2.println("Cliente: " + itoa(m.origen) + " pide objs[" + strGetToken(m.msg,'#', 1) + "," + strGetToken(m.msg,'#', 2) + "]" );
// esta funcion esta en modNetwork.prg..
netSendObjs( m.origen, atoi( strGetToken(m.msg,'#', 1) ), atoi( strGetToken(m.msg,'#', 2) ), m.PacketID );
end




/* MENSAJES DE RECOGIDA DE OBJETOS */
case "getObject":
if(STRSTR(net_msg_id_stack.str, m.PacketID) > -1)
//idChat.println("Ya existe en stack!");
else
net_msg_id_stack.add(m.PacketID);

cx_ = atoi( strGetToken(m.msg,'#', 1) ); // celda X de la recogida del item..
cy_ = atoi( strGetToken(m.msg,'#', 2) ); // celda Y de la recogida del item..
z = world.zone[ xZone, yZone ].objs[ cx_, cy_ ];
idChat.println( players[m.origen].nick + " has get: " + itoa(z) );
world.zone[ xZone, yZone ].objs[ cx_, cy_ ] = atoi( strGetToken(m.msg,'#', 3) ); // item que suelta el player si transportaba algo..
z = world.zone[ xZone, yZone ].objs[ cx_, cy_ ];
if(z == 0)
//idChat2.println( players[m.origen].nick + " no leaves nothing.." ); // si no dejo nada..
else
//idChat2.println( players[m.origen].nick + " leaves: " + itoa(z) ); // si dejo algun objeto..
z = world.zone[ xZone, yZone ].objs[ x, y ];
object( cx_, cy_, z ); // celdaX celdaY graph..
end
updateZoneMapObjects();
netSendACK( m.PacketID, m.origen );
end
end

end



end
// + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
// + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
// + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
return(0);
end
//===========================================================================
//===========================================================================[/Codebox]

Ves, en función de la "accion añadida al mensaje" puedes procesar la peticion, generar un resultado, y enviarlo al que lo ha solicitado.

Los netMessages tienen este cuerpo:

[Codebox=gemix file=Untitled.gemix] /* USER DEFINED NET DATA PACKET */
type netMsg // paquete personalizado..
int packetType = NET_PACKET_MSG;
string PacketID[8]; // identificador de paquete..
string msg[640] = "";
int origen;
int destino;
string accion[32] = "";
end[/Codebox]

Contienen su origen, su destino, la accion que quieren, y en msg[] los parametros.

No falla ni un envio.. mira el codigo de un mensaje:

[Codebox=gemix file=Untitled.gemix]process netMessage( int destino )
private
netMsg myMessage;
string delimitier = "#";
Photon_Packed paquete;
int timeout;
int retry = 3;
int client_target[1] = 0;
methods
//------------------------------------------------------------------------------------
method callback initialize()
begin
timeout = (2*photon_server_ping) + 50; // timeout del mensaje
msgIdCounter = msgIdCounter + 1;
PacketID = itoa(PHOTON_PLAYER_ID) + "-" + itoa(msgIdCounter);
end
//------------------------------------------------------------------------------------
method public setTimeout(int ms)
begin
timeout = ms;
end
//------------------------------------------------------------------------------------
method public add(string s)
begin
myMessage.msg += s;
myMessage.msg += delimitier;
return(0);
end
//------------------------------------------------------------------------------------
method public string get(int num)
begin
//strGetToken( msg, delimiter, num );
return( strGetToken( myMessage.msg, delimitier, num ) );
end
//------------------------------------------------------------------------------------
method public setAction( string action )
begin
myMessage.accion = action;
return(0);
end
//------------------------------------------------------------------------------------
method public size()
begin
return( strtokencount( myMessage.msg, delimitier ) );
end
//------------------------------------------------------------------------------------
method public send()
begin
client_target[0] = destino;
myMessage.PacketID = PacketID;
myMessage.origen = PHOTON_PLAYER_ID; // indica el jugador que crea el mensaje.. necesario para responderle luego..
myMessage.destino = destino; // indica el jugador al que va dirigido el mensaje..
paquete.data = &myMessage; // indica el inicio del mensaje..
paquete.data_length = sizeof(netMsg); // indica el final del mensaje..
if( destino > 0 ) // SI EL DESTINO ES UN SIMPLE NUMERO DE SLOT..
PHOTON_PACK_SENDGROUP( &paquete, true, &client_target, 0); // envio el mensaje a su destinatario..
else
PHOTON_PACK_SEND( &paquete , true); // envio el mensaje a todos los clientes conectados..
end
st = 10;
return(0);
end
//------------------------------------------------------------------------------------
method public delete()
begin
signal(this, s_kill);
return(0);
end
//------------------------------------------------------------------------------------
begin
loop
switch(st)
case 0:
// wait to send msg..
end
case 10:
// msg just sended..
z = GET_MILLISECS();
st = 20;
end
case 20:
// if disconnect from network..
if( !PHOTON_CONNECTED )
signal(this, s_kill);
end
// if timeout..
if( (GET_MILLISECS() - z) > timeout )
if(retry > 0)
retry--;
send();
else
signal(this, s_kill);
end
end
end
end
frame;
end
end[/Codebox]

Conclusion, sistema de mensajes emulando TCP bajo la tecnologia photon jeje, la verdad es que funciona a las mil maravillas