Console Command Manager #

• Overview
• Core Concepts
  • What Is the Console Command System?
  • How It Works
  • Key Components
• Components
  • Console Command Manager Component
  • Console Command Communicator
  • Chat Box Input
  • Parameter Resolvers
• DT_Commands
  • Structure
  • Accepted Commands
  • Event Tag
  • Command Structure Description
  • Override Minimal Parameter Amount
  • Command Auto Complete
  • Parameter Resolvers Array
• Parameter Resolvers
  • What Are Parameter Resolvers?
  • How Resolvers Work
  • Creating Custom Resolvers
• Command Execution Flow
  • Input to Server RPC
  • Command Parsing
  • Parameter Resolution
  • Event Triggering
• Autocompletion
  • Command Autocompletion
  • Parameter Autocompletion
• Event Manager Integration
  • Event Tag Conversion
  • First Parameter Handling
  • Values Array
• Configuration
  • Prefix and Delimiter
  • Setting Up Commands
• How To Guides
  • Creating a New Command
  • Creating a Custom Parameter Resolver
  • Adding Command Aliases
  • Handling Optional Parameters
• OVERVIEW

This documentation explains the Console Command System, which allows players to execute commands through a chat box interface with autocompletion, parameter resolvers, and event-driven execution.

What Is the Console Command System?:

The Console Command System is a flexible command execution framework that processes text commands entered in a chat box, resolves parameters to typed values, and triggers events through the Event Manager.

Key Features:

• ✅ Chat Box Input: Text input interface for entering commands
• ✅ Server RPC: Commands sent to server via Console Command Communicator
• ✅ DT_Commands: Data table defining all commands and their configuration
• ✅ Command Aliases: Multiple command strings for same functionality (e.g., /w, /whisper, /private)
• ✅ Parameter Resolvers: Convert input strings to typed values (gameplay tags, booleans, floats, strings)
• ✅ Autocompletion: Smart command and parameter suggestions using @ syntax
• ✅ Event Manager Integration: Commands trigger events using Event Manager
• ✅ Customizable Prefix/Delimiter: Configurable in Console Command Manager component
• ✅ Optional Parameters: Support for default values when parameters not provided

Use Cases:

• Developer commands (change gravity, show FPS, debug tools)
• Admin commands (change weather, give items, manage server)
• Player commands (whisper messages, invite to party, use items)
• Social commands (kick from team, send messages)

Core concepts #

What Is the Console Command System? #

The Console Command System provides a command-line interface for executing game commands with parameter resolution, autocompletion, and event-driven execution.

Core Flow:

1. Player types command in chat box (e.g., “/giveitem Sword 5”)
2. Autocompletion suggests commands and parameters
3. Player presses Enter
4. Console Command Communicator sends Server RPC
5. Console Command Manager receives and parses command
6. Parameter Resolvers convert strings to typed values
7. Event Manager receives event with converted parameters
8. Event executes command logic
9. Command complete

System Flow:

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

How It Works #

Command Execution Process:

Step 1 – Input: #

• Player types in chat box
• Autocompletion shows matching commands
• Parameter suggestions show based on @ tags

Step 2 – Server RPC: #

• Console Command Communicator sends command to server
• Server receives command string

Step 3 – Parsing: #

• Prefix: “/” (identifies this as command)
• Delimiter: ” ” (space separates parts)
• Command: “giveitem”
• Parameters: [“Sword”, “5”]

Step 4 – Command Lookup: #

• Find “giveitem” in DT_Commands “Accepted Commands” array
• Get associated Event Tag (e.g., Event.Triggers.Gameplay.AddItem)

Step 5 – Parameter Resolution: #

• Parameter 1 “Sword” → Resolver converts to gameplay tag
• Parameter 2 “5” → Resolver converts to float
• Results stored in values array

Step 6 – Event Trigger: #

• Event Manager receives Event Tag
• First parameter: Gameplay tag (if conversion succeeded) OR string (if failed)
• Additional parameters: Values array
• Event executes: Add item to player inventory

Step 7 – Complete #

• Command processed

Key Components #

Chat Box Input:

• Text input field for commands
• Autocompletion dropdown
• Enter to execute

Console Command Communicator:

• Handles Server RPC
• Sends command string to server
• Client-to-server communication

Console Command Manager Component (AC_GameState_ConsoleCommandManager_Advanced):

• Parses command string using prefix/delimiter
• Looks up command in DT_Commands
• Calls parameter resolvers
• Triggers events via Event Manager
• Configurable prefix and delimiter

Console Command Communicator (AC_PlayerController_ConsoleCommand):

• Handles Server RPC
• Sends command string to server
• Client-to-server communication

Parameter Resolvers:

• Inherit from BP_CommandString_Resolver_Abstract
• Convert string arguments to typed values
• Return: Boolean, String, Float, or Gameplay Tag
• Custom resolvers can be created

DT_Commands:

• Data table defining all commands
• Accepted Commands (array of command aliases)
• Event Tag (gameplay tag for Event Manager)
• Command Structure Description
• Parameter Resolvers array
• Autocompletion configuration

---

Components #

Console Command Manager Component #

Component Name: AC_GameState_ConsoleCommandManager_Advanced

Component Location: GameState

Purpose: Parses commands, resolves parameters, and triggers events.

Configuration Properties:

• Prefix: Character that identifies a command (configurable)
• Delimiter: Character that separates command parts (configurable)

Key Functions:

Parse Command:

Input: “/giveitem Sword 5”

Process:

1. Check if starts with prefix (“/”)
2. Remove prefix → “giveitem Sword 5”
3. Split by delimiter (space) → [“giveitem”, “Sword”, “5”]
4. Command = “giveitem”
5. Arguments = [“Sword”, “5”]

Lookup Command:

Input: Command string “giveitem”

Process:

1. Search DT_Commands for row where “Accepted Commands” array contains “giveitem”
2. If found → Get Event Tag and Parameter Resolvers
3. If not found → Command not recognized

Resolve Parameters:

Input: Arguments array, Parameter Resolvers array

Process:

1. For each argument and corresponding resolver:

 - Call resolver with argument string
 - Resolver returns typed value (bool, string, float, or gameplay tag)
 - Store resolved value in array

1. Return array of resolved values

Trigger Event:

Input: Event Tag, Resolved parameters

Process:

1. First parameter handling (special case – see section 8.2)
2. Additional parameters go into values array
3. Use Event Manager to trigger event
4. Event listeners execute command logic

Console Command Communicator #

Component Name: AC_PlayerController_ConsoleCommand

Component Location: PlayerController

Purpose: Handles client-to-server communication for commands.

How It Works:

Client Side:

1. Player enters command in chat box
2. AC_PlayerController_ConsoleCommand receives input
3. Sends Server RPC with command string

Server Side:

1. Server receives RPC
2. Passes command to AC_GameState_ConsoleCommandManager_Advanced
3. Command Manager processes command

Why Server RPC:

• Commands executed on server for authority
• Prevents client-side cheating
• Centralized command processing
• Server validates and executes

Chat Box Input #

Purpose: Text input interface for entering commands with autocompletion.

Functionality:

Input Field:

Chat box features:

• Text input field
• Command history (up/down arrows)
• Enter to submit command
• Escape to cancel/close

Autocompletion:

As player types:

1. System checks DT_Commands “Accepted Commands” for matches
2. Shows dropdown with matching commands
3. Player can select from dropdown or continue typing
4. Tab to autocomplete current suggestion

Parameter Suggestions:

After command typed:

1. System checks Command Auto Complete for @ tags
2. Shows suggestions for current parameter
3. Example: “@itemname” shows all item names
4. Player selects or continues typing

Parameter Resolvers #

Purpose: Convert string arguments to typed values.

Base Class: BP_CommandString_Resolver_Abstract

All Resolvers Inherit From:

• BP_CommandString_Resolver_Abstract

Resolver Types:

• Can return: Boolean, String, Float, or Gameplay Tag
• Custom resolvers inherit from abstract base
• Each resolver implements conversion logic

How Resolvers Are Used:

Process:

1. AC_GameState_ConsoleCommandManager_Advanced gets resolver from DT_Commands
2. Calls resolver with string argument
3. Resolver converts string to typed value
4. Returns converted value to manager
5. Manager stores in values array

---

4 dt_commands #

Purpose: Defines all available commands with their configuration.

Structure #

DT_Commands Fields:

Accepted Commands (Array of Strings):

Purpose: All command aliases that trigger this command

Usage: Player can type “/giveitem” OR “/additem” OR “/give”

Result: All trigger the same Event Tag

Why Multiple Commands:

• Different players prefer different syntax
• Shorthand versions (“/w” vs “/whisper”)
• Compatibility with different conventions

Event Tag (Gameplay Tag):

Purpose: Event triggered in Event Manager when command executes

Usage: This tag is sent to Event Manager

Result: Event listeners respond to this tag

Command Structure Description (String):

Purpose: Shows command format with parameters

Format: Use {} to indicate parameters

Usage: Displayed in help/autocomplete

Override Minimal Parameter Amount (Integer):

Purpose: Set custom minimum parameter count (optional)

Default Behavior: All parameters must be provided

Override Use Case: Allow missing parameters with defaults

• Command: /giveitem/{item}/{amount}
• Normal: Both item AND amount required
• Override to 1: Only item required, amount optional
• Result: “/giveitem Sword” works, amount defaults in event handler

When to Use:

• Commands with optional parameters
• Default values handled in event logic
• Flexible parameter counts

How It Works:

• System checks parameter count >= Override value
• Missing parameters NOT passed to resolvers
• Event handler must handle missing parameters

Command Auto Complete (String):

Purpose: Defines autocompletion for parameters

Format: Use @ symbol to indicate autocomplete type

Usage: When player types parameter, system shows suggestions

How It Works:

1. Player types command: “/giveitem “
2. System sees “@itemname” in Auto Complete
3. Calls corresponding resolver for suggestions
4. Shows dropdown with item names

• @ tags trigger parameter autocompletion
• Examples: @itemname, @playername, @questname
• Custom @ tags must be programmed yourself

Parameter Resolvers (Array of Object References):

Purpose: Resolvers to convert each parameter

Usage: Index matches parameter index

• Parameters: {item}, {amount}
• Resolvers: [Item Resolver, Float Resolver]
• Parameter 1 “Sword” → Item Resolver → Gameplay Tag
• Parameter 2 “5” → Float Resolver → Float value 5.0

If No Resolver Needed:

• Leave array element empty/null
• Parameter passed as string directly

Accepted Commands #

Command Aliases:

Purpose: Multiple command strings for same functionality

Accepted Commands: [“w”, “whisper”, “private”]

Event Tag: Event.Chat.Whisper

Player can type:

• “/w PlayerName Message”

- "/whisper PlayerName Message"

• “/private PlayerName Message”

All execute same logic, all trigger Event.Chat.Whisper

Why Use Aliases:

Convenience:

• Short versions: “/w” faster than “/whisper”
• Familiar syntax: Players from different games
• Compatibility: Support multiple conventions

Management:

• Event Tag groups all aliases
• One implementation for all variations
• Easy to add new aliases without code changes

Event Tag #

Purpose: Gameplay tag that identifies the command type in Event Manager.

How Event Tags Work:

Command Definition:

• Accepted Commands: [“giveitem”, “additem”]
• Event Tag: Event.Triggers.Gameplay.AddItem

Execution:

1. Player types “/giveitem Sword 5”
2. System finds “giveitem” in Accepted Commands
3. Gets Event Tag: Event.Triggers.Gameplay.AddItem
4. Triggers event with this tag in Event Manager
5. Event listeners registered to this tag respond

Event Tag Structure:

Use gameplay tag hierarchy for organization:

Event.Triggers.Gameplay.AddItem

Event.Triggers.Gameplay.RemoveItem

Event.Chat.Whisper

Event.Chat.Say

Event.Admin.KickPlayer

Event.Admin.ChangeWeather

• Easy to filter by category
• Clear organization
• Event Manager integration

Command Structure Description #

Purpose: Visual representation of command format.

Format:

Use {} to indicate parameters

“/giveitem/{item}/{amount}”

“/whisper/{player}/{message}”

“/kick/{playername}”

“/changeweather/{weathertype}”

Display:

• Shown in help text
• Shown in autocomplete tooltip
• Visual guide for players

• The {} are just visual indicators
• No special parsing of {}
• Just shows what parameters are needed

Override Minimal Parameter Amount #

Purpose: Allow commands with optional parameters.

How It Works:

Normal Behavior:

• Command: /giveitem/{item}/{amount}
• Parameter Resolvers: [Item, Float] (2 resolvers)
• System expects: 2 parameters
• Player must type: “/giveitem Sword 5”

With Override = 1:

• Command: /giveitem/{item}/{amount}
• Override Minimal Parameter Amount: 1
• System expects: At least 1 parameter
• Player can type: “/giveitem Sword” (amount missing)
• System only validates: 1 parameter provided
• Only calls: First resolver (Item)
• Missing parameter: NOT resolved, must handle in event

Event Handler Must:

1. Check if amount parameter exists
2. If missing, use default (e.g., 1)
3. Execute logic with default value

Configuration:

• Accepted Commands: [“giveitem”]
• Parameter Resolvers: [Item Resolver, Float Resolver]
• Override Minimal Parameter Amount: 1

Usage:

“/giveitem Sword” → Only item resolved, amount missing

“/giveitem Sword 5” → Both item and amount resolved

Event Handler:

1. Receive event
2. Check values array length
3. If length = 1: amount = 1 (default)
4. If length = 2: amount = values[1]
5. Add item with amount

Command Auto Complete #

Purpose: Enables parameter autocompletion.

@ Syntax:

Use @ to indicate autocomplete type

Command Auto Complete: “/giveitem/@itemname”

How It Works:

1. Player types: “/giveitem “
2. System parses Auto Complete string
3. Finds: “@itemname”
4. Calls: Item resolver's suggestion function
5. Shows: Dropdown with all item names
6. Player: Selects or continues typing

Multiple Parameters:

Command Auto Complete: “/whisper/@playername/{message}”

Autocompletion:

• First parameter: @playername → Shows player names
• Second parameter: {message} → No autocomplete (just shows format)

Only @ triggers autocomplete

{} just shows parameter placeholder

@ tags enable parameter autocompletion (e.g., @itemname, @playername).

Custom @ tags must be programmed yourself.

Parameter Resolvers Array #

Purpose: Defines how to convert each parameter.

Structure:

Array of Object References to resolver blueprints

Index 0: BP_CommandString_Resolver_Item

Index 1: BP_CommandString_Resolver_ToFloat

Index 2: (empty/null if no resolver needed)

Mapping:

• Index matches parameter position
• Parameter 1 → Resolvers[0]
• Parameter 2 → Resolvers[1]
• Etc.

Command: “/giveitem Sword 5”

Parameters: [“Sword”, “5”]

Resolvers: [BP_CommandString_Resolver_Item, BP_CommandString_Resolver_ToFloat]

Resolution:

1. “Sword” → Resolvers[0] (Item Resolver)

 → Returns gameplay tag

1. “5” → Resolvers[1] (Float Resolver)

 → Returns float 5.0

No Resolver Needed:

Some parameters don't need conversion

Command: “/kick PlayerName”

Parameters: [“PlayerName”]

Resolvers: [(empty/null)]

Result:

• “PlayerName” passed as string directly
• No conversion needed
• Event receives string value

---

Parameter resolvers #

What Are Parameter Resolvers? #

Purpose: Convert string input to typed values that other systems understand.

Base Class: BP_CommandString_Resolver_Abstract

All Parameter Resolvers:

• Inherit from BP_CommandString_Resolver_Abstract
• Convert string argument to typed value
• Return: Boolean, String, Float, or Gameplay Tag

Why Resolvers Are Needed:

Without Resolver:

• Player types: “/giveitem Sword”
• System receives: String “Sword”
• Problem: Inventory System needs gameplay tag
• Result: Cannot find item

With Resolver:

• Player types: “/giveitem Sword”
• Item Resolver: “Sword” → Item.Weapon.Sword (gameplay tag)
• Inventory System receives: Item.Weapon.Sword
• Result: Item added successfully

When Resolvers Are NOT Needed:

Some parameters use string directly:

• Player types: “/kick JohnDoe”
• Team Manager needs: String “JohnDoe”
• No resolver: String used directly
• Result: Finds player by name string

How Resolvers Work #

Resolver Implementation:

All resolvers inherit from: BP_CommandString_Resolver_Abstract

Resolvers must implement:

• Convert string to typed value
• Return one of: Boolean, String, Float, or Gameplay Tag
• (Optional) Provide suggestions for autocompletion

Conversion Process:

Input: String “Sword”

Process:

1. Look up “Sword” in DT_Items
2. Find item with matching name
3. Get item's gameplay tag: Item.Weapon.Sword
4. Return gameplay tag value

Output: Gameplay Tag (Item.Weapon.Sword)

Input: String “5”

Process:

1. Parse string to float
2. Convert “5” → 5.0
3. Return float value

Output: Float (5.0)

Resolver Return Types:

Resolvers can return:

1. Boolean:

 - Example: "true" → True
 - Use for: Flags, toggles

1. String:

 - Example: "PlayerName" → "PlayerName"
 - Use for: Names, text input

1. Float:

 - Example: "5.5" → 5.5
 - Use for: Numbers, amounts, values

1. Gameplay Tag:

 - Example: "Sword" → Item.Weapon.Sword
 - Use for: Items, quests, weather, any tag-based system

Creating Custom Resolvers #

Step 1 – Create Resolver Blueprint: #

1. Create new blueprint
2. Parent class: BP_CommandString_Resolver_Abstract
3. Name: BP_CommandString_Resolver_YourType

Step 2 – Implement Conversion Logic: #

Override/Implement conversion function:

Input: String argument

Output: Converted value (bool, string, float, or gameplay tag)

1. Input: “DefeatGoblins”
2. Look up quest in DT_Quests where name = “DefeatGoblins”
3. If found:

 - Get quest gameplay tag: Quest.Main.DefeatGoblins
 - Return gameplay tag

1. If not found:

 - Return error or empty value

Step 3 – Implement Suggestions (Optional): #

For autocompletion support (if using @ tags):

Implement suggestion function that returns array of valid values.

Step 4 – Use in DT_Commands: #

Add resolver to command:

1. Open DT_Commands
2. Find your command row
3. In Parameter Resolvers array:

 - Add reference to your resolver blueprint
 - Position in array = parameter index

1. Save

---

Command execution flow #

Input to Server RPC #

Client Side:

Step 1 – Player Input: #

• Player types command in chat box
• Example: “/giveitem Sword 5”
• Presses Enter

Step 2 – Console Command Communicator: #

• Receives input from chat box
• Creates Server RPC with command string
• Sends to server

Why Server RPC:

• Commands executed on server for authority
• Prevents client-side manipulation
• Server validates all commands
• Centralized processing

Server Side:

Step 3 – Server Receives: #

• Server RPC received
• Command string passed to AC_GameState_ConsoleCommandManager_Advanced
• Manager begins processing

Command Parsing #

Parsing Steps:

Step 1 – Check Prefix: #

• Check if starts with prefix (configurable)
• “/giveitem Sword 5” → Yes, starts with “/”
• Is command, continue processing

Step 2 – Remove Prefix: #

• Remove prefix from string
• “/giveitem Sword 5” → “giveitem Sword 5”

Step 3 – Split by Delimiter: #

• Delimiter (configurable)
• Split: [“giveitem”, “Sword”, “5”]

Step 4 – Extract Parts: #

• Command string: “giveitem”
• Arguments: [“Sword”, “5”]

Command Lookup:

Step 5 – Find in DT_Commands: #

• Search all rows in DT_Commands
• Check “Accepted Commands” array for “giveitem”
• If found: Get Event Tag and Parameter Resolvers
• If not found: Command not recognized, abort

Row in DT_Commands:

• Accepted Commands: [“giveitem”, “additem”, “give”]
• “giveitem” matches!
• Get Event Tag: Event.Triggers.Gameplay.AddItem
• Get Parameter Resolvers: [Item Resolver, Float Resolver]

Parameter Resolution #

Resolution Process:

Input:

• Arguments: [“Sword”, “5”]
• Parameter Resolvers: [Item Resolver, Float Resolver]

Step 1 – Check Parameter Count: #

• Arguments count: 2
• Resolvers count: 2
• Override Minimal Parameter Amount: (check if set)
• If count valid, continue

Step 2 – Resolve Each Parameter: #

Parameter 1:

• Argument: “Sword”
• Resolver: Item Resolver (BP_CommandString_Resolver_Item)
• Call resolver with “Sword”
• Resolver converts to gameplay tag: Item.Weapon.Sword
• Store result

Parameter 2:

• Argument: “5”
• Resolver: Float Resolver (BP_CommandString_Resolver_ToFloat)
• Call resolver with “5”
• Resolver converts to float: 5.0
• Store result

Step 3 – Build Values Array: #

• Resolved values: [Item.Weapon.Sword (tag), 5.0 (float)]
• Ready for event

Handling Optional Parameters:

Input: “/giveitem Sword” (amount missing)

Arguments: [“Sword”]

Step 1 – Check Count: #

• Arguments count: 1
• Override Minimal: 1
• Valid! Continue

Step 2 – Resolve Available Parameters: #

• Only resolve “Sword” with Item Resolver
• Skip Float Resolver (no argument provided)
• Values array: [Item.Weapon.Sword]

Step 3 – Event Handler Responsibility: #

• Event receives only 1 value
• Event must check values array length
• If missing, use default (e.g., amount = 1)

Event Triggering #

Event Preparation:

After resolution complete:

Event Tag: Event.Triggers.Gameplay.AddItem

Resolved Values: [Item.Weapon.Sword, 5.0]

Player: Reference to player who executed command

First Parameter Special Handling:

The first parameter has special conversion logic:

(See section 8.2 for detailed explanation)

If first parameter can be converted to gameplay tag:

• Use gameplay tag as event parameter
• Example: Item.Weapon.Sword

If first parameter cannot be converted:

• Use string value instead
• Example: Player name “JohnDoe”

Event Manager Call:

Trigger Event:

1. Event Manager receives Event Tag
2. First parameter: Gameplay tag OR string
3. Additional parameters: Values array
4. Player reference: Who executed command

Event listeners respond:

• Inventory System listens to Event.Triggers.Gameplay.AddItem
• Receives: Item tag, Amount, Player
• Executes: Add item to player inventory

---

Autocompletion #

Command Autocompletion #

How Command Autocompletion Works:

Player types: “/gi”

Autocomplete process:

1. System checks all “Accepted Commands” in DT_Commands
2. Filters commands starting with “gi”
3. Finds matches:

 - "giveitem"
 - "give"

1. Shows dropdown with matches
2. Player selects or continues typing
3. Tab to complete

Multiple Aliases:

Accepted Commands: [“w”, “whisper”, “private”]

Player types: “/w”

Autocomplete shows:

• “w”
• “whisper” (also matches because starts with 'w')

Player types: “/wh”

Autocomplete shows:

• “whisper”

All variations shown based on what player types

Parameter Autocompletion #

@ Syntax for Autocomplete:

Command Auto Complete field uses @ to trigger suggestions

Command Auto Complete: “/giveitem/@itemname”

How It Works:

1. Player types: “/giveitem “
2. System parses Auto Complete string
3. Finds: “@itemname” for first parameter
4. Calls Item Resolver's suggestion function
5. Resolver returns array of item names
6. Shows dropdown with all item names
7. Player selects or continues typing

Multiple Parameter Autocomplete:

Command Auto Complete: “/whisper/@playername/{message}”

Behavior:

First parameter:

• Player types: “/whisper “
• System sees: “@playername”
• Shows: List of online player names
• Player selects player

Second parameter:

• Player types: “/whisper JohnDoe “
• System sees: “{message}” (no @ tag)
• Shows: No autocomplete (just format hint)
• Player types message freely

@ tags enable parameter autocompletion (e.g., @itemname, @playername).

Custom @ tags must be programmed yourself.

---

Event manager integration #

Event Tag Conversion #

How Event Tags Work:

DT_Commands Configuration:

• Accepted Commands: [“giveitem”, “additem”]
• Event Tag: Event.Triggers.Gameplay.AddItem

Execution Flow:

1. Player types: “/giveitem Sword 5”
2. System finds “giveitem” in Accepted Commands
3. Gets Event Tag: Event.Triggers.Gameplay.AddItem
4. Triggers event with this tag via Event Manager
5. All listeners registered to this tag respond

Event Manager Integration:

See Event Manager documentation for full details on event system.

Console Command System uses Event Manager to:

• Trigger events by gameplay tag
• Pass resolved parameters to event listeners
• Decouple commands from implementation
• Allow multiple systems to respond to one command

First Parameter Handling #

Special First Parameter Logic:

The first parameter is handled differently from other parameters to support both gameplay tag-based and string-based systems.

Why First Parameter Is Special:

Different systems have different needs:

Tag-Based Systems:

• Quest System: Needs quest gameplay tag to add/complete quest
• Inventory System: Needs item gameplay tag to give/remove item
• Weather System: Needs weather gameplay tag to change weather

→ These need first parameter as gameplay tag

String-Based Systems:

• Player Manager: Needs player name as string to kick player
• Chat System: Needs player name as string to whisper
• Team System: Needs player name as string for team invite

→ These need first parameter as string

How It Works:

First Parameter Conversion Logic:

Step 1 – Try Gameplay Tag Conversion: #

• Attempt to convert first parameter to gameplay tag
• Use resolver if specified
• Example: “Sword” → Item.Weapon.Sword

Step 2 – Check Conversion Success: #

If conversion to gameplay tag successful:

• Pass gameplay tag as first parameter to event
• Example: Event receives Item.Weapon.Sword (tag)

If conversion to gameplay tag failed:

• Pass string value as first parameter to event
• Example: Event receives “JohnDoe” (string)

Step 3 – Additional Parameters: #

• All other parameters go into values array
• Values array contains resolved parameter values
• Event receives both first parameter AND values array

Command: “/giveitem Sword 5”

Parameters: [“Sword”, “5”]

Resolvers: [Item Resolver, Float Resolver]

First Parameter:

• “Sword” → Item Resolver → Item.Weapon.Sword (tag)
• Conversion successful!
• Event receives: First param = Item.Weapon.Sword (gameplay tag)

Additional Parameters:

• “5” → Float Resolver → 5.0
• Values array: [5.0]

Event Data:

• First Parameter: Item.Weapon.Sword (gameplay tag)
• Values Array: [5.0]

Command: “/kick JohnDoe Reason”

Parameters: [“JohnDoe”, “Reason”]

Resolvers: [null, null] (no resolvers, use strings)

First Parameter:

• “JohnDoe” → No resolver, cannot convert to tag
• Conversion failed (not a tag)
• Event receives: First param = “JohnDoe” (string)

Additional Parameters:

• “Reason” → String value
• Values array: [“Reason”]

Event Data:

• First Parameter: “JohnDoe” (string)
• Values Array: [“Reason”]

Values Array #

What Is the Values Array:

The values array contains all resolved parameter values.

Structure:

• Array of resolved parameters
• Index matches parameter position (after first parameter)
• Contains typed values (bool, string, float, tag)

How Values Array Is Built:

Parameters: [“Sword”, “5”, “true”]

Resolvers: [Item Resolver, Float Resolver, Boolean Resolver]

Resolution:

1. “Sword” → Item.Weapon.Sword (tag) → First parameter
2. “5” → 5.0 (float) → Values array index 0
3. “true” → True (bool) → Values array index 1

Result:

• First Parameter: Item.Weapon.Sword (gameplay tag)
• Values Array: [5.0, True]

Event Handler Receives:

• First parameter: Item tag or string
• Values[0]: Amount (float)
• Values[1]: Some boolean flag

Accessing Values in Event Handler:

Event Handler Implementation:

Function: OnAddItemCommand(FirstParameter, ValuesArray)

1. Check first parameter type:

 - If gameplay tag: Item = FirstParameter
 - If string: Error, invalid item

1. Get additional parameters:

 - Amount = ValuesArray[0] (float)
 - Flag = ValuesArray[1] (boolean) if exists

1. Execute logic:

 - Add item with amount
 - Apply flag if needed

1. Handle missing parameters:

 - Check ValuesArray.Length
 - Use defaults if parameters missing

---

Configuration #

Prefix and Delimiter #

Where to Configure:

Prefix and Delimiter are set in the AC_GameState_ConsoleCommandManager_Advanced component.

Prefix:

What it is: Character that identifies a command

Configurable: Set in component properties

Purpose:

• Distinguishes commands from normal chat messages
• “/” = command, no “/” = chat message

• Prefix “/” → Command: “/giveitem Sword”
• Prefix “!” → Command: “!giveitem Sword”
• Prefix “.” → Command: “.giveitem Sword”

Configuration:

1. Find AC_GameState_ConsoleCommandManager_Advanced Component
2. Set “Prefix” property
3. Can be any single character

Delimiter:

What it is: Character that separates command parts

Configurable: Set in component properties

Purpose:

• Splits command into parts
• Separates command from arguments
• Separates arguments from each other

• Delimiter ” ” → “/giveitem Sword 5”
• Delimiter “,” → “/giveitem,Sword,5”
• Delimiter “|” → “/giveitem|Sword|5”

Configuration:

1. Find Console Command Manager Component
2. Set “Delimiter” property
3. Can be any single character

Setting Up Commands #

Adding a New Command to DT_Commands:

Step 1 – Open DT_Commands: #

• Navigate to data table
• Add new row

Step 2 – Configure Fields: #

Accepted Commands:

• Add command aliases: [“commandname”, “alias1”, “alias2”]
• Example: [“giveitem”, “additem”, “give”]

Event Tag:

• Set gameplay tag for Event Manager
• Example: Event.Triggers.Gameplay.AddItem

Command Structure Description:

• Show command format: “/giveitem/{item}/{amount}”
• Use {} for parameters

Override Minimal Parameter Amount:

• Leave default (-1) for all parameters required
• Set to number if some parameters optional
• Example: 1 = only first parameter required

Command Auto Complete:

• Use @ for autocomplete parameters
• Example: “/giveitem/@itemname”
• Use {} for non-autocomplete parameters

Parameter Resolvers:

• Add resolver references in order
• Index matches parameter position
• Leave empty/null if no resolver needed
• Example: [BP_CommandString_Resolver_Item, BP_CommandString_Resolver_ToFloat]

Step 3 – Save: #

• Save DT_Commands
• Command now available in game

---

How to guides #

Creating a New Command #

This guide shows how to create a complete command from DT_Commands setup to event handling.

Step 1 – Add to DT_Commands: #

1. Open DT_Commands
2. Add new row: “Heal”
3. Configure:

Accepted Commands: [“heal”, “h”]

Event Tag: Event.Player.Heal

Command Structure Description: “/heal/{amount}”

Override Minimal Parameter Amount: 0 (amount required)

Command Auto Complete: “/heal”

Parameter Resolvers: [BP_CommandString_Resolver_ToFloat]

1. Save DT_Commands

Step 2 – Create Event Listener: #

In your Health System blueprint:

1. On Begin Play or Initialization:

 - Register event listener with Event Manager
 - Event Tag: Event.Player.Heal
 - Callback function: OnHealCommand

1. Implement OnHealCommand:

Function: OnHealCommand(FirstParameter, ValuesArray)

Implementation:

1. Get amount:

 - Amount = ValuesArray[0] (float from resolver)

1. Get player:

 - Player reference from event context

1. Heal player:

 - CurrentHealth = min(CurrentHealth + Amount, MaxHealth)

1. Return success (optional feedback)

Step 3 – Test: #

1. Play game
2. Open chat box
3. Type: “/heal 50”
4. Press Enter
5. Verify: Player health increased by 50
6. Test alias: “/h 50” (should also work)

Creating a Custom Parameter Resolver #

This guide shows how to create a resolver that converts weather names to gameplay tags.

Step 1 – Create Resolver Blueprint: #

1. Navigate to resolver folder
2. Create new blueprint
3. Parent class: BP_CommandString_Resolver_Abstract
4. Name: BP_CommandString_Resolver_Weather

Step 2 – Implement Conversion Function: #

Override conversion function:

Input: String (weather name)

Output: Gameplay Tag (weather tag)

Implementation:

1. Create weather name to tag map:

 - "Sunny" → Weather.Sunny
 - "Rainy" → Weather.Rainy
 - "Snowy" → Weather.Snowy
 - "Stormy" → Weather.Stormy

1. Look up input string in map:

 - If found: Return gameplay tag
 - If not found: Return error/empty

1. Return gameplay tag value

Step 3 – Implement Suggestions (Optional): #

For autocompletion support (if using @ tags):

Implement suggestion function that returns array of valid values.

Step 4 – Use in DT_Commands: #

1. Open DT_Commands
2. Find or create weather command
3. Configure:

Accepted Commands: [“weather”, “setweather”]

Event Tag: Event.World.ChangeWeather

Command Structure Description: “/weather/{type}”

Command Auto Complete: “/weather/@weathertype”

Parameter Resolvers: [BP_CommandString_Resolver_Weather]

1. Save

Step 5 – Test: #

1. Play game
2. Type: “/weather “
3. Autocomplete shows weather options (if @ tag implemented)
4. Select or type: “/weather Rainy”
5. Event receives: Weather.Rainy gameplay tag

Adding Command Aliases #

This guide shows how to add multiple command variations that execute the same logic.

Scenario: Add aliases for whisper command.

Step 1 – Configure Accepted Commands: #

1. Open DT_Commands
2. Find whisper command row (or create new)
3. Configure Accepted Commands array:

Accepted Commands: [“whisper”, “w”, “msg”, “tell”, “private”]

All these commands trigger same Event Tag

Step 2 – Update Command Auto Complete (Optional): #

Update auto complete to show all variations:

Command Auto Complete: “/whisper/@playername/{message}”

Players see suggestions regardless of which alias used

Step 3 – Test: #

Test all aliases:

1. “/whisper JohnDoe Hello” → Works
2. “/w JohnDoe Hello” → Works
3. “/msg JohnDoe Hello” → Works
4. “/tell JohnDoe Hello” → Works
5. “/private JohnDoe Hello” → Works

All trigger same event: Event.Chat.Whisper

All execute same logic

• Players use preferred syntax
• Short versions for speed
• Compatibility with different conventions
• One implementation for all variations
• Easy to add more aliases anytime

Handling Optional Parameters #

This guide shows how to create commands with optional parameters using Override Minimal Parameter Amount.

Scenario: Give item command where amount is optional (defaults to 1).

Step 1 – Configure DT_Commands: #

1. Open DT_Commands
2. Add/edit command:

Accepted Commands: [“giveitem”, “give”]

Event Tag: Event.Inventory.AddItem

Command Structure Description: “/giveitem/{item}/{amount}”

Override Minimal Parameter Amount: 1 ← Key setting!

Command Auto Complete: “/giveitem/@itemname”

Parameter Resolvers: [BP_CommandString_Resolver_Item, BP_CommandString_Resolver_ToFloat]

Override = 1 means only first parameter required

Step 2 – Implement Event Handler: #

Function: OnAddItemCommand(FirstParameter, ValuesArray)

Implementation:

1. Get item tag:

 - Item = FirstParameter (gameplay tag from resolver)

1. Get amount with default:

 - If ValuesArray.Length > 0:
 - Amount = ValuesArray[0] (float)
 - Else:
 - Amount = 1.0 (default when not provided)

1. Add item:

 - Add item to inventory with amount

1. Important: Always check ValuesArray length

 - Missing optional parameters won't be in array
 - Use defaults when length is less than expected

Step 3 – Test Both Cases: #

Test with amount:

• Command: “/giveitem Sword 5”
• Arguments: [“Sword”, “5”]
• Both parameters resolved
• ValuesArray[0] = 5.0
• Result: Add 5 Swords

Test without amount:

• Command: “/giveitem Sword”
• Arguments: [“Sword”]
• Only first parameter resolved
• ValuesArray is empty
• Result: Add 1 Sword (default)

Multiple Optional Parameters:

Command: “/teleport/{x}/{y}/{z}”

Override Minimal Parameter Amount: 0

Allows:

• “/teleport 100 50 200” → All provided
• “/teleport 100 50” → Z missing, use default
• “/teleport 100” → Y and Z missing, use defaults
• “/teleport” → All missing, use all defaults

Event Handler Must:

• Check ValuesArray.Length for each parameter
• Apply defaults for any missing parameters
• —

END OF DOCUMENTATION

Summary:

The Console Command System provides a flexible command execution framework with:

Core Features:

• Chat Box Input: Text input with autocompletion
• Server RPC: Commands sent via Console Command Communicator
• DT_Commands: Data table defining commands with accepted aliases
• Parameter Resolvers: Convert strings to typed values (inherit from BP_CommandString_Resolver_Abstract)
• Event Manager Integration: Commands trigger events by gameplay tag
• Autocompletion: Command and parameter suggestions using @ syntax
• Optional Parameters: Override Minimal Parameter Amount for flexible parameter counts
• Configurable: Prefix and Delimiter set in Console Command Manager Component

Key Concepts:

• Accepted Commands: Array of command aliases (e.g., [“w”, “whisper”, “private”])
• Event Tag: Gameplay tag triggering events via Event Manager
• First Parameter Special: Converted to gameplay tag if possible, otherwise string
• Values Array: Contains all resolved parameters after the first
• @ Autocomplete: Use @ in Command Auto Complete for parameter suggestions
• No Permission Levels: Permission system not implemented (implement yourself if needed)

Build powerful command interfaces with aliases, autocompletion, and event-driven execution!