gne.cpp

Go to the documentation of this file.

//Mutexar någonstans??

//Lägg in så att updatePlayersFromServer görs automatiskt

//sätta dit eller ta bort LOG_ERRORS??

//använd timestamplarna till nått kanske? eller ta bort dom..

//Om man dissar med en klient så borde man kunna ansluta igen med samma..

//lägg in lite if isrunning för å se så att servern är igång..

//Stäng inte ned listen tråden.. låt den vara uppe och svara nej på nya anslutningar istället?

//Fixa stopserver och disconnect så dom funkar bra.. kolla även i disconnect i Connection.

// kolla 333:55  bör ej vara exit(-1)


// kolla bara så jag inte har lyckats göra så att idlist[i] = i.. effektivisera isf..

#include "gne.h"

#define TIMEOUT_TS 10000

Gne::Gne(){
        msgQueue = NULL;
        self = NULL;
        freeSlotsThreads = NULL;
        playerIdSlots = NULL;
        connection = NULL;
        clients = NULL;

        this->isrunning = false;
        this->playerlist = new PlayerList();
        this->self = new Player();
        if(isserver)
                this->self->setID(0);
        this->msgQueue = new MessageQueue(MAX_MSG);
        this->eventQueue = new EventQueue();
        this->playerInfoSelfIsSet = false;
}


Gne::~Gne(){
        //connection->disconnect();

        TerminateThread(hThreadListen, 0);
        TerminateThread(hThreadClient, 0);
        if(isserver){
                for(int i = 0; i<this->getMaxPlayers(); i++)
                        if(!freeSlotsThreads[i])
                                TerminateThread(hThreadTCP[i], 0);
        }
        /*
        if(msgQueue){
                //memset(msgQueue, '\0', sizeof(msgQueue));     
                delete(msgQueue);
        }
        if(eventQueue){
                //memset(eventQueue, '\0', sizeof(eventQueue)); 
                delete(eventQueue);
        }
        if(playerlist){
                //memset(playerlist, '\0', sizeof(playerlist)); 
                delete(playerlist);
        }
        if(self){
                //memset(self, '\0', sizeof(self));     
                delete(self);
        }
        if(freeSlotsThreads){
                memset(freeSlotsThreads, '\0', sizeof(freeSlotsThreads));
                free(freeSlotsThreads);
        }
        if(playerIdSlots){
                memset(playerIdSlots, '\0', sizeof(playerIdSlots));
                free(playerIdSlots);
        }
        if(clients){    
                memset(clients, '\0', sizeof(clients));
                free(clients);
        }
        if(idlist){
                memset(idlist, '\0', sizeof(idlist));
                free(idlist);
        }*/
}


int Gne::init(bool isserver){
        if(isrunning)
                return(-1);
        this->isserver = isserver;
        this->port = STD_PORT;

        //LOG_FILE("Network.txt");
        LOG_SUCCESS(("Gne initiated."));
        LOG_SUCCESS(("Port set to %d.", port));

        return(0);
}


bool Gne::isServer(){
        return(this->isserver);
}


bool Gne::isRunning(){
        return(this->isrunning);
}

int Gne::setMaxPlayers(int n){
        if(isrunning)
                return(-1);
        playerlist->setMaxPlayers(n);
        hThreadTCP = (HANDLE *)malloc(n*sizeof(HANDLE));
        freeSlotsThreads = (bool *)malloc(n*sizeof(bool));
        clients = (Connection **)malloc(n*sizeof(Connection));
        idlist = (int *)malloc(n*sizeof(int));
        for(int i = 0; i < n; i++){
                freeSlotsThreads[i] = true;
                hThreadTCP[i] = NULL;
        }
        
        LOG_SUCCESS(("Max players set to %d.", n));
        return(n);
}


int Gne::getMaxPlayers(){
        return(playerlist->getMaxPlayers());
}


int Gne::getNumPlayers(){
        return(playerlist->getNumPlayers()+1);
}


int Gne::addPlayer(Player *p){
        int ret = playerlist->addPlayer(p);
        this->eventQueue->addLast(new GE_PlayerJoined(p->getID()));
        return(ret);    
}


int Gne::removePlayerById(int playerid)
{
        if(!isrunning)
                return(-1);
        return(playerlist->removePlayerById(playerid)); 
}


Player* Gne::getPlayerById(int playerid){
        if(this->self->getID() == playerid)
                return(self);
        return(playerlist->getPlayerById(playerid));
}



int Gne::setPlayerInfoSelf(char *name){
        if(strlen(name) > 25){
                LOG_ERROR(("Name have to be shorter then 26 characters."));
                return(-1);
        }
        playerInfoSelfIsSet = true;
        if(isserver){
                this->self->setID(0);
                this->self->setName(name);
                return(0);
        }
        this->self->setName(name);
        return(0);
}


void Gne::setPlayerIdSelf(int id){
        this->self->setID(id);
}


char *Gne::getPlayerNameSelf(){
        if(!playerInfoSelfIsSet)
                return(NULL);
        return(this->self->getName());
}


int Gne::getPlayerIdSelf(){
        if(!playerInfoSelfIsSet)
                return(-1);
        return(this->self->getID());
}



int Gne::getNextPlayerID(){
        return(this->playerlist->getFreeId());
}



bool Gne::isMessagePending(){
        return(!this->msgQueue->isEmpty());
}


msgstruct Gne::getNextMessage(){
        return(msgQueue->getNextMessage());
        
}



int Gne::setPort(int port){
        if(port<1024){
                LOG_ERROR(("Port %d is invalid, choose a port > 1024.", port));
                return(-1);
        }
        LOG_SUCCESS(("Port changed to %d.", port));
        return(this->port = port);
}


int Gne::getPort(){
        return(this->port);
}


int Gne::getFreeThread(){
        int n = this->getMaxPlayers();
        for(int i=0; i<n; i++)
                if(freeSlotsThreads[i]){
                        freeSlotsThreads[i] = false;
                        return(i);
                }
        return(-1);
}



void Gne::setFreeThread(int nr){
        freeSlotsThreads[nr] = true;
}


int Gne::startServer(){
        if(!isserver)
                return(-1);

        hThreadListen = CreateThread(
                NULL, 
                0,
                listen,
                (void *)this,
                0,
                &hThreadListenID);
        if(hThreadListen == NULL){
                LOG_ERROR(("Could not create the server thread."));
                return(-1);
        }
        isrunning = true;       
        return(0);
}


int Gne::stopServer(){
        if(!isServer()&&!isRunning())
                return(-1);
        
        /*
        this->disconnect();
        TerminateThread(hThreadListen, 0);
        TerminateThread(hThreadClient, 0);
        for(int i = 0; i<this->getMaxPlayers(); i++)
                if(!freeSlotsThreads[i])
                        TerminateThread(hThreadTCP[i], 0);

  */
        this->connection->disconnect();
        TerminateThread(hThreadListen, 0);
        TerminateThread(hThreadClient, 0);
        for(int i = 0; i<this->getMaxPlayers(); i++)
                if(!freeSlotsThreads[i])
                        TerminateThread(hThreadTCP[i], 0);
        isrunning = false;
        return(0);
}



int Gne::joinServer(char *address){
        if(isserver)
                return(-1);
        connection = new Connection(this->getPort());
        int b = connection->connectByIp(address);
        if(b == -1){
                LOG_ERROR(("Could not connect to %s.", address));
                return(-1);
        }
        LOG_SUCCESS(("Connection to %s succeded.", address));
        packetConnect pc = createPacketConnect(VERSION_ID);
        setTimeStamp(&pc.header);
        setPacketFrom(&pc.header, self->getID());
        //Request to join game
        b = connection->sendData((char *)&pc, sizeof(packetConnect));
        if(b == -1){
                connection->disconnect();
                LOG_ERROR(("Could not send data to server."));
                return(-1);
        }
        //look at the response
        packetConnectionResponse pktRes;
        b = connection->recieveData((char *)&pktRes, sizeof(pktRes), 0);
        if(b == -1||pktRes.header.pktType!=PKT_CONNECTION_RESPONSE){
                connection->disconnect();
                LOG_ERROR(("error when recieving data."));
                return(-1);
        }
        if(pktRes.acceptionFlag == 0)
        {
                connection->disconnect();
                LOG_ERROR(("Your client was not accepted."));
                return(-1);
        }
        else{
                packetPlayerInfo ppi;
                ppi = createPacketPlayerInfo(this->getPlayerNameSelf(), 0);
                setTimeStamp(&ppi.header);
                setPacketFrom(&ppi.header, self->getID());
                b = connection->sendData((char *)&ppi, sizeof(ppi));
                if(b == -1){
                                LOG_ERROR(("Could not send data to server."));
                                connection->disconnect();
                                return(-1);
                }
                b = connection->recieveData((char *)&ppi, sizeof(ppi), 0);
                if(b == -1||ppi.header.pktType!=PKT_PLAYER_INFO){
                        LOG_ERROR(("Did not playerinfo from the server."));
                        connection->disconnect();
                        return(-1);
                }
                this->setPlayerIdSelf(ppi.id);
                Player *serv = new Player();
                serv->setID(0);
                serv->setName(ppi.name);
                playerlist->addPlayer(serv);
                this->eventQueue->addLast(new GE_PlayerJoined(0));
                isrunning = true;
                
                //tråd som lyssnar på meddelanden från servern.
                this->hThreadClient = CreateThread(
                        NULL, 
                        0,
                        clientThread,
                        (void *)this,
                        0,
                        &hThreadClientID);
                if(this->hThreadClient = NULL){
                        LOG_ERROR(("Could not spawn a new thread with the server connection."));
                        return(-1);
                }

        }
        return(0);
}


DWORD WINAPI Gne::listen(LPVOID arg){
        Gne *gne = (Gne *)arg;
        Connection *conn = gne->connection;
        Connection *newConn;
        int b;
        bool first = true;
        packetConnectionResponse pktRes;
        packetConnect pkt;
        packetConnectionResponse pktOk;
        packetPlayerInfo ppi;

        while(gne->playerlist->isNotFull()){
                try{
                        if(first){
                                conn = new Connection(gne->getPort());
                                first = false;
                        }
                        else
                                conn = newConn;
                }
                catch(char *err){
                        LOG_ERROR(("%s", err));
                        exit(-1); //eller kasta vidare exception så man kan gå ner i menyn lr nått...
                }
                
                newConn = conn->waitForConnection();
                if(newConn == NULL)
                {       
                        LOG_ERROR(("Could not wait for connection."));
                        exit(-1); //eller kasta vidare exception så man kan gå ner i menyn lr nått...

                }
                b = conn->recieveData((char *)&pkt, sizeof(packetConnect), 0);
                if(b == -1){
                        LOG_ERROR(("Could not recieve data."));
                }
                if(pkt.header.pktType!=PKT_CONNECTION_REQUEST){
                        LOG_ERROR(("Non connectionpacket - connection refused."));
                        conn->disconnect();             
                }
                else if(pkt.vid!=VERSION_ID){
                        LOG_ERROR(("Version missmatch - connection refused."));
                        pktRes = createPacketConnectionResponse(0);
                        setTimeStamp(&pktOk.header);
                        setPacketFrom(&pktOk.header, gne->self->getID());
                        b = conn->sendData((char *)&pktRes, sizeof(pktRes));
                        if(b == -1){
                                LOG_ERROR(("Could not send response to the refused client."));
                        }
                        LOG_ERROR(("A connecting client had wrong version of the network protocol."));
                        conn->disconnect();
                }
                else{
                        pktRes = createPacketConnectionResponse(1);
                        setTimeStamp(&pktRes.header);
                        setPacketFrom(&pktRes.header, gne->self->getID());
                        b = conn->sendData((char *)&pktRes, sizeof(pktRes));
                        if(b == -1){
                                LOG_ERROR(("Could not send data to client."));
                                conn->disconnect();
                        }
                        else{                           
                                conn->recieveData((char *)&ppi, sizeof(ppi), 0);
                                if(b == -1||ppi.header.pktType!=PKT_PLAYER_INFO){
                                        LOG_ERROR(("Could not get playerinfo."));
                                        conn->disconnect();
                                }
                                else{                                   
                                        Player *p = new Player();
                                        p->setName(ppi.name);
                                        int id = gne->getNextPlayerID();
                                        p->setID(id);
                                        gne->addPlayer(p);
                                        ppi.id = id;
                                        //skickar egen info samt klientens playerid
                                        strcpy(ppi.name, gne->self->getName());

                                        setTimeStamp(&ppi.header);
                                        setPacketFrom(&ppi.header, gne->self->getID());
                                        b = conn->sendData((char *)&ppi, sizeof(ppi));
                                        if(b == -1){
                                                LOG_ERROR(("Could not send data to client."));
                                                //skicka nått event?
                                                gne->removePlayerById(id);
                                                conn->disconnect();
                                        }
                                        else{
                                                //Använd samma för att skapa en udp-tråd.
                                                int freeHandler = gne->getFreeThread();
                                                gne->latestThread = freeHandler;
                                                gne->latestPlayerID = id;
                                                gne->clients[freeHandler] = conn;
                                                gne->idlist[freeHandler] = id;

                                                gne->hThreadTCP[freeHandler] = CreateThread(
                                                        NULL, 
                                                        0,
                                                        aPlayer,
                                                        (void *)arg,
                                                        0,
                                                        NULL);
                                                if(gne->hThreadTCP[freeHandler] = NULL){
                                                        LOG_ERROR(("Could not spawn thread for the new client."));
                                                        return(-1);
                                                }
                                                //Finns det något sätt att vänta på tråden?
                                                if(gne->sendPlayerToAll(p, freeHandler) == -1){
                                                        LOG_ERROR(("Could not send out a clients info."));
                                                        //släng ut spelaren??
                                                }
                                        }
                                }       
                        }
                }
        }
        return(0);
}



DWORD WINAPI Gne::aPlayer(LPVOID arg){
        Gne *gne = (Gne *)arg;
        int mySock = gne->latestThread;
        int myPlayerID = gne->latestPlayerID;
        Connection *conn = gne->clients[mySock];
        Player *p;
        int size;
        int i;
        packetHeader chk;
        packetChatMsg pcm;
        packetRequestAllPlayersInfo prapi;
        packetDisconnect pd;
        packetPlayerPosition ppp;
        packetAttack pa;
        packetPlayerState pps;
        packetPlayerScore ppsc;
        packetPlayerAction ppa;
        packetPlayerKilled ppd;
        packetPlayerExtras ppe;
        packetDealExtras pde;
        packetPlayerName ppn;

        while(1){
                size = conn->recieveData((char *)&chk, sizeof(chk), MSG_PEEK);
                if(size == -1){
                        conn->disconnect();
                        gne->setFreeThread(mySock);
                        gne->removePlayerById(myPlayerID);
                        gne->eventQueue->addLast(new GE_PlayerDisconnected(myPlayerID));
                        LOG_ERROR(("Connection to a client lost."));
                        ExitThread(-1);
                }
                switch(chk.pktType){
                case(PKT_CHAT_MSG):
                        size = conn->recieveData((char *)&pcm, sizeof(pcm), 0);
                        gne->msgQueue->newMessage(pcm.msg);
                        gne->sendChatMsg(pcm.msg);
                        break;
                case(PKT_REQUEST_PLAYERS):
                        size = conn->recieveData((char *)&prapi, sizeof(prapi), 0);
                        for(i = 1; i < gne->playerlist->getNumPlayers(); i++){
                                if((p = gne->playerlist->getPlayerById(i))!=NULL)
                                        gne->sendPlayer(conn, p);
                        }
                        break;
                case(PKT_DISCONNECT):           
                        size = conn->recieveData((char *)&pd, sizeof(pd), 0);
                        setTimeStamp(&pd.header);
                        size = gne->sendDisconnectToAll(pd);
                        conn->disconnect();
                        gne->removePlayerById(pd.id);
                        gne->setFreeThread(mySock);
                        gne->eventQueue->addLast(new GE_PlayerDisconnected(pd.id));
                        ExitThread(0);
                        break;
                case(PKT_PLAYER_POSITION):
                        size = conn->recieveData((char *)&ppp, sizeof(ppp), 0);
                        gne->sendPlayerPosToAll(ppp, ppp.header.from);
                        gne->eventQueue->addLast(new GE_PlayerPos(ppp.id, ppp.rotation, ppp.move, ppp.x, ppp.y, ppp.angle));
                        break;
                case(PKT_ATTACK):
                        size = conn->recieveData((char *)&pa, sizeof(pa), 0);
                        gne->sendAttackNT(pa.id, pa.attack, pa.x, pa.y, pa.z, pa.dx, pa.dy, pa.dz, pa.header.from);
                        gne->eventQueue->addLast(new GE_Attack(pa.id, pa.attack, pa.x, pa.y, pa.z, pa.dx, pa.dy, pa.dz));
                        break;
                case(PKT_PLAYER_STATE):
                        size = conn->recieveData((char *)&pps, sizeof(pps), 0);                 
                        gne->setPlayerState(pps.id, pps.state);
                        gne->eventQueue->addLast(new GE_State(pps.id, pps.state));
                        break;
                case(PKT_PLAYER_SCORE):
                        size = conn->recieveData((char *)&ppsc, sizeof(ppsc), 0);                       
                        gne->setPlayerScore(ppsc.id, ppsc.frags, ppsc.kills, ppsc.deaths);
                        gne->eventQueue->addLast(new GE_PlayerScore(ppsc.id, ppsc.frags, ppsc.kills, ppsc.deaths));
                        break;
                case(PKT_PLAYER_ACTION):
                        size = conn->recieveData((char *)&ppa, sizeof(ppa), 0);
                        gne->setPlayerAction(ppa.id, ppa.action);
                        //gne->eventQueue->addLast(new GE_PlayerAction(ppa.id, ppa.action));
                        break;
                case(PKT_PLAYER_KILLED):
                        size = conn->recieveData((char *)&ppd, sizeof(pps), 0);                 
                        gne->setPlayerDeath(ppd.id, ppd.killer);
                        //gne->eventQueue->addLast(new GE_PlayerDeath(ppd.id, ppd.killer));
                        break;
                case(PKT_PLAYER_EXTRAS):
                        size = conn->recieveData((char *)&ppe, sizeof(ppe), 0);                 
                        gne->setPlayerExtras(ppe.id, ppe.extras, ppe.value);
                        //gne->eventQueue->addLast(new GE_PlayerExtras(ppe.id, ppe.extras, ppe.value));
                        break;
                case(PKT_DEAL_EXTRAS):
                        size = conn->recieveData((char *)&pde, sizeof(pde), 0);                 
                        gne->dealExtras(pde.detype, pde.x, pde.y, pde.flag);
                        //gne->eventQueue->addLast(new GE_PlayerExtras(ppe.id, ppe.extras, ppe.value));
                        break;
                case(PKT_PLAYER_NAME):
                        size = conn->recieveData((char *)&ppn, sizeof(ppn), 0);
                        gne->setPlayerName(ppn.id, ppn.name, ppn.flag);
                        if(ppn.id != gne->getPlayerIdSelf())
                                gne->playerlist->setPlayerName(ppn.id, ppn.name);
                        break;
                default:
                        conn->recieveData(NULL, size, 0);
                        break;
                }
        }
        return(NULL);
}


DWORD WINAPI Gne::clientThread(LPVOID arg){
        Gne *gne = (Gne *)arg;
        Connection *conn = gne->connection;
        int size;
        packetHeader chk;
        Player *p;
        packetChatMsg pcm;
        packetPlayerInfo ppi;
        packetDisconnect pd;
        packetPlayerPosition ppp;
        packetAttack pa;
        packetPlayerState pps;
        packetPlayerAction ppa;
        packetPlayerScore ppsc;
        packetPlayerKilled ppd;
        packetPlayerExtras ppe;
        packetDealExtras pde;
        packetPlayerName ppn;
        packetInfo pi;

        while(1){
                size = conn->recieveData((char *)&chk, sizeof(chk), MSG_PEEK);
                if(size == -1){
                        conn->disconnect();
                        gne->playerlist->removeAllPlayers();
                        gne->eventQueue->addLast(new GE_PlayerDisconnected(0));
                        LOG_ERROR(("Connection lost."));
                        ExitThread(-1);
                }

                switch(chk.pktType){
                case(PKT_CHAT_MSG):
                        size = conn->recieveData((char *)&pcm, sizeof(pcm), 0);
                        if(size == -1){
                                LOG_ERROR(("Error recieving chat msg."));
                                ExitThread(-1);
                        }
                        else
                                gne->msgQueue->newMessage(pcm.msg);
                        break;
                case(PKT_PLAYER_INFO):
                        size = conn->recieveData((char *)&ppi, sizeof(ppi), 0);
                        if(ppi.id!=gne->self->getID()){
                                p = new Player();
                                p->setID(ppi.id);
                                p->setName(ppi.name);
                                gne->addPlayer(p);
                        }
                        break;
                case(PKT_DISCONNECT):
                        size = conn->recieveData((char *)&pd, sizeof(pd), 0);
                        if(pd.id == gne->self->getID()){
                                gne->connection->disconnect();
                                delete(gne->connection);
                                gne->playerlist->removeAllPlayers();
                                gne->eventQueue->addLast(new GE_PlayerDisconnected(pd.id));
                                ExitThread(0);
                        }
                        if(pd.id == 0){
                                gne->disconnect();
                        }
                        else{
                                gne->removePlayerById(pd.id);
                                gne->eventQueue->addLast(new GE_PlayerDisconnected(pd.id));
                        }
                        break;
                case(PKT_PLAYER_POSITION):
                        size = conn->recieveData((char *)&ppp, sizeof(ppp), 0);
                        gne->eventQueue->addLast(new GE_PlayerPos(ppp.id, ppp.rotation, ppp.move, ppp.x, ppp.y, ppp.angle));
                        break;
                case(PKT_ATTACK):                       
                        size = conn->recieveData((char *)&pa, sizeof(pa), 0);
                        gne->eventQueue->addLast(new GE_Attack(pa.id, pa.attack, pa.x, pa.y, pa.z, pa.dx, pa.dy, pa.dz));
                        break;
                case(PKT_PLAYER_STATE):                 
                        size = conn->recieveData((char *)&pps, sizeof(pps), 0);
                        gne->eventQueue->addLast(new GE_State(pps.id, pps.state));
                        break;
                case(PKT_PLAYER_SCORE):
                        size = conn->recieveData((char *)&ppsc, sizeof(ppsc), 0);                       
                        gne->eventQueue->addLast(new GE_PlayerScore(ppsc.id, ppsc.frags, ppsc.kills, ppsc.deaths));
                        break;
                case(PKT_PLAYER_ACTION):
                        size = conn->recieveData((char *)&ppa, sizeof(ppa), 0);
                        gne->eventQueue->addLast(new GE_PlayerAction(ppa.id, ppa.action));
                        break;
                case(PKT_PLAYER_KILLED):
                        size = conn->recieveData((char *)&ppd, sizeof(pps), 0);
                        gne->eventQueue->addLast(new GE_PlayerDeath(ppd.id, ppd.killer));
                        break;
                case(PKT_PLAYER_EXTRAS):
                        size = conn->recieveData((char *)&ppe, sizeof(ppe), 0);                 
                        gne->eventQueue->addLast(new GE_PlayerExtras(ppe.id, ppe.extras, ppe.value));
                        break;
                case(PKT_DEAL_EXTRAS):
                        size = conn->recieveData((char *)&pde, sizeof(pde), 0);                 
                        gne->eventQueue->addLast(new GE_DealExtras(pde.detype, pde.x, pde.y, pde.flag));
                        break;
                case(PKT_PLAYER_NAME):
                        size = conn->recieveData((char *)&ppn, sizeof(ppn), 0);
                        if(ppn.id != gne->getPlayerIdSelf())
                                gne->playerlist->setPlayerName(ppn.id, ppn.name);
                        gne->eventQueue->addLast(new GE_SetName(ppn.id, ppn.name, ppn.flag));
                        break;
                case(PKT_INFO):
                        size = conn->recieveData((char *)&pi, sizeof(pi), 0);
                        gne->eventQueue->addLast(new GE_Info(pi.id, pi.valA, pi.valB, pi.valC));
                        break;
                default:
                        conn->recieveData(NULL, chk.pktLen, 0);
                        break;
                }
        }
        return(NULL);
}



int Gne::disconnect(){
        packetDisconnect pd;
        if(!isrunning){
                LOG_ERROR(("Could not disconnect: not connected."));
                return(-1);
        }
        if(!isserver){
        /*      pd = createPacketDisconnect(this->self->getID());
                setTimeStamp(&pd.header);
                setPacketFrom(&pd.header, self->getID());
                this->connection->sendData((char *)&pd, sizeof(pd));*/
                this->connection->disconnect();
        }
        else{
                pd = createPacketDisconnect(this->self->getID());
                setTimeStamp(&pd.header);
                setPacketFrom(&pd.header, self->getID());
                sendDisconnectToAll(pd);
                if(connection)
                        connection->disconnect();
                //kan ta ett tag tills alla är disconnected.
        }
        return(0);
}



int Gne::sendChatMsg(char *msg){
        int b;
        packetChatMsg pkt;
        pkt = createPacketChatMsg(this->self->getID() ,msg);
        setTimeStamp(&pkt.header);
        setPacketFrom(&pkt.header, self->getID());
        if(!isserver){
                b = this->connection->sendData((char *)&pkt, sizeof(pkt));
        }
        else{
                for(int i = 0; i < playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                b = this->clients[i]->sendData((char *)&pkt, sizeof(pkt));
                        }
                }
                this->msgQueue->newMessage(0, msg);
        }
        if(b == -1)
        {
                LOG_ERROR(("Error sending chat message."));
                return(-1);
        }
        return(b);
}


int Gne::sendChatMsg(msgstruct msg){
        int b;
        packetChatMsg pkt;
        pkt = createPacketChatMsg(msg.playerid ,msg.msg);
        setTimeStamp(&pkt.header);
        setPacketFrom(&pkt.header, self->getID());
        if(!isserver){
                b = this->connection->sendData((char *)&pkt, sizeof(pkt));
        }
        else{
                for(int i = 0; i < playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                b = this->clients[i]->sendData((char *)&pkt, sizeof(pkt));
                                if(b == -1)
                                {
                                        LOG_ERROR(("Error sending chat message."));
                                        return(-1);
                                }
                        }
                }
        }
        return(b);
}



int Gne::sendDisconnectToAll(packetDisconnect pkt){
        int b;
        if(!isserver)
                return(-1); 
        setTimeStamp(&pkt.header);
        setPacketFrom(&pkt.header, self->getID());

        //for(int i = 0; i < this->nextPlayerID; i++){
        for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                if(!freeSlotsThreads[i]){
                        b = this->clients[i]->sendData((char *)&pkt, sizeof(pkt));
                        if(b == -1)
                        {
                                LOG_ERROR(("Error sending a disconnect to a client."));
                                return(-1);
                        }
                }
        }
        return(b);
}




//server calls
int Gne::sendPlayer(Connection *conn, Player *p){
        packetPlayerInfo pkt = createPacketPlayerInfo(p->getName(), p->getID());
        setTimeStamp(&pkt.header);
        setPacketFrom(&pkt.header, self->getID());
        int size = conn->sendData((char *)&pkt, sizeof(pkt));
        if(size == -1){
                LOG_ERROR(("sendPlayer() error:: error sending player information."));
        }
        return(size);
}



//exception är fulhack.. se i listen.
int Gne::sendPlayerToAll(Player *p, int exception){
        int b;
        int num = this->playerlist->getNumPlayers();
        for(int i = 0; i < num; i++){
                if(!freeSlotsThreads[i]&&(i!=exception)){
                        b = sendPlayer(this->clients[i], p);
                        if(b==-1){
                                LOG_ERROR(("sendPlayerToAll() error:: this is a error follows from the sendPlayer() error."));
                                return(-1);
                        }
                }
        }
        return(b);
}


int Gne::updatePlayersFromServer(){
        if(isserver)
                return(-1);
        packetRequestAllPlayersInfo prapi;
        prapi = createPacketRequestAllPlayersInfo();
        setTimeStamp(&prapi.header);
        setPacketFrom(&prapi.header, self->getID());
        int size = this->connection->sendData((char *)&prapi, sizeof(prapi));
        if(size == -1){
                return(-1);
        }
        
        return(0);
}


void Gne::setPlayerPos(int id, int rotation, int move, float x, float y, float angle){
        packetPlayerPosition pkt;
        pkt = createPacketPlayerPosition(id, rotation, move, x, y, angle, false);
        setTimeStamp(&pkt.header);
        setPacketFrom(&pkt.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&pkt, sizeof(pkt));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                if(!freeSlotsThreads[i]){
                        this->clients[i]->sendData((char *)&pkt, sizeof(pkt));
                        }
                }
        }
}




void Gne::sendPlayerPosToAll(packetPlayerPosition pkt, int nt){
        if(!isserver)
                return;
        setTimeStamp(&pkt.header);
        setPacketFrom(&pkt.header, self->getID());
        for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                if(!freeSlotsThreads[i]&&idlist[i]!=nt){
                        this->clients[i]->sendData((char *)&pkt, sizeof(pkt));
                }
        }

}



void Gne::sendAttackNT(int playerid, int type, float x, float y, float z, float dx, float dy, float dz, int nt){
        if(!isrunning)
                return;
        packetAttack pa;
        pa = createPacketAttack(playerid, type, x, y, z, dx, dy, dz);
        setTimeStamp(&pa.header);
        setPacketFrom(&pa.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&pa, sizeof(pa));

        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]&&idlist[i]!=nt){
                                        this->clients[i]->sendData((char *)&pa, sizeof(pa));
                        }
                }
        }
}


void Gne::sendInfo(int playerid, int valA, int valB, int valC){
        if(!isrunning)
                return;
        packetInfo pi;
        pi = createPacketInfo(playerid, valA, valB, valC);
        setTimeStamp(&pi.header);
        setPacketFrom(&pi.header, self->getID());
        for(int i=0; i<this->playerlist->getNumPlayers(); i++){
                if(idlist[i]==playerid)
                        this->clients[i]->sendData((char *)&pi, sizeof(pi));
        }
}




void Gne::sendAttack(int playerid, int type, float x, float y, float z, float dx, float dy, float dz){
        sendAttackNT(playerid, type, x, y, z, dx, dy, dz, 0);
}


void Gne::setPlayerState(int playerid, int state){
        if(!isrunning)
                return;
        packetPlayerState pps;
        pps = createPacketPlayerState(playerid, state);
        setTimeStamp(&pps.header);
        setPacketFrom(&pps.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&pps, sizeof(pps));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                        this->clients[i]->sendData((char *)&pps, sizeof(pps));
                        }
                }
        }
}


void Gne::setPlayerScore(int playerID, int frags, int kills, int deaths){
        if(!isrunning)
                return;
        packetPlayerScore ppsc;
        ppsc = createPacketPlayerScore(playerID, kills, frags, deaths);
        setTimeStamp(&ppsc.header);
        setPacketFrom(&ppsc.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&ppsc, sizeof(ppsc));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                        this->clients[i]->sendData((char *)&ppsc, sizeof(ppsc));
                        }
                }
        }
}


void Gne::setPlayerActionNT(int playerID, int action, int nt){
        if(!isrunning)
                return;
        packetPlayerAction ppa;
        ppa = createPacketPlayerAction(playerID, action);
        setTimeStamp(&ppa.header);
        setPacketFrom(&ppa.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&ppa, sizeof(ppa));

        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]/*&&idlist[i]!=nt*/){
                                        this->clients[i]->sendData((char *)&ppa, sizeof(ppa));
                        }
                }
                this->eventQueue->addLast(new GE_PlayerAction(playerID, action));
        }
}


void Gne::setPlayerAction(int playerID, int action){
        setPlayerActionNT(playerID, action, 0);
}



void Gne::setPlayerDeath(int playerID, int killerID){
        if(!isrunning)
                return;
        packetPlayerKilled ppd;
        ppd = createPacketPlayerKilled(playerID, killerID);
        setTimeStamp(&ppd.header);
        setPacketFrom(&ppd.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&ppd, sizeof(ppd));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                        this->clients[i]->sendData((char *)&ppd, sizeof(ppd));
                        }
                }
                this->eventQueue->addLast(new GE_PlayerDeath(playerID, killerID));
        }
}


void Gne::setPlayerExtras(int playerID, int extras, int value){
        if(!isrunning)
                return;
        packetPlayerExtras ppe;
        ppe = createPacketPlayerExtras(playerID, extras, value);
        setTimeStamp(&ppe.header);
        setPacketFrom(&ppe.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&ppe, sizeof(ppe));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                        this->clients[i]->sendData((char *)&ppe, sizeof(ppe));
                        }
                }
                this->eventQueue->addLast(new GE_PlayerExtras(playerID, extras, value));
        }
}


void Gne::dealExtras(int type, float x, float y, int flag){
        if(!isrunning)
                return;
        packetDealExtras pde;
        pde = createPacketDealExtras(type, x, y, flag);
        setTimeStamp(&pde.header);
        setPacketFrom(&pde.header, self->getID());
        if(!isserver){
                this->connection->sendData((char *)&pde, sizeof(pde));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                        this->clients[i]->sendData((char *)&pde, sizeof(pde));
                        }
                }
                this->eventQueue->addLast(new GE_DealExtras(type, x, y, flag));
        }
}



int Gne::setPlayerName(int playerID, const char *name, int flag){
        if(!isrunning)
                return(-1);
        if(strlen(name) > 25){
                LOG_ERROR(("Name have to be shorter then 26 characters."));
                return(-1);
        }

        packetPlayerName ppn;
        ppn = createPacketPlayerName(playerID, name, flag);
        setTimeStamp(&ppn.header);
        setPacketFrom(&ppn.header, getPlayerIdSelf());
        if(!isserver){
                this->connection->sendData((char *)&ppn, sizeof(ppn));
        }
        else{
                for(int i = 0; i < this->playerlist->getNumPlayers(); i++){
                        if(!freeSlotsThreads[i]){
                                        this->clients[i]->sendData((char *)&ppn, sizeof(ppn));
                        }
                }
                this->eventQueue->addLast(new GE_SetName(playerID, name, flag));
        }       

        if(playerID == self->getID()){
                this->self->setName(name);
                return(0);
        }
        return(0);

}


int Gne::setName(const char *name, int flag){
        return(setPlayerName(this->getPlayerIdSelf(), name, flag));
}


int Gne::nextEventPending(){
        return(this->eventQueue->getType());
}


void *Gne::getNextEvent(){
        return(this->eventQueue->getNextEvent());
}

---