// Base class for all packets.
public class Packet
{
  // All of my special Write functions for the stream, here.
}


//-----------------------------------------------------------------

public class DataPacket : Packet
{
    DataPacket(uint32 Opcode)
    {
      // Write the opcode and sequence
    };
}

//------------------------------------------------------------------

public class PingPacket : Packet
{
    PingPacket();
}

//------------------------------------------------------------------

public class MovementPacket : DataPacket
{
   MovementPacket(float Speed, float Direction) : DataPacket(0xDEADCODE)
   {
     // Write the variables for movement, but skip writing the head for Data Packets.
    // The DataPacket class is already handling that.
   }
}

// "Traditional" method. Each packet opcode has its own format. This approach offers the // least amount of packet size overhead at the expense of more complicated parsing logic.// Also, the downside is, if the packet format were to change, then a number of changes// are required to keep the packing/unpacking in sync. Imagine if a DWORD were to be removed// above and not from below.{	cStreamBuilder builder;	builder.Append<WORD>(0); // size place holder	builder.Append<WORD>(1); // opcode	builder.Append<DWORD>(10);	builder.Append<DWORD>(100);	builder.Append<DWORD>(1000);	builder.Append<DWORD>(10000);	builder.Overwrite<WORD>(0, builder.GetStreamSize() - 4); // Set the final packet size	cStreamReader reader(builder.GetStreamData(), builder.GetStreamSize());	WORD size = reader.Read<WORD>();	WORD opcode = reader.Read<WORD>();	if(opcode == 1)	{		DWORD dw1 = reader.Read<DWORD>();		DWORD dw2 = reader.Read<DWORD>();		DWORD dw3 = reader.Read<DWORD>();		DWORD dw4 = reader.Read<DWORD>();	}}

// "Theoretical Method 1". One packet format for all opcodes. Trivial to process, but the // expense is an extra byte for each field in the packet + 1 extra byte. If N fields exist // in the packet to parse, packet size has an  extra N bytes + 1 of overhead. However, any // changes made in the packet format do not affect the parsing or packing logic.{	cStreamBuilder builder;	builder.Append<WORD>(0); // size place holder	builder.Append<WORD>(1); // opcode	builder.Append<BYTE>(4); builder.Append<DWORD>(100); // size -> data format	builder.Append<BYTE>(2); builder.Append<WORD>(10); // size -> data format	builder.Append<BYTE>(1); builder.Append<BYTE>(1); // size -> data format	builder.Append<BYTE>(0); // no more data	builder.Overwrite<WORD>(0, builder.GetStreamSize() - 4); // Set the final packet size	cStreamReader reader(builder.GetStreamData(), builder.GetStreamSize());	WORD size = reader.Read<WORD>();	WORD opcode = reader.Read<WORD>();	BYTE data[255] = {0}; // Let's only allow 255 bytes of data to exist in any field	BYTE count = 0;	int index = 0;	do	{		count = reader.Read<BYTE>();		reader.ReadArray(data, count);		// Based on the opcode, process data / count in accordance		// to the packet format. Perhaps a function that is called		// passing the data along to an object to be stored. Here is		// one example, not optimized or anything just to show a		// possibility.		if(opcode == 1)		{			// void SomeClass::AddField(int index, LPBYTE data, BYTE count);			AddField(index++, data, count);		}	}	while(count);}

// "Theoretical Method 2". This method combines the two previous methods, but// shifts where the overhead occurs as well as what changes during a format change.// The packet format itself only has to change in one place. Fields of the format// naturally have to be changed as needed where they are used. The overhead added// is added in terms of overall processing done and memory consumption, but no// additional packet overhead is added.SetupPacketFields();cStreamBuilder builder;{	cEntity sourcedata;	sourcedata.SetDecimal("Gold", 1000.35);	sourcedata.SetString("Name", "Drew");	sourcedata.SetNumber("NameLength", 4);	sourcedata.SetNumber("HP", 200);	builder = Pack(1, sourcedata); // Build a packet from a data object	cStreamReader reader(builder.GetStreamData(), builder.GetStreamSize());	WORD size = reader.Read<WORD>();	WORD opcode = reader.Read<WORD>();	cEntity thisObj;	Unpack(opcode, reader, thisObj);	// Based on the opcode, process the 'packet' object. Can use the	// GetNumber, GetString, and GetDecimal functions to retrieve data	// and then Set_XX functions to add data and even pass the data on	// to other functions as needed. Here is one example, not optimized 	// or anything just to show a possibility.	if(opcode == 1)	{		std::string name = thisObj.GetString("Name");		DWORD hp = thisObj.GetNumber("HP");		double gold = thisObj.GetDecimal("Gold");		printf("[%s][%i hp][%.0f gold]\n", name.c_str(), hp, gold);	}}

struct tPacketField{	BYTE type;	BYTE size;	std::string name;};std::map<WORD, std::vector<tPacketField> > packet_formats;void SetupPacketFields(){	// Hard coded here, but imagine loading from files/database	tPacketField format1;	format1.type = 0; // 0 - number	format1.size = 4; // number types can be 1-4 bytes	format1.name = "HP";	tPacketField format2;	format2.type = 1; // 1 - decimal	format2.size = 8; // all decimal types are doubles, 8 bytes	format2.name = "Gold";	tPacketField format3;	format3.type = 0; // 0 - number	format3.size = 1; // number types can be 1-4 bytes	format3.name = "NameLength";	tPacketField format4;	format4.type = 2; // 2 - string	format4.size = 0; // Size of 0 means use the previous entry's data, otherwise the # of bytes to read	format4.name = "Name";	packet_formats[1].push_back(format1);	packet_formats[1].push_back(format2);	packet_formats[1].push_back(format3);	packet_formats[1].push_back(format4);}void Unpack(const WORD opcode, cStreamReader & reader, cEntity & object){	// This code would be the same unpack code for all opcodes	std::map<WORD, std::vector<tPacketField> >::iterator itr = packet_formats.find(opcode);	if(itr != packet_formats.end())	{		std::vector<tPacketField> & formatVec = itr->second;		const size_t length = formatVec.size();		for(size_t x = 0; x < length; ++x)		{			tPacketField & field = formatVec[x];			// Number			if(field.type == 0)			{				long data = 0;				reader.ReadArray<BYTE>((LPBYTE)&data, field.size); // By program convention a # is 1-4 bytes only				object.SetNumber(field.name, data);			}			// Decimal			else if(field.type == 1)			{				double data = reader.Read<double>(); // By program convention a decimal is only a double, never a float				object.SetDecimal(field.name, data);			}			// String			else if(field.type == 2)			{				char data[256] = {0};				if(field.size)				{					reader.ReadArray(data, field.size);				}				else				{					long size = object.GetNumber(formatVec[x - 1].name);					reader.ReadArray(data, size);				}				object.SetString(field.name, data);			}		}	}}cStreamBuilder Pack(const WORD opcode, cEntity & sourcedata){	cStreamBuilder builder;	builder.Append<WORD>(0); // size place holder	builder.Append<WORD>(opcode); // opcode	std::map<WORD, std::vector<tPacketField> >::iterator itr = packet_formats.find(opcode);	// This code would be the same pack code for all opcodes	if(itr != packet_formats.end())	{		std::vector<tPacketField> & formatVec = itr->second;		const size_t length = formatVec.size();		for(size_t x = 0; x < length; ++x)		{			tPacketField & field = formatVec[x];			// Number			if(field.type == 0)			{				long data = sourcedata.GetNumber(field.name);				builder.AppendArray<BYTE>((LPBYTE)&data, field.size);			}			// Decimal			else if(field.type == 1)			{				double data = sourcedata.GetDecimal(field.name);				builder.Append<double>(data);			}			// String			else if(field.type == 2)			{				// Since we are mixing std::string with a C string format, we have a bit of extra work to take care of				std::string data = sourcedata.GetString(field.name);				if(field.size)				{					char * strdata = new char[field.size];					memset(strdata, 0, field.size);					int count = 0;					if(field.size > data.size())						count = data.size(); // make sure we don't read more data than there is					else						count = field.size; // we have more data than we need, truncate					memcpy(strdata, data.c_str(), count); // Just copy the data, '\0' is handled by other end					builder.AppendArray<const char>(strdata, field.size);				}				else				{					long size = sourcedata.GetNumber(formatVec[x - 1].name); // If everything is used correctly, this will be data.size()					builder.AppendArray<const char>(data.c_str(), size);				}			}		}	}	builder.Overwrite<WORD>(0, builder.GetStreamSize() - 4); // Set the final packet size	return builder;}

class cEntity{private:	CRITICAL_SECTION cs;	std::map<std::string, std::string> classStrings;	std::map<std::string, long> classNumbers;	std::map<std::string, double> classDecimals;public:	cEntity();	~cEntity();	// Clears all associated numbers with the class	void ClearNumbers();	// Clears all decimals numbers with the class	void ClearDecimals();	// Clears all associated strings with the class	void ClearStrings();	// Sets a key data pair. If the key exists, its previous contents are overwritten with the new data	void SetNumber(const std::string & key, long data);		// Removes the entry with the specific key. Returns true if the key was successfully	// removed or false if the key was not found	bool RemoveNumber(const std::string & key);	// Modifies an existing entry's data. If the key is not found a const char * std::exception is thrown	long ModifyNumber(const std::string & key, long data);	// Returns the number data associated with the key of name. Throws a const char * std::exception if the 	// name does not exist.	long GetNumber(const std::string & key);	// Sets a key data pair. If the key exists, its previous contents are overwritten with the new data	void SetDecimal(const std::string & key, double data);		// Removes the entry with the specific key. Returns true if the key was successfully	// removed or false if the key was not found	bool RemoveDecimal(const std::string & key);	// Modifies an existing entry's data. If the key is not found a const char * std::exception is thrown	double ModifyDecimal(const std::string & key, double data);		// Returns the decimal data associated with the key of name. Throws a const char * std::exception if the 	// name does not exist.	double GetDecimal(const std::string & key);	// Sets a key data pair. If the key exists, its previous contents are overwritten with the new data	void SetString(const std::string & key, std::string data);	// Removes the entry with the specific key. Returns true if the key was successfully	// removed or false if the key was not found	bool RemoveString(const std::string & key);	// Returns the string data associated with the key of name. Throws a std::string std::exception if the 	// name does not exist.	std::string GetString(const std::string & key);	// Saves the entity's data to a file. Any entries prefixed with TMP_ are not saved.	// If the file cannot be saved, false is returned, otherwise true indicates success.	bool Save(const std::string & filename);	// Loads data from a file. Any entries prefixed with TMP_ are not loaded. Returns	// false if the file could not be loaded or true on success.	bool Load(const std::string & filename);};