- reworked completly the JNetwork, JSocket interface (had to ifdef out the PSP socket code)

- added 2 menus to wait for connection and wait for deck selection
- tested compilation on Qt Linux, Qt Windows and PSP
- deactivated everywhere (NETWORK_SUPPORT to activate).

JGE/include/JNetwork.h

@@ -6,47 +6,41 @@
 
 #include "JGE.h"
 #include <string>
+#include <map>
 using namespace std;
+class JSocket;
+#include <iostream>
+#include <sstream>
+#include "Threading.h"
 
-class JNetwork{
+typedef void(*processCmd)(istream&, ostream&);
+
+class JNetwork {
 private:
-  static JNetwork * mInstance;
+  int connected_to_ap;
-  static int connected_to_ap;
+  JSocket* socket;
-  
+  boost::mutex sendMutex;
+  boost::mutex receiveMutex;
+  stringstream received;
+  stringstream toSend;
+  static map<string, processCmd> sCommandMap;
+
 public:
-  static  string error;
   JNetwork();
-  static JNetwork * GetInstance();
+  ~JNetwork();
-  static void EndInstance();
+  string serverIP;
-  static string serverIP;
+
-  int receive(char * buffer, int length);
-  int send(char * buffer, int length);
   int connect(string serverIP = "");
-  static int isConnected();
+  bool isConnected();
-#if defined (WIN32)
+  static void ThreadProc(void* param);
-  static int net_thread(void* param);
+#if !defined (WIN32) && !defined (LINUX)
-#elif defined (LINUX)
-  static void* net_thread(void* param);
-#else
   static int connect_to_apctl(int config);
 #endif
+  bool sendCommand(string command);
+  static void registerCommand(string command, processCmd processCommand, processCmd processResponse);
 
 private:
-
+  boost::thread *mpWorkerThread;
-#if defined (WIN32)
-  static DWORD netthread;
-#elif defined (LINUX)
-  static pthread_t netthread;
-#else
-    static int netthread;
-#endif
-
 };
 
-#if defined (WIN32)
-#elif defined (LINUX)
-#else
-  static int net_thread(SceSize args, void *argp);
-#endif
-
 #endif

JGE/include/JSocket.h

@@ -2,29 +2,48 @@
 #define _JSOCKET_H_
 
 #include <queue>
+#include "Threading.h"
 using namespace std;
 
-//TODO config ?
-#define SERVER_PORT 20666
-
 class JSocket{
 public:
-  queue<char> received_data;
+    typedef enum {
-  queue<char> tosend_data;
+        // no network available currently from the device
-  static JSocket * mInstance;
+        NOT_AVAILABLE,
-  int start_server(const char *szIpAddr);
+        // network available but disconnected from another socket
-  int start_client(const char *szIpAddr);
+        DISCONNECTED,
-  
+        // connected with another socket
+        CONNECTED,
+        // some fatal problem
+        FATAL_ERROR,
+    } SOCKET_STATE;
+
+
+  // Server creation
+  JSocket(string ipAddr);
+  // Client creation
   JSocket();
   ~JSocket();
-  static int connected;
+
+  JSocket* Accept();
+  int Read(char* buff, int size);
+  int Write(char* buff, int size);
+  bool isConnected() { return state == CONNECTED; };
+  void Disconnect();
+
 private:
-  void init();  
+  // socket creation when server accepts a connection
-  void readWrite(int sock);
+  JSocket(int fd);
-#if defined (WIN32) || defined (LINUX)
+  // convert the socket into non-blocking state
-#else
+  bool SetNonBlocking(int sock);
-  int make_socket(uint16_t port);
+  // socket handle
+#ifdef WIN32
+  SOCKET mfd;
+#elif LINUX
+  int mfd;
 #endif
+  // socket state
+  SOCKET_STATE state;
 };
 
 #endif

JGE/src/JNetwork.cpp

@@ -4,7 +4,7 @@
 
 */
 
-
+#include "../include/DebugRoutines.h"
 #include "../include/JNetwork.h"
 
 #if defined (WIN32) || defined (LINUX)
@@ -30,144 +30,154 @@
 
 #endif
 
-
+#include <sstream>
-
 #include "../include/JSocket.h"
 
-JNetwork* JNetwork::mInstance = NULL;
+map<string, processCmd> JNetwork::sCommandMap;
-string JNetwork::serverIP = "";
-string JNetwork::error = "";
 
-JNetwork * JNetwork::GetInstance(){
+bool JNetwork::isConnected(){
-  if (!mInstance) mInstance = new JNetwork();
+  if (connected_to_ap !=1) return false;
-  return mInstance;
+  return socket->isConnected();
 }
 
-void JNetwork::EndInstance(){
+JNetwork::JNetwork()
-  SAFE_DELETE(mInstance);
+  : mpWorkerThread(NULL)
-}
+{
-
+#if (defined WIN32) || (defined LINUX)
-
+  connected_to_ap = 1;
-
-#if defined (WIN32)
-  DWORD JNetwork::netthread = 0;
-  int JNetwork::connected_to_ap = 1;
-#elif defined (LINUX)
-  pthread_t JNetwork::netthread = NULL;
-  int JNetwork::connected_to_ap = 1;
 #else
-  int JNetwork::connected_to_ap = 0;
+  connected_to_ap = 0;
-  int JNetwork::netthread = 0;
 #endif
 
-int JNetwork::isConnected(){
-  if (connected_to_ap !=1) return 0;
-  return JSocket::connected;
 }
 
-JNetwork::JNetwork(){
+JNetwork::~JNetwork()
-}
-
-int JNetwork::receive(char * buffer, int length){
-  JSocket * socket = JSocket::mInstance;
-  if (!socket) return 0;
-  int size = 0;
-  while(!socket->received_data.empty() && size < length){
-    buffer[size] = socket->received_data.front();
-    socket->received_data.pop();
-    size++;
-  }
-  return size;
-}
-
-int JNetwork::send(char * buffer, int length){
-  JSocket * socket = JSocket::mInstance;
-  if (!socket) return 0;
-  for (int i = 0; i < length; i++){
-    socket->tosend_data.push(buffer[i]);
-  }
-  return length;
-}
-
-
-
-#if defined (WIN32)
-int JNetwork::net_thread(void* param)
 {
-  do
+  if(mpWorkerThread) {
+    socket->Disconnect();
+    mpWorkerThread->join();
+    delete mpWorkerThread;
+  }
+  if(socket)
+    delete socket;
+}
+
+bool JNetwork::sendCommand(string xString)
+{
+  string aString = xString;
+  boost::mutex::scoped_lock l(sendMutex);
+  if(!socket) {
+    DebugTrace("sendCommand failed: no sockeet");
+    return false;
+  }
+  aString = aString + "Command";
+  if(sCommandMap.find(aString) == sCommandMap.end()) {
+    DebugTrace("sendCommand failed: command not registered");
+    return false;
+  }
+  aString = aString + "\n";
+
+  toSend << aString;
+
+  return true;
+}
+
+void JNetwork::registerCommand(string command, processCmd processCommand, processCmd processResponse)
+{
+  sCommandMap[command + "Command"] = processCommand;
+  sCommandMap[command + "Response"] = processResponse;
+}
+
+void JNetwork::ThreadProc(void* param)
+{
+  JNetwork* pThis = reinterpret_cast<JNetwork*>(param);
+  JSocket* pSocket = NULL;
+  if (pThis->serverIP.size()) {
+    DebugTrace("Starting Client Thread");
+    pThis->socket = new JSocket(pThis->serverIP);
+    if(pThis->socket->isConnected())
+      pSocket = pThis->socket;
+  } else {
+    DebugTrace("Starting Server Thread");
+    pThis->socket = new JSocket();
+    // Wait for some client
+    pSocket = pThis->socket->Accept();
+  }
+
+  while(pSocket && pSocket->isConnected()) {
+    char buff[1024];
     {
-      JSocket::mInstance = new JSocket();
+      boost::mutex::scoped_lock l(pThis->receiveMutex);
-      JSocket * s = JSocket::mInstance;
+      int len =  pSocket->Read(buff, sizeof(buff));
-      if (JNetwork::serverIP.size()){
+      if(len) {
-	OutputDebugString(JNetwork::serverIP.c_str());
+        DebugTrace("receiving " << len << " bytes : " << buff);
-	s->start_client(JNetwork::serverIP.c_str());
+        pThis->received << buff;
-      }else{
+      }
-	s->start_server(""); //IP address useless for server ?
+      // Checking for some command to execute
+      size_t found = pThis->received.str().find("Command");
+      if(found != string::npos)
+      {
+        map<string, processCmd>::iterator ite = sCommandMap.find((pThis->received.str()).substr(0, found) + "Command");
+        if(ite != sCommandMap.end())
+        {
+          DebugTrace("begin of command received : "<< pThis->received.str() );
+          DebugTrace("begin of command toSend : "<< pThis->toSend.str() );
+
+          boost::mutex::scoped_lock l(pThis->sendMutex);
+          pThis->toSend << pThis->received.str().substr(0, found) + "Response ";
+          pThis->received.str("");
+          processCmd theMethod = (ite)->second;
+          theMethod(pThis->received, pThis->toSend);
+
+          DebugTrace("end of command received : "<< pThis->received.str() );
+          DebugTrace("end of command toSend : "<< pThis->toSend.str() );
+        }
+      }
+      // Checking for some response to execute
+      found = pThis->received.str().find("Response");
+      if(found != string::npos)
+      {
+        map<string, processCmd>::iterator ite = sCommandMap.find((pThis->received.str()).substr(0, found) + "Response");
+        if(ite != sCommandMap.end())
+        {
+          DebugTrace("begin of response received : "<< pThis->received.str() );
+          DebugTrace("begin of response toSend : "<< pThis->toSend.str() );
+
+          boost::mutex::scoped_lock l(pThis->sendMutex);
+          string aString;
+          pThis->received >> aString;
+          processCmd theMethod = (ite)->second;
+          theMethod(pThis->received, pThis->toSend);
+          pThis->received.str("");
+
+          DebugTrace("end of response received : "<< pThis->received.str() );
+          DebugTrace("end of response toSend : "<< pThis->toSend.str() );
+        }
       }
     }
-  while(0);
 
-  return 0;
+    boost::mutex::scoped_lock l(pThis->sendMutex);
-}
+    if(!pThis->toSend.str().empty())
-int JNetwork::connect(string serverIP){
-  if(netthread) return 0;
-
-  JNetwork::serverIP = serverIP;
-  /* Create a user thread to do the real work */
-  HANDLE hthread;
-  hthread=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)net_thread,0,0,&netthread);
-  return netthread;
-}
-
-#elif defined (LINUX)
-void* JNetwork::net_thread(void* param __attribute__((unused)))
-{
-  do
     {
-      JSocket::mInstance = new JSocket();
+      DebugTrace("sending  " << pThis->toSend.str().size() << " bytes : " << pThis->toSend.str());
-      JSocket * s = JSocket::mInstance;
+      pSocket->Write((char*)pThis->toSend.str().c_str(), pThis->toSend.str().size()+1);
-      if (JNetwork::serverIP.size())
+      pThis->toSend.str("");
-	s->start_client(JNetwork::serverIP.c_str());
-      else
-	s->start_server(""); //IP address useless for server ?
     }
-  while (0);
+  }
-  return NULL;
+
+  DebugTrace("Quitting Thread");
 }
 
-int JNetwork::connect(string serverIP)
+#if defined (WIN32) || defined (LINUX)
+int JNetwork::connect(string ip)
 {
-  if (netthread) return 0;
+  if (mpWorkerThread) return 0;
-  JNetwork::serverIP = serverIP;
+  serverIP = ip;
-  return pthread_create(&netthread, NULL, net_thread, NULL);
+  mpWorkerThread = new boost::thread(JNetwork::ThreadProc, this);
+  return 42;
 }
 
 #else
-int net_thread(SceSize args, void *argp)
-{
-#ifdef NETWORK_SUPPORT
-	do
-	{
-    JSocket::mInstance = new JSocket();
-    JSocket * s = JSocket::mInstance;
-    if (JNetwork::serverIP.size()){
-			s->start_client(JNetwork::serverIP.c_str());
-
-    }else{
-			// connected, get my IPADDR and run test
-			SceNetApctlInfo szMyIPAddr;
-      if (sceNetApctlGetInfo(8, &szMyIPAddr) != 0){
-      }else{
-			  s->start_server(szMyIPAddr.ip);
-      }
-
-		}
-	}
-	while(0);
-#endif
-	return 0;
-}
-
 
 int JNetwork::connect(string serverIP){
 #ifdef NETWORK_SUPPORT

JGE/src/JSocket.cpp

@@ -1,3 +1,5 @@
+#if 0
+// need a complete rewrite to comply to the new interface
 #ifdef NETWORK_SUPPORT
 
 #include <pspkernel.h>
@@ -223,5 +225,6 @@ int JSocket::start_server(const char *szIpAddr)
 	return 0;
 }
 
+#endif //NETWORK_SUPPORT
 
 

JGE/src/pc/JSocket.cpp

@@ -1,230 +1,301 @@
+#include "PrecompiledHeader.h"
+
+#include <errno.h>
+#ifdef WIN32
 #pragma comment(lib,"WSOCK32.LIB")
 #include <stdio.h>
 #include <conio.h>
 #include <winsock.h>
-#include <errno.h>
 #include <winsock.h>
+#include <fcntl.h>
+#elif LINUX
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <fcntl.h>
+#endif //WINDOWS
 
 #include "../../include/JSocket.h"
-JSocket * JSocket::mInstance = NULL;
+//JSocket * JSocket::mInstance = NULL;
 
-#define SERVER_PORT 20666
+//#define SERVER_PORT 20666
+#define SERVER_PORT 5001
 unsigned char ADRESSE_IP_SERVEUR [4] = {127,0,0,1};
 
 
-int JSocket::connected = 0;
+JSocket::JSocket(string ipAddr)
-
+  : state(NOT_AVAILABLE),
-void JSocket::init(){
+  mfd(-1)
-	//TODO ?
+{
-}
+  int result = -1;
-
+#ifdef WIN32
-JSocket::JSocket(){
-  init();
-}
-
-JSocket::~JSocket(){
- //TODO ?
-}
-
-
-void JSocket::readWrite(int val){
-  char data[1024];
-
-  	fd_set set;
-    FD_ZERO(&set);
-	  FD_SET(val, &set);
-    struct timeval tv;
-   int result = select(0, &set, NULL, NULL, &tv);
-		if( result< 0)
-		{
-      printf("Socket %d closed\n", val);
-		  closesocket(val);
-      connected= 0;
-			printf("select error\n");
-			return;
-		}
-    
-    if (result > 0){
-      OutputDebugString("Receiving!\n");
-      int readbytes = recv(val, data, sizeof(data),0);
-	    if(readbytes < 0)
-	    {
-        int error = WSAGetLastError();
-        if (error != WSAEWOULDBLOCK){
-		      printf("Socket %d closed\n", val);
-		      closesocket(val);
-          connected= 0;
-        }
-	    }
-	    else
-	    {
-        OutputDebugString("received Data!!!\n");
-		    for (int i = 0; i < readbytes; i++){
-		      received_data.push(data[i]);
-          OutputDebugString("getting byte\n");
-		    }
-	    }
-    }
-
-  //Write
-  int size = 0;
-  while(!tosend_data.empty()){
-    size++;
-    if (size > sizeof(data)){
-      send(val,data,sizeof(data),0);
-      size = 0;
-    }
-    data[size-1] = tosend_data.front();
-    tosend_data.pop();
-  }
-  if (size) {
-    send(val,data,size-1,0);
-    OutputDebugString("sending Data\n");
-  }
-}
-
-/* Start a client */
-int JSocket::start_client(const char *szIpAddr){
   SOCKET Desc_Socket_Cliente;
-  SOCKADDR_IN Adresse_Socket_Serveur;
+#elif LINUX
+  int Desc_Socket_Cliente;
+#endif
+
+  struct hostent *hostentptr;
+#ifdef WIN32
+  SOCKADDR_IN Adresse_Socket_Server;
   WORD wVersionRequested;
   WSADATA wsaData;
 
-  struct hostent *hostentptr;
-
   wVersionRequested=MAKEWORD(1,1);
-  WSAStartup(wVersionRequested,&wsaData);
+  result = WSAStartup(wVersionRequested,&wsaData);
+  if(result!=0){
+    DebugTrace("WSAStartup\t");
+    return;
+  }
+#elif LINUX
+  struct sockaddr_in Adresse_Socket_Server;
+#endif
 
-  Desc_Socket_Cliente=socket(AF_INET,SOCK_STREAM,0);
+  mfd=socket(AF_INET,SOCK_STREAM,0);
-  unsigned int addr_dest = inet_addr(szIpAddr); 
+  if(mfd < 0)
+    return;
+  DebugTrace("Connecting " << ipAddr);
+
+#ifdef WIN32
+  unsigned int addr_dest = inet_addr(ipAddr.c_str());
   hostentptr=gethostbyaddr((char*) &addr_dest,4,AF_INET);
+#elif LINUX
+  hostentptr = gethostbyname(ipAddr.c_str());
+#endif
+  if (hostentptr == NULL) {
+      DebugTrace("ERROR, no such host\n");
+      return;
+  }
 
-  ZeroMemory(&Adresse_Socket_Serveur,sizeof(Adresse_Socket_Serveur));
+#ifdef WIN32
+  ZeroMemory( (char*)&Adresse_Socket_Server,sizeof(Adresse_Socket_Server));
+#elif LINUX
+  bzero( (char*)&Adresse_Socket_Server,sizeof(Adresse_Socket_Server));
+#endif //WINDOWS
 
-  Adresse_Socket_Serveur.sin_family=(*hostentptr).h_addrtype;
+  Adresse_Socket_Server.sin_family=(*hostentptr).h_addrtype;
-  Adresse_Socket_Serveur.sin_port=htons(SERVER_PORT);
+  Adresse_Socket_Server.sin_port=htons(SERVER_PORT);
-  Adresse_Socket_Serveur.sin_addr=*((struct in_addr*)(*hostentptr).h_addr);
+  Adresse_Socket_Server.sin_addr=*((struct in_addr*)(*hostentptr).h_addr);
-
-  int result = connect(
-    Desc_Socket_Cliente,
-    (const struct sockaddr*)&Adresse_Socket_Serveur,
-    sizeof(Adresse_Socket_Serveur));
-
-OutputDebugString("client state 0\n");
 
+  result = connect(
+      mfd,
+      (const struct sockaddr*)&Adresse_Socket_Server,
+      sizeof(Adresse_Socket_Server));
   if (result != 0){
-    connected = 0;
+      DebugTrace("client connect failed :" << strerror(errno));
-    return 0;
+      state = FATAL_ERROR;
+      return;
   }
 
-OutputDebugString("client state 1\n");
+  state = CONNECTED;
+}
 
+bool JSocket::SetNonBlocking(int sock)
+{
+  int opts;
 
-  connected = 1;
+#ifdef WIN32
-
+#elif LINUX
-while(1){
+  opts = fcntl(sock,F_GETFL);
-  readWrite(Desc_Socket_Cliente);
+  if (opts < 0) {
-/*  Nb_Caracteres_Recus=recv(Desc_Socket_Cliente,Message_Recu,sizeof(Message_Recu),0);
+    perror("fcntl(F_GETFL)");
-  if(Nb_Caracteres_Recus<=0){
+    return false;
-    //continuer=FALSE;
-  }else{
-    strcpy(message,Message_Recu);
-    len=strlen(message);
   }
-  */
+  opts = (opts | O_NONBLOCK);
-}
+  if (fcntl(sock,F_SETFL,opts) < 0) {
-#
+    perror("fcntl(F_SETFL)");
-closesocket(Desc_Socket_Cliente);
+    return false;
-WSACleanup();
+  }
-return 0;
+#endif //WINDOWS
+  return true;
 }
 
-/* Start a server */
+JSocket::JSocket()
-int JSocket::start_server(const char *szIpAddr){
+  : state(NOT_AVAILABLE),
-  OutputDebugString("server state 0\n");
+  mfd(-1)
-  connected= 0;
+{
-  int Code_Retour;
+  int result;
-  SOCKET Desc_Socket_Connection;
+#ifdef WIN32
   SOCKADDR_IN Adresse_Socket_Connection;
   WORD wVersionRequested;
   WSADATA wsaData;
 
   wVersionRequested=MAKEWORD(1,1);
+  result=WSAStartup(wVersionRequested,&wsaData);
 
-  Code_Retour=WSAStartup(wVersionRequested,&wsaData);
+  if(result!=0){
-
+    DebugTrace("WSAStartup\t");
-  if(Code_Retour!=0){
+    return;
-    perror("WSAStartup\t");
-    _getch();
-    WSACleanup();
-    return Code_Retour;
   }
-  OutputDebugString("server state 1\n");
+#elif LINUX
-/*    printf("la version supportee est : %d.%d\n",
+  struct sockaddr_in Adresse_Socket_Connection;
-LOBYTE(wsaData.wHighVersion),
+#endif //WINDOWS
-HIBYTE(wsaData.wHighVersion)
-);*/
 
-  Desc_Socket_Connection=socket( AF_INET, SOCK_STREAM,0);
+  mfd=socket( AF_INET, SOCK_STREAM,0);
 
-//printf("valeur de la socket = %d\n",Desc_Socket_Connection);
+#ifdef WIN32
+#elif LINUX
+  int reuse_addr = 1;  /* Used so we can re-bind to our port
+        while a previous connection is still
+        in TIME_WAIT state. */
+  /* So that we can re-bind to it without TIME_WAIT problems */
+  setsockopt(mfd, SOL_SOCKET, SO_REUSEADDR, &reuse_addr,
+    sizeof(reuse_addr));
+#endif //WINDOWS
 
-  ZeroMemory(&Adresse_Socket_Connection,sizeof(Adresse_Socket_Connection));
+  SetNonBlocking(mfd);
+
+#ifdef WIN32
+  ZeroMemory( &Adresse_Socket_Connection,sizeof(Adresse_Socket_Connection));
+#elif LINUX
+  bzero( &Adresse_Socket_Connection,sizeof(Adresse_Socket_Connection));
+#endif //WINDOWS
   Adresse_Socket_Connection.sin_family=AF_INET;
   Adresse_Socket_Connection.sin_port=htons(SERVER_PORT);
 
-  Code_Retour=bind(Desc_Socket_Connection,
+  result=bind(mfd,
     (struct sockaddr*)&Adresse_Socket_Connection,
     sizeof(Adresse_Socket_Connection));
-
+  if(result!=0){
-
+    state = FATAL_ERROR;
-
+    DebugTrace("bind error:" <<  strerror(errno));
-  if(Code_Retour!=0){
+    return;
-    perror("bind\t");
-    _getch();
-    closesocket(Desc_Socket_Connection);
-    WSACleanup();
-    return Code_Retour;
   }
-  OutputDebugString("server state 3\n");
 
-  Code_Retour=listen(Desc_Socket_Connection,1);
+  result=listen(mfd,1);
-  if(Code_Retour!=0){
+  if(result!=0){
-    perror("listen\n");
+    state = FATAL_ERROR;
-    WSACleanup();
+    DebugTrace("listen error:" << strerror(errno));
-    return Code_Retour;
+    return;
   }
-  OutputDebugString("server state 4\n");
-  printf("serveur en attente d'une connection\n\n");
-  printf("***************arret du serveur par<CTRL><C>**************\n\n");
-  connected = 1;
-  while(1){
-    SOCKET * pt_Nouveau_Socket_Serveur;
-    SOCKADDR_IN Adresse_Socket_Cliente;
-    int Longueur_Adresse;
 
-    pt_Nouveau_Socket_Serveur = new SOCKET;
+  state = DISCONNECTED;
+}
 
-    Longueur_Adresse = sizeof(Adresse_Socket_Cliente);
+JSocket::JSocket(int fd)
+  : state(CONNECTED),
+  mfd(fd)
+{
+}
 
-    int val=accept(
+JSocket::~JSocket(){
-      Desc_Socket_Connection,
+  Disconnect();
-      (struct sockaddr*)&Adresse_Socket_Cliente,
+#ifdef WIN32
-      &Longueur_Adresse);
+  WSACleanup();
-    printf("connection accepte depuis le port client %d\n", ntohs(Adresse_Socket_Cliente.sin_port));
+#endif
-      OutputDebugString("connection accepte depuis le port client\n");
+}
 
-
+void JSocket::Disconnect()
-    while(1)
+{
-    {
+  state = JSocket::DISCONNECTED;
-	    readWrite(val);
+  if(mfd) {
-    }
+#ifdef WIN32
-    closesocket(*pt_Nouveau_Socket_Serveur);
+    closesocket(mfd);
-    return 0;
+#elif LINUX
+    close(mfd);
+#endif
+    mfd = 0;
   }
 }
 
-
+JSocket* JSocket::Accept()
-
+{
+  #ifdef WIN32
+  SOCKADDR_IN Adresse_Socket_Cliente;
+  int Longueur_Adresse;
+  #elif LINUX
+  struct sockaddr_in Adresse_Socket_Cliente;
+  socklen_t Longueur_Adresse;
+  #endif //WINDOWS
+
+  while(mfd) {
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(mfd, &set);
+    struct timeval tv;
+    tv.tv_sec = 0;
+    tv.tv_usec = 1000*100;
+
+    int result = select(mfd+1, &set, NULL, NULL, &tv);
+    if( result > 0 && FD_ISSET(mfd, &set) ) {
+
+      Longueur_Adresse = sizeof(Adresse_Socket_Cliente);
+      int val=accept(
+        mfd,
+        (struct sockaddr*)&Adresse_Socket_Cliente,
+        &Longueur_Adresse);
+      DebugTrace("connection on client port "<< ntohs(Adresse_Socket_Cliente.sin_port));
+
+      if(val >=0 ) {
+        state = CONNECTED;
+        return new JSocket(val);
+      } else {
+        return NULL;
+      }
+    }
+  }
+}
+
+int JSocket::Read(char* buff, int size)
+{
+  if(state == CONNECTED)
+  {
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(mfd, &set);
+    struct timeval tv;
+    tv.tv_sec = 0;
+    tv.tv_usec = 1000*100;
+
+    int result = select(mfd+1, &set, NULL, NULL, &tv);
+    if( result > 0 && FD_ISSET(mfd, &set) )
+    {
+  #ifdef WIN32
+      int readbytes = recv(mfd, buff, size,0);
+  #elif LINUX
+      int readbytes = read(mfd, buff, size);
+  #endif //WINDOWS
+      if(readbytes < 0)
+      {
+        DebugTrace("Error reading from socket\n");
+        return -1;
+      }
+      else
+        return readbytes;
+    }
+    else if( result < 0)
+    {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+int JSocket::Write(char* buff, int size)
+{
+  int size1 = size;
+  while (size > 0 && state == CONNECTED) {
+    fd_set set;
+    FD_ZERO(&set);
+    FD_SET(mfd, &set);
+    struct timeval tv;
+    tv.tv_sec = 0;
+    tv.tv_usec = 1000*100;
+
+    int result = select(mfd+1, NULL, &set, NULL, &tv);
+    if( result > 0  && FD_ISSET(mfd, &set))
+    {
+      int len = send(mfd, buff, size, 0);
+      if (len < 0) {
+        return -1;
+      }
+      size -= len;
+      buff += len;
+    } else if (result < 0) {
+      return -1;
+    }
+  }
+  return size1 - size;
+}
 
 

projects/mtg/include/AIMomirPlayer.h

@@ -6,7 +6,7 @@
 class AIMomirPlayer: public AIPlayerBaka
 {
 public:
-    AIMomirPlayer(MTGDeck * deck, string file, string fileSmall, string avatarFile);
+    AIMomirPlayer(string file, string fileSmall, string avatarFile, MTGDeck * deck = NULL);
     int getEfficiency(AIAction * action);
     int momir();
     int computeActions();

projects/mtg/include/AIPlayer.h

@@ -100,7 +100,7 @@ public:
     int receiveEvent(WEvent * event);
     void Render();
     ManaCost * getPotentialMana(MTGCardInstance * card = NULL);
-    AIPlayer(MTGDeck * deck, string deckFile, string deckFileSmall);
+    AIPlayer(string deckFile, string deckFileSmall, MTGDeck * deck = NULL);
     virtual ~AIPlayer();
     virtual MTGCardInstance * chooseCard(TargetChooser * tc, MTGCardInstance * source, int random = 0);
     virtual int chooseTarget(TargetChooser * tc = NULL, Player * forceTarget =NULL,MTGCardInstance * Choosencard = NULL);
@@ -123,7 +123,7 @@ class AIPlayerBaka: public AIPlayer{
   MTGCardInstance * FindCardToPlay(ManaCost * potentialMana, const char * type);
  public:
   int deckId;
-  AIPlayerBaka(MTGDeck * deck, string deckFile, string deckfileSmall, string avatarFile);
+  AIPlayerBaka(string deckFile, string deckfileSmall, string avatarFile, MTGDeck * deck = NULL);
   virtual int Act(float dt);
   void initTimer();
   virtual int computeActions();

projects/mtg/include/GameApp.h

@@ -22,12 +22,18 @@
 #include "MTGGameZones.h"
 
 #include "CardEffect.h"
+#ifdef NETWORK_SUPPORT
+#include "JNetwork.h"
+#endif //NETWORK_SUPPORT
 
 enum
 {
     PLAYER_TYPE_CPU = 0,
     PLAYER_TYPE_HUMAN=1,
-    PLAYER_TYPE_TESTSUITE=2
+    PLAYER_TYPE_TESTSUITE=2,
+#ifdef NETWORK_SUPPORT
+    PLAYER_TYPE_REMOTE=3
+#endif //NETWORK_SUPPORT
 };
 
 enum
@@ -37,7 +43,10 @@ enum
     GAME_TYPE_RANDOM1,
     GAME_TYPE_RANDOM2,
     GAME_TYPE_STORY,
-    GAME_TYPE_DEMO
+    GAME_TYPE_DEMO,
+#ifdef NETWORK_SUPPORT
+    GAME_TYPE_SLAVE,
+#endif //NETWORK_SUPPORT
 };
 
 class MTGAllCards;
@@ -61,6 +70,9 @@ public:
 
     int gameType;
     CardEffect *effect;
+#ifdef NETWORK_SUPPORT
+    JNetwork* mpNetwork;
+#endif //NETWORK_SUPPORT
 
     GameApp();
     virtual ~GameApp();

projects/mtg/include/GameStateDuel.h

@@ -15,6 +15,9 @@ class TestSuite;
 #endif
 class Credits;
 class Rules;
+#ifdef NETWORK_SUPPORT
+class JNetwork;
+#endif
 
 class GameStateDuel: public GameState, public JGuiListener
 {
@@ -22,6 +25,7 @@ private:
 #ifdef TESTSUITE
     TestSuite * testSuite;
 #endif
+
     Credits * credits;
     int mGamePhase;
     Player * mCurrentPlayer;
@@ -40,7 +44,7 @@ private:
     Rules * rules;
 
     bool MusicExist(string FileName);
-    void loadPlayer(int playerId, int decknb = 0, int isAI = 0);
+    void loadPlayer(int playerId, int decknb = 0, bool isAI = false, bool isNetwork = false);
     void ConstructOpponentMenu(); //loads the opponentMenu if it doesn't exist
     void initScroller();
 
@@ -66,6 +70,10 @@ public:
         MENUITEM_MAIN_MENU = -13,
         MENUITEM_EVIL_TWIN = -14,
         MENUITEM_MULLIGAN = -15,
+#ifdef NETWORK_SUPPORT
+        MENUITEM_REMOTE_CLIENT = -16,
+        MENUITEM_REMOTE_SERVER = -17,
+#endif
         MENUITEM_MORE_INFO = kInfoMenuID
     };
 

projects/mtg/include/NetworkPlayer.h

@@ -0,0 +1,33 @@
+#ifndef NETWORKPLAYER_H
+#define NETWORKPLAYER_H
+
+#include "PrecompiledHeader.h"
+#include "Player.h"
+#include "JNetwork.h"
+
+extern void RegisterNetworkPlayers();
+
+class ProxyPlayer
+{
+protected:
+    Player* mpPlayer;
+    JNetwork* mpNetwork;
+    static ProxyPlayer* mInstance;
+public:
+    ProxyPlayer(Player* pxPlayer, JNetwork* pxNetwork);
+    static void Serialize(istream& in, ostream& out);
+};
+
+
+class RemotePlayer : public Player
+{
+protected:
+    JNetwork* mpNetwork;
+    static RemotePlayer* mInstance;
+public:
+    RemotePlayer(JNetwork*);
+    static void Deserialize(istream& in, ostream& out);
+    bool isLoaded() {return game!=NULL;};
+};
+
+#endif // NETWORKPLAYER_H

projects/mtg/include/Player.h

@@ -35,7 +35,7 @@ public:
     string deckName;
     string phaseRing;
 
-    Player(MTGDeck * deck, string deckFile, string deckFileSmall);
+    Player(string deckFile, string deckFileSmall, MTGDeck * deck = NULL);
     virtual ~Player();
 
     virtual void End();
@@ -98,7 +98,7 @@ public:
 class HumanPlayer: public Player
 {
 public:
-    HumanPlayer(MTGDeck * deck, string deckFile, string deckFileSmall);
+    HumanPlayer(string deckFile, string deckFileSmall, MTGDeck * deck = NULL);
     HumanPlayer(string deckFile);
 
 };

projects/mtg/src/AIMomirPlayer.cpp

@@ -8,8 +8,8 @@
 
 MTGAbility * AIMomirPlayer::momirAbility = NULL;
 
-AIMomirPlayer::AIMomirPlayer(MTGDeck * deck, string file, string fileSmall, string avatarFile) :
+AIMomirPlayer::AIMomirPlayer(string file, string fileSmall, string avatarFile, MTGDeck * deck) :
-    AIPlayerBaka(deck, file, fileSmall, avatarFile)
+    AIPlayerBaka(file, fileSmall, avatarFile, deck)
 {
     momirAbility = NULL;
     agressivity = 100;

projects/mtg/src/AIPlayer.cpp

@@ -38,8 +38,8 @@ int AIAction::Act()
     return 0;
 }
 
-AIPlayer::AIPlayer(MTGDeck * deck, string file, string fileSmall) :
+AIPlayer::AIPlayer(string file, string fileSmall, MTGDeck * deck) :
-    Player(deck, file, fileSmall)
+    Player(file, fileSmall, deck)
 {
     nextCardToPlay = NULL;
     stats = NULL;
@@ -1189,10 +1189,8 @@ AIPlayer * AIPlayerFactory::createAIPlayer(MTGAllCards * collection, Player * op
         if ( meta->getVictoryPercentage() >= 65)
             deckSetting = HARD;
     }
-    MTGDeck * tempDeck = NEW MTGDeck(deckFile, collection,0, deckSetting);
+    AIPlayerBaka * baka = NEW AIPlayerBaka(deckFile, deckFileSmall, avatarFile);
-    AIPlayerBaka * baka = NEW AIPlayerBaka(tempDeck, deckFile, deckFileSmall, avatarFile);
     baka->deckId = deckid;
-    SAFE_DELETE(tempDeck);
     return baka;
 }
 
@@ -1272,8 +1270,8 @@ MTGCardInstance * AIPlayerBaka::FindCardToPlay(ManaCost * pMana, const char * ty
     return nextCardToPlay;
 }
 
-AIPlayerBaka::AIPlayerBaka(MTGDeck * deck, string file, string fileSmall, string avatarFile) :
+AIPlayerBaka::AIPlayerBaka(string file, string fileSmall, string avatarFile, MTGDeck * deck) :
-    AIPlayer(deck, file, fileSmall)
+    AIPlayer(file, fileSmall, deck)
 {
     mAvatarTex = WResourceManager::Instance()->RetrieveTexture(avatarFile, RETRIEVE_LOCK, TEXTURE_SUB_AVATAR);
 

projects/mtg/src/DuelLayers.cpp

@@ -81,7 +81,7 @@ void DuelLayers::CheckUserInput(int isAI)
                 break;
         }
     }
-    if (JGE::GetInstance()->GetLeftClickCoordinates(x, y))
+    if ((!isAI) && JGE::GetInstance()->GetLeftClickCoordinates(x, y))
     {
         if (avatars->CheckUserInput(x, y))
         {

projects/mtg/src/GameApp.cpp

@@ -44,6 +44,9 @@ GameState::GameState(GameApp* parent) :
 
 GameApp::GameApp() :
     JApp()
+#ifdef NETWORK_SUPPORT
+    ,mpNetwork(NULL)
+#endif //NETWORK_SUPPORT
 {
 #ifdef DEBUG
     nbUpdates = 0;

projects/mtg/src/GameStateDuel.cpp

@@ -20,6 +20,10 @@
 #include "TestSuiteAI.h"
 #endif
 
+#ifdef NETWORK_SUPPORT
+#include "NetworkPlayer.h"
+#endif
+
 #if defined (WIN32) || defined (LINUX)
 #include <time.h>
 #endif
@@ -41,6 +45,9 @@ enum ENUM_DUEL_STATE
     DUEL_STATE_PLAY,
     DUEL_STATE_BACK_TO_MAIN_MENU,
     DUEL_STATE_MENU,
+#ifdef NETWORK_SUPPORT
+    DUEL_STATE_OPPONENT_WAIT,
+#endif //NETWORK_SUPPORT
     DUEL_STATE_ERROR
 };
 
@@ -77,6 +84,10 @@ GameState(parent)
     credits = NULL;
     rules = NULL;
 
+#ifdef NETWORK_SUPPORT
+    RegisterNetworkPlayers();
+#endif //NETWORK_SUPPORT
+
 }
 
 GameStateDuel::~GameStateDuel()
@@ -156,22 +167,34 @@ void GameStateDuel::Start()
     }
 }
 
-void GameStateDuel::loadPlayer(int playerId, int decknb, int isAI)
+void GameStateDuel::loadPlayer(int playerId, int decknb, bool isAI, bool isNetwork)
 {
     if (decknb)
     {
         if (!isAI)
         { //Human Player
-            char deckFile[255];
+            if(playerId == 0)
-            if (premadeDeck)
+            {
-                sprintf(deckFile, JGE_GET_RES("player/premade/deck%i.txt").c_str(), decknb);
+                char deckFile[255];
+                if (premadeDeck)
+                    sprintf(deckFile, JGE_GET_RES("player/premade/deck%i.txt").c_str(), decknb);
+                else
+                    sprintf(deckFile, "%s/deck%i.txt", options.profileFile().c_str(), decknb);
+                char deckFileSmall[255];
+                sprintf(deckFileSmall, "player_deck%i", decknb);
+                mPlayers[playerId] = NEW HumanPlayer(deckFile, deckFileSmall);
+#ifdef NETWORK_SUPPORT
+                if(isNetwork)
+                {
+                    ProxyPlayer* mProxy;
+                    mProxy = NEW ProxyPlayer(mPlayers[playerId], mParent->mpNetwork);
+                }
+            }
             else
-                sprintf(deckFile, "%s/deck%i.txt", options.profileFile().c_str(), decknb);
+            {   //Remote player
-            char deckFileSmall[255];
+                mPlayers[playerId] = NEW RemotePlayer(mParent->mpNetwork);
-            sprintf(deckFileSmall, "player_deck%i", decknb);
+#endif //NETWORK_SUPPORT
-            MTGDeck * tempDeck = NEW MTGDeck(deckFile, MTGCollection());
+            }
-            mPlayers[playerId] = NEW HumanPlayer(tempDeck, deckFile, deckFileSmall);
-            SAFE_DELETE( tempDeck );
         }
         else
         { //AI Player, chooses deck
@@ -471,6 +494,29 @@ void GameStateDuel::Update(float dt)
             mGamePhase = DUEL_STATE_MENU;
         }
         break;
+#ifdef NETWORK_SUPPORT
+    case DUEL_STATE_OPPONENT_WAIT:
+      {
+        if(mPlayers[1] && mPlayers[1]->game)
+        { // Player loaded
+          menu->Close();
+          SAFE_DELETE(menu);
+          mGamePhase = DUEL_STATE_PLAY;
+        } else if(menu == NULL)
+        {
+          loadPlayer(1, 42/* 0 not good*/, false, true);
+          menu = NEW SimpleMenu(DUEL_STATE_OPPONENT_WAIT, this, Fonts::MENU_FONT, 150, 60);
+          if (menu)
+          {
+              menu->Add(MENUITEM_MAIN_MENU, "Back to main menu");
+          }
+        } else
+        {
+          menu->Update(dt);
+        }
+      }
+      break;
+#endif //NETWORK_SUPPORT
     case DUEL_STATE_MENU:
         menu->Update(dt);
         break;
@@ -565,7 +611,11 @@ void GameStateDuel::Render()
     case DUEL_STATE_CHOOSE_DECK2_TO_PLAY:
     case DUEL_STATE_DECK1_DETAILED_INFO:
     case DUEL_STATE_DECK2_DETAILED_INFO:
-        if (mParent->gameType != GAME_TYPE_CLASSIC)
+        if (mParent->gameType != GAME_TYPE_CLASSIC
+#ifdef NETWORK_SUPPORT
+                && mParent->gameType != GAME_TYPE_SLAVE
+#endif //NETWORK_SUPPORT
+                )
             mFont->DrawString(_("LOADING DECKS").c_str(), 0, SCREEN_HEIGHT / 2);
         else
         {
@@ -582,6 +632,11 @@ void GameStateDuel::Render()
         mFont->DrawString(_("NO DECK AVAILABLE,").c_str(), 0, SCREEN_HEIGHT / 2);
         mFont->DrawString(_("PRESS CIRCLE TO GO TO THE DECK EDITOR!").c_str(), 0, SCREEN_HEIGHT / 2 + 20);
         break;
+#ifdef NETWORK_SUPPORT
+    case DUEL_STATE_OPPONENT_WAIT:
+        if (menu) menu->Render();
+        break;
+#endif //NETWORK_SUPPORT
     case DUEL_STATE_MENU:
     case DUEL_STATE_CANCEL:
     case DUEL_STATE_BACK_TO_MAIN_MENU:
@@ -742,9 +797,22 @@ void GameStateDuel::ButtonPressed(int controllerId, int controlId)
             vector<DeckMetaData *> * playerDeck = deckManager->getPlayerDeckOrderList();
             if (!premadeDeck && controlId > 0) 
                 deckNumber = playerDeck->at(controlId - 1)->getDeckId();
-            loadPlayer(0, deckNumber);
+            loadPlayer(0, deckNumber, false
+#ifdef NETWORK_SUPPORT
+                       ,(mParent->players[1] == PLAYER_TYPE_REMOTE)
+#endif //NETWORK_SUPPORT
+                       );
             deckmenu->Close();
-            mGamePhase = DUEL_STATE_CHOOSE_DECK1_TO_2;
+#ifdef NETWORK_SUPPORT
+            if(mParent->players[1] == PLAYER_TYPE_REMOTE)
+            {   // no need to choose an opponent deck in network mode
+                mGamePhase = DUEL_STATE_OPPONENT_WAIT;
+            }
+            else
+#endif //NETWORK_SUPPORT
+            {
+                mGamePhase = DUEL_STATE_CHOOSE_DECK1_TO_2;
+            }
             playerDeck = NULL;
         }
         else

projects/mtg/src/GameStateMenu.cpp

@@ -39,7 +39,10 @@ enum ENUM_MENU_STATE_MAJOR
     MENU_STATE_MAJOR_FIRST_TIME = 0x05,
     MENU_STATE_MAJOR_DUEL = 0x06,
     MENU_STATE_MAJOR_LANG = 0x07,
-
+#ifdef NETWORK_SUPPORT
+    MENU_STATE_NETWORK_DEFINE = 0x08,
+    MENU_STATE_NETWORK_WAIT = 0x09,
+#endif //NETWORK_SUPPORT
     MENU_STATE_MAJOR = 0xFF
 };
 
@@ -61,8 +64,9 @@ enum
     MENUITEM_EXIT,
     SUBMENUITEM_1PLAYER,
 #ifdef NETWORK_SUPPORT
-    SUBMENUITEM_2PLAYER_SERVER,
+    SUBMENUITEM_2PLAYERS,
-    SUBMENUITEM_2PLAYER_CLIENT,
+    SUBMENUITEM_HOST_GAME,
+    SUBMENUITEM_JOIN_GAME,
 #endif //NETWORK_SUPPORT
     SUBMENUITEM_DEMO,
     SUBMENUITEM_TESTSUITE,
@@ -535,6 +539,44 @@ void GameStateMenu::Update(float dt)
         if (mEngine->GetButtonState(JGE_BTN_NEXT)) //Hook for GameStateAward state
             mParent->DoTransition(TRANSITION_FADE, GAME_STATE_AWARDS); //TODO: A slide transition would be nice.
         break;
+#ifdef NETWORK_SUPPORT
+    case MENU_STATE_NETWORK_DEFINE:
+        currentState = MENU_STATE_MAJOR_SUBMENU;
+        subMenuController = NEW SimpleMenu(MENU_FIRST_DUEL_SUBMENU, this, Fonts::MENU_FONT, 150, 60);
+        if (subMenuController)
+        {
+            subMenuController->Add(SUBMENUITEM_HOST_GAME, "Host a game");
+            subMenuController->Add(SUBMENUITEM_JOIN_GAME, "Join a game");
+            subMenuController->Add(SUBMENUITEM_CANCEL, "Cancel");
+        }
+    break;
+    case MENU_STATE_NETWORK_WAIT:
+        if(MENU_STATE_MINOR_NONE == (currentState & MENU_STATE_MINOR))
+        {
+            if(mParent->mpNetwork->isConnected())
+            {
+                if(subMenuController) subMenuController->Close();
+                currentState = MENU_STATE_MAJOR_DUEL | MENU_STATE_MINOR_SUBMENU_CLOSING;
+            }
+            else if(!subMenuController)
+            {
+//                currentState = MENU_STATE_MAJOR_SUBMENU;
+                subMenuController = NEW SimpleMenu(MENU_FIRST_DUEL_SUBMENU, this, Fonts::MENU_FONT, 150, 60);
+                if (subMenuController)
+                {
+                    subMenuController->Add(SUBMENUITEM_CANCEL, "Cancel connection");
+                }
+            }
+            else{
+                if (subMenuController)
+                    subMenuController->Update(dt);
+                ensureMGuiController();
+                mGuiController->Update(dt);
+                break;
+            }
+        }
+        break;
+#endif //NETWORK_SUPPORT
     case MENU_STATE_MAJOR_SUBMENU:
         if (subMenuController)
             subMenuController->Update(dt);
@@ -751,8 +793,7 @@ void GameStateMenu::ButtonPressed(int controllerId, int controlId)
                 // TODO Put 2 players mode back
                 // This requires to fix the hand (to accept 2 players) OR to implement network game
 #ifdef NETWORK_SUPPORT
-                subMenuController->Add(SUBMENUITEM_2PLAYER_SERVER, "2 Players - server");
+                subMenuController->Add(SUBMENUITEM_2PLAYERS, "2 Players");
-                subMenuController->Add(SUBMENUITEM_2PLAYER_CLIENT, "2 Players - client");
 #endif //NETWORK_SUPPORT
                 subMenuController->Add(SUBMENUITEM_DEMO, "Demo");
                 subMenuController->Add(SUBMENUITEM_CANCEL, "Cancel");
@@ -781,22 +822,39 @@ void GameStateMenu::ButtonPressed(int controllerId, int controlId)
             currentState = MENU_STATE_MAJOR_DUEL | MENU_STATE_MINOR_SUBMENU_CLOSING;
             break;
 #ifdef NETWORK_SUPPORT
-        case SUBMENUITEM_2PLAYER_SERVER:
+        case SUBMENUITEM_2PLAYERS:
             mParent->players[0] = PLAYER_TYPE_HUMAN;
-            mParent->players[1] = PLAYER_TYPE_HUMAN;
+            mParent->players[1] = PLAYER_TYPE_REMOTE;
-            this->hasChosenGameType = true;
-            mParent->gameType = GAME_TYPE_CLASSIC;
             subMenuController->Close();
-            currentState = MENU_STATE_MAJOR_DUEL | MENU_STATE_MINOR_SUBMENU_CLOSING;
+            currentState = MENU_STATE_NETWORK_DEFINE | MENU_STATE_MINOR_SUBMENU_CLOSING;
             break;
-        case SUBMENUITEM_2PLAYER_CLIENT:
+        case SUBMENUITEM_HOST_GAME:
-            mParent->players[0] = PLAYER_TYPE_HUMAN;
+        {
-            mParent->players[1] = PLAYER_TYPE_HUMAN;
+            if(!mParent->mpNetwork)
-            this->hasChosenGameType = true;
+            {
-            mParent->gameType = GAME_TYPE_CLASSIC;
+                mParent->mpNetwork = new JNetwork();
+            }
+            mParent->mpNetwork->connect();
             subMenuController->Close();
-            currentState = MENU_STATE_MAJOR_DUEL | MENU_STATE_MINOR_SUBMENU_CLOSING;
+            currentState = MENU_STATE_NETWORK_WAIT | MENU_STATE_MINOR_SUBMENU_CLOSING;
             break;
+        }
+        case SUBMENUITEM_JOIN_GAME:
+        {
+            if(!mParent->mpNetwork)
+            {
+                mParent->mpNetwork = new JNetwork();
+            }
+            // FIXME needs to be able to specify the server ip
+            mParent->mpNetwork->connect("127.0.0.1");
+            // we let the server choose the game mode
+            mParent->gameType = GAME_TYPE_SLAVE;
+            hasChosenGameType = true;
+            subMenuController->Close();
+//            currentState = MENU_STATE_MAJOR_DUEL | MENU_STATE_MINOR_SUBMENU_CLOSING;
+            currentState = MENU_STATE_NETWORK_WAIT;
+            break;
+        }
 #endif //NETWORK_SUPPORT
         case SUBMENUITEM_DEMO:
             mParent->players[0] = PLAYER_TYPE_CPU;
@@ -810,6 +868,12 @@ void GameStateMenu::ButtonPressed(int controllerId, int controlId)
             {
                 subMenuController->Close();
             }
+#ifdef NETWORK_SUPPORT
+            if(mParent->mpNetwork)
+            {
+              SAFE_DELETE(mParent->mpNetwork);
+            }
+#endif //NETWORK_SUPPORT
             currentState = MENU_STATE_MAJOR_MAINMENU | MENU_STATE_MINOR_SUBMENU_CLOSING;
             break;
 

projects/mtg/src/MTGGameZones.cpp

@@ -974,11 +974,10 @@ ostream& operator<<(ostream& out, const MTGGameZone& z)
 }
 ostream& operator<<(ostream& out, const MTGPlayerCards& z)
 {
-    out << z.library->nb_cards << endl;
+    out << z.library->nb_cards << " ";
     for (int i = 0; i < z.library->nb_cards; i++)
         out << z.library->cards[i]->getMTGId() << " ";
 
-    out << endl;
     return out;
 }
 

projects/mtg/src/NetworkPlayer.cpp

@@ -0,0 +1,41 @@
+#include "NetworkPlayer.h"
+#include <sstream>
+
+RemotePlayer* RemotePlayer::mInstance = NULL;
+ProxyPlayer* ProxyPlayer::mInstance = NULL;
+
+void RegisterNetworkPlayers()
+{
+//  JNetwork::registerCommand("GetPlayer", ProxyPlayer::Serialize, RemotePlayer::Deserialize);
+}
+
+
+RemotePlayer::RemotePlayer(JNetwork* pxNetwork)
+    :     Player("remote", "", NULL), mpNetwork(pxNetwork)
+{
+  mInstance = this;
+  mpNetwork->sendCommand("GetPlayer");
+}
+
+void RemotePlayer::Deserialize(istream& in, ostream& out)
+{
+//    istringstream ss(mInstance->mpNetwork->receiveString());
+    in >> *mInstance;
+}
+
+
+ProxyPlayer::ProxyPlayer(Player* pxPlayer, JNetwork* pxNetwork)
+    : mpPlayer(pxPlayer), mpNetwork(pxNetwork)
+{
+  mInstance = this;
+  JNetwork::registerCommand("GetPlayer", ProxyPlayer::Serialize, RemotePlayer::Deserialize);
+
+//  ostringstream ss;
+//  ss << "Player : " << *mpPlayer;
+//  mpNetwork->send(ss.str());
+}
+
+void ProxyPlayer::Serialize(istream& in, ostream& out)
+{
+    out << *(mInstance->mpPlayer);
+}

projects/mtg/src/Player.cpp

@@ -5,9 +5,16 @@
 #include "DeckStats.h"
 #include "ManaCost.h"
 
-Player::Player(MTGDeck * deck, string file, string fileSmall) :
+Player::Player(string file, string fileSmall, MTGDeck * deck) :
 Damageable(20)
 {
+    bool deleteDeckPlease = false;
+    if(deck == NULL && file != "testsuite" && file != "remote")
+    {
+        deck = NEW MTGDeck(file.c_str(), MTGCollection());
+        deleteDeckPlease = true;
+    }
+
     game = NULL;
     deckFile = file;
     deckFileSmall = fileSmall;
@@ -25,6 +32,10 @@ Damageable(20)
             game->setOwner(this);
             deckName = deck->meta_name;
     }
+    if(deleteDeckPlease)
+    {
+        SAFE_DELETE(deck);
+    }
 }
 
 /*Method to call at the end of a game, before all objects involved in the game are destroyed */
@@ -87,8 +98,8 @@ Player * Player::opponent()
     return this == game->players[0] ? game->players[1] : game->players[0];
 }
 
-HumanPlayer::HumanPlayer(MTGDeck * deck, string file, string fileSmall) :
+HumanPlayer::HumanPlayer(string file, string fileSmall, MTGDeck * deck) :
-    Player(deck, file, fileSmall)
+    Player(file, fileSmall, deck)
 {
     loadAvatar("avatar.jpg");
     playMode = MODE_HUMAN;
@@ -203,6 +214,7 @@ istream& operator>>(istream& in, Player& p)
     }
 
     in >> *(p.game);
+    p.game->setOwner(&p);
 
     return in;
 }

projects/mtg/src/Rules.cpp

@@ -191,7 +191,11 @@ void Rules::addExtraRules()
             if (p->playMode != Player::MODE_TEST_SUITE && g->mRules->gamemode != GAME_TYPE_MOMIR && g->mRules->gamemode
                 != GAME_TYPE_RANDOM1 && g->mRules->gamemode != GAME_TYPE_RANDOM2 && g->mRules->gamemode
                 != GAME_TYPE_STORY && 
-                g->mRules->gamemode != GAME_TYPE_DEMO && (!g->players[0] == PLAYER_TYPE_CPU && !g->players[1] == PLAYER_TYPE_CPU))//keep this out of mimor and other game modes.
+                g->mRules->gamemode != GAME_TYPE_DEMO && (!g->players[0] == PLAYER_TYPE_CPU && !g->players[1] == PLAYER_TYPE_CPU)
+#ifdef NETWORK_SUPPORT
+                && !g->players[1] == PLAYER_TYPE_REMOTE
+#endif //NETWORK_SUPPORT
+                    )//keep this out of mimor and other game modes.
             {
                 difficultyRating = DeckManager::getDifficultyRating(g->players[0], g->players[1]);
             }
@@ -273,9 +277,9 @@ Player * Rules::loadPlayerMomir(int isAI)
 
     Player *player = NULL;
     if (!isAI) // Human Player
-        player = NEW HumanPlayer(tempDeck, options.profileFile("momir.txt", "", true).c_str(), deckFileSmall);
+        player = NEW HumanPlayer(options.profileFile("momir.txt", "", true).c_str(), deckFileSmall, tempDeck);
     else
-        player = NEW AIMomirPlayer(tempDeck, options.profileFile("momir.txt", "", true).c_str(), deckFileSmall, empty);
+        player = NEW AIMomirPlayer(options.profileFile("momir.txt", "", true).c_str(), deckFileSmall, empty, tempDeck);
 
     delete tempDeck;
     return player;
@@ -308,9 +312,9 @@ Player * Rules::loadPlayerRandom(int isAI, int mode)
 
     Player *player = NULL;
     if (!isAI) // Human Player
-        player = NEW HumanPlayer(tempDeck, deckFile, deckFileSmall);
+        player = NEW HumanPlayer(deckFile, deckFileSmall, tempDeck);
     else
-        player = NEW AIPlayerBaka(tempDeck, deckFile, deckFileSmall, "");
+        player = NEW AIPlayerBaka(deckFile, deckFileSmall, "", tempDeck);
 
     delete tempDeck;
     return player;

projects/mtg/src/StoryFlow.cpp

@@ -305,16 +305,12 @@ void StoryDuel::init()
     sprintf(folder, JGE_GET_RES(CAMPAIGNS_FOLDER"%s/%s").c_str(), mParent->folder.c_str(), pageId.c_str());
 
     sprintf(deckFile, "%s/deck.txt", folder);
-    MTGDeck * tempDeck = NEW MTGDeck(deckFile, MTGCollection());
     sprintf(deckFileSmall, "campaign_%s", mParent->folder.c_str());
-    players[0] = NEW HumanPlayer(tempDeck, deckFile, deckFileSmall);
+    players[0] = NEW HumanPlayer(deckFile, deckFileSmall);
-    SAFE_DELETE(tempDeck);
 
     sprintf(deckFile, "%s/opponent_deck.txt", folder);
-    tempDeck = NEW MTGDeck(deckFile, MTGCollection());
     sprintf(deckFileSmall, "campaign_ennemy_%s_%s", mParent->folder.c_str(), pageId.c_str());
-    players[1] = NEW AIPlayerBaka(tempDeck, deckFile, deckFileSmall, "baka.jpg");
+    players[1] = NEW AIPlayerBaka(deckFile, deckFileSmall, "baka.jpg");
-    SAFE_DELETE(tempDeck);
 
     string rulesFile = folder;
     rulesFile.append("/rules.txt");

projects/mtg/src/TestSuiteAI.cpp

@@ -16,7 +16,7 @@ using std::string;
 // NULL is sent in place of a MTGDeck since there is no way to create a MTGDeck without a proper deck file.
 // TestSuiteAI will be responsible for managing its own deck state.
 TestSuiteAI::TestSuiteAI(TestSuite * _suite, int playerId) :
-    AIPlayerBaka(NULL, "testsuite", "testsuite", "baka.jpg")
+    AIPlayerBaka("testsuite", "testsuite", "baka.jpg", NULL)
 {
     this->game = _suite->buildDeck(playerId);
     game->setOwner(this);