The general pattern is to subclass CommandScript, override the GetCommands function, and provide a top-level function which calls the constructor. You may also want to define permissions to use the command, so that is included below as well.

Choose a prefix for your command

For the remaining code examples, I'll be using my.

Add new permission

In src/server/game/Accounts/RBAC.h, you'll find enum RBACPermissions. This contains all of the permissions defined for the RBAC system. At the end, you can add your custom permissions (starting at enum value 1000, use a higher value if appropriate). Add RBAC_PERM_COMMAND_MY here, before RBAC_PERM_MAX.

enum RBACPermissions
{
    // ... lots of permissions
    //                                                                                               
    // IF YOU ADD NEW PERMISSIONS, ADD THEM IN MASTER BRANCH AS WELL!                                
    //                                                                                               
    // custom permissions 1000+                                                                      
    RBAC_PERM_COMMAND_MY                                     = 1000,
    RBAC_PERM_MAX
};

Add entrypoint to cs_script_loader.cpp

In src/server/scripts/Commands/cs_script_loader.cpp, define a top-level function called AddSC_my_commandscript.

void AddSC_my_commandscript();

Call the entrypoint in cs_script_loader.cpp

At the end of the file, there's a function called AddCommandsScripts(). Call the entrypoint at the bottom of the function

void AddCommandsScripts()
{
    // other entrypoints
    AddSC_my_commandscript();
}

Create the new CommandScript

Create a new file in src/server/scripts/Commands called cs_my.cpp.

Create the CommandScript class

In cs_my.cpp, create a new class called my_commandscript, which is a subclass of CommandScript, having a public constructor, and overriding the GetCommands function. This example uses the new way of providing command functionality, so you'll also need to use the Trinity::ChatCommands namespace.

In the constructor, call the base constructor, passing in the name of the class.

#include "Chat.h"

using namespace Trinity::ChatCommands;

class my_commandscript : public CommandScript
{
public:
    my_commandscript() : CommandScript("my_commandscript") { }

    ChatCommandTable GetCommands() const override
    {
        // Coming next
    }
};

Create the ChatCommandTable and Handler

GetCommands() needs to return a ChatCommandTable. Each command is defined by a name, TypedHandler, RBAC permissions, and whether it is exposed to the Console. The TypedHandler function needs to return a boolean value, so we'll return true for now.

    ChatCommandTable GetCommands() const override
    {
        static ChatCommandTable myCommandTable =
        {
            { "my", HandleMyCommand, rbac::RBAC_PERM_COMMAND_MY, Console::Yes }
        };
        return myCommandTable;
    }

    static bool HandleMyCommand(ChatHandler* handler)
    {
        return true;
    }

Implement HandleMyCommand

For this simple Hello world example, we'll just log something to the console. This will require us to include Log.h in order to use TC_LOG_INFO.

// top of file
#include "Chat.h"
#include "Log.h"

    // in my_commandscript
    static bool HandleMyCommand(ChatHandler* handler)
    {
        TC_LOG_INFO("server", "Hello world from my command.");
        return true;
    }

Provide the implementation of the entrypoint

After the class, provide the implementation of the entrypoint declared in cs_script_loader.cpp

class my_commandscript : public CommandScript
{
    // ...
}

void AddSC_my_commandscript()
{
    new my_commandscript();
}

Compile

From the root of the repo, run the command you used when you set up the server initially (for example, Compiling the source code from the Linux guide)

cmake ../ -DCMAKE_INSTALL_PREFIX=/home/username/server
make
make install

Start the worldserver, and test the command

Start your worldserver, and you'll be presented with the TC CLI. Run .help and you should see the my command in the list

TC> .help
TC> Commands available to you:
...
|- my
...

Then just run .my and see Hello world printed to the console.

TC> .my
TC> Hello world from my command.
TC> 

Coming soon:

• Command arguments
• Nested commands
• Maybe migrating from the old style to the new?
• Advanced: Tail arg
• Effects in the world