From b7d9d487cca2f9af1bbdb34aa5cbef7596e51da3 Mon Sep 17 00:00:00 2001 From: Borja Ferrer Date: Sun, 14 Oct 2007 00:04:21 +0000 Subject: [PATCH] ported SM's core to Orange Box build is broken now in purpose --HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401547 --- core/ChatTriggers.cpp | 20 +- core/ChatTriggers.h | 5 + core/ConCmdManager.cpp | 38 +- core/ConCmdManager.h | 8 +- core/ConVarManager.cpp | 35 +- core/ConVarManager.h | 8 +- core/CoreConfig.cpp | 7 +- core/CoreConfig.h | 2 +- core/GameConfigs.cpp | 4 +- core/MenuStyle_Radio.cpp | 6 +- core/MenuStyle_Radio.h | 3 +- core/MenuStyle_Valve.cpp | 6 +- core/MenuStyle_Valve.h | 3 +- core/MenuVoting.cpp | 8 + core/PlayerManager.cpp | 22 +- core/PlayerManager.h | 4 + core/TimerSys.cpp | 18 +- core/bitbuf.cpp | 961 +++++++++++++++++++++++++++++++++ core/convar_sm_ob.h | 709 ++++++++++++++++++++++++ core/msvc8/sourcemod_mm.sln | 6 + core/msvc8/sourcemod_mm.vcproj | 175 +++++- core/sm_srvcmds.cpp | 62 +-- core/sm_srvcmds.h | 7 +- core/smn_console.cpp | 28 +- core/smn_usermsgs.cpp | 20 +- core/smn_vector.cpp | 12 +- core/sourcemm_api.cpp | 25 +- core/sourcemm_api.h | 10 +- core/systems/ExtensionSys.cpp | 11 +- core/systems/ExtensionSys.h | 2 +- core/systems/PluginSys.cpp | 17 +- core/systems/PluginSys.h | 6 +- public/IRootConsoleMenu.h | 26 +- public/compat_wrappers.h | 82 +++ public/metamod_wrappers.h | 48 ++ 35 files changed, 2240 insertions(+), 164 deletions(-) create mode 100644 core/bitbuf.cpp create mode 100644 core/convar_sm_ob.h create mode 100644 public/compat_wrappers.h create mode 100644 public/metamod_wrappers.h diff --git a/core/ChatTriggers.cpp b/core/ChatTriggers.cpp index 3dc81c57..dcda7f33 100644 --- a/core/ChatTriggers.cpp +++ b/core/ChatTriggers.cpp @@ -36,13 +36,17 @@ #include /* :HACKHACK: We can't SH_DECL here because ConCmdManager.cpp does */ +#if defined ORANGEBOX_BUILD +extern bool __SourceHook_FHRemoveConCommandDispatch(void *, bool, class fastdelegate::FastDelegate1); +extern int __SourceHook_FHAddConCommandDispatch(void *, ISourceHook::AddHookMode, bool, class fastdelegate::FastDelegate1); +#else extern bool __SourceHook_FHRemoveConCommandDispatch(void *, bool, class fastdelegate::FastDelegate0); - #if SH_IMPL_VERSION >= 4 extern int __SourceHook_FHAddConCommandDispatch(void *, bool, class fastdelegate::FastDelegate0); #else extern bool __SourceHook_FHAddConCommandDispatch(void *, bool, class fastdelegate::FastDelegate0); -#endif +#endif //SH_IMPL_VERSION >= 4 +#endif //ORANGEBOX_BUILD ChatTriggers g_ChatTriggers; @@ -140,8 +144,14 @@ void ChatTriggers::OnSourceModShutdown() } } +#if defined ORANGEBOX_BUILD +void ChatTriggers::OnSayCommand_Pre(const CCommand &command) +{ +#else void ChatTriggers::OnSayCommand_Pre() { + CCommand command; +#endif int client = g_ConCmds.GetCommandClient(); m_bIsChatTrigger = false; @@ -151,7 +161,7 @@ void ChatTriggers::OnSayCommand_Pre() RETURN_META(MRES_IGNORED); } - const char *args = engine->Cmd_Args(); + const char *args = command.ArgS(); if (!args) { @@ -211,7 +221,11 @@ void ChatTriggers::OnSayCommand_Pre() RETURN_META(MRES_IGNORED); } +#if defined ORANGEBOX_BUILD +void ChatTriggers::OnSayCommand_Post(const CCommand &command) +#else void ChatTriggers::OnSayCommand_Post() +#endif { m_bIsChatTrigger = false; if (m_bWillProcessInPost) diff --git a/core/ChatTriggers.h b/core/ChatTriggers.h index 6912801c..ddfbecf7 100644 --- a/core/ChatTriggers.h +++ b/core/ChatTriggers.h @@ -50,8 +50,13 @@ public: //SMGlobalClass char *error, size_t maxlength); private: //ConCommand +#if defined ORANGEBOX_BUILD + void OnSayCommand_Pre(const CCommand &command); + void OnSayCommand_Post(const CCommand &command); +#else void OnSayCommand_Pre(); void OnSayCommand_Post(); +#endif public: unsigned int GetReplyTo(); unsigned int SetReplyTo(unsigned int reply); diff --git a/core/ConCmdManager.cpp b/core/ConCmdManager.cpp index 43da1796..b64b78d6 100644 --- a/core/ConCmdManager.cpp +++ b/core/ConCmdManager.cpp @@ -40,7 +40,12 @@ ConCmdManager g_ConCmds; -SH_DECL_HOOK0_void(ConCommand, Dispatch, SH_NOATTRIB, false); +#if defined ORANGEBOX_BUILD + SH_DECL_HOOK1_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommand &); +#else + SH_DECL_HOOK0_void(ConCommand, Dispatch, SH_NOATTRIB, false); +#endif + SH_DECL_HOOK1_void(IServerGameClients, SetCommandClient, SH_NOATTRIB, false, int); struct PlCmdInfo @@ -144,10 +149,15 @@ void ConCmdManager::OnPluginDestroyed(IPlugin *plugin) delete pList; } } - +#if defined ORANGEBOX_BUILD +void CommandCallback(const CCommand &command) +{ +#else void CommandCallback() { - g_ConCmds.InternalDispatch(); + CCommand command; +#endif + g_ConCmds.InternalDispatch(command); } void ConCmdManager::SetCommandClient(int client) @@ -201,7 +211,7 @@ ResultType ConCmdManager::DispatchClientCommand(int client, const char *cmd, int return type; } -void ConCmdManager::InternalDispatch() +void ConCmdManager::InternalDispatch(const CCommand &command) { int client = m_CmdClient; @@ -221,7 +231,7 @@ void ConCmdManager::InternalDispatch() * Whether or not it goes through the callback is determined by FCVAR_GAMEDLL */ char cmd[300]; - strncopy(cmd, engine->Cmd_Argv(0), sizeof(cmd)); + strncopy(cmd, command.Arg(0), sizeof(cmd)); ConCmdInfo *pInfo; if (!sm_trie_retrieve(m_pCmds, cmd, (void **)&pInfo)) @@ -230,7 +240,7 @@ void ConCmdManager::InternalDispatch() } cell_t result = Pl_Continue; - int args = engine->Cmd_Argc() - 1; + int args = command.ArgC() - 1; List::iterator iter; CmdHook *pHook; @@ -725,7 +735,7 @@ void ConCmdManager::RemoveConCmd(ConCmdInfo *info) if (info->sourceMod) { /* Unlink from SourceMM */ - g_SMAPI->UnregisterConCmdBase(g_PLAPI, info->pCmd); + g_SMAPI->UnregisterConCommandBase(g_PLAPI, info->pCmd); /* Delete the command's memory */ char *new_help = const_cast(info->pCmd->GetHelpText()); char *new_name = const_cast(info->pCmd->GetName()); @@ -822,11 +832,11 @@ ConCmdInfo *ConCmdManager::AddOrFindCommand(const char *name, const char *descri return pInfo; } -void ConCmdManager::OnRootConsoleCommand(const char *command, unsigned int argcount) +void ConCmdManager::OnRootConsoleCommand(const char *cmdname, const CCommand &command) { - if (argcount >= 3) + if (command.ArgC() >= 3) { - const char *text = engine->Cmd_Argv(2); + const char *text = command.Arg(2); int id = atoi(text); CPlugin *pPlugin = g_PluginSys.GetPluginByOrder(id); @@ -919,9 +929,15 @@ void _YamState(int state) g_yam_state = state; } +#if defined ORANGEBOX_BUILD +void _IntExt_CallYams(const CCommand &cmd) +{ +#else void _IntExt_CallYams() { - const char *arg = engine->Cmd_Argv(1); + CCommand cmd; +#endif + const char *arg = cmd.Arg(1); /* should be impossible */ if (!arg || arg[0] == '\0') diff --git a/core/ConCmdManager.h b/core/ConCmdManager.h index 062003e9..b63797eb 100644 --- a/core/ConCmdManager.h +++ b/core/ConCmdManager.h @@ -96,7 +96,11 @@ class ConCmdManager : public IRootConsoleCommand, public IPluginsListener { +#if defined ORANGEBOX_BUILD + friend void CommandCallback(const CCommand &command); +#else friend void CommandCallback(); +#endif public: ConCmdManager(); ~ConCmdManager(); @@ -106,7 +110,7 @@ public: //SMGlobalClass public: //IPluginsListener void OnPluginDestroyed(IPlugin *plugin); public: //IRootConsoleCommand - void OnRootConsoleCommand(const char *command, unsigned int argcount); + void OnRootConsoleCommand(const char *cmdname, const CCommand &command); public: bool AddServerCommand(IPluginFunction *pFunction, const char *name, const char *description, int flags); bool AddConsoleCommand(IPluginFunction *pFunction, const char *name, const char *description, int flags); @@ -122,7 +126,7 @@ public: bool LookForCommandAdminFlags(const char *cmd, FlagBits *pFlags); bool CheckCommandAccess(int client, const char *cmd, FlagBits flags); private: - void InternalDispatch(); + void InternalDispatch(const CCommand &command); ResultType RunAdminCommand(ConCmdInfo *pInfo, int client, int args); ConCmdInfo *AddOrFindCommand(const char *name, const char *description, int flags); void SetCommandClient(int client); diff --git a/core/ConVarManager.cpp b/core/ConVarManager.cpp index e906579a..f9831058 100644 --- a/core/ConVarManager.cpp +++ b/core/ConVarManager.cpp @@ -234,16 +234,17 @@ void ConVarManager::OnHandleDestroy(HandleType_t type, void *object) delete [] pConVar->GetHelpText(); /* Then unlink it from SourceMM */ - g_SMAPI->UnregisterConCmdBase(g_PLAPI, pConVar); + g_SMAPI->UnregisterConCommandBase(g_PLAPI, pConVar); } } -void ConVarManager::OnRootConsoleCommand(const char *command, unsigned int argcount) +void ConVarManager::OnRootConsoleCommand(const char *cmdname, const CCommand &command) { + int argcount = command.ArgC(); if (argcount >= 3) { /* Get plugin index that was passed */ - int id = atoi(g_RootMenu.GetArgument(2)); + int id = atoi(command.Arg(2)); /* Get plugin object */ CPlugin *plugin = g_PluginSys.GetPluginByOrder(id); @@ -525,10 +526,14 @@ void ConVarManager::AddConVarToPluginList(IPluginContext *pContext, const ConVar } } +#if defined ORANGEBOX_BUILD +void ConVarManager::OnConVarChanged(IConVar *pConVar, const char *oldValue, float flOldValue) +#else void ConVarManager::OnConVarChanged(ConVar *pConVar, const char *oldValue) +#endif { /* If the values are the same, exit early in order to not trigger callbacks */ - if (strcmp(pConVar->GetString(), oldValue) == 0) + if (strcmp(reinterpret_cast(pConVar)->GetString(), oldValue) == 0) { return; } @@ -539,19 +544,23 @@ void ConVarManager::OnConVarChanged(ConVar *pConVar, const char *oldValue) /* Find the convar in the lookup trie */ sm_trie_retrieve(pCache, pConVar->GetName(), (void **)&pInfo); - FnChangeCallback origCallback = pInfo->origCallback; + FnChangeCallback_t origCallback = pInfo->origCallback; IChangeableForward *pForward = pInfo->pChangeForward; /* If there was a change callback installed previously, call it */ if (origCallback) { +#if defined ORANGEBOX_BUILD + origCallback(pConVar, oldValue, flOldValue); +#else origCallback(pConVar, oldValue); +#endif } /* Now call forwards in plugins that have hooked this */ pForward->PushCell(pInfo->handle); pForward->PushString(oldValue); - pForward->PushString(pConVar->GetString()); + pForward->PushString(reinterpret_cast(pConVar)->GetString()); pForward->Execute(NULL); } @@ -652,10 +661,16 @@ void _YamagramPrinterTwoPointOhOh(int yamagram) s_YamagramState = yamagram; } +#if defined ORANGEBOX_BUILD +void _IntExt_CallYamagrams(const CCommand &cmd) +{ +#else void _IntExt_CallYamagrams() { + CCommand cmd; +#endif bool correct = false; - const char *arg = engine->Cmd_Args(); + const char *arg = cmd.ArgS(); if (!arg || arg[0] == '\0') { @@ -737,10 +752,14 @@ void _IntExt_EnableYamagrams() } } +#if defined ORANGEBOX_BUILD +void _IntExt_OnHostnameChanged(IConVar *pConVar, const char *oldValue, float flOldValue) +#else void _IntExt_OnHostnameChanged(ConVar *pConVar, char const *oldValue) +#endif { if (strcmp(oldValue, "Good morning, DS-san.") == 0 - && strcmp(pConVar->GetString(), "Good night, talking desk lamp.") == 0) + && strcmp(reinterpret_cast(pConVar)->GetString(), "Good night, talking desk lamp.") == 0) { _IntExt_EnableYamagrams(); } diff --git a/core/ConVarManager.h b/core/ConVarManager.h index 771cb9be..5ffd7a80 100644 --- a/core/ConVarManager.h +++ b/core/ConVarManager.h @@ -51,7 +51,7 @@ struct ConVarInfo Handle_t handle; /**< Handle to convar */ bool sourceMod; /**< Determines whether or not convar was created by a SourceMod plugin */ IChangeableForward *pChangeForward; /**< Forward associated with convar */ - FnChangeCallback origCallback; /**< The original callback function */ + FnChangeCallback_t origCallback; /**< The original callback function */ #if PLAPI_VERSION < 12 const char *name; /**< Name of convar */ #endif @@ -85,7 +85,7 @@ public: // IHandleTypeDispatch public: // IPluginsListener void OnPluginUnloaded(IPlugin *plugin); public: //IRootConsoleCommand - void OnRootConsoleCommand(const char *command, unsigned int argcount); + void OnRootConsoleCommand(const char *cmdname, const CCommand &command); public: /** * Get the 'ConVar' handle type ID. @@ -150,7 +150,11 @@ private: /** * Static callback that Valve's ConVar object executes when the convar's value changes. */ +#if defined ORANGEBOX_BUILD + static void OnConVarChanged(IConVar *pConVar, const char *oldValue, float flOldValue); +#else static void OnConVarChanged(ConVar *pConVar, const char *oldValue); +#endif /** * Callback for when StartQueryCvarValue() has finished. diff --git a/core/CoreConfig.cpp b/core/CoreConfig.cpp index 7bf4fddc..2359b670 100644 --- a/core/CoreConfig.cpp +++ b/core/CoreConfig.cpp @@ -71,12 +71,13 @@ void CoreConfig::OnSourceModLevelChange(const char *mapName) g_bConfigsExecd = false; } -void CoreConfig::OnRootConsoleCommand(const char *command, unsigned int argcount) +void CoreConfig::OnRootConsoleCommand(const char *cmdname, const CCommand &command) { + int argcount = command.ArgC(); if (argcount >= 4) { - const char *option = engine->Cmd_Argv(2); - const char *value = engine->Cmd_Argv(3); + const char *option = command.Arg(2); + const char *value = command.Arg(3); char error[255]; diff --git a/core/CoreConfig.h b/core/CoreConfig.h index 01054445..73398e97 100644 --- a/core/CoreConfig.h +++ b/core/CoreConfig.h @@ -50,7 +50,7 @@ public: // SMGlobalClass public: // ITextListener_SMC SMCParseResult ReadSMC_KeyValue(const char *key, const char *value, bool key_quotes, bool value_quotes); public: // IRootConsoleCommand - void OnRootConsoleCommand(const char *command, unsigned int argcount); + void OnRootConsoleCommand(const char *cmdname, const CCommand &command); public: /** * Initializes CoreConfig by reading from core.cfg file diff --git a/core/GameConfigs.cpp b/core/GameConfigs.cpp index 7d559270..d3c790ef 100644 --- a/core/GameConfigs.cpp +++ b/core/GameConfigs.cpp @@ -386,9 +386,9 @@ SMCParseResult CGameConfig::ReadSMC_LeavingSection() void *addrInBase = NULL; if (strcmp(s_TempSig.library, "server") == 0) { - addrInBase = (void *)g_SMAPI->serverFactory(false); + addrInBase = (void *)g_SMAPI->GetServerFactory(false); } else if (strcmp(s_TempSig.library, "engine") == 0) { - addrInBase = (void *)g_SMAPI->engineFactory(false); + addrInBase = (void *)g_SMAPI->GetEngineFactory(false); } void *final_addr = NULL; if (addrInBase == NULL) diff --git a/core/MenuStyle_Radio.cpp b/core/MenuStyle_Radio.cpp index 26503340..c891025b 100644 --- a/core/MenuStyle_Radio.cpp +++ b/core/MenuStyle_Radio.cpp @@ -96,16 +96,16 @@ bool CRadioStyle::IsSupported() return (g_ShowMenuId != -1); } -bool CRadioStyle::OnClientCommand(int client, const char *cmd) +bool CRadioStyle::OnClientCommand(int client, const char *cmdname, const CCommand &cmd) { - if (strcmp(cmd, "menuselect") == 0) + if (strcmp(cmdname, "menuselect") == 0) { if (!m_players[client].bInMenu) { return false; } - int arg = atoi(engine->Cmd_Argv(1)); + int arg = atoi(cmd.Arg(1)); ClientPressedKey(client, arg); return true; } diff --git a/core/MenuStyle_Radio.h b/core/MenuStyle_Radio.h index 248b8162..35f30cf0 100644 --- a/core/MenuStyle_Radio.h +++ b/core/MenuStyle_Radio.h @@ -40,6 +40,7 @@ #include #include "sm_fastlink.h" #include +#include using namespace SourceMod; @@ -70,7 +71,7 @@ public: //IUserMessageListener void OnUserMessageSent(int msg_id); public: bool IsSupported(); - bool OnClientCommand(int client, const char *cmd); + bool OnClientCommand(int client, const char *cmdname, const CCommand &cmd); public: CRadioDisplay *MakeRadioDisplay(CRadioMenu *menu=NULL); void FreeRadioDisplay(CRadioDisplay *display); diff --git a/core/MenuStyle_Valve.cpp b/core/MenuStyle_Valve.cpp index 08bd4b16..501cc32e 100644 --- a/core/MenuStyle_Valve.cpp +++ b/core/MenuStyle_Valve.cpp @@ -53,11 +53,11 @@ CBaseMenuPlayer *ValveMenuStyle::GetMenuPlayer(int client) return &m_players[client]; } -bool ValveMenuStyle::OnClientCommand(int client, const char *cmd) +bool ValveMenuStyle::OnClientCommand(int client, const char *cmdname, const CCommand &cmd) { - if (strcmp(cmd, "sm_vmenuselect") == 0) + if (strcmp(cmdname, "sm_vmenuselect") == 0) { - int key_press = atoi(engine->Cmd_Argv(1)); + int key_press = atoi(cmd.Arg(1)); g_ValveMenuStyle.ClientPressedKey(client, key_press); return true; } diff --git a/core/MenuStyle_Valve.h b/core/MenuStyle_Valve.h index 56797d18..1551c600 100644 --- a/core/MenuStyle_Valve.h +++ b/core/MenuStyle_Valve.h @@ -38,6 +38,7 @@ #include "sourcemm_api.h" #include "KeyValues.h" #include "sm_fastlink.h" +#include using namespace SourceMod; @@ -59,7 +60,7 @@ class ValveMenuStyle : { public: ValveMenuStyle(); - bool OnClientCommand(int client, const char *cmd); + bool OnClientCommand(int client, const char *cmdname, const CCommand &cmd); public: //BaseMenuStyle CBaseMenuPlayer *GetMenuPlayer(int client); void SendDisplay(int client, IMenuPanel *display); diff --git a/core/MenuVoting.cpp b/core/MenuVoting.cpp index 998051f7..d1f5d672 100644 --- a/core/MenuVoting.cpp +++ b/core/MenuVoting.cpp @@ -37,7 +37,11 @@ float g_next_vote = 0.0f; +#if defined ORANGEBOX_BUILD +void OnVoteDelayChange(IConVar *cvar, const char *value, float flOldValue); +#else void OnVoteDelayChange(ConVar *cvar, const char *value); +#endif ConVar sm_vote_delay("sm_vote_delay", "30", 0, @@ -48,7 +52,11 @@ ConVar sm_vote_delay("sm_vote_delay", 0.0, OnVoteDelayChange); +#if defined ORANGEBOX_BUILD +void OnVoteDelayChange(IConVar *cvar, const char *value, float flOldValue) +#else void OnVoteDelayChange(ConVar *cvar, const char *value) +#endif { /* See if the new vote delay isn't something we need to account for */ if (sm_vote_delay.GetFloat() < 1.0f) diff --git a/core/PlayerManager.cpp b/core/PlayerManager.cpp index bea79bc0..99fff178 100644 --- a/core/PlayerManager.cpp +++ b/core/PlayerManager.cpp @@ -54,7 +54,11 @@ const unsigned int *g_NumPlayersToAuth = NULL; SH_DECL_HOOK5(IServerGameClients, ClientConnect, SH_NOATTRIB, 0, bool, edict_t *, const char *, const char *, char *, int); SH_DECL_HOOK2_void(IServerGameClients, ClientPutInServer, SH_NOATTRIB, 0, edict_t *, const char *); SH_DECL_HOOK1_void(IServerGameClients, ClientDisconnect, SH_NOATTRIB, 0, edict_t *); +#if defined ORANGEBOX_BUILD +SH_DECL_HOOK2_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *, const CCommand &); +#else SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *); +#endif SH_DECL_HOOK1_void(IServerGameClients, ClientSettingsChanged, SH_NOATTRIB, 0, edict_t *); SH_DECL_HOOK3_void(IServerGameDLL, ServerActivate, SH_NOATTRIB, 0, edict_t *, int, int); @@ -565,8 +569,14 @@ void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity) } } +#if defined ORANGEBOX_BUILD +void PlayerManager::OnClientCommand(edict_t *pEntity, const CCommand &args) +{ +#else void PlayerManager::OnClientCommand(edict_t *pEntity) { + CCommand args; +#endif int client = engine->IndexOfEdict(pEntity); cell_t res = Pl_Continue; @@ -580,15 +590,15 @@ void PlayerManager::OnClientCommand(edict_t *pEntity) * We cache this because the engine is not re-entrant. */ char cmd[300]; - int args = engine->Cmd_Argc() - 1; - strncopy(cmd, engine->Cmd_Argv(0), sizeof(cmd)); + int argcount = args.ArgC() - 1; + strncopy(cmd, args.Arg(0), sizeof(cmd)); - bool result = g_ValveMenuStyle.OnClientCommand(client, cmd); + bool result = g_ValveMenuStyle.OnClientCommand(client, cmd, args); if (result) { res = Pl_Handled; } else { - result = g_RadioMenuStyle.OnClientCommand(client, cmd); + result = g_RadioMenuStyle.OnClientCommand(client, cmd, args); if (result) { res = Pl_Handled; @@ -597,7 +607,7 @@ void PlayerManager::OnClientCommand(edict_t *pEntity) cell_t res2 = Pl_Continue; m_clcommand->PushCell(client); - m_clcommand->PushCell(args); + m_clcommand->PushCell(argcount); m_clcommand->Execute(&res2, NULL); if (res2 > res) @@ -610,7 +620,7 @@ void PlayerManager::OnClientCommand(edict_t *pEntity) RETURN_META(MRES_SUPERCEDE); } - res = g_ConCmds.DispatchClientCommand(client, cmd, args, (ResultType)res); + res = g_ConCmds.DispatchClientCommand(client, cmd, argcount, (ResultType)res); if (res >= Pl_Handled) { diff --git a/core/PlayerManager.h b/core/PlayerManager.h index 76e504f2..d44b5c9c 100644 --- a/core/PlayerManager.h +++ b/core/PlayerManager.h @@ -122,7 +122,11 @@ public: void OnClientPutInServer(edict_t *pEntity, char const *playername); void OnClientDisconnect(edict_t *pEntity); void OnClientDisconnect_Post(edict_t *pEntity); +#if defined ORANGEBOX_BUILD + void OnClientCommand(edict_t *pEntity, const CCommand &args); +#else void OnClientCommand(edict_t *pEntity); +#endif void OnClientSettingsChanged(edict_t *pEntity); //void OnClientSettingsChanged_Pre(edict_t *pEntity); public: //IPlayerManager diff --git a/core/TimerSys.cpp b/core/TimerSys.cpp index 806a307b..99e7b4d0 100644 --- a/core/TimerSys.cpp +++ b/core/TimerSys.cpp @@ -35,7 +35,15 @@ #include "sourcemm_api.h" #include "frame_hooks.h" -SH_DECL_HOOK2_void(ICvar, CallGlobalChangeCallback, SH_NOATTRIB, false, ConVar *, const char *); +#if !defined ORANGEBOX_BUILD +#define CallGlobalChangeCallbacks CallGlobalChangeCallback +#endif + +#if defined ORANGEBOX_BUILD +SH_DECL_HOOK3_void(ICvar, CallGlobalChangeCallbacks, SH_NOATTRIB, false, ConVar *, const char *, float); +#else +SH_DECL_HOOK2_void(ICvar, CallGlobalChangeCallbacks, SH_NOATTRIB, false, ConVar *, const char *); +#endif TimerSystem g_Timers; float g_fUniversalTime = 0.0f; @@ -107,7 +115,11 @@ public: mp_timelimit->SetValue(mp_timelimit->GetInt() + extra_time); } +#if defined ORANGEBOX_BUILD + void GlobalChangeCallback(ConVar *pVar, const char *old_value, float flOldValue) +#else void GlobalChangeCallback(ConVar *pVar, const char *old_value) +#endif { if (pVar != mp_timelimit) { @@ -125,12 +137,12 @@ public: private: void Enable() { - SH_ADD_HOOK_MEMFUNC(ICvar, CallGlobalChangeCallback, icvar, this, &DefaultMapTimer::GlobalChangeCallback, false); + SH_ADD_HOOK_MEMFUNC(ICvar, CallGlobalChangeCallbacks, icvar, this, &DefaultMapTimer::GlobalChangeCallback, false); } void Disable() { - SH_REMOVE_HOOK_MEMFUNC(ICvar, CallGlobalChangeCallback, icvar, this, &DefaultMapTimer::GlobalChangeCallback, false); + SH_REMOVE_HOOK_MEMFUNC(ICvar, CallGlobalChangeCallbacks, icvar, this, &DefaultMapTimer::GlobalChangeCallback, false); } private: diff --git a/core/bitbuf.cpp b/core/bitbuf.cpp new file mode 100644 index 00000000..23c0040e --- /dev/null +++ b/core/bitbuf.cpp @@ -0,0 +1,961 @@ +//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#include "bitbuf.h" +#include "coordsize.h" +#include "vector.h" +#include "mathlib/math_base.h" +#include "vstdlib/strtools.h" + + +// FIXME: Can't use this until we get multithreaded allocations in tier0 working for tools +// This is used by VVIS and fails to link +// NOTE: This must be the last file included!!! +//#include "tier0/memdbgon.h" + +#ifdef _XBOX +// mandatory ... wary of above comment and isolating, tier0 is built as MT though +#include "tier0/memdbgon.h" +#endif + +static BitBufErrorHandler g_BitBufErrorHandler = 0; + + +void InternalBitBufErrorHandler( BitBufErrorType errorType, const char *pDebugName ) +{ + if ( g_BitBufErrorHandler ) + g_BitBufErrorHandler( errorType, pDebugName ); +} + + +void SetBitBufErrorHandler( BitBufErrorHandler fn ) +{ + g_BitBufErrorHandler = fn; +} + + +// #define BB_PROFILING + + +// Precalculated bit masks for WriteUBitLong. Using these tables instead of +// doing the calculations gives a 33% speedup in WriteUBitLong. +unsigned long g_BitWriteMasks[32][33]; + +// (1 << i) - 1 +unsigned long g_ExtraMasks[32]; + +class CBitWriteMasksInit +{ +public: + CBitWriteMasksInit() + { + for( unsigned int startbit=0; startbit < 32; startbit++ ) + { + for( unsigned int nBitsLeft=0; nBitsLeft < 33; nBitsLeft++ ) + { + unsigned int endbit = startbit + nBitsLeft; + g_BitWriteMasks[startbit][nBitsLeft] = (1 << startbit) - 1; + if(endbit < 32) + g_BitWriteMasks[startbit][nBitsLeft] |= ~((1 << endbit) - 1); + } + } + + for ( unsigned int maskBit=0; maskBit < 32; maskBit++ ) + g_ExtraMasks[maskBit] = (1 << maskBit) - 1; + } +}; +CBitWriteMasksInit g_BitWriteMasksInit; + + +// ---------------------------------------------------------------------------------------- // +// bf_write +// ---------------------------------------------------------------------------------------- // + +bf_write::bf_write() +{ + m_pData = NULL; + m_nDataBytes = 0; + m_nDataBits = -1; // set to -1 so we generate overflow on any operation + m_iCurBit = 0; + m_bOverflow = false; + m_bAssertOnOverflow = true; + m_pDebugName = NULL; +} + +bf_write::bf_write( const char *pDebugName, void *pData, int nBytes, int nBits ) +{ + m_bAssertOnOverflow = true; + m_pDebugName = pDebugName; + StartWriting( pData, nBytes, 0, nBits ); +} + +bf_write::bf_write( void *pData, int nBytes, int nBits ) +{ + m_bAssertOnOverflow = true; + StartWriting( pData, nBytes, 0, nBits ); +} + +void bf_write::StartWriting( void *pData, int nBytes, int iStartBit, int nBits ) +{ + // Make sure it's dword aligned and padded. + Assert( (nBytes % 4) == 0 ); + Assert(((unsigned long)pData & 3) == 0); + + m_pData = (unsigned char*)pData; + m_nDataBytes = nBytes; + + if ( nBits == -1 ) + { + m_nDataBits = nBytes << 3; + } + else + { + Assert( nBits <= nBytes*8 ); + m_nDataBits = nBits; + } + + m_iCurBit = iStartBit; + m_bOverflow = false; +} + +void bf_write::Reset() +{ + m_iCurBit = 0; + m_bOverflow = false; +} + + +void bf_write::SetAssertOnOverflow( bool bAssert ) +{ + m_bAssertOnOverflow = bAssert; +} + + +const char* bf_write::GetDebugName() +{ + return m_pDebugName; +} + + +void bf_write::SetDebugName( const char *pDebugName ) +{ + m_pDebugName = pDebugName; +} + + +void bf_write::SeekToBit( int bitPos ) +{ + m_iCurBit = bitPos; +} + + +// Sign bit comes first +void bf_write::WriteSBitLong( int data, int numbits ) +{ + // Do we have a valid # of bits to encode with? + Assert( numbits >= 1 ); + + // Note: it does this wierdness here so it's bit-compatible with regular integer data in the buffer. + // (Some old code writes direct integers right into the buffer). + if(data < 0) + { +#ifdef _DEBUG + if( numbits < 32 ) + { + // Make sure it doesn't overflow. + + if( data < 0 ) + { + Assert( data >= -(1 << (numbits-1)) ); + } + else + { + Assert( data < (1 << (numbits-1)) ); + } + } +#endif + + WriteUBitLong( (unsigned int)(0x80000000 + data), numbits - 1, false ); + WriteOneBit( 1 ); + } + else + { + WriteUBitLong((unsigned int)data, numbits - 1); + WriteOneBit( 0 ); + } +} + +// writes an unsigned integer with variable bit length +void bf_write::WriteUBitVar( unsigned int data ) +{ + unsigned int bits = 0; + unsigned int base = 0; + + while (data > (base<<1)) + { + bits++; + base = (1< 0) + WriteUBitLong( 0, bits ); + + // end marker + WriteOneBit( 1 ); + + // write the value + if ( bits > 0) + WriteUBitLong( data - base , bits ); +} + +void bf_write::WriteBitLong(unsigned int data, int numbits, bool bSigned) +{ + if(bSigned) + WriteSBitLong((int)data, numbits); + else + WriteUBitLong(data, numbits); +} + +bool bf_write::WriteBits(const void *pInData, int nBits) +{ +#if defined( BB_PROFILING ) + VPROF( "bf_write::WriteBits" ); +#endif + + unsigned char *pOut = (unsigned char*)pInData; + int nBitsLeft = nBits; + + if((m_iCurBit+nBits) > m_nDataBits) + { + SetOverflowFlag(); + CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() ); + return false; + } + + // Get output dword-aligned. + while(((unsigned long)pOut & 3) != 0 && nBitsLeft >= 8) + { + + WriteUBitLong( *pOut, 8, false ); + ++pOut; + nBitsLeft -= 8; + } + + // check if we can use fast memcpy if m_iCurBit is byte aligned + if ( (nBitsLeft >= 32) && (m_iCurBit & 7) == 0 ) + { + int numbytes = (nBitsLeft >> 3); + int numbits = numbytes << 3; + + // Bounds checking.. + // TODO: May not need this check anymore + if((m_iCurBit+numbits) > m_nDataBits) + { + m_iCurBit = m_nDataBits; + SetOverflowFlag(); + CallErrorHandler( BITBUFERROR_BUFFER_OVERRUN, GetDebugName() ); + return false; + } + + Q_memcpy( m_pData+(m_iCurBit>>3), pOut, numbytes ); + pOut += numbytes; + nBitsLeft -= numbits; + m_iCurBit += numbits; + } + + // Read dwords. + while(nBitsLeft >= 32) + { + WriteUBitLong( *((unsigned long*)pOut), 32, false ); + pOut += sizeof(unsigned long); + nBitsLeft -= 32; + } + + // Read the remaining bytes. + while(nBitsLeft >= 8) + { + WriteUBitLong( *pOut, 8, false ); + ++pOut; + nBitsLeft -= 8; + } + + // Read the remaining bits. + if(nBitsLeft) + { + WriteUBitLong( *pOut, nBitsLeft, false ); + } + + return !IsOverflowed(); +} + + +bool bf_write::WriteBitsFromBuffer( bf_read *pIn, int nBits ) +{ + // This could be optimized a little by + while ( nBits > 32 ) + { + WriteUBitLong( pIn->ReadUBitLong( 32 ), 32 ); + nBits -= 32; + } + + WriteUBitLong( pIn->ReadUBitLong( nBits ), nBits ); + return !IsOverflowed() && !pIn->IsOverflowed(); +} + + +void bf_write::WriteBitAngle( float fAngle, int numbits ) +{ + int d; + unsigned int mask; + unsigned int shift; + + shift = (1<(f)); + int fractval = abs((int)(f*COORD_DENOMINATOR)) & (COORD_DENOMINATOR-1); + + + // Send the bit flags that indicate whether we have an integer part and/or a fraction part. + WriteOneBit( intval ); + WriteOneBit( fractval ); + + if ( intval || fractval ) + { + // Send the sign bit + WriteOneBit( signbit ); + + // Send the integer if we have one. + if ( intval ) + { + // Adjust the integers from [1..MAX_COORD_VALUE] to [0..MAX_COORD_VALUE-1] + intval--; + WriteUBitLong( (unsigned int)intval, COORD_INTEGER_BITS ); + } + + // Send the fraction if we have one + if ( fractval ) + { + WriteUBitLong( (unsigned int)fractval, COORD_FRACTIONAL_BITS ); + } + } +} + +void bf_write::WriteBitFloat(float val) +{ + long intVal; + + Assert(sizeof(long) == sizeof(float)); + Assert(sizeof(float) == 4); + + void *v = &val; + intVal = *reinterpret_cast(v); + WriteUBitLong( intVal, 32 ); +} + +void bf_write::WriteBitVec3Coord( const Vector& fa ) +{ + int xflag, yflag, zflag; + + xflag = (fa[0] >= COORD_RESOLUTION) || (fa[0] <= -COORD_RESOLUTION); + yflag = (fa[1] >= COORD_RESOLUTION) || (fa[1] <= -COORD_RESOLUTION); + zflag = (fa[2] >= COORD_RESOLUTION) || (fa[2] <= -COORD_RESOLUTION); + + WriteOneBit( xflag ); + WriteOneBit( yflag ); + WriteOneBit( zflag ); + + if ( xflag ) + WriteBitCoord( fa[0] ); + if ( yflag ) + WriteBitCoord( fa[1] ); + if ( zflag ) + WriteBitCoord( fa[2] ); +} + +void bf_write::WriteBitNormal( float f ) +{ + int signbit = (f <= -NORMAL_RESOLUTION); + + // NOTE: Since +/-1 are valid values for a normal, I'm going to encode that as all ones + unsigned int fractval = abs( (int)(f*NORMAL_DENOMINATOR) ); + + // clamp.. + if (fractval > NORMAL_DENOMINATOR) + fractval = NORMAL_DENOMINATOR; + + // Send the sign bit + WriteOneBit( signbit ); + + // Send the fractional component + WriteUBitLong( fractval, NORMAL_FRACTIONAL_BITS ); +} + +void bf_write::WriteBitVec3Normal( const Vector& fa ) +{ + int xflag, yflag; + + xflag = (fa[0] >= NORMAL_RESOLUTION) || (fa[0] <= -NORMAL_RESOLUTION); + yflag = (fa[1] >= NORMAL_RESOLUTION) || (fa[1] <= -NORMAL_RESOLUTION); + + WriteOneBit( xflag ); + WriteOneBit( yflag ); + + if ( xflag ) + WriteBitNormal( fa[0] ); + if ( yflag ) + WriteBitNormal( fa[1] ); + + // Write z sign bit + int signbit = (fa[2] <= -NORMAL_RESOLUTION); + WriteOneBit( signbit ); +} + +void bf_write::WriteBitAngles( const QAngle& fa ) +{ + // FIXME: + Vector tmp( fa.x, fa.y, fa.z ); + WriteBitVec3Coord( tmp ); +} + +void bf_write::WriteChar(int val) +{ + WriteSBitLong(val, sizeof(char) << 3); +} + +void bf_write::WriteByte(int val) +{ + WriteUBitLong(val, sizeof(unsigned char) << 3); +} + +void bf_write::WriteShort(int val) +{ + WriteSBitLong(val, sizeof(short) << 3); +} + +void bf_write::WriteWord(int val) +{ + WriteUBitLong(val, sizeof(unsigned short) << 3); +} + +void bf_write::WriteLong(long val) +{ + WriteSBitLong(val, sizeof(long) << 3); +} + +void bf_write::WriteFloat(float val) +{ + WriteBits(&val, sizeof(val) << 3); +} + +bool bf_write::WriteBytes( const void *pBuf, int nBytes ) +{ + return WriteBits(pBuf, nBytes << 3); +} + +bool bf_write::WriteString(const char *pStr) +{ + if(pStr) + { + do + { + WriteChar( *pStr ); + ++pStr; + } while( *(pStr-1) != 0 ); + } + else + { + WriteChar( 0 ); + } + + return !IsOverflowed(); +} + +// ---------------------------------------------------------------------------------------- // +// bf_read +// ---------------------------------------------------------------------------------------- // + +bf_read::bf_read() +{ + m_pData = NULL; + m_nDataBytes = 0; + m_nDataBits = -1; // set to -1 so we overflow on any operation + m_iCurBit = 0; + m_bOverflow = false; + m_bAssertOnOverflow = true; + m_pDebugName = NULL; +} + +bf_read::bf_read( const void *pData, int nBytes, int nBits ) +{ + m_bAssertOnOverflow = true; + StartReading( pData, nBytes, 0, nBits ); +} + +bf_read::bf_read( const char *pDebugName, const void *pData, int nBytes, int nBits ) +{ + m_bAssertOnOverflow = true; + m_pDebugName = pDebugName; + StartReading( pData, nBytes, 0, nBits ); +} + +void bf_read::StartReading( const void *pData, int nBytes, int iStartBit, int nBits ) +{ + // Make sure we're dword aligned. + Assert(((unsigned long)pData & 3) == 0); + + m_pData = (unsigned char*)pData; + m_nDataBytes = nBytes; + + if ( nBits == -1 ) + { + m_nDataBits = m_nDataBytes << 3; + } + else + { + Assert( nBits <= nBytes*8 ); + m_nDataBits = nBits; + } + + m_iCurBit = iStartBit; + m_bOverflow = false; +} + +void bf_read::Reset() +{ + m_iCurBit = 0; + m_bOverflow = false; +} + +void bf_read::SetAssertOnOverflow( bool bAssert ) +{ + m_bAssertOnOverflow = bAssert; +} + +const char* bf_read::GetDebugName() +{ + return m_pDebugName; +} + +void bf_read::SetDebugName( const char *pName ) +{ + m_pDebugName = pName; +} + +unsigned int bf_read::CheckReadUBitLong(int numbits) +{ + // Ok, just read bits out. + int i, nBitValue; + unsigned int r = 0; + + for(i=0; i < numbits; i++) + { + nBitValue = ReadOneBitNoCheck(); + r |= nBitValue << i; + } + m_iCurBit -= numbits; + + return r; +} + +bool bf_read::ReadBits(void *pOutData, int nBits) +{ +#if defined( BB_PROFILING ) + VPROF( "bf_write::ReadBits" ); +#endif + + unsigned char *pOut = (unsigned char*)pOutData; + int nBitsLeft = nBits; + + + // Get output dword-aligned. + while(((unsigned long)pOut & 3) != 0 && nBitsLeft >= 8) + { + *pOut = (unsigned char)ReadUBitLong(8); + ++pOut; + nBitsLeft -= 8; + } + + // Read dwords. + while(nBitsLeft >= 32) + { + *((unsigned long*)pOut) = ReadUBitLong(32); + pOut += sizeof(unsigned long); + nBitsLeft -= 32; + } + + // Read the remaining bytes. + while(nBitsLeft >= 8) + { + *pOut = ReadUBitLong(8); + ++pOut; + nBitsLeft -= 8; + } + + // Read the remaining bits. + if(nBitsLeft) + { + *pOut = ReadUBitLong(nBitsLeft); + } + + return !IsOverflowed(); +} + +float bf_read::ReadBitAngle( int numbits ) +{ + float fReturn; + int i; + float shift; + + shift = (float)( 1 << numbits ); + + i = ReadUBitLong( numbits ); + fReturn = (float)i * (360.0 / shift); + + return fReturn; +} + +unsigned int bf_read::PeekUBitLong( int numbits ) +{ + unsigned int r; + int i, nBitValue; +#ifdef BIT_VERBOSE + int nShifts = numbits; +#endif + + bf_read savebf; + + savebf = *this; // Save current state info + + r = 0; + for(i=0; i < numbits; i++) + { + nBitValue = ReadOneBit(); + + // Append to current stream + if ( nBitValue ) + { + r |= 1 << i; + } + } + + *this = savebf; + +#ifdef BIT_VERBOSE + Con_Printf( "PeekBitLong: %i %i\n", nShifts, (unsigned int)r ); +#endif + + return r; +} + +// Append numbits least significant bits from data to the current bit stream +int bf_read::ReadSBitLong( int numbits ) +{ + int r, sign; + + r = ReadUBitLong(numbits - 1); + + // Note: it does this wierdness here so it's bit-compatible with regular integer data in the buffer. + // (Some old code writes direct integers right into the buffer). + sign = ReadOneBit(); + if(sign) + r = -((1 << (numbits-1)) - r); + + return r; +} + +unsigned int bf_read::ReadUBitVar() +{ + int bits = 0; // how many bits are used to encode delta offset + + // how many bits do we use + while ( ReadOneBit() == 0 ) + bits++; + + unsigned int data = (1< 0) + data += ReadUBitLong( bits ); + + return data; +} + + +unsigned int bf_read::ReadBitLong(int numbits, bool bSigned) +{ + if(bSigned) + return (unsigned int)ReadSBitLong(numbits); + else + return ReadUBitLong(numbits); +} + + +// Basic Coordinate Routines (these contain bit-field size AND fixed point scaling constants) +float bf_read::ReadBitCoord (void) +{ +#if defined( BB_PROFILING ) + VPROF( "bf_write::ReadBitCoord" ); +#endif + int intval=0,fractval=0,signbit=0; + float value = 0.0; + + + // Read the required integer and fraction flags + intval = ReadOneBit(); + fractval = ReadOneBit(); + + // If we got either parse them, otherwise it's a zero. + if ( intval || fractval ) + { + // Read the sign bit + signbit = ReadOneBit(); + + // If there's an integer, read it in + if ( intval ) + { + // Adjust the integers from [0..MAX_COORD_VALUE-1] to [1..MAX_COORD_VALUE] + intval = ReadUBitLong( COORD_INTEGER_BITS ) + 1; + } + + // If there's a fraction, read it in + if ( fractval ) + { + fractval = ReadUBitLong( COORD_FRACTIONAL_BITS ); + } + + // Calculate the correct floating point value + value = intval + ((float)fractval * COORD_RESOLUTION); + + // Fixup the sign if negative. + if ( signbit ) + value = -value; + } + + return value; +} + +void bf_read::ReadBitVec3Coord( Vector& fa ) +{ + int xflag, yflag, zflag; + + // This vector must be initialized! Otherwise, If any of the flags aren't set, + // the corresponding component will not be read and will be stack garbage. + fa.Init( 0, 0, 0 ); + + xflag = ReadOneBit(); + yflag = ReadOneBit(); + zflag = ReadOneBit(); + + if ( xflag ) + fa[0] = ReadBitCoord(); + if ( yflag ) + fa[1] = ReadBitCoord(); + if ( zflag ) + fa[2] = ReadBitCoord(); +} + +float bf_read::ReadBitNormal (void) +{ + // Read the sign bit + int signbit = ReadOneBit(); + + // Read the fractional part + unsigned int fractval = ReadUBitLong( NORMAL_FRACTIONAL_BITS ); + + // Calculate the correct floating point value + float value = (float)fractval * NORMAL_RESOLUTION; + + // Fixup the sign if negative. + if ( signbit ) + value = -value; + + return value; +} + +void bf_read::ReadBitVec3Normal( Vector& fa ) +{ + int xflag = ReadOneBit(); + int yflag = ReadOneBit(); + + if (xflag) + fa[0] = ReadBitNormal(); + else + fa[0] = 0.0f; + + if (yflag) + fa[1] = ReadBitNormal(); + else + fa[1] = 0.0f; + + // The first two imply the third (but not its sign) + int znegative = ReadOneBit(); + + float fafafbfb = fa[0] * fa[0] + fa[1] * fa[1]; + if (fafafbfb < 1.0f) + fa[2] = sqrt( 1.0f - fafafbfb ); + else + fa[2] = 0.0f; + + if (znegative) + fa[2] = -fa[2]; +} + +void bf_read::ReadBitAngles( QAngle& fa ) +{ + Vector tmp; + ReadBitVec3Coord( tmp ); + fa.Init( tmp.x, tmp.y, tmp.z ); +} + +int bf_read::ReadChar() +{ + return ReadSBitLong(sizeof(char) << 3); +} + +int bf_read::ReadByte() +{ + return ReadUBitLong(sizeof(unsigned char) << 3); +} + +int bf_read::ReadShort() +{ + return ReadSBitLong(sizeof(short) << 3); +} + +int bf_read::ReadWord() +{ + return ReadUBitLong(sizeof(unsigned short) << 3); +} + +long bf_read::ReadLong() +{ + return ReadSBitLong(sizeof(long) << 3); +} + +float bf_read::ReadFloat() +{ + float ret; + Assert( sizeof(ret) == 4 ); + ReadBits(&ret, 32); + return ret; +} + +bool bf_read::ReadBytes(void *pOut, int nBytes) +{ + return ReadBits(pOut, nBytes << 3); +} + +bool bf_read::ReadString( char *pStr, int maxLen, bool bLine, int *pOutNumChars ) +{ + Assert( maxLen != 0 ); + + bool bTooSmall = false; + int iChar = 0; + while(1) + { + char val = ReadChar(); + if ( val == 0 ) + break; + else if ( bLine && val == '\n' ) + break; + + if ( iChar < (maxLen-1) ) + { + pStr[iChar] = val; + ++iChar; + } + else + { + bTooSmall = true; + } + } + + // Make sure it's null-terminated. + Assert( iChar < maxLen ); + pStr[iChar] = 0; + + if ( pOutNumChars ) + *pOutNumChars = iChar; + + return !IsOverflowed() && !bTooSmall; +} + + +char* bf_read::ReadAndAllocateString( bool *pOverflow ) +{ + char str[2048]; + + int nChars; + bool bOverflow = !ReadString( str, sizeof( str ), false, &nChars ); + if ( pOverflow ) + *pOverflow = bOverflow; + + // Now copy into the output and return it; + char *pRet = new char[ nChars + 1 ]; + for ( int i=0; i <= nChars; i++ ) + pRet[i] = str[i]; + + return pRet; +} + + +bool bf_read::Seek(int iBit) +{ + if(iBit < 0) + { + SetOverflowFlag(); + m_iCurBit = m_nDataBits; + return false; + } + else if(iBit > m_nDataBits) + { + SetOverflowFlag(); + m_iCurBit = m_nDataBits; + return false; + } + else + { + m_iCurBit = iBit; + return true; + } +} + +void bf_read::ExciseBits( int startbit, int bitstoremove ) +{ + int endbit = startbit + bitstoremove; + int remaining_to_end = m_nDataBits - endbit; + + bf_write temp; + temp.StartWriting( (void *)m_pData, m_nDataBits << 3, startbit ); + + Seek( endbit ); + + for ( int i = 0; i < remaining_to_end; i++ ) + { + temp.WriteOneBit( ReadOneBit() ); + } + + Seek( startbit ); + + m_nDataBits -= bitstoremove; + m_nDataBytes = m_nDataBits >> 3; +} diff --git a/core/convar_sm_ob.h b/core/convar_sm_ob.h new file mode 100644 index 00000000..b4d27792 --- /dev/null +++ b/core/convar_sm_ob.h @@ -0,0 +1,709 @@ +//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======// +// +// Purpose: +// +// $Workfile: $ +// $Date: $ +// +//----------------------------------------------------------------------------- +// $NoKeywords: $ +//===========================================================================// + +#ifndef CONVAR_H +#define CONVAR_H + +#if _WIN32 +#pragma once +#endif + +#include "tier0/dbg.h" +#include "tier1/iconvar.h" +#include "tier1/utlvector.h" +#include "tier1/utlstring.h" +#include "icvar.h" + +#ifdef _WIN32 +#define FORCEINLINE_CVAR FORCEINLINE +#elif _LINUX +#define FORCEINLINE_CVAR inline +#else +#error "implement me" +#endif + + +//----------------------------------------------------------------------------- +// Forward declarations +//----------------------------------------------------------------------------- +class ConVar; +class CCommand; +class ConCommand; +class ConCommandBase; +struct characterset_t; + + + +//----------------------------------------------------------------------------- +// Any executable that wants to use ConVars need to implement one of +// these to hook up access to console variables. +//----------------------------------------------------------------------------- +class IConCommandBaseAccessor +{ +public: + // Flags is a combination of FCVAR flags in cvar.h. + // hOut is filled in with a handle to the variable. + virtual bool RegisterConCommandBase( ConCommandBase *pVar ) = 0; +}; + + +//----------------------------------------------------------------------------- +// Helper method for console development +//----------------------------------------------------------------------------- +#if defined( _X360 ) && !defined( _RETAIL ) +void ConVar_PublishToVXConsole(); +#endif + + +//----------------------------------------------------------------------------- +// Called when a ConCommand needs to execute +//----------------------------------------------------------------------------- +typedef void ( *FnCommandCallbackV1_t )( void ); +typedef void ( *FnCommandCallback_t )( const CCommand &command ); + +#define COMMAND_COMPLETION_MAXITEMS 64 +#define COMMAND_COMPLETION_ITEM_LENGTH 64 + +//----------------------------------------------------------------------------- +// Returns 0 to COMMAND_COMPLETION_MAXITEMS worth of completion strings +//----------------------------------------------------------------------------- +typedef int ( *FnCommandCompletionCallback )( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] ); + + +//----------------------------------------------------------------------------- +// Interface version +//----------------------------------------------------------------------------- +class ICommandCallback +{ +public: + virtual void CommandCallback( const CCommand &command ) = 0; +}; + +class ICommandCompletionCallback +{ +public: + virtual int CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands ) = 0; +}; + +//----------------------------------------------------------------------------- +// Purpose: The base console invoked command/cvar interface +//----------------------------------------------------------------------------- +class ConCommandBase +{ + friend class CCvar; + friend class ConVar; + friend class ConCommand; + friend void ConVar_Register( int nCVarFlag, IConCommandBaseAccessor *pAccessor ); + friend void ConVar_PublishToVXConsole(); + + // FIXME: Remove when ConVar changes are done + friend class CDefaultCvar; + +public: + ConCommandBase( void ); + ConCommandBase( const char *pName, const char *pHelpString = 0, + int flags = 0 ); + + virtual ~ConCommandBase( void ); + + virtual bool IsCommand( void ) const; + + // Check flag + virtual bool IsFlagSet( int flag ) const; + // Set flag + virtual void AddFlags( int flags ); + + // Return name of cvar + virtual const char *GetName( void ) const; + + // Return help text for cvar + virtual const char *GetHelpText( void ) const; + + // Deal with next pointer + const ConCommandBase *GetNext( void ) const; + ConCommandBase *GetNext( void ); + + void SetNext(ConCommandBase *pBase) + { + m_pNext = pBase; + } + + virtual bool IsRegistered( void ) const; + + // Returns the DLL identifier + virtual CVarDLLIdentifier_t GetDLLIdentifier() const; + +protected: + virtual void Create( const char *pName, const char *pHelpString = 0, + int flags = 0 ); + + // Used internally by OneTimeInit to initialize/shutdown + virtual void Init(); + void Shutdown(); + + // Internal copy routine ( uses new operator from correct module ) + char *CopyString( const char *from ); + +private: + // Next ConVar in chain + // Prior to register, it points to the next convar in the DLL. + // Once registered, though, m_pNext is reset to point to the next + // convar in the global list + ConCommandBase *m_pNext; + + // Has the cvar been added to the global list? + bool m_bRegistered; + + // Static data + const char *m_pszName; + const char *m_pszHelpString; + + // ConVar flags + int m_nFlags; + +protected: + // ConVars add themselves to this list for the executable. + // Then ConVar_Register runs through all the console variables + // and registers them into a global list stored in vstdlib.dll + static ConCommandBase *s_pConCommandBases; + + // ConVars in this executable use this 'global' to access values. + static IConCommandBaseAccessor *s_pAccessor; +public: // Hackalicous + inline int GetFlags() const + { + return m_nFlags; + } + inline void SetFlags(int flags) + { + m_nFlags = flags; + } +}; + + +//----------------------------------------------------------------------------- +// Command tokenizer +//----------------------------------------------------------------------------- +class CCommand +{ +public: + CCommand(); + CCommand( int nArgC, const char **ppArgV ); + bool Tokenize( const char *pCommand, characterset_t *pBreakSet = NULL ); + void Reset(); + + int ArgC() const; + const char **ArgV() const; + const char *ArgS() const; // All args that occur after the 0th arg, in string form + const char *GetCommandString() const; // The entire command in string form, including the 0th arg + const char *operator[]( int nIndex ) const; // Gets at arguments + const char *Arg( int nIndex ) const; // Gets at arguments + + // Helper functions to parse arguments to commands. + const char* FindArg( const char *pName ) const; + int FindArgInt( const char *pName, int nDefaultVal ) const; + + static int MaxCommandLength(); + static characterset_t* DefaultBreakSet(); + +private: + enum + { + COMMAND_MAX_ARGC = 64, + COMMAND_MAX_LENGTH = 512, + }; + + int m_nArgc; + int m_nArgv0Size; + char m_pArgSBuffer[ COMMAND_MAX_LENGTH ]; + char m_pArgvBuffer[ COMMAND_MAX_LENGTH ]; + const char* m_ppArgv[ COMMAND_MAX_ARGC ]; +}; + +inline int CCommand::MaxCommandLength() +{ + return COMMAND_MAX_LENGTH - 1; +} + +inline int CCommand::ArgC() const +{ + return m_nArgc; +} + +inline const char **CCommand::ArgV() const +{ + return m_nArgc ? (const char**)m_ppArgv : NULL; +} + +inline const char *CCommand::ArgS() const +{ + return m_nArgv0Size ? &m_pArgSBuffer[m_nArgv0Size] : ""; +} + +inline const char *CCommand::GetCommandString() const +{ + return m_nArgc ? m_pArgSBuffer : ""; +} + +inline const char *CCommand::Arg( int nIndex ) const +{ + // FIXME: Many command handlers appear to not be particularly careful + // about checking for valid argc range. For now, we're going to + // do the extra check and return an empty string if it's out of range + if ( nIndex < 0 || nIndex >= m_nArgc ) + return ""; + return m_ppArgv[nIndex]; +} + +inline const char *CCommand::operator[]( int nIndex ) const +{ + return Arg( nIndex ); +} + + +//----------------------------------------------------------------------------- +// Purpose: The console invoked command +//----------------------------------------------------------------------------- +class ConCommand : public ConCommandBase +{ +friend class CCvar; + +public: + typedef ConCommandBase BaseClass; + + ConCommand( const char *pName, FnCommandCallbackV1_t callback, + const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 ); + ConCommand( const char *pName, FnCommandCallback_t callback, + const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 ); + ConCommand( const char *pName, ICommandCallback *pCallback, + const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 ); + + virtual ~ConCommand( void ); + + virtual bool IsCommand( void ) const; + + virtual int AutoCompleteSuggest( const char *partial, CUtlVector< CUtlString > &commands ); + + virtual bool CanAutoComplete( void ); + + // Invoke the function + virtual void Dispatch( const CCommand &command ); + +private: + // NOTE: To maintain backward compat, we have to be very careful: + // All public virtual methods must appear in the same order always + // since engine code will be calling into this code, which *does not match* + // in the mod code; it's using slightly different, but compatible versions + // of this class. Also: Be very careful about adding new fields to this class. + // Those fields will not exist in the version of this class that is instanced + // in mod code. + + // Call this function when executing the command + union + { + FnCommandCallbackV1_t m_fnCommandCallbackV1; + FnCommandCallback_t m_fnCommandCallback; + ICommandCallback *m_pCommandCallback; + }; + + union + { + FnCommandCompletionCallback m_fnCompletionCallback; + ICommandCompletionCallback *m_pCommandCompletionCallback; + }; + + bool m_bHasCompletionCallback : 1; + bool m_bUsingNewCommandCallback : 1; + bool m_bUsingCommandCallbackInterface : 1; +public: // Hackalicous + inline FnCommandCallback_t GetCallback() const + { + return m_fnCommandCallback; + } +}; + + +//----------------------------------------------------------------------------- +// Purpose: A console variable +//----------------------------------------------------------------------------- +class ConVar : public ConCommandBase, public IConVar +{ +friend class CCvar; +friend class ConVarRef; + +public: + typedef ConCommandBase BaseClass; + + ConVar( const char *pName, const char *pDefaultValue, int flags = 0); + + ConVar( const char *pName, const char *pDefaultValue, int flags, + const char *pHelpString ); + ConVar( const char *pName, const char *pDefaultValue, int flags, + const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax ); + ConVar( const char *pName, const char *pDefaultValue, int flags, + const char *pHelpString, FnChangeCallback_t callback ); + ConVar( const char *pName, const char *pDefaultValue, int flags, + const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax, + FnChangeCallback_t callback ); + + virtual ~ConVar( void ); + + virtual bool IsFlagSet( int flag ) const; + virtual const char* GetHelpText( void ) const; + virtual bool IsRegistered( void ) const; + virtual const char *GetName( void ) const; + virtual void AddFlags( int flags ); + virtual bool IsCommand( void ) const; + + // Install a change callback (there shouldn't already be one....) + void InstallChangeCallback( FnChangeCallback_t callback ); + + // Retrieve value + FORCEINLINE_CVAR float GetFloat( void ) const; + FORCEINLINE_CVAR int GetInt( void ) const; + FORCEINLINE_CVAR bool GetBool() const { return !!GetInt(); } + FORCEINLINE_CVAR char const *GetString( void ) const; + + // Any function that allocates/frees memory needs to be virtual or else you'll have crashes + // from alloc/free across dll/exe boundaries. + + // These just call into the IConCommandBaseAccessor to check flags and set the var (which ends up calling InternalSetValue). + virtual void SetValue( const char *value ); + virtual void SetValue( float value ); + virtual void SetValue( int value ); + + // Reset to default value + void Revert( void ); + + // True if it has a min/max setting + bool GetMin( float& minVal ) const; + bool GetMax( float& maxVal ) const; + const char *GetDefault( void ) const; + +private: + // Called by CCvar when the value of a var is changing. + virtual void InternalSetValue(const char *value); + // For CVARs marked FCVAR_NEVER_AS_STRING + virtual void InternalSetFloatValue( float fNewValue ); + virtual void InternalSetIntValue( int nValue ); + + virtual bool ClampValue( float& value ); + virtual void ChangeStringValue( const char *tempVal, float flOldValue ); + + virtual void Create( const char *pName, const char *pDefaultValue, int flags = 0, + const char *pHelpString = 0, bool bMin = false, float fMin = 0.0, + bool bMax = false, float fMax = false, FnChangeCallback_t callback = 0 ); + + // Used internally by OneTimeInit to initialize. + virtual void Init(); + +private: + + // This either points to "this" or it points to the original declaration of a ConVar. + // This allows ConVars to exist in separate modules, and they all use the first one to be declared. + // m_pParent->m_pParent must equal m_pParent (ie: m_pParent must be the root, or original, ConVar). + ConVar *m_pParent; + + // Static data + const char *m_pszDefaultValue; + + // Value + // Dynamically allocated + char *m_pszString; + int m_StringLength; + + // Values + float m_fValue; + int m_nValue; + + // Min/Max values + bool m_bHasMin; + float m_fMinVal; + bool m_bHasMax; + float m_fMaxVal; + + // Call this function when ConVar changes + FnChangeCallback_t m_fnChangeCallback; +public: // Hackalicous + inline FnChangeCallback_t GetCallback() const + { + return m_fnChangeCallback; + } + inline void SetMin(bool set, float min=0.0) + { + m_bHasMin = set; + m_fMinVal = min; + } + inline void SetMax(bool set, float max=0.0) + { + m_bHasMax = set; + m_fMaxVal = max; + } +}; + + +//----------------------------------------------------------------------------- +// Purpose: Return ConVar value as a float +// Output : float +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR float ConVar::GetFloat( void ) const +{ + return m_pParent->m_fValue; +} + +//----------------------------------------------------------------------------- +// Purpose: Return ConVar value as an int +// Output : int +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR int ConVar::GetInt( void ) const +{ + return m_pParent->m_nValue; +} + + +//----------------------------------------------------------------------------- +// Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc. +// Output : const char * +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR const char *ConVar::GetString( void ) const +{ + if ( m_nFlags & FCVAR_NEVER_AS_STRING ) + return "FCVAR_NEVER_AS_STRING"; + + return ( m_pParent->m_pszString ) ? m_pParent->m_pszString : ""; +} + + +//----------------------------------------------------------------------------- +// Used to read/write convars that already exist (replaces the FindVar method) +//----------------------------------------------------------------------------- +class ConVarRef +{ +public: + ConVarRef( const char *pName ); + ConVarRef( const char *pName, bool bIgnoreMissing ); + ConVarRef( IConVar *pConVar ); + + void Init( const char *pName, bool bIgnoreMissing ); + bool IsValid() const; + bool IsFlagSet( int nFlags ) const; + IConVar *GetLinkedConVar(); + + // Get/Set value + float GetFloat( void ) const; + int GetInt( void ) const; + bool GetBool() const { return !!GetInt(); } + const char *GetString( void ) const; + + void SetValue( const char *pValue ); + void SetValue( float flValue ); + void SetValue( int nValue ); + void SetValue( bool bValue ); + + const char *GetName() const; + + const char *GetDefault() const; + +private: + // High-speed method to read convar data + IConVar *m_pConVar; + ConVar *m_pConVarState; +}; + + +//----------------------------------------------------------------------------- +// Did we find an existing convar of that name? +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR bool ConVarRef::IsFlagSet( int nFlags ) const +{ + return ( m_pConVar->IsFlagSet( nFlags ) != 0 ); +} + +FORCEINLINE_CVAR IConVar *ConVarRef::GetLinkedConVar() +{ + return m_pConVar; +} + +FORCEINLINE_CVAR const char *ConVarRef::GetName() const +{ + return m_pConVar->GetName(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Return ConVar value as a float +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR float ConVarRef::GetFloat( void ) const +{ + return m_pConVarState->m_fValue; +} + +//----------------------------------------------------------------------------- +// Purpose: Return ConVar value as an int +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR int ConVarRef::GetInt( void ) const +{ + return m_pConVarState->m_nValue; +} + +//----------------------------------------------------------------------------- +// Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc. +//----------------------------------------------------------------------------- +FORCEINLINE_CVAR const char *ConVarRef::GetString( void ) const +{ + Assert( !IsFlagSet( FCVAR_NEVER_AS_STRING ) ); + return m_pConVarState->m_pszString; +} + + +FORCEINLINE_CVAR void ConVarRef::SetValue( const char *pValue ) +{ + m_pConVar->SetValue( pValue ); +} + +FORCEINLINE_CVAR void ConVarRef::SetValue( float flValue ) +{ + m_pConVar->SetValue( flValue ); +} + +FORCEINLINE_CVAR void ConVarRef::SetValue( int nValue ) +{ + m_pConVar->SetValue( nValue ); +} + +FORCEINLINE_CVAR void ConVarRef::SetValue( bool bValue ) +{ + m_pConVar->SetValue( bValue ? 1 : 0 ); +} + +FORCEINLINE_CVAR const char *ConVarRef::GetDefault() const +{ + return m_pConVarState->m_pszDefaultValue; +} + + +//----------------------------------------------------------------------------- +// Called by the framework to register ConCommands with the ICVar +//----------------------------------------------------------------------------- +void ConVar_Register( int nCVarFlag = 0, IConCommandBaseAccessor *pAccessor = NULL ); +void ConVar_Unregister( ); + + +//----------------------------------------------------------------------------- +// Utility methods +//----------------------------------------------------------------------------- +void ConVar_PrintFlags( const ConCommandBase *var ); +void ConVar_PrintDescription( const ConCommandBase *pVar ); + + +//----------------------------------------------------------------------------- +// Purpose: Utility class to quickly allow ConCommands to call member methods +//----------------------------------------------------------------------------- +#if defined _MSC_VER +#pragma warning (disable : 4355 ) +#endif + +template< class T > +class CConCommandMemberAccessor : public ConCommand, public ICommandCallback, public ICommandCompletionCallback +{ + typedef ConCommand BaseClass; + typedef void ( T::*FnMemberCommandCallback_t )( const CCommand &command ); + typedef int ( T::*FnMemberCommandCompletionCallback_t )( const char *pPartial, CUtlVector< CUtlString > &commands ); + +public: + CConCommandMemberAccessor( T* pOwner, const char *pName, FnMemberCommandCallback_t callback, const char *pHelpString = 0, + int flags = 0, FnMemberCommandCompletionCallback_t completionFunc = 0 ) : + BaseClass( pName, this, pHelpString, flags, ( completionFunc != 0 ) ? this : NULL ) + { + m_pOwner = pOwner; + m_Func = callback; + m_CompletionFunc = completionFunc; + } + + ~CConCommandMemberAccessor() + { + Shutdown(); + } + + void SetOwner( T* pOwner ) + { + m_pOwner = pOwner; + } + + virtual void CommandCallback( const CCommand &command ) + { + Assert( m_pOwner && m_Func ); + (m_pOwner->*m_Func)( command ); + } + + virtual int CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands ) + { + Assert( m_pOwner && m_CompletionFunc ); + return (m_pOwner->*m_CompletionFunc)( pPartial, commands ); + } + +private: + T* m_pOwner; + FnMemberCommandCallback_t m_Func; + FnMemberCommandCompletionCallback_t m_CompletionFunc; +}; + +#if defined _MSC_VER +#pragma warning ( default : 4355 ) +#endif + + +//----------------------------------------------------------------------------- +// Purpose: Utility macros to quicky generate a simple console command +//----------------------------------------------------------------------------- +#define CON_COMMAND( name, description ) \ + static void name( const CCommand &args ); \ + static ConCommand name##_command( #name, name, description ); \ + static void name( const CCommand &args ) + +#define CON_COMMAND_F( name, description, flags ) \ + static void name( const CCommand &args ); \ + static ConCommand name##_command( #name, name, description, flags ); \ + static void name( const CCommand &args ) + +#define CON_COMMAND_F_COMPLETION( name, description, flags, completion ) \ + static void name( const CCommand &args ); \ + static ConCommand name##_command( #name, name, description, flags, completion ); \ + static void name( const CCommand &args ) + +#define CON_COMMAND_EXTERN( name, _funcname, description ) \ + void _funcname( const CCommand &args ); \ + static ConCommand name##_command( #name, _funcname, description ); \ + void _funcname( const CCommand &args ) + +#define CON_COMMAND_EXTERN_F( name, _funcname, description, flags ) \ + void _funcname( const CCommand &args ); \ + static ConCommand name##_command( #name, _funcname, description, flags ); \ + void _funcname( const CCommand &args ) + +#define CON_COMMAND_MEMBER_F( _thisclass, name, _funcname, description, flags ) \ + void _funcname( const CCommand &args ); \ + friend class CCommandMemberInitializer_##_funcname; \ + class CCommandMemberInitializer_##_funcname \ + { \ + public: \ + CCommandMemberInitializer_##_funcname() : m_ConCommandAccessor( NULL, name, &_thisclass::_funcname, description, flags ) \ + { \ + m_ConCommandAccessor.SetOwner( GET_OUTER( _thisclass, m_##_funcname##_register ) ); \ + } \ + private: \ + CConCommandMemberAccessor< _thisclass > m_ConCommandAccessor; \ + }; \ + \ + CCommandMemberInitializer_##_funcname m_##_funcname##_register; \ + + +#endif // CONVAR_H diff --git a/core/msvc8/sourcemod_mm.sln b/core/msvc8/sourcemod_mm.sln index 6d3ef0e6..e103b70d 100644 --- a/core/msvc8/sourcemod_mm.sln +++ b/core/msvc8/sourcemod_mm.sln @@ -6,14 +6,20 @@ EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution CrazyDebug|Win32 = CrazyDebug|Win32 + Debug - Orange Box|Win32 = Debug - Orange Box|Win32 Debug|Win32 = Debug|Win32 + Release - Orange Box|Win32 = Release - Orange Box|Win32 Release|Win32 = Release|Win32 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.CrazyDebug|Win32.ActiveCfg = CrazyDebug|Win32 {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.CrazyDebug|Win32.Build.0 = CrazyDebug|Win32 + {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Debug - Orange Box|Win32.ActiveCfg = Debug - Orange Box|Win32 + {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Debug - Orange Box|Win32.Build.0 = Debug - Orange Box|Win32 {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Debug|Win32.ActiveCfg = Debug|Win32 {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Debug|Win32.Build.0 = Debug|Win32 + {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Release - Orange Box|Win32.ActiveCfg = Release - Orange Box|Win32 + {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Release - Orange Box|Win32.Build.0 = Release - Orange Box|Win32 {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Release|Win32.ActiveCfg = Release|Win32 {E39527CD-7CAB-4420-97CC-DA1B93B260BC}.Release|Win32.Build.0 = Release|Win32 EndGlobalSection diff --git a/core/msvc8/sourcemod_mm.vcproj b/core/msvc8/sourcemod_mm.vcproj index 68db9142..243666c9 100644 --- a/core/msvc8/sourcemod_mm.vcproj +++ b/core/msvc8/sourcemod_mm.vcproj @@ -1,7 +1,7 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -271,6 +431,10 @@ RelativePath="..\ADTFactory.cpp" > + + @@ -316,6 +480,15 @@ AssemblerOutput="0" /> + + + = 2) { - const char *cmd = GetArgument(1); - if (strcmp(cmd, "text") == 0) + const char *cmdname = cmd.Arg(1); + if (strcmp(cmdname, "text") == 0) { _IntExt_EnableYams(); return; - } else if (strcmp(cmd, "internal") == 0) { + } else if (strcmp(cmdname, "internal") == 0) { if (argnum >= 3) { - const char *arg = GetArgument(2); + const char *arg = cmd.Arg(2); if (strcmp(arg, "1") == 0) { SM_ConfigsExecuted_Global(); } else if (strcmp(arg, "2") == 0) { if (argnum >= 4) { - SM_ConfigsExecuted_Plugin(atoi(GetArgument(3))); + SM_ConfigsExecuted_Plugin(atoi(cmd.Arg(3))); } } } @@ -230,9 +237,9 @@ void RootConsoleMenu::GotRootCmd() } IRootConsoleCommand *pHandler; - if (sm_trie_retrieve(m_pCommands, cmd, (void **)&pHandler)) + if (sm_trie_retrieve(m_pCommands, cmdname, (void **)&pHandler)) { - pHandler->OnRootConsoleCommand(cmd, argnum); + pHandler->OnRootConsoleCommand(cmdname, cmd); return; } } @@ -249,24 +256,9 @@ void RootConsoleMenu::GotRootCmd() } } -const char *RootConsoleMenu::GetArgument(unsigned int argno) +void RootConsoleMenu::OnRootConsoleCommand(const char *cmdname, const CCommand &command) { - return engine->Cmd_Argv(argno); -} - -const char *RootConsoleMenu::GetArguments() -{ - return engine->Cmd_Args(); -} - -unsigned int RootConsoleMenu::GetArgumentCount() -{ - return engine->Cmd_Argc(); -} - -void RootConsoleMenu::OnRootConsoleCommand(const char *cmd, unsigned int argcount) -{ - if (strcmp(cmd, "credits") == 0) + if (strcmp(cmdname, "credits") == 0) { ConsolePrint(" SourceMod was developed by AlliedModders, LLC."); ConsolePrint(" Development would not have been possible without the following people:"); @@ -277,7 +269,7 @@ void RootConsoleMenu::OnRootConsoleCommand(const char *cmd, unsigned int argcoun ConsolePrint(" Special thanks to Viper of GameConnect"); ConsolePrint(" Special thanks to Mani of Mani-Admin-Plugin"); ConsolePrint(" http://www.sourcemod.net/"); - } else if (strcmp(cmd, "version") == 0) { + } else if (strcmp(cmdname, "version") == 0) { ConsolePrint(" SourceMod Version Information:"); ConsolePrint(" SourceMod Version: %s", SVN_FULL_VERSION); ConsolePrint(" JIT Version: %s, %s", g_pVM->GetVMName(), g_pVM->GetVersionString()); @@ -288,18 +280,24 @@ void RootConsoleMenu::OnRootConsoleCommand(const char *cmd, unsigned int argcoun CON_COMMAND(sm, "SourceMod Menu") { - g_RootMenu.GotRootCmd(); +#if !defined ORANGEBOX_BUILD + CCommand args; +#endif + g_RootMenu.GotRootCmd(args); } CON_COMMAND(sm_dump_handles, "Dumps Handle usage to a file for finding Handle leaks") { - if (engine->Cmd_Argc() < 2) +#if !defined ORANGEBOX_BUILD + CCommand args; +#endif + if (args.ArgC() < 2) { g_RootMenu.ConsolePrint("Usage: sm_dump_handles "); return; } - const char *arg = engine->Cmd_Argv(1); + const char *arg = args.Arg(1); FILE *fp = fopen(arg, "wt"); if (!fp) { diff --git a/core/sm_srvcmds.h b/core/sm_srvcmds.h index 64277109..eedd0e02 100644 --- a/core/sm_srvcmds.h +++ b/core/sm_srvcmds.h @@ -64,17 +64,14 @@ public: //SMGlobalClass void OnSourceModStartup(bool late); void OnSourceModShutdown(); public: //IRootConsoleCommand - void OnRootConsoleCommand(const char *cmd, unsigned int argcount); + void OnRootConsoleCommand(const char *cmdname, const CCommand &command); public: //IRootConsole bool AddRootConsoleCommand(const char *cmd, const char *text, IRootConsoleCommand *pHandler); bool RemoveRootConsoleCommand(const char *cmd, IRootConsoleCommand *pHandler); void ConsolePrint(const char *fmt, ...); - const char *GetArgument(unsigned int argno); - unsigned int GetArgumentCount(); - const char *GetArguments(); void DrawGenericOption(const char *cmd, const char *text); public: - void GotRootCmd(); + void GotRootCmd(const CCommand &cmd); private: bool m_CfgExecDone; Trie *m_pCommands; diff --git a/core/smn_console.cpp b/core/smn_console.cpp index 508040a5..dc48a0ac 100644 --- a/core/smn_console.cpp +++ b/core/smn_console.cpp @@ -107,7 +107,7 @@ static void NotifyConVar(ConVar *pConVar) { IGameEvent *pEvent = gameevents->CreateEvent("server_cvar"); pEvent->SetString("cvarname", pConVar->GetName()); - if (pConVar->IsBitSet(FCVAR_PROTECTED)) + if (IsFlagSet(pConVar, FCVAR_PROTECTED)) { pEvent->SetString("cvarvalue", "***PROTECTED***"); } else { @@ -250,13 +250,13 @@ static cell_t sm_SetConVarNum(IPluginContext *pContext, const cell_t *params) pConVar->SetValue(params[2]); /* Should we replicate it? */ - if (params[3] && pConVar->IsBitSet(FCVAR_REPLICATED)) + if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED)) { ReplicateConVar(pConVar); } /* Should we notify clients? */ - if (params[4] && pConVar->IsBitSet(FCVAR_NOTIFY)) + if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY)) { NotifyConVar(pConVar); } @@ -297,13 +297,13 @@ static cell_t sm_SetConVarFloat(IPluginContext *pContext, const cell_t *params) pConVar->SetValue(value); /* Should we replicate it? */ - if (params[3] && pConVar->IsBitSet(FCVAR_REPLICATED)) + if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED)) { ReplicateConVar(pConVar); } /* Should we notify clients? */ - if (params[4] && pConVar->IsBitSet(FCVAR_NOTIFY)) + if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY)) { NotifyConVar(pConVar); } @@ -346,13 +346,13 @@ static cell_t sm_SetConVarString(IPluginContext *pContext, const cell_t *params) pConVar->SetValue(value); /* Should we replicate it? */ - if (params[3] && pConVar->IsBitSet(FCVAR_REPLICATED)) + if (params[3] && IsFlagSet(pConVar, FCVAR_REPLICATED)) { ReplicateConVar(pConVar); } /* Should we notify clients? */ - if (params[4] && pConVar->IsBitSet(FCVAR_NOTIFY)) + if (params[4] && IsFlagSet(pConVar, FCVAR_NOTIFY)) { NotifyConVar(pConVar); } @@ -375,13 +375,13 @@ static cell_t sm_ResetConVar(IPluginContext *pContext, const cell_t *params) pConVar->Revert(); /* Should we replicate it? */ - if (params[2] && pConVar->IsBitSet(FCVAR_REPLICATED)) + if (params[2] && IsFlagSet(pConVar, FCVAR_REPLICATED)) { ReplicateConVar(pConVar); } /* Should we notify clients? */ - if (params[3] && pConVar->IsBitSet(FCVAR_NOTIFY)) + if (params[3] && IsFlagSet(pConVar, FCVAR_NOTIFY)) { NotifyConVar(pConVar); } @@ -625,22 +625,22 @@ static cell_t sm_RegAdminCmd(IPluginContext *pContext, const cell_t *params) static cell_t sm_GetCmdArgs(IPluginContext *pContext, const cell_t *params) { - return engine->Cmd_Argc() - 1; + return 4 :O;//engine->Cmd_Argc() - 1; } static cell_t sm_GetCmdArg(IPluginContext *pContext, const cell_t *params) { - const char *arg = engine->Cmd_Argv(params[1]); + //const char *arg = //engine->Cmd_Argv(params[1]); size_t length; - pContext->StringToLocalUTF8(params[2], params[3], arg, &length); + //pContext->StringToLocalUTF8(params[2], params[3], arg, &length); return (cell_t)length; } static cell_t sm_GetCmdArgString(IPluginContext *pContext, const cell_t *params) { - const char *args = engine->Cmd_Args(); + const char *args = NULL;//engine->Cmd_Args(); size_t length; if (!args) @@ -751,7 +751,7 @@ static cell_t sm_InsertServerCommand(IPluginContext *pContext, const cell_t *par buffer[len++] = '\n'; buffer[len] = '\0'; - engine->InsertServerCommand(buffer); + InsertServerCommand(buffer); return 1; } diff --git a/core/smn_usermsgs.cpp b/core/smn_usermsgs.cpp index 1d8c0a1e..d560dfbe 100644 --- a/core/smn_usermsgs.cpp +++ b/core/smn_usermsgs.cpp @@ -60,7 +60,7 @@ public: //SMGlobalClass, IHandleTypeDispatch, IPluginListener void OnPluginUnloaded(IPlugin *plugin); public: MsgListenerWrapper *CreateListener(IPluginContext *pCtx); - MsgWrapperIter FindListener(int msgid, IPluginContext *pCtx, IPluginFunction *pHook, bool intercept); + bool FindListener(int msgid, IPluginContext *pCtx, IPluginFunction *pHook, bool intercept, MsgWrapperIter *iter); bool DeleteListener(IPluginContext *pCtx, MsgWrapperIter iter); private: CStack m_FreeListeners; @@ -156,30 +156,31 @@ MsgListenerWrapper *UsrMessageNatives::CreateListener(IPluginContext *pCtx) return pListener; } -MsgWrapperIter UsrMessageNatives::FindListener(int msgid, IPluginContext *pCtx, IPluginFunction *pHook, bool intercept) +bool UsrMessageNatives::FindListener(int msgid, IPluginContext *pCtx, IPluginFunction *pHook, bool intercept, MsgWrapperIter *iter) { MsgWrapperList *pList; - MsgWrapperIter iter; + MsgWrapperIter _iter; MsgListenerWrapper *pListener; IPlugin *pl = g_PluginSys.FindPluginByContext(pCtx->GetContext()); if (!pl->GetProperty("MsgListeners", reinterpret_cast(&pList))) { - return NULL; + return false; } - for (iter=pList->begin(); iter!=pList->end(); iter++) + for (_iter=pList->begin(); _iter!=pList->end(); _iter++) { - pListener = (*iter); + pListener = (*_iter); if ((msgid == pListener->GetMessageId()) && (intercept == pListener->IsInterceptHook()) && (pHook == pListener->GetHookedFunction())) { - return iter; + *iter = _iter; + return true; } } - return NULL; + return false; } bool UsrMessageNatives::DeleteListener(IPluginContext *pCtx, MsgWrapperIter iter) @@ -467,8 +468,7 @@ static cell_t smn_UnhookUserMessage(IPluginContext *pCtx, const cell_t *params) } intercept = (params[3]) ? true : false; - iter = s_UsrMessageNatives.FindListener(msgid, pCtx, pFunc, intercept); - if (iter == NULL) + if (!s_UsrMessageNatives.FindListener(msgid, pCtx, pFunc, intercept, &iter)) { return pCtx->ThrowNativeError("Unable to unhook the current user message"); } diff --git a/core/smn_vector.cpp b/core/smn_vector.cpp index 01f8663b..ef52e969 100644 --- a/core/smn_vector.cpp +++ b/core/smn_vector.cpp @@ -31,7 +31,7 @@ #include "sm_globals.h" #include -#include +#include #define SET_VECTOR(addr, vec) \ addr[0] = sp_ftoc(vec.x); \ @@ -181,6 +181,16 @@ static cell_t NormalizeVector(IPluginContext *pContext, const cell_t *params) return sp_ftoc(length); } +//:TODO: OMG remove this when we get the OB SDK!!1 +// as well as bitbuf.cpp (i write it here just to remind it) +#if defined ORANGEBOX_BUILD +float ham(float _X) +{ + return sqrt(_X); +} +float (*pfSqrt)(float x) = ham; +#endif + REGISTER_NATIVES(vectorNatives) { {"GetAngleVectors", GetAngleVectors}, diff --git a/core/sourcemm_api.cpp b/core/sourcemm_api.cpp index ad49c7b7..4d4005d8 100644 --- a/core/sourcemm_api.cpp +++ b/core/sourcemm_api.cpp @@ -29,10 +29,9 @@ * Version: $Id$ */ -#include +#include "sourcemod.h" #include "sourcemm_api.h" #include "sm_version.h" -#include "sourcemod.h" #include "Logger.h" #include "ConVarManager.h" @@ -58,18 +57,18 @@ bool SourceMod_Core::Load(PluginId id, ISmmAPI *ismm, char *error, size_t maxlen { PLUGIN_SAVEVARS(); - GET_V_IFACE_ANY(serverFactory, gamedll, IServerGameDLL, INTERFACEVERSION_SERVERGAMEDLL); - GET_V_IFACE_CURRENT(engineFactory, engine, IVEngineServer, INTERFACEVERSION_VENGINESERVER); - GET_V_IFACE_CURRENT(serverFactory, serverClients, IServerGameClients, INTERFACEVERSION_SERVERGAMECLIENTS); - GET_V_IFACE_CURRENT(engineFactory, icvar, ICvar, VENGINE_CVAR_INTERFACE_VERSION); - GET_V_IFACE_CURRENT(engineFactory, gameevents, IGameEventManager2, INTERFACEVERSION_GAMEEVENTSMANAGER2); - GET_V_IFACE_CURRENT(engineFactory, engrandom, IUniformRandomStream, VENGINE_SERVER_RANDOM_INTERFACE_VERSION); - GET_V_IFACE_CURRENT(fileSystemFactory, basefilesystem, IBaseFileSystem, BASEFILESYSTEM_INTERFACE_VERSION); - GET_V_IFACE_CURRENT(engineFactory, enginesound, IEngineSound, IENGINESOUND_SERVER_INTERFACE_VERSION); - GET_V_IFACE_CURRENT(engineFactory, serverpluginhelpers, IServerPluginHelpers, INTERFACEVERSION_ISERVERPLUGINHELPERS); + GET_V_IFACE_ANY(GetServerFactory, gamedll, IServerGameDLL, INTERFACEVERSION_SERVERGAMEDLL); + GET_V_IFACE_CURRENT(GetEngineFactory, engine, IVEngineServer, INTERFACEVERSION_VENGINESERVER); + GET_V_IFACE_CURRENT(GetServerFactory, serverClients, IServerGameClients, INTERFACEVERSION_SERVERGAMECLIENTS); + GET_V_IFACE_CURRENT(GetEngineFactory, icvar, ICvar, CVAR_INTERFACE_VERSION); + GET_V_IFACE_CURRENT(GetEngineFactory, gameevents, IGameEventManager2, INTERFACEVERSION_GAMEEVENTSMANAGER2); + GET_V_IFACE_CURRENT(GetEngineFactory, engrandom, IUniformRandomStream, VENGINE_SERVER_RANDOM_INTERFACE_VERSION); + GET_V_IFACE_CURRENT(GetFileSystemFactory, basefilesystem, IBaseFileSystem, BASEFILESYSTEM_INTERFACE_VERSION); + GET_V_IFACE_CURRENT(GetEngineFactory, enginesound, IEngineSound, IENGINESOUND_SERVER_INTERFACE_VERSION); + GET_V_IFACE_CURRENT(GetEngineFactory, serverpluginhelpers, IServerPluginHelpers, INTERFACEVERSION_ISERVERPLUGINHELPERS); /* :TODO: Make this optional and... make it find earlier versions [?] */ - GET_V_IFACE_CURRENT(serverFactory, playerinfo, IPlayerInfoManager, INTERFACEVERSION_PLAYERINFOMANAGER); + GET_V_IFACE_CURRENT(GetServerFactory, playerinfo, IPlayerInfoManager, INTERFACEVERSION_PLAYERINFOMANAGER); if ((g_pMMPlugins = (ISmmPluginManager *)g_SMAPI->MetaFactory(MMIFACE_PLMANAGER, NULL, NULL)) == NULL) { @@ -80,7 +79,7 @@ bool SourceMod_Core::Load(PluginId id, ISmmAPI *ismm, char *error, size_t maxlen return false; } - gpGlobals = ismm->pGlobals(); + gpGlobals = ismm->GetCGlobals(); ismm->AddListener(this, this); ismm->EnableVSPListener(); diff --git a/core/sourcemm_api.h b/core/sourcemm_api.h index ada8ba8b..472fc398 100644 --- a/core/sourcemm_api.h +++ b/core/sourcemm_api.h @@ -32,7 +32,11 @@ #ifndef _INCLUDE_SOURCEMOD_MM_API_H_ #define _INCLUDE_SOURCEMOD_MM_API_H_ -#include "convar_sm.h" +#if defined ORANGEBOX_BUILD + #include "convar_sm_ob.h" +#else + #include "convar_sm.h" +#endif #include #include #include @@ -41,6 +45,10 @@ #include #include +#ifndef METAMOD_PLAPI_VERSION + #include +#endif + /** * @file Contains wrappers around required Metamod:Source API exports */ diff --git a/core/systems/ExtensionSys.cpp b/core/systems/ExtensionSys.cpp index 7ff728c6..7e8a7afe 100644 --- a/core/systems/ExtensionSys.cpp +++ b/core/systems/ExtensionSys.cpp @@ -813,11 +813,12 @@ void CExtensionManager::AddDependency(IExtension *pSource, const char *file, boo } } -void CExtensionManager::OnRootConsoleCommand(const char *cmd, unsigned int argcount) +void CExtensionManager::OnRootConsoleCommand(const char *cmdname, const CCommand &command) { + int argcount = command.ArgC(); if (argcount >= 3) { - const char *cmd = g_RootMenu.GetArgument(2); + const char *cmd = command.Arg(2); if (strcmp(cmd, "list") == 0) { List::iterator iter; @@ -869,7 +870,7 @@ void CExtensionManager::OnRootConsoleCommand(const char *cmd, unsigned int argco return; } - const char *sId = g_RootMenu.GetArgument(3); + const char *sId = command.Arg(3); unsigned int id = atoi(sId); if (id <= 0) { @@ -936,7 +937,7 @@ void CExtensionManager::OnRootConsoleCommand(const char *cmd, unsigned int argco return; } - const char *arg = g_RootMenu.GetArgument(3); + const char *arg = command.Arg(3); unsigned int num = atoi(arg); CExtension *pExt = FindByOrder(num); @@ -948,7 +949,7 @@ void CExtensionManager::OnRootConsoleCommand(const char *cmd, unsigned int argco if (argcount > 4 && pExt->unload_code) { - const char *unload = g_RootMenu.GetArgument(4); + const char *unload = command.Arg(4); if (pExt->unload_code == (unsigned)atoi(unload)) { char filename[PLATFORM_MAX_PATH]; diff --git a/core/systems/ExtensionSys.h b/core/systems/ExtensionSys.h index 4b3aed92..579f625a 100644 --- a/core/systems/ExtensionSys.h +++ b/core/systems/ExtensionSys.h @@ -121,7 +121,7 @@ public: //IExtensionManager public: //IPluginsListener void OnPluginDestroyed(IPlugin *plugin); public: //IRootConsoleCommand - void OnRootConsoleCommand(const char *cmd, unsigned int argcount); + void OnRootConsoleCommand(const char *cmdname, const CCommand &command); public: IExtension *LoadAutoExtension(const char *path); void BindDependency(IExtension *pOwner, IfaceInfo *pInfo); diff --git a/core/systems/PluginSys.cpp b/core/systems/PluginSys.cpp index 3f08fd91..1934e25e 100644 --- a/core/systems/PluginSys.cpp +++ b/core/systems/PluginSys.cpp @@ -1961,11 +1961,12 @@ const char *CPluginManager::GetStatusText(PluginStatus st) } } -void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argcount) +void CPluginManager::OnRootConsoleCommand(const char *cmdname, const CCommand &command) { + int argcount = command.ArgC(); if (argcount >= 3) { - const char *cmd = g_RootMenu.GetArgument(2); + const char *cmd = command.Arg(2); if (strcmp(cmd, "list") == 0) { char buffer[256]; @@ -2016,7 +2017,7 @@ void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argc char error[128]; bool wasloaded; - const char *filename = g_RootMenu.GetArgument(3); + const char *filename = command.Arg(3); char pluginfile[256]; const char *ext = g_LibSys.GetFileExtension(filename) ? "" : ".smx"; @@ -2047,7 +2048,7 @@ void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argc CPlugin *pl; char *end; - const char *arg = g_RootMenu.GetArgument(3); + const char *arg = command.Arg(3); int id = strtol(arg, &end, 10); if (*end == '\0') @@ -2089,7 +2090,7 @@ void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argc return; } - int num = atoi(g_RootMenu.GetArgument(3)); + int num = atoi(command.Arg(3)); if (num < 1 || num > (int)GetPluginCount()) { g_RootMenu.ConsolePrint("[SM] Plugin index not found."); @@ -2166,7 +2167,7 @@ void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argc return; } - int num = atoi(g_RootMenu.GetArgument(3)); + int num = atoi(command.Arg(3)); if (num < 1 || num > (int)GetPluginCount()) { g_RootMenu.ConsolePrint("[SM] Plugin index not found."); @@ -2174,7 +2175,7 @@ void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argc } int res; - const char *mode = g_RootMenu.GetArgument(4); + const char *mode = command.Arg(4); if ((res=strcmp("on", mode)) && strcmp("off", mode)) { g_RootMenu.ConsolePrint("[SM] The only possible options are \"on\" and \"off.\""); @@ -2218,7 +2219,7 @@ void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argc CPlugin *pl; char *end; - const char *arg = g_RootMenu.GetArgument(3); + const char *arg = command.Arg(3); int id = strtol(arg, &end, 10); if (*end == '\0') diff --git a/core/systems/PluginSys.h b/core/systems/PluginSys.h index 86868485..a0dd9f55 100644 --- a/core/systems/PluginSys.h +++ b/core/systems/PluginSys.h @@ -48,7 +48,11 @@ #include "sm_trie.h" #include "sourcemod.h" #include +#if defined ORANGEBOX_BUILD +#include "convar_sm_ob.h" +#else #include "convar_sm.h" +#endif using namespace SourceHook; @@ -351,7 +355,7 @@ public: //SMGlobalClass public: //IHandleTypeDispatch void OnHandleDestroy(HandleType_t type, void *object); public: //IRootConsoleCommand - void OnRootConsoleCommand(const char *command, unsigned int argcount); + void OnRootConsoleCommand(const char *cmdname, const CCommand &command); public: /** * Loads all plugins not yet loaded diff --git a/public/IRootConsoleMenu.h b/public/IRootConsoleMenu.h index 9ebd9af0..71ec1fd0 100644 --- a/public/IRootConsoleMenu.h +++ b/public/IRootConsoleMenu.h @@ -32,6 +32,8 @@ #ifndef _INCLUDE_SOURCEMOD_ROOT_CONSOLE_MENU_H_ #define _INCLUDE_SOURCEMOD_ROOT_CONSOLE_MENU_H_ +#include + /** * @file IRootConsoleMenu.h * @brief Defines the interface for adding options to the "sm" console command. @@ -51,7 +53,7 @@ namespace SourceMod class IRootConsoleCommand { public: - virtual void OnRootConsoleCommand(const char *command, unsigned int argcount) =0; + virtual void OnRootConsoleCommand(const char *cmdname, const CCommand &command) =0; }; /** @@ -87,28 +89,6 @@ namespace SourceMod */ virtual void ConsolePrint(const char *fmt, ...) =0; - /** - * @brief Returns the string of an argument. - * - * @param argno The index of the argument. - * @return A string containing the argument, or nothing if invalid. - */ - virtual const char *GetArgument(unsigned int argno) =0; - - /** - * @brief Returns the number of arguments. - * - * @return Number of arguments. - */ - virtual unsigned int GetArgumentCount() =0; - - /** - * @brief Returns the entire argument string. - * - * @return String containing all arguments. - */ - virtual const char *GetArguments() =0; - /** * @brief Draws a generic command/description pair. * NOTE: The pair is currently four spaces indented and 16-N spaces of separation, diff --git a/public/compat_wrappers.h b/public/compat_wrappers.h new file mode 100644 index 00000000..56e9dfeb --- /dev/null +++ b/public/compat_wrappers.h @@ -0,0 +1,82 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * SourceMod + * Copyright (C) 2004-2007 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or . + * + * Version: $Id$ + */ + +#ifndef _INCLUDE_SOURCEMOD_COMPAT_WRAPPERS_H_ +#define _INCLUDE_SOURCEMOD_COMPAT_WRAPPERS_H_ + +#if defined ORANGEBOX_BUILD + #include "convar_sm_ob.h" + #include "sourcemm_api.h" + + #define CONVAR_REGISTER(object) ConVar_Register(0, object) + + inline bool IsFlagSet(ConCommandBase *cmd, int flag) + { + return cmd->IsFlagSet(flag); + } + inline void InsertServerCommand(const char *buf) + { + engine->ServerCommand(buf); + } +#else + #include "sourcemm_api.h" + + class CCommand + { + public: + inline const char *ArgS() const + { + return engine->Cmd_Args(); + } + inline int ArgC() const + { + return engine->Cmd_Argc(); + } + inline const char *Arg(int index) const + { + return engine->Cmd_Argv(index); + } + }; + + inline bool IsFlagSet(ConCommandBase *cmd, int flag) + { + return cmd->IsBitSet(flag); + } + inline void InsertServerCommand(const char *buf) + { + engine->InsertServerCommand(buf); + } + + #define CONVAR_REGISTER(object) ConCommandBaseMgr::OneTimeInit(object) + typedef FnChangeCallback FnChangeCallback_t; +#endif //ORANGEBOX_BUILD + +#endif //_INCLUDE_SOURCEMOD_COMPAT_WRAPPERS_H_ diff --git a/public/metamod_wrappers.h b/public/metamod_wrappers.h new file mode 100644 index 00000000..279396fa --- /dev/null +++ b/public/metamod_wrappers.h @@ -0,0 +1,48 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * SourceMod + * Copyright (C) 2004-2007 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or . + * + * Version: $Id$ + */ + +#ifndef _INCLUDE_METAMOD_WRAPPERS_H_ +#define _INCLUDE_METAMOD_WRAPPERS_H_ + +/* Get iface wrappers */ +#define GetEngineFactory engineFactory +#define GetServerFactory serverFactory +#define GetPhysicsFactory physicsFactory +#define GetFileSystemFactory fileSystemFactory + +#define GetCGlobals pGlobals + +#define UnregisterConCommandBase UnregisterConCmdBase + +/* Valve interface wrappers */ +#define CVAR_INTERFACE_VERSION VENGINE_CVAR_INTERFACE_VERSION + +#endif //_INCLUDE_METAMOD_WRAPPERS_H_