From 68f99bc2d5ee104ce1e3693c1e0068999171e2bb Mon Sep 17 00:00:00 2001 From: Arkshine Date: Fri, 9 Oct 2015 11:26:40 +0200 Subject: [PATCH] Add get/Set_gamerules_* natives --- modules/fakemeta/pdata_gc.cpp | 216 ++++++++++++++++++++++++++++++++-- plugins/include/fakemeta.inc | 177 ++++++++++++++++++++++++++++ 2 files changed, 380 insertions(+), 13 deletions(-) diff --git a/modules/fakemeta/pdata_gc.cpp b/modules/fakemeta/pdata_gc.cpp index 562ae6a7..7089ff6d 100644 --- a/modules/fakemeta/pdata_gc.cpp +++ b/modules/fakemeta/pdata_gc.cpp @@ -556,6 +556,189 @@ static cell AMX_NATIVE_CALL set_ent_data_string(AMX *amx, cell *params) } + +// native any:get_gamerules_int(const class[], const member[], element = 0); +static cell AMX_NATIVE_CALL get_gamerules_int(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Integer, GAMERULES); + + int element = params[3]; + CHECK_ELEMENT(element); + + return GetData(GameRulesAddress, data, element); +} + +// native set_gamerules_int(const class[], const member[], any:value, element = 0); +static cell AMX_NATIVE_CALL set_gamerules_int(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Integer, GAMERULES); + + int element = params[4]; + CHECK_ELEMENT(element); + + if (data.fieldType == FieldType::FIELD_STRUCTURE || data.fieldType == FieldType::FIELD_CLASS) + { + MF_LogError(amx, AMX_ERR_NATIVE, "Setting directly to a class or structure address is not available"); + return 0; + } + + SetData(GameRulesAddress, data, params[3], element); + + return 0; +} + + +// native Float:get_gamerules_float(const class[], const member[], element = 0); +static cell AMX_NATIVE_CALL get_gamerules_float(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Float, GAMERULES); + + int element = params[3]; + CHECK_ELEMENT(element); + + return GetDataFloat(GameRulesAddress, data, element); +} + +// native set_gamerules_float(const class[], const member[], Float:value, element = 0); +static cell AMX_NATIVE_CALL set_gamerules_float(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Float, GAMERULES); + + int element = params[4]; + CHECK_ELEMENT(element); + + SetDataFloat(GameRulesAddress, data, amx_ctof(params[3]), element); + + return 1; +} + + +// native get_gamerules_vector(const class[], const member[], Float:value[3], element = 0); +static cell AMX_NATIVE_CALL get_gamerules_vector(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Vector, GAMERULES); + + int element = params[4]; + CHECK_ELEMENT(element); + + GetDataVector(GameRulesAddress, data, MF_GetAmxAddr(amx, params[3]), element); + + return 1; +} + +// native set_gamerules_vector(const class[], const member[], Float:value[3], element = 0); +static cell AMX_NATIVE_CALL set_gamerules_vector(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Vector, GAMERULES); + + int element = params[4]; + CHECK_ELEMENT(element); + + GetDataVector(GameRulesAddress, data, MF_GetAmxAddr(amx, params[3]), element); + + return 1; +} + + +// native get_gamerules_entity(const class[], const member[], element = 0); +static cell AMX_NATIVE_CALL get_gamerules_entity(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Entity, GAMERULES); + + int element = params[3]; + CHECK_ELEMENT(element); + + return GetDataEntity(GameRulesAddress, data, element); +} + +// native set_gamerules_entity(const class[], const member[], value, element = 0); +static cell AMX_NATIVE_CALL set_gamerules_entity(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + int value = params[3]; + + if (value != -1) + { + CHECK_ENTITY(value); + } + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::Entity, GAMERULES); + + int element = params[4]; + CHECK_ELEMENT(element); + + SetDataEntity(GameRulesAddress, data, params[3], element); + + return 0; +} + + +// native get_gamerules_string(const class[], const member[], value[], maxlen, element = 0); +static cell AMX_NATIVE_CALL get_gamerules_string(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::String, GAMERULES); + + int element = params[5]; + CHECK_ELEMENT(element); + + auto buffer = params[3]; + auto maxlen = params[4]; + + auto string = GetDataString(GameRulesAddress, data, element); + + if (data.fieldSize) + { + maxlen = ke::Min(maxlen, data.fieldSize); + } + + return MF_SetAmxStringUTF8Char(amx, buffer, string ? string : "", string ? strlen(string) : 0, maxlen); +} + +// native set_gamerules_string(const class[], const member[], const value[], element = 0); +static cell AMX_NATIVE_CALL set_gamerules_string(AMX *amx, cell *params) +{ + CHECK_GAMERULES(); + + TypeDescription data; + GET_TYPE_DESCRIPTION(1, data, BaseFieldType::String, GAMERULES); + + int element = params[4]; + CHECK_ELEMENT(element); + + int length; + const char *value = MF_GetAmxString(amx, params[3], 0, &length); + + return SetDataString(GameRulesAddress, data, value, length, element); +} + + + // native get_ent_data_size(const class[], const member[]); static cell AMX_NATIVE_CALL get_ent_data_size(AMX *amx, cell *params) { @@ -581,20 +764,27 @@ static cell AMX_NATIVE_CALL find_ent_data_info(AMX *amx, cell *params) AMX_NATIVE_INFO pdata_gc_natives[] = { - { "get_ent_data" , get_ent_data }, - { "set_ent_data" , set_ent_data }, + { "get_ent_data" , get_ent_data }, + { "set_ent_data" , set_ent_data }, + { "get_ent_data_float" , get_ent_data_float }, + { "set_ent_data_float" , set_ent_data_float }, + { "get_ent_data_vector" , get_ent_data_vector }, + { "set_ent_data_vector" , set_ent_data_vector }, + { "get_ent_data_entity" , get_ent_data_entity }, + { "set_ent_data_entity" , set_ent_data_entity }, + { "get_ent_data_string" , get_ent_data_string }, + { "set_ent_data_string" , set_ent_data_string }, - { "get_ent_data_float" , get_ent_data_float }, - { "set_ent_data_float" , set_ent_data_float }, - - { "get_ent_data_vector", get_ent_data_vector }, - { "set_ent_data_vector", set_ent_data_vector }, - - { "get_ent_data_entity", get_ent_data_entity }, - { "set_ent_data_entity", set_ent_data_entity }, - - { "get_ent_data_string", get_ent_data_string }, - { "set_ent_data_string", set_ent_data_string }, + { "get_gamerules_int" , get_gamerules_int }, + { "set_gamerules_int" , set_gamerules_int }, + { "get_gamerules_float" , get_gamerules_float }, + { "set_gamerules_float" , set_gamerules_float }, + { "get_gamerules_vector", get_gamerules_vector }, + { "set_gamerules_vector", set_gamerules_vector }, + { "get_gamerules_entity", get_gamerules_entity }, + { "set_gamerules_entity", set_gamerules_entity }, + { "get_gamerules_string", get_gamerules_string }, + { "set_gamerules_string", set_gamerules_string }, { "get_ent_data_size" , get_ent_data_size }, { "find_ent_data_info" , find_ent_data_info }, diff --git a/plugins/include/fakemeta.inc b/plugins/include/fakemeta.inc index ff7d4531..a8183ceb 100755 --- a/plugins/include/fakemeta.inc +++ b/plugins/include/fakemeta.inc @@ -808,6 +808,183 @@ native get_ent_data_string(entity, const class[], const member[], value[], maxle */ native set_ent_data_string(entity, const class[], const member[], const value[], element = 0); +/** + * Retrieves an integer value from the gamerules object based off a class + * and member name. + * + * @note This native is used to access the following (C++/engine) data types: + * integer, boolean, short, character, pointer, structure, class, + * stringint and function. Unsigned variants (if applicable) are supported + * and will be converted automatically. + * + * @param class Class name + * @param member Member name + * @param element Element to retrieve (starting from 0) if member is an array + * + * @return Integer value + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native any:get_gamerules_int(const class[], const member[], element = 0); + +/** + * Sets an integer value to the gamerules objecta based off a class + * and member name. + * + * @note This native is used to access the following (C++/engine) data types: + * integer, boolean, short, character, pointer, stringint and function. + * Unsigned variants (if applicable) are supported and will be converted + * automatically. + * + * @param class Class name + * @param member Member name + * @param value Value to set + * @param element Element to set (starting from 0) if member is an array + * + * @noreturn + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native set_gamerules_int(const class[], const member[], any:value, element = 0); + +/** + * Retrieves a float value from the gamerules object based off a class + * and member name. + * + * @param class Class name + * @param member Member name + * @param element Element to retrieve (starting from 0) if member is an array + * + * @return Float value + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native Float:get_gamerules_float(const class[], const member[], element = 0); + +/** + * Sets a float value to the gamerules object based off a class + * and member name. + * + * @param class Class name + * @param member Member name + * @param value Value to set + * @param element Element to set (starting from 0) if member is an array + * + * @noreturn + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native set_gamerules_float(const class[], const member[], Float:value, element = 0); + +/** + * Retrieves a vector from the gamerules object based off a class and member name. + * + * @param class Class name + * @param member Member name + * @param value Vector buffer to store data in + * @param element Element to retrieve (starting from 0) if member is an array + * + * @noreturn + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native get_gamerules_vector(const class[], const member[], Float:value[3], element = 0); + +/** + * Sets a vector to the gamerules object based off a class and member name. + * + * @param class Class name + * @param member Member name + * @param value Vector to set + * @param element Element to set (starting from 0) if member is an array + * + * @noreturn + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native set_gamerules_vector(const class[], const member[], Float:value[3], element = 0); + +/** + * Retrieves an entity index from the gamerules object based off a class + * and member name. + * + * @note This native is used to access the following (C++/engine) data types: + * classptr, entvars, edict and ehandle. + * + * @param class Class name + * @param member Member name + * @param element Element to retrieve (starting from 0) if member is an array + * + * @return Entity index if found, -1 otherwise + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native get_gamerules_entity(const class[], const member[], element = 0); + +/** + * Sets an entity index to the gamerules object based off a class + * and member name. + * + * @note This native is used to access the following (C++/engine) data types: + * classptr, entvars, edict and ehandle. + * @note Pass -1 as value to act as C++ NULL. + * + * @param class Class name + * @param member Member name + * @param value Entity index to set + * @param element Element to set (starting from 0) if member is an array + * + * @noreturn + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native set_gamerules_entity(const class[], const member[], value, element = 0); + +/** + * Retrieves a string from the gamerules object based off a class and member name. + * + * @note This native is used to access the following (C++/engine) data types: + * string, stringptr. + * + * @param class Class name + * @param member Member name + * @param value Buffer to store data in + * @param maxlen Maximum size of the buffer + * @param element Element to retrieve (starting from 0) if member is an array + * + * @return Number of cells written to buffer + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native get_gamerules_string(const class[], const member[], value[], maxlen, element = 0); + +/** + * Sets a string to the gamerules object based off a class and member name. + * + * @note This native is used to access the following (C++/engine) data types: + * string, stringptr. + * + * @param class Class name + * @param member Member name + * @param value String to set + * @param element Element to set (starting from 0) if member is an array + * + * @return Number of cells written to buffer + * @error If member is empty, no offset is found or an invalid offset + * is retrieved, or the data type does not match, an error will + * be thrown. + */ +native set_gamerules_string(const class[], const member[], const value[], element = 0); + /** * Retrieves the size of array of a class member. *