gopeak 2.1.0 → 2.2.1

package/build/addon/godot_mcp_editor/tool_executor.gd

@@ -0,0 +1,114 @@
+@tool
+extends Node
+class_name MCPToolExecutor
+
+var _editor_plugin: EditorPlugin = null
+
+var _scene_tools: Node = null
+var _resource_tools: Node = null
+var _animation_tools: Node = null
+
+var _tool_map: Dictionary = {}
+var _initialized := false
+
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+	_init_tools()
+
+	if _scene_tools and _scene_tools.has_method("set_editor_plugin"):
+		_scene_tools.set_editor_plugin(plugin)
+	if _resource_tools and _resource_tools.has_method("set_editor_plugin"):
+		_resource_tools.set_editor_plugin(plugin)
+	if _animation_tools and _animation_tools.has_method("set_editor_plugin"):
+		_animation_tools.set_editor_plugin(plugin)
+
+
+func _init_tools() -> void:
+	if _initialized:
+		return
+	_initialized = true
+
+	var base_path: String = get_script().resource_path.get_base_dir()
+	var scene_tools_path := "%s/tools/scene_tools.gd" % base_path
+	var resource_tools_path := "%s/tools/resource_tools.gd" % base_path
+	var animation_tools_path := "%s/tools/animation_tools.gd" % base_path
+
+	if ResourceLoader.exists(scene_tools_path):
+		var scene_script: Script = load(scene_tools_path)
+		if scene_script:
+			_scene_tools = scene_script.new()
+			_scene_tools.name = "SceneTools"
+			add_child(_scene_tools)
+
+	if ResourceLoader.exists(resource_tools_path):
+		var resource_script: Script = load(resource_tools_path)
+		if resource_script:
+			_resource_tools = resource_script.new()
+			_resource_tools.name = "ResourceTools"
+			add_child(_resource_tools)
+
+	if ResourceLoader.exists(animation_tools_path):
+		var animation_script: Script = load(animation_tools_path)
+		if animation_script:
+			_animation_tools = animation_script.new()
+			_animation_tools.name = "AnimationTools"
+			add_child(_animation_tools)
+
+	_tool_map = {
+		# Scene tools
+		"create_scene": [_scene_tools, "create_scene"],
+		"list_scene_nodes": [_scene_tools, "list_scene_nodes"],
+		"add_node": [_scene_tools, "add_node"],
+		"delete_node": [_scene_tools, "delete_node"],
+		"duplicate_node": [_scene_tools, "duplicate_node"],
+		"reparent_node": [_scene_tools, "reparent_node"],
+		"set_node_properties": [_scene_tools, "set_node_properties"],
+		"get_node_properties": [_scene_tools, "get_node_properties"],
+		"load_sprite": [_scene_tools, "load_sprite"],
+		"save_scene": [_scene_tools, "save_scene"],
+		"connect_signal": [_scene_tools, "connect_signal"],
+		"disconnect_signal": [_scene_tools, "disconnect_signal"],
+		"list_connections": [_scene_tools, "list_connections"],
+
+		# Resource tools
+		"create_resource": [_resource_tools, "create_resource"],
+		"modify_resource": [_resource_tools, "modify_resource"],
+		"create_material": [_resource_tools, "create_material"],
+		"create_shader": [_resource_tools, "create_shader"],
+		"create_tileset": [_resource_tools, "create_tileset"],
+		"set_tilemap_cells": [_resource_tools, "set_tilemap_cells"],
+		"set_theme_color": [_resource_tools, "set_theme_color"],
+		"set_theme_font_size": [_resource_tools, "set_theme_font_size"],
+		"apply_theme_shader": [_resource_tools, "apply_theme_shader"],
+
+		# Animation tools
+		"create_animation": [_animation_tools, "create_animation"],
+		"add_animation_track": [_animation_tools, "add_animation_track"],
+		"create_animation_tree": [_animation_tools, "create_animation_tree"],
+		"add_animation_state": [_animation_tools, "add_animation_state"],
+		"connect_animation_states": [_animation_tools, "connect_animation_states"],
+		"create_navigation_region": [_animation_tools, "create_navigation_region"],
+		"create_navigation_agent": [_animation_tools, "create_navigation_agent"]
+	}
+
+
+func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
+	if not _tool_map.has(tool_name):
+		return {"ok": false, "error": "Unknown tool: " + tool_name}
+
+	var handler: Array = _tool_map[tool_name]
+	var node: Node = handler[0]
+	var method: String = handler[1]
+
+	if node == null:
+		return {"ok": false, "error": "Tool handler unavailable: " + tool_name}
+
+	if not node.has_method(method):
+		return {"ok": false, "error": "Tool method not found: %s.%s" % [node.name, method]}
+
+	var result = node.call(method, args)
+	if result is Dictionary:
+		return result
+
+	return {"ok": false, "error": "Invalid tool result from: " + tool_name}

package/build/addon/godot_mcp_editor/tools/animation_tools.gd

@@ -0,0 +1,502 @@
+@tool
+extends Node
+class_name MCPAnimationTools
+
+var _editor_plugin: EditorPlugin = null
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+
+
+# =============================================================================
+# Shared helpers
+# =============================================================================
+func _ensure_res_path(path: String) -> String:
+	if not path.begins_with("res://"): return "res://" + path
+	return path
+
+func _refresh_and_reload(scene_path: String) -> void:
+	_refresh_filesystem()
+	_reload_scene_in_editor(scene_path)
+
+func _refresh_filesystem() -> void:
+	if _editor_plugin:
+		EditorInterface.get_resource_filesystem().scan()
+
+func _reload_scene_in_editor(scene_path: String) -> void:
+	if not _editor_plugin: return
+	var edited = EditorInterface.get_edited_scene_root()
+	if edited and edited.scene_file_path == scene_path:
+		EditorInterface.reload_scene_from_path(scene_path)
+
+func _load_scene(scene_path: String) -> Array:
+	if not FileAccess.file_exists(scene_path):
+		return [null, {"ok": false, "error": "Scene not found: " + scene_path}]
+	var packed = load(scene_path) as PackedScene
+	if not packed: return [null, {"ok": false, "error": "Failed to load: " + scene_path}]
+	var root = packed.instantiate()
+	if not root: return [null, {"ok": false, "error": "Failed to instantiate: " + scene_path}]
+	return [root, {}]
+
+func _save_scene(scene_root: Node, scene_path: String) -> Dictionary:
+	var packed = PackedScene.new()
+	if packed.pack(scene_root) != OK:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Failed to pack scene"}
+	if ResourceSaver.save(packed, scene_path) != OK:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Failed to save scene"}
+	scene_root.queue_free()
+	_refresh_and_reload(scene_path)
+	return {}
+
+func _find_node(root: Node, path: String) -> Node:
+	if path == "." or path.is_empty(): return root
+	return root.get_node_or_null(path)
+
+func _parse_value(value):
+	if typeof(value) == TYPE_DICTIONARY:
+		if value.has("type") or value.has("_type"):
+			var t = value.get("type", value.get("_type", ""))
+			match t:
+				"Vector2": return Vector2(value.get("x",0), value.get("y",0))
+				"Vector3": return Vector3(value.get("x",0), value.get("y",0), value.get("z",0))
+				"Color": return Color(value.get("r",1), value.get("g",1), value.get("b",1), value.get("a",1))
+	if typeof(value) == TYPE_ARRAY:
+		var result = []
+		for item in value:
+			result.append(_parse_value(item))
+		return result
+	return value
+
+func _parse_json_maybe(value):
+	if typeof(value) != TYPE_STRING:
+		return value
+	var parsed = JSON.parse_string(value)
+	if parsed == null and value != "null":
+		return value
+	return parsed
+
+func _parse_method_args(raw_args: Array) -> Array:
+	var parsed_args: Array = []
+	for raw_arg in raw_args:
+		var parsed = _parse_json_maybe(raw_arg)
+		parsed_args.append(_parse_value(parsed))
+	return parsed_args
+
+func _get_default_animation_library(player: AnimationPlayer) -> AnimationLibrary:
+	var anim_lib: AnimationLibrary = player.get_animation_library("")
+	if anim_lib:
+		return anim_lib
+	anim_lib = AnimationLibrary.new()
+	var add_lib_err := player.add_animation_library("", anim_lib)
+	if add_lib_err != OK:
+		return null
+	return anim_lib
+
+func _get_state_machine(anim_tree: AnimationTree, state_machine_path: String = "") -> AnimationNodeStateMachine:
+	if not anim_tree:
+		return null
+	if state_machine_path.is_empty() or state_machine_path == "root":
+		return anim_tree.tree_root as AnimationNodeStateMachine
+
+	var current = anim_tree.tree_root
+	for segment in state_machine_path.split("/", false):
+		if String(segment).is_empty():
+			continue
+		if current == null or not current.has_method("get_node"):
+			return null
+		current = current.call("get_node", StringName(segment))
+	return current as AnimationNodeStateMachine
+
+
+# =============================================================================
+# create_animation
+# =============================================================================
+func create_animation(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var player_node_path: String = str(args.get("playerNodePath", "."))
+	var animation_name: String = str(args.get("animationName", ""))
+	var loop_mode_name: String = str(args.get("loopMode", "none"))
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if animation_name.strip_edges().is_empty():
+		return {"ok": false, "error": "Missing animationName"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var player = _find_node(scene_root, player_node_path) as AnimationPlayer
+	if not player:
+		scene_root.queue_free()
+		return {"ok": false, "error": "AnimationPlayer not found at: " + player_node_path}
+
+	var anim_lib := _get_default_animation_library(player)
+	if not anim_lib:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Failed to create default AnimationLibrary"}
+	if anim_lib.has_animation(StringName(animation_name)):
+		scene_root.queue_free()
+		return {"ok": false, "error": "Animation already exists: " + animation_name}
+
+	var loop_mode := Animation.LOOP_NONE
+	match loop_mode_name:
+		"linear": loop_mode = Animation.LOOP_LINEAR
+		"pingpong": loop_mode = Animation.LOOP_PINGPONG
+		_:
+			loop_mode_name = "none"
+			loop_mode = Animation.LOOP_NONE
+
+	var anim = Animation.new()
+	anim.length = float(args.get("length", 1.0))
+	anim.loop_mode = loop_mode
+	anim.step = float(args.get("step", 0.1))
+
+	var add_err := anim_lib.add_animation(StringName(animation_name), anim)
+	if add_err != OK:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Failed to add animation: " + str(add_err)}
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {
+		"ok": true,
+		"animationName": animation_name,
+		"length": anim.length,
+		"loopMode": loop_mode_name,
+	}
+
+
+# =============================================================================
+# add_animation_track
+# =============================================================================
+func add_animation_track(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var player_node_path: String = str(args.get("playerNodePath", "."))
+	var animation_name: String = str(args.get("animationName", ""))
+	var track: Dictionary = args.get("track", {})
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if animation_name.strip_edges().is_empty():
+		return {"ok": false, "error": "Missing animationName"}
+	if track.is_empty():
+		return {"ok": false, "error": "Missing track"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var player = _find_node(scene_root, player_node_path) as AnimationPlayer
+	if not player:
+		scene_root.queue_free()
+		return {"ok": false, "error": "AnimationPlayer not found at: " + player_node_path}
+
+	var anim_lib: AnimationLibrary = player.get_animation_library("")
+	if not anim_lib:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Default AnimationLibrary not found"}
+
+	var anim: Animation = anim_lib.get_animation(StringName(animation_name))
+	if not anim:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Animation not found: " + animation_name}
+
+	var track_type: String = str(track.get("type", ""))
+	var track_idx := -1
+	var keyframes: Array = track.get("keyframes", [])
+
+	match track_type:
+		"property":
+			var node_path_str: String = str(track.get("nodePath", ""))
+			var prop_name: String = str(track.get("property", ""))
+			if prop_name.is_empty():
+				scene_root.queue_free()
+				return {"ok": false, "error": "track.property is required for property track"}
+			track_idx = anim.add_track(Animation.TYPE_VALUE)
+			anim.track_set_path(track_idx, NodePath(node_path_str + ":" + prop_name))
+			for keyframe in keyframes:
+				if typeof(keyframe) != TYPE_DICTIONARY:
+					continue
+				var raw_value = keyframe.get("value")
+				var parsed_value = _parse_json_maybe(raw_value) if typeof(raw_value) == TYPE_STRING else raw_value
+				anim.track_insert_key(track_idx, float(keyframe.get("time", 0.0)), _parse_value(parsed_value))
+
+		"method":
+			var method_node_path: String = str(track.get("nodePath", ""))
+			var method_name: String = str(track.get("method", ""))
+			if method_name.is_empty():
+				scene_root.queue_free()
+				return {"ok": false, "error": "track.method is required for method track"}
+			track_idx = anim.add_track(Animation.TYPE_METHOD)
+			anim.track_set_path(track_idx, NodePath(method_node_path))
+			for keyframe in keyframes:
+				if typeof(keyframe) != TYPE_DICTIONARY:
+					continue
+				anim.track_insert_key(
+					track_idx,
+					float(keyframe.get("time", 0.0)),
+					{
+						"method": method_name,
+						"args": _parse_method_args(keyframe.get("args", [])),
+					}
+				)
+
+		_:
+			scene_root.queue_free()
+			return {"ok": false, "error": "Unsupported track.type: " + track_type}
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {"ok": true, "trackType": track_type, "trackIndex": track_idx}
+
+
+# =============================================================================
+# create_animation_tree
+# =============================================================================
+func create_animation_tree(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var parent_path: String = str(args.get("parentPath", "."))
+	var node_name: String = str(args.get("nodeName", "AnimationTree"))
+	var anim_player_path: String = str(args.get("animPlayerPath", ""))
+	var root_type: String = str(args.get("rootType", "StateMachine"))
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if anim_player_path.is_empty():
+		return {"ok": false, "error": "Missing animPlayerPath"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var parent = _find_node(scene_root, parent_path)
+	if not parent:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Parent node not found: " + parent_path}
+
+	var anim_tree := AnimationTree.new()
+	anim_tree.name = node_name
+	anim_tree.anim_player = NodePath(anim_player_path)
+
+	var root = null
+	match root_type:
+		"StateMachine": root = AnimationNodeStateMachine.new()
+		"BlendTree": root = AnimationNodeBlendTree.new()
+		"BlendSpace1D": root = AnimationNodeBlendSpace1D.new()
+		"BlendSpace2D": root = AnimationNodeBlendSpace2D.new()
+		_:
+			scene_root.queue_free()
+			return {"ok": false, "error": "Unsupported rootType: " + root_type}
+
+	anim_tree.tree_root = root
+	parent.add_child(anim_tree)
+	anim_tree.owner = scene_root
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {"ok": true, "nodeName": node_name, "rootType": root_type}
+
+
+# =============================================================================
+# add_animation_state
+# =============================================================================
+func add_animation_state(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var anim_tree_path: String = str(args.get("animTreePath", ""))
+	var state_name: String = str(args.get("stateName", ""))
+	var animation_name: String = str(args.get("animationName", ""))
+	var state_machine_path: String = str(args.get("stateMachinePath", ""))
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if anim_tree_path.is_empty():
+		return {"ok": false, "error": "Missing animTreePath"}
+	if state_name.is_empty():
+		return {"ok": false, "error": "Missing stateName"}
+	if animation_name.is_empty():
+		return {"ok": false, "error": "Missing animationName"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var anim_tree = _find_node(scene_root, anim_tree_path) as AnimationTree
+	if not anim_tree:
+		scene_root.queue_free()
+		return {"ok": false, "error": "AnimationTree not found at: " + anim_tree_path}
+
+	var sm := _get_state_machine(anim_tree, state_machine_path)
+	if not sm:
+		scene_root.queue_free()
+		return {"ok": false, "error": "AnimationNodeStateMachine not found"}
+
+	var anim_node := AnimationNodeAnimation.new()
+	anim_node.animation = StringName(animation_name)
+	sm.add_node(StringName(state_name), anim_node)
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {"ok": true, "stateName": state_name, "animationName": animation_name}
+
+
+# =============================================================================
+# connect_animation_states
+# =============================================================================
+func connect_animation_states(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var anim_tree_path: String = str(args.get("animTreePath", ""))
+	var from_state: String = str(args.get("fromState", ""))
+	var to_state: String = str(args.get("toState", ""))
+	var transition_type: String = str(args.get("transitionType", "immediate"))
+	var state_machine_path: String = str(args.get("stateMachinePath", ""))
+	var advance_condition: String = str(args.get("advanceCondition", ""))
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if anim_tree_path.is_empty():
+		return {"ok": false, "error": "Missing animTreePath"}
+	if from_state.is_empty() or to_state.is_empty():
+		return {"ok": false, "error": "Missing fromState or toState"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var anim_tree = _find_node(scene_root, anim_tree_path) as AnimationTree
+	if not anim_tree:
+		scene_root.queue_free()
+		return {"ok": false, "error": "AnimationTree not found at: " + anim_tree_path}
+
+	var sm := _get_state_machine(anim_tree, state_machine_path)
+	if not sm:
+		scene_root.queue_free()
+		return {"ok": false, "error": "AnimationNodeStateMachine not found"}
+
+	var transition := AnimationNodeStateMachineTransition.new()
+	match transition_type:
+		"sync": transition.switch_mode = AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC
+		"at_end": transition.switch_mode = AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END
+		"immediate": transition.switch_mode = AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE
+		_:
+			scene_root.queue_free()
+			return {"ok": false, "error": "Unsupported transitionType: " + transition_type}
+
+	if not advance_condition.is_empty():
+		transition.advance_condition = StringName(advance_condition)
+
+	sm.add_transition(StringName(from_state), StringName(to_state), transition)
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {"ok": true, "from": from_state, "to": to_state}
+
+
+# =============================================================================
+# create_navigation_region
+# =============================================================================
+func create_navigation_region(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var parent_path: String = str(args.get("parentPath", "."))
+	var node_name: String = str(args.get("nodeName", "NavigationRegion"))
+	var is_3d: bool = bool(args.get("is3D", false))
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var parent = _find_node(scene_root, parent_path)
+	if not parent:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Parent node not found: " + parent_path}
+
+	var nav: Node = null
+	if is_3d:
+		var nav3d := NavigationRegion3D.new()
+		nav3d.navigation_mesh = NavigationMesh.new()
+		nav = nav3d
+	else:
+		var nav2d := NavigationRegion2D.new()
+		nav2d.navigation_polygon = NavigationPolygon.new()
+		nav = nav2d
+
+	nav.name = node_name
+	parent.add_child(nav)
+	nav.owner = scene_root
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {"ok": true, "nodeName": node_name, "is3D": is_3d}
+
+
+# =============================================================================
+# create_navigation_agent
+# =============================================================================
+func create_navigation_agent(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var parent_path: String = str(args.get("parentPath", "."))
+	var node_name: String = str(args.get("nodeName", "NavigationAgent"))
+	var is_3d: bool = bool(args.get("is3D", false))
+
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+
+	var loaded := _load_scene(scene_path)
+	if not loaded[1].is_empty():
+		return loaded[1]
+
+	var scene_root: Node = loaded[0]
+	var parent = _find_node(scene_root, parent_path)
+	if not parent:
+		scene_root.queue_free()
+		return {"ok": false, "error": "Parent node not found: " + parent_path}
+
+	var agent: Node = null
+	if is_3d:
+		var agent3d := NavigationAgent3D.new()
+		agent3d.name = node_name
+		if args.has("pathDesiredDistance") and args.get("pathDesiredDistance") != null:
+			agent3d.path_desired_distance = float(args.get("pathDesiredDistance"))
+		if args.has("targetDesiredDistance") and args.get("targetDesiredDistance") != null:
+			agent3d.target_desired_distance = float(args.get("targetDesiredDistance"))
+		agent = agent3d
+	else:
+		var agent2d := NavigationAgent2D.new()
+		agent2d.name = node_name
+		if args.has("pathDesiredDistance") and args.get("pathDesiredDistance") != null:
+			agent2d.path_desired_distance = float(args.get("pathDesiredDistance"))
+		if args.has("targetDesiredDistance") and args.get("targetDesiredDistance") != null:
+			agent2d.target_desired_distance = float(args.get("targetDesiredDistance"))
+		agent = agent2d
+
+	parent.add_child(agent)
+	agent.owner = scene_root
+
+	var save_err := _save_scene(scene_root, scene_path)
+	if not save_err.is_empty():
+		return save_err
+
+	return {"ok": true, "nodeName": node_name, "is3D": is_3d}