fix(events): EventResult Handled not being considered & Event Object Lifetime

skuzzis · skuzzis · commit ba74d1d45062 · 2025-05-31T21:48:45.000Z
diff --git a/src/core/entrypoint.cpp b/src/core/entrypoint.cpp
@@ -246,19 +246,21 @@ bool SwiftlyS2::Unload(char* error, size_t maxlen)
 
 bool OnClientCommand(int playerid, std::string command)
 {
-    ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);
-    g_pluginManager.ExecuteEvent("core", "OnClientCommand", { playerid, command }, &data);
+    ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+    g_pluginManager.ExecuteEvent("core", "OnClientCommand", { playerid, command }, data);
 
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetAnyData("event_return"));
+        response = std::any_cast<bool>(data->GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
         response = true;
     }
 
+    delete data;
+
     return response;
 }
 
diff --git a/src/entities/system.cpp b/src/entities/system.cpp
@@ -64,4 +64,9 @@ void EntitySystem::AcceptInput(void* entity, std::string input, void* activator,
 {
     variant_t variantValue = variant_t(value.c_str());
     g_GameData.FetchSignature<CEntityInstance_AcceptInput>("CEntityInstance_AcceptInput")(entity, input.c_str(), activator, caller, &variantValue, outputID);
+}
+
+bool EntitySystem::IsValidEntity(void* entity)
+{
+    return entity != nullptr;
 }
diff --git a/src/entities/system.h b/src/entities/system.h
@@ -29,6 +29,8 @@ class EntitySystem
     void Despawn(void* entity);
     void* CreateByName(const char* name);
     void AcceptInput(void* entity, std::string input, void* activator, void* caller, std::string value, int outputID);
+
+    bool IsValidEntity(void* entity);
 };
 
 class CEntityListener : public IEntityListener
diff --git a/src/network/usermessages/usermessages.cpp b/src/network/usermessages/usermessages.cpp
@@ -31,8 +31,9 @@ bool UserMessages::FilterMessage(const CNetMessage* cMsg, INetChannel* netchan)
     if (!client) RETURN_META_VALUE(MRES_IGNORED, true);
 
     UserMessage um(cMsg->GetNetMessage(), const_cast<CNetMessage*>(cMsg), (uint64_t*)0);
-    ClassData umobj({ { "um_ptr", &um } }, "UserMessage", nullptr);
-    auto result = g_pluginManager.ExecuteEvent("core", "OnUserMessageReceive", { client->GetPlayerSlot().Get(), &umobj }, {});
+    ClassData* umobj = new ClassData({ { "um_ptr", &um } }, "UserMessage", nullptr);
+    auto result = g_pluginManager.ExecuteEvent("core", "OnUserMessageReceive", { client->GetPlayerSlot().Get(), umobj }, {});
+    delete umobj;
     if (result != EventResult::Continue)
         RETURN_META_VALUE(MRES_SUPERCEDE, true);
 
@@ -50,8 +51,12 @@ void UserMessages::Destroy()
 void UserMessages::PostEvent(CSplitScreenSlot nSlot, bool bLocalOnly, int nClientCount, const uint64* clients, INetworkMessageInternal* pEvent, const CNetMessage* pData, unsigned long nSize, NetChannelBufType_t bufType)
 {
     UserMessage um(pEvent, const_cast<CNetMessage*>(pData), (uint64_t*)(const_cast<uint64*>(clients)));
-    ClassData umobj({ { "um_ptr", &um } }, "UserMessage", nullptr);
+    ClassData* umobj = new ClassData({ { "um_ptr", &um } }, "UserMessage", nullptr);
 
-    if (g_pluginManager.ExecuteEvent("core", "OnUserMessageSend", { &umobj, bufType == BUF_RELIABLE }, {}) == EventResult::Stop)
+    if (g_pluginManager.ExecuteEvent("core", "OnUserMessageSend", { umobj, bufType == BUF_RELIABLE }, {}) == EventResult::Stop) {
+        delete umobj;
         RETURN_META(MRES_SUPERCEDE);
+    }
+
+    delete umobj;
 }
diff --git a/src/plugins/manager.cpp b/src/plugins/manager.cpp
@@ -216,9 +216,9 @@ std::string PluginsManager::GetPluginBasePath(std::string plugin_name)
 
 EXT_API int swiftly_TriggerEvent(const char* ext_name, const char* evName, void* args, void* eventReturn)
 {
-    ClassData data({ { "plugin_name", std::string(ext_name) } }, "Event", nullptr);
-    auto result = g_pluginManager.ExecuteEvent(ext_name, evName, *(std::vector<std::any>*)args, &data);
-    *reinterpret_cast<std::any*>(eventReturn) = data.GetAnyData("event_return");
-
+    ClassData* data = new ClassData({ { "plugin_name", std::string(ext_name) } }, "Event", nullptr);
+    auto result = g_pluginManager.ExecuteEvent(ext_name, evName, *(std::vector<std::any>*)args, data);
+    *reinterpret_cast<std::any*>(eventReturn) = data->GetAnyData("event_return");
+    delete data;
     return (int)result;
 }
diff --git a/src/plugins/object.cpp b/src/plugins/object.cpp
@@ -77,7 +77,7 @@ EventResult PluginObject::TriggerEvent(std::string invokedBy, std::string eventN
         if (value.isNumber())
         {
             int result = value.cast<int>();
-            if (result < (int)EventResult::Continue || result >(int)EventResult::Stop)
+            if (result < (int)EventResult::Continue || result >(int)EventResult::Handled)
                 response = EventResult::Continue;
             else
                 response = (EventResult)result;
diff --git a/src/scripting/engine/gameevents.cpp b/src/scripting/engine/gameevents.cpp
@@ -29,18 +29,19 @@ FunctionHook CCSPlayerPawnBase_PostThink("CCSPlayerPawnBase_PostThink", dyno::Ca
 
 bool OnClientChat(int playerid, std::string text, bool teamonly)
 {
-    ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);
-    g_pluginManager.ExecuteEvent("core", "OnClientChat", { playerid, text, teamonly }, &data);
+    ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+    g_pluginManager.ExecuteEvent("core", "OnClientChat", { playerid, text, teamonly }, data);
 
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetAnyData("event_return"));
+        response = std::any_cast<bool>(data->GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
         response = true;
     }
+    delete data;
 
     return response;
 }
@@ -52,18 +53,19 @@ void OnClientConvarQuery(int playerid, std::string convar_name, std::string conv
 
 dyno::ReturnAction Hook_CGameRules_TerminateRound(dyno::CallbackType type, dyno::IHook& hook)
 {
-    ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);
-    g_pluginManager.ExecuteEvent("core", "OnTerminateRound", std::vector<std::any>{ hook.getArgument<float>(1), hook.getArgument<uint32_t>(2) }, & data);
+    ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+    g_pluginManager.ExecuteEvent("core", "OnTerminateRound", std::vector<std::any>{ hook.getArgument<float>(1), hook.getArgument<uint32_t>(2) }, data);
 
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetAnyData("event_return"));
+        response = std::any_cast<bool>(data->GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
         response = true;
     }
+    delete data;
 
     if (!response) return dyno::ReturnAction::Supercede;
 
@@ -74,17 +76,17 @@ FunctionHook CGameRules_TerminateRound("CGameRules_TerminateRound", dyno::Callba
 
 dyno::ReturnAction Hook_CEntityIdentity_AcceptInput(dyno::CallbackType type, dyno::IHook& hook)
 {
-    ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+    ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
     ClassData* ThisPlayer = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void*)(hook.getArgument<CEntityIdentity*>(0)->m_pInstance) } }, "SDKClass", nullptr);
     ClassData* Activator = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void*)(hook.getArgument<CEntityInstance*>(2)) } }, "SDKClass", nullptr);
     ClassData* Caller = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void*)(hook.getArgument<CEntityInstance*>(3)) } }, "SDKClass", nullptr);
 
-    g_pluginManager.ExecuteEvent("core", "OnEntityAcceptInput", { ThisPlayer, hook.getArgument<CUtlSymbolLarge*>(1)->String(), Activator, Caller, hook.getArgument<variant_t*>(4)->ToString(), hook.getArgument<int>(5) }, &data);
+    g_pluginManager.ExecuteEvent("core", "OnEntityAcceptInput", { ThisPlayer, hook.getArgument<CUtlSymbolLarge*>(1)->String(), Activator, Caller, hook.getArgument<variant_t*>(4)->ToString(), hook.getArgument<int>(5) }, data);
 
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetAnyData("event_return"));
+        response = std::any_cast<bool>(data->GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
@@ -94,6 +96,7 @@ dyno::ReturnAction Hook_CEntityIdentity_AcceptInput(dyno::CallbackType type, dyn
     delete ThisPlayer;
     delete Activator;
     delete Caller;
+    delete data;
 
     if (!response) return dyno::ReturnAction::Supercede;
 
@@ -120,17 +123,17 @@ dyno::ReturnAction Hook_CBaseEntity_TakeDamage(dyno::CallbackType type, dyno::IH
         if (attackerController) attackerid = attackerController.GetEntryIndex() - 1;
     }
 
-    ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+    ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
     ClassData* damageinfo = new ClassData({ { "class_name", std::string("CTakeDamageInfo") }, { "class_ptr", (void*)info } }, "SDKClass", nullptr);
     ClassData* Inflictor = new ClassData({ { "class_name", std::string("CBaseEntity") }, { "class_ptr", (void*)(info->m_hInflictor.Get()) } }, "SDKClass", nullptr);
     ClassData* Ability = new ClassData({ { "class_name", std::string("CBaseEntity") }, { "class_ptr", (void*)(info->m_hAbility.Get()) } }, "SDKClass", nullptr);
 
-    g_pluginManager.ExecuteEvent("core", "OnPlayerDamage", { playerid, attackerid, damageinfo, Inflictor, Ability }, &data);
+    g_pluginManager.ExecuteEvent("core", "OnPlayerDamage", { playerid, attackerid, damageinfo, Inflictor, Ability }, data);
 
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetAnyData("event_return"));
+        response = std::any_cast<bool>(data->GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
@@ -140,6 +143,7 @@ dyno::ReturnAction Hook_CBaseEntity_TakeDamage(dyno::CallbackType type, dyno::IH
     delete damageinfo;
     delete Inflictor;
     delete Ability;
+    delete data;
 
     if (!response) return dyno::ReturnAction::Supercede;
 
diff --git a/src/scripting/memory/hooks.cpp b/src/scripting/memory/hooks.cpp
@@ -72,14 +72,16 @@ dyno::ReturnAction HookCallback(dyno::CallbackType type, dyno::IHook& hook) {
     if (hooksList.find(hptr) == hooksList.end())
         return dyno::ReturnAction::Ignored;
 
-    ClassData ev({ { "plugin_name", std::string("core") }, { "hook_ptr", hptr } }, "Event", nullptr);
+    ClassData* ev = new ClassData({ { "plugin_name", std::string("core") }, { "hook_ptr", hptr } }, "Event", nullptr);
     for (auto hk : hooksList[hptr])
     {
-        if (g_pluginManager.ExecuteEvent("core", "hook:" + callbackType + ":" + hk.id, {}, &ev) != EventResult::Continue) {
+        if (g_pluginManager.ExecuteEvent("core", "hook:" + callbackType + ":" + hk.id, {}, ev) != EventResult::Continue) {
+            delete ev;
             return dyno::ReturnAction::Supercede;
         }
     }
 
+    delete ev;
     return dyno::ReturnAction::Ignored;
 }
 
@@ -109,7 +111,7 @@ dyno::ReturnAction Hook_FireOutputInternal(dyno::CallbackType type, dyno::IHook&
 
     if (hookIds.size() > 0)
     {
-        ClassData ev({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+        ClassData* ev = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
 
         ClassData* entIOOutput = new ClassData({ { "class_name", std::string("CEntityIOOutput") }, { "class_ptr", (void*)pThis } }, "SDKClass", nullptr);
         ClassData* Activator = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void*)pActivator } }, "SDKClass", nullptr);
@@ -123,16 +125,21 @@ dyno::ReturnAction Hook_FireOutputInternal(dyno::CallbackType type, dyno::IHook&
                 Activator,
                 Caller,
                 delay
-            }, &ev);
+            }, ev);
             if (result != EventResult::Continue)
             {
+                delete entIOOutput;
+                delete Activator;
+                delete Caller;
+                delete ev;
                 return dyno::ReturnAction::Supercede;
             }
         }
 
         delete entIOOutput;
         delete Activator;
         delete Caller;
+        delete ev;
     }
 
     return dyno::ReturnAction::Ignored;
diff --git a/src/scripting/sdk/schema.cpp b/src/scripting/sdk/schema.cpp
@@ -100,7 +100,7 @@ void SchemaCallback(PluginObject plugin, EContext* ctx) {
     });
 
     ADD_CLASS_FUNCTION("SDKClass", "IsValid", [](FunctionContext* context, ClassData* data) -> void {
-        context->SetReturn(data->GetData<void*>("class_ptr") != nullptr);
+        context->SetReturn(g_entSystem.IsValidEntity(data->GetData<void*>("class_ptr")));
     });
 
     ADD_CLASS_FUNCTION("SDKClass", "ToPtr", [](FunctionContext* context, ClassData* data) -> void {
@@ -311,7 +311,7 @@ void SchemaCallback(PluginObject plugin, EContext* ctx) {
         uint64_t path = ((uint64_t)hash_32_fnv1a_const(className.c_str()) << 32 | hash_32_fnv1a_const(fieldName.c_str()));
 
         void* instance = data->GetData<void*>("class_ptr");
-        if (!instance) {
+        if (!g_entSystem.IsValidEntity(instance)) {
             ReportPreventionIncident("Schema / SDK", string_format("Tried to get member '%s::%s' but the entity is invalid.", className.c_str(), fieldName.c_str()));
             return context->StopExecution();
         }
@@ -322,7 +322,7 @@ void SchemaCallback(PluginObject plugin, EContext* ctx) {
         std::string fieldName = explode(context->GetFunctionKey(), " ").back();
 
         void* instance = data->GetData<void*>("class_ptr");
-        if (!instance) {
+        if (!g_entSystem.IsValidEntity(instance)) {
             ReportPreventionIncident("Schema / SDK", string_format("Tried to set member '%s::%s' but the entity is invalid.", className.c_str(), fieldName.c_str()));
             return context->StopExecution();
         }
@@ -339,7 +339,7 @@ void SchemaCallback(PluginObject plugin, EContext* ctx) {
         uint64_t path = ((uint64_t)hash_32_fnv1a_const(className.c_str()) << 32 | hash_32_fnv1a_const(function_name.c_str()));
         if (classFuncs.find(path) != classFuncs.end()) {
             void* instance = data->GetData<void*>("class_ptr");
-            if (!instance) {
+            if (!g_entSystem.IsValidEntity(instance)) {
                 ReportPreventionIncident("Schema / SDK", string_format("Tried to call function '%s::%s' but the entity is invalid.", className.c_str(), function_name.c_str()));
                 return context->StopExecution();
             }
diff --git a/src/server/player/manager.cpp b/src/server/player/manager.cpp
@@ -117,18 +117,19 @@ bool PlayerManager::ClientConnect(CPlayerSlot slot, const char* pszName, uint64
     Player* player = new Player(false, slot.Get(), pszName, xuid, ip_address);
     RegisterPlayer(slot, player);
 
-    ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);
-    g_pluginManager.ExecuteEvent("core", "OnClientConnect", { slot.Get() }, &data);
+    ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);
+    g_pluginManager.ExecuteEvent("core", "OnClientConnect", { slot.Get() }, data);
 
     bool response = true;
     try
     {
-        response = std::any_cast<bool>(data.GetAnyData("event_return"));
+        response = std::any_cast<bool>(data->GetAnyData("event_return"));
     }
     catch (std::bad_any_cast& e)
     {
         response = true;
     }
+    delete data;
 
     RETURN_META_VALUE(MRES_IGNORED, response);
 }

Original file line number	Diff line number	Diff line change
`@@ -246,19 +246,21 @@ bool SwiftlyS2::Unload(char* error, size_t maxlen)`
`246`	`246`
`247`	`247`	`bool OnClientCommand(int playerid, std::string command)`
`248`	`248`	`{`
`249`		`- ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`250`		`- g_pluginManager.ExecuteEvent("core", "OnClientCommand", { playerid, command }, &data);`
	`249`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`250`	`+ g_pluginManager.ExecuteEvent("core", "OnClientCommand", { playerid, command }, data);`
`251`	`251`
`252`	`252`	`bool response = true;`
`253`	`253`	`try`
`254`	`254`	`{`
`255`		`- response = std::any_cast<bool>(data.GetAnyData("event_return"));`
	`255`	`+ response = std::any_cast<bool>(data->GetAnyData("event_return"));`
`256`	`256`	`}`
`257`	`257`	`catch (std::bad_any_cast& e)`
`258`	`258`	`{`
`259`	`259`	`response = true;`
`260`	`260`	`}`
`261`	`261`
	`262`	`+ delete data;`
	`263`	`+`
`262`	`264`	`return response;`
`263`	`265`	`}`
`264`	`266`
Original file line number	Diff line number	Diff line change
`@@ -64,4 +64,9 @@ void EntitySystem::AcceptInput(void* entity, std::string input, void* activator,`
`64`	`64`	`{`
`65`	`65`	`variant_t variantValue = variant_t(value.c_str());`
`66`	`66`	`g_GameData.FetchSignature<CEntityInstance_AcceptInput>("CEntityInstance_AcceptInput")(entity, input.c_str(), activator, caller, &variantValue, outputID);`
	`67`	`+}`
	`68`	`+`
	`69`	`+bool EntitySystem::IsValidEntity(void* entity)`
	`70`	`+{`
	`71`	`+ return entity != nullptr;`
`67`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -216,9 +216,9 @@ std::string PluginsManager::GetPluginBasePath(std::string plugin_name)`
`216`	`216`
`217`	`217`	`EXT_API int swiftly_TriggerEvent(const char* ext_name, const char* evName, void* args, void* eventReturn)`
`218`	`218`	`{`
`219`		`- ClassData data({ { "plugin_name", std::string(ext_name) } }, "Event", nullptr);`
`220`		`- auto result = g_pluginManager.ExecuteEvent(ext_name, evName, (std::vector<std::any>)args, &data);`
`221`		`- reinterpret_cast<std::any>(eventReturn) = data.GetAnyData("event_return");`
`222`		`-`
	`219`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string(ext_name) } }, "Event", nullptr);`
	`220`	`+ auto result = g_pluginManager.ExecuteEvent(ext_name, evName, (std::vector<std::any>)args, data);`
	`221`	`+ reinterpret_cast<std::any>(eventReturn) = data->GetAnyData("event_return");`
	`222`	`+ delete data;`
`223`	`223`	`return (int)result;`
`224`	`224`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ EventResult PluginObject::TriggerEvent(std::string invokedBy, std::string eventN`
`77`	`77`	`if (value.isNumber())`
`78`	`78`	`{`
`79`	`79`	`int result = value.cast<int>();`
`80`		`- if (result < (int)EventResult::Continue \|\| result >(int)EventResult::Stop)`
	`80`	`+ if (result < (int)EventResult::Continue \|\| result >(int)EventResult::Handled)`
`81`	`81`	`response = EventResult::Continue;`
`82`	`82`	`else`
`83`	`83`	`response = (EventResult)result;`
Original file line number	Diff line number	Diff line change
`@@ -29,18 +29,19 @@ FunctionHook CCSPlayerPawnBase_PostThink("CCSPlayerPawnBase_PostThink", dyno::Ca`
`29`	`29`
`30`	`30`	`bool OnClientChat(int playerid, std::string text, bool teamonly)`
`31`	`31`	`{`
`32`		`- ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`33`		`- g_pluginManager.ExecuteEvent("core", "OnClientChat", { playerid, text, teamonly }, &data);`
	`32`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`33`	`+ g_pluginManager.ExecuteEvent("core", "OnClientChat", { playerid, text, teamonly }, data);`
`34`	`34`
`35`	`35`	`bool response = true;`
`36`	`36`	`try`
`37`	`37`	`{`
`38`		`- response = std::any_cast<bool>(data.GetAnyData("event_return"));`
	`38`	`+ response = std::any_cast<bool>(data->GetAnyData("event_return"));`
`39`	`39`	`}`
`40`	`40`	`catch (std::bad_any_cast& e)`
`41`	`41`	`{`
`42`	`42`	`response = true;`
`43`	`43`	`}`
	`44`	`+ delete data;`
`44`	`45`
`45`	`46`	`return response;`
`46`	`47`	`}`
`@@ -52,18 +53,19 @@ void OnClientConvarQuery(int playerid, std::string convar_name, std::string conv`
`52`	`53`
`53`	`54`	`dyno::ReturnAction Hook_CGameRules_TerminateRound(dyno::CallbackType type, dyno::IHook& hook)`
`54`	`55`	`{`
`55`		`- ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`56`		`- g_pluginManager.ExecuteEvent("core", "OnTerminateRound", std::vector<std::any>{ hook.getArgument<float>(1), hook.getArgument<uint32_t>(2) }, & data);`
	`56`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`57`	`+ g_pluginManager.ExecuteEvent("core", "OnTerminateRound", std::vector<std::any>{ hook.getArgument<float>(1), hook.getArgument<uint32_t>(2) }, data);`
`57`	`58`
`58`	`59`	`bool response = true;`
`59`	`60`	`try`
`60`	`61`	`{`
`61`		`- response = std::any_cast<bool>(data.GetAnyData("event_return"));`
	`62`	`+ response = std::any_cast<bool>(data->GetAnyData("event_return"));`
`62`	`63`	`}`
`63`	`64`	`catch (std::bad_any_cast& e)`
`64`	`65`	`{`
`65`	`66`	`response = true;`
`66`	`67`	`}`
	`68`	`+ delete data;`
`67`	`69`
`68`	`70`	`if (!response) return dyno::ReturnAction::Supercede;`
`69`	`71`
`@@ -74,17 +76,17 @@ FunctionHook CGameRules_TerminateRound("CGameRules_TerminateRound", dyno::Callba`
`74`	`76`
`75`	`77`	`dyno::ReturnAction Hook_CEntityIdentity_AcceptInput(dyno::CallbackType type, dyno::IHook& hook)`
`76`	`78`	`{`
`77`		`- ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`79`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`78`	`80`	`ClassData* ThisPlayer = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void)(hook.getArgument<CEntityIdentity>(0)->m_pInstance) } }, "SDKClass", nullptr);`
`79`	`81`	`ClassData* Activator = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void)(hook.getArgument<CEntityInstance>(2)) } }, "SDKClass", nullptr);`
`80`	`82`	`ClassData* Caller = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void)(hook.getArgument<CEntityInstance>(3)) } }, "SDKClass", nullptr);`
`81`	`83`
`82`		`- g_pluginManager.ExecuteEvent("core", "OnEntityAcceptInput", { ThisPlayer, hook.getArgument<CUtlSymbolLarge>(1)->String(), Activator, Caller, hook.getArgument<variant_t>(4)->ToString(), hook.getArgument<int>(5) }, &data);`
	`84`	`+ g_pluginManager.ExecuteEvent("core", "OnEntityAcceptInput", { ThisPlayer, hook.getArgument<CUtlSymbolLarge>(1)->String(), Activator, Caller, hook.getArgument<variant_t>(4)->ToString(), hook.getArgument<int>(5) }, data);`
`83`	`85`
`84`	`86`	`bool response = true;`
`85`	`87`	`try`
`86`	`88`	`{`
`87`		`- response = std::any_cast<bool>(data.GetAnyData("event_return"));`
	`89`	`+ response = std::any_cast<bool>(data->GetAnyData("event_return"));`
`88`	`90`	`}`
`89`	`91`	`catch (std::bad_any_cast& e)`
`90`	`92`	`{`
`@@ -94,6 +96,7 @@ dyno::ReturnAction Hook_CEntityIdentity_AcceptInput(dyno::CallbackType type, dyn`
`94`	`96`	`delete ThisPlayer;`
`95`	`97`	`delete Activator;`
`96`	`98`	`delete Caller;`
	`99`	`+ delete data;`
`97`	`100`
`98`	`101`	`if (!response) return dyno::ReturnAction::Supercede;`
`99`	`102`
`@@ -120,17 +123,17 @@ dyno::ReturnAction Hook_CBaseEntity_TakeDamage(dyno::CallbackType type, dyno::IH`
`120`	`123`	`if (attackerController) attackerid = attackerController.GetEntryIndex() - 1;`
`121`	`124`	`}`
`122`	`125`
`123`		`- ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`126`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`124`	`127`	`ClassData* damageinfo = new ClassData({ { "class_name", std::string("CTakeDamageInfo") }, { "class_ptr", (void*)info } }, "SDKClass", nullptr);`
`125`	`128`	`ClassData* Inflictor = new ClassData({ { "class_name", std::string("CBaseEntity") }, { "class_ptr", (void*)(info->m_hInflictor.Get()) } }, "SDKClass", nullptr);`
`126`	`129`	`ClassData* Ability = new ClassData({ { "class_name", std::string("CBaseEntity") }, { "class_ptr", (void*)(info->m_hAbility.Get()) } }, "SDKClass", nullptr);`
`127`	`130`
`128`		`- g_pluginManager.ExecuteEvent("core", "OnPlayerDamage", { playerid, attackerid, damageinfo, Inflictor, Ability }, &data);`
	`131`	`+ g_pluginManager.ExecuteEvent("core", "OnPlayerDamage", { playerid, attackerid, damageinfo, Inflictor, Ability }, data);`
`129`	`132`
`130`	`133`	`bool response = true;`
`131`	`134`	`try`
`132`	`135`	`{`
`133`		`- response = std::any_cast<bool>(data.GetAnyData("event_return"));`
	`136`	`+ response = std::any_cast<bool>(data->GetAnyData("event_return"));`
`134`	`137`	`}`
`135`	`138`	`catch (std::bad_any_cast& e)`
`136`	`139`	`{`
`@@ -140,6 +143,7 @@ dyno::ReturnAction Hook_CBaseEntity_TakeDamage(dyno::CallbackType type, dyno::IH`
`140`	`143`	`delete damageinfo;`
`141`	`144`	`delete Inflictor;`
`142`	`145`	`delete Ability;`
	`146`	`+ delete data;`
`143`	`147`
`144`	`148`	`if (!response) return dyno::ReturnAction::Supercede;`
`145`	`149`
Original file line number	Diff line number	Diff line change
`@@ -72,14 +72,16 @@ dyno::ReturnAction HookCallback(dyno::CallbackType type, dyno::IHook& hook) {`
`72`	`72`	`if (hooksList.find(hptr) == hooksList.end())`
`73`	`73`	`return dyno::ReturnAction::Ignored;`
`74`	`74`
`75`		`- ClassData ev({ { "plugin_name", std::string("core") }, { "hook_ptr", hptr } }, "Event", nullptr);`
	`75`	`+ ClassData* ev = new ClassData({ { "plugin_name", std::string("core") }, { "hook_ptr", hptr } }, "Event", nullptr);`
`76`	`76`	`for (auto hk : hooksList[hptr])`
`77`	`77`	`{`
`78`		`- if (g_pluginManager.ExecuteEvent("core", "hook:" + callbackType + ":" + hk.id, {}, &ev) != EventResult::Continue) {`
	`78`	`+ if (g_pluginManager.ExecuteEvent("core", "hook:" + callbackType + ":" + hk.id, {}, ev) != EventResult::Continue) {`
	`79`	`+ delete ev;`
`79`	`80`	`return dyno::ReturnAction::Supercede;`
`80`	`81`	`}`
`81`	`82`	`}`
`82`	`83`
	`84`	`+ delete ev;`
`83`	`85`	`return dyno::ReturnAction::Ignored;`
`84`	`86`	`}`
`85`	`87`
`@@ -109,7 +111,7 @@ dyno::ReturnAction Hook_FireOutputInternal(dyno::CallbackType type, dyno::IHook&`
`109`	`111`
`110`	`112`	`if (hookIds.size() > 0)`
`111`	`113`	`{`
`112`		`- ClassData ev({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`114`	`+ ClassData* ev = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`113`	`115`
`114`	`116`	`ClassData* entIOOutput = new ClassData({ { "class_name", std::string("CEntityIOOutput") }, { "class_ptr", (void*)pThis } }, "SDKClass", nullptr);`
`115`	`117`	`ClassData* Activator = new ClassData({ { "class_name", std::string("CEntityInstance") }, { "class_ptr", (void*)pActivator } }, "SDKClass", nullptr);`
`@@ -123,16 +125,21 @@ dyno::ReturnAction Hook_FireOutputInternal(dyno::CallbackType type, dyno::IHook&`
`123`	`125`	`Activator,`
`124`	`126`	`Caller,`
`125`	`127`	`delay`
`126`		`- }, &ev);`
	`128`	`+ }, ev);`
`127`	`129`	`if (result != EventResult::Continue)`
`128`	`130`	`{`
	`131`	`+ delete entIOOutput;`
	`132`	`+ delete Activator;`
	`133`	`+ delete Caller;`
	`134`	`+ delete ev;`
`129`	`135`	`return dyno::ReturnAction::Supercede;`
`130`	`136`	`}`
`131`	`137`	`}`
`132`	`138`
`133`	`139`	`delete entIOOutput;`
`134`	`140`	`delete Activator;`
`135`	`141`	`delete Caller;`
	`142`	`+ delete ev;`
`136`	`143`	`}`
`137`	`144`
`138`	`145`	`return dyno::ReturnAction::Ignored;`
Original file line number	Diff line number	Diff line change
`@@ -117,18 +117,19 @@ bool PlayerManager::ClientConnect(CPlayerSlot slot, const char* pszName, uint64`
`117`	`117`	`Player* player = new Player(false, slot.Get(), pszName, xuid, ip_address);`
`118`	`118`	`RegisterPlayer(slot, player);`
`119`	`119`
`120`		`- ClassData data({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
`121`		`- g_pluginManager.ExecuteEvent("core", "OnClientConnect", { slot.Get() }, &data);`
	`120`	`+ ClassData* data = new ClassData({ { "plugin_name", std::string("core") } }, "Event", nullptr);`
	`121`	`+ g_pluginManager.ExecuteEvent("core", "OnClientConnect", { slot.Get() }, data);`
`122`	`122`
`123`	`123`	`bool response = true;`
`124`	`124`	`try`
`125`	`125`	`{`
`126`		`- response = std::any_cast<bool>(data.GetAnyData("event_return"));`
	`126`	`+ response = std::any_cast<bool>(data->GetAnyData("event_return"));`
`127`	`127`	`}`
`128`	`128`	`catch (std::bad_any_cast& e)`
`129`	`129`	`{`
`130`	`130`	`response = true;`
`131`	`131`	`}`
	`132`	`+ delete data;`
`132`	`133`
`133`	`134`	`RETURN_META_VALUE(MRES_IGNORED, response);`
`134`	`135`	`}`