game.h

//---------------------------------------------------------------------------
// game
//---------------------------------------------------------------------------
#ifndef __GAME_H
#define __GAME_H

#include "system.h"
#include "board.h"
#include "thread.h"
#include "net_socket.h"
#include "net_host.h"
#include <string>
#include <iostream>
using namespace std;

/*namespace Net{

    class HelloMessage;
    class MoveMessage;
    class ByeMessage;

    class Message{
        protected:
            unsigned char  type;
            unsigned int   size; // htonl (out) ntohl (in)
            unsigned char *data;
        public:
            Message(unsigned char type, unsigned int size, unsigned char *data);
            static Message* translate(Socket &s);
            virtual void send()=0;
            unsigned char* getData(){ return data; };
            virtual void setData(unsigned char* data)=0;
    };

    class HelloMessage: public Message{
        public:
            HelloMessage(){ type = 0; };
            HelloMessage(unsigned char type, unsigned int size, unsigned char *data): Message(type, size, data){};
            virtual void send();
            virtual void setData(unsigned char* data){};
    };

    class MoveMessage: public Message{
        public:
            MoveMessage(){ type = 1; };
            MoveMessage(unsigned char type, unsigned int size, unsigned char *data): Message(type, size, data){};
            virtual void send();
            virtual void setData(unsigned char* data);
    };

    class ByeMessage: public Message{
        public:
            ByeMessage(){ type = 2; };
            ByeMessage(unsigned char type, unsigned int size, unsigned char *data): Message(type, size, data){};
            virtual void send();
            virtual void setData(unsigned char* data){};
    };


}   // end of namespace Net
*/

namespace Games {

    class GameState{
    private:
        int dataSize;
    public:
        System::Mutexed<unsigned char*> data;
        System::Mutexed<bool> localInterrupt;
        System::Mutexed<bool> remoteInterrupt;
        System::Mutexed<string> localNick;
        System::Mutexed<string> remoteNick;
        System::Mutexed<bool> newData;
        System::Mutexed<bool> ready;

                GameState(int size);
                GameState(){ data = NULL; };
                void getData(unsigned char* ptr);
                void setData(unsigned char* ptr);
                void print();
                void sendMessage(Net::Socket socket, unsigned char type);
        };


} // end of namespace Game


namespace System{

    class Listener: public Thread{
        private:
            Net::AcceptedSocket socket;
                unsigned int port;
                int size;
        protected:
                void dispatchMessage();
                    virtual void* tmain(void *args);
        public:
            Games::GameState state;

            Listener(unsigned int port, int size){ this->port = port; this->size = size; state = Games::GameState(size); };
            Listener(){};
            string peerName(){ return socket.peerName(); };


    };



/*    class ListenThread: public Thread{
        private:
            Net::ServerSocket   server;
            Net::AcceptedSocket listen;
            unsigned int port;
            unsigned int size;
        protected:
            virtual void* tmain(void* args);

        public:
            ListenThread(unsigned int port, unsigned int size);
            Mutexed<bool> ready;
            Mutexed<bool> interrupt;
            Mutexed<int> move;
            Mutexed<unsigned char*> data;
            Mutexed<string> nick;
            Net::Host clientHost;
            string toString(){ return listen.peerName(); };
    };*/

    /*class PostThread: public Thread{
        private:
            Net::ClientSocket   *socket;
        protected:
            virtual void* main(void* args);
        public:
            void sendHello(const char* nick);
            void sendMove(unsigned int size, unsigned char *ptr);
            void sendQuit();
    };*/
}

namespace Games{


    class Game{
        protected:
                bool running;
            Board* board;

            virtual bool playerOne()=0;

            virtual bool playerTwo()=0;
                virtual void interrupt(){};
            virtual bool isInterrupted()=0;
        public:
            //bool isEnd();
            Game(){ board = new Board(16,16,50,50,16); running = false; };
            virtual int run();

    };

    class LocalGame: public Game{
        protected:
            bool playerMove(unsigned char pl);

            virtual bool playerOne(){ return playerMove(1); };

            virtual bool playerTwo(){ return playerMove(2); };

                        virtual bool isInterrupted(){ return false; };
        public:
                LocalGame(): Game() { running = true; };
            //virtual int run();
    };


        class NetworkGame: public Game{
        protected:
                System::Listener listener;
                Net::ClientSocket socket;

                bool localPlayer(unsigned char pl);

                        bool remotePlayer(unsigned char pl);

                virtual bool isInterrupted(){ return *listener.state.localInterrupt || *listener.state.remoteInterrupt; };
                        virtual void interrupt(){ listener.state.localInterrupt = true; };
                public:
            NetworkGame(){};
            virtual ~NetworkGame(){ socket.destroy(); };
        };

    class MasterGame: public NetworkGame{
        protected:

                virtual bool playerOne(){ return localPlayer(1); };

                virtual bool playerTwo(){ return remotePlayer(2); };
        public:
                MasterGame(string nick, unsigned int size);
        };

    class SlaveGame: public NetworkGame{
                protected:

            virtual bool playerOne(){ return remotePlayer(1); };

            virtual bool playerTwo(){ return localPlayer(2); };
        public:
            SlaveGame(string nick, string host, unsigned int size);
            };
/*    class NetworkGame: public Game{
        protected:
            System::ListenThread *listener;
            Net::ClientSocket socket;
            string myNick, otherNick;
            void sendMessage(unsigned char type);
            int currentMove;
            bool isNewMove(){ return currentMove < *(listener->move); };
            bool localPlayerMove(int pl);
            bool networkPlayerMove();
        public:
            NetworkGame(): currentMove(0){};
            virtual ~NetworkGame(){ listener->interrupt = true; };
    };

    class MasterGame: public NetworkGame{
        protected:
            virtual bool playerOne(){ return localPlayerMove(1); };
            virtual bool playerTwo(){ return networkPlayerMove(); };
            virtual void interrupt(){ if (running){ sendMessage(2); listener->interrupt = true; } };
        public:
            MasterGame();
    };

    class SlaveGame: public NetworkGame{
        protected:
            virtual bool playerOne(){ return networkPlayerMove(); };
            virtual bool playerTwo(){ return localPlayerMove(2); };
            virtual void interrupt(){ if (running){ sendMessage(2); listener->interrupt = true; } };
        public:
            SlaveGame();
    };
*/
}   // end of namespace Games

#endif // __GAME_H

---