Gemix Photon

by **coldev** » Mon Mar 12, 2018 1:53 pm

Gracias por testear,

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

by **shao** » Tue Mar 13, 2018 12:18 pm

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.

http://www.youtube.com/user/fasetconasa · by **erkosone** » Tue Mar 13, 2018 1:17 pm

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.

by **shao** » Tue Mar 13, 2018 5:04 pm

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.

http://www.youtube.com/user/fasetconasa · by **erkosone** » Tue Mar 13, 2018 5:14 pm

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

by **shao** » Tue Mar 27, 2018 7:55 pm

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.

http://www.youtube.com/user/fasetconasa · by **erkosone** » Tue Mar 27, 2018 9:20 pm

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.

by **shao** » Wed Mar 28, 2018 10:19 am

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.

http://www.youtube.com/user/fasetconasa · by **erkosone** » Wed Mar 28, 2018 1:29 pm

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:

http://www.youtube.com/user/fasetconasa · by **erkosone** » Wed Mar 28, 2018 1:39 pm

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:

Source Code (Gemix) [ Download ] [ Hide ]

//===========================================================================
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
//===========================================================================
//===========================================================================

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:

Source Code (Gemix) [ Download ] [ Hide ]

                /* 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

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:

Source Code (Gemix) [ Download ] [ Hide ]

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

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

Gemix Photon

Re: GemixPhoton

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Re: Gemix Photon

Who is online