Rearranged the SerialPacket and serialization code

The serialization code is now using macros to simplify each line, and to
prevent errors. It should be noted that, apart from the region content,
the serialization and deserialization code is essentially identical.

common/network/serial.cpp

@@ -25,85 +25,59 @@
 
 #include <cstring>
 
+//-------------------------
+//Convenience Macros
+//-------------------------
+
+#define SERIALIZE(buffer, data, size) memcpy(buffer, data, size); buffer += size;
+#define DESERIALIZE(buffer, data, size) memcpy(data, buffer, size); buffer += size;
+
 //-------------------------
 //internal serialization functions
 //-------------------------
 
 void serializeType(SerialPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	SERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
 }
 
 void serializeServer(SerialPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	SERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
 	//server info
-	//Note: version info serialization goes here
+	SERIALIZE(buffer, &packet->serverInfo.networkVersion, sizeof(int));
-	memcpy(buffer, packet->serverInfo.name, PACKET_STRING_SIZE);
+	SERIALIZE(buffer, packet->serverInfo.name, PACKET_STRING_SIZE);
-	buffer += PACKET_STRING_SIZE;
+	SERIALIZE(buffer, &packet->serverInfo.playerCount, sizeof(int));
-	memcpy(buffer, &packet->serverInfo.playerCount, sizeof(int));
-	buffer += sizeof(int);
-
-	//map format
-	memcpy(buffer, &packet->serverInfo.regionWidth, sizeof(int));
-	buffer += sizeof(int);
-	memcpy(buffer, &packet->serverInfo.regionHeight, sizeof(int));
-	buffer += sizeof(int);
-	memcpy(buffer, &packet->serverInfo.regionDepth, sizeof(int));
 }
 
 void serializeClient(SerialPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	SERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
-	memcpy(buffer, &packet->clientInfo.index, sizeof(int));
-}
-
-void serializePlayer(SerialPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
 	//indexes
-	memcpy(buffer, &packet->playerInfo.clientIndex, sizeof(int));
+	SERIALIZE(buffer, &packet->clientInfo.clientIndex, sizeof(int));
-	buffer += sizeof(int);
+	SERIALIZE(buffer, &packet->clientInfo.playerIndex, sizeof(int));
-	memcpy(buffer, &packet->playerInfo.playerIndex, sizeof(int));
-	buffer += sizeof(int);
 
-	//text
+	//texts
-	memcpy(buffer, packet->playerInfo.handle, PACKET_STRING_SIZE);
+	SERIALIZE(buffer, packet->clientInfo.player, PACKET_STRING_SIZE);
-	buffer += PACKET_STRING_SIZE;
+	SERIALIZE(buffer, packet->clientInfo.handle, PACKET_STRING_SIZE);
-	memcpy(buffer, packet->playerInfo.avatar, PACKET_STRING_SIZE);
+	SERIALIZE(buffer, packet->clientInfo.avatar, PACKET_STRING_SIZE);
-	buffer += PACKET_STRING_SIZE;
-
-	//vectors
-	memcpy(buffer, &packet->playerInfo.position.x, sizeof(double));
-	buffer += sizeof(double);
-	memcpy(buffer, &packet->playerInfo.position.y, sizeof(double));
-	buffer += sizeof(double);
-	memcpy(buffer, &packet->playerInfo.motion.x, sizeof(double));
-	buffer += sizeof(double);
-	memcpy(buffer, &packet->playerInfo.motion.y, sizeof(double));
 }
 
 void serializeRegionFormat(SerialPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	SERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
-	//x & y
+	//format
-	memcpy(buffer, &packet->regionInfo.x, sizeof(int));
+	SERIALIZE(buffer, &packet->regionInfo.mapIndex, sizeof(int));
-	buffer += sizeof(int);
+	SERIALIZE(buffer, &packet->regionInfo.x, sizeof(int));
-	memcpy(buffer, &packet->regionInfo.y, sizeof(int));
+	SERIALIZE(buffer, &packet->regionInfo.y, sizeof(int));
 }
 
 void serializeRegionContent(SerialPacket* packet, char* buffer) {
-	//format
+	SERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
-	//x & y
+	//format
-	*reinterpret_cast<int*>(buffer) = packet->regionInfo.region->GetX();
+	SERIALIZE(buffer, &packet->regionInfo.mapIndex, sizeof(int));
-	buffer += sizeof(int);
+	SERIALIZE(buffer, &packet->regionInfo.x, sizeof(int));
-	*reinterpret_cast<int*>(buffer) = packet->regionInfo.region->GetY();
+	SERIALIZE(buffer, &packet->regionInfo.y, sizeof(int));
-	buffer += sizeof(int);
 
 	//content
 	for (register int i = 0; i < REGION_WIDTH; i++) {
@@ -116,92 +90,75 @@ void serializeRegionContent(SerialPacket* packet, char* buffer) {
 	}
 }
 
+void serializePlayer(SerialPacket* packet, char* buffer) {
+	SERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+
+	//indexes
+	SERIALIZE(buffer, &packet->playerInfo.clientIndex, sizeof(int));
+	SERIALIZE(buffer, &packet->playerInfo.playerIndex, sizeof(int));
+
+	//vectors
+	SERIALIZE(buffer, &packet->playerInfo.position.x, sizeof(double));
+	SERIALIZE(buffer, &packet->playerInfo.position.y, sizeof(double));
+	SERIALIZE(buffer, &packet->playerInfo.motion.x, sizeof(double));
+	SERIALIZE(buffer, &packet->playerInfo.motion.y, sizeof(double));
+}
+
 //-------------------------
 //internal deserialization functions
 //-------------------------
 
 void deserializeType(SerialPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	DESERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
 }
 
 void deserializeServer(SerialPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	DESERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
 	//server info
-	//Note: version info deserialization goes here
+	DESERIALIZE(buffer, &packet->serverInfo.networkVersion, sizeof(int));
-	memcpy(packet->serverInfo.name, buffer, PACKET_STRING_SIZE);
+	DESERIALIZE(buffer, packet->serverInfo.name, PACKET_STRING_SIZE);
-	buffer += PACKET_STRING_SIZE;
+	DESERIALIZE(buffer, &packet->serverInfo.playerCount, sizeof(int));
-	memcpy(&packet->serverInfo.playerCount, buffer, sizeof(int));
-	buffer += sizeof(int);
-
-	//map format
-	memcpy(&packet->serverInfo.regionWidth, buffer, sizeof(int));
-	buffer += sizeof(int);
-	memcpy(&packet->serverInfo.regionHeight, buffer, sizeof(int));
-	buffer += sizeof(int);
-	memcpy(&packet->serverInfo.regionDepth, buffer, sizeof(int));
 }
 
 void deserializeClient(SerialPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	DESERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
-	memcpy(&packet->clientInfo.index, buffer, sizeof(int));
-}
-
-void deserializePlayer(SerialPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
 	//indexes
-	memcpy(&packet->playerInfo.clientIndex, buffer, sizeof(int));
+	DESERIALIZE(buffer, &packet->clientInfo.clientIndex, sizeof(int));
-	buffer += sizeof(int);
+	DESERIALIZE(buffer, &packet->clientInfo.playerIndex, sizeof(int));
-	memcpy(&packet->playerInfo.playerIndex, buffer, sizeof(int));
-	buffer += sizeof(int);
 
-	//text
+	//texts
-	memcpy(packet->playerInfo.handle, buffer, PACKET_STRING_SIZE);
+	DESERIALIZE(buffer, packet->clientInfo.player, PACKET_STRING_SIZE);
-	buffer += PACKET_STRING_SIZE;
+	DESERIALIZE(buffer, packet->clientInfo.handle, PACKET_STRING_SIZE);
-	memcpy(packet->playerInfo.avatar, buffer, PACKET_STRING_SIZE);
+	DESERIALIZE(buffer, packet->clientInfo.avatar, PACKET_STRING_SIZE);
-	buffer += PACKET_STRING_SIZE;
-
-	//vectors
-	memcpy(&packet->playerInfo.position.x, buffer, sizeof(double));
-	buffer += sizeof(double);
-	memcpy(&packet->playerInfo.position.y, buffer, sizeof(double));
-	buffer += sizeof(double);
-	memcpy(&packet->playerInfo.motion.x, buffer, sizeof(double));
-	buffer += sizeof(double);
-	memcpy(&packet->playerInfo.motion.y, buffer, sizeof(double));
 }
 
 void deserializeRegionFormat(SerialPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	DESERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
-	//x & y
+	//format
-	memcpy(&packet->regionInfo.x, buffer, sizeof(int));
+	DESERIALIZE(buffer, &packet->regionInfo.mapIndex, sizeof(int));
-	buffer += sizeof(int);
+	DESERIALIZE(buffer, &packet->regionInfo.x, sizeof(int));
-	memcpy(&packet->regionInfo.y, buffer, sizeof(int));
+	DESERIALIZE(buffer, &packet->regionInfo.y, sizeof(int));
 }
 
 void deserializeRegionContent(SerialPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	DESERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
-	buffer += sizeof(SerialPacket::Type);
 
-	//x & y
+	//format
-	memcpy(&packet->regionInfo.x, buffer, sizeof(int));
+	DESERIALIZE(buffer, &packet->regionInfo.mapIndex, sizeof(int));
-	buffer += sizeof(int);
+	DESERIALIZE(buffer, &packet->regionInfo.x, sizeof(int));
-	memcpy(&packet->regionInfo.y, buffer, sizeof(int));
+	DESERIALIZE(buffer, &packet->regionInfo.y, sizeof(int));
-	buffer += sizeof(int);
 
-	//content
+	//an object to work on
 	BlankAllocator().Create(
 		&packet->regionInfo.region,
 		packet->regionInfo.x,
 		packet->regionInfo.y
 	);
 
+	//content
 	for (register int i = 0; i < REGION_WIDTH; i++) {
 		for (register int j = 0; j < REGION_HEIGHT; j++) {
 			for (register int k = 0; k < REGION_DEPTH; k++) {
@@ -212,6 +169,20 @@ void deserializeRegionContent(SerialPacket* packet, char* buffer) {
 	}
 }
 
+void deserializePlayer(SerialPacket* packet, char* buffer) {
+	DESERIALIZE(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+
+	//indexes
+	DESERIALIZE(buffer, &packet->playerInfo.clientIndex, sizeof(int));
+	DESERIALIZE(buffer, &packet->playerInfo.playerIndex, sizeof(int));
+
+	//vectors
+	DESERIALIZE(buffer, &packet->playerInfo.position.x, sizeof(double));
+	DESERIALIZE(buffer, &packet->playerInfo.position.y, sizeof(double));
+	DESERIALIZE(buffer, &packet->playerInfo.motion.x, sizeof(double));
+	DESERIALIZE(buffer, &packet->playerInfo.motion.y, sizeof(double));
+}
+
 //-------------------------
 //the interface functions
 //-------------------------
@@ -223,8 +194,6 @@ void serialize(SerialPacket* packet, void* buffer) {
 		case SerialPacket::Type::PING:
 		case SerialPacket::Type::PONG:
 		case SerialPacket::Type::BROADCAST_REQUEST:
-		case SerialPacket::Type::JOIN_REQUEST:
-		case SerialPacket::Type::SYNCHRONIZE:
 			serializeType(packet, reinterpret_cast<char*>(buffer));
 		break;
 
@@ -234,19 +203,14 @@ void serialize(SerialPacket* packet, void* buffer) {
 		break;
 
 		//Client info
+		case SerialPacket::Type::JOIN_REQUEST:
 		case SerialPacket::Type::JOIN_RESPONSE:
+		case SerialPacket::Type::SYNCHRONIZE:
 		case SerialPacket::Type::DISCONNECT:
 		case SerialPacket::Type::SHUTDOWN:
 			serializeClient(packet, reinterpret_cast<char*>(buffer));
 		break;
 
-		//Player info
-		case SerialPacket::Type::PLAYER_NEW:
-		case SerialPacket::Type::PLAYER_DELETE:
-		case SerialPacket::Type::PLAYER_UPDATE:
-			serializePlayer(packet, reinterpret_cast<char*>(buffer));
-		break;
-
 		//region info
 		case SerialPacket::Type::REGION_REQUEST:
 			serializeRegionFormat(packet, reinterpret_cast<char*>(buffer));
@@ -255,6 +219,13 @@ void serialize(SerialPacket* packet, void* buffer) {
 		case SerialPacket::Type::REGION_CONTENT:
 			serializeRegionContent(packet, reinterpret_cast<char*>(buffer));
 		break;
+
+		//Player info
+		case SerialPacket::Type::PLAYER_NEW:
+		case SerialPacket::Type::PLAYER_DELETE:
+		case SerialPacket::Type::PLAYER_UPDATE:
+			serializePlayer(packet, reinterpret_cast<char*>(buffer));
+		break;
 	}
 }
 
@@ -267,8 +238,6 @@ void deserialize(SerialPacket* packet, void* buffer) {
 		case SerialPacket::Type::PING:
 		case SerialPacket::Type::PONG:
 		case SerialPacket::Type::BROADCAST_REQUEST:
-		case SerialPacket::Type::JOIN_REQUEST:
-		case SerialPacket::Type::SYNCHRONIZE:
 			//NOTHING
 		break;
 
@@ -278,19 +247,14 @@ void deserialize(SerialPacket* packet, void* buffer) {
 		break;
 
 		//Client info
+		case SerialPacket::Type::JOIN_REQUEST:
 		case SerialPacket::Type::JOIN_RESPONSE:
+		case SerialPacket::Type::SYNCHRONIZE:
 		case SerialPacket::Type::DISCONNECT:
 		case SerialPacket::Type::SHUTDOWN:
 			deserializeClient(packet, reinterpret_cast<char*>(buffer));
 		break;
 
-		//Player info
-		case SerialPacket::Type::PLAYER_NEW:
-		case SerialPacket::Type::PLAYER_DELETE:
-		case SerialPacket::Type::PLAYER_UPDATE:
-			deserializePlayer(packet, reinterpret_cast<char*>(buffer));
-		break;
-
 		//region info
 		case SerialPacket::Type::REGION_REQUEST:
 			deserializeRegionFormat(packet, reinterpret_cast<char*>(buffer));
@@ -299,5 +263,12 @@ void deserialize(SerialPacket* packet, void* buffer) {
 		case SerialPacket::Type::REGION_CONTENT:
 			deserializeRegionContent(packet, reinterpret_cast<char*>(buffer));
 		break;
+
+		//Player info
+		case SerialPacket::Type::PLAYER_NEW:
+		case SerialPacket::Type::PLAYER_DELETE:
+		case SerialPacket::Type::PLAYER_UPDATE:
+			deserializePlayer(packet, reinterpret_cast<char*>(buffer));
+		break;
 	}
 }

common/network/serial.hpp

@@ -27,10 +27,10 @@
 /* NOTE: Keep the PACKET_BUFFER_SIZE up to date
  * NOTE: REGION_CONTENT is currently the largest type of packet
  *  map content: REGION_WIDTH * REGION_HEIGHT * REGION_DEPTH * sizoeof(region::type_t)
- *  map format: sizeof(int) * 2
+ *  map format: sizeof(int) * 3
  *  metadata: sizeof(metadata)
 */
-#define PACKET_BUFFER_SIZE REGION_WIDTH * REGION_HEIGHT * REGION_DEPTH * sizeof(Region::type_t) + sizeof(int) * 2 + sizeof(SerialPacket::Metadata)
+#define PACKET_BUFFER_SIZE REGION_WIDTH * REGION_HEIGHT * REGION_DEPTH * sizeof(Region::type_t) + sizeof(int) * 3 + sizeof(SerialPacket::Metadata)
 
 void serialize(SerialPacket* const, void*);
 void deserialize(SerialPacket* const, void*);

common/network/serial_packet.hpp

@@ -27,6 +27,7 @@
 
 #include "SDL/SDL_net.h"
 
+#define NETWORK_VERSION 20140426
 #define PACKET_STRING_SIZE 100
 
 #pragma pack(push, 0)
@@ -49,23 +50,23 @@ union SerialPacket {
 		JOIN_REQUEST = 5,
 		JOIN_RESPONSE = 6,
 
-		//disconnect from the server
-		DISCONNECT = 7,
-
 		//mass update
-		SYNCHRONIZE = 8,
+		SYNCHRONIZE = 7,
+
+		//disconnect from the server
+		DISCONNECT = 8,
 
 		//shut down the server
 		SHUTDOWN = 9,
 
-		//Player movement, etc.
-		PLAYER_NEW = 10,
-		PLAYER_DELETE = 11,
-		PLAYER_UPDATE = 12,
-
 		//map data
-		REGION_REQUEST = 13,
+		REGION_REQUEST = 10,
-		REGION_CONTENT = 14,
+		REGION_CONTENT = 11,
+
+		//Player movement, etc.
+		PLAYER_NEW = 12,
+		PLAYER_DELETE = 13,
+		PLAYER_UPDATE = 14,
 
 		//TODO: combat packets
 	};
@@ -79,42 +80,38 @@ union SerialPacket {
 	//information about the server
 	struct ServerInformation {
 		Metadata meta;
-		//TODO: version info
+		int networkVersion;
 		char name[PACKET_STRING_SIZE];
 		int playerCount;
-
-		//map format
-		int regionWidth;
-		int regionHeight;
-		int regionDepth;
 	}serverInfo;
 
 	//information about the client
-	//TODO: login credentials
 	struct ClientInformation {
 		Metadata meta;
-		int index;
+		int clientIndex;
+		int playerIndex;
+		char player[PACKET_STRING_SIZE];
+		char handle[PACKET_STRING_SIZE];
+		char avatar[PACKET_STRING_SIZE];
 	}clientInfo;
 
+	//map data
+	struct RegionInformation {
+		Metadata meta;
+		int mapIndex;
+		int x, y;
+		Region* region;
+	}regionInfo;
+
 	//information about a player
 	struct PlayerInformation {
 		Metadata meta;
 		int clientIndex;
 		int playerIndex;
-		//TODO: should move handle/avatar into clientInfo; these might actually do better during the login system
-		char handle[PACKET_STRING_SIZE];
-		char avatar[PACKET_STRING_SIZE];
 		Vector2 position;
 		Vector2 motion;
 	}playerInfo;
 
-	//map data
-	struct RegionInformation {
-		Metadata meta;
-		int x, y;
-		Region* region;
-	}regionInfo;
-
 	//defaults
 	SerialPacket() {
 		meta.type = Type::NONE;