C4ClientList &C4ClientList::operator =(const C4ClientList &List)
{
// remove clients that are not in the list
C4Client *pClient, *pNext;
for (pClient = pFirst; pClient; pClient = pNext)
{
pNext = pClient->pNext;
if (!List.getClientByID(pClient->getID()))
{
Remove(pClient);
delete pClient;
}
}
// add all clients
for (pClient = List.pFirst; pClient; pClient = pClient->pNext)
{
// already in list?
C4Client *pNewClient = getClientByID(pClient->getID());
if (pNewClient)
{
// core change
pNewClient->SetCore(pClient->getCore());
}
else
{
// add
pNewClient = Add(pClient->getCore());
}
}
return *this;
}
char* bb_clientGetLastMessage(unsigned long clientID)
{
cClient *c = getClientByID(clientID);
if(!c) return 0;
return c->GetLastMessage();
}
char* bb_clientGetLastMessage(UINT4 clientID)
{
cClient *c = getClientByID(clientID);
if(!c) return 0;
return c->GetLastMessage();
}
unsigned long bb_clientGetBytesReceived(unsigned long clientID)
{
cClient *c = getClientByID(clientID);
if(c) return c->BytesReceived;
return 0;
}
UINT4 bb_clientGetBytesReceived(UINT4 clientID)
{
cClient *c = getClientByID(clientID);
if(c) return c->BytesReceived;
return 0;
}
unsigned long bb_clientGetBytesSent(unsigned long clientID)
{
cClient *c = getClientByID(clientID);
if(!c) return 0;
return c->BytesSent;
}
UINT4 bb_clientGetBytesSent(UINT4 clientID)
{
cClient *c = getClientByID(clientID);
if(!c) return 0;
return c->BytesSent;
}
C4Client *C4ClientList::Add(const C4ClientCore &Core)
{
// client with same ID in list?
if (getClientByID(Core.getID()))
{ Log("ClientList: Duplicated client ID!"); return NULL; }
// create, add
C4Client *pClient = new C4Client(Core);
Add(pClient);
return pClient;
}
int bb_clientSend(unsigned long clientID,char* dataToSend,int dataSize,int typeID,int protocol)
{
cClient *c = getClientByID(clientID);
if(!c) return 1;
c->CreatePacket(new cPacket(dataToSend,dataSize,(unsigned short)typeID),c->UDPenabled ? (protocol ? true : false) : false);
return 0;
}
int bb_clientSetRate(unsigned long clientID,int nbBytes)
{
cClient *c = getClientByID(clientID);
if(!c) return 1;
c->DataRate = (unsigned short)nbBytes;
return 0;
}
char* bb_clientGetLastError(UINT4 clientID)
{
cClient *c = getClientByID(clientID);
if(!c)
{
return serror;
}
return c->GetLastError();
}
void C4ClientList::Add(C4Client *pClient)
{
// local client?
if (pClient->isLocal()) pLocal = pClient;
// already in list?
assert(!getClientByID(pClient->getID()));
// find insert position
C4Client *pPos = pFirst, *pPrev = NULL;
for (; pPos; pPrev = pPos, pPos = pPos->pNext)
if (pPos->getID() > pClient->getID())
break;
// add to list
pClient->pNext = pPos;
(pPrev ? pPrev->pNext : pFirst) = pClient;
// register to network
if (pNetClients)
pClient->pNetClient = pNetClients->RegClient(pClient);
}
int bb_clientDisconnect(unsigned long clientID)
{
if(!MainClients) return 1;
cClient *c = getClientByID(clientID);
if(!c) return 1;
c->Disconnect();
if(c->Next) c->Next->Previous = c->Previous;
if(c->Previous) c->Previous->Next = c->Next;
if(c == MainClients) MainClients = MainClients->Next;
delete c;
return 0;
}
char* bb_clientReceive(unsigned long clientID,int *typeID)
{
cClient *c = getClientByID(clientID);
if(!c)
{
*typeID = 0;
return 0;
}
cPacket* p=0;
//on va checker les packet qui vienne des client qui sont pret a etre recu
p = c->GetReadyPacket();
if(p)
{
*typeID = p->TypeID;
return p->Data == 0 ? (char *)1 : p->Data;
}
return 0;
}
int bb_clientUpdate(unsigned long clientID,float elapsed,int updateMsg)
{
cClient *c = getClientByID(clientID);
if(!c) return 1;
sprintf(c->LastMessage,"");
sprintf(c->LastError,"");
if(c->isConnected)
{
switch(updateMsg)
{
case UPDATE_SEND_RECV:
{
//on recois UDP du serveur
//UDPserver->ReceiveFromSocket( Server ? 20 : 50 );
//on recois TCP/UDP du serveur
int r = c->ReceivePacketsFromServer();
if(r) return r;
//on envoi au serveur TCP/UDP
if(c->SendPacketsToServer()) return 1;
return 0;
}
case UPDATE_SEND:
{
//on envoi au serveur TCP/UDP
if(c->SendPacketsToServer()) return 1;
return 0;
}
case UPDATE_RECV:
{
//on recois UDP du serveur
//UDPserver->ReceiveFromSocket( Server ? 20 : 40 );
//on recois TCP/UDP du serveur
int r = c->ReceivePacketsFromServer();
if(r) return r;
return 0;
}
}
}
else //on est pas encore connecter
{
int r = c->UpdateConnection(elapsed);
if(r==2) //connection reussi!
{
c->isConnected = true;
return 3;
}
if(r==1) //erreur pendant la connection
{
c->isConnected = false;
return 1;
}
}
return 0;
}
void update(float dt) {
int clientsCount = clients.size();
lockMutex( clientsMutex );
for ( Uint32 i = 0; i < clients.size(); i++ ) {
lockMutex( clients[i]->mutex );
if ( clients[i]->recvSize > 2 ) {
int readPos = clients[i]->startPos;
if ( readPos >= BUFFER_SIZE )
readPos -= BUFFER_SIZE;
char msgType = clients[i]->msg[readPos];
readPos++;
if ( readPos >= BUFFER_SIZE )
readPos -= BUFFER_SIZE;
char msgLength = clients[i]->msg[readPos];
if ( msgLength <= clients[i]->recvSize - 2 ) {
char * data = (char*) malloc( msgLength+1 );
for ( Uint16 j = 0; j < msgLength; j++ ) {
readPos++;
if (readPos >= BUFFER_SIZE)
readPos -= BUFFER_SIZE;
data[j] = clients[i]->msg[readPos];
}
readPos++;
if ( readPos >= BUFFER_SIZE )
readPos -= BUFFER_SIZE;
clients[i]->startPos = readPos;
clients[i]->recvSize -= msgLength+2;
data[msgLength] = 0;
void* dat = data;
printf( "Decoded message type %c:%X\n", msgType, (unsigned)msgType );
switch ( msgType ) {
case 'm':
printf( "%s: %s\n", clients[i]->address, data );
break;
case 'b':
broadcast( 'm', data, msgLength );
break;
case B_NEWPLAYER:{
unsigned int id = clients[i]->ID;
send ( &clients[i]->socket, B_NEWPLAYERID, &id, sizeof( unsigned int ) );
float* pos = (float*) data;
(float)pos[3] = (float) clients[i]->ID;
printf("New player. ID: %i\n", clients[i]->ID);
broadcastExcept( clients[i]->socket, B_NEWPLAYER, data, sizeof(float)*4 );
break;
}
case B_FORNEWBIE:{
Uint8 id = ((float*)dat)[8];
Client* dest = getClientByID(id);
if (dest != NULL) {
send( &dest->socket, B_FORNEWBIE, dat, msgLength );
}
break;
}
case B_PLAYERTURN:{
broadcastExcept ( clients[i]->socket, B_PLAYERTURN, dat, msgLength );
break;
}
case B_PLAYERTURNZ:
broadcastExcept ( clients[i]->socket, B_PLAYERTURNZ, dat, msgLength );
break;
}
}
}
unlockMutex( clients[i]->mutex );
}
unlockMutex( clientsMutex );
}
