Foro de elhacker.net

Hola.
esque estoy intentando hacer street fighter "online por asi decirlo" poco a poco conforme voy aprendiendo.
y mi problema llega aqui.

e conseguido que desde el cliente se mueva el pj en servidor.

pero ahora supongomago para hacer 1 partida de 1vs1:

PC 1 envia informacion al PC 2 . "PC 1 cliente, PC 2 servidor"
PC 2 actualiza los datos enviados del PC 1.
PC 2 envia informacion al PC1 . "PC 2 cliente , PC 1 servidor"
PC 1 actualiza los datos enviados del PC2.

...

para hacer esto deberian de ser servidor-cliente.
eso se puede hacer?
Nuevo code.
explico.
si se pone el exit(1) en el punto indicado se cierra hasta a i bien. peor el problema es que hay 1 orden antes que no la hace, que es guardar X datos en el archivo externo

#include <iostream>
#include <fstream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_net.h>
using namespace std;
SDL_Surface *screen;
SDL_Event evento;
Uint8 *tecla;
////////////////////////////////////////////////////////////
ofstream LOG("log.txt",ios::out);
ofstream ERROR("error.txt",ios::out);
////////////////////////////////////////////////////////////
IPaddress ipservidor,*ipremitente,ipcliente;
TCPsocket sservidor,sremitente,scliente;
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
char DATOS[10];
int main(int argc,char *argv[]){
    SDL_Init(SDL_INIT_VIDEO);
    SDLNet_Init();
    screen=SDL_SetVideoMode(540,480,32,SDL_SWSURFACE);
    SDL_WM_SetCaption("Servidor-Cliente, By Xafi ...",0);
    //servidor
    SDLNet_ResolveHost(&ipservidor,0,2000);
    sservidor=SDLNet_TCP_Open(&ipservidor);
 
    //cliente
    SDLNet_ResolveHost(&ipcliente,"127.0.0.1",2000);
    scliente=SDLNet_TCP_Open(&ipcliente);
    //
    while(1){
        SDL_Delay(30);
        //LOG << "\nCONEXIONES: \tServidor: " << SDLNet_Read32(&ipservidor.host) << "\tCliente: " << SDLNet_Read32(&ipremitente->host);
        SDLNet_TCP_Send(scliente,"cliente conectado",512);
        if(sremitente=SDLNet_TCP_Accept(sservidor)){
            ERROR << "CONECTADO";
            ipremitente=SDLNet_TCP_GetPeerAddress(sremitente);
            while(1){
                LOG << "\nCONEXION: " << SDLNet_Read32(&ipremitente->host);
                //pongan la siguiente linea
                //exit(1)
                SDLNet_TCP_Recv(sremitente,DATOS,512);
                tecla=SDL_GetKeyState(0);
                SDL_PollEvent(&evento);
                if(tecla[SDLK_ESCAPE])exit(1);
            }
        }
        else ERROR << "\n" << SDLNet_GetError();
    }
 
}
 
 

Este tema se había planteado antes (creo xD)... y la cosa depende ... depende de cuantos clientes quieras escalar ...
usando el método de cliente-servidor/PC con varias compus terminás con que el ancho de banda se dispara de forma exponencial con cada máquina que agregás ... (muchas computadoras notificándose las unas a las otras sobre updates) y salvo que implementes un buen balancing de carga, no se sostiene... salvo que se aminore usando un modelo de cliente y servidor ..

Además de que con ese balancing tirás para arriba las posibilidades de "chitear" ...   la cantidad de datos procesados en el server es inversamente proporcional a la probabilidad de hacer un cheat  ... (y directamente proporcional a la dificultad de hacerlo)

Lo importante es pensar en términos de diffs (de updates o actualizaciones) y  de compresión a nivel bit ....
también e ideal sería predicción de acciones, pero esto es opcional ....

todo lo que puedas empaquetar y que no se te vaya del rango de número de bits, empaquetalo .... y sobre todo evitá la redundancia (lo que pueda calcularse en base a otras cosas, calculalas ...), date una idea que tenés que mantener un flujo constante de información si no querés que la info se vea "rara" o cortada ... 30 updates sobre segundo aproximadamente para mantener un flujo constante ...

podés armar algo muy básico con aproximadamente 8 bytes por update ...

hay un ejercicio interesante, y es ponerse a ver todo lo que podrías o deberías transmitir en cada update (es decir el qué podés hacer para determinar cuanto tenés que enviar y cada cuanto), pasarlo a en cuanto pesaría, y multiplicarlo por la cantidad de updates por segundo ... y ahí te das cuenta del problema y prioridad "ancho de banda" (y de lo que sería plantear un buen esquema de actualizacion tanto del lado cliente y servidor)

por eso diría que no te malcríes con librerías de alto nivel para lo que es redes, salvo que te den flexibilidad de hacer cosas de bajo nivel (esto te lo digo por si las dudas, nunca miré ni de lejos SDL_Net, es mandar fruta para tu caso, ví otras y no me gustaron ... pero por si aplica, siempre usé mis propias clases basadas en sockets a pelo por que te permite esbozar bien lo que querés y como querés mandarlo)


Saludos.

vertex@Symphony gracias por lo que me has dicho lo tendre en cuenta.
pero no soy experto como para hacerme 1 libreria de sockets, ni mucho menos si, ni siquiera ser usar SDLNet, que la veo muy facil pero el problema es que se me cuelga si hago 2 llamadas a

socket_s=SDLNet_TCP_Open(&ip_s); // esta para recivir
socket_c=SDLNet_TCP_Open(&ip_c);// esta para mandar
XS

actualizado. ayudenme por favor

Bueno la idea me vino mientras miraba mis plantas de mariahachis XD.


aqui esta el code. con alto indice de fallos y errores e conseguid conectar .
creo que se cuales son los fallos intentare arreglarlo.
pero lo principal que e conseguido hacer servidor-cliente.

#include <iostream>
#include <fstream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_net.h>
using namespace std;
SDL_Surface *screen;
SDL_Event evento;
Uint8 *tecla;
////////////////////////////////////////////////////////////
ofstream LOG("log.txt",ios::out);
ofstream ERROR("error.txt");
////////////////////////////////////////////////////////////
IPaddress ipservidor,*ipremitente,ipcliente;
TCPsocket sservidor,sremitente,scliente;
int opcion=0;
int cl=0;
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
char DATOS[512];
int main(int argc,char *argv[]){
    SDL_Init(SDL_INIT_VIDEO);
    SDLNet_Init();
    screen=SDL_SetVideoMode(540,480,32,SDL_SWSURFACE);
    SDL_WM_SetCaption("Servidor-Cliente, By Xafi ...",0);
    //servidor
    SDLNet_ResolveHost(&ipservidor,0,2000);
    //sservidor=SDLNet_TCP_Open(&ipservidor);
    //cliente
    SDLNet_ResolveHost(&ipcliente,"127.0.0.1",2000);
    //scliente=SDLNet_TCP_Open(&ipcliente);
    while(1){
        SDL_Delay(30);
        tecla=SDL_GetKeyState(0);
        SDL_PollEvent(&evento);
        if(tecla[SDLK_ESCAPE])exit(1);
        if(opcion==0){
            if(tecla[SDLK_s]){
                opcion=1;
                cl=1;
 
            }
            if(tecla[SDLK_c]){
                opcion=2;
                cl=2;
 
            }
        }
        //sservidor=SDLNet_TCP_Open(&ipservidor);
        if(opcion==1){
            if(cl==2 || cl==3)SDLNet_TCP_Close(scliente);
            sservidor=SDLNet_TCP_Open(&ipservidor);
            LOG << "\nCONEXIONES: \tServidor: " << SDLNet_Read32(&ipservidor.host);
            while(1){
                if(sremitente=SDLNet_TCP_Accept(sservidor)){
                    ERROR << "CONECTADO";
                    ipremitente=SDLNet_TCP_GetPeerAddress(sremitente);
                    LOG << "\nCONEXION: " << SDLNet_Read32(&ipremitente->host);
                    SDLNet_TCP_Recv(sremitente,DATOS,512);
                    break;
                }
            }
            opcion=2;
            cl=3;
        }
        if(opcion==2){
            if(cl==1 || cl==3)SDLNet_TCP_Close(sservidor);
            scliente=SDLNet_TCP_Open(&ipcliente);
            SDLNet_TCP_Send(scliente,"datos",512);
            SDLNet_TCP_Close(scliente);
            opcion=1;
            cl=3;
        }
    }
 
}