447 lines
15 KiB
C++
447 lines
15 KiB
C++
// Copyright (C) 2007 EQ2EMulator Development Team, GPL v3+
|
|
|
|
// Template data getter/setter functions for PacketStruct
|
|
|
|
// Template functions for setting generic data with conditional type handling
|
|
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 function for setting data by value with type conversion
|
|
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) {
|
|
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 functions for setting data by name
|
|
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);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::string(name).append(tmp);
|
|
setData(findStruct(name2.c_str(), index1, index2), data, index2, use_second_type);
|
|
}
|
|
|
|
template<class Data> void setSubArrayLengthByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0)
|
|
{
|
|
char tmp[10] = { 0 };
|
|
sprintf(tmp, "_%i", index1);
|
|
std::string name2 = std::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);
|
|
std::string name2 = std::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);
|
|
}
|
|
|
|
// Getter functions by name for all data types
|
|
int8 getType_int8_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_int8(data_struct, index, force);
|
|
}
|
|
|
|
int16 getType_int16_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_int16(data_struct, index, force);
|
|
}
|
|
|
|
int32 getType_int32_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_int32(data_struct, index, force);
|
|
}
|
|
|
|
int64 getType_int64_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_int64(data_struct, index, force);
|
|
}
|
|
|
|
sint8 getType_sint8_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_sint8(data_struct, index, force);
|
|
}
|
|
|
|
sint16 getType_sint16_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_sint16(data_struct, index, force);
|
|
}
|
|
|
|
sint32 getType_sint32_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_sint32(data_struct, index, force);
|
|
}
|
|
|
|
sint64 getType_sint64_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_sint64(data_struct, index, force);
|
|
}
|
|
|
|
float getType_float_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_float(data_struct, index, force);
|
|
}
|
|
|
|
double getType_double_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_double(data_struct, index, force);
|
|
}
|
|
|
|
char getType_char_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_char(data_struct, index, force);
|
|
}
|
|
|
|
EQ2_8BitString getType_EQ2_8BitString_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_EQ2_8BitString(data_struct, index, force);
|
|
}
|
|
|
|
EQ2_16BitString getType_EQ2_16BitString_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_EQ2_16BitString(data_struct, index, force);
|
|
}
|
|
|
|
EQ2_32BitString getType_EQ2_32BitString_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_EQ2_32BitString(data_struct, index, force);
|
|
}
|
|
|
|
EQ2_Color getType_EQ2_Color_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_EQ2_Color(data_struct, index, force);
|
|
}
|
|
|
|
EQ2_EquipmentItem getType_EQ2_EquipmentItem_ByName(const char* name, int32 index = 0, bool force = false)
|
|
{
|
|
DataStruct* data_struct = findStruct(name, index);
|
|
return getType_EQ2_EquipmentItem(data_struct, index, force);
|
|
}
|
|
|
|
// Getter functions by data structure for all data types
|
|
int8 getType_int8(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT8) || force)) {
|
|
int8* ptr = (int8*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int16 getType_int16(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT16) || force)) {
|
|
int16* ptr = (int16*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32 getType_int32(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT32) || force)) {
|
|
int32* ptr = (int32*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int64 getType_int64(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT64) || force)) {
|
|
int64* ptr = (int64*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sint8 getType_sint8(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT8) || force)) {
|
|
sint8* ptr = (sint8*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sint16 getType_sint16(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT16) || force)) {
|
|
sint16* ptr = (sint16*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sint32 getType_sint32(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT32) || force)) {
|
|
sint32* ptr = (sint32*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
sint64 getType_sint64(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT64) || force)) {
|
|
sint64* ptr = (sint64*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
float getType_float(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_FLOAT) || force)) {
|
|
float* ptr = (float*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
double getType_double(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_DOUBLE) || force)) {
|
|
double* ptr = (double*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char getType_char(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_CHAR) || force)) {
|
|
char* ptr = (char*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
EQ2_8BitString getType_EQ2_8BitString(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQ2_8BIT_STRING) || force)) {
|
|
EQ2_8BitString* ptr = (EQ2_8BitString*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
EQ2_8BitString ret;
|
|
ret.size = 0;
|
|
return ret;
|
|
}
|
|
|
|
EQ2_16BitString getType_EQ2_16BitString(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQ2_16BIT_STRING) || force)) {
|
|
EQ2_16BitString* ptr = (EQ2_16BitString*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
EQ2_16BitString ret;
|
|
ret.size = 0;
|
|
return ret;
|
|
}
|
|
|
|
EQ2_32BitString getType_EQ2_32BitString(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQ2_32BIT_STRING) || force)) {
|
|
EQ2_32BitString* ptr = (EQ2_32BitString*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
EQ2_32BitString ret;
|
|
ret.size = 0;
|
|
return ret;
|
|
}
|
|
|
|
EQ2_Color getType_EQ2_Color(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_COLOR) || force)) {
|
|
EQ2_Color* ptr = (EQ2_Color*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
EQ2_Color ret;
|
|
ret.blue = 0;
|
|
ret.red = 0;
|
|
ret.green = 0;
|
|
return ret;
|
|
}
|
|
|
|
EQ2_EquipmentItem getType_EQ2_EquipmentItem(DataStruct* data_struct, int32 index = 0, bool force = false)
|
|
{
|
|
if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQUIPMENT) || force)) {
|
|
EQ2_EquipmentItem* ptr = (EQ2_EquipmentItem*)GetStructPointer(data_struct);
|
|
return ptr[index];
|
|
}
|
|
EQ2_EquipmentItem ret;
|
|
ret.color.blue = 0;
|
|
ret.color.red = 0;
|
|
ret.color.green = 0;
|
|
ret.highlight.blue = 0;
|
|
ret.highlight.red = 0;
|
|
ret.highlight.green = 0;
|
|
ret.type = 0;
|
|
return ret;
|
|
} |