mo

NetCode.h:
#define maxRemoteHosts 32
#define SERVER_PLAYER_ID -1
#define FIRST_PLAYER_ID 0

#define EVENT_JOIN 		1
#define EVENT_JOINACK	2
#define EVENT_JOINDEN	3

#define EVENT_LEAVE  	4
#define EVENT_MSG  		5


struct remoteHost {
	IPaddress ipaddr;
	bool isActive;
};

struct myDataPacket {
	int playerID;
	int eventNo;
};

struct myJoinPacket {
	char playerName[20];
};

struct myJoinDeniedPacked {
	char reason[100];
};

class NetCode {
	private:

		int allocPlayerID();
		void freePlayerID ( int i );
			
		remoteHost *addRemotePlayer ( IPaddress remoteAddr );
		remoteHost *hosts;
		IPaddress serverAddr;
		
		
	
		bool amIServer;
		int listenPort;
		UDPsocket udpsock;
		
		// clientMethods:
		
		int clientID;
		
	public:
	void sendJoinPacket ( char *playerName );
		NetCode ( int port, int serverport, char *address );
		NetCode ( int port );
		bool init ();
		bool close ();
		void doNetStuff ();
};

NetCode.cpp:
#include "stdheaders.h"

// server-constructor
NetCode::NetCode ( int port ) {
	amIServer = true;
	listenPort = port;
	hosts = new remoteHost [ maxRemoteHosts ];
	for ( int i = 0; i < maxRemoteHosts; i ++ ) {
		hosts[i].isActive = false;
	}
}


// client-constructor
NetCode::NetCode ( int port, int serverport, char *address ) {
	amIServer = false;
	listenPort = port;
	if ( SDLNet_ResolveHost(&serverAddr, address, serverport) == -1 ) {
		cerr << "error resolving serveraddress" << endl;
	}
	clientID = -1;
}

bool NetCode::init () {
// create a UDPsocket on port 6666 (server)
	udpsock=SDLNet_UDP_Open(listenPort);
	if(!udpsock) {
    	printf("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
    	return false;
	}
	return true;
}

bool NetCode::close () {
	SDLNet_UDP_Close(udpsock);
	udpsock = NULL;
	return true;
}

int NetCode::allocPlayerID() {
	for ( int i = 0; i < maxRemoteHosts; i++ ) {
		if ( hosts[i].isActive == false ) {
			hosts[i].isActive = true;
			return i;
		}
	}
	return -1;
}

void NetCode::freePlayerID ( int i ) {
	hosts[i].isActive = false;
}

void NetCode::doNetStuff () {
	Uint8 data[1000];
	UDPpacket packet;
	packet.data = data;
	int numrecv = 1;
	while ( numrecv == 1 ) {
		numrecv=SDLNet_UDP_Recv(udpsock, &packet);
		if ( numrecv == 0 ) break;
		if ( numrecv == -1 ) {
			cerr << "error on calling UDP_Recv" << endl;
			break;
		}
		if ( numrecv == 1 ) {
			cerr << "recv ok" << endl;
		}
		//cout << "packet received"<< endl;
		// generic stuff...
		cout << "packet len: " << packet.len << endl;
		cout << "packet maxlen: " << packet.maxlen << endl;
		cout << "packet status: " << packet.status << endl;
		cout << "expected: " <<  sizeof ( myDataPacket)+ sizeof ( myJoinPacket ) << endl;
		myDataPacket dataPacket;
		memcpy ( &dataPacket, packet.data, sizeof ( myDataPacket ) );
		cout << "eventNo" << dataPacket.eventNo << endl;
		// copy payload in eventtypes...
		
		myJoinPacket joinPacket;
		
		switch ( dataPacket.eventNo ) {
			case EVENT_JOIN:
				cout << "event: join" << endl;
				memcpy ( &joinPacket, packet.data + sizeof ( myDataPacket), sizeof ( myJoinPacket ) );
				break;
			default:
				break;
		}
		int playerNo;
		int eventNo;//memcpy ( void * destination, const void * source, size_t num );
			
		if ( amIServer == true ) { // I AM SERVER 
			switch ( dataPacket.eventNo ) {
				case EVENT_JOIN:
					cout << "Player " << joinPacket.playerName << " wants to join " << endl;
					// TODO: add to player list
					// TODO: send ACK-packet
					// TODO: errorconditions ( DENY packets )
					break;
				default:
					cout << "unidentified packet" << endl;
					break;
			}
		} else { // I AM CLIENT
			switch ( dataPacket.eventNo ) {
				case EVENT_JOINACK:
					cout << "JOINACK" << endl;
					break;
				default:
					break;
			}
		}
	}
}

void NetCode::sendJoinPacket ( char *playerName ) {
	myDataPacket dataPacket;
	myJoinPacket joinPacket;
	bool endReached = false;
	for ( int i = 0; i < 20; i ++ ) {
		if ( endReached == false ) {
			joinPacket.playerName[i] = playerName[i];
		} else {
			joinPacket.playerName[i] = '\0';
		}
		if ( playerName[i] == '\0' ) endReached = true;
	}
	dataPacket.eventNo = EVENT_JOIN ;
	dataPacket.playerID = -1;
	
	Uint8 data [ sizeof ( myDataPacket ) + sizeof ( myJoinPacket ) ];
	UDPpacket udpPacket;
	udpPacket.channel = -1;
	udpPacket.data = data;
	udpPacket.len = sizeof ( myDataPacket ) + sizeof ( myJoinPacket );
	udpPacket.maxlen = sizeof ( myDataPacket ) + sizeof ( myJoinPacket );
	udpPacket.address = serverAddr;
	memcpy ( data, &dataPacket, sizeof ( myDataPacket ) );
	memcpy ( data + sizeof ( myDataPacket ), &joinPacket, sizeof ( myJoinPacket ) );	
	int numsent=SDLNet_UDP_Send(udpsock, -1, &udpPacket);
	if(!numsent) {
    	printf("SDLNet_UDP_Send error :( : %s\n", SDLNet_GetError());
	}
	cout << "sent packet, len: " << udpPacket.status << " / " << udpPacket.len << " / " << udpPacket.maxlen << endl;
}

call:
	NetCode *netcode;
	netcode = new NetCode ( 10001, 10000, "localhost"  );
	netcode->init();
	NetCode *serverNetcode;
	serverNetcode = new NetCode ( 10000 );
	serverNetcode->init();
	
	netcode->sendJoinPacket("mo");
	for ( int i = 0; i < 1000000; i ++ ) {
		
		serverNetcode->doNetStuff();
		SDL_Delay ( 10 );
	}
	
	netcode->close();
	serverNetcode->close();
	delete ( netcode );
	delete ( serverNetcode );