c91542fbe8
Also added missing header --HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%40510
416 lines
9.9 KiB
C++
416 lines
9.9 KiB
C++
/**
|
|
* ===============================================================
|
|
* SourceMod (C)2004-2007 AlliedModders LLC. All rights reserved.
|
|
* ===============================================================
|
|
*
|
|
* This file is not open source and may not be copied without explicit
|
|
* written permission of AlliedModders LLC. This file may not be redistributed
|
|
* in whole or significant part.
|
|
* For information, see LICENSE.txt or http://www.sourcemod.net/license.php
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#include "CConCmdManager.h"
|
|
#include "sm_srvcmds.h"
|
|
#include "sm_stringutil.h"
|
|
|
|
CConCmdManager g_ConCmds;
|
|
|
|
SH_DECL_HOOK0_void(ConCommand, Dispatch, SH_NOATTRIB, false);
|
|
SH_DECL_HOOK1_void(IServerGameClients, SetCommandClient, SH_NOATTRIB, false, int);
|
|
|
|
struct PlCmdInfo
|
|
{
|
|
ConCmdInfo *pInfo;
|
|
CmdType type;
|
|
};
|
|
|
|
typedef List<PlCmdInfo> CmdList;
|
|
|
|
CConCmdManager::CConCmdManager()
|
|
{
|
|
m_pCmds = sm_trie_create();
|
|
}
|
|
|
|
CConCmdManager::~CConCmdManager()
|
|
{
|
|
sm_trie_destroy(m_pCmds);
|
|
}
|
|
|
|
void CConCmdManager::OnSourceModAllInitialized()
|
|
{
|
|
g_PluginSys.AddPluginsListener(this);
|
|
g_RootMenu.AddRootConsoleCommand("cmds", "List console commands", this);
|
|
SH_ADD_HOOK_MEMFUNC(IServerGameClients, SetCommandClient, serverClients, this, &CConCmdManager::SetCommandClient, false);
|
|
}
|
|
|
|
void CConCmdManager::OnSourceModShutdown()
|
|
{
|
|
/* All commands should already be removed by the time we're done */
|
|
SH_REMOVE_HOOK_MEMFUNC(IServerGameClients, SetCommandClient, serverClients, this, &CConCmdManager::SetCommandClient, false);
|
|
g_RootMenu.RemoveRootConsoleCommand("cmds", this);
|
|
g_PluginSys.RemovePluginsListener(this);
|
|
}
|
|
|
|
void CConCmdManager::OnPluginLoaded(IPlugin *plugin)
|
|
{
|
|
/* Nothing yet... */
|
|
}
|
|
|
|
void CConCmdManager::OnPluginDestroyed(IPlugin *plugin)
|
|
{
|
|
CmdList *pList;
|
|
List<ConCmdInfo *> removed;
|
|
if (plugin->GetProperty("CommandList", (void **)&pList, true))
|
|
{
|
|
CmdList::iterator iter;
|
|
for (iter=pList->begin();
|
|
iter!=pList->end();
|
|
iter++)
|
|
{
|
|
PlCmdInfo &cmd = (*iter);
|
|
if (cmd.type == Cmd_Server
|
|
|| cmd.type == Cmd_Console)
|
|
{
|
|
ConCmdInfo *pInfo = cmd.pInfo;
|
|
/* See if this is being removed */
|
|
if (removed.find(pInfo) != removed.end())
|
|
{
|
|
continue;
|
|
}
|
|
/* See if there are still hooks */
|
|
if (pInfo->srvhooks
|
|
&& pInfo->srvhooks->GetFunctionCount())
|
|
{
|
|
continue;
|
|
}
|
|
if (pInfo->conhooks
|
|
&& pInfo->conhooks->GetFunctionCount())
|
|
{
|
|
continue;
|
|
}
|
|
/* Remove the command */
|
|
RemoveConCmd(pInfo);
|
|
removed.push_back(pInfo);
|
|
}
|
|
}
|
|
delete pList;
|
|
}
|
|
}
|
|
|
|
void CommandCallback()
|
|
{
|
|
g_ConCmds.InternalDispatch();
|
|
}
|
|
|
|
void CConCmdManager::SetCommandClient(int client)
|
|
{
|
|
m_CmdClient = client + 1;
|
|
}
|
|
|
|
ResultType CConCmdManager::DispatchClientCommand(int client, ResultType type)
|
|
{
|
|
const char *cmd = engine->Cmd_Argv(0);
|
|
int args = engine->Cmd_Argc() - 1;
|
|
|
|
ConCmdInfo *pInfo;
|
|
if (sm_trie_retrieve(m_pCmds, cmd, (void **)&pInfo))
|
|
{
|
|
cell_t result = type;
|
|
if (pInfo->conhooks && pInfo->conhooks->GetFunctionCount())
|
|
{
|
|
pInfo->conhooks->PushCell(client);
|
|
pInfo->conhooks->PushCell(args);
|
|
pInfo->conhooks->Execute(&result);
|
|
}
|
|
if (result >= Pl_Stop)
|
|
{
|
|
return Pl_Stop;
|
|
}
|
|
type = (ResultType)result;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
void CConCmdManager::InternalDispatch()
|
|
{
|
|
/**
|
|
* Note: Console commands will EITHER go through IServerGameDLL::ClientCommand,
|
|
* OR this dispatch. They will NEVER go through both.
|
|
* --
|
|
* Whether or not it goes through the callback is determined by FCVAR_GAMEDLL
|
|
*/
|
|
|
|
const char *cmd = engine->Cmd_Argv(0);
|
|
ConCmdInfo *pInfo;
|
|
if (!sm_trie_retrieve(m_pCmds, cmd, (void **)&pInfo))
|
|
{
|
|
return;
|
|
}
|
|
|
|
cell_t result = Pl_Continue;
|
|
int args = engine->Cmd_Argc() - 1;
|
|
|
|
if (m_CmdClient == 0)
|
|
{
|
|
if (pInfo->srvhooks && pInfo->srvhooks->GetFunctionCount())
|
|
{
|
|
pInfo->srvhooks->PushCell(args);
|
|
pInfo->srvhooks->Execute(&result);
|
|
}
|
|
|
|
/* Check if there's an early stop */
|
|
if (result >= Pl_Stop)
|
|
{
|
|
if (!pInfo->sourceMod)
|
|
{
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Execute console command hooks */
|
|
if (pInfo->conhooks && pInfo->conhooks->GetFunctionCount())
|
|
{
|
|
pInfo->conhooks->PushCell(m_CmdClient);
|
|
pInfo->conhooks->PushCell(args);
|
|
pInfo->conhooks->Execute(&result);
|
|
}
|
|
|
|
if (result >= Pl_Handled)
|
|
{
|
|
if (!pInfo->sourceMod)
|
|
{
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CConCmdManager::AddConsoleCommand(IPluginFunction *pFunction,
|
|
const char *name,
|
|
const char *description,
|
|
int flags)
|
|
{
|
|
ConCmdInfo *pInfo = AddOrFindCommand(name, description, flags);
|
|
|
|
if (!pInfo->conhooks)
|
|
{
|
|
pInfo->conhooks = g_Forwards.CreateForwardEx(NULL, ET_Hook, 2, NULL, Param_Cell, Param_Cell);
|
|
}
|
|
|
|
pInfo->conhooks->AddFunction(pFunction);
|
|
|
|
/* Add to the plugin */
|
|
CmdList *pList;
|
|
IPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pFunction->GetParentContext()->GetContext());
|
|
if (!pPlugin->GetProperty("CommandList", (void **)&pList))
|
|
{
|
|
pList = new CmdList();
|
|
pPlugin->SetProperty("CommandList", pList);
|
|
}
|
|
PlCmdInfo info;
|
|
info.pInfo = pInfo;
|
|
info.type = Cmd_Console;
|
|
pList->push_back(info);
|
|
}
|
|
|
|
void CConCmdManager::AddServerCommand(IPluginFunction *pFunction,
|
|
const char *name,
|
|
const char *description,
|
|
int flags)
|
|
|
|
{
|
|
ConCmdInfo *pInfo = AddOrFindCommand(name, description, flags);
|
|
|
|
if (!pInfo->srvhooks)
|
|
{
|
|
pInfo->srvhooks = g_Forwards.CreateForwardEx(NULL, ET_Hook, 1, NULL, Param_Cell);
|
|
}
|
|
|
|
pInfo->srvhooks->AddFunction(pFunction);
|
|
|
|
/* Add to the plugin */
|
|
CmdList *pList;
|
|
IPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pFunction->GetParentContext()->GetContext());
|
|
if (!pPlugin->GetProperty("CommandList", (void **)&pList))
|
|
{
|
|
pList = new CmdList();
|
|
pPlugin->SetProperty("CommandList", pList);
|
|
}
|
|
PlCmdInfo info;
|
|
info.pInfo = pInfo;
|
|
info.type = Cmd_Server;
|
|
pList->push_back(info);
|
|
}
|
|
|
|
void CConCmdManager::AddToCmdList(ConCmdInfo *info)
|
|
{
|
|
List<ConCmdInfo *>::iterator iter = m_CmdList.begin();
|
|
ConCmdInfo *pInfo;
|
|
bool inserted = false;
|
|
const char *orig = NULL;
|
|
|
|
orig = info->pCmd->GetName();
|
|
|
|
/* Insert this into the help list, SORTED alphabetically. */
|
|
while (iter != m_CmdList.end())
|
|
{
|
|
const char *cmd = NULL;
|
|
pInfo = (*iter);
|
|
cmd = pInfo->pCmd->GetName();
|
|
if (strcmp(orig, cmd) < 0)
|
|
{
|
|
m_CmdList.insert(iter, info);
|
|
inserted = true;
|
|
break;
|
|
}
|
|
iter++;
|
|
}
|
|
|
|
if (!inserted)
|
|
{
|
|
m_CmdList.push_back(info);
|
|
}
|
|
}
|
|
|
|
void CConCmdManager::RemoveConCmd(ConCmdInfo *info)
|
|
{
|
|
/* Remove console-specific information
|
|
* This should always be true as of right now
|
|
*/
|
|
if (info->pCmd)
|
|
{
|
|
/* Remove from the trie */
|
|
sm_trie_delete(m_pCmds, info->pCmd->GetName());
|
|
|
|
if (info->sourceMod)
|
|
{
|
|
/* Unlink from SourceMM */
|
|
g_SMAPI->UnregisterConCmdBase(g_PLAPI, info->pCmd);
|
|
/* Delete the command's memory */
|
|
char *new_help = const_cast<char *>(info->pCmd->GetHelpText());
|
|
char *new_name = const_cast<char *>(info->pCmd->GetName());
|
|
delete [] new_help;
|
|
delete [] new_name;
|
|
delete info->pCmd;
|
|
} else {
|
|
/* Remove the external hook */
|
|
SH_REMOVE_HOOK_STATICFUNC(ConCommand, Dispatch, info->pCmd, CommandCallback, false);
|
|
}
|
|
}
|
|
|
|
/* Remove from list */
|
|
m_CmdList.remove(info);
|
|
|
|
/* Free forwards */
|
|
if (info->srvhooks)
|
|
{
|
|
g_Forwards.ReleaseForward(info->srvhooks);
|
|
}
|
|
}
|
|
|
|
ConCmdInfo *CConCmdManager::AddOrFindCommand(const char *name, const char *description, int flags)
|
|
{
|
|
ConCmdInfo *pInfo;
|
|
if (!sm_trie_retrieve(m_pCmds, name, (void **)&pInfo))
|
|
{
|
|
pInfo = new ConCmdInfo();
|
|
/* Find the commandopan */
|
|
ConCommandBase *pBase = icvar->GetCommands();
|
|
ConCommand *pCmd = NULL;
|
|
while (pBase)
|
|
{
|
|
if (pBase->IsCommand()
|
|
&& (strcmp(pBase->GetName(), name) == 0))
|
|
{
|
|
pCmd = (ConCommand *)pBase;
|
|
break;
|
|
}
|
|
pBase = const_cast<ConCommandBase *>(pBase->GetNext());
|
|
}
|
|
|
|
if (!pCmd)
|
|
{
|
|
/* Note that we have to duplicate because the source might not be
|
|
* a static string, and these expect static memory.
|
|
*/
|
|
if (!description)
|
|
{
|
|
description = "";
|
|
}
|
|
char *new_name = sm_strdup(name);
|
|
char *new_help = sm_strdup(description);
|
|
pCmd = new ConCommand(new_name, CommandCallback, new_help, flags);
|
|
pInfo->sourceMod = true;
|
|
} else {
|
|
SH_ADD_HOOK_STATICFUNC(ConCommand, Dispatch, pCmd, CommandCallback, false);
|
|
}
|
|
|
|
pInfo->pCmd = pCmd;
|
|
|
|
sm_trie_insert(m_pCmds, name, pInfo);
|
|
AddToCmdList(pInfo);
|
|
}
|
|
|
|
return pInfo;
|
|
}
|
|
|
|
void CConCmdManager::OnRootConsoleCommand(const char *command, unsigned int argcount)
|
|
{
|
|
if (argcount >= 3)
|
|
{
|
|
const char *text = engine->Cmd_Argv(2);
|
|
int id = atoi(text);
|
|
CPlugin *pPlugin = g_PluginSys.GetPluginByOrder(id);
|
|
|
|
if (!pPlugin)
|
|
{
|
|
g_RootMenu.ConsolePrint("[SM] Plugin index %d not found.", id);
|
|
return;
|
|
}
|
|
|
|
CmdList *pList;
|
|
if (!pPlugin->GetProperty("CommandList", (void **)&pList))
|
|
{
|
|
g_RootMenu.ConsolePrint("[SM] No commands found for %s", pPlugin->GetFilename());
|
|
return;
|
|
}
|
|
if (!pList->size())
|
|
{
|
|
g_RootMenu.ConsolePrint("[SM] No commands found for %s", pPlugin->GetFilename());
|
|
return;
|
|
}
|
|
|
|
CmdList::iterator iter;
|
|
const char *type = NULL;
|
|
const char *name;
|
|
const char *help;
|
|
g_RootMenu.ConsolePrint(" %-17.16s %-8.7s %s", "[Name]", "[Type]", "[Help]");
|
|
for (iter=pList->begin();
|
|
iter!=pList->end();
|
|
iter++)
|
|
{
|
|
PlCmdInfo &cmd = (*iter);
|
|
if (cmd.type == Cmd_Server)
|
|
{
|
|
type = "server";
|
|
} else if (cmd.type == Cmd_Console) {
|
|
type = "console";
|
|
} else if (cmd.type == Cmd_Client) {
|
|
type = "client";
|
|
}
|
|
name = cmd.pInfo->pCmd->GetName();
|
|
help = cmd.pInfo->pCmd->GetHelpText();
|
|
g_RootMenu.ConsolePrint(" %-17.16s %-12.11s %s", name, type, help);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
g_RootMenu.ConsolePrint("[SM] Usage: sm cmds <plugin #>");
|
|
}
|