759 lines
30 KiB
C#
759 lines
30 KiB
C#
// Assets/_Project/Scripts/Dev/DebugConsole.cs
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.UIElements;
|
|
using TD.UI;
|
|
using TD.Gameplay.Draft;
|
|
using TD.Gameplay.EnemyUpgrades;
|
|
|
|
namespace TD.Dev
|
|
{
|
|
/// <summary>
|
|
/// Standalone debug console overlay: press the toggle key to open a text
|
|
/// input, type a command, Enter to submit, Escape to cancel.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Deliberately decoupled from <see cref="HUDController"/> — own GameObject,
|
|
/// own UIDocument (it shares HUDPanelSettings, drawn above the HUD via a
|
|
/// higher sorting order) — so it can be dropped out of a build entirely by
|
|
/// not including that GameObject, the same way <see cref="DevWaveControls"/>
|
|
/// is kept separate from shipping systems.
|
|
///
|
|
/// The grammar lives in a <see cref="CommandNode"/> tree (see
|
|
/// <see cref="BuildCommandTree"/>) rather than in hardcoded string compares,
|
|
/// so the same definition drives both execution and the autocomplete list.
|
|
/// Supports one command so far: "get <type> <name>" grants a
|
|
/// <see cref="TD.Gameplay.Draft.DraftOption"/> to the local player via
|
|
/// <see cref="DebugCommandRelay"/>.
|
|
///
|
|
/// Keys while open: Up/Down move the suggestion highlight, Tab accepts it,
|
|
/// Enter accepts it while the command is still incomplete and submits once
|
|
/// it is complete, Escape closes without submitting.
|
|
/// </remarks>
|
|
[RequireComponent(typeof(UIDocument))]
|
|
public class DebugConsole : MonoBehaviour
|
|
{
|
|
public static DebugConsole Instance { get; private set; }
|
|
|
|
/// <summary>
|
|
/// True while the console overlay is showing. Legacy IMGUI (<c>OnGUI</c>) dev tools
|
|
/// draw after every runtime UI Toolkit panel regardless of sorting order, so they
|
|
/// have to check this and skip drawing rather than rely on layering.
|
|
/// </summary>
|
|
public static bool IsOpen => Instance != null && Instance.consoleOpen;
|
|
|
|
[Tooltip("Keyboard shortcut that opens and closes the console. Uses the new Input " +
|
|
"System (UnityEngine.InputSystem.Key). Backquote is the physical ` / ~ key.")]
|
|
[SerializeField] private Key toggleKey = Key.Backquote;
|
|
|
|
private DebugConsoleUI ui;
|
|
private bool consoleOpen;
|
|
|
|
// Frame on which the console was opened or closed. The toggle key and Enter
|
|
// are ignored on that frame and the next so the keypress that opened/closed
|
|
// the console doesn't also get typed into the field or immediately submit it.
|
|
// Mirrors HUDController's chatToggleSuppressFrame.
|
|
private int toggleSuppressFrame = -1;
|
|
|
|
// Current completion candidates for what's typed, the highlighted one, and the
|
|
// index in the input text where accepting a candidate starts overwriting.
|
|
private List<Suggestion> suggestions = new List<Suggestion>();
|
|
private int selectedIndex;
|
|
private int fragmentStart;
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Debug.LogError("[DebugConsole] Duplicate instance detected. Destroying the new one.");
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
Instance = this;
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
var doc = GetComponent<UIDocument>();
|
|
if (doc == null)
|
|
{
|
|
Debug.LogError("[DebugConsole] No UIDocument component found.");
|
|
return;
|
|
}
|
|
|
|
var root = doc.rootVisualElement;
|
|
if (root == null)
|
|
{
|
|
Debug.LogError("[DebugConsole] rootVisualElement is null. " +
|
|
"Check that Panel Settings is assigned.");
|
|
return;
|
|
}
|
|
|
|
ui = new DebugConsoleUI(root);
|
|
|
|
// Focus tracking — contributes to the same flag HUDController's chat
|
|
// input sets, so camera/builder/spell input all stay gated correctly
|
|
// regardless of which text field currently has focus.
|
|
ui.CommandInput.RegisterCallback<FocusInEvent>(_ => HUDController.IsTextInputActive = true);
|
|
ui.CommandInput.RegisterCallback<FocusOutEvent>(_ => HUDController.IsTextInputActive = false);
|
|
|
|
ui.CommandInput.RegisterValueChangedCallback(_ => RefreshSuggestions());
|
|
|
|
// Tab and the arrows can't be polled from Keyboard.current the way Enter and
|
|
// Escape are (below): UI Toolkit would still insert a tab character and move
|
|
// the focus ring before Update runs. Intercept them on the field in the
|
|
// trickle-down phase, before the text engine and the focus ring see them.
|
|
ui.CommandInput.RegisterCallback<KeyDownEvent>(OnConsoleKeyDown, TrickleDown.TrickleDown);
|
|
ui.CommandInput.RegisterCallback<NavigationMoveEvent>(OnConsoleNavigationMove,
|
|
TrickleDown.TrickleDown);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
var kb = Keyboard.current;
|
|
if (kb == null) return; // no keyboard connected (e.g. headless server)
|
|
|
|
if (Time.frameCount <= toggleSuppressFrame) return;
|
|
|
|
if (toggleKey != Key.None && kb[toggleKey].wasPressedThisFrame)
|
|
{
|
|
if (consoleOpen) CloseConsole();
|
|
else OpenConsole();
|
|
return;
|
|
}
|
|
|
|
if (!consoleOpen) return;
|
|
|
|
bool enterDown = kb.enterKey.wasPressedThisFrame || kb.numpadEnterKey.wasPressedThisFrame;
|
|
bool escDown = kb.escapeKey.wasPressedThisFrame;
|
|
|
|
if (enterDown) SubmitCommand();
|
|
else if (escDown) CloseConsole();
|
|
}
|
|
|
|
private void OnConsoleKeyDown(KeyDownEvent evt)
|
|
{
|
|
if (!consoleOpen) return;
|
|
|
|
switch (evt.keyCode)
|
|
{
|
|
case KeyCode.Tab:
|
|
AcceptSelectedSuggestion();
|
|
Swallow(evt);
|
|
return;
|
|
case KeyCode.DownArrow:
|
|
MoveSelection(1);
|
|
Swallow(evt);
|
|
return;
|
|
case KeyCode.UpArrow:
|
|
MoveSelection(-1);
|
|
Swallow(evt);
|
|
return;
|
|
}
|
|
|
|
// Tab reaches the field twice — once carrying keyCode, once carrying only the
|
|
// '\t' character. Swallow the second one too or a literal tab lands in the text.
|
|
if (evt.character == '\t') Swallow(evt);
|
|
}
|
|
|
|
// UI Toolkit also translates Tab into a focus-ring navigation event, separately
|
|
// from the key event above. Block it so Tab can't move focus off the console.
|
|
private void OnConsoleNavigationMove(NavigationMoveEvent evt)
|
|
{
|
|
if (!consoleOpen) return;
|
|
Swallow(evt);
|
|
}
|
|
|
|
// Consume an event so neither the text engine nor the focus ring acts on it.
|
|
// EventBase.PreventDefault is obsolete in Unity 6; FocusController.IgnoreEvent is
|
|
// its replacement for the focus-navigation half.
|
|
private void Swallow(EventBase evt)
|
|
{
|
|
evt.StopImmediatePropagation();
|
|
ui.CommandInput?.panel?.focusController?.IgnoreEvent(evt);
|
|
}
|
|
|
|
private void OpenConsole()
|
|
{
|
|
if (ui.CommandInput == null) return;
|
|
ui.Show();
|
|
ui.CommandInput.SetValueWithoutNotify(string.Empty);
|
|
RefreshSuggestions();
|
|
|
|
// Suppress the toggle key and Enter for this frame and the next so the
|
|
// keypress that opened the console doesn't also get typed into the field.
|
|
// Focus is deferred a frame for the same reason — UI Toolkit would
|
|
// otherwise route the open keypress to the freshly-focused TextField.
|
|
toggleSuppressFrame = Time.frameCount + 1;
|
|
consoleOpen = true;
|
|
StartCoroutine(FocusNextFrame());
|
|
}
|
|
|
|
private IEnumerator FocusNextFrame()
|
|
{
|
|
yield return null;
|
|
if (consoleOpen && ui.CommandInput != null)
|
|
{
|
|
ui.CommandInput.Focus();
|
|
ui.CommandInput.SelectAll();
|
|
}
|
|
}
|
|
|
|
private void CloseConsole()
|
|
{
|
|
if (ui.CommandInput != null)
|
|
{
|
|
ui.CommandInput.SetValueWithoutNotify(string.Empty);
|
|
ui.CommandInput.Blur();
|
|
}
|
|
ui.Hide();
|
|
|
|
suggestions.Clear();
|
|
selectedIndex = 0;
|
|
ui.ClearSuggestions();
|
|
|
|
consoleOpen = false;
|
|
toggleSuppressFrame = Time.frameCount + 1;
|
|
SuppressHudChatOpen();
|
|
}
|
|
|
|
// The Enter that submitted/accepted in this console also gets polled by
|
|
// HUDController's chat this same frame — suppress its "Enter opens chat" branch
|
|
// (HUDController.HandleChatInput, which gates only on this frame counter) so
|
|
// using the debug console never pops chat open too.
|
|
private static void SuppressHudChatOpen()
|
|
{
|
|
HUDController.SuppressChatOpenUntilFrame = Time.frameCount + 1;
|
|
}
|
|
|
|
private void SubmitCommand()
|
|
{
|
|
string text = ui.CommandInput?.value ?? string.Empty;
|
|
|
|
// Enter doubles as "accept the highlighted suggestion" while the typed
|
|
// command isn't runnable yet, so you can drive the whole thing with Enter
|
|
// and only ever hit Tab when you want to skip past the highlighted row.
|
|
if (!string.IsNullOrWhiteSpace(text) && suggestions.Count > 0 && !IsComplete(text))
|
|
{
|
|
AcceptSelectedSuggestion();
|
|
SuppressHudChatOpen();
|
|
return;
|
|
}
|
|
|
|
CloseConsole();
|
|
|
|
if (string.IsNullOrWhiteSpace(text)) return;
|
|
ExecuteCommand(text.Trim());
|
|
}
|
|
|
|
// ---------------------------------------------------------------- grammar
|
|
|
|
/// <summary>
|
|
/// One token level of the command grammar. Literal levels list their
|
|
/// <see cref="Children"/>; a level that takes a free-form final argument sets
|
|
/// <see cref="Values"/> to enumerate the valid values for completion.
|
|
/// </summary>
|
|
private sealed class CommandNode
|
|
{
|
|
public string Token; // literal token; null for the root
|
|
public string Hint; // dim one-liner shown beside the token
|
|
public Func<List<string>> Values; // non-null => this level takes a final value
|
|
public bool Executable; // a complete command can end here
|
|
public Action<string> Execute; // "Values" level: run the completed command
|
|
public readonly List<CommandNode> Children = new List<CommandNode>();
|
|
}
|
|
|
|
private const string UsageHint = "Try: get <type> <name>, grant enemy <ability>";
|
|
|
|
// Maps the type token in "get <type> <name>" to the DraftOption subclass it
|
|
// should match against. Add an entry here whenever a new DraftOption subclass
|
|
// should be gettable from the console — the command tree and its autocomplete
|
|
// list are both built from this.
|
|
private static readonly Dictionary<string, Type> DraftTypeAliases =
|
|
new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
{ "spell", typeof(BuilderSpellDraftOption) },
|
|
{ "tower", typeof(NewTowerDraftOption) },
|
|
{ "buff", typeof(BuilderEffectDraftOption) },
|
|
{ "effect", typeof(BuilderEffectDraftOption) },
|
|
};
|
|
|
|
private CommandNode commandTree;
|
|
private CommandNode CommandTree => commandTree ?? (commandTree = BuildCommandTree());
|
|
|
|
private static CommandNode BuildCommandTree()
|
|
{
|
|
var root = new CommandNode();
|
|
|
|
var get = new CommandNode
|
|
{
|
|
Token = "get",
|
|
Hint = "grant a draft option to the local player",
|
|
};
|
|
root.Children.Add(get);
|
|
|
|
foreach (var pair in DraftTypeAliases)
|
|
{
|
|
string typeToken = pair.Key;
|
|
var optionType = pair.Value;
|
|
get.Children.Add(new CommandNode
|
|
{
|
|
Token = typeToken,
|
|
Hint = "<name>",
|
|
Executable = true,
|
|
Values = () => DraftOptionNames(optionType),
|
|
Execute = name => ExecuteGet(typeToken, optionType, name),
|
|
});
|
|
}
|
|
|
|
var grant = new CommandNode
|
|
{
|
|
Token = "grant",
|
|
Hint = "grant a buff to the enemies",
|
|
};
|
|
root.Children.Add(grant);
|
|
|
|
grant.Children.Add(new CommandNode
|
|
{
|
|
Token = "enemy",
|
|
Hint = "<ability>",
|
|
Executable = true,
|
|
Values = EnemyUpgradeNames,
|
|
Execute = ExecuteGrantEnemyAbility,
|
|
});
|
|
|
|
return root;
|
|
}
|
|
|
|
// Display names of every pooled DraftOption of the given subclass, alphabetically.
|
|
// Recomputed per keystroke rather than cached: DraftPool is a scene singleton that
|
|
// may not exist yet when the console is built, and the pool is only a handful of
|
|
// entries. Uses DraftPool's existing Count/Get surface — the same one ExecuteGet
|
|
// walks — so completion can never offer something the command can't resolve.
|
|
private static List<string> DraftOptionNames(Type optionType)
|
|
{
|
|
var names = new List<string>();
|
|
|
|
var pool = DraftPool.Instance;
|
|
if (pool == null) return names;
|
|
|
|
for (int i = 0; i < pool.Count; i++)
|
|
{
|
|
var option = pool.Get(i);
|
|
if (option == null || !optionType.IsInstanceOfType(option)) continue;
|
|
|
|
string name = option.DisplayName;
|
|
if (string.IsNullOrWhiteSpace(name)) continue;
|
|
if (names.Contains(name)) continue;
|
|
|
|
names.Add(name);
|
|
}
|
|
|
|
names.Sort(StringComparer.OrdinalIgnoreCase);
|
|
return names;
|
|
}
|
|
|
|
// Display names of every pooled AbilityEnemyUpgradeOption, alphabetically. Mirrors
|
|
// DraftOptionNames above — EnemyUpgradePool is the enemy-side equivalent of DraftPool,
|
|
// and this is the same Count/Get surface ExecuteGrantEnemyAbility walks. Non-ability
|
|
// cards (e.g. the vote-meta "Double Dip") aren't an AbilityEnemyUpgradeOption, so they
|
|
// don't show up here even though they're in the pool.
|
|
private static List<string> EnemyUpgradeNames()
|
|
{
|
|
var names = new List<string>();
|
|
|
|
var pool = EnemyUpgradePool.Instance;
|
|
if (pool == null) return names;
|
|
|
|
for (int i = 0; i < pool.Count; i++)
|
|
{
|
|
var option = pool.Get(i) as AbilityEnemyUpgradeOption;
|
|
if (option == null) continue;
|
|
|
|
string name = option.DisplayName;
|
|
if (string.IsNullOrWhiteSpace(name)) continue;
|
|
if (names.Contains(name)) continue;
|
|
|
|
names.Add(name);
|
|
}
|
|
|
|
names.Sort(StringComparer.OrdinalIgnoreCase);
|
|
return names;
|
|
}
|
|
|
|
// Valid literal tokens at a level, for error messages ("Expected one of: ...").
|
|
private static string ChildTokens(CommandNode node)
|
|
{
|
|
var tokens = new List<string>();
|
|
for (int i = 0; i < node.Children.Count; i++) tokens.Add(node.Children[i].Token);
|
|
tokens.Sort(StringComparer.OrdinalIgnoreCase);
|
|
return string.Join(", ", tokens);
|
|
}
|
|
|
|
private static CommandNode FindChild(CommandNode node, string token)
|
|
{
|
|
for (int i = 0; i < node.Children.Count; i++)
|
|
if (string.Equals(node.Children[i].Token, token, StringComparison.OrdinalIgnoreCase))
|
|
return node.Children[i];
|
|
return null;
|
|
}
|
|
|
|
// Whitespace tokenizer that also reports where each token starts, so completion
|
|
// knows which span of the raw input a candidate would replace.
|
|
private static void Tokenize(string text, List<string> tokens, List<int> starts)
|
|
{
|
|
tokens.Clear();
|
|
starts.Clear();
|
|
|
|
int i = 0;
|
|
while (i < text.Length)
|
|
{
|
|
while (i < text.Length && char.IsWhiteSpace(text[i])) i++;
|
|
if (i >= text.Length) break;
|
|
|
|
int start = i;
|
|
while (i < text.Length && !char.IsWhiteSpace(text[i])) i++;
|
|
tokens.Add(text.Substring(start, i - start));
|
|
starts.Add(start);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------- completion
|
|
|
|
private struct Suggestion
|
|
{
|
|
public string Text; // what replaces the current fragment
|
|
public string Hint; // dim trailing text, display only
|
|
public bool AppendSpace; // true when more tokens follow this one
|
|
}
|
|
|
|
private readonly List<string> walkTokens = new List<string>();
|
|
private readonly List<int> walkStarts = new List<int>();
|
|
|
|
/// <summary>
|
|
/// Candidates for the token currently being typed, plus (via
|
|
/// <paramref name="fragStart"/>) the index in <paramref name="text"/> where
|
|
/// accepting one starts overwriting.
|
|
/// </summary>
|
|
private List<Suggestion> ComputeSuggestions(string text, out int fragStart)
|
|
{
|
|
text = text ?? string.Empty;
|
|
Tokenize(text, walkTokens, walkStarts);
|
|
|
|
bool endsWithSpace = text.Length > 0 && char.IsWhiteSpace(text[text.Length - 1]);
|
|
|
|
var node = CommandTree;
|
|
int i = 0;
|
|
|
|
while (true)
|
|
{
|
|
// Free-form final argument: everything from here to the end of the line is
|
|
// one value, so multi-word names ("Slow Area") complete as a single unit —
|
|
// matching how ExecuteCommand rejoins the trailing tokens.
|
|
if (node.Values != null)
|
|
{
|
|
fragStart = i < walkTokens.Count ? walkStarts[i] : text.Length;
|
|
string valueFragment = i < walkTokens.Count
|
|
? text.Substring(fragStart).Trim()
|
|
: string.Empty;
|
|
return FilterValues(node.Values(), valueFragment);
|
|
}
|
|
|
|
// Nothing typed at this level yet — offer everything it accepts.
|
|
if (i >= walkTokens.Count)
|
|
{
|
|
fragStart = text.Length;
|
|
return FilterChildren(node, string.Empty);
|
|
}
|
|
|
|
// Last token with no trailing space is still being typed: complete it
|
|
// rather than trying to descend through it.
|
|
if (i == walkTokens.Count - 1 && !endsWithSpace)
|
|
{
|
|
fragStart = walkStarts[i];
|
|
return FilterChildren(node, walkTokens[i]);
|
|
}
|
|
|
|
var child = FindChild(node, walkTokens[i]);
|
|
if (child == null)
|
|
{
|
|
// A finished token that matches nothing — the rest of the line is
|
|
// unreachable, so there's nothing useful to suggest.
|
|
fragStart = walkStarts[i];
|
|
return new List<Suggestion>();
|
|
}
|
|
|
|
node = child;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
private static List<Suggestion> FilterChildren(CommandNode node, string fragment)
|
|
{
|
|
var result = new List<Suggestion>();
|
|
for (int i = 0; i < node.Children.Count; i++)
|
|
{
|
|
var child = node.Children[i];
|
|
if (fragment.Length > 0 &&
|
|
!child.Token.StartsWith(fragment, StringComparison.OrdinalIgnoreCase))
|
|
continue;
|
|
|
|
result.Add(new Suggestion
|
|
{
|
|
Text = child.Token,
|
|
Hint = child.Hint,
|
|
AppendSpace = child.Children.Count > 0 || child.Values != null,
|
|
});
|
|
}
|
|
result.Sort((a, b) => string.Compare(a.Text, b.Text, StringComparison.OrdinalIgnoreCase));
|
|
return result;
|
|
}
|
|
|
|
// Values are matched on the same normalized form execution uses, so anything the
|
|
// list offers for "slow_ar" is something ExecuteGet would also accept.
|
|
private static List<Suggestion> FilterValues(List<string> values, string fragment)
|
|
{
|
|
var result = new List<Suggestion>();
|
|
string normalizedFragment = Normalize(fragment);
|
|
|
|
for (int i = 0; i < values.Count; i++)
|
|
{
|
|
if (normalizedFragment.Length > 0 &&
|
|
!Normalize(values[i]).StartsWith(normalizedFragment, StringComparison.Ordinal))
|
|
continue;
|
|
|
|
result.Add(new Suggestion { Text = values[i], AppendSpace = false });
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>True when <paramref name="text"/> is a runnable command as typed.</summary>
|
|
private bool IsComplete(string text)
|
|
{
|
|
Tokenize(text ?? string.Empty, walkTokens, walkStarts);
|
|
|
|
var node = CommandTree;
|
|
int i = 0;
|
|
|
|
while (i < walkTokens.Count)
|
|
{
|
|
if (node.Values != null) break;
|
|
|
|
var child = FindChild(node, walkTokens[i]);
|
|
if (child == null) return false;
|
|
|
|
node = child;
|
|
i++;
|
|
}
|
|
|
|
if (!node.Executable) return false;
|
|
|
|
if (node.Values != null)
|
|
{
|
|
if (i >= walkTokens.Count) return false; // value level, nothing typed for it
|
|
|
|
string normalized = Normalize(string.Join(" ", walkTokens.GetRange(i, walkTokens.Count - i)));
|
|
var values = node.Values();
|
|
for (int v = 0; v < values.Count; v++)
|
|
if (Normalize(values[v]) == normalized) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// --------------------------------------------------------- suggestion UI
|
|
|
|
private void RefreshSuggestions()
|
|
{
|
|
if (ui.CommandInput == null) return;
|
|
|
|
// Keep the highlight on the same candidate when it survives the new filter,
|
|
// so typing another character doesn't silently move what Enter would accept.
|
|
string previouslySelected = selectedIndex >= 0 && selectedIndex < suggestions.Count
|
|
? suggestions[selectedIndex].Text
|
|
: null;
|
|
|
|
suggestions = ComputeSuggestions(ui.CommandInput.value, out fragmentStart);
|
|
|
|
selectedIndex = 0;
|
|
if (previouslySelected != null)
|
|
{
|
|
for (int i = 0; i < suggestions.Count; i++)
|
|
{
|
|
if (!string.Equals(suggestions[i].Text, previouslySelected, StringComparison.Ordinal))
|
|
continue;
|
|
selectedIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ui.RenderSuggestions(ToSuggestionRows(suggestions), selectedIndex);
|
|
}
|
|
|
|
private static List<DebugConsoleUI.SuggestionRow> ToSuggestionRows(List<Suggestion> suggestions)
|
|
{
|
|
var rows = new List<DebugConsoleUI.SuggestionRow>(suggestions.Count);
|
|
for (int i = 0; i < suggestions.Count; i++)
|
|
rows.Add(new DebugConsoleUI.SuggestionRow(suggestions[i].Text, suggestions[i].Hint));
|
|
return rows;
|
|
}
|
|
|
|
private void MoveSelection(int delta)
|
|
{
|
|
if (suggestions.Count == 0) return;
|
|
|
|
selectedIndex = (selectedIndex + delta) % suggestions.Count;
|
|
if (selectedIndex < 0) selectedIndex += suggestions.Count;
|
|
|
|
ui.RenderSuggestions(ToSuggestionRows(suggestions), selectedIndex);
|
|
}
|
|
|
|
private bool AcceptSelectedSuggestion()
|
|
{
|
|
if (ui.CommandInput == null) return false;
|
|
if (selectedIndex < 0 || selectedIndex >= suggestions.Count) return false;
|
|
|
|
var suggestion = suggestions[selectedIndex];
|
|
string text = ui.CommandInput.value ?? string.Empty;
|
|
int start = Mathf.Clamp(fragmentStart, 0, text.Length);
|
|
|
|
string completed = text.Substring(0, start) + suggestion.Text +
|
|
(suggestion.AppendSpace ? " " : string.Empty);
|
|
|
|
// SetValueWithoutNotify + an explicit refresh instead of assigning value:
|
|
// one deterministic recompute, and the caret placement below can't race the
|
|
// change callback.
|
|
ui.CommandInput.SetValueWithoutNotify(completed);
|
|
ui.CommandInput.SelectRange(completed.Length, completed.Length);
|
|
RefreshSuggestions();
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------------------------- execution
|
|
|
|
private void ExecuteCommand(string text)
|
|
{
|
|
Tokenize(text, walkTokens, walkStarts);
|
|
|
|
var node = CommandTree;
|
|
int i = 0;
|
|
|
|
while (i < walkTokens.Count && node.Values == null)
|
|
{
|
|
var child = FindChild(node, walkTokens[i]);
|
|
if (child == null)
|
|
{
|
|
Debug.Log($"[DebugConsole] Unrecognized token \"{walkTokens[i]}\" in " +
|
|
$"\"{text}\". Expected one of: {ChildTokens(node)}. {UsageHint}");
|
|
return;
|
|
}
|
|
|
|
node = child;
|
|
i++;
|
|
}
|
|
|
|
if (node.Values == null || !node.Executable || i >= walkTokens.Count)
|
|
{
|
|
Debug.Log($"[DebugConsole] Incomplete command: \"{text}\". {UsageHint}");
|
|
return;
|
|
}
|
|
|
|
string nameToken = string.Join(" ", walkTokens.GetRange(i, walkTokens.Count - i));
|
|
node.Execute(nameToken);
|
|
}
|
|
|
|
// "get <type> <name>": grants any DraftOption of the given type whose DisplayName
|
|
// matches <name>, via the local player's DebugCommandRelay. Reuses DraftOption's
|
|
// existing type-agnostic ServerApply dispatch instead of hardcoding a grant path
|
|
// per option type.
|
|
private static void ExecuteGet(string typeToken, Type optionType, string nameToken)
|
|
{
|
|
var pool = DraftPool.Instance;
|
|
if (pool == null)
|
|
{
|
|
Debug.LogWarning("[DebugConsole] No DraftPool in this scene.");
|
|
return;
|
|
}
|
|
|
|
string normalizedTarget = Normalize(nameToken);
|
|
for (int i = 0; i < pool.Count; i++)
|
|
{
|
|
var option = pool.Get(i);
|
|
if (option == null || !optionType.IsInstanceOfType(option)) continue;
|
|
if (Normalize(option.DisplayName) != normalizedTarget) continue;
|
|
|
|
var relay = DebugCommandRelay.Local;
|
|
if (relay == null)
|
|
{
|
|
Debug.LogWarning("[DebugConsole] No local DebugCommandRelay found — " +
|
|
"is it on the Player prefab?");
|
|
return;
|
|
}
|
|
|
|
relay.DebugGrantDraftOptionRpc(i);
|
|
return;
|
|
}
|
|
|
|
Debug.LogWarning($"[DebugConsole] No {typeToken} option named \"{nameToken}\" found.");
|
|
}
|
|
|
|
// "grant enemy <ability>": the same effect as the post-wave vote picking that ability
|
|
// card for the current wave slot — records it via RunState.ServerAddUpgrade and runs
|
|
// its ServerOnApplied, mirroring WaveVote.ServerResolve exactly (see DebugCommandRelay.
|
|
// DebugGrantEnemyUpgradeRpc). Takes effect the next time this wave slot's enemies
|
|
// spawn, not retroactively on enemies already alive.
|
|
private static void ExecuteGrantEnemyAbility(string nameToken)
|
|
{
|
|
var pool = EnemyUpgradePool.Instance;
|
|
if (pool == null)
|
|
{
|
|
Debug.LogWarning("[DebugConsole] No EnemyUpgradePool in this scene.");
|
|
return;
|
|
}
|
|
|
|
string normalizedTarget = Normalize(nameToken);
|
|
for (int i = 0; i < pool.Count; i++)
|
|
{
|
|
var option = pool.Get(i) as AbilityEnemyUpgradeOption;
|
|
if (option == null || Normalize(option.DisplayName) != normalizedTarget) continue;
|
|
|
|
var relay = DebugCommandRelay.Local;
|
|
if (relay == null)
|
|
{
|
|
Debug.LogWarning("[DebugConsole] No local DebugCommandRelay found — " +
|
|
"is it on the Player prefab?");
|
|
return;
|
|
}
|
|
|
|
relay.DebugGrantEnemyUpgradeRpc(i);
|
|
return;
|
|
}
|
|
|
|
Debug.LogWarning($"[DebugConsole] No enemy ability named \"{nameToken}\" found.");
|
|
}
|
|
|
|
// DisplayName is player-facing draft card text (its spacing/casing is chosen for
|
|
// presentation, not for typing), so command matching strips everything but letters
|
|
// and digits before comparing — "Slow Area", "slow_area", and "SlowArea" all match
|
|
// the same option.
|
|
private static string Normalize(string s)
|
|
{
|
|
if (string.IsNullOrEmpty(s)) return string.Empty;
|
|
var sb = new StringBuilder(s.Length);
|
|
foreach (char c in s)
|
|
if (char.IsLetterOrDigit(c)) sb.Append(char.ToLowerInvariant(c));
|
|
return sb.ToString();
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (Instance == this) Instance = null;
|
|
}
|
|
}
|
|
}
|