chore(deps): upgrade metamod & hl2sdk (#856)

roflmuffin · web-flow · commit 462ca52229d8 · 2025-05-10T12:17:45.000+10:00
diff --git a/libraries/hl2sdk-cs2 b/libraries/hl2sdk-cs2
@@ -1 +1 @@
-Subproject commit a26ca82e875814130feb8d74fb450c92b5f2d76d
+Subproject commit bc59586979ae55578a00e502fcf88f69f5588b52
diff --git a/libraries/metamod-source b/libraries/metamod-source
@@ -1 +1 @@
-Subproject commit 607301adc3ed0ccc5916fd44bf7c52a54444f4bc
+Subproject commit 6091f15217cdde3a043c2d0dc6bf9bdf20bdbc13
diff --git a/src/core/gameconfig.cpp b/src/core/gameconfig.cpp
@@ -3,7 +3,6 @@
 #include <fstream>
 
 #include "log.h"
-#include "metamod_oslink.h"
 
 namespace counterstrikesharp {
 
diff --git a/src/core/globals.h b/src/core/globals.h
@@ -1,10 +1,6 @@
 #pragma once
 
-#define protected public
-#define private   public
 #include <tier1/convar.h>
-#undef protected
-#undef private
 
 #include <sourcehook/sourcehook.h>
 
diff --git a/src/core/managers/con_command_manager.cpp b/src/core/managers/con_command_manager.cpp
@@ -179,7 +179,7 @@ CON_COMMAND(dump_schema, "dump schema symbols")
     output << std::setw(2) << j << std::endl;
 }
 
-SH_DECL_HOOK3_void(ICvar, DispatchConCommand, SH_NOATTRIB, 0, ConCommandHandle, const CCommandContext&, const CCommand&);
+SH_DECL_HOOK3_void(ICvar, DispatchConCommand, SH_NOATTRIB, 0, ConCommandRef, const CCommandContext&, const CCommand&);
 
 ConCommandInfo::ConCommandInfo()
 {
@@ -222,45 +222,31 @@ void UnlockConVars()
 {
     int unhiddenConVars = 0;
 
-    ConVar* currentCvar = nullptr;
-    ConVarHandle currentCvarHandle;
-    currentCvarHandle.Set(0);
-
-    do
+    for (ConVarRefAbstract ref(ConVarRef((uint16)0)); ref.IsValidRef(); ref = ConVarRefAbstract(ConVarRef(ref.GetAccessIndex() + 1)))
     {
-        currentCvar = globals::cvars->GetConVar(currentCvarHandle);
-
-        currentCvarHandle.Set(currentCvarHandle.Get() + 1);
-
-        if (!currentCvar) continue;
-
-        if (!(currentCvar->flags & flagsToRemove)) continue;
+        if (!ref.IsFlagSet(flagsToRemove)) continue;
 
-        currentCvar->flags &= ~flagsToRemove;
+        ref.RemoveFlags(flagsToRemove);
         unhiddenConVars++;
-    } while (currentCvar);
+    }
 }
 
 void UnlockConCommands()
 {
     int unhiddenConCommands = 0;
 
-    ConCommand* currentConCommand = nullptr;
-    ConCommand* invalidConCommand = globals::cvars->GetCommand(ConCommandHandle());
-    ConCommandHandle conCommandHandle;
-    conCommandHandle.Set(0);
+    ConCommandData* currentConCommand = nullptr;
+    ConCommandData* invalidConCommand = globals::cvars->GetConCommandData(ConCommandRef());
+    ConCommandRef ref = ConCommandRef((uint16)0);
 
-    do
+    ConCommandData* data = g_pCVar->GetConCommandData(ConCommandRef());
+    for (ConCommandRef ref = ConCommandRef((uint16)0); ref.GetRawData() != data; ref = ConCommandRef(ref.GetAccessIndex() + 1))
     {
-        currentConCommand = globals::cvars->GetCommand(conCommandHandle);
-
-        conCommandHandle.Set(conCommandHandle.Get() + 1);
+        if (!ref.IsFlagSet(flagsToRemove)) continue;
 
-        if (!currentConCommand || currentConCommand == invalidConCommand || !(currentConCommand->GetFlags() & flagsToRemove)) continue;
-
-        currentConCommand->RemoveFlags(flagsToRemove);
+        ref.RemoveFlags(flagsToRemove);
         unhiddenConCommands++;
-    } while (currentConCommand && currentConCommand != invalidConCommand);
+    }
 }
 
 void ConCommandManager::OnShutdown()
@@ -301,10 +287,10 @@ void ConCommandManager::AddCommandListener(const char* name, CallbackT callback,
         pInfo = new ConCommandInfo();
         m_cmd_lookup[strName] = pInfo;
 
-        ConCommandHandle hExistingCommand = globals::cvars->FindCommand(name);
-        if (hExistingCommand.IsValid())
+        ConCommandRef hExistingCommand = globals::cvars->FindConCommand(name);
+        if (hExistingCommand.IsValidRef())
         {
-            pInfo->command = globals::cvars->GetCommand(hExistingCommand);
+            pInfo->command = globals::cvars->GetConCommandData(hExistingCommand);
         }
     }
 
@@ -353,11 +339,10 @@ void ConCommandManager::RemoveCommandListener(const char* name, CallbackT callba
 
 bool ConCommandManager::AddValveCommand(const char* name, const char* description, bool server_only, int flags)
 {
-    ConCommandHandle hExistingCommand = globals::cvars->FindCommand(name);
-    if (hExistingCommand.IsValid()) return false;
+    ConCommandRef hExistingCommand = globals::cvars->FindConCommand(name);
+    if (hExistingCommand.IsValidRef()) return false;
 
-    ConCommandRefAbstract conCommandRefAbstract;
-    auto conCommand = new ConCommand(&conCommandRefAbstract, strdup(name), CommandCallback, description ? strdup(description) : "", flags);
+    auto conCommand = new ConCommand(strdup(name), CommandCallback, description ? strdup(description) : "", flags);
 
     ConCommandInfo* pInfo = m_cmd_lookup[std::string(name)];
 
@@ -367,23 +352,22 @@ bool ConCommandManager::AddValveCommand(const char* name, const char* descriptio
         m_cmd_lookup[std::string(name)] = pInfo;
     }
 
-    pInfo->p_cmd = conCommandRefAbstract;
-    pInfo->command = conCommand;
+    pInfo->command = conCommand->GetRawData();
     pInfo->server_only = server_only;
 
     return true;
 }
 
 bool ConCommandManager::RemoveValveCommand(const char* name)
 {
-    auto hFoundCommand = globals::cvars->FindCommand(name);
+    auto hFoundCommand = globals::cvars->FindConCommand(name);
 
-    if (!hFoundCommand.IsValid())
+    if (!hFoundCommand.IsValidRef())
     {
         return false;
     }
 
-    globals::cvars->UnregisterConCommand(hFoundCommand);
+    globals::cvars->UnregisterConCommandCallbacks(hFoundCommand);
 
     auto pInfo = m_cmd_lookup[std::string(name)];
     if (!pInfo)
@@ -474,7 +458,7 @@ HookResult ConCommandManager::ExecuteCommandCallbacks(
     return result;
 }
 
-void ConCommandManager::Hook_DispatchConCommand(ConCommandHandle cmd, const CCommandContext& ctx, const CCommand& args)
+void ConCommandManager::Hook_DispatchConCommand(ConCommandRef cmd, const CCommandContext& ctx, const CCommand& args)
 {
     const char* name = args.Arg(0);
 
@@ -486,7 +470,7 @@ void ConCommandManager::Hook_DispatchConCommand(ConCommandHandle cmd, const CCom
         RETURN_META(MRES_SUPERCEDE);
     }
 }
-void ConCommandManager::Hook_DispatchConCommand_Post(ConCommandHandle cmd, const CCommandContext& ctx, const CCommand& args)
+void ConCommandManager::Hook_DispatchConCommand_Post(ConCommandRef cmd, const CCommandContext& ctx, const CCommand& args)
 {
     const char* name = args.Arg(0);
 
@@ -498,8 +482,8 @@ void ConCommandManager::Hook_DispatchConCommand_Post(ConCommandHandle cmd, const
 }
 bool ConCommandManager::IsValidValveCommand(const char* name)
 {
-    ConCommandHandle pCmd = globals::cvars->FindCommand(name);
-    return pCmd.IsValid();
+    ConCommandRef pCmd = globals::cvars->FindConCommand(name);
+    return pCmd.IsValidRef();
 }
 
 CommandCallingContext ConCommandManager::GetCommandCallingContext(CCommand* args) { return m_cmd_contexts[args]; }
diff --git a/src/core/managers/con_command_manager.h b/src/core/managers/con_command_manager.h
@@ -78,8 +78,7 @@ class ConCommandInfo
     ScriptCallback* GetCallback() { return callback_pre; }
 
   private:
-    ConCommandRefAbstract p_cmd;
-    ConCommand* command;
+    ConCommandData* command;
     ScriptCallback* callback_pre;
     ScriptCallback* callback_post;
     bool server_only;
@@ -100,8 +99,8 @@ class ConCommandManager : public GlobalClass
     bool IsValidValveCommand(const char* name);
     bool AddValveCommand(const char* name, const char* description, bool server_only, int flags);
     bool RemoveValveCommand(const char* name);
-    void Hook_DispatchConCommand(ConCommandHandle cmd, const CCommandContext& ctx, const CCommand& args);
-    void Hook_DispatchConCommand_Post(ConCommandHandle cmd, const CCommandContext& ctx, const CCommand& args);
+    void Hook_DispatchConCommand(ConCommandRef cmd, const CCommandContext& ctx, const CCommand& args);
+    void Hook_DispatchConCommand_Post(ConCommandRef cmd, const CCommandContext& ctx, const CCommand& args);
     HookResult ExecuteCommandCallbacks(
         const char* name, const CCommandContext& ctx, const CCommand& args, HookMode mode, CommandCallingContext callingContext);
 
diff --git a/src/core/memory_module.h b/src/core/memory_module.h
@@ -32,7 +32,6 @@
 
 #include "interface.h"
 #include "strtools.h"
-#include "metamod_oslink.h"
 #undef snprintf
 
 namespace counterstrikesharp::modules {
diff --git a/src/mm_plugin.cpp b/src/mm_plugin.cpp
@@ -66,6 +66,8 @@ class GameSessionConfiguration_t
 {
 };
 
+PLUGIN_EXPOSE(CounterStrikeSharpMMPlugin, counterstrikesharp::gPlugin);
+
 namespace counterstrikesharp {
 
 SH_DECL_HOOK3_void(IServerGameDLL, GameFrame, SH_NOATTRIB, 0, bool, bool, bool);
@@ -81,7 +83,6 @@ CounterStrikeSharpMMPlugin gPlugin;
 ConVar sample_cvar("sample_cvar", "42", 0);
 #endif
 
-PLUGIN_EXPOSE(CounterStrikeSharpMMPlugin, gPlugin);
 bool CounterStrikeSharpMMPlugin::Load(PluginId id, ISmmAPI* ismm, char* error, size_t maxlen, bool late)
 {
     PLUGIN_SAVEVARS();
diff --git a/src/mm_plugin.h b/src/mm_plugin.h
@@ -74,7 +74,9 @@ static ScriptCallback* on_activate_callback;
 static ScriptCallback* on_metamod_all_plugins_loaded_callback;
 extern CounterStrikeSharpMMPlugin gPlugin;
 
-PLUGIN_GLOBALVARS();
 
 #endif //_INCLUDE_METAMOD_SOURCE_STUB_PLUGIN_H_
 }
+
+PLUGIN_GLOBALVARS();
+
diff --git a/src/scripting/natives/natives_commands.cpp b/src/scripting/natives/natives_commands.cpp
@@ -17,14 +17,14 @@
 #include <eiface.h>
 #include <networksystem/inetworkmessages.h>
 
-#include "scripting/autonative.h"
-#include "scripting/callback_manager.h"
+#include "core/log.h"
 #include "core/managers/con_command_manager.h"
 #include "core/managers/player_manager.h"
 #include "core/recipientfilters.h"
 #include "igameeventsystem.h"
+#include "scripting/autonative.h"
+#include "scripting/callback_manager.h"
 #include "scripting/script_engine.h"
-#include "core/log.h"
 #include <networkbasetypes.pb.h>
 
 namespace counterstrikesharp {
@@ -37,8 +37,7 @@ static void AddCommand(ScriptContext& script_context)
     auto flags = script_context.GetArgument<int>(3);
     auto callback = script_context.GetArgument<CallbackT>(4);
 
-    CSSHARP_CORE_TRACE("Adding command {}, {}, {}, {}, {}", name, description, server_only, flags,
-                       (void*)callback);
+    CSSHARP_CORE_TRACE("Adding command {}, {}, {}, {}, {}", name, description, server_only, flags, (void*)callback);
 
     globals::conCommandManager.AddValveCommand(name, description, server_only, flags);
     globals::conCommandManager.AddCommandListener(name, callback, HookMode::Pre);
@@ -59,8 +58,7 @@ static void AddCommandListener(ScriptContext& script_context)
     auto callback = script_context.GetArgument<CallbackT>(1);
     auto post = script_context.GetArgument<bool>(2);
 
-    globals::conCommandManager.AddCommandListener(name, callback,
-                                                  post ? HookMode::Post : HookMode::Pre);
+    globals::conCommandManager.AddCommandListener(name, callback, post ? HookMode::Post : HookMode::Pre);
 }
 
 static void RemoveCommandListener(ScriptContext& script_context)
@@ -69,15 +67,15 @@ static void RemoveCommandListener(ScriptContext& script_context)
     auto callback = script_context.GetArgument<CallbackT>(1);
     auto post = script_context.GetArgument<bool>(2);
 
-    globals::conCommandManager.RemoveCommandListener(name, callback,
-                                                     post ? HookMode::Post : HookMode::Pre);
+    globals::conCommandManager.RemoveCommandListener(name, callback, post ? HookMode::Post : HookMode::Pre);
 }
 
 static int CommandGetArgCount(ScriptContext& script_context)
 {
     auto command = script_context.GetArgument<CCommand*>(0);
 
-    if (!command) {
+    if (!command)
+    {
         script_context.ThrowNativeError("Invalid command.");
         return -1;
     }
@@ -89,7 +87,8 @@ static const char* CommandGetArgString(ScriptContext& script_context)
 {
     auto command = script_context.GetArgument<CCommand*>(0);
 
-    if (!command) {
+    if (!command)
+    {
         script_context.ThrowNativeError("Invalid command.");
         return nullptr;
     }
@@ -101,7 +100,8 @@ static const char* CommandGetCommandString(ScriptContext& script_context)
 {
     auto* command = script_context.GetArgument<CCommand*>(0);
 
-    if (!command) {
+    if (!command)
+    {
         script_context.ThrowNativeError("Invalid command.");
         return nullptr;
     }
@@ -114,7 +114,8 @@ static const char* CommandGetArgByIndex(ScriptContext& script_context)
     auto* command = script_context.GetArgument<CCommand*>(0);
     auto index = script_context.GetArgument<int>(1);
 
-    if (!command) {
+    if (!command)
+    {
         script_context.ThrowNativeError("Invalid command.");
         return nullptr;
     }
@@ -145,9 +146,8 @@ static void IssueClientCommandFromServer(ScriptContext& script_context)
     CCommand args;
     args.Tokenize(pszCommand);
 
-    auto handle = globals::cvars->FindCommand(args.Arg(0));
-    if (!handle.IsValid())
-        return;
+    auto handle = globals::cvars->FindConCommand(args.Arg(0));
+    if (!handle.IsValidRef()) return;
 
     CCommandContext context(CommandTarget_t::CT_NO_TARGET, CPlayerSlot(slot));
 
@@ -171,28 +171,37 @@ static void SetFakeClientConVarValue(ScriptContext& script_context)
     globals::engine->SetFakeClientConVarValue(CPlayerSlot(playerSlot), convarName, convarValue);
 }
 
-ConVar* FindConVar(ScriptContext& script_context)
+ConVarData* FindConVar(ScriptContext& script_context)
 {
     auto name = script_context.GetArgument<const char*>(0);
     auto hCvarHandle = globals::cvars->FindConVar(name, true);
 
-    if (!hCvarHandle.IsValid()) {
+    if (!hCvarHandle.IsValidRef())
+    {
         return nullptr;
     }
 
-    return globals::cvars->GetConVar(hCvarHandle);
+    return globals::cvars->GetConVarData(hCvarHandle);
 }
 
 void SetConVarStringValue(ScriptContext& script_context)
 {
-    auto pCvar = script_context.GetArgument<ConVar*>(0);
+    auto pCvar = script_context.GetArgument<ConVarData*>(0);
     auto value = script_context.GetArgument<const char*>(1);
 
-    if (!pCvar) {
+    if (!pCvar)
+    {
+        script_context.ThrowNativeError("Invalid cvar.");
+    }
+
+    ConVarRefAbstract cvarRef(pCvar->GetName());
+
+    if (!cvarRef.IsValidRef() || !cvarRef.IsConVarDataAvailable())
+    {
         script_context.ThrowNativeError("Invalid cvar.");
     }
 
-    pCvar->values = reinterpret_cast<CVValue_t**>((char*)value);
+    cvarRef.SetString(value);
 }
 
 void ReplicateConVar(ScriptContext& script_context)
@@ -230,8 +239,7 @@ REGISTER_NATIVES(commands, {
     ScriptEngine::RegisterNativeHandler("SET_CONVAR_STRING_VALUE", SetConVarStringValue);
 
     ScriptEngine::RegisterNativeHandler("ISSUE_CLIENT_COMMAND", IssueClientCommand);
-    ScriptEngine::RegisterNativeHandler("ISSUE_CLIENT_COMMAND_FROM_SERVER",
-                                        IssueClientCommandFromServer);
+    ScriptEngine::RegisterNativeHandler("ISSUE_CLIENT_COMMAND_FROM_SERVER", IssueClientCommandFromServer);
     ScriptEngine::RegisterNativeHandler("GET_CLIENT_CONVAR_VALUE", GetClientConVarValue);
     ScriptEngine::RegisterNativeHandler("SET_FAKE_CLIENT_CONVAR_VALUE", SetFakeClientConVarValue);
     ScriptEngine::RegisterNativeHandler("REPLICATE_CONVAR", ReplicateConVar);

Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ CON_COMMAND(dump_schema, "dump schema symbols")`
`179`	`179`	`output << std::setw(2) << j << std::endl;`
`180`	`180`	`}`
`181`	`181`
`182`		`-SH_DECL_HOOK3_void(ICvar, DispatchConCommand, SH_NOATTRIB, 0, ConCommandHandle, const CCommandContext&, const CCommand&);`
	`182`	`+SH_DECL_HOOK3_void(ICvar, DispatchConCommand, SH_NOATTRIB, 0, ConCommandRef, const CCommandContext&, const CCommand&);`
`183`	`183`
`184`	`184`	`ConCommandInfo::ConCommandInfo()`
`185`	`185`	`{`
`@@ -222,45 +222,31 @@ void UnlockConVars()`
`222`	`222`	`{`
`223`	`223`	`int unhiddenConVars = 0;`
`224`	`224`
`225`		`- ConVar* currentCvar = nullptr;`
`226`		`- ConVarHandle currentCvarHandle;`
`227`		`- currentCvarHandle.Set(0);`
`228`		`-`
`229`		`- do`
	`225`	`+ for (ConVarRefAbstract ref(ConVarRef((uint16)0)); ref.IsValidRef(); ref = ConVarRefAbstract(ConVarRef(ref.GetAccessIndex() + 1)))`
`230`	`226`	`{`
`231`		`- currentCvar = globals::cvars->GetConVar(currentCvarHandle);`
`232`		`-`
`233`		`- currentCvarHandle.Set(currentCvarHandle.Get() + 1);`
`234`		`-`
`235`		`- if (!currentCvar) continue;`
`236`		`-`
`237`		`- if (!(currentCvar->flags & flagsToRemove)) continue;`
	`227`	`+ if (!ref.IsFlagSet(flagsToRemove)) continue;`
`238`	`228`
`239`		`- currentCvar->flags &= ~flagsToRemove;`
	`229`	`+ ref.RemoveFlags(flagsToRemove);`
`240`	`230`	`unhiddenConVars++;`
`241`		`- } while (currentCvar);`
	`231`	`+ }`
`242`	`232`	`}`
`243`	`233`
`244`	`234`	`void UnlockConCommands()`
`245`	`235`	`{`
`246`	`236`	`int unhiddenConCommands = 0;`
`247`	`237`
`248`		`- ConCommand* currentConCommand = nullptr;`
`249`		`- ConCommand* invalidConCommand = globals::cvars->GetCommand(ConCommandHandle());`
`250`		`- ConCommandHandle conCommandHandle;`
`251`		`- conCommandHandle.Set(0);`
	`238`	`+ ConCommandData* currentConCommand = nullptr;`
	`239`	`+ ConCommandData* invalidConCommand = globals::cvars->GetConCommandData(ConCommandRef());`
	`240`	`+ ConCommandRef ref = ConCommandRef((uint16)0);`
`252`	`241`
`253`		`- do`
	`242`	`+ ConCommandData* data = g_pCVar->GetConCommandData(ConCommandRef());`
	`243`	`+ for (ConCommandRef ref = ConCommandRef((uint16)0); ref.GetRawData() != data; ref = ConCommandRef(ref.GetAccessIndex() + 1))`
`254`	`244`	`{`
`255`		`- currentConCommand = globals::cvars->GetCommand(conCommandHandle);`
`256`		`-`
`257`		`- conCommandHandle.Set(conCommandHandle.Get() + 1);`
	`245`	`+ if (!ref.IsFlagSet(flagsToRemove)) continue;`
`258`	`246`
`259`		`- if (!currentConCommand \|\| currentConCommand == invalidConCommand \|\| !(currentConCommand->GetFlags() & flagsToRemove)) continue;`
`260`		`-`
`261`		`- currentConCommand->RemoveFlags(flagsToRemove);`
	`247`	`+ ref.RemoveFlags(flagsToRemove);`
`262`	`248`	`unhiddenConCommands++;`
`263`		`- } while (currentConCommand && currentConCommand != invalidConCommand);`
	`249`	`+ }`
`264`	`250`	`}`
`265`	`251`
`266`	`252`	`void ConCommandManager::OnShutdown()`
`@@ -301,10 +287,10 @@ void ConCommandManager::AddCommandListener(const char* name, CallbackT callback,`
`301`	`287`	`pInfo = new ConCommandInfo();`
`302`	`288`	`m_cmd_lookup[strName] = pInfo;`
`303`	`289`
`304`		`- ConCommandHandle hExistingCommand = globals::cvars->FindCommand(name);`
`305`		`- if (hExistingCommand.IsValid())`
	`290`	`+ ConCommandRef hExistingCommand = globals::cvars->FindConCommand(name);`
	`291`	`+ if (hExistingCommand.IsValidRef())`
`306`	`292`	`{`
`307`		`- pInfo->command = globals::cvars->GetCommand(hExistingCommand);`
	`293`	`+ pInfo->command = globals::cvars->GetConCommandData(hExistingCommand);`
`308`	`294`	`}`
`309`	`295`	`}`
`310`	`296`
`@@ -353,11 +339,10 @@ void ConCommandManager::RemoveCommandListener(const char* name, CallbackT callba`
`353`	`339`
`354`	`340`	`bool ConCommandManager::AddValveCommand(const char* name, const char* description, bool server_only, int flags)`
`355`	`341`	`{`
`356`		`- ConCommandHandle hExistingCommand = globals::cvars->FindCommand(name);`
`357`		`- if (hExistingCommand.IsValid()) return false;`
	`342`	`+ ConCommandRef hExistingCommand = globals::cvars->FindConCommand(name);`
	`343`	`+ if (hExistingCommand.IsValidRef()) return false;`
`358`	`344`
`359`		`- ConCommandRefAbstract conCommandRefAbstract;`
`360`		`- auto conCommand = new ConCommand(&conCommandRefAbstract, strdup(name), CommandCallback, description ? strdup(description) : "", flags);`
	`345`	`+ auto conCommand = new ConCommand(strdup(name), CommandCallback, description ? strdup(description) : "", flags);`
`361`	`346`
`362`	`347`	`ConCommandInfo* pInfo = m_cmd_lookup[std::string(name)];`
`363`	`348`
`@@ -367,23 +352,22 @@ bool ConCommandManager::AddValveCommand(const char* name, const char* descriptio`
`367`	`352`	`m_cmd_lookup[std::string(name)] = pInfo;`
`368`	`353`	`}`
`369`	`354`
`370`		`- pInfo->p_cmd = conCommandRefAbstract;`
`371`		`- pInfo->command = conCommand;`
	`355`	`+ pInfo->command = conCommand->GetRawData();`
`372`	`356`	`pInfo->server_only = server_only;`
`373`	`357`
`374`	`358`	`return true;`
`375`	`359`	`}`
`376`	`360`
`377`	`361`	`bool ConCommandManager::RemoveValveCommand(const char* name)`
`378`	`362`	`{`
`379`		`- auto hFoundCommand = globals::cvars->FindCommand(name);`
	`363`	`+ auto hFoundCommand = globals::cvars->FindConCommand(name);`
`380`	`364`
`381`		`- if (!hFoundCommand.IsValid())`
	`365`	`+ if (!hFoundCommand.IsValidRef())`
`382`	`366`	`{`
`383`	`367`	`return false;`
`384`	`368`	`}`
`385`	`369`
`386`		`- globals::cvars->UnregisterConCommand(hFoundCommand);`
	`370`	`+ globals::cvars->UnregisterConCommandCallbacks(hFoundCommand);`
`387`	`371`
`388`	`372`	`auto pInfo = m_cmd_lookup[std::string(name)];`
`389`	`373`	`if (!pInfo)`
`@@ -474,7 +458,7 @@ HookResult ConCommandManager::ExecuteCommandCallbacks(`
`474`	`458`	`return result;`
`475`	`459`	`}`
`476`	`460`
`477`		`-void ConCommandManager::Hook_DispatchConCommand(ConCommandHandle cmd, const CCommandContext& ctx, const CCommand& args)`
	`461`	`+void ConCommandManager::Hook_DispatchConCommand(ConCommandRef cmd, const CCommandContext& ctx, const CCommand& args)`
`478`	`462`	`{`
`479`	`463`	`const char* name = args.Arg(0);`
`480`	`464`
`@@ -486,7 +470,7 @@ void ConCommandManager::Hook_DispatchConCommand(ConCommandHandle cmd, const CCom`
`486`	`470`	`RETURN_META(MRES_SUPERCEDE);`
`487`	`471`	`}`
`488`	`472`	`}`
`489`		`-void ConCommandManager::Hook_DispatchConCommand_Post(ConCommandHandle cmd, const CCommandContext& ctx, const CCommand& args)`
	`473`	`+void ConCommandManager::Hook_DispatchConCommand_Post(ConCommandRef cmd, const CCommandContext& ctx, const CCommand& args)`
`490`	`474`	`{`
`491`	`475`	`const char* name = args.Arg(0);`
`492`	`476`
`@@ -498,8 +482,8 @@ void ConCommandManager::Hook_DispatchConCommand_Post(ConCommandHandle cmd, const`
`498`	`482`	`}`
`499`	`483`	`bool ConCommandManager::IsValidValveCommand(const char* name)`
`500`	`484`	`{`
`501`		`- ConCommandHandle pCmd = globals::cvars->FindCommand(name);`
`502`		`- return pCmd.IsValid();`
	`485`	`+ ConCommandRef pCmd = globals::cvars->FindConCommand(name);`
	`486`	`+ return pCmd.IsValidRef();`
`503`	`487`	`}`
`504`	`488`
`505`	`489`	`CommandCallingContext ConCommandManager::GetCommandCallingContext(CCommand* args) { return m_cmd_contexts[args]; }`
Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,8 @@ class GameSessionConfiguration_t`
`66`	`66`	`{`
`67`	`67`	`};`
`68`	`68`
	`69`	`+PLUGIN_EXPOSE(CounterStrikeSharpMMPlugin, counterstrikesharp::gPlugin);`
	`70`	`+`
`69`	`71`	`namespace counterstrikesharp {`
`70`	`72`
`71`	`73`	`SH_DECL_HOOK3_void(IServerGameDLL, GameFrame, SH_NOATTRIB, 0, bool, bool, bool);`
`@@ -81,7 +83,6 @@ CounterStrikeSharpMMPlugin gPlugin;`
`81`	`83`	`ConVar sample_cvar("sample_cvar", "42", 0);`
`82`	`84`	`#endif`
`83`	`85`
`84`		`-PLUGIN_EXPOSE(CounterStrikeSharpMMPlugin, gPlugin);`
`85`	`86`	`bool CounterStrikeSharpMMPlugin::Load(PluginId id, ISmmAPI* ismm, char* error, size_t maxlen, bool late)`
`86`	`87`	`{`
`87`	`88`	`PLUGIN_SAVEVARS();`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,9 @@ static ScriptCallback* on_activate_callback;`
`74`	`74`	`static ScriptCallback* on_metamod_all_plugins_loaded_callback;`
`75`	`75`	`extern CounterStrikeSharpMMPlugin gPlugin;`
`76`	`76`
`77`		`-PLUGIN_GLOBALVARS();`
`78`	`77`
`79`	`78`	`#endif //_INCLUDE_METAMOD_SOURCE_STUB_PLUGIN_H_`
`80`	`79`	`}`
	`80`	`+`
	`81`	`+PLUGIN_GLOBALVARS();`
	`82`	`+`