The Console Command Manager provides a chat-driven command framework for developer, admin, player, and social commands. Players enter command text in the chat box, the command is sent to the server, parameters are resolved into useful values, and the resulting gameplay event is triggered through the Event Manager.

Use this page for the system-specific command flow, data table setup, resolver behavior, autocomplete rules, and extension points. For shared setup guidance, see the Migration Guide and Integration Guide. Use the System Atlas to look up functions, variables, events, components, and ownership references.

Related Videos

Some videos may have been recorded before V4. The principles still apply, but asset names, component names, and folder locations may differ. Treat this written page and the current V4 names as the source of truth.

• Play

• Play

Overview

The system is built around a small server-authoritative command pipeline:

Chat Box -> Communicator (RPC) -> Command Manager -> Parameter Resolvers -> Event Manager -> Command Logic

This keeps command entry simple for players while keeping command execution centralized on the server.

• Chat box input captures command text, supports history, and displays autocomplete suggestions.
• AC_PlayerController_ConsoleCommand sends the command string to the server through an RPC.
• AC_GameState_ConsoleCommandManager parses the command, looks it up in DT_Commands, resolves parameters, and triggers the configured event.
• BP_CommandString_Resolver_Abstract based resolvers convert raw string parameters into booleans, strings, floats, or gameplay tags.
• Event Manager receives the configured gameplay tag and parameter values, then dispatches the command logic.

Command Flow

For a command such as /giveitem Sword 5, the system performs the following steps:

1. The player types the command in the chat box.
2. Autocomplete checks DT_Commands for matching command aliases and parameter suggestions.
3. The player submits the command.
4. AC_PlayerController_ConsoleCommand sends the command string to the server.
5. AC_GameState_ConsoleCommandManager verifies the command prefix, splits the input by delimiter, and separates the command name from its parameters.
6. The manager finds a matching row in DT_Commands by checking the Accepted Commands array.
7. Each parameter is passed through the matching resolver, if one is configured.
8. The Event Manager receives the row’s Event Tag and the resolved values.

The command /giveitem Sword 5 is parsed as command giveitem with parameters Sword and 5. A typical setup resolves Sword through an item resolver and 5 through a float resolver before triggering an event such as Event.Triggers.Gameplay.AddItem.

Core Components

Console Command Manager Component

AC_GameState_ConsoleCommandManager lives on the GameState and owns the command parsing and dispatch flow. It is responsible for checking the command prefix, splitting the command by delimiter, looking up the command definition in DT_Commands, resolving parameters, and triggering the Event Manager.

The component exposes the command Prefix and Delimiter. The prefix identifies command text, while the delimiter separates the command name and parameters. A common setup uses / as the prefix and a space as the delimiter.

Console Command Communicator

AC_PlayerController_ConsoleCommand lives on the PlayerController and handles the client-to-server handoff. The chat box passes submitted text to this component, which sends the command to the server through an RPC. The server then passes the command string to AC_GameState_ConsoleCommandManager.

This keeps command execution server-authoritative, centralizes validation, and avoids running command logic directly on the client.

Chat Box Input

The chat box is the player-facing command entry point. It provides the text input field, command history, submit/cancel behavior, and autocomplete display.

• Enter submits the current command.
• Escape cancels or closes the input.
• Up/down arrows navigate command history.
• Tab can complete the active suggestion.

While the player types, the system checks command aliases in DT_Commands. After a command is recognized, the Command Auto Complete pattern controls parameter suggestions.

Parameter Resolvers

Parameter resolvers convert raw text into values that command logic can use. All resolvers inherit from BP_CommandString_Resolver_Abstract.

• BP_CommandString_Resolver_Item can convert an item name such as Sword into a gameplay tag or item reference used by command logic.
• BP_CommandString_Resolver_ToFloat can convert a value such as 5 into float value 5.0.
• Parameters without a resolver can be passed through as strings.
• Custom resolvers can be added by inheriting from BP_CommandString_Resolver_Abstract.

DT_Commands

DT_Commands is the command definition table. Each row defines the aliases that invoke a command, the event tag that should fire, the expected command format, autocomplete behavior, and the resolvers used for parameters.

Accepted Commands

Accepted Commands lets one command support multiple aliases. For a whisper command, the row could use [“w”, “whisper”, “private”]. The player can type /w PlayerName Message, /whisper PlayerName Message, or /private PlayerName Message, and all three can trigger the same event, such as Event.Chat.Whisper.

Aliases are useful for shorthand commands, familiar syntax from other games, and alternate naming conventions without duplicating command logic.

Event Tag

Event Tag identifies the gameplay event to trigger after the command is parsed and resolved. Example tags from the document include:

• Event.Triggers.Gameplay.AddItem
• Event.Triggers.Gameplay.RemoveItem
• Event.Chat.Whisper
• Event.Chat.Say
• Event.Admin.KickPlayer
• Event.Admin.ChangeWeather
• Event.Player.Heal
• Event.World.ChangeWeather
• Event.Inventory.AddItem

Using gameplay tag hierarchy keeps command events organized and easy to filter in Event Manager listeners.

Command Structure Description

Command Structure Description is a visual guide for the command format. Curly braces are only placeholders for display; they do not create special parsing behavior by themselves.

• /giveitem/{item}/{amount}
• /whisper/{player}/{message}
• /kick/{playername}
• /changeweather/{weathertype}

Use this field for help text, tooltips, and autocomplete guidance.

Override Minimal Parameter Amount

By default, the system expects all configured parameters to be provided. Override Minimal Parameter Amount lets a command accept fewer parameters when the event handler can supply defaults.

For /giveitem/{item}/{amount} with resolvers [Item Resolver, Float Resolver]:

• Without an override, the player must type /giveitem Sword 5.
• With Override Minimal Parameter Amount set to 1, the player can type /giveitem Sword.
• The system validates that at least one parameter was provided.
• Only the provided parameter is resolved.
• The event handler must detect the missing amount and apply a default value, such as 1.

Use this only when the event logic is designed to handle missing parameters.

Command Auto Complete

Command Auto Complete controls parameter suggestions. Use @ for parameters that should show suggestions, and use {} only as visual placeholders.

• /giveitem/@itemname can show item name suggestions.
• /whisper/@playername/{message} can show player suggestions for the first parameter while leaving the message as free text.
• @itemname, @playername, and @questname are autocomplete markers used by the system.
• Custom @ autocomplete types must be implemented by the relevant resolver or suggestion logic.

Parameter Resolvers Array

The Parameter Resolvers array matches command parameters by index. For /giveitem Sword 5:

If a parameter does not need conversion, leave that resolver entry empty or null. For example, /kick PlayerName can pass PlayerName directly as a string.

Event Manager Integration

The Console Command Manager dispatches commands through the Event Manager after parsing and parameter resolution.

The configured Event Tag is sent to the Event Manager. Event listeners registered for that tag execute the actual command behavior, such as adding an item, healing a player, changing weather, or sending a whisper.

First Parameter Handling

The first resolved parameter receives special handling. If it resolves to a gameplay tag, that gameplay tag can be used as the primary event payload. If conversion fails or no resolver exists, the raw string value can be used instead. Additional parameters are placed in the values array.

Examples:

• /giveitem Sword 5 can send the resolved item value as the first parameter and the amount in the values array.
• /heal 50 can send the heal amount through the configured float resolver.
• /whisper PlayerName Message can pass the player name and message through according to the command’s resolver setup.

Values Array

The values array contains resolved parameters that the event handler can read. Event handlers should check the array length before reading optional parameters, especially when Override Minimal Parameter Amount is used.

• Resolve each provided parameter in order.
• Store converted values in the array.
• Skip missing optional parameters.
• Let the event handler apply defaults where needed.

Configuration

Prefix and Delimiter

Configure the command Prefix and Delimiter on AC_GameState_ConsoleCommandManager.

Setting Up a Command Row

1. Open DT_Commands.
2. Add a new row for the command.
3. Add one or more aliases to Accepted Commands, such as [“giveitem”, “additem”, “give”].
4. Set the Event Tag, such as Event.Triggers.Gameplay.AddItem.
5. Set Command Structure Description, such as /giveitem/{item}/{amount}.
6. Set Override Minimal Parameter Amount only if the event handler supports optional parameters.
7. Set Command Auto Complete, such as /giveitem/@itemname.
8. Add Parameter Resolvers in parameter order, such as [BP_CommandString_Resolver_Item, BP_CommandString_Resolver_ToFloat].
9. Save DT_Commands.

How-to Guides

Create a New Command

This example creates a heal command.

1. Open DT_Commands.
2. Add a row named Heal.
3. Set Accepted Commands to [“heal”, “h”].
4. Set Event Tag to Event.Player.Heal.
5. Set Command Structure Description to /heal/{amount}.
6. Set Command Auto Complete to /heal.
7. Set Parameter Resolvers to [BP_CommandString_Resolver_ToFloat].
8. Save DT_Commands.
9. Create or update an Event Manager listener for Event.Player.Heal.
10. Test with /heal 50.

Create a Custom Parameter Resolver

1. Create a resolver Blueprint that inherits from BP_CommandString_Resolver_Abstract.
2. Implement the conversion logic for the incoming string value.
3. Return the appropriate value type, such as boolean, string, float, or gameplay tag.
4. If the resolver supports autocomplete, implement suggestion logic that returns valid values.
5. Assign the resolver in the matching DT_Commands row.

Custom @ tag autocompletion must be programmed for the resolver or the related suggestion system.

Add Command Aliases

To add aliases, edit the row’s Accepted Commands array. For a whisper command, use aliases such as [“w”, “whisper”, “private”]. Keep the same Event Tag so all aliases reach the same command implementation.

Autocomplete can still show suggestions regardless of which alias the player starts typing.

Handle Optional Parameters

This example allows /giveitem Sword and /giveitem Sword 5 to use the same command row.

1. Open DT_Commands.
2. Set Accepted Commands to [“giveitem”, “give”].
3. Set Event Tag to Event.Inventory.AddItem.
4. Set Command Structure Description to /giveitem/{item}/{amount}.
5. Set Override Minimal Parameter Amount to 1.
6. Set Command Auto Complete to /giveitem/@itemname.
7. Set Parameter Resolvers to [BP_CommandString_Resolver_Item, BP_CommandString_Resolver_ToFloat].
8. In the event handler, check whether the amount parameter exists.
9. If the amount is missing, apply a default amount.
10. Test both /giveitem Sword and /giveitem Sword 5.

For commands with multiple optional parameters, such as /teleport/{x}/{y}/{z}, the event handler must check ValuesArray.Length before reading each value and apply defaults for missing parameters.

Summary

The Console Command Manager turns chat input into server-authoritative gameplay events. DT_Commands defines command aliases, event tags, display formats, autocomplete patterns, optional parameter behavior, and resolver mappings. Parameter resolvers keep command input flexible while allowing gameplay logic to receive typed values instead of raw text.

The main extension points are new DT_Commands rows, new Event Manager listeners, and custom BP_CommandString_Resolver_Abstract implementations.