include/Client.h

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <sstream>
#include <zoidcom.h>
#include <limits.h>
#include <Game.h>

#define PORT 1337
#define IP "141.82.59.28"
//SERVER AUF DER PRÄSE!
//#define IP "141.82.59.30"

//char IP[ 16 ];
//char PORT[ 6 ];

class Client : public ZCom_Control 
{

public:
        ZoidCom* zcom;
        ZCom_BitStream* groupTypeMsg;
        bool exit_now;
        ZCom_Address server_addr;
        ZCom_ConnID server_id;
        ZCom_ConnID client_id;
        //char clientType[ 100 ];
        char* clientType;
        Game* game;

        Client()
        {
                ;
        }

        Client( char* clientType, Game* game )
        {

                this->game = game;
                this->exit_now = false;
                this->server_id = 0;
                this->client_id = 0;
                this->clientType = clientType;

                // initialize Zoidcom
                zcom = new ZoidCom("sonus_network_controller.log");     
                if ( !zcom || !zcom->Init() )
                        exit(255);

                // make instance of our Client class
                /*Client *client = new Client();*/
                this->ZCom_setDebugName( "Client" );

                zcom->setConnectionTimeout( UINT_MAX );
                //printf( "Timeout set to %u seconds\n", UINT_MAX / 1000 );

                // this creates and initializes the network sockets
                // true = use UDP socket, 0 = let OS choose UDP port, 0 = no internal socket
                bool result = this->ZCom_initSockets( true, 0, 0 );

                /*printf( "Select client type: (GAME or TUTORIAL): " );
                fgets( clientType, 10, stdin );
                printf( "Selected client type: %s\n", clientType );*/

                /*printf("Connecting...\n");*/
                // prepare bitstream
                groupTypeMsg = new ZCom_BitStream();
                groupTypeMsg->addString( clientType );

                // prepare address
                std::stringstream sstr;
                sstr << IP << ":" << PORT;
                server_addr.setAddress( eZCom_AddressUDP, 0, sstr.str().c_str() );

                // connect
                server_id = this->ZCom_Connect( server_addr, groupTypeMsg );
                //printf( "SERVER ID: %d ADDRESS: %u\n", server_id, server_addr.getIP() );
                this->ZCom_processInput();
                this->ZCom_processOutput();
                this->ZCom_processInput();
        }

        ~Client()
        {
                delete zcom;
        }

        void update()
        {
                // put this into a codeblock so that server_addr gets out of scope before 
                // 'delete zcom;' get called (everything needs to be gone before the 
                // ZoidCom object gets deleted)
                {

                                // make sure every input process is processed!
                                for( int i = 0; i < 3; i++ )
                                {
                                        this->ZCom_processInput();
                                }

                                ZCom_BitStream* message = new ZCom_BitStream();
                                //code Nr 6 for 'update'
                                message->addInt( 6, 8 );

                                //player position
                                message->addFloat( 132.465, 23 );
                                message->addFloat( -100.69, 23 );

                                //player orientation
                                message->addFloat( -1.46682, 23 );

                                //playerReachedPortal
                                message->addBool( false );

                                //playerObstaclesBeforePortal
                                message->addBool( true );

                                //end game
                                message->addBool( false );

                                //level name
                                message->addString( "01tut" );

                                // send the data to the server
                                //ZCom_sendData( _id, message );


                                for( int i = 0; i < 3; i++ )
                                {
                                        this->ZCom_processOutput();
                                }

                                zcom->Sleep( 100 );
                }

                this->ZCom_processOutput();

                // give up remaining cpu time
                //zcom->Sleep(20);
        }

        protected:

        virtual void ZCom_cbConnectResult( ZCom_ConnID _id, eZCom_ConnectResult _result, ZCom_BitStream &_reply )
        {
                if ( _result == eZCom_ConnAccepted )
                {
                        //printf("Connection established. The reply was: %s\n", _reply.getStringStatic());
                        client_id = _reply.getInt( 8 );
                        //printf("This clients ID is: %d\n", client_id );

                } else {
                        //printf("Connection failed. The reply was: %s\n", _reply.getStringStatic());
                        return;
                }

                // if we get here, the connection was accepted

                server_id = _id;
                //printf( "server_id has been set to: %i\n", server_id );
        }

        void ZCom_cbConnectionClosed( ZCom_ConnID _id, eZCom_CloseReason _reason, ZCom_BitStream &_reasondata )  
        {
                //printf("Connection to server closed. Exiting...\n");
                exit_now = true;
        }

        // data was received
        void ZCom_cbDataReceived( ZCom_ConnID  _id, ZCom_BitStream &_data ) 
        {
                ZCom_BitStream* message = new ZCom_BitStream();

                switch( _data.getInt( 8 ) )
                {
                case 1:
                        //printf( "starting game\n" );
                        //call game->begingame
                        game->beginGame();
                        OutputDebugStr( "CLIENT: starting game\n" );
                        break;
                case 2:
                        //printf( "stopping game\n" );
                        //call game->endgame
                        game->endGame();
                        OutputDebugStr( "CLIENT: stopping game\n" );
                        break;
                case 3:
                        //printf( "restarting game\n" );
                        game->endGame();
                        game->beginGame();
                        break;
                case 4:
                        //printf( "winning game\n" );
                        //end game for other player
                        break;
                case 5:
                        {
                                //Send dummy Data, should be actual data from the Game

                                //printf( "Sending update to server...\n" );
                                //ZCom_BitStream* message = new ZCom_BitStream();

                                //code Nr 6 for 'update'
                                message->addInt( 6, 8 );

                                //player position
                                message->addFloat( 132.465, 23);
                                message->addFloat( -100.69, 23);
                                //player orientation
                                message->addFloat( -1.46682, 23);
                                //playerReachedPortal
                                message->addBool( false );
                                //playerObstaclesBeforePortal
                                message->addBool( true );
                                //end game
                                message->addBool( false );
                                //level name
                                message->addString( "01tut" );

                                // send the data to the server
                                //ZCom_sendData( _id, message );
                                // message has been given to Zoidcom and may not be deleted
                                //message = NULL;
                                break;
                        }
                default:
                        break;
                }


                // send the data to the server
                ZCom_sendData( _id, message );
                // message has been given to Zoidcom and may not be deleted
                message = NULL;                 
        }

        //these functions can be ignored for a start; not (yet) necessary for basic networking control for sonus
        bool ZCom_cbConnectionRequest( ZCom_ConnID  _id, ZCom_BitStream &_request, ZCom_BitStream &_reply ){return false;}
        void ZCom_cbConnectionSpawned( ZCom_ConnID _id ) {}
        bool ZCom_cbZoidRequest( ZCom_ConnID _id, zU8 _requested_level, ZCom_BitStream &_reason ) {return false;}
        void ZCom_cbZoidResult( ZCom_ConnID _id, eZCom_ZoidResult _result, zU8 _new_level, ZCom_BitStream &_reason ) {}
        void ZCom_cbNodeRequest_Dynamic( ZCom_ConnID _id, ZCom_ClassID _requested_class, ZCom_BitStream *_announcedata,
                eZCom_NodeRole _role, ZCom_NodeID _net_id ) {}
        void ZCom_cbNodeRequest_Tag( ZCom_ConnID _id, ZCom_ClassID _requested_class, ZCom_BitStream *_announcedata,
                eZCom_NodeRole _role, zU32 _tag ) {}
        bool ZCom_cbDiscoverRequest( const ZCom_Address &_addr, 
                ZCom_BitStream &_request, ZCom_BitStream &_reply ) {return false;}
        void ZCom_cbDiscovered( const ZCom_Address & _addr, ZCom_BitStream &_reply )  {}
};

---