305 lines
12 KiB
C#
305 lines
12 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;
|
|
|
|
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/PanelSettings — 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.
|
|
///
|
|
/// Supports one command so far: "get <type> <name>" grants a
|
|
/// <see cref="TD.Gameplay.Draft.DraftOption"/> to the local player via
|
|
/// <see cref="DebugCommandRelay"/>.
|
|
/// </remarks>
|
|
[RequireComponent(typeof(UIDocument))]
|
|
public class DebugConsole : MonoBehaviour
|
|
{
|
|
public static DebugConsole Instance { get; private set; }
|
|
|
|
[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 VisualElement consoleContainer;
|
|
private TextField commandInput;
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
BuildConsoleUi(root);
|
|
}
|
|
|
|
private void BuildConsoleUi(VisualElement uiRoot)
|
|
{
|
|
// Top-anchored bar, closed by default. Distinct position from the HUD's
|
|
// bottom-left chat panel so the two never overlap.
|
|
consoleContainer = new VisualElement();
|
|
consoleContainer.pickingMode = PickingMode.Ignore;
|
|
consoleContainer.style.position = Position.Absolute;
|
|
consoleContainer.style.left = 0;
|
|
consoleContainer.style.right = 0;
|
|
consoleContainer.style.top = 0;
|
|
consoleContainer.style.paddingTop = 8;
|
|
consoleContainer.style.paddingBottom = 8;
|
|
consoleContainer.style.paddingLeft = 12;
|
|
consoleContainer.style.paddingRight = 12;
|
|
consoleContainer.style.backgroundColor = new Color(0f, 0f, 0f, 0.75f);
|
|
consoleContainer.style.display = DisplayStyle.None;
|
|
|
|
commandInput = new TextField();
|
|
commandInput.style.minHeight = 28;
|
|
commandInput.style.width = Length.Percent(100);
|
|
commandInput.maxLength = 200;
|
|
commandInput.isDelayed = false;
|
|
StyleConsoleInput(commandInput);
|
|
|
|
// 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.
|
|
commandInput.RegisterCallback<FocusInEvent>(_ => HUDController.IsTextInputActive = true);
|
|
commandInput.RegisterCallback<FocusOutEvent>(_ => HUDController.IsTextInputActive = false);
|
|
|
|
consoleContainer.Add(commandInput);
|
|
uiRoot.Add(consoleContainer);
|
|
}
|
|
|
|
// Mirrors HUDController.StyleChatInputDark — dark background, white text,
|
|
// a thin border, and inner padding so ascenders/descenders don't clip.
|
|
// Green border (vs. chat's neutral gray) as a quick visual "this is the
|
|
// debug console, not chat" cue.
|
|
private static void StyleConsoleInput(TextField field)
|
|
{
|
|
var darkBg = new Color(0.05f, 0.05f, 0.05f, 0.95f);
|
|
var borderClr = new Color(0.35f, 0.75f, 0.35f);
|
|
|
|
field.style.backgroundColor = darkBg;
|
|
field.style.color = Color.white;
|
|
field.style.borderTopWidth = field.style.borderBottomWidth =
|
|
field.style.borderLeftWidth = field.style.borderRightWidth = 1;
|
|
field.style.borderTopColor = field.style.borderBottomColor =
|
|
field.style.borderLeftColor = field.style.borderRightColor = borderClr;
|
|
|
|
var inner = field.Q("unity-text-input");
|
|
if (inner != null)
|
|
{
|
|
inner.style.backgroundColor = darkBg;
|
|
inner.style.color = Color.white;
|
|
inner.style.paddingTop = 4;
|
|
inner.style.paddingBottom = 4;
|
|
inner.style.paddingLeft = 6;
|
|
inner.style.paddingRight = 6;
|
|
}
|
|
}
|
|
|
|
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 OpenConsole()
|
|
{
|
|
if (commandInput == null) return;
|
|
consoleContainer.style.display = DisplayStyle.Flex;
|
|
consoleContainer.pickingMode = PickingMode.Position;
|
|
commandInput.SetValueWithoutNotify(string.Empty);
|
|
|
|
// 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 && commandInput != null)
|
|
{
|
|
commandInput.Focus();
|
|
commandInput.SelectAll();
|
|
}
|
|
}
|
|
|
|
private void CloseConsole()
|
|
{
|
|
if (commandInput != null)
|
|
{
|
|
commandInput.SetValueWithoutNotify(string.Empty);
|
|
commandInput.Blur();
|
|
}
|
|
if (consoleContainer != null)
|
|
{
|
|
consoleContainer.style.display = DisplayStyle.None;
|
|
consoleContainer.pickingMode = PickingMode.Ignore;
|
|
}
|
|
|
|
consoleOpen = false;
|
|
toggleSuppressFrame = Time.frameCount + 1;
|
|
|
|
// The Enter that submitted/cancelled this console also gets polled by
|
|
// HUDController's chat this same frame — suppress its "Enter opens chat"
|
|
// branch so closing the debug console doesn't pop chat open too.
|
|
HUDController.SuppressChatOpenUntilFrame = Time.frameCount + 1;
|
|
}
|
|
|
|
private void SubmitCommand()
|
|
{
|
|
string text = commandInput?.value ?? string.Empty;
|
|
CloseConsole();
|
|
|
|
if (string.IsNullOrWhiteSpace(text)) return;
|
|
ExecuteCommand(text.Trim());
|
|
}
|
|
|
|
// 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.
|
|
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 void ExecuteCommand(string text)
|
|
{
|
|
string[] tokens = text.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
|
|
if (tokens.Length < 3 || !string.Equals(tokens[0], "get", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
Debug.Log($"[DebugConsole] Unrecognized command: \"{text}\". Try: get <type> <name>");
|
|
return;
|
|
}
|
|
|
|
string nameToken = string.Join(" ", tokens, 2, tokens.Length - 2);
|
|
ExecuteGet(tokens[1], 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 void ExecuteGet(string typeToken, string nameToken)
|
|
{
|
|
if (!DraftTypeAliases.TryGetValue(typeToken, out var optionType))
|
|
{
|
|
Debug.LogWarning($"[DebugConsole] Unknown draft option type \"{typeToken}\". " +
|
|
$"Valid types: {string.Join(", ", DraftTypeAliases.Keys)}");
|
|
return;
|
|
}
|
|
|
|
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.");
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
}
|