Mensajes: 145
Temas: 78
Registro en: Sep 2020
Reputación:
0
30/06/2021, 01:21 PM
(Última modificación: 30/06/2021, 01:23 PM por MalitoMaloso. Edited 1 time in total.)
api_custom_entities.amxx
hola tengo un problema con este plugins probé plugins por plugins en mod halowin
y los cierra el juego al intentar entrar al sv cuando esta activado si alguien me puede ayudar se lo agradesco
Código PHP: #pragma semicolon 1
#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fakemeta>
#include <hamsandwich>
#include <cellarray>
#include <celltrie>
#include <xs>
#define PLUGIN "[API] Custom Entities"
#define VERSION "1.2.1"
#define AUTHOR "Hedgehog Fog"
#define CE_BASE_CLASSNAME "info_target"
#define LOG_PREFIX "[CE]"
#define TASKID_SUM_DISAPPEAR 1000
#define TASKID_SUM_RESPAWN 2000
#define TASKID_SUM_REMOVE 3000
/*--------------------------------[ Constants ]--------------------------------*/
enum CEPreset
{
CEPreset_None = 0,
CEPreset_Item,
CEPreset_NPC,
CEPreset_Prop
};
enum CEFunction
{
CEFunction_Spawn,
CEFunction_Kill,
CEFunction_Killed,
CEFunction_Remove,
CEFunction_Picked,
CEFunction_Pickup,
CEFunction_KVD
};
enum CEHookData
{
CEHookData_PluginID,
CEHookData_FuncID
};
enum _:RegisterArgs
{
RegisterArg_Name = 1,
RegisterArg_ModelIndex,
RegisterArg_Mins,
RegisterArg_Maxs,
RegisterArg_LifeTime,
RegisterArg_RespawnTime,
RegisterArg_IgnoreRounds,
RegisterArg_Preset
};
enum _:CEData
{
CEData_Handler,
CEData_TempIndex,
CEData_WorldIndex,
CEData_StartOrigin
};
/*--------------------------------[ Variables ]--------------------------------*/
new g_ptrBaseClassname;
new Trie:g_entityHandlers;
new Array:g_entityName;
new Array:g_entityPluginID;
new Array:g_entityModelIndex;
new Array:g_entityMins;
new Array:g_entityMaxs;
new Array:g_entityLifeTime;
new Array:g_entityRespawnTime;
new Array:g_entityPreset;
new Array:g_entityIgnoreRounds;
new Array:g_entityHooks;
new g_entityCount = 0;
new Array:g_worldEntities;
new Array:g_tmpEntities;
new g_lastCEIdx = 0;
new g_lastCEEnt = 0;
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);
if (g_lastCEEnt) {
dllfunc(DLLFunc_Spawn, g_lastCEEnt); // spawn last handled entity
}
RegisterHam(Ham_Touch, CE_BASE_CLASSNAME, "OnTouch", .Post = 1);
RegisterHam(Ham_Killed, CE_BASE_CLASSNAME, "OnKilled", .Post = 0);
register_event("HLTV", "OnNewRound", "a", "1=0", "2=0");
register_concmd("ce_spawn", "OnClCmd_CESpawn", ADMIN_CVAR);
}
public plugin_end()
{
for (new i = 0; i < g_entityCount; ++i) {
DestroyFunctions(i);
}
if (g_entityCount) {
TrieDestroy(g_entityHandlers);
ArrayDestroy(g_entityName);
ArrayDestroy(g_entityPluginID);
ArrayDestroy(g_entityModelIndex);
ArrayDestroy(g_entityMins);
ArrayDestroy(g_entityMaxs);
ArrayDestroy(g_entityLifeTime);
ArrayDestroy(g_entityRespawnTime);
ArrayDestroy(g_entityIgnoreRounds);
ArrayDestroy(g_entityPreset);
ArrayDestroy(g_entityHooks);
}
if (g_tmpEntities) {
ArrayDestroy(g_tmpEntities);
}
if (g_worldEntities) {
ArrayDestroy(g_worldEntities);
}
}
public plugin_precache()
{
g_ptrBaseClassname = engfunc(EngFunc_AllocString, CE_BASE_CLASSNAME);
register_forward(FM_KeyValue, "OnKeyValue", 1);
RegisterHam(Ham_Spawn, CE_BASE_CLASSNAME, "OnSpawn", .Post = 1);
}
public plugin_natives()
{
register_library("api_custom_entities");
register_native("CE_Register", "Native_Register");
register_native("CE_Create", "Native_Create");
register_native("CE_Kill", "Native_Kill");
register_native("CE_Remove", "Native_Remove");
register_native("CE_GetSize", "Native_GetSize");
register_native("CE_GetModelIndex", "Native_GetModelIndex");
register_native("CE_RegisterHook", "Native_RegisterHook");
register_native("CE_CheckAssociation_", "Native_CheckAssociation");
register_native("CE_GetHandler", "Native_GetHandler");
register_native("CE_GetHandlerByEntity", "Native_GetHandlerByEntity");
}
/*--------------------------------[ Natives ]--------------------------------*/
public Native_Register(pluginID, argc)
{
static szClassName[32];
get_string(RegisterArg_Name, szClassName, charsmax(szClassName));
new modelIndex = get_param(RegisterArg_ModelIndex);
new Float:fLifeTime = get_param_f(RegisterArg_LifeTime);
new Float:fRespawnTime = get_param_f(RegisterArg_RespawnTime);
new bool:ignoreRounds = bool:get_param(RegisterArg_IgnoreRounds);
new CEPreset:preset = CEPreset:get_param(RegisterArg_Preset);
new Float:vMins[3];
get_array_f(RegisterArg_Mins, vMins, 3);
new Float:vMaxs[3];
get_array_f(RegisterArg_Maxs, vMaxs, 3);
return Register(szClassName, pluginID, modelIndex, vMins, vMaxs, fLifeTime, fRespawnTime, ignoreRounds, preset);
}
public Native_Create(pluginID, argc)
{
new szClassName[32];
get_string(1, szClassName, charsmax(szClassName));
new Float:vOrigin[3];
get_array_f(2, vOrigin, 3);
new bool:temp = !!get_param(3);
return Create(szClassName, vOrigin, temp);
}
public Native_Kill(pluginID, argc)
{
new ent = get_param(1);
new killer = get_param(2);
Kill(ent, killer);
}
public bool:Native_Remove(pluginID, argc)
{
new ent = get_param(1);
return Remove(ent);
}
public Native_GetSize(pluginID, argc)
{
new szClassName[32];
get_string(1, szClassName, charsmax(szClassName));
new ceIdx;
if (!TrieGetCell(g_entityHandlers, szClassName, ceIdx)) {
return false;
}
new Float:vMins[3];
ArrayGetArray(g_entityMins, ceIdx, vMins);
new Float:vMaxs[3];
ArrayGetArray(g_entityMaxs, ceIdx, vMaxs);
set_array_f(2, vMins, 3);
set_array_f(3, vMaxs, 3);
return true;
}
public Native_GetModelIndex(pluginID, argc)
{
new szClassName[32];
get_string(1, szClassName, charsmax(szClassName));
new ceIdx;
if (!TrieGetCell(g_entityHandlers, szClassName, ceIdx)) {
return false;
}
return ArrayGetCell(g_entityModelIndex, ceIdx);
}
public Native_RegisterHook(pluginID, argc)
{
new CEFunction:function = CEFunction:get_param(1);
new szClassname[32];
get_string(2, szClassname, charsmax(szClassname));
new szCallback[32];
get_string(3, szCallback, charsmax(szCallback));
RegisterHook(function, szClassname, szCallback, pluginID);
}
public Native_CheckAssociation(pluginID, argc)
{
new ent = get_param(1);
new ceIdx = GetHandlerByEntity(ent);
return (ceIdx > 0 && pluginID == ArrayGetCell(g_entityPluginID, ceIdx));
}
public Native_GetHandler(pluginID, argc)
{
new szClassname[32];
get_string(1, szClassname, charsmax(szClassname));
return GetHandler(szClassname);
}
public Native_GetHandlerByEntity(pluginID, argc)
{
new ent = get_param(1);
return GetHandlerByEntity(ent);
}
/*--------------------------------[ Hooks ]--------------------------------*/
public OnClCmd_CESpawn(id, level, cid)
{
if(!cmd_access(id, level, cid, 2)) {
return PLUGIN_HANDLED;
}
static szClassname[128];
read_args(szClassname, charsmax(szClassname));
remove_quotes(szClassname);
if(szClassname[0] == '^0') {
return PLUGIN_HANDLED;
}
static Float:vOrigin[3];
pev(id, pev_origin, vOrigin);
new ent = Create(szClassname, vOrigin);
if (ent) {
dllfunc(DLLFunc_Spawn, ent);
}
return PLUGIN_HANDLED;
}
public OnKeyValue(ent, kvd)
{
static szKey[32];
get_kvd(kvd, KV_KeyName, szKey, charsmax(szKey));
static szValue[32];
get_kvd(kvd, KV_Value, szValue, charsmax(szValue));
if (equal(szKey, "classname"))
{
if (g_lastCEEnt) {
dllfunc(DLLFunc_Spawn, g_lastCEEnt); // spawn last handled entity
g_lastCEEnt = 0;
}
if (TrieGetCell(g_entityHandlers, szValue, g_lastCEIdx)) {
g_lastCEEnt = Create(szValue, .temp = false); // clone entity
}
return;
}
if (!g_lastCEEnt) {
return;
}
DispatchKeyValue(g_lastCEEnt, szKey, szValue); // dispatch kvd to cloned entity
ExecuteFunction(CEFunction_KVD, g_lastCEIdx, g_lastCEEnt, szKey, szValue);
}
public OnSpawn(ent)
{
if (!Check(ent)) {
return;
}
new Array:ceData = GetPData(ent);
new ceIdx = ArrayGetCell(ceData, CEData_Handler);
//Save start origin
if (ArrayGetCell(ceData, CEData_StartOrigin) == Invalid_Array) {
new Float:vOrigin[3];
pev(ent, pev_origin, vOrigin);
new Array:startOrigin = ArrayCreate(3, 1);
ArrayPushArray(startOrigin, vOrigin);
ArraySetCell(ceData, CEData_StartOrigin, startOrigin);
}
new tmpIdx = ArrayGetCell(ceData, CEData_TempIndex);
InitEntity(ent, ceIdx, (tmpIdx >= 0));
ExecuteFunction(CEFunction_Spawn, ceIdx, ent);
}
public OnTouch(ent, id)
{
if (pev(ent, pev_flags) & ~FL_ONGROUND) {
return;
}
if (!is_user_connected(id)) {
return;
}
if (!is_user_alive(id)) {
return;
}
static szClassname[32];
pev(ent, pev_classname, szClassname, charsmax(szClassname));
new ceIdx;
if (!TrieGetCell(g_entityHandlers, szClassname, ceIdx)) {
return;
}
new CEPreset:preset = ArrayGetCell(g_entityPreset, ceIdx);
if (preset != CEPreset_Item) {
return;
}
if (ExecuteFunction(CEFunction_Pickup, ceIdx, ent, id) > 0) {
ExecuteFunction(CEFunction_Picked, ceIdx, ent, id);
Kill(ent, id, .picked = true);
}
}
public OnKilled(ent, killer)
{
if (!Check(ent)) {
return HAM_IGNORED;
}
Kill(ent, killer);
return HAM_SUPERCEDE;
}
public OnNewRound()
{
Cleanup();
RespawnEntities();
}
/*--------------------------------[ Methods ]--------------------------------*/
Register(
const szClassname[],
pluginID,
modelIndex,
const Float:vMins[3],
const Float:vMaxs[3],
Float:fLifeTime,
Float:fRespawnTime,
bool:ignoreRounds,
CEPreset:preset
)
{
if (!g_entityCount) {
g_entityHandlers = TrieCreate();
g_entityName = ArrayCreate(32);
g_entityPluginID = ArrayCreate(1);
g_entityModelIndex = ArrayCreate(1);
g_entityMaxs = ArrayCreate(3);
g_entityMins = ArrayCreate(3);
g_entityLifeTime = ArrayCreate(1);
g_entityRespawnTime = ArrayCreate(1);
g_entityIgnoreRounds = ArrayCreate(1);
g_entityPreset = ArrayCreate(1);
g_entityHooks = ArrayCreate(1);
}
new index = g_entityCount;
TrieSetCell(g_entityHandlers, szClassname, index);
ArrayPushString(g_entityName, szClassname);
ArrayPushCell(g_entityPluginID, pluginID);
ArrayPushCell(g_entityModelIndex, modelIndex);
ArrayPushArray(g_entityMins, vMins);
ArrayPushArray(g_entityMaxs, vMaxs);
ArrayPushCell(g_entityLifeTime, fLifeTime);
ArrayPushCell(g_entityRespawnTime, fRespawnTime);
ArrayPushCell(g_entityIgnoreRounds, ignoreRounds);
ArrayPushCell(g_entityPreset, preset);
ArrayPushCell(g_entityHooks, 0);
g_entityCount++;
log_amx("%s Entity %s successfully registred.", LOG_PREFIX, szClassname);
return index;
}
Create(const szClassname[], const Float:vOrigin[3] = {0.0, 0.0, 0.0}, bool:temp = true)
{
new ceIdx;
if (!TrieGetCell(g_entityHandlers, szClassname, ceIdx)) {
log_error(0, "%s Entity %s is not registered as custom entity.", LOG_PREFIX, szClassname);
return 0;
}
new ent = engfunc(EngFunc_CreateNamedEntity, g_ptrBaseClassname);
set_pev(ent, pev_classname, szClassname, strlen(szClassname));
engfunc(EngFunc_SetOrigin, ent, vOrigin);
new tmpIdx = -1;
new worldIdx = -1;
if (temp) {
if (!g_tmpEntities) {
g_tmpEntities = ArrayCreate();
}
tmpIdx = ArraySize(g_tmpEntities);
ArrayPushCell(g_tmpEntities, ent);
} else {
if (!g_worldEntities) {
g_worldEntities = ArrayCreate();
}
worldIdx = ArraySize(g_worldEntities);
ArrayPushCell(g_worldEntities, ent);
}
new Array:ceData = CreatePData(ent);
ArraySetCell(ceData, CEData_Handler, ceIdx);
ArraySetCell(ceData, CEData_TempIndex, tmpIdx);
ArraySetCell(ceData, CEData_WorldIndex, worldIdx);
ArraySetCell(ceData, CEData_StartOrigin, Invalid_Array);
set_pev(ent, pev_deadflag, DEAD_NO);
return ent;
}
Respawn(ent)
{
remove_task(ent+TASKID_SUM_RESPAWN);
new Array:ceData = GetPData(ent);
new Array:startOrigin = ArrayGetCell(ceData, CEData_StartOrigin);
if (startOrigin != Invalid_Array) {
static Float:vOrigin[3];
ArrayGetArray(startOrigin, 0, vOrigin);
engfunc(EngFunc_SetOrigin, ent, vOrigin);
}
set_pev(ent, pev_deadflag, DEAD_NO);
set_pev(ent, pev_effects, pev(ent, pev_effects) & ~EF_NODRAW);
set_pev(ent, pev_flags, pev(ent, pev_flags) & ~FL_ONGROUND);
dllfunc(DLLFunc_Spawn, ent);
}
Kill(ent, killer = 0, bool:picked = false)
{
new Array:ceData = GetPData(ent);
new ceIdx = ArrayGetCell(ceData, CEData_Handler);
if (ExecuteFunction(CEFunction_Kill, ceIdx, ent, killer, picked) != PLUGIN_CONTINUE) {
return;
}
set_pev(ent, pev_takedamage, DAMAGE_NO);
set_pev(ent, pev_effects, pev(ent, pev_effects) | EF_NODRAW);
set_pev(ent, pev_solid, SOLID_NOT);
set_pev(ent, pev_movetype, MOVETYPE_NONE);
set_pev(ent, pev_flags, pev(ent, pev_flags) & ~FL_ONGROUND);
//Get temp index
new tmpIdx = ArrayGetCell(ceData, CEData_TempIndex);
//Check if entity is temp
if (tmpIdx < 0) {
new Float:fRespawnTime = ArrayGetCell(g_entityRespawnTime, ceIdx);
if (fRespawnTime > 0.0) {
set_pev(ent, pev_deadflag, DEAD_RESPAWNABLE);
set_task(fRespawnTime, "TaskRespawn", ent+TASKID_SUM_RESPAWN);
} else {
set_pev(ent, pev_deadflag, DEAD_DEAD);
}
} else {
set_pev(ent, pev_deadflag, DEAD_DISCARDBODY);
}
remove_task(ent+TASKID_SUM_DISAPPEAR);
ExecuteFunction(CEFunction_Killed, ceIdx, ent, killer, picked);
if (tmpIdx >= 0) {
set_task(0.0, "TaskRemove", ent+TASKID_SUM_REMOVE);
}
}
bool:Remove(ent)
{
if (!Check(ent)) {
log_error(0, "%s Entity %i is not a custom entity.", LOG_PREFIX, ent);
return false;
}
new Array:ceData = GetPData(ent);
//Get temp index
new tmpIdx = ArrayGetCell(ceData, CEData_TempIndex);
//Check if entity is temp
if (tmpIdx >= 0) {
//Remove entity from storage of temp entities
ArraySetCell(g_tmpEntities, tmpIdx, 0);
} else {
//Get world index
new worldIdx = ArrayGetCell(ceData, CEData_WorldIndex);
if (worldIdx >= 0) {
ArraySetCell(g_worldEntities, worldIdx, 0);
}
}
ClearTasks(ent);
//Get handler
new ceIdx = ArrayGetCell(ceData, CEData_Handler);
//Execute remove function
ExecuteFunction(CEFunction_Remove, ceIdx, ent);
DestroyPData(ent);
//Remove entity
set_pev(ent, pev_flags, pev(ent, pev_flags) | FL_KILLME);
dllfunc(DLLFunc_Think, ent);
return true;
}
Check(ent)
{
return (pev(ent, pev_gaitsequence) == 'c'+'e');
}
ClearTasks(ent)
{
remove_task(ent+TASKID_SUM_DISAPPEAR);
remove_task(ent+TASKID_SUM_RESPAWN);
remove_task(ent+TASKID_SUM_REMOVE);
}
GetHandlerByEntity(ent)
{
if (!Check(ent)) {
return -1;
}
new Array:ceData = GetPData(ent);
return ArrayGetCell(ceData, CEData_Handler);
}
GetHandler(const szClassname[])
{
new ceIdx;
if (!TrieGetCell(g_entityHandlers, szClassname, ceIdx)) {
return -1;
}
return ceIdx;
}
Cleanup()
{
if (!g_tmpEntities) {
return;
}
new size = ArraySize(g_tmpEntities);
for (new i = size - 1; i >= 0; --i)
{
new ent = ArrayGetCell(g_tmpEntities, i);
if (ent && pev_valid(ent))
{
new ceIdx = GetHandlerByEntity(ent);
if (ceIdx == -1) {
log_error(0, "%s Entity %i is not a custom entity.", LOG_PREFIX, ent);
continue;
}
new ignoreRounds = ArrayGetCell(g_entityIgnoreRounds, ceIdx);
if (!ignoreRounds) {
Remove(ent);
ArrayDeleteItem(g_tmpEntities, i);
}
}
}
}
RespawnEntities()
{
if (!g_worldEntities) {
return;
}
new size = ArraySize(g_worldEntities);
for (new i = 0; i < size; ++i) {
new ent = ArrayGetCell(g_worldEntities, i);
if (ent) {
Respawn(ent);
}
}
}
bool:InitEntity(ent, ceIdx, bool:temp)
{
static Float:vMins[3];
ArrayGetArray(g_entityMins, ceIdx, vMins);
static Float:vMaxs[3];
ArrayGetArray(g_entityMaxs, ceIdx, vMaxs);
static Float:vOrigin[3];
pev(ent, pev_origin, vOrigin);
engfunc(EngFunc_SetSize, ent, vMins, vMaxs);
engfunc(EngFunc_SetOrigin, ent, vOrigin);
{
new preset = ArrayGetCell(g_entityPreset, ceIdx);
ApplyPreset(ent, preset);
}
new modelIndex = ArrayGetCell(g_entityModelIndex, ceIdx);
if (modelIndex > 0) {
set_pev(ent, pev_modelindex, modelIndex);
}
if (temp) {
new Float:fLifeTime = ArrayGetCell(g_entityLifeTime, ceIdx);
if (fLifeTime > 0.0) {
set_task(fLifeTime, "TaskDisappear", ent+TASKID_SUM_DISAPPEAR);
}
}
return true;
}
ApplyPreset(ent, preset)
{
switch (preset)
{
case CEPreset_Item:
{
set_pev(ent, pev_solid, SOLID_TRIGGER);
set_pev(ent, pev_movetype, MOVETYPE_TOSS);
set_pev(ent, pev_takedamage, DAMAGE_NO);
}
case CEPreset_NPC:
{
set_pev(ent, pev_solid, SOLID_BBOX);
set_pev(ent, pev_movetype, MOVETYPE_PUSHSTEP);
set_pev(ent, pev_takedamage, DAMAGE_AIM);
set_pev(ent, pev_controller_0, 125);
set_pev(ent, pev_controller_1, 125);
set_pev(ent, pev_controller_2, 125);
set_pev(ent, pev_controller_3, 125);
set_pev(ent, pev_gamestate, 1);
set_pev(ent, pev_gravity, 1.0);
set_pev(ent, pev_flags, pev(ent, pev_flags) | FL_MONSTER);
set_pev(ent, pev_fixangle, 1);
set_pev(ent, pev_friction, 0.25);
}
case CEPreset_Prop:
{
set_pev(ent, pev_solid, SOLID_BBOX);
set_pev(ent, pev_movetype, MOVETYPE_FLY);
set_pev(ent, pev_takedamage, DAMAGE_NO);
}
}
}
RegisterHook(CEFunction:function, const szClassname[], const szCallback[], pluginID = -1)
{
new ceIdx;
if (!TrieGetCell(g_entityHandlers, szClassname, ceIdx)) {
log_error(0, "%s Entity %s is not registered.", LOG_PREFIX, szClassname);
return -1;
}
new funcID = get_func_id(szCallback, pluginID);
if (funcID < 0) {
new szFilename[32];
get_plugin(pluginID, szFilename, charsmax(szFilename));
log_error(0, "Function %s not found in plugin %s.", szCallback, szFilename);
return -1;
}
new Array:functions = ArrayGetCell(g_entityHooks, ceIdx);
if (!functions) {
functions = InitializeFunctions(ceIdx);
}
new Array:functionHooks = ArrayGetCell(functions, _:function);
new Array:hookData = CreateHookData(pluginID, funcID);
return ArrayPushCell(functionHooks, hookData);
}
Array:InitializeFunctions(ceIdx)
{
new Array:functions = ArrayCreate(1, _:CEFunction);
for (new i = 0; i < _:CEFunction; ++i) {
new Array:functionHooks = ArrayCreate();
ArrayPushCell(functions, functionHooks);
}
ArraySetCell(g_entityHooks, ceIdx, functions);
return functions;
}
DestroyFunctions(ceIdx)
{
new Array:functions = ArrayGetCell(g_entityHooks, ceIdx);
if (!functions) {
return;
}
for (new i = 0; i < _:CEFunction; ++i) {
new Array:functionHooks = ArrayGetCell(functions, i);
ArrayDestroy(functionHooks);
}
ArrayDestroy(functions);
ArraySetCell(g_entityHooks, ceIdx, 0);
}
Array:CreateHookData(pluginID, funcID)
{
new Array:hookData = ArrayCreate(1, _:CEHookData);
ArrayPushCell(hookData, pluginID);
ArrayPushCell(hookData, funcID);
return hookData;
}
ExecuteFunction(CEFunction:function, ceIdx, any:...)
{
new result = 0;
new ent = getarg(2);
new Array:functions = ArrayGetCell(g_entityHooks, ceIdx);
if (functions == Invalid_Array) {
return 0;
}
new Array:functionHooks = ArrayGetCell(functions, _:function);
new count = ArraySize(functionHooks);
for (new i = 0; i < count; ++i)
{
new Array:hookData = ArrayGetCell(functionHooks, i);
new pluginID = ArrayGetCell(hookData, _:CEHookData_PluginID);
new funcID = ArrayGetCell(hookData, _:CEHookData_FuncID);
if (funcID < 0) {
continue;
}
if (callfunc_begin_i(funcID, pluginID) == 1)
{
callfunc_push_int(ent);
switch (function)
{
case CEFunction_Kill, CEFunction_Killed: {
new killer = getarg(3);
new bool:picked = bool:getarg(4);
callfunc_push_int(killer);
callfunc_push_int(picked);
}
case CEFunction_Pickup, CEFunction_Picked: {
new id = getarg(3);
callfunc_push_int(id);
}
case CEFunction_KVD: {
static szKey[32];
for (new i = 0; i < charsmax(szKey); ++i) {
szKey[i] = getarg(3, i);
if (szKey[i] == '^0') {
break;
}
}
static szValue[32];
for (new i = 0; i < charsmax(szValue); ++i) {
szValue[i] = getarg(4, i);
if (szValue[i] == '^0') {
break;
}
}
callfunc_push_str(szKey);
callfunc_push_str(szValue);
}
}
result += callfunc_end();
}
}
return result;
}
Array:CreatePData(ent)
{
new Array:ceData = ArrayCreate(1, CEData);
for (new i = 0; i < CEData; ++i) {
ArrayPushCell(ceData, 0);
}
set_pev(ent, pev_gaitsequence, 'c'+'e');
set_pev(ent, pev_iStepLeft, ceData);
return ceData;
}
DestroyPData(ent)
{
//Destroy data array
new Array:ceData = GetPData(ent);
{
new Array:startOrigin = ArrayGetCell(ceData, CEData_StartOrigin);
if (startOrigin != Invalid_Array) {
ArrayDestroy(startOrigin);
}
} ArrayDestroy(ceData);
set_pev(ent, pev_gaitsequence, 0);
set_pev(ent, pev_iStepLeft, 0);
}
Array:GetPData(ent)
{
new Array:ceData = any:pev(ent, pev_iStepLeft);
if (ceData == Invalid_Array) {
log_error(0, "%s Invalid Custom Entity data provided for %i.", LOG_PREFIX, ent);
}
return ceData;
}
/*--------------------------------[ Tasks ]--------------------------------*/
public TaskDisappear(taskID)
{
new ent = taskID - TASKID_SUM_DISAPPEAR;
Kill(ent, 0);
}
public TaskRespawn(taskID)
{
new ent = taskID - TASKID_SUM_RESPAWN;
Respawn(ent);
}
public TaskRemove(taskID)
{
new ent = taskID - TASKID_SUM_REMOVE;
Remove(ent);
}
Mensajes: 2,571
Temas: 40
Registro en: Feb 2014
Reputación:
72
¿Qué otros plugins tienes que interactúen con esta API? Posiblemente en alguno de aquellos tengas un model o sprite mal copiado (en el servidor y en tu cliente).
Mensajes: 145
Temas: 78
Registro en: Sep 2020
Reputación:
0
30/06/2021, 07:35 PM
(Última modificación: 30/06/2021, 07:38 PM por MalitoMaloso. Edited 1 time in total.)
api_particles.amxx
Código PHP: #pragma semicolon 1
#include <amxmodx>
#include <fakemeta>
#include <xs>
#define PLUGIN "[API] Particles"
#define VERSION "1.0.0"
#define AUTHOR "Hedgehog Fog"
#define TASKID_SUM_TARGET_TICK 1000
#define TASKID_SUM_REMOVE_TARGET 2000
#define TASKID_SUM_REMOVE_PARTICLE 3000
new Trie:g_particles;
new Array:g_particlePluginID;
new Array:g_particleFuncID;
new Array:g_particleSprites;
new Array:g_particleLifeTime;
new Array:g_particleScale;
new Array:g_particleRenderMode;
new Array:g_particleRenderAmt;
new Array:g_particleSpawnCount;
new g_particleCount = 0;
new g_ptrTargetClassname;
new g_ptrParticleClassname;
public plugin_precache()
{
g_ptrTargetClassname = engfunc(EngFunc_AllocString, "info_target");
g_ptrParticleClassname = engfunc(EngFunc_AllocString, "env_sprite");
}
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);
}
public plugin_end()
{
if (g_particleCount) {
TrieDestroy(g_particles);
ArrayDestroy(g_particlePluginID);
ArrayDestroy(g_particleFuncID);
ArrayDestroy(g_particleSprites);
ArrayDestroy(g_particleLifeTime);
ArrayDestroy(g_particleScale);
ArrayDestroy(g_particleRenderMode);
ArrayDestroy(g_particleRenderAmt);
ArrayDestroy(g_particleSpawnCount);
}
}
public plugin_natives()
{
register_library("api_particles");
register_native("Particles_Register", "Native_Register");
register_native("Particles_Spawn", "Native_Spawn");
register_native("Particles_Remove", "Native_Remove");
}
public Native_Register(pluginID, argc)
{
new szName[32];
get_string(1, szName, charsmax(szName));
new szTransformCallback[32];
get_string(2, szTransformCallback, charsmax(szTransformCallback));
new funcID = get_func_id(szTransformCallback, pluginID);
new Array:sprites = any:get_param(3);
new Float:fLifeTime = get_param_f(4);
new Float:fScale = get_param_f(5);
new renderMode = get_param(6);
new Float:fRenderAmt = get_param_f(7);
new spawnCount = get_param(8);
RegisterParticle(szName, pluginID, funcID, sprites, fLifeTime, fScale, renderMode, fRenderAmt, spawnCount);
}
public Native_Spawn(pluginID, argc)
{
new szName[32];
get_string(1, szName, charsmax(szName));
new Float:vOrigin[3];
get_array_f(2, vOrigin, sizeof(vOrigin));
new Float:fPlayTime = get_param_f(3);
return SpawnParticles(szName, vOrigin, fPlayTime);
}
public Native_Remove(pluginID, argc)
{
new ent = get_param(1);
RemoveParticles(ent);
}
RegisterParticle(const szName[], pluginID, funcID, Array:sprites, Float:fLifeTime, Float:fScale, renderMode, Float:fRenderAmt, spawnCount)
{
if (!g_particleCount) {
g_particles = TrieCreate();
g_particlePluginID = ArrayCreate();
g_particleFuncID = ArrayCreate();
g_particleSprites = ArrayCreate();
g_particleLifeTime = ArrayCreate();
g_particleScale = ArrayCreate();
g_particleRenderMode = ArrayCreate();
g_particleRenderAmt = ArrayCreate();
g_particleSpawnCount = ArrayCreate();
}
new index = g_particleCount;
TrieSetCell(g_particles, szName, index);
ArrayPushCell(g_particlePluginID, pluginID);
ArrayPushCell(g_particleFuncID, funcID);
ArrayPushCell(g_particleLifeTime, fLifeTime);
ArrayPushCell(g_particleScale, fScale);
ArrayPushCell(g_particleRenderMode, renderMode);
ArrayPushCell(g_particleRenderAmt, fRenderAmt);
ArrayPushCell(g_particleSpawnCount, spawnCount);
ArrayPushCell(g_particleSprites, sprites);
g_particleCount++;
return index;
}
SpawnParticles(const szName[], const Float:vOrigin[3], Float:fPlayTime)
{
if (!g_particleCount) {
return 0;
}
new index;
if (!TrieGetCell(g_particles, szName, index)) {
return 0;
}
new ent = engfunc(EngFunc_CreateNamedEntity, g_ptrTargetClassname);
engfunc(EngFunc_SetOrigin, ent, vOrigin);
dllfunc(DLLFunc_Spawn, ent);
set_pev(ent, pev_iuser1, index);
set_task(0.04, "TaskTargetTick", ent+TASKID_SUM_TARGET_TICK, _, _, "b");
if (fPlayTime > 0.0) {
set_task(fPlayTime, "TaskRemoveTarget", ent+TASKID_SUM_REMOVE_TARGET);
}
return ent;
}
RemoveParticles(ent)
{
remove_task(ent+TASKID_SUM_TARGET_TICK);
set_pev(ent, pev_flags, pev(ent, pev_flags) | FL_KILLME);
dllfunc(DLLFunc_Think, ent);
}
public TaskRemoveTarget(taskID)
{
new ent = taskID - TASKID_SUM_REMOVE_TARGET;
RemoveParticles(ent);
}
public TaskTargetTick(taskID)
{
new ent = taskID - TASKID_SUM_TARGET_TICK;
new index = pev(ent, pev_iuser1);
new pluginID = ArrayGetCell(g_particlePluginID, index);
new funcID = ArrayGetCell(g_particleFuncID, index);
new Float:fLifeTime = ArrayGetCell(g_particleLifeTime, index);
new Float:fScale = ArrayGetCell(g_particleScale, index);
new renderMode = ArrayGetCell(g_particleRenderMode, index);
new Float:fRenderAmt = ArrayGetCell(g_particleRenderAmt, index);
new spawnCount = ArrayGetCell(g_particleSpawnCount, index);
new Array:sprites = ArrayGetCell(g_particleSprites, index);
static Float:vOrigin[3];
static Float:vVelocity[3];
for (new i = 0; i < spawnCount; ++i)
{
pev(ent, pev_origin, vOrigin);
xs_vec_set(vVelocity, 0.0, 0.0, 0.0);
if (callfunc_begin_i(funcID, pluginID) == 1) {
callfunc_push_array(_:vOrigin, 3);
callfunc_push_array(_:vVelocity, 3);
callfunc_end();
}
static modelindex;
{
new size = ArraySize(sprites);
modelindex = ArrayGetCell(sprites, random(size));
}
static particleEnt;
{
particleEnt = engfunc(EngFunc_CreateNamedEntity, g_ptrParticleClassname);
engfunc(EngFunc_SetOrigin, particleEnt, vOrigin);
set_pev(particleEnt, pev_velocity, vVelocity);
set_pev(particleEnt, pev_modelindex, modelindex);
set_pev(particleEnt, pev_solid, SOLID_TRIGGER);
set_pev(particleEnt, pev_movetype, MOVETYPE_NOCLIP);
set_pev(particleEnt, pev_rendermode, renderMode);
set_pev(particleEnt, pev_renderamt, fRenderAmt);
set_pev(particleEnt, pev_scale, fScale);
set_task(fLifeTime, "TaskRemoveParticle", particleEnt+TASKID_SUM_REMOVE_PARTICLE);
}
}
}
public TaskRemoveParticle(taskID)
{
new ent = taskID - TASKID_SUM_REMOVE_PARTICLE;
set_pev(ent, pev_flags, pev(ent, pev_flags) | FL_KILLME);
dllfunc(DLLFunc_Think, ent);
}
api_player_burn.amxx
Código PHP: #pragma semicolon 1
#include <amxmodx>
#include <hamsandwich>
#include <fakemeta>
#define PLUGIN "[API] Player Burn"
#define VERSION "0.3.1"
#define AUTHOR "Hedgehog Fog"
#define MAX_PLAYERS 32
#define CBASEPLAYER_LINUX_OFFSET 5
#define m_flVelocityModifier 108
#define TASKID_SUM_BURN 1000
#define DMG_BURN_PAINSHOCK 0.5
#define DMG_BURN_AMOUNT 3.0
new Array:g_playerAttacker;
new g_flagPlayerBurn;
new g_sprFlame;
new g_sprSmoke;
new g_maxPlayers;
new const g_szSndBurn[] = "ambience/burning1.wav";
public plugin_precache()
{
g_sprFlame = precache_model("sprites/xffloor.spr");
g_sprSmoke = precache_model("sprites/black_smoke3.spr");
precache_sound(g_szSndBurn);
}
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);
RegisterHam(Ham_Spawn, "player", "on_player_spawn", .Post = 1);
RegisterHam(Ham_Killed, "player", "on_player_killed", .Post = 0);
RegisterHam(Ham_TakeDamage, "player", "on_player_takeDamage", .Post = 1);
RegisterHam(Ham_Player_PostThink, "player", "on_player_prethink", .Post = 1);
g_maxPlayers = get_maxplayers();
g_playerAttacker = ArrayCreate(1, g_maxPlayers+1);
for (new i = 0; i <= g_maxPlayers; ++i) {
ArrayPushCell(g_playerAttacker, 0);
}
}
public plugin_natives()
{
register_library("api_player_burn");
register_native("burn_player", "native_burn_player");
register_native("extinguish_player", "native_extinguish_player");
register_native("is_player_burn", "native_is_player_burn");
}
public plugin_end()
{
ArrayDestroy(g_playerAttacker);
}
/*----[ Natives ]----*/
public bool:native_is_player_burn(plugin_id, argc)
{
new id = get_param(1);
return is_player_burn(id);
}
public native_burn_player(plugin_id, argc)
{
new id = get_param(1);
new inflictor = get_param(2);
new burnTime = get_param(3);
burn_player(id, inflictor, burnTime);
}
public native_extinguish_player(plugin_id, argc)
{
new id = get_param(1);
extinguish_player(id);
}
/*----[ Private methods ]----*/
bool:is_player_burn(id)
{
if(g_flagPlayerBurn & (1 << (id & 31)))
return true;
return false;
}
burn_player(id, attacker, burnTime)
{
if(!is_user_alive(id))
return;
if(is_player_burn(id))
return;
g_flagPlayerBurn |= (1 << (id & 31));
ArraySetCell(g_playerAttacker, id, attacker);
remove_task(id+TASKID_SUM_BURN);
set_task(0.2, "task_player_burn_effect", id+TASKID_SUM_BURN, _, _, "b");
set_task(1.0, "task_player_burn_damage", id+TASKID_SUM_BURN, _, _, "b");
if(burnTime > 0)
set_task(float(burnTime), "task_player_extinguish", id+TASKID_SUM_BURN);
}
extinguish_player(id)
{
remove_task(id+TASKID_SUM_BURN);
g_flagPlayerBurn &= ~(1 << (id & 31));
ArraySetCell(g_playerAttacker, id, 0);
emit_sound(id, CHAN_VOICE, g_szSndBurn, VOL_NORM, ATTN_NORM, SND_STOP, PITCH_NORM);
}
/*----[ Events ]----*/
#if AMXX_VERSION_NUM < 183
public client_disconnect(id)
#else
public client_disconnected(id)
#endif
{
if(is_player_burn(id))
extinguish_player(id);
}
public on_player_killed(victim, attacker)
{
if(!is_player_burn(victim)) {
return;
}
if(!attacker) {
SetHamParamEntity(2, ArrayGetCell(g_playerAttacker, victim));
}
extinguish_player(victim);
}
public on_player_spawn(id)
{
if(!is_user_alive(id))
return;
if(is_player_burn(id)) {
extinguish_player(id);
}
}
public on_player_takeDamage(victim, inflictor, attacker, Float:damage, damageType)
{
if(attacker)
return;
if(!is_player_burn(victim))
return;
if(!(damageType & DMG_BURN))
return;
new Float:fPainShock = get_pdata_float(victim, m_flVelocityModifier, CBASEPLAYER_LINUX_OFFSET);
fPainShock = fPainShock/DMG_BURN_PAINSHOCK*0.80;
set_pdata_float(victim, m_flVelocityModifier, fPainShock, CBASEPLAYER_LINUX_OFFSET);
}
public on_player_prethink(id)
{
if (~pev(id, pev_flags) & FL_INWATER)
return;
if (!is_user_alive(id))
return;
if(is_player_burn(id))
extinguish_player(id);
}
/*----[ Tasks ]----*/
public task_player_burn_effect(taskID)
{
new id = taskID - TASKID_SUM_BURN;
if(!is_user_alive(id))
return;
static Float:fOrigin[3];
pev(id, pev_origin, fOrigin);
engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, fOrigin, 0);
write_byte(TE_SPRITE);
engfunc(EngFunc_WriteCoord, fOrigin[0]);
engfunc(EngFunc_WriteCoord, fOrigin[1]);
engfunc(EngFunc_WriteCoord, fOrigin[2]);
write_short(g_sprFlame);
write_byte(random_num(5, 10));
write_byte(200);
message_end();
engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, fOrigin, 0);
write_byte(TE_SMOKE);
engfunc(EngFunc_WriteCoord, fOrigin[0]);
engfunc(EngFunc_WriteCoord, fOrigin[1]);
engfunc(EngFunc_WriteCoord, fOrigin[2]-48.0);
write_short(g_sprSmoke);
write_byte(random_num(15, 20));
write_byte(random_num(10, 20));
message_end();
emit_sound(id, CHAN_VOICE, g_szSndBurn, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}
public task_player_burn_damage(taskID)
{
new id = taskID - TASKID_SUM_BURN;
if(!is_user_alive(id))
return;
UTIL_CS_DamagePlayer(id, DMG_BURN_AMOUNT, DMG_BURN, 0, 0);
}
public task_player_extinguish(taskID)
{
new id = taskID - TASKID_SUM_BURN;
extinguish_player(id);
}
stock UTIL_CS_DamagePlayer(victim, Float:fDamage, dmgbits = DMG_GENERIC, attacker = 0, inflictor = 0)
{
new armorType = get_pdata_int(victim, 112);
set_pdata_int(victim, 112, 0);
ExecuteHamB(Ham_TakeDamage, victim, inflictor, attacker, fDamage, dmgbits);
set_pdata_int(victim, 112, armorType);
}
api_player_cosmetic.amxx
Código PHP: #pragma semicolon 1
#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>
#include <nvault>
#include <api_player_inventory>
#include <api_player_cosmetic>
#define PLUGIN "[Player Inventory Item] Cosmetic"
#define VERSION "1.0.0"
#define AUTHOR "Hedgehog Fog"
#define TASKID_SUM_PLAYER_TIMER 1000
#define ITEM_TYPE "cosmetic"
#define UNUSUAL_ENTITY_RENDER_AMT 1.0
enum ItemState
{
ItemState_None = 0,
ItemState_Equiped,
ItemState_Equip,
ItemState_Unequip
};
enum ItemData
{
ItemData_Cosmetic = 0,
PCosmetic_Type:ItemData_CosmeticType,
ItemData_Time,
ItemState:ItemData_State,
ItemData_Entity
};
new Trie:g_cosmeticIndexes;
new Array:g_cosmeticName;
new Array:g_cosmeticGroups;
new Array:g_cosmeticModelIndex;
new Array:g_cosmeticUnusualColor;
new g_cosmeticCount = 0;
new Array:g_playerRenderMode;
new Array:g_playerRenderAmt;
new g_allocClassname;
new PInv_ItemType:g_itemType;
new g_hVault;
new g_maxPlayers;
public plugin_precache()
{
g_allocClassname = engfunc(EngFunc_AllocString, "info_target");
g_hVault = nvault_open("api_player_cosmetic");
g_itemType = PInv_RegisterItemType(ITEM_TYPE);
}
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);
RegisterHam(Ham_Spawn, "player", "OnPlayerSpawn", .Post = 1);
RegisterHam(Ham_Killed, "player", "OnPlayerKilled", .Post = 1);
g_playerRenderMode = ArrayCreate(1, g_maxPlayers+1);
g_playerRenderAmt = ArrayCreate(1, g_maxPlayers+1);
g_maxPlayers = get_maxplayers();
for (new i = 0; i <= g_maxPlayers; ++i) {
ArrayPushCell(g_playerRenderMode, 0);
ArrayPushCell(g_playerRenderAmt, 0);
}
}
public plugin_natives()
{
register_library("api_player_cosmetic");
register_native("PCosmetic_Register", "Native_Register");
register_native("PCosmetic_Give", "Native_Give");
register_native("PCosmetic_Equip", "Native_Equip");
register_native("PCosmetic_Unequip", "Native_Unequip");
register_native("PCosmetic_IsItemEquiped", "Native_IsItemEquiped");
register_native("PCosmetic_CanBeEquiped", "Native_CanBeEquiped");
register_native("PCosmetic_GetItemCosmetic", "Native_GetItemCosmetic");
register_native("PCosmetic_GetItemCosmeticType", "Native_GetItemCosmeticType");
register_native("PCosmetic_GetItemTime", "Native_GetItemTime");
register_native("PCosmetic_GetCosmeticName", "Native_GetCosmeticName");
register_native("PCosmetic_GetCosmeticGroups", "Native_GetCosmeticGroups");
}
public plugin_end()
{
ArrayDestroy(g_playerRenderMode);
ArrayDestroy(g_playerRenderAmt);
}
#if AMXX_VERSION_NUM < 183
public client_disconnect(id)
#else
public client_disconnected(id)
#endif
{
new size = PInv_Size(id);
for (new i = 0; i < size; ++i)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, i);
if (itemType != g_itemType) {
continue;
}
Unequip(id, i, .changeState = false);
}
ClearPlayerTasks(id);
}
/*--------------------------------[ Hooks ]--------------------------------*/
public OnPlayerSpawn(id)
{
if (!is_user_alive(id)) {
return;
}
UpdateEquipment(id);
SetupPlayerTasks(id);
}
public OnPlayerKilled(id)
{
ClearPlayerTasks(id);
}
/*--------------------------------[ Natives ]--------------------------------*/
public Native_Register(pluginID, argc)
{
new szName[32];
get_string(1, szName, charsmax(szName));
new PCosmetic_Groups:groups = PCosmetic_Groups:get_param(2);
new modelIndex = get_param(3);
new Float:color[3];
get_array_f(4, color, 3);
return Register(szName, groups, modelIndex, color);
}
public Native_Give(pluginID, argc)
{
new id = get_param(1);
new cosmetic = get_param(2);
new PCosmetic_Type:cosmeticType = PCosmetic_Type:get_param(3);
new time = get_param(4);
return Give(id, cosmetic, cosmeticType, time);
}
public Native_GetCosmeticName(pluginID, argc)
{
new cosmetic = get_param(1);
new maxlen = get_param(3);
static szName[32];
ArrayGetString(g_cosmeticName, cosmetic, szName, charsmax(szName));
set_string(2, szName, maxlen);
}
public Native_GetCosmeticGroups(pluginID, argc)
{
new cosmetic = get_param(1);
return ArrayGetCell(g_cosmeticGroups, cosmetic);
}
public Native_Equip(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:item = Array:PInv_GetItem(id, slotIdx);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState == ItemState_None) {
itemState = ItemState_Equip;
} else if (itemState == ItemState_Unequip) {
itemState = ItemState_Equiped;
}
ArraySetCell(item, _:ItemData_State, itemState);
}
public Native_Unequip(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:item = Array:PInv_GetItem(id, slotIdx);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState == ItemState_Equiped) {
itemState = ItemState_Unequip;
} else if (itemState == ItemState_Equip) {
itemState = ItemState_None;
}
ArraySetCell(item, _:ItemData_State, itemState);
}
public Native_IsItemEquiped(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:item = Array:PInv_GetItem(id, slotIdx);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
return (itemState == ItemState_Equiped || itemState == ItemState_Equip);
}
public Native_CanBeEquiped(pluginID, argc)
{
new id = get_param(1);
new cosmetic = get_param(2);
new ignoreSlotIdx = get_param(3);
return CanBeEquiped(id, cosmetic, ignoreSlotIdx);
}
public Native_GetItemCosmetic(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:item = Array:PInv_GetItem(id, slotIdx);
return ArrayGetCell(item, _:ItemData_Cosmetic);
}
public Native_GetItemCosmeticType(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:item = Array:PInv_GetItem(id, slotIdx);
return ArrayGetCell(item, _:ItemData_CosmeticType);
}
public Native_GetItemTime(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:item = Array:PInv_GetItem(id, slotIdx);
return ArrayGetCell(item, _:ItemData_Time);
}
/*--------------------------------[ Events ]--------------------------------*/
public PInv_Event_SlotLoaded(id, slotIdx)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, slotIdx);
if (PInv_ItemType:itemType != g_itemType) {
return; //Invalid item type
}
new item = PInv_GetItem(id, slotIdx);
new cosmetic;
new PCosmetic_Type:cosmeticType;
new itemTime;
new ItemState:itemState;
if (item == _:Invalid_Array) {
return; //Handler is invalid
}
if (!LoadItem(item, cosmetic, cosmeticType, itemTime, itemState)) {
PInv_SetItem(id, slotIdx, Invalid_Array, PInv_Invalid_ItemType);
PInv_TakeItem(id, slotIdx);
return; //Invalid cosmetic
}
item = _:CreateCosmetic(cosmetic, cosmeticType, itemTime);
if (itemState == ItemState_Equiped) {
itemState = ItemState_Equip;
} else if (itemState == ItemState_Unequip) {
itemState = ItemState_None;
}
PInv_SetItem(id, slotIdx, item, g_itemType);
ArraySetCell(Array:item, _:ItemData_State, itemState); //Change state of item
}
public PInv_Event_SlotSaved(id, slotIdx)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, slotIdx);
if (itemType != g_itemType) {
return; //Invalid item type
}
new item = PInv_GetItem(id, slotIdx);
if (item == _:Invalid_Array) {
return; //Handler is invalid
}
SaveItem(item); //Save data about handler
}
public PInv_Event_TakeSlot(id, slotIdx)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, slotIdx);
if (itemType != g_itemType) {
return; //Invalid item type
}
new Array:item = PInv_GetItem(id, slotIdx);
if (item == Invalid_Array) {
return; //Handler is invalid
}
ArrayDestroy(item);
}
public PInv_Event_Destroy()
{
TrieDestroy(g_cosmeticIndexes);
if (g_cosmeticCount) {
ArrayDestroy(g_cosmeticName);
ArrayDestroy(g_cosmeticGroups);
ArrayDestroy(g_cosmeticModelIndex);
ArrayDestroy(g_cosmeticUnusualColor);
}
nvault_close(g_hVault);
}
/*--------------------------------[ Methods ]--------------------------------*/
Array:CreateCosmetic(cosmetic, PCosmetic_Type:cosmeticType, time)
{
new Array:item = ArrayCreate(1, _:ItemData);
for (new i = 0; i < _:ItemData; ++i) {
ArrayPushCell(item, 0);
}
ArraySetCell(item, _:ItemData_Cosmetic, cosmetic);
ArraySetCell(item, _:ItemData_CosmeticType, cosmeticType);
ArraySetCell(item, _:ItemData_Time, time);
ArraySetCell(item, _:ItemData_State, ItemState_None);
return item;
}
Register(const szName[], PCosmetic_Groups:groups, modelIndex, const Float:unusualColor[3])
{
if (!g_cosmeticCount) {
g_cosmeticName = ArrayCreate(32);
g_cosmeticGroups = ArrayCreate();
g_cosmeticModelIndex = ArrayCreate();
g_cosmeticUnusualColor = ArrayCreate(3);
g_cosmeticIndexes = TrieCreate();
}
ArrayPushString(g_cosmeticName, szName);
ArrayPushCell(g_cosmeticGroups, groups);
ArrayPushCell(g_cosmeticModelIndex, modelIndex);
ArrayPushArray(g_cosmeticUnusualColor, unusualColor);
new cosmetic = g_cosmeticCount;
TrieSetCell(g_cosmeticIndexes, szName, cosmetic);
g_cosmeticCount++;
return cosmetic;
}
Give(id, cosmetic, PCosmetic_Type:cosmeticType, time)
{
new slotIdx = -1;
new Array:item = Invalid_Array;
new size = PInv_Size(id);
for (new i = 0; i < size; ++i)
{
if (g_itemType != PInv_GetItemType(id, i)) {
continue;
}
item = Array:PInv_GetItem(id, i);
new itemCosmetic = ArrayGetCell(item, _:ItemData_Cosmetic);
new PCosmetic_Type:itemCosmeticType = ArrayGetCell(item, _:ItemData_CosmeticType);
if (cosmetic == itemCosmetic && cosmeticType == itemCosmeticType) {
slotIdx = i;
break;
}
}
if (slotIdx == -1) {
item = CreateCosmetic(cosmetic, cosmeticType, time);
slotIdx = PInv_GiveItem(id, item, g_itemType);
}
return slotIdx;
}
Equip(id, slotIdx)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, slotIdx);
if (itemType != g_itemType) {
return; //Is not a cosmetic
}
new Array:item = Array:PInv_GetItem(id, slotIdx);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState == ItemState_Equiped) {
return; //Already equiped
}
new cosmetic = ArrayGetCell(item, _:ItemData_Cosmetic);
if (!CanBeEquiped(id, cosmetic, slotIdx)) {
return; //Can't be equiped
}
new PCosmetic_Type:cosmeticType = ArrayGetCell(item, _:ItemData_CosmeticType);
new ent = CreateCosmeticEntity(id, cosmetic, cosmeticType);
ArraySetCell(item, _:ItemData_Entity, ent);
ArraySetCell(item, _:ItemData_State, ItemState_Equiped);
}
Unequip(id, slotIdx, bool:changeState = true)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, slotIdx);
if (itemType != g_itemType) {
return; //Is not a cosmetic
}
new Array:item = Array:PInv_GetItem(id, slotIdx);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState == ItemState_None) {
return; //Not equiped
}
new ent = ArrayGetCell(item, _:ItemData_Entity);
if (pev_valid(ent)) {
set_pev(ent, pev_movetype, MOVETYPE_NONE);
set_pev(ent, pev_aiment, 0);
engfunc(EngFunc_RemoveEntity, ent);
}
ArraySetCell(item, _:ItemData_Entity, 0);
if (changeState) {
ArraySetCell(item, _:ItemData_State, ItemState_None);
}
new itemTime = ArrayGetCell(item, _:ItemData_Time);
if (itemTime <= 0) {
PInv_TakeItem(id, slotIdx);
}
}
bool:CanBeEquiped(id, cosmetic, ignoreSlotIdx = -1)
{
new cosmeticGroups = ArrayGetCell(g_cosmeticGroups, cosmetic);
new size = PInv_Size(id);
for (new i = 0; i < size; ++i)
{
if (i == ignoreSlotIdx) {
continue;
}
new PInv_ItemType:itemType = PInv_GetItemType(id, i);
if (itemType != g_itemType) {
continue;
}
new Array:item = Array:PInv_GetItem(id, i);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState != ItemState_Equiped && itemState != ItemState_Equip) {
continue; //This item not equiped.
}
new itemCosmetic = ArrayGetCell(item, _:ItemData_Cosmetic);
if (cosmetic == itemCosmetic) {
return false; //This item is already equiped
}
new itemCosmeticGroups = ArrayGetCell(g_cosmeticGroups, itemCosmetic);
if (cosmeticGroups & itemCosmeticGroups) {
return false; //Item with some groups already equiped
}
}
return true;
}
CreateCosmeticEntity(owner, cosmetic, PCosmetic_Type:type = PCosmetic_Type_Normal)
{
new ent = engfunc(EngFunc_CreateNamedEntity, g_allocClassname);
set_pev(ent, pev_movetype, MOVETYPE_FOLLOW);
set_pev(ent, pev_aiment, owner);
if (type == PCosmetic_Type_Unusual) {
static Float:color[3];
ArrayGetArray(g_cosmeticUnusualColor, cosmetic, color);
set_pev(ent, pev_renderfx, kRenderFxGlowShell);
set_pev(ent, pev_rendercolor, color);
set_pev(ent, pev_renderamt, UNUSUAL_ENTITY_RENDER_AMT);
}
new modelIndex = ArrayGetCell(g_cosmeticModelIndex, cosmetic);
set_pev(ent, pev_modelindex, modelIndex);
return ent;
}
UpdateEquipment(id)
{
if (!g_cosmeticCount) {
return;
}
new size = PInv_Size(id);
for (new i = 0; i < size; ++i)
{
new PInv_ItemType:itemType = PInv_GetItemType(id, i);
if (itemType != g_itemType) {
continue; //Invalid item type
}
new Array:item = Array:PInv_GetItem(id, i);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState == ItemState_Equip) {
Equip(id, i);
} else if (itemState == ItemState_Unequip) {
Unequip(id, i);
}
}
}
SetupPlayerTasks(id)
{
if (!task_exists(id)) {
set_task(0.1, "TaskPlayerThink", id, _, _, "b");
}
if (!task_exists(id+TASKID_SUM_PLAYER_TIMER)) {
set_task(1.0, "TaskPlayerTimer", id+TASKID_SUM_PLAYER_TIMER, _, _, "b");
}
}
ClearPlayerTasks(id)
{
remove_task(id);
remove_task(id+TASKID_SUM_PLAYER_TIMER);
}
/*--------------------------------[ Vault ]--------------------------------*/
bool:LoadItem(any:item, &cosmetic, &PCosmetic_Type:cosmeticType, &itemTime, &ItemState:itemState)
{
if (!g_cosmeticCount) {
return false;
}
new szKey[32];
new szValue[32];
//cosmetic;
{
format(szKey, charsmax(szKey), "%i_name", item);
nvault_get(g_hVault, szKey, szValue, charsmax(szValue));
nvault_remove(g_hVault, szKey);
if (szValue[0] == '^0') {
return false;
}
if (!TrieKeyExists(g_cosmeticIndexes, szValue)) {
return false;
}
//Get index by name
if (!TrieGetCell(g_cosmeticIndexes, szValue, cosmetic)) {
return false;
}
}
//cosmeticType;
{
format(szKey, charsmax(szKey), "%i_cosmeticType", item);
cosmeticType = PCosmetic_Type:nvault_get(g_hVault, szKey);
nvault_remove(g_hVault, szKey);
}
//itemTime;
{
format(szKey, charsmax(szKey), "%i_time", item);
itemTime = nvault_get(g_hVault, szKey);
nvault_remove(g_hVault, szKey);
}
//ItemState:itemState;
{
format(szKey, charsmax(szKey), "%i_state", item);
itemState = ItemState:nvault_get(g_hVault, szKey);
nvault_remove(g_hVault, szKey);
}
return true;
}
SaveItem(any:item)
{
new itemTime = ArrayGetCell(item, _:ItemData_Time);
if (itemTime <= 0) {
return;
}
new szKey[32];
new szValue[32];
new cosmetic = ArrayGetCell(item, _:ItemData_Cosmetic);
{
format(szKey, charsmax(szKey), "%i_name", item);
ArrayGetString(g_cosmeticName, cosmetic, szValue, charsmax(szValue));
nvault_set(g_hVault, szKey, szValue);
}
new cosmeticType = ArrayGetCell(item, _:ItemData_CosmeticType);
{
format(szKey, charsmax(szKey), "%i_cosmeticType", item);
format(szValue, charsmax(szValue), "%i", cosmeticType);
nvault_set(g_hVault, szKey, szValue);
}
//itemTime
{
format(szKey, charsmax(szKey), "%i_time", item);
format(szValue, charsmax(szValue), "%i", itemTime);
nvault_set(g_hVault, szKey, szValue);
}
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
{
format(szKey, charsmax(szKey), "%i_state", item);
format(szValue, charsmax(szValue), "%i", itemState);
nvault_set(g_hVault, szKey, szValue);
}
}
/*--------------------------------[ Tasks ]--------------------------------*/
public TaskPlayerTimer(taskID)
{
new id = taskID - TASKID_SUM_PLAYER_TIMER;
if (!is_user_alive(id)) {
return;
}
new size = PInv_Size(id);
for (new i = 0; i < size; ++i)
{
if (g_itemType != PInv_GetItemType(id, i)) {
continue; //Invalid item type
}
new Array:item = Array:PInv_GetItem(id, i);
new ItemState:itemState = ArrayGetCell(item, _:ItemData_State);
if (itemState == ItemState_None) {
continue; //This item not equiped.
}
if (itemState == ItemState_Equip) {
continue; //This item not equiped.
}
new time = ArrayGetCell(item, _:ItemData_Time) - 1;
if (time >= 0) {
ArraySetCell(item, _:ItemData_Time, time);
} else {
ArraySetCell(item, _:ItemData_State, ItemState_Unequip);
}
}
}
public TaskPlayerThink(id)
{
new renderMode = pev(id, pev_rendermode);
static Float:renderAmt;
pev(id, pev_renderamt, renderAmt);
if (renderMode != ArrayGetCell(g_playerRenderMode, id)
|| renderAmt != ArrayGetCell(g_playerRenderAmt, id))
{
ArraySetCell(g_playerRenderMode, id, renderMode);
ArraySetCell(g_playerRenderAmt, id, renderAmt);
new size = PInv_Size(id);
for (new i = 0; i < size; ++i)
{
if (g_itemType != PInv_GetItemType(id, i)) {
continue;
}
new Array:item = Array:PInv_GetItem(id, i);
if (ArrayGetCell(item, _:ItemData_State) != ItemState_Equiped
&& ArrayGetCell(item, _:ItemData_State) != ItemState_Unequip) {
continue;
}
new ent = ArrayGetCell(item, _:ItemData_Entity);
if (!ent) {
continue;
}
set_pev(ent, pev_rendermode, renderMode);
if (ArrayGetCell(item, _:ItemData_CosmeticType) == PCosmetic_Type_Normal) {
set_pev(ent, pev_renderamt, renderAmt);
} else {
set_pev(ent, pev_renderamt, UNUSUAL_ENTITY_RENDER_AMT);
}
}
}
}
api_player_inventory.amxx
Código PHP: #pragma semicolon 1
#include <amxmodx>
#include <cellarray>
#include <celltrie>
#include <nvault>
#include <api_player_inventory>
#define PLUGIN "[API] Player Inventory"
#define VERSION "1.0.0"
#define AUTHOR "Hedgehog Fog"
enum _:Slot
{
Slot_Item,
Slot_ItemType
};
new g_fwNewSlot;
new g_fwTakeSlot;
new g_fwSlotLoaded;
new g_fwSlotSaved;
new g_fwResult;
new g_fwDestroy;
new g_hVault;
new Array:g_playerInventories;
new Trie:g_itemTypeHandlers;
new Array:g_itemTypeNames;
new g_itemTypeCount = 0;
new Array:g_userAuthID;
new g_maxPlayers;
public plugin_precache()
{
g_hVault = nvault_open("api_player_inventory");
g_fwNewSlot = CreateMultiForward("PInv_Event_NewSlot", ET_IGNORE, FP_CELL, FP_CELL);
g_fwTakeSlot = CreateMultiForward("PInv_Event_TakeSlot", ET_IGNORE, FP_CELL, FP_CELL);
g_fwSlotLoaded = CreateMultiForward("PInv_Event_SlotLoaded", ET_IGNORE, FP_CELL, FP_CELL);
g_fwSlotSaved = CreateMultiForward("PInv_Event_SlotSaved", ET_IGNORE, FP_CELL, FP_CELL);
g_fwDestroy = CreateMultiForward("PInv_Event_Destroy", ET_IGNORE);
}
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);
g_maxPlayers = get_maxplayers();
g_playerInventories = ArrayCreate(1, g_maxPlayers+1);
for (new i = 0; i <= g_maxPlayers; ++i) {
ArrayPushCell(g_playerInventories, Invalid_Array);
}
}
public plugin_end()
{
for (new id = 1; id <= g_maxPlayers; ++id) {
SavePlayerInventory(id);
DestroyPlayerInventory(id);
}
ArrayDestroy(g_playerInventories);
if (g_itemTypeCount) {
TrieDestroy(g_itemTypeHandlers);
ArrayDestroy(g_itemTypeNames);
}
if (g_userAuthID != Invalid_Array) {
ArrayDestroy(g_userAuthID);
}
nvault_close(g_hVault);
ExecuteForward(g_fwDestroy, g_fwResult);
}
public plugin_natives()
{
register_library("api_player_inventory");
register_native("PInv_RegisterItemType", "Native_RegisterItemType");
register_native("PInv_GetItemTypeHandler", "Native_GetItemTypeHandler");
register_native("PInv_GetItem", "Native_GetItem");
register_native("PInv_GetItemType", "Native_GetItemType");
register_native("PInv_GiveItem", "Native_GiveItem");
register_native("PInv_TakeItem", "Native_TakeItem");
register_native("PInv_SetItem", "Native_SetItem");
register_native("PInv_Size", "Native_Size");
}
public client_authorized(id)
{
if (g_userAuthID == Invalid_Array) {
g_userAuthID = ArrayCreate(32, g_maxPlayers+1);
for (new i = 0; i <= g_maxPlayers; ++i) {
ArrayPushCell(g_userAuthID, 0);
}
}
static authID[32];
get_user_authid(id, authID, charsmax(authID));
ArraySetString(g_userAuthID, id, authID);
}
public client_putinserver(id)
{
LoadPlayerInventory(id);
}
#if AMXX_VERSION_NUM < 183
public client_disconnect(id)
#else
public client_disconnected(id)
#endif
{
SavePlayerInventory(id);
}
/*--------------------------------[ Natives ]--------------------------------*/
public Native_RegisterItemType(pluginID, argc)
{
new typeName[32];
get_string(1, typeName, charsmax(typeName));
return RegisterItemType(typeName);
}
public PInv_ItemType:Native_GetItemTypeHandler(pluginID, argc)
{
new typeName[32];
get_string(1, typeName, charsmax(typeName));
new PInv_ItemType:itemType;
if (!TrieGetCell(g_itemTypeHandlers, typeName, itemType)) {
return PInv_Invalid_ItemType;
}
return itemType;
}
public Native_GetItem(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:inventory = ArrayGetCell(g_playerInventories, id);
new Array:slot = ArrayGetCell(inventory, slotIdx);
new item = ArrayGetCell(slot, Slot_Item);
return item;
}
public Native_GetItemType(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new Array:inventory = ArrayGetCell(g_playerInventories, id);
new Array:slot = ArrayGetCell(inventory, slotIdx);
new itemType = ArrayGetCell(slot, Slot_ItemType);
return itemType;
}
public Native_GiveItem(pluginID, argc)
{
new id = get_param(1);
new item = get_param(2);
new itemType = get_param(3);
return GiveItem(id, item, itemType);
}
public Native_TakeItem(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
TakeItem(id, slotIdx);
}
public Native_SetItem(pluginID, argc)
{
new id = get_param(1);
new slotIdx = get_param(2);
new item = get_param(3);
new itemType = get_param(4);
SetItem(id, slotIdx, item, itemType);
}
public Native_Size(pluginID, argc)
{
new id = get_param(1);
new Array:inventory = ArrayGetCell(g_playerInventories, id);
if (inventory == Invalid_Array) {
return 0;
}
return ArraySize(inventory);
}
/*--------------------------------[ Methods ]--------------------------------*/
RegisterItemType(const szTypeName[])
{
if (!g_itemTypeCount) {
g_itemTypeHandlers = TrieCreate();
g_itemTypeNames = ArrayCreate(32);
}
new itemType = g_itemTypeCount;
ArrayPushString(g_itemTypeNames, szTypeName);
TrieSetCell(g_itemTypeHandlers, szTypeName, itemType);
g_itemTypeCount++;
return itemType;
}
GetItemTypeIndex(const szTypeName[])
{
if (!g_itemTypeHandlers) {
return -1;
}
new type = 0;
if (!TrieGetCell(g_itemTypeHandlers, szTypeName, type)) {
return -1;
}
return type;
}
GetItemTypeName(itemType, szTypeName[], maxlen)
{
ArrayGetString(g_itemTypeNames, itemType, szTypeName, maxlen);
}
Array:CreatePlayerInventory(id)
{
new Array:inventory = ArrayCreate(1);
ArraySetCell(g_playerInventories, id, inventory);
return inventory;
}
Array:DestroyPlayerInventory(id)
{
new Array:inventory = ArrayGetCell(g_playerInventories, id);
if (inventory == Invalid_Array) {
return;
}
ArrayDestroy(inventory);
}
Array:ClearPlayerInventory(id)
{
new Array:inventory = ArrayGetCell(g_playerInventories, id);
if (inventory == Invalid_Array) {
return;
}
ArrayClear(inventory);
}
AddSlot(Array:inventory)
{
new Array:slot = ArrayCreate(1, Slot);
for (new i = 0; i < Slot; ++i) {
ArrayPushCell(slot, 0);
}
new index = ArraySize(inventory);
ArrayPushCell(inventory, slot);
return index;
}
GiveItem(id, item, itemType)
{
if (itemType == _:PInv_Invalid_ItemType) {
return -1;
}
new Array:inventory = ArrayGetCell(g_playerInventories, id);
if (inventory == Invalid_Array) {
inventory = CreatePlayerInventory(id);
}
new slotIdx = AddSlot(inventory);
new Array:slot = ArrayGetCell(inventory, slotIdx);
ArraySetCell(slot, Slot_Item, item);
ArraySetCell(slot, Slot_ItemType, itemType);
ExecuteForward(g_fwNewSlot, g_fwResult, id, slotIdx);
return slotIdx;
}
TakeItem(id, slotIdx)
{
ExecuteForward(g_fwTakeSlot, g_fwResult, id, slotIdx);
new Array:inventory = ArrayGetCell(g_playerInventories, id);
new Array:slot = ArrayGetCell(inventory, slotIdx);
ArraySetCell(slot, Slot_ItemType, PInv_Invalid_ItemType);
}
SetItem(id, slotIdx, item, itemType)
{
new Array:inventory = ArrayGetCell(g_playerInventories, id);
new Array:slot = ArrayGetCell(inventory, slotIdx);
ArraySetCell(slot, Slot_Item, item);
ArraySetCell(slot, Slot_ItemType, itemType);
}
/*--------------------------------[ Vault ]--------------------------------*/
LoadPlayerInventory(id)
{
ClearPlayerInventory(id);
new authID[32];
ArrayGetString(g_userAuthID, id, authID, charsmax(authID));
new key[32];
new size;
{
format(key, charsmax(key), "%s_size", authID);
size = nvault_get(g_hVault, key);
}
//Save items
for (new i = 0; i < size; ++i)
{
static typeName[32];
new itemType;
{
format(key, charsmax(key), "%s_%i_itemType", authID, i);
nvault_get(g_hVault, key, typeName, charsmax(typeName));
itemType = GetItemTypeIndex(typeName);
}
/*if (itemType == _:PInv_Invalid_ItemType) {
continue;
}*/
new item;
{
format(key, charsmax(key), "%s_%i_item", authID, i);
item = nvault_get(g_hVault, key);
}
new slotIdx = GiveItem(id, item, itemType);
ExecuteForward(g_fwSlotLoaded, g_fwResult, id, slotIdx);
}
}
SavePlayerInventory(id)
{
if (g_userAuthID == Invalid_Array) {
return;
}
new Array:inventory = ArrayGetCell(g_playerInventories, id);
if (inventory == Invalid_Array) {
return;
}
new size = ArraySize(inventory);
if (!size) {
return;
}
new authID[32];
ArrayGetString(g_userAuthID, id, authID, charsmax(authID));
new key[32];
new value[32];
//Save items
new inventorySize = 0;
for (new i = 0; i < size; ++i)
{
new Array:slot = ArrayGetCell(inventory, i);
new itemType = ArrayGetCell(slot, Slot_ItemType);
if (itemType == _:PInv_Invalid_ItemType) {
continue;
}
new item = ArrayGetCell(slot, Slot_Item);
{
format(key, charsmax(key), "%s_%i_item", authID, inventorySize);
format(value, charsmax(value), "%i", item);
nvault_set(g_hVault, key, value);
}
//itemType
{
static itemTypeName[32];
format(key, charsmax(key), "%s_%i_itemType", authID, inventorySize);
GetItemTypeName(itemType, itemTypeName, charsmax(itemTypeName));
nvault_set(g_hVault, key, itemTypeName);
}
inventorySize++;
ExecuteForward(g_fwSlotSaved, g_fwResult, id, i);
}
//Save inventory size
{
format(key, charsmax(key), "%s_size", authID);
format(value, charsmax(value), "%i", inventorySize);
nvault_set(g_hVault, key, value);
}
}
esos serian
Mensajes: 2,571
Temas: 40
Registro en: Feb 2014
Reputación:
72
No me sirve el código xD
Me refiero a los models / sprites. Vuelve a instalarlos en tu servidor y cópialos en tu cliente.
|
