chore: upgrade metamod & hl2sdk

src/core/gameconfig.cpp

@@ -3,7 +3,6 @@
 #include <fstream>
 
 #include "log.h"
-#include "metamod_oslink.h"
 
 namespace counterstrikesharp {
 

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>
 

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]; }

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);
 

src/core/memory_module.h

@@ -32,7 +32,6 @@
 
 #include "interface.h"
 #include "strtools.h"
-#include "metamod_oslink.h"
 #undef snprintf
 
 namespace counterstrikesharp::modules {

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();

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();
+

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);