//-----------------------------------------------------------------------------
// Returns a CServerCommandManager instance.
//-----------------------------------------------------------------------------
CServerCommandManager* CServerCommandManager::CreateCommand(const char* szName,
const char* szHelpText, int iFlags)
{
// Copy the name and store a help text copier value
char* szNameCopy = strdup(szName);
char* szHelpTextCopy = NULL;
// FInd if the command already exists
ConCommand* pConCommand = g_pCVar->FindCommand(szName);
if( pConCommand )
{
// Store the current command's help text and flags
szHelpTextCopy = strdup(pConCommand->GetHelpText());
iFlags = pConCommand->m_nFlags;
// Unregister the old command
g_pCVar->UnregisterConCommand(pConCommand);
}
else if( szHelpText != NULL )
{
// Store the given help text
szHelpTextCopy = strdup(szHelpText);
}
// Return a new instance of ConCommand
return new CServerCommandManager(pConCommand, szNameCopy, szHelpTextCopy, iFlags);
}
void PluginImpl::LevelShutdown() {
g_roundIsActive = false;
if (g_pEngineClient->IsRecordingDemo() && g_demoIsInternal) {
ConCommand *stop = g_pCVar->FindCommand("stop");
const char *argv[1] = {"stop"};
stop->Dispatch(CCommand(1, argv));
g_demoIsInternal = false;
if (!g_pDemoInfo->HasMarks() && prec_delete_useless_demo.GetInt() == 1) {
prec_delete_demo(CCommand(0, nullptr));
}
}
}
object execute_server_command(tuple args, dict kwargs)
{
std::string szCommand;
ConCommand* pCommand;
prepare_command(args, kwargs, &pCommand, &szCommand);
CCommand c;
if (!c.Tokenize(szCommand.c_str()))
BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Failed to tokenize '%s'.", szCommand.c_str())
pCommand->Dispatch(c);
return object();
}
// Syntax: cssm_help [command name]
void cssmatch::cssm_help(const CCommand & args)
{
ServerPlugin * plugin = ServerPlugin::getInstance();
const map<string, ConCommand *> * pluginConCommands = plugin->getPluginConCommands();
map<string, ConCommand *>::const_iterator lastConCommand = pluginConCommands->end();
if (args.ArgC() == 1)
{
map<string, ConCommand *>::const_iterator itConCommand = pluginConCommands->begin();
while (itConCommand != lastConCommand)
{
ConCommand * command = itConCommand->second;
const char * helpText = command->GetHelpText();
Msg("%s\n", helpText);
delete [] helpText;
itConCommand++;
}
}
else
{
string commandName = args.Arg(1);
map<string, ConCommand *>::const_iterator itConCommand = pluginConCommands->find(
commandName);
if (itConCommand != lastConCommand)
{
const char * helpText = itConCommand->second->GetHelpText();
Msg("%s\n", helpText);
delete [] helpText;
}
else
{
I18nManager * i18n = plugin->getI18nManager();
map<string, string> parameters;
parameters["$command"] = commandName;
i18n->i18nMsg("error_command_not_found", parameters);
}
}
}
static ConCommand *FindAutoCompleteCommmandFromPartial( const char *partial )
{
char command[ 256 ];
Q_strncpy( command, partial, sizeof( command ) );
char *space = Q_strstr( command, " " );
if ( space )
{
*space = 0;
}
ConCommand *cmd = g_pCVar->FindCommand( command );
if ( !cmd )
return NULL;
if ( !cmd->CanAutoComplete() )
return NULL;
return cmd;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ConVar_PrintDescription( const ConCommandBase *pVar )
{
bool bMin, bMax;
float fMin, fMax;
const char *pStr;
assert( pVar );
Color clr;
clr.SetColor( 255, 100, 100, 255 );
if ( !pVar->IsCommand() )
{
ConVar *var = ( ConVar * )pVar;
const ConVar_ServerBounded *pBounded = dynamic_cast<const ConVar_ServerBounded*>( var );
bMin = var->GetMin( fMin );
bMax = var->GetMax( fMax );
const char *value = NULL;
char tempVal[ 32 ];
if ( pBounded || var->IsFlagSet( FCVAR_NEVER_AS_STRING ) )
{
value = tempVal;
int intVal = pBounded ? pBounded->GetInt() : var->GetInt();
float floatVal = pBounded ? pBounded->GetFloat() : var->GetFloat();
if ( fabs( (float)intVal - floatVal ) < 0.000001 )
{
Q_snprintf( tempVal, sizeof( tempVal ), "%d", intVal );
}
else
{
Q_snprintf( tempVal, sizeof( tempVal ), "%f", floatVal );
}
}
else
{
value = var->GetString();
}
if ( value )
{
ConColorMsg( clr, "\"%s\" = \"%s\"", var->GetName(), value );
if ( stricmp( value, var->GetDefault() ) )
{
ConMsg( " ( def. \"%s\" )", var->GetDefault() );
}
}
if ( bMin )
{
ConMsg( " min. %f", fMin );
}
if ( bMax )
{
ConMsg( " max. %f", fMax );
}
ConMsg( "\n" );
// Handled virtualized cvars.
if ( pBounded && fabs( pBounded->GetFloat() - var->GetFloat() ) > 0.0001f )
{
ConColorMsg( clr, "** NOTE: The real value is %.3f but the server has temporarily restricted it to %.3f **\n",
var->GetFloat(), pBounded->GetFloat() );
}
}
else
{
ConCommand *var = ( ConCommand * )pVar;
ConColorMsg( clr, "\"%s\"\n", var->GetName() );
}
ConVar_PrintFlags( pVar );
pStr = pVar->GetHelpText();
if ( pStr && pStr[0] )
{
ConMsg( " - %s\n", pStr );
}
}
//-----------------------------------------------------------------------------
// Purpose: rebuilds the list of possible completions from the current entered text
//-----------------------------------------------------------------------------
void CConsolePanel::RebuildCompletionList(const char *text)
{
ClearCompletionList();
// we need the length of the text for the partial string compares
int len = Q_strlen(text);
if ( len < 1 )
{
// Fill the completion list with history instead
for ( int i = 0 ; i < m_CommandHistory.Count(); i++ )
{
CHistoryItem *item = &m_CommandHistory[ i ];
CompletionItem *comp = new CompletionItem();
m_CompletionList.AddToTail( comp );
comp->m_bIsCommand = false;
comp->m_pCommand = NULL;
comp->m_pText = new CHistoryItem( *item );
}
return;
}
bool bNormalBuild = true;
// if there is a space in the text, and the command isn't of the type to know how to autocomplet, then command completion is over
const char *space = strstr( text, " " );
if ( space )
{
ConCommand *pCommand = FindAutoCompleteCommmandFromPartial( text );
if ( !pCommand )
return;
bNormalBuild = false;
CUtlVector< CUtlString > commands;
int count = pCommand->AutoCompleteSuggest( text, commands );
Assert( count <= COMMAND_COMPLETION_MAXITEMS );
int i;
for ( i = 0; i < count; i++ )
{
// match found, add to list
CompletionItem *item = new CompletionItem();
m_CompletionList.AddToTail( item );
item->m_bIsCommand = false;
item->m_pCommand = NULL;
item->m_pText = new CHistoryItem( commands[ i ].String() );
}
}
if ( bNormalBuild )
{
// look through the command list for all matches
ConCommandBase const *cmd = (ConCommandBase const *)cvar->GetCommands();
while (cmd)
{
if ( cmd->IsFlagSet( FCVAR_DEVELOPMENTONLY ) || cmd->IsFlagSet( FCVAR_HIDDEN ) )
{
cmd = cmd->GetNext();
continue;
}
if ( !strnicmp(text, cmd->GetName(), len))
{
// match found, add to list
CompletionItem *item = new CompletionItem();
m_CompletionList.AddToTail( item );
item->m_pCommand = (ConCommandBase *)cmd;
const char *tst = cmd->GetName();
if ( !cmd->IsCommand() )
{
item->m_bIsCommand = false;
ConVar *var = ( ConVar * )cmd;
ConVar_ServerBounded *pBounded = dynamic_cast<ConVar_ServerBounded*>( var );
if ( pBounded || var->IsFlagSet( FCVAR_NEVER_AS_STRING ) )
{
char strValue[512];
int intVal = pBounded ? pBounded->GetInt() : var->GetInt();
float floatVal = pBounded ? pBounded->GetFloat() : var->GetFloat();
if ( floatVal == intVal )
Q_snprintf( strValue, sizeof( strValue ), "%d", intVal );
else
Q_snprintf( strValue, sizeof( strValue ), "%f", floatVal );
item->m_pText = new CHistoryItem( var->GetName(), strValue );
}
else
{
item->m_pText = new CHistoryItem( var->GetName(), var->GetString() );
}
}
else
{
item->m_bIsCommand = true;
item->m_pText = new CHistoryItem( tst );
}
}
cmd = cmd->GetNext();
}
// Now sort the list by command name
if ( m_CompletionList.Count() >= 2 )
{
for ( int i = 0 ; i < m_CompletionList.Count(); i++ )
{
for ( int j = i + 1; j < m_CompletionList.Count(); j++ )
{
const CompletionItem *i1, *i2;
i1 = m_CompletionList[ i ];
i2 = m_CompletionList[ j ];
if ( Q_stricmp( i1->GetName(), i2->GetName() ) > 0 )
{
CompletionItem *temp = m_CompletionList[ i ];
m_CompletionList[ i ] = m_CompletionList[ j ];
m_CompletionList[ j ] = temp;
}
}
}
}
}
}
