fix(scripting): Pointers -> Objects

Author: skuzzis

src/plugins/core/scripting.h

@@ -20,21 +20,11 @@
 
 #include <any>
 
+#include "scripting/generated/classes.h"
+
 #define INVALID_MESSAGE_ID -1
 
-class GCBaseEntity;
-class GCBasePlayerController;
-class GCBasePlayerPawn;
-class GCCSPlayerController;
-class GCCSPlayerPawn;
-class GCCSPlayerPawnBase;
-class GCEntityInstance;
 class PluginMemory;
-class GCBasePlayerWeapon;
-class GCCSWeaponBase;
-class GCBasePlayerWeaponVData;
-class GCCSWeaponBaseVData;
-class GCCSGameRules;
 
 //////////////////////////////////////////////////////////////
 /////////////////          Entity IO           //////////////
@@ -539,18 +529,16 @@ class PluginPlayer
     std::string plugin_name;
     int playerId;
 
-    std::map<std::string, void*> ptrs;
-
 public:
     PluginPlayer(std::string m_plugin_name, int m_playerId);
     ~PluginPlayer();
 
-    GCBaseEntity* GetCBaseEntity();
-    GCBasePlayerController* GetCBasePlayerController();
-    GCBasePlayerPawn* GetCBasePlayerPawn();
-    GCCSPlayerController* GetCCSPlayerController();
-    GCCSPlayerPawn* GetCCSPlayerPawn();
-    GCCSPlayerPawnBase* GetCCSPlayerPawnBase();
+    GCBaseEntity GetCBaseEntity();
+    GCBasePlayerController GetCBasePlayerController();
+    GCBasePlayerPawn GetCBasePlayerPawn();
+    GCCSPlayerController GetCCSPlayerController();
+    GCCSPlayerPawn GetCCSPlayerPawn();
+    GCCSPlayerPawnBase GetCCSPlayerPawnBase();
     void Drop(int reason);
     uint32_t GetConnectedTime();
     PluginWeaponManager GetWeaponManager();
@@ -597,6 +585,8 @@ class PluginPlayer
 
     void SetBunnyhop(bool state);
     bool GetBunnyhop();
+
+    bool IsValid();
 };
 
 //////////////////////////////////////////////////////////////
@@ -718,8 +708,8 @@ class PluginHooks
 /////////////////           Entities           //////////////
 ////////////////////////////////////////////////////////////
 
-std::vector<GCEntityInstance*> UTIL_FindEntitiesByClassname(const char* name);
-GCEntityInstance* CreateEntityByName(const char* name);
+std::vector<GCEntityInstance> UTIL_FindEntitiesByClassname(const char* name);
+GCEntityInstance CreateEntityByName(const char* name);
 
 //////////////////////////////////////////////////////////////
 /////////////////             Utils            //////////////
@@ -728,7 +718,7 @@ GCEntityInstance* CreateEntityByName(const char* name);
 bool scripting_IsWindows();
 bool scripting_IsLinux();
 std::string scripting_GetOS();
-GCCSGameRules* scripting_GetCCSGameRules();
+GCCSGameRules scripting_GetCCSGameRules();
 std::string scripting_GetPluginPath(std::string plugin_name);
 void scripting_StateUpdate(std::string ptr, std::string classname, std::string field, bool isStruct);
 

src/plugins/core/scripting/entities.cpp

@@ -1,38 +1,24 @@
 #include "../scripting.h"
 
-#include "generated/classes.h"
-
-std::map<CEntityIdentity *, GCEntityInstance *> entityInstanceMapping;
-
-std::vector<GCEntityInstance *> UTIL_FindEntitiesByClassname(const char *name)
+std::vector<GCEntityInstance> UTIL_FindEntitiesByClassname(const char* name)
 {
-    extern CEntitySystem *g_pEntitySystem;
-    CEntityIdentity *pEntity = g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
-    std::vector<GCEntityInstance *> entities;
+    extern CEntitySystem* g_pEntitySystem;
+    CEntityIdentity* pEntity = g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
+    std::vector<GCEntityInstance> entities;
 
     for (; pEntity; pEntity = pEntity->m_pNext)
-    {
         if (!strcmp(pEntity->m_designerName.String(), name))
-        {
-            if (entityInstanceMapping.find(pEntity) == entityInstanceMapping.end())
-                entityInstanceMapping.insert({pEntity, new GCEntityInstance((void *)(pEntity->m_pInstance))});
-
-            entities.push_back(entityInstanceMapping.at(pEntity));
-        }
-    };
+            entities.push_back(GCEntityInstance((void*)(pEntity->m_pInstance)));
 
     return entities;
 }
 
-GCEntityInstance *CreateEntityByName(const char *name)
+GCEntityInstance CreateEntityByName(const char* name)
 {
     std::string className = (!name ? "prop_dynamic_override" : name);
 
-    CEntityIdentity *entityPtr = reinterpret_cast<CEntityIdentity *>(g_Signatures->FetchSignature<UTIL_CreateEntityByName>("UTIL_CreateEntityByName")(className.c_str(), -1));
-
-    GCEntityInstance *instance = new GCEntityInstance(entityPtr);
-    if (entityInstanceMapping.find(entityPtr) == entityInstanceMapping.end())
-        entityInstanceMapping.insert({entityPtr, instance});
+    CEntityIdentity* entityPtr = reinterpret_cast<CEntityIdentity*>(g_Signatures->FetchSignature<UTIL_CreateEntityByName>("UTIL_CreateEntityByName")(className.c_str(), -1));
 
+    GCEntityInstance instance(entityPtr);
     return instance;
 }

src/plugins/core/scripting/generated/classes.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "../../scripting_includes.h"
 #include "enums.h"
 

src/plugins/core/scripting/player.cpp

@@ -4,8 +4,6 @@
 #include "../../../commands/CommandsManager.h"
 #include "../../../precacher/precacher.h"
 
-#include "generated/classes.h"
-
 PluginPlayer::PluginPlayer(std::string m_plugin_name, int m_playerId)
 {
     REGISTER_CALLSTACK(this->plugin_name, string_format("PluginPlayer::PluginPlayer(m_plugin_name=\"%s\", m_playerId=%d)", m_plugin_name.c_str(), m_playerId));
@@ -14,123 +12,78 @@ PluginPlayer::PluginPlayer(std::string m_plugin_name, int m_playerId)
     this->playerId = m_playerId;
 }
 
-PluginPlayer::~PluginPlayer()
-{
-
-    for (auto it = this->ptrs.begin(); it != this->ptrs.end(); ++it)
-    {
-        delete it->second;
-    }
-    this->ptrs.clear();
-}
+PluginPlayer::~PluginPlayer() {}
 
-GCBaseEntity* PluginPlayer::GetCBaseEntity()
+GCBaseEntity PluginPlayer::GetCBaseEntity()
 {
     Player* player = g_playerManager->GetPlayer(this->playerId);
-
-    if (this->ptrs.find("CBaseEntity") == this->ptrs.end())
-    {
-        void* ptr = (void*)(new GCBaseEntity(player->GetPlayerPawn()));
-        this->ptrs.insert({ "CBaseEntity", ptr });
-    }
-    else {
-        if (((GCBaseEntity*)this->ptrs.at("CBaseEntity"))->GetPtr() != (void*)player->GetPlayerPawn()) {
-            delete this->ptrs["CBaseEntity"];
-            this->ptrs["CBaseEntity"] = (void*)(new GCBaseEntity(player->GetPlayerPawn()));
-        }
+    if (!player) {
+        GCBaseEntity val(nullptr);
+        return val;
     }
 
-    return (GCBaseEntity*)this->ptrs.at("CBaseEntity");
+    GCBaseEntity val((void*)player->GetPlayerPawn());
+    return val;
 }
 
-GCBasePlayerController* PluginPlayer::GetCBasePlayerController()
+GCBasePlayerController PluginPlayer::GetCBasePlayerController()
 {
     Player* player = g_playerManager->GetPlayer(this->playerId);
-    if (this->ptrs.find("CBasePlayerController") == this->ptrs.end())
-    {
-        void* ptr = (void*)(new GCBasePlayerController(player->GetController()));
-        this->ptrs.insert({ "CBasePlayerController", ptr });
-    }
-    else {
-        if (((GCBasePlayerController*)this->ptrs.at("CBasePlayerController"))->GetPtr() != (void*)player->GetController()) {
-            delete this->ptrs["CBasePlayerController"];
-            this->ptrs["CBasePlayerController"] = (void*)(new GCBasePlayerController(player->GetController()));
-        }
+    if (!player) {
+        GCBasePlayerController val(nullptr);
+        return val;
     }
 
-    return (GCBasePlayerController*)this->ptrs.at("CBasePlayerController");
+    GCBasePlayerController val((void*)player->GetController());
+    return val;
 }
 
-GCBasePlayerPawn* PluginPlayer::GetCBasePlayerPawn()
+GCBasePlayerPawn PluginPlayer::GetCBasePlayerPawn()
 {
     Player* player = g_playerManager->GetPlayer(this->playerId);
-    if (this->ptrs.find("CBasePlayerPawn") == this->ptrs.end())
-    {
-        void* ptr = (void*)(new GCBasePlayerPawn(player->GetPawn()));
-        this->ptrs.insert({ "CBasePlayerPawn", ptr });
-    }
-    else {
-        if (((GCBasePlayerPawn*)this->ptrs.at("CBasePlayerPawn"))->GetPtr() != (void*)player->GetPawn()) {
-            delete this->ptrs["CBasePlayerPawn"];
-            this->ptrs["CBasePlayerPawn"] = (void*)(new GCBasePlayerPawn(player->GetPawn()));
-        }
+    if (!player) {
+        GCBasePlayerPawn val(nullptr);
+        return val;
     }
 
-    return (GCBasePlayerPawn*)this->ptrs.at("CBasePlayerPawn");
+    GCBasePlayerPawn val((void*)player->GetPawn());
+    return val;
 }
 
-GCCSPlayerController* PluginPlayer::GetCCSPlayerController()
+GCCSPlayerController PluginPlayer::GetCCSPlayerController()
 {
     Player* player = g_playerManager->GetPlayer(this->playerId);
-    if (this->ptrs.find("CCSPlayerController") == this->ptrs.end())
-    {
-        void* ptr = (void*)(new GCCSPlayerController(player->GetPlayerController()));
-        this->ptrs.insert({ "CCSPlayerController", ptr });
-    }
-    else {
-        if (((GCCSPlayerController*)this->ptrs.at("CCSPlayerController"))->GetPtr() != (void*)player->GetPlayerController()) {
-            delete this->ptrs["CCSPlayerController"];
-            this->ptrs["CCSPlayerController"] = (void*)(new GCCSPlayerController(player->GetPlayerController()));
-        }
+    if (!player) {
+        GCCSPlayerController val(nullptr);
+        return val;
     }
 
-    return (GCCSPlayerController*)this->ptrs.at("CCSPlayerController");
+    GCCSPlayerController val((void*)player->GetPlayerController());
+    return val;
 }
 
-GCCSPlayerPawn* PluginPlayer::GetCCSPlayerPawn()
+GCCSPlayerPawn PluginPlayer::GetCCSPlayerPawn()
 {
     Player* player = g_playerManager->GetPlayer(this->playerId);
-    if (this->ptrs.find("CCSPlayerPawn") == this->ptrs.end())
-    {
-        void* ptr = (void*)(new GCCSPlayerPawn(player->GetPlayerPawn()));
-        this->ptrs.insert({ "CCSPlayerPawn", ptr });
-    }
-    else {
-        if (((GCCSPlayerPawn*)this->ptrs.at("CCSPlayerPawn"))->GetPtr() != (void*)player->GetPlayerPawn()) {
-            delete this->ptrs["CCSPlayerPawn"];
-            this->ptrs["CCSPlayerPawn"] = (void*)(new GCCSPlayerPawn(player->GetPlayerPawn()));
-        }
+    if (!player) {
+        GCCSPlayerPawn val(nullptr);
+        return val;
     }
 
-    return (GCCSPlayerPawn*)this->ptrs.at("CCSPlayerPawn");
+    GCCSPlayerPawn val((void*)player->GetPlayerPawn());
+    return val;
 }
 
-GCCSPlayerPawnBase* PluginPlayer::GetCCSPlayerPawnBase()
+GCCSPlayerPawnBase PluginPlayer::GetCCSPlayerPawnBase()
 {
     Player* player = g_playerManager->GetPlayer(this->playerId);
-    if (this->ptrs.find("CCSPlayerPawnBase") == this->ptrs.end())
-    {
-        void* ptr = (void*)(new GCCSPlayerPawnBase(player->GetPlayerBasePawn()));
-        this->ptrs.insert({ "CCSPlayerPawnBase", ptr });
-    }
-    else {
-        if (((GCCSPlayerPawnBase*)this->ptrs.at("CCSPlayerPawnBase"))->GetPtr() != (void*)player->GetPlayerBasePawn()) {
-            delete this->ptrs["CCSPlayerPawnBase"];
-            this->ptrs["CCSPlayerPawnBase"] = (void*)(new GCCSPlayerPawnBase(player->GetPlayerBasePawn()));
-        }
+    if (!player) {
+        GCCSPlayerPawnBase val(nullptr);
+        return val;
     }
 
-    return (GCCSPlayerPawnBase*)this->ptrs.at("CCSPlayerPawnBase");
+    GCCSPlayerPawnBase val((void*)player->GetPlayerBasePawn());
+    return val;
 }
 
 void PluginPlayer::Drop(int reason)
@@ -563,3 +516,21 @@ bool PluginPlayer::GetBunnyhop()
 
     return self->bunnyhopState;
 }
+
+bool PluginPlayer::IsValid()
+{
+    Player* self = g_playerManager->GetPlayer(this->playerId);
+    if (!self) return false;
+    if (self->IsFirstSpawn()) return false;
+    if (self->IsFakeClient()) return false;
+
+    CBasePlayerController* controller = self->GetController();
+    if (!controller) return false;
+    if (controller->m_bIsHLTV()) return false;
+    if (controller->m_iConnected() != CPlayerConnectedState::PlayerConnected) return false;
+
+    CBasePlayerPawn* pawn = self->GetPawn();
+    if (!pawn) return false;
+
+    return true;
+}

src/plugins/core/scripting/utils.cpp

@@ -1,18 +1,16 @@
 #include "../scripting.h"
 #include "../../../sdk/entity/CGameRules.h"
 #include "../../../hooks/FuncHook.h"
-#include "generated/classes.h"
 #include "../../PluginManager.h"
 
-void Hook_CGameRules_Constructor(CGameRules *pThis);
-CCSGameRules *gameRules = nullptr;
-GCCSGameRules *gameRulesPtr = nullptr;
+void Hook_CGameRules_Constructor(CGameRules* pThis);
+CCSGameRules* gameRules = nullptr;
 
 FuncHook<decltype(Hook_CGameRules_Constructor)> CGameRules_ConstructorT(Hook_CGameRules_Constructor, "CGameRules_Constructor");
 
-void Hook_CGameRules_Constructor(CGameRules *pThis)
+void Hook_CGameRules_Constructor(CGameRules* pThis)
 {
-    gameRules = (CCSGameRules *)pThis;
+    gameRules = (CCSGameRules*)pThis;
     CGameRules_ConstructorT(pThis);
 }
 
@@ -31,23 +29,16 @@ std::string scripting_GetOS()
     return WIN_LINUX("Windows", "Linux");
 }
 
-GCCSGameRules *scripting_GetCCSGameRules()
+GCCSGameRules scripting_GetCCSGameRules()
 {
-    if (!gameRulesPtr)
-        gameRulesPtr = new GCCSGameRules((void *)gameRules);
-    else if (gameRulesPtr->GetPtr() != (void *)gameRules)
-    {
-        delete gameRulesPtr;
-        gameRulesPtr = new GCCSGameRules((void *)gameRules);
-    }
-
-    return gameRulesPtr;
+    GCCSGameRules val(gameRules);
+    return val;
 }
 
 std::string scripting_GetPluginPath(std::string plugin_name)
 {
     Plugin* plugin = g_pluginManager->FetchPlugin(plugin_name);
-    if(!plugin) return "";
+    if (!plugin) return "";
 
     return string_format("addons/swiftly/plugins/%s", plugin->GetName().c_str());
 }

src/plugins/core/scripting/weapons.cpp

@@ -1,6 +1,5 @@
 #include "../scripting.h"
 #include "../../../player/PlayerManager.h"
-#include "generated/classes.h"
 
 PluginWeaponManager::PluginWeaponManager(int playerId)
 {

src/plugins/lua/scripting/weapons.cpp

@@ -1,7 +1,6 @@
 #include "core.h"
-#include "../../core/scripting/generated/classes.h"
 
-void SetupLuaWeapons(LuaPlugin *plugin, lua_State *state)
+void SetupLuaWeapons(LuaPlugin* plugin, lua_State* state)
 {
     luabridge::getGlobalNamespace(state)
         .beginClass<PluginWeaponManager>("WeaponManager")