I've adjusted the naming conventions for the serial code (read more)

It looks like this whole branch is fucking useless, considering that I'll
need to reimplement that massive switch statement again just to determine
which overwritten method to use. I might as well not have bothered.

common/network/packet_types/character_packet.cpp

@@ -24,49 +24,49 @@
 #include "serial_utility.hpp"
 
 void CharacterPacket::Serialize(void* buffer) {
-	serialize(&buffer, &type, sizeof(SerialPacketType));
+	serializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
 	//identify the character
-	serialize(&buffer, &characterIndex, sizeof(int));
+	serializeCopy(&buffer, &characterIndex, sizeof(int));
-	serialize(&buffer, handle, PACKET_STRING_SIZE);
+	serializeCopy(&buffer, handle, PACKET_STRING_SIZE);
-	serialize(&buffer, avatar, PACKET_STRING_SIZE);
+	serializeCopy(&buffer, avatar, PACKET_STRING_SIZE);
 
 	//the owner
-	serialize(&buffer, &accountIndex, sizeof(int));
+	serializeCopy(&buffer, &accountIndex, sizeof(int));
 
 	//location
-	serialize(&buffer, &roomIndex, sizeof(int));
+	serializeCopy(&buffer, &roomIndex, sizeof(int));
-	serialize(&buffer, &origin.x, sizeof(double));
+	serializeCopy(&buffer, &origin.x, sizeof(double));
-	serialize(&buffer, &origin.y, sizeof(double));
+	serializeCopy(&buffer, &origin.y, sizeof(double));
-	serialize(&buffer, &motion.x, sizeof(double));
+	serializeCopy(&buffer, &motion.x, sizeof(double));
-	serialize(&buffer, &motion.y, sizeof(double));
+	serializeCopy(&buffer, &motion.y, sizeof(double));
 
 	//stats structure
-	serializeStatistics(&buffer, &stats);
+	serializeCopyStatistics(&buffer, &stats);
 
 	//TODO: gameplay components: equipment, items, buffs, debuffs
 }
 
 void CharacterPacket::Deserialize(void* buffer) {
-	deserialize(&buffer, &type, sizeof(SerialPacketType));
+	deserializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
 	//identify the character
-	deserialize(&buffer, &characterIndex, sizeof(int));
+	deserializeCopy(&buffer, &characterIndex, sizeof(int));
-	deserialize(&buffer, handle, PACKET_STRING_SIZE);
+	deserializeCopy(&buffer, handle, PACKET_STRING_SIZE);
-	deserialize(&buffer, avatar, PACKET_STRING_SIZE);
+	deserializeCopy(&buffer, avatar, PACKET_STRING_SIZE);
 
 	//the owner
-	deserialize(&buffer, &accountIndex, sizeof(int));
+	deserializeCopy(&buffer, &accountIndex, sizeof(int));
 
 	//location
-	deserialize(&buffer, &roomIndex, sizeof(int));
+	deserializeCopy(&buffer, &roomIndex, sizeof(int));
-	deserialize(&buffer, &origin.x, sizeof(double));
+	deserializeCopy(&buffer, &origin.x, sizeof(double));
-	deserialize(&buffer, &origin.y, sizeof(double));
+	deserializeCopy(&buffer, &origin.y, sizeof(double));
-	deserialize(&buffer, &motion.x, sizeof(double));
+	deserializeCopy(&buffer, &motion.x, sizeof(double));
-	deserialize(&buffer, &motion.y, sizeof(double));
+	deserializeCopy(&buffer, &motion.y, sizeof(double));
 
 	//stats structure
-	deserializeStatistics(&buffer, &stats);
+	deserializeCopyStatistics(&buffer, &stats);
 
 	//TODO: gameplay components: equipment, items, buffs, debuffs
 }

common/network/packet_types/client_packet.cpp

@@ -24,17 +24,17 @@
 #include "serial_utility.hpp"
 
 void ClientPacket::Serialize(void* buffer) {
-	serialize(&buffer, &type, sizeof(SerialPacketType));
+	serializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
-	serialize(&buffer, &clientIndex, sizeof(int));
+	serializeCopy(&buffer, &clientIndex, sizeof(int));
-	serialize(&buffer, &accountIndex, sizeof(int));
+	serializeCopy(&buffer, &accountIndex, sizeof(int));
-	serialize(&buffer, username, PACKET_STRING_SIZE);
+	serializeCopy(&buffer, username, PACKET_STRING_SIZE);
 }
 
 void ClientPacket::Deserialize(void* buffer) {
-	deserialize(&buffer, &type, sizeof(SerialPacketType));
+	deserializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
-	deserialize(&buffer, &clientIndex, sizeof(int));
+	deserializeCopy(&buffer, &clientIndex, sizeof(int));
-	deserialize(&buffer, &accountIndex, sizeof(int));
+	deserializeCopy(&buffer, &accountIndex, sizeof(int));
-	deserialize(&buffer, username, PACKET_STRING_SIZE);
+	deserializeCopy(&buffer, username, PACKET_STRING_SIZE);
 }

common/network/packet_types/region_packet.cpp

@@ -24,12 +24,12 @@
 #include "serial_utility.hpp"
 
 void RegionPacket::Serialize(void* buffer) {
-	serialize(&buffer, &type, sizeof(SerialPacketType));
+	serializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
 	//format
-	serialize(&buffer, &roomIndex, sizeof(int));
+	serializeCopy(&buffer, &roomIndex, sizeof(int));
-	serialize(&buffer, &x, sizeof(int));
+	serializeCopy(&buffer, &x, sizeof(int));
-	serialize(&buffer, &y, sizeof(int));
+	serializeCopy(&buffer, &y, sizeof(int));
 
 	if (type != SerialPacketType::REGION_CONTENT) {
 		return;
@@ -46,16 +46,16 @@ void RegionPacket::Serialize(void* buffer) {
 	}
 
 	//solids
-	serialize(&buffer, region->GetSolidBitset(), REGION_SOLID_FOOTPRINT);
+	serializeCopy(&buffer, region->GetSolidBitset(), REGION_SOLID_FOOTPRINT);
 }
 
 void RegionPacket::Deserialize(void* buffer) {
-	deserialize(&buffer, &type, sizeof(SerialPacketType));
+	deserializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
 	//format
-	deserialize(&buffer, &roomIndex, sizeof(int));
+	deserializeCopy(&buffer, &roomIndex, sizeof(int));
-	deserialize(&buffer, &x, sizeof(int));
+	deserializeCopy(&buffer, &x, sizeof(int));
-	deserialize(&buffer, &y, sizeof(int));
+	deserializeCopy(&buffer, &y, sizeof(int));
 
 	if (type != SerialPacketType::REGION_CONTENT) {
 		return;
@@ -75,5 +75,5 @@ void RegionPacket::Deserialize(void* buffer) {
 	}
 
 	//solids
-	deserialize(&buffer, region->GetSolidBitset(), REGION_SOLID_FOOTPRINT);
+	deserializeCopy(&buffer, region->GetSolidBitset(), REGION_SOLID_FOOTPRINT);
 }

common/network/packet_types/serial_packet_base.cpp

@@ -21,3 +21,4 @@
 */
 #include "serial_packet_base.hpp"
 
+//NOTE: This is a sanity check

common/network/packet_types/server_packet.cpp

@@ -24,19 +24,19 @@
 #include "serial_utility.hpp"
 
 void ServerPacket::Serialize(void* buffer) {
-	serialize(&buffer, &type, sizeof(SerialPacketType));
+	serializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
 	//identify the server
-	serialize(&buffer, name, PACKET_STRING_SIZE);
+	serializeCopy(&buffer, name, PACKET_STRING_SIZE);
-	serialize(&buffer, &playerCount, sizeof(int));
+	serializeCopy(&buffer, &playerCount, sizeof(int));
-	serialize(&buffer, &version, sizeof(int));
+	serializeCopy(&buffer, &version, sizeof(int));
 }
 
 void ServerPacket::Deserialize(void* buffer) {
-	deserialize(&buffer, &type, sizeof(SerialPacketType));
+	deserializeCopy(&buffer, &type, sizeof(SerialPacketType));
 
 	//identify the server
-	deserialize(&buffer, name, PACKET_STRING_SIZE);
+	deserializeCopy(&buffer, name, PACKET_STRING_SIZE);
-	deserialize(&buffer, &playerCount, sizeof(int));
+	deserializeCopy(&buffer, &playerCount, sizeof(int));
-	deserialize(&buffer, &version, sizeof(int));
+	deserializeCopy(&buffer, &version, sizeof(int));
 }

common/network/serial_utility.cpp

@@ -21,54 +21,72 @@
 */
 #include "serial_utility.hpp"
 
+#include "serial_packet_type.hpp"
+
 #include <cstring>
 
-void serialize(void** bufferHead, void* data, int size) {
+void serializePacket(SerialPacketBase* packet, void* data) {
+	switch(packet->GetType()) {
+		//define all packet types
+	}
+}
+
+void deserializePacket(SerialPacketBase* packet, void* data) {
+	//get the type
+	SerialPacketType type;
+	memcpy(&type, data, sizeof(SerialPacketType));
+
+	switch(type) {
+		//define all extra types
+	}
+}
+
+void serializeCopy(void** bufferHead, void* data, int size) {
 	memcpy(*bufferHead, data, size);
 	(*bufferHead) = static_cast<void*>(static_cast<char*>(*bufferHead) + size);
 }
 
-void deserialize(void** bufferHead, void* data, int size) {
+void deserializeCopy(void** bufferHead, void* data, int size) {
 	memcpy(data, *bufferHead, size);
 	(*bufferHead) = static_cast<void*>(static_cast<char*>(*bufferHead) + size);
 }
 
-void serializeStatistics(void** bufferHead, Statistics* stats) {
+void serializeCopyStatistics(void** bufferHead, Statistics* stats) {
 	//integers
-	serialize(bufferHead, &stats->level, sizeof(int));
+	serializeCopy(bufferHead, &stats->level, sizeof(int));
-	serialize(bufferHead, &stats->exp, sizeof(int));
+	serializeCopy(bufferHead, &stats->exp, sizeof(int));
-	serialize(bufferHead, &stats->maxHP, sizeof(int));
+	serializeCopy(bufferHead, &stats->maxHP, sizeof(int));
-	serialize(bufferHead, &stats->health, sizeof(int));
+	serializeCopy(bufferHead, &stats->health, sizeof(int));
-	serialize(bufferHead, &stats->maxMP, sizeof(int));
+	serializeCopy(bufferHead, &stats->maxMP, sizeof(int));
-	serialize(bufferHead, &stats->mana, sizeof(int));
+	serializeCopy(bufferHead, &stats->mana, sizeof(int));
-	serialize(bufferHead, &stats->attack, sizeof(int));
+	serializeCopy(bufferHead, &stats->attack, sizeof(int));
-	serialize(bufferHead, &stats->defence, sizeof(int));
+	serializeCopy(bufferHead, &stats->defence, sizeof(int));
-	serialize(bufferHead, &stats->intelligence, sizeof(int));
+	serializeCopy(bufferHead, &stats->intelligence, sizeof(int));
-	serialize(bufferHead, &stats->resistance, sizeof(int));
+	serializeCopy(bufferHead, &stats->resistance, sizeof(int));
-	serialize(bufferHead, &stats->speed, sizeof(int));
+	serializeCopy(bufferHead, &stats->speed, sizeof(int));
 
 	//floats
-	serialize(bufferHead, &stats->accuracy, sizeof(float));
+	serializeCopy(bufferHead, &stats->accuracy, sizeof(float));
-	serialize(bufferHead, &stats->evasion, sizeof(float));
+	serializeCopy(bufferHead, &stats->evasion, sizeof(float));
-	serialize(bufferHead, &stats->luck, sizeof(float));
+	serializeCopy(bufferHead, &stats->luck, sizeof(float));
 }
 
-void deserializeStatistics(void** bufferHead, Statistics* stats) {
+void deserializeCopyStatistics(void** bufferHead, Statistics* stats) {
 	//integers
-	deserialize(bufferHead, &stats->level, sizeof(int));
+	deserializeCopy(bufferHead, &stats->level, sizeof(int));
-	deserialize(bufferHead, &stats->exp, sizeof(int));
+	deserializeCopy(bufferHead, &stats->exp, sizeof(int));
-	deserialize(bufferHead, &stats->maxHP, sizeof(int));
+	deserializeCopy(bufferHead, &stats->maxHP, sizeof(int));
-	deserialize(bufferHead, &stats->health, sizeof(int));
+	deserializeCopy(bufferHead, &stats->health, sizeof(int));
-	deserialize(bufferHead, &stats->maxMP, sizeof(int));
+	deserializeCopy(bufferHead, &stats->maxMP, sizeof(int));
-	deserialize(bufferHead, &stats->mana, sizeof(int));
+	deserializeCopy(bufferHead, &stats->mana, sizeof(int));
-	deserialize(bufferHead, &stats->attack, sizeof(int));
+	deserializeCopy(bufferHead, &stats->attack, sizeof(int));
-	deserialize(bufferHead, &stats->defence, sizeof(int));
+	deserializeCopy(bufferHead, &stats->defence, sizeof(int));
-	deserialize(bufferHead, &stats->intelligence, sizeof(int));
+	deserializeCopy(bufferHead, &stats->intelligence, sizeof(int));
-	deserialize(bufferHead, &stats->resistance, sizeof(int));
+	deserializeCopy(bufferHead, &stats->resistance, sizeof(int));
-	deserialize(bufferHead, &stats->speed, sizeof(int));
+	deserializeCopy(bufferHead, &stats->speed, sizeof(int));
 
 	//floats
-	deserialize(bufferHead, &stats->accuracy, sizeof(float));
+	deserializeCopy(bufferHead, &stats->accuracy, sizeof(float));
-	deserialize(bufferHead, &stats->evasion, sizeof(float));
+	deserializeCopy(bufferHead, &stats->evasion, sizeof(float));
-	deserialize(bufferHead, &stats->luck, sizeof(float));
+	deserializeCopy(bufferHead, &stats->luck, sizeof(float));
 }

common/network/serial_utility.hpp

@@ -19,16 +19,24 @@
  * 3. This notice may not be removed or altered from any source
  * distribution.
 */
-#ifndef SERIALIZEUTIL_HPP_
+#ifndef SERIALIZEUTILITY_HPP_
-#define SERIALIZEUTIL_HPP_
+#define SERIALIZEUTILITY_HPP_
+
+#include "serial_packet_base.hpp"
 
 #include "statistics.hpp"
 
-//raw memcpy
+//NOTE: The naming conventions here are fucking terrible
-void serialize(void** bufferHead, void* data, int size);
-void deserialize(void** bufferHead, void* data, int size);
 
-void serializeStatistics(void** bufferHead, Statistics* stats);
+//BUGFIX: There's really no way to escape this :(
-void deserializeStatistics(void** bufferHead, Statistics* stats);
+void serializePacket(SerialPacketBase* packet, void* data);
+void deserializePacket(SerialPacketBase* packet, void* data);
+
+//raw memcpy
+void serializeCopy(void** bufferHead, void* data, int size);
+void deserializeCopy(void** bufferHead, void* data, int size);
+
+void serializeCopyStatistics(void** bufferHead, Statistics* stats);
+void deserializeCopyStatistics(void** bufferHead, Statistics* stats);
 
 #endif

common/network/udp_network_utility.cpp

@@ -21,6 +21,8 @@
 */
 #include "udp_network_utility.hpp"
 
+#include "serial_utility.hpp"
+
 #include <stdexcept>
 
 //BUGFIX: memset() is used before sending a packet to remove old data; you don't want to send sensitive data over the network
@@ -164,7 +166,7 @@ int UDPNetworkUtility::SendTo(const char* ip, int port, SerialPacket* serialPack
 
 int UDPNetworkUtility::SendTo(IPaddress* add, SerialPacket* serialPacket) {
 	memset(packet->data, 0, packet->maxlen);
-	serialPacket->Serialize(packet->data);
+	serializePacket(serialPacket, packet->data);
 	packet->len = PACKET_BUFFER_SIZE;
 	packet->address = *add;
 
@@ -179,7 +181,7 @@ int UDPNetworkUtility::SendTo(IPaddress* add, SerialPacket* serialPacket) {
 
 int UDPNetworkUtility::SendTo(int channel, SerialPacket* serialPacket) {
 	memset(packet->data, 0, packet->maxlen);
-	serialPacket->Serialize(packet->data);
+	serializePacket(serialPacket, packet->data);
 	packet->len = PACKET_BUFFER_SIZE;
 
 	int ret = SDLNet_UDP_Send(socket, channel, packet);
@@ -193,7 +195,7 @@ int UDPNetworkUtility::SendTo(int channel, SerialPacket* serialPacket) {
 
 int UDPNetworkUtility::SendToAllChannels(SerialPacket* serialPacket) {
 	memset(packet->data, 0, packet->maxlen);
-	serialPacket->Serialize(packet->data);
+	serializePacket(serialPacket, packet->data);
 	packet->len = PACKET_BUFFER_SIZE;
 
 	int sent = 0;
@@ -213,7 +215,7 @@ int UDPNetworkUtility::Receive(SerialPacket* serialPacket) {
 	int ret = SDLNet_UDP_Recv(socket, packet);
 	if (ret > 0) {
 		//BUG: This simply fails
-		serialPacket->Deserialize(packet->data);
+		deserializePacket(serialPacket, packet->data);
 		serialPacket->srcAddress = packet->address;
 	}