@satelliteoflove/godot-mcp 3.16.0 → 3.18.0

package/addon/commands/input_commands.gd

@@ -115,15 +115,7 @@ func _get_editor_input_map() -> Dictionary:
 
 func _event_to_string(event: InputEvent) -> String:
 	if event is InputEventKey:
-		var key_event := event as InputEventKey
-		var key_name := OS.get_keycode_string(key_event.keycode)
-		if key_event.ctrl_pressed:
-			key_name = "Ctrl+" + key_name
-		if key_event.alt_pressed:
-			key_name = "Alt+" + key_name
-		if key_event.shift_pressed:
-			key_name = "Shift+" + key_name
-		return key_name
+		return MCPKeyNames.event_string(event as InputEventKey)
 	elif event is InputEventMouseButton:
 		var mouse_event := event as InputEventMouseButton
 		match mouse_event.button_index:
@@ -137,10 +129,12 @@ func _event_to_string(event: InputEvent) -> String:
 				return "Mouse Button %d" % mouse_event.button_index
 	elif event is InputEventJoypadButton:
 		var joy_event := event as InputEventJoypadButton
-		return "Joypad Button %d" % joy_event.button_index
+		return "Joypad Button %d (%s)" % [joy_event.button_index, MCPJoyNames.button_name(joy_event.button_index)]
 	elif event is InputEventJoypadMotion:
+		# The signed axis_value is the direction bit an agent needs to lift the
+		# binding straight into an injection (e.g. move_left = left_x, value -1.0).
 		var joy_motion := event as InputEventJoypadMotion
-		return "Joypad Axis %d" % joy_motion.axis
+		return "Joypad Axis %d (%s, value %+.1f)" % [joy_motion.axis, MCPJoyNames.axis_name(joy_motion.axis), joy_motion.axis_value]
 	return event.as_text()
 
 

package/addon/game_bridge/joy_names.gd

@@ -0,0 +1,68 @@
+@tool
+class_name MCPJoyNames
+extends RefCounted
+## Canonical joypad name<->index tables, shared by the game bridge (event
+## injection) and the editor input commands (get_input_map display) so the
+## wire vocabulary and the displayed names can never drift apart.
+
+const BUTTONS := {
+	"a": JOY_BUTTON_A,
+	"b": JOY_BUTTON_B,
+	"x": JOY_BUTTON_X,
+	"y": JOY_BUTTON_Y,
+	"back": JOY_BUTTON_BACK,
+	"guide": JOY_BUTTON_GUIDE,
+	"start": JOY_BUTTON_START,
+	"left_stick": JOY_BUTTON_LEFT_STICK,
+	"right_stick": JOY_BUTTON_RIGHT_STICK,
+	"left_shoulder": JOY_BUTTON_LEFT_SHOULDER,
+	"right_shoulder": JOY_BUTTON_RIGHT_SHOULDER,
+	"dpad_up": JOY_BUTTON_DPAD_UP,
+	"dpad_down": JOY_BUTTON_DPAD_DOWN,
+	"dpad_left": JOY_BUTTON_DPAD_LEFT,
+	"dpad_right": JOY_BUTTON_DPAD_RIGHT,
+	"misc1": JOY_BUTTON_MISC1,
+	"paddle1": JOY_BUTTON_PADDLE1,
+	"paddle2": JOY_BUTTON_PADDLE2,
+	"paddle3": JOY_BUTTON_PADDLE3,
+	"paddle4": JOY_BUTTON_PADDLE4,
+	"touchpad": JOY_BUTTON_TOUCHPAD,
+}
+
+const AXES := {
+	"left_x": JOY_AXIS_LEFT_X,
+	"left_y": JOY_AXIS_LEFT_Y,
+	"right_x": JOY_AXIS_RIGHT_X,
+	"right_y": JOY_AXIS_RIGHT_Y,
+	"trigger_left": JOY_AXIS_TRIGGER_LEFT,
+	"trigger_right": JOY_AXIS_TRIGGER_RIGHT,
+}
+
+
+## Resolve a wire value (name string, or raw index as an escape hatch) to a
+## JoyButton index. Returns -1 for anything unknown.
+static func button_index(value: Variant) -> int:
+	if value is int or value is float:
+		var i := int(value)
+		return i if i >= 0 and i < JOY_BUTTON_SDL_MAX else -1
+	return int(BUTTONS.get(str(value), -1))
+
+
+## Resolve a wire axis name to a JoyAxis index. Names only — the name itself
+## is what tells an agent trigger (0..1) from stick (-1..1). Returns -1 if unknown.
+static func axis_index(value: Variant) -> int:
+	return int(AXES.get(str(value), -1))
+
+
+static func button_name(idx: int) -> String:
+	for n in BUTTONS:
+		if int(BUTTONS[n]) == idx:
+			return n
+	return "button_%d" % idx
+
+
+static func axis_name(idx: int) -> String:
+	for n in AXES:
+		if int(AXES[n]) == idx:
+			return n
+	return "axis_%d" % idx

package/addon/game_bridge/joy_names.gd.uid

@@ -0,0 +1 @@
+uid://row4hmo5gdem

package/addon/game_bridge/key_names.gd

@@ -0,0 +1,133 @@
+@tool
+class_name MCPKeyNames
+extends RefCounted
+## Canonical keyboard name<->keycode parsing/formatting (#290), shared by the
+## game bridge (raw InputEventKey injection) and the editor input commands
+## (get_input_map display) so the wire vocabulary and the displayed names can
+## never drift apart.
+##
+## Why this exists rather than calling OS.find_keycode_from_string directly:
+## that engine helper parses Ctrl/Shift/Alt prefixes but SILENTLY DROPS Meta/Cmd
+## (verified Godot 4.6 — "Meta+Q" returns a bare KEY_Q). We split modifiers here
+## ourselves so meta round-trips, and only hand the base token to the engine.
+
+## Modifier token -> key mask. Case-insensitive (callers lowercase first).
+## Aliases cover the common cross-platform spellings agents reach for.
+const MODIFIERS := {
+	"ctrl": KEY_MASK_CTRL,
+	"control": KEY_MASK_CTRL,
+	"shift": KEY_MASK_SHIFT,
+	"alt": KEY_MASK_ALT,
+	"option": KEY_MASK_ALT,
+	"opt": KEY_MASK_ALT,
+	"meta": KEY_MASK_META,
+	"cmd": KEY_MASK_META,
+	"command": KEY_MASK_META,
+	"super": KEY_MASK_META,
+	"win": KEY_MASK_META,
+}
+
+## Key mask -> the modifier's own keycode, so a combo can press each modifier as
+## a real key (the only way is_key_pressed(KEY_CTRL) ever reads true — the
+## modifier FLAG on another event does not update the polled singleton).
+const MODIFIER_KEYCODES := {
+	KEY_MASK_CTRL: KEY_CTRL,
+	KEY_MASK_SHIFT: KEY_SHIFT,
+	KEY_MASK_ALT: KEY_ALT,
+	KEY_MASK_META: KEY_META,
+}
+
+# The four modifier masks, in canonical display/iteration order.
+const _MOD_ORDER: Array = [KEY_MASK_CTRL, KEY_MASK_SHIFT, KEY_MASK_ALT, KEY_MASK_META]
+const _MOD_TOKENS := {
+	KEY_MASK_CTRL: "Ctrl",
+	KEY_MASK_SHIFT: "Shift",
+	KEY_MASK_ALT: "Alt",
+	KEY_MASK_META: "Meta",
+}
+
+
+## Parse a wire key value into {code:int, mask:int}. Accepts a string with
+## optional modifier prefixes ("a", "Escape", "ctrl+s", "shift+alt+f1") or a raw
+## Godot Key enum int (which may carry modifier mask bits). Returns code = KEY_NONE
+## (0) for anything that does not resolve to a base key, which the caller turns
+## into an "Unknown key" error.
+static func parse(value: Variant) -> Dictionary:
+	if value is int or value is float:
+		var raw := int(value)
+		return {"code": raw & ~int(KEY_MODIFIER_MASK), "mask": raw & int(KEY_MODIFIER_MASK)}
+
+	var s := str(value).strip_edges()
+	if s.is_empty():
+		return {"code": KEY_NONE, "mask": 0}
+
+	var mask := 0
+	var base := ""
+	for part in s.split("+", false):
+		var token := String(part).strip_edges()
+		if token.is_empty():
+			continue
+		var lower := token.to_lower()
+		if MODIFIERS.has(lower):
+			mask |= int(MODIFIERS[lower])
+		else:
+			# The last non-modifier token wins as the base (a stray extra base
+			# would just overwrite, which is fine — a malformed combo resolves to
+			# whatever its final base token is, or KEY_NONE if none resolves).
+			base = token
+
+	if base.is_empty():
+		# A lone modifier name ("shift", "ctrl", "cmd") means the modifier KEY
+		# itself — e.g. a game binding bare Shift, or polling is_key_pressed(KEY_CTRL).
+		# Exactly one modifier resolves to its keycode; a baseless multi-modifier
+		# combo ("ctrl+shift") is ambiguous and stays unknown.
+		for m in _MOD_ORDER:
+			if mask == int(m):
+				return {"code": int(MODIFIER_KEYCODES[m]), "mask": 0}
+		return {"code": KEY_NONE, "mask": mask}
+
+	# find_keycode_from_string handles Ctrl/Shift/Alt itself; strip any mask bits
+	# it folded in so `code` is always a bare base keycode.
+	var resolved := int(OS.find_keycode_from_string(base))
+	mask |= resolved & int(KEY_MODIFIER_MASK)
+	var code := resolved & ~int(KEY_MODIFIER_MASK)
+	return {"code": code, "mask": mask}
+
+
+## The modifier keycodes (KEY_CTRL, ...) present in a mask, in canonical order,
+## so a combo can press each one as its own key event.
+static func modifier_key_indices(mask: int) -> Array:
+	var out: Array = []
+	for m in _MOD_ORDER:
+		if mask & int(m):
+			out.append(int(MODIFIER_KEYCODES[m]))
+	return out
+
+
+## Canonical display for a key binding (get_input_map). Modifier prefixes come
+## from the event's own flags with fixed tokens (platform-stable, and re-parseable
+## by parse() — unlike OS.get_keycode_string's mask spelling, which
+## find_keycode_from_string cannot read back for Meta). A logical key + modifier
+## combo round-trips through parse(); a physical-only binding (keycode unset)
+## renders from physical_keycode with a "(physical)" marker that tells an agent to
+## inject with physical:true — that marker is display-only, not re-parseable.
+static func event_string(event: InputEventKey) -> String:
+	var prefix := ""
+	if event.ctrl_pressed:
+		prefix += _MOD_TOKENS[KEY_MASK_CTRL] + "+"
+	if event.shift_pressed:
+		prefix += _MOD_TOKENS[KEY_MASK_SHIFT] + "+"
+	if event.alt_pressed:
+		prefix += _MOD_TOKENS[KEY_MASK_ALT] + "+"
+	if event.meta_pressed:
+		prefix += _MOD_TOKENS[KEY_MASK_META] + "+"
+
+	if event.keycode != KEY_NONE:
+		var base := OS.get_keycode_string(event.keycode)
+		return prefix + (base if not base.is_empty() else "Key %d" % int(event.keycode))
+	if event.physical_keycode != KEY_NONE:
+		var pbase := OS.get_keycode_string(event.physical_keycode)
+		return prefix + (pbase if not pbase.is_empty() else "Key %d" % int(event.physical_keycode)) + " (physical)"
+	# Last resort: an event with neither keycode set (e.g. unicode-only).
+	var label := prefix.trim_suffix("+")
+	return label if not label.is_empty() else "(unset)"

package/addon/game_bridge/key_names.gd.uid

@@ -0,0 +1 @@
+uid://blya2h0lff4ar