Register a new console command.

Parameters

sCommand	Command name.
func	Pointer to the console command function to be called when command is invoked.
nFlags	Bitfield consisting of VF_ flags (e.g. VF_CHEAT).
sHelp	Help string, will be displayed when typing in console "command ?".

#include 

// The function that will be executed with the command
void MyCommand(IConsoleCmdArgs* pArgs)
{
    // The first argument is always the name of the command
    const char* szCommand = pArgs->GetArg(0);
    if (pArgs->GetArgCount() > 1)
    {
        // Get the first argument, if any
        const char* szFirstArgument = pArgs->GetArg(1);

        /* Handle the command, and its argument here */
    }
}

void RegisterCommand()
{
    // Specify bit flags that define the CCommand's behavior, see EVarFlags
    const int variableFlags = VF_NULL;

    // Register the command in the console
    REGISTER_COMMAND("myCommand", MyCommand, variableFlags, "Executes the MyCommand function!");
}

void UnregisterCommand()
{
    // Make sure to unregister the command once we are done
    gEnv->pConsole->RemoveCommand("myCommand");
}

void ExecuteCommand()
{
    // Do not silence execution of the command from logs
    const bool silent = false;
    // Execute the command immediately, instead of the next frame
    const bool deferExecution = false;

    gEnv->pConsole->ExecuteString("myCommand", silent, deferExecution);
}

Register a new console command that execute script function. EG "Game.Connect(%1)" the symbol "%1" will be replaced with the command parameter 1 writing in the console "connect 127.0.0.1" will invoke Game.Connect("127.0.0.1").

Parameters

sCommand	Command name.
sScriptFunc	Script function to be executed when command is invoked.
nFlags	Bitfield consist of VF_ flags (e.g. VF_CHEAT).
sHelp	Help string, will be displayed when typing in console "command ?".

#include 

// The function that will be executed with the command
void MyCommand(IConsoleCmdArgs* pArgs)
{
    // The first argument is always the name of the command
    const char* szCommand = pArgs->GetArg(0);
    if (pArgs->GetArgCount() > 1)
    {
        // Get the first argument, if any
        const char* szFirstArgument = pArgs->GetArg(1);

        /* Handle the command, and its argument here */
    }
}

void RegisterCommand()
{
    // Specify bit flags that define the CCommand's behavior, see EVarFlags
    const int variableFlags = VF_NULL;

    // Register the command in the console
    REGISTER_COMMAND("myCommand", MyCommand, variableFlags, "Executes the MyCommand function!");
}

void UnregisterCommand()
{
    // Make sure to unregister the command once we are done
    gEnv->pConsole->RemoveCommand("myCommand");
}

void ExecuteCommand()
{
    // Do not silence execution of the command from logs
    const bool silent = false;
    // Execute the command immediately, instead of the next frame
    const bool deferExecution = false;

    gEnv->pConsole->ExecuteString("myCommand", silent, deferExecution);
}

Parameters

szCommand

Must not be 0.

Console variable sink. Adds a new console variables sink callback.

Add output sink (clases which are interested in the output) - order is not guaranteed.

Parameters

inpSink

Must not be 0 and is not allowed to be added twice.

Bind a console command to a key.

Parameters

sCmd	console command that must be executed.
sRes	name of the key to invoke the command.

Dump all console-variables to a callback-interface.

Parameters

Callback

Callback-interface which needs to be called for each element.

Dump all key bindings to a callback-interface.

Parameters

Callback

callback-interface which needs to be called for each element.

Enable or disable the activation key (tilde by default). This is useful when user is in a text field and want to be able to enter the default key.

Parameters

BEnable

If true, console will show.

Execute a string in the console.

Parameters

command	Console command e.g. "map testy" - no leading slash
bSilentMode	true=suppresses log in error case and logging the command to the console
bDeferExecution	true=the command is stored in special fifo that allows delayed execution by using wait_seconds and wait_frames commands

#include 

// The function that will be executed with the command
void MyCommand(IConsoleCmdArgs* pArgs)
{
    // The first argument is always the name of the command
    const char* szCommand = pArgs->GetArg(0);
    if (pArgs->GetArgCount() > 1)
    {
        // Get the first argument, if any
        const char* szFirstArgument = pArgs->GetArg(1);

        /* Handle the command, and its argument here */
    }
}

void RegisterCommand()
{
    // Specify bit flags that define the CCommand's behavior, see EVarFlags
    const int variableFlags = VF_NULL;

    // Register the command in the console
    REGISTER_COMMAND("myCommand", MyCommand, variableFlags, "Executes the MyCommand function!");
}

void UnregisterCommand()
{
    // Make sure to unregister the command once we are done
    gEnv->pConsole->RemoveCommand("myCommand");
}

void ExecuteCommand()
{
    // Do not silence execution of the command from logs
    const bool silent = false;
    // Execute the command immediately, instead of the next frame
    const bool deferExecution = false;

    gEnv->pConsole->ExecuteString("myCommand", silent, deferExecution);
}

Print a message into the log and abort the execution of the application.

Parameters

message

error string to print in the log.

Retrieve a console variable by name - not case sensitive.

Parameters

name	variable name.

Returns

a pointer to the ICVar interface, NULL if is not found.

See also

ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Parameters

bUpOrDown

true=after pressed "up", false=after pressed "down".

Returns

0 if there is no history line or pointer to the null terminated history line.

Retrieves the background-image.

Returns

background-image.

Returns

Current number of lines in the console.

Iterate through the lines - used for dedicated server (truncated if needed).

Parameters

indwLineNo	0.. counted from the last printed line on.
outszBuffer	Pointer to the destination string buffer (zero terminated afterwards), must not be 0.
indwBufferSize	1.. size of the buffer.

Returns

true if line was returned, false=there are no more lines.

Parameters

szPrefix

- 0 or prefix e.g. "sys_spec_".

Returns

Used size. nListType = 0 get all values, nListTypes=1 return only cvars, nListTypes=2 return only console commands

Retrieve the status of the console (active/not active).

Returns

the variable value(true = active/false = not active).

Read a value from a configuration file (.ini) and return the value.

Parameters

szVarName	Variable name.
szFileName	Source configuration file.
def_val	Default value (if the variable is not found into the file).

Returns

The variable value.

Read a value from a configuration file (.ini) and return the value.

Parameters

szVarName	variable name.
szFileName	source configuration file.
def_val	default value (if the variable is not found into the file).

Returns

the variable value.

Return true if the console is opened.

Returns

the variable value(true = opened/false = closed).

Executes a command with optional arguments Will defer setting of the value until the command is registered if it hasn't been already

Sets the value of a CVar as loaded from a config Will defer setting of the value until the CVar is registered if it hasn't been already

Print a string in the console and go to the new line.

Parameters

s	The string to print.

Append a string in the last console line.

Parameters

s	The string to print.

Create a new console variable that will update the user defined float.

Parameters

sName	Console variable name.
src	Pointer to the memory that will be updated.
nFlags	User defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
help	Help text that is shown when you use " ?" in the console.
allowModify	Allow modification through config vars, prevents missing modifications in release mode.

Returns

pointer to the interface ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Create a new console variable that will update the user defined float.

Parameters

sName	Console variable name.
src	Pointer to the memory that will be updated.
nFlags	User defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
help	Help text that is shown when you use " ?" in the console.
allowModify	Allow modification through config vars, prevents missing modifications in release mode.

Returns

pointer to the interface ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Create a new console variable that will update the user defined float.

Parameters

sName	Console variable name.
src	Pointer to the memory that will be updated.
nFlags	User defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
help	Help text that is shown when you use " ?" in the console.
allowModify	Allow modification through config vars, prevents missing modifications in release mode.

Returns

pointer to the interface ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Registers an existing console variable. Should only be used with static duration objects, object is never freed.

Parameters

pVar	The existing console variable.

Returns

Pointer to the interface ICVar (that was passed in)

Create a new console variable that store the value in a float.

Parameters

sName	Console variable name.
fValue	Default value.
nFlags	User defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
help	help text that is shown when you use " ?" in the console.

Returns

Pointer to the interface ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Create a new console variable that store the value in a int.

Parameters

sName	Console variable name.
iValue	Default value.
nFlags	User defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
Help	help text that is shown when you use " ?" in the console.

Returns

Pointer to the interface ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Create a new console variable that store the value in a int64.

Parameters

sName	Console variable name.
iValue	Default value.
nFlags	Her defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
help	- help text that is shown when you use " ?" in the console.

Returns

Pointer to the interface ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};

Create a new console variable that store the value in a string.

Parameters

sName	Console variable name.
sValue	Default value.
nFlags	User defined flag, this parameter is used by other subsystems and doesn't affect the console variable (basically of user data).
help	Help text that is shown when you use " ?" in the console.

Returns

Pointer to the interface ICVar.

Removes a console command which was previously registered with AddCommand.

Parameters

sCommand

Command name.

#include 

// The function that will be executed with the command
void MyCommand(IConsoleCmdArgs* pArgs)
{
    // The first argument is always the name of the command
    const char* szCommand = pArgs->GetArg(0);
    if (pArgs->GetArgCount() > 1)
    {
        // Get the first argument, if any
        const char* szFirstArgument = pArgs->GetArg(1);

        /* Handle the command, and its argument here */
    }
}

void RegisterCommand()
{
    // Specify bit flags that define the CCommand's behavior, see EVarFlags
    const int variableFlags = VF_NULL;

    // Register the command in the console
    REGISTER_COMMAND("myCommand", MyCommand, variableFlags, "Executes the MyCommand function!");
}

void UnregisterCommand()
{
    // Make sure to unregister the command once we are done
    gEnv->pConsole->RemoveCommand("myCommand");
}

void ExecuteCommand()
{
    // Do not silence execution of the command from logs
    const bool silent = false;
    // Execute the command immediately, instead of the next frame
    const bool deferExecution = false;

    gEnv->pConsole->ExecuteString("myCommand", silent, deferExecution);
}

Remove output sink (clases which are interested in the output) - order is not guaranteed.

Parameters

inpSink

Must not be 0 and has to be added before.

Sets the background-image.

Parameters

pImage

background-image.

Parameters

szLine

Must not be 0.

Sets the loading-background-image.

Parameters

pImage

Background image.

Set the y coordinate where the console will stop to scroll when is dropped.

Parameters

value

Y in screen coordinates.

Show/hide the console.

Parameters

specifies	if the window must be (true=show,false=hide).
specifies	iRequestScrollMax <=0 if not used, otherwise it sets SetScrollMax temporary to the given value.

Sets static/scroll background-mode.

Parameters

bStatic

true if static.

Remove a variable from the console.

Parameters

sVarName	Console variable name.
bDelete	If true, the variable is deleted.

See also

ICVar.

#include 

// Minimal example of how a console variable can be implemented and used
// In this case we create a system, and a variable that determines whether or not the system should be currently updated
class CMySystem
{
    CMySystem()
    {
        // Specify bit flags that define the CVar's behavior, see EVarFlags
        const int variableFlags = VF_NULL;

        // Register the "g_mySystem_enable" command into the console, allowing modification by designers and code at run-time
        REGISTER_CVAR2("g_mySystem_enable", &m_enabled, m_enabled, variableFlags, "Determines whether or not the system should run");

        // Retrieve an ICVar instance for the variable from the console
        ICVar* pCVar = gEnv->pConsole->GetCVar("g_mySystem_enable");
        /* If necessary, utilize pCVar here */
    }

    ~CMySystem()
    {
        // Make sure to unregister the variable once we go out of scope
        gEnv->pConsole->UnregisterVariable("g_mySystem_enable");
    }

    void Update()
    {
        // If the system was disabled via the console, skip update
        if (m_enabled == 0)
        {
            return;
        }

        /* Update system here */
    }

protected:
    // Store the variable locally here, the console takes a reference that will update the variable in place
    // We start off by setting this value to 1.
    int m_enabled = 1;
};