EQ2EMu/EQ2/source/common/PacketStruct.h

/*
	EQ2Emulator:  Everquest II Server Emulator
	Copyright (C) 2007  EQ2EMulator Development Team (http://www.eq2emulator.net)

	This file is part of EQ2Emulator.

	EQ2Emulator is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	EQ2Emulator is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with EQ2Emulator.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __EQ2_PACKETSTRUCT__
#define __EQ2_PACKETSTRUCT__
#include "types.h"
#include "DataBuffer.h"
#include "opcodemgr.h"

#include <vector>
#include <map>
#ifdef WORLD
class Item;
class Player;
#endif
extern map<int16, OpcodeManager*>EQOpcodeManager;
using namespace std;

#define DATA_STRUCT_NONE				0
#define DATA_STRUCT_INT8				1
#define DATA_STRUCT_INT16				2
#define DATA_STRUCT_INT32				3
#define DATA_STRUCT_INT64				4
#define DATA_STRUCT_FLOAT				5
#define DATA_STRUCT_DOUBLE				6
#define DATA_STRUCT_COLOR				7
#define DATA_STRUCT_SINT8				8
#define DATA_STRUCT_SINT16				9
#define DATA_STRUCT_SINT32				10
#define DATA_STRUCT_CHAR				11
#define DATA_STRUCT_EQ2_8BIT_STRING		12
#define DATA_STRUCT_EQ2_16BIT_STRING	13
#define DATA_STRUCT_EQ2_32BIT_STRING	14
#define DATA_STRUCT_EQUIPMENT			15
#define DATA_STRUCT_ARRAY				16
#define DATA_STRUCT_ITEM				17
#define DATA_STRUCT_SINT64				18

class DataStruct {
public:
	DataStruct();
	DataStruct(DataStruct* data_struct);
	DataStruct(const char* new_name, int8 new_type, int32 new_length = 1, int8 new_type2 = DATA_STRUCT_NONE);
	DataStruct(const char* new_name, const char* new_type, int32 new_length = 1, const char* new_type2 = 0);
	DataStruct(const char* new_name, int32 new_length);
	void	SetType(const char* new_type, int8* output_type);
	void	SetType(int8 new_type);
	void	SetName(const char* new_name);
	void	SetLength(int32 new_length);
	void	SetArraySizeVariable(const char* new_name);
	void	SetDefaultValue(int8 new_val);
	void	SetMaxArraySize(int8 size);
	void	SetOversized(int8 val);
	void	SetOversizedByte(int8 val);
	void	SetAddToStruct(bool val);
	void	SetAddType(int8 new_type);
	void	SetPackedIndex(int8 new_index);
	void	SetPackedSizeVariable(const char* new_name);
	void	SetPacked(const char* value);
	void	SetItemSize(int32 val);
	void	SetIfSetVariable(const char* variable);
	void	SetIfNotSetVariable(const char* variable);
	void	SetIfEqualsVariable(const char* variable);
	void	SetIfNotEqualsVariable(const char* variable);
	void	SetIfFlagSetVariable(const char* variable);
	void	SetIfFlagNotSetVariable(const char* variable);
	void	SetIsSet(bool val);
	void	SetIsOptional(bool val);

	int8	GetPackedIndex();
	const char* GetPackedSizeVariable();
	const char* GetArraySizeVariable();
	int8	GetDefaultValue();
	int8	GetOversized();
	int8	GetOversizedByte();
	int8	GetMaxArraySize();
	int8	GetType();
	int8	GetType2();
	const char* GetName();
	string	GetStringName();
	int32	GetLength();
	bool	AddToStruct();
	int8	GetAddType();
	int32	GetItemSize();
	bool	GetIfSet();
	const char* GetIfSetVariable();
	bool	GetIfNotSet();
	const char* GetIfNotSetVariable();
	bool	GetIfEquals();
	const char* GetIfEqualsVariable();
	bool	GetIfNotEquals();
	const char* GetIfNotEqualsVariable();
	bool	GetIfFlagSet();
	const char* GetIfFlagSetVariable();
	bool	GetIfFlagNotSet();
	const char* GetIfFlagNotSetVariable();
	bool	IsSet();
	bool	IsOptional();
	int32 GetDataSizeInBytes();

private:
	bool	is_set;
	bool	if_not_set;
	bool	optional;
	bool	if_set;
	bool	if_not_equals;
	bool	if_equals;
	bool	if_flag_set;
	bool	if_flag_not_set;
	string	if_flag_not_set_variable;
	string	if_flag_set_variable;
	string	if_not_equals_variable;
	string	if_equals_variable;
	string	if_not_set_variable;
	string	if_set_variable;
	int8	oversized;
	int8	oversized_byte;
	bool	add;
	int8	addType;
	int8	maxArraySize;
	string	array_size_variable;
	string	name;
	int8	type;
	int8	default_value;
	int8	type2;
	int32	length;
	int32	item_size;
};
class PacketStruct : public DataBuffer {
public:
	PacketStruct();
	PacketStruct(PacketStruct* packet, bool sub);
	PacketStruct(PacketStruct* packet, int16 in_client_version);
	~PacketStruct();
	void add(DataStruct* data);
	void reAddAll(int32 length);
	void add(PacketStruct* packet_struct);
	void addPacketArrays(PacketStruct* packet);
	void deletePacketArrays(PacketStruct* packet);
	void deleteDataStructs(vector<DataStruct*>* data_structs);
	void setSmallStringByName(const char* name, const char* text, int32 index = 0);
	void setMediumStringByName(const char* name, const char* text, int32 index = 0);
	void setLargeStringByName(const char* name, const char* text, int32 index = 0);
	void setSmallString(DataStruct* data_struct, const char* text, int32 index = 0);
	void setMediumString(DataStruct* data_struct, const char* text, int32 index = 0);
	void setLargeString(DataStruct* data_struct, const char* text, int32 index = 0);
	void renameSubstructArray(const char* substruct, int32 index);
	template<class Data> void setSubstructSubstructDataByName(const char* substruct_name1, const char* substruct_name2, const char* name, Data data, int32 substruct_index1 = 0, int32 substruct_index2 = 0, int32 index = 0) {
		char tmp[15] = { 0 };
		sprintf(tmp, "_%i_%i", substruct_index1, substruct_index2);
		string name2 = string(substruct_name1).append("_").append(substruct_name2).append("_").append(name).append(tmp);
		setData(findStruct(name2.c_str(), index), data, index);
	}
	template<class Data> void setSubstructDataByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", substruct_index);
		string name2 = string(substruct_name).append("_").append(name).append(tmp);
		setData(findStruct(name2.c_str(), index), data, index);
	}
	template<class Data> void setSubstructColorByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", substruct_index);
		string name2 = string(substruct_name).append("_").append(name).append(tmp);
		setColor(findStruct(name2.c_str(), index), data, index);
	}
	template<class Data> void setSubstructArrayDataByName(const char* substruct_name, const char* name, Data data, int32 index = 0, int32 substruct_index = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", substruct_index);
		string name2 = string(substruct_name).append("_").append(name).append(tmp);
		setData(findStruct(name2.c_str(), substruct_index, index), data, index);
	}
	template<class Data> void setSubstructArrayColorByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", substruct_index);
		string name2 = string(substruct_name).append("_").append(name).append(tmp);
		setColor(findStruct(name2.c_str(), index, substruct_index), data, index);
	}
	template<class Data> void setDataByName(const char* name, Data data, int32 index = 0, bool use_second_type = false) {
		setData(findStruct(name, index), data, index, use_second_type);
	}
	template<class Data> void setDataByName(const char* name, Data* data, int32 index = 0, bool use_second_type = false) {
		setData(findStruct(name, index), data, index, use_second_type);
	}
	template<class Data> void setSubArrayDataByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0, int32 index3 = 0) {
		char tmp[20] = { 0 };
		sprintf(tmp, "%i_%i", index1, index2);
		string name2 = string(name).append(tmp);
		setData(findStruct(name2.c_str(), index2, index3), data, index3);
	}
	template<class Data> void setArrayDataByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0, bool use_second_type = false) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", index1);
		string name2 = string(name).append(tmp);
		setData(findStruct(name2.c_str(), index1, index2), data, index2, use_second_type);
	}
	void setArrayAddToPacketByName(const char* name, bool new_val, int32 index1 = 0, int32 index2 = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", index1);
		string name2 = string(name).append(tmp);
		DataStruct* data = findStruct(name2.c_str(), index2);
		if (data)
			data->SetAddToStruct(new_val);
	}
	void setAddToPacketByName(const char* name, bool new_val, int32 index = 0) {
		DataStruct* data = findStruct(name, index);
		if (data)
			data->SetAddToStruct(new_val);
	}
	void setAddTypePacketByName(const char* name, int8 new_val, int32 index = 0) {
		DataStruct* data = findStruct(name, index);
		if (data)
			data->SetAddType(new_val);
	}
	const char* GetOpcodeType();
	bool	IsSubPacket();
	void	IsSubPacket(bool new_val);
	int32	GetSubPacketSize();
	void	SetSubPacketSize(int32 new_size);
	void	SetOpcodeType(const char* opcodeType);
	int32	GetArraySizeByName(const char* name, int32 index);
	int32	GetArraySize(DataStruct* data_struct, int32 index);
	int32	GetArraySize(const char* name, int32 index);
	void	LoadFromPacketStruct(PacketStruct* packet, char* substruct_name = 0);
	bool	GetVariableIsSet(const char* name);
	bool	GetVariableIsNotSet(const char* name);

	int8	getType_int8_ByName(const char* name, int32 index = 0, bool force = false);
	int16	getType_int16_ByName(const char* name, int32 index = 0, bool force = false);
	int32	getType_int32_ByName(const char* name, int32 index = 0, bool force = false);
	int64	getType_int64_ByName(const char* name, int32 index = 0, bool force = false);
	sint8	getType_sint8_ByName(const char* name, int32 index = 0, bool force = false);
	sint16	getType_sint16_ByName(const char* name, int32 index = 0, bool force = false);
	sint32	getType_sint32_ByName(const char* name, int32 index = 0, bool force = false);
	sint64	getType_sint64_ByName(const char* name, int32 index = 0, bool force = false);
	float	getType_float_ByName(const char* name, int32 index = 0, bool force = false);
	double	getType_double_ByName(const char* name, int32 index = 0, bool force = false);
	char	getType_char_ByName(const char* name, int32 index = 0, bool force = false);
	EQ2_8BitString	getType_EQ2_8BitString_ByName(const char* name, int32 index = 0, bool force = false);
	EQ2_16BitString	getType_EQ2_16BitString_ByName(const char* name, int32 index = 0, bool force = false);
	EQ2_32BitString	getType_EQ2_32BitString_ByName(const char* name, int32 index = 0, bool force = false);
	EQ2_Color getType_EQ2_Color_ByName(const char* name, int32 index = 0, bool force = false);
	EQ2_EquipmentItem getType_EQ2_EquipmentItem_ByName(const char* name, int32 index = 0, bool force = false);

	int8	getType_int8(DataStruct* data_struct, int32 index = 0, bool force = false);
	int16	getType_int16(DataStruct* data_struct, int32 index = 0, bool force = false);
	int32	getType_int32(DataStruct* data_struct, int32 index = 0, bool force = false);
	int64	getType_int64(DataStruct* data_struct, int32 index = 0, bool force = false);
	sint8	getType_sint8(DataStruct* data_struct, int32 index = 0, bool force = false);
	sint16	getType_sint16(DataStruct* data_struct, int32 index = 0, bool force = false);
	sint32	getType_sint32(DataStruct* data_struct, int32 index = 0, bool force = false);
	sint64	getType_sint64(DataStruct* data_struct, int32 index = 0, bool force = false);
	float	getType_float(DataStruct* data_struct, int32 index = 0, bool force = false);
	double	getType_double(DataStruct* data_struct, int32 index = 0, bool force = false);
	char	getType_char(DataStruct* data_struct, int32 index = 0, bool force = false);
	EQ2_8BitString	getType_EQ2_8BitString(DataStruct* data_struct, int32 index = 0, bool force = false);
	EQ2_16BitString	getType_EQ2_16BitString(DataStruct* data_struct, int32 index = 0, bool force = false);
	EQ2_32BitString	getType_EQ2_32BitString(DataStruct* data_struct, int32 index = 0, bool force = false);
	EQ2_Color getType_EQ2_Color(DataStruct* data_struct, int32 index = 0, bool force = false);
	EQ2_EquipmentItem getType_EQ2_EquipmentItem(DataStruct* data_struct, int32 index = 0, bool force = false);

	void setDataType(DataStruct* data_struct, char data, int32 index);
	void setDataType(DataStruct* data_struct, int8 data, int32 index);
	void setDataType(DataStruct* data_struct, int16 data, int32 index);
	void setDataType(DataStruct* data_struct, int32 data, int32 index);
	void setDataType(DataStruct* data_struct, int64 data, int32 index);
	void setDataType(DataStruct* data_struct, sint8 data, int32 index);
	void setDataType(DataStruct* data_struct, sint16 data, int32 index);
	void setDataType(DataStruct* data_struct, sint32 data, int32 index);
	void setDataType(DataStruct* data_struct, sint64 data, int32 index);
	void setDataType(DataStruct* data_struct, float data, int32 index);
	void setDataType(DataStruct* data_struct, double data, int32 index);
	void setData(DataStruct* data_struct, EQ2_8BitString* input_string, int32 index, bool use_second_type = false);
	void setData(DataStruct* data_struct, EQ2_16BitString* input_string, int32 index, bool use_second_type = false);
	void setData(DataStruct* data_struct, EQ2_32BitString* input_string, int32 index, bool use_second_type = false);

	template<class Data> void setData(DataStruct* data_struct, Data* data, int32 index, bool use_second_type = false) {
		if (!data_struct)
			return;
		data_struct->SetIsOptional(false);
		int8 type_to_use = (use_second_type) ? data_struct->GetType2() : data_struct->GetType();
		if (type_to_use >= DATA_STRUCT_EQ2_8BIT_STRING && type_to_use <= DATA_STRUCT_EQ2_32BIT_STRING) {
			if (type_to_use == DATA_STRUCT_EQ2_8BIT_STRING) {
				setSmallString(data_struct, data, index);
			}
			else if (type_to_use == DATA_STRUCT_EQ2_16BIT_STRING) {
				setMediumString(data_struct, data, index);
			}
			else {
				setLargeString(data_struct, data, index);
			}
		}
		else {
			if (data_struct && index == 0 && data_struct->GetLength() > 1) {
				if (type_to_use == DATA_STRUCT_CHAR) {
					for (int32 i = 0; data && i < data_struct->GetLength() && i < strlen(data); i++)
						setData(data_struct, data[i], i);
				}
				else {
					for (int32 i = 0; i < data_struct->GetLength(); i++)
						setData(data_struct, data[i], i);
				}
			}
			else
				setData(data_struct, *data, index);
		}
	}
	template<class Data> void setData(DataStruct* data_struct, Data data, int32 index, bool use_second_type = false) {
		if (data_struct && index < data_struct->GetLength()) {
			data_struct->SetIsOptional(false);
			int8 type_to_use = (use_second_type) ? data_struct->GetType2() : data_struct->GetType();
			if (use_second_type) {
				// Need to figure out why type2 always seems to be 205
				// since only items use type2 for now just hardcoded the value needed (BAD!!!)
				//type_to_use = DATA_STRUCT_SINT16; // 9;
				data_struct->SetType(type_to_use);
			}
			switch (type_to_use) {
			case DATA_STRUCT_INT8:
				setDataType(data_struct, (int8)data, index);
				break;
			case DATA_STRUCT_INT16:
				setDataType(data_struct, (int16)data, index);
				break;
			case DATA_STRUCT_INT32:
				setDataType(data_struct, (int32)data, index);
				break;
			case DATA_STRUCT_INT64:
				setDataType(data_struct, (int64)data, index);
				break;
			case DATA_STRUCT_SINT8:
				setDataType(data_struct, (sint8)data, index);
				break;
			case DATA_STRUCT_SINT16:
				setDataType(data_struct, (sint16)data, index);
				break;
			case DATA_STRUCT_SINT32:
				setDataType(data_struct, (sint32)data, index);
				break;
			case DATA_STRUCT_SINT64:
				setDataType(data_struct, (sint64)data, index);
				break;
			case DATA_STRUCT_CHAR:
				setDataType(data_struct, (char)data, index);
				break;
			case DATA_STRUCT_FLOAT:
				setDataType(data_struct, (float)data, index);
				break;
			case DATA_STRUCT_DOUBLE:
				setDataType(data_struct, (double)data, index);
				break;
			case DATA_STRUCT_COLOR:
				setColor(data_struct, *((EQ2_Color*)&data), index);
				break;
			case DATA_STRUCT_EQUIPMENT:
				setEquipmentByName(data_struct, *((EQ2_EquipmentItem*)&data), index);
				break;
			case DATA_STRUCT_ITEM:
				break;
			}
		}
	}

	template<class Data> void setSubArrayLengthByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", index1);
		string name2 = string(name).append(tmp);
		DataStruct* data_struct = findStruct(name2.c_str(), index2);
		setData(data_struct, data, index2);
		UpdateArrayByArrayLength(data_struct, index2, data);
	}
	template<class Data> void setArrayLengthByName(const char* name, Data data, int32 index = 0) {
		DataStruct* data_struct = findStruct(name, index);
		setData(data_struct, data, index);
		UpdateArrayByArrayLength(data_struct, index, data);
	}
	template<class Data> void setSubstructArrayLengthByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0) {
		char tmp[10] = { 0 };
		sprintf(tmp, "_%i", substruct_index);
		string name2 = string(substruct_name).append("_").append(name).append(tmp);

		DataStruct* data_struct = findStruct(name2.c_str(), index);
		setData(data_struct, data, index);
		UpdateArrayByArrayLength(data_struct, index, data);
	}
	void UpdateArrayByArrayLengthName(const char* name, int32 index, int32 size);
	void UpdateArrayByArrayLength(DataStruct* data_struct, int32 index, int32 size);
	bool StructLoadData(DataStruct* data_struct, void* data, int32 len, bool useType2 = false);
	bool LoadPacketData(uchar* data, int32 data_len);
	bool CheckFlagExists(const char* name);

	void setColorByName(const char* name, EQ2_Color* data, int32 index = 0) {
		if (data)
			setColorByName(name, data->red, data->green, data->blue, index);
	}
	void setColorByName(const char* name, EQ2_Color data, int32 index = 0) {
		setColorByName(name, data.red, data.green, data.blue, index);
	}
	void setColor(DataStruct* data_struct, EQ2_Color data, int32 index = 0) {
		if (data_struct) {
			EQ2_Color* ptr = (EQ2_Color*)struct_data[data_struct];
			ptr[index] = data;
		}
	}
	void setColorByName(const char* name, int8 red, int8 green, int8 blue, int32 index = 0) {
		setColor(findStruct(name, index), red, green, blue, index);
	}
	void setColor(DataStruct* data, int8 red, int8 green, int8 blue, int32 index);
	void setEquipmentByName(DataStruct* data_struct, EQ2_EquipmentItem data, int32 index = 0) {
		if (data_struct) {
			EQ2_EquipmentItem* ptr = (EQ2_EquipmentItem*)struct_data[data_struct];
			ptr[index] = data;
		}
	}
#ifdef WORLD	
	void setItem(DataStruct* ds, Item* item, Player* player, int32 index, sint8 offset = 0, bool loot_item = false);
	void setItemByName(const char* name, Item* item, Player* player, int32 index = 0, sint8 offset = 0, bool loot_item = false);
	void setItemArrayDataByName(const char* name, Item* item, Player* player, int32 index1 = 0, int32 index2 = 0, sint8 offset = 0, bool loot_item = false);
#endif
	void setEquipmentByName(const char* name, EQ2_EquipmentItem data, int32 index = 0) {
		setEquipmentByName(findStruct(name, index), data, index);
	}
	void setEquipmentByName(const char* name, EQ2_EquipmentItem* data, int32 size) {
		DataStruct* data_struct = findStruct(name, 0);
		if (data_struct) {
			for (int32 i = 0; i < size; i++)
				setEquipmentByName(data_struct, data[i], i);
		}
	}
	void setEquipmentByName(const char* name, int32 type, int8 c_red, int8 c_blue, int8 c_green, int8 h_red, int8 h_blue, int8 h_green, int32 index = 0) {
		setEquipment(findStruct(name, index), type, c_red, c_blue, c_green, h_red, h_blue, h_green, index);
	}
	void setEquipment(DataStruct* data, int16 type, int8 c_red, int8 c_blue, int8 c_green, int8 h_red, int8 h_blue, int8 h_green, int32 index);
	void remove(DataStruct* data);
	vector<DataStruct*>* getStructs() { return &structs; }
	DataStruct* findStruct(const char* name, int32 index);
	DataStruct* findStruct(const char* name, int32 index1, int32 index2);
	void remove(const char* name);
	void remove(int32 position);
	void serializePacket(bool clear = true);

	void AddSerializedData(DataStruct* data, int32 index = 0, string* datastring = 0);
	EQ2Packet* serialize();
	EQ2Packet* serializeCountPacket(int16 version, int8 offset = 0, uchar* orig_packet = 0, uchar* xor_packet = 0);
	string* serializeString();
	int32 GetVersion() { return version; }
	void SetVersion(int32 in_version) { version = in_version; }
	bool SetOpcode(const char* new_opcode);
	EmuOpcode GetOpcode() { return opcode; }
	int16 GetOpcodeValue(int16 client_version);
	const char* GetName() { return name.c_str(); }
	void SetName(const char* in_name) { name = string(in_name); }
	bool LoadedSuccessfully() { return loadedSuccessfully; }
	bool IsStringValueType(string in_name, int32 index);
	bool IsColorValueType(string in_name, int32 index);
	int32 GetTotalPacketSize();
	PacketStruct* GetPacketStructByName(const char* name);
	void* GetStructPointer(DataStruct* data_struct, bool erase = false);
	void PrintPacket();
	string GetSQLQuery(const char* table_name);
	vector<DataStruct*> GetDataStructs();
	void AddPackedData();
	void ResetData();
	void AddFlag(const char* name);

private:
	PacketStruct* parent;
	int32 sub_packet_size;
	string	opcode_type;
	bool sub_packet;
	bool loadedSuccessfully;
	string name;
	EmuOpcode opcode;
	int16 version;
	int16 client_version;
	vector<PacketStruct*> arrays;
	vector<string> flags;
	map<DataStruct*, void*> struct_data;
	map<int8, string> packed_data;
	map<string, DataStruct*> struct_map;
	vector<DataStruct*> structs;
	vector<DataStruct*> orig_structs;
	vector<PacketStruct*> orig_packets;
};
#endif