Custom Commands & IntelliSense

Registering Custom Commands#

Creating a custom command is as simple as adding the [Command] attribute to any method in your game, whether it’s static or part of a MonoBehaviour.

using DevConsole;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    // The method will be automatically discovered on startup!
    [Command("spawn.enemy", "Spawns an enemy at the player's position.")]
    public static void SpawnEnemy(string type, int count)
    {
        // Your logic here.
    }
}

Event-like Execution with SharedCommands#

If you want to invoke multiple methods across entirely different scripts simultaneously using the exact same command name, use the [SharedCommand] attribute! This acts like an event broadcast.

You can also precisely control the execution order using the Order property. Methods with lower Order values execute first. If Order is not defined, the system automatically runs them last, sorting them alphabetically by their script name, and prints a warning in the console log.

public class GameManager : MonoBehaviour
{
    [SharedCommand("save.all", Order = 1)]
    public static void SaveGameWorld()
    {
        // Executes first
    }
}

public class InventoryManager : MonoBehaviour
{
    [SharedCommand("save.all", Order = 2)]
    public static void SavePlayerInventory()
    {
        // Executes after the GameManager
    }
}

Supported Parameter Types#

The Dev Console Pro handles type conversion natively for almost every common Unity type without requiring any boilerplate parsing code.

Parameter IntelliSense (Autocomplete)#

The Dev Console Pro features a powerful contextual suggestion engine. When the user types a command, it can suggest valid values for each specific parameter dynamically.

Option A: Automatic Type Inference (Zero Setup)#

If you do nothing, the console automatically infers suggestion types for parameters!

[Command("set.god.mode")]
public static void SetGodMode(bool enabled, KeyCode triggerKey, EnemyType enemyEnum) 
{
    // Automatically suggests 'true'/'false' for enabled.
    // Automatically suggests Unity KeyCode list for triggerKey.
    // Automatically suggests EnemyType values for enemyEnum.
}

Note: String parameters with names like sceneName or layer will also be automatically inferred.

Option B: Method-level Attributes#

For simple cases, you can provide an array of SuggestionType values directly in the [Command] attribute:

[Command("teleport", "Teleport to a GameObject", ParameterSuggestions = new[] { SuggestionType.GameObject })]
public static void Teleport(string target)
{
    // Typing "teleport " will suggest scene GameObjects
}

Option C: Per-Parameter Attributes#

If you need complex suggestions (like suggesting GameObjects that only have a specific component attached), use the [CommandParamSuggestion] attribute.

[Command("find", "Find objects with a specific component")]
public static void Find(
    [CommandParamSuggestion(SuggestionType.Component, typeof(Rigidbody2D))] string objectName)
{
    // The console will only suggest GameObjects that actually have a Rigidbody2D!
}

Option D: Custom Dynamic Providers & Reverse Lookup#

You can provide your own dynamically generated lists of suggestions. Even better, if you use the Generic provider overload, the console will automatically map the strings in the UI back to actual object instances at execution time!

1. Register the provider (e.g., in Awake):

// Passing a generic provider will automatically convert values to strings for UI
// AND it will automatically resolve the exact object instance during execution!
SuggestionProvider.RegisterCustomProvider<ScriptableRendererFeature>("render_features", () => myRendererData.rendererFeatures);

2. Use the Custom ID in your command:

[Command("renderer.toggle")]
public static void ToggleFeature([CommandParamSuggestion("render_features")] ScriptableRendererFeature feature)
{
    // When you type "renderer.toggle ", it auto-suggests the names of the features.
    // When you hit enter, the actual 'feature' object reference is safely injected here!
    feature.SetActive(!feature.isActive);
}

List of Suggestion Types#

Here is the complete list of available SuggestionType enum values you can use:

Advanced Parsing Features#

• Multi-Word Commands: You can include spaces in command names (e.g., [Command("spawn boss")]). The autocomplete seamlessly handles multi-word groupings.
• Vector Syntax Rendering: Vector values are color-coded in the UI to match Unity’s standard Red/Green/Blue gizmos for absolute visual clarity!
• Nested Alias Parsing: The robust nested context parser completely prevents autocomplete failures or logic breaks when you are writing complex nested aliases with bracket [ ] syntax.