gdharness 0.4.1

package/build/godot/addons/auto_reload/auto_reload.gd

@@ -0,0 +1,89 @@
+@tool
+extends EditorPlugin
+
+## Reloads the open scene and the scripts it carries when they change on disk, without the
+## editor's confirmation popup. Every edit made through gdharness lands on disk, and an editor
+## that keeps showing the old file is how a change reads as one that never happened. The
+## files are polled once a second; the editor's own watcher only fires on window focus.
+
+const CHECK_INTERVAL_SECONDS: float = 1.0
+
+var _timer: Timer
+## The last modification time seen, by path.
+var _watched_files: Dictionary = {}
+
+
+func _enter_tree() -> void:
+	_timer = Timer.new()
+	_timer.wait_time = CHECK_INTERVAL_SECONDS
+	_timer.timeout.connect(_check_for_changes)
+	add_child(_timer)
+	_timer.start()
+	_update_watched_files()
+
+
+func _exit_tree() -> void:
+	if _timer:
+		_timer.stop()
+		_timer.queue_free()
+
+
+func _update_watched_files() -> void:
+	var edited_scene: Node = EditorInterface.get_edited_scene_root()
+	if edited_scene and edited_scene.scene_file_path:
+		var path: String = edited_scene.scene_file_path
+		if not _watched_files.has(path):
+			_watched_files[path] = _get_modified_time(path)
+		_watch_node_scripts(edited_scene)
+
+
+func _watch_node_scripts(node: Node) -> void:
+	var script: Variant = node.get_script()
+	if script is Script:
+		var attached: Script = script
+		var path: String = attached.resource_path
+		if not path.is_empty() and not _watched_files.has(path):
+			_watched_files[path] = _get_modified_time(path)
+	for child: Node in node.get_children():
+		_watch_node_scripts(child)
+
+
+func _get_modified_time(path: String) -> int:
+	var global_path: String = ProjectSettings.globalize_path(path)
+	if FileAccess.file_exists(global_path):
+		return FileAccess.get_modified_time(global_path)
+	return 0
+
+
+func _check_for_changes() -> void:
+	_update_watched_files()
+
+	var scenes_to_reload: Array[String] = []
+	var scripts_to_reload: Array[String] = []
+	for path: String in _watched_files.keys():
+		var current_time: int = _get_modified_time(path)
+		var last_time: int = _watched_files[path]
+		if current_time > last_time:
+			if path.ends_with(".gd"):
+				scripts_to_reload.append(path)
+			else:
+				scenes_to_reload.append(path)
+			_watched_files[path] = current_time
+
+	# Scripts first, so a scene reloaded after them instantiates the new code.
+	for path: String in scripts_to_reload:
+		_reload_script(path)
+	for path: String in scenes_to_reload:
+		_reload_scene(path)
+
+
+func _reload_script(path: String) -> void:
+	print("[gdharness] Script changed on disk, reloading: ", path)
+	ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
+
+
+func _reload_scene(path: String) -> void:
+	var edited_scene: Node = EditorInterface.get_edited_scene_root()
+	if edited_scene and edited_scene.scene_file_path == path:
+		print("[gdharness] Scene changed on disk, reloading: ", path)
+		EditorInterface.reload_scene_from_path(path)

package/build/godot/addons/auto_reload/plugin.cfg

@@ -0,0 +1,6 @@
+[plugin]
+name="gdharness auto reload"
+description="Reloads scenes and scripts in the editor when a file changes on disk, which is how every edit made through gdharness arrives."
+author="gdharness"
+version="0.1.0"
+script="auto_reload.gd"

package/build/godot/addons/gdharness_editor/bridge_client.gd

@@ -0,0 +1,197 @@
+@tool
+extends Node
+
+## The editor's end of the bridge: one WebSocket to the gdharness server, reconnected on its
+## own when it drops, carrying tool requests in and their results out.
+
+signal connected
+signal disconnected
+signal tool_requested(request_id: String, tool_name: String, args: Dictionary)
+
+const DEFAULT_URL: String = "ws://127.0.0.1:6505/godot"
+## Written beside the addon by the install, so it names the version this copy came from.
+const VERSION_MARKER: String = "res://addons/gdharness_editor/.gdharness-version"
+const RECONNECT_DELAY: float = 3.0
+const MAX_RECONNECT_DELAY: float = 30.0
+
+var socket: WebSocketPeer = WebSocketPeer.new()
+var server_url: String = DEFAULT_URL
+var _is_connected: bool = false
+var _reconnect_timer: Timer
+var _current_reconnect_delay: float = RECONNECT_DELAY
+var _should_reconnect: bool = true
+var _project_path: String
+var _initialized: bool = false
+
+
+func _ready() -> void:
+	_project_path = ProjectSettings.globalize_path("res://")
+
+	_reconnect_timer = Timer.new()
+	_reconnect_timer.one_shot = true
+	_reconnect_timer.timeout.connect(_on_reconnect_timer)
+	add_child(_reconnect_timer)
+
+	set_process(true)
+	_initialized = true
+
+
+func _process(_delta: float) -> void:
+	if not _initialized:
+		return
+
+	if socket.get_ready_state() == WebSocketPeer.STATE_CLOSED:
+		if _is_connected:
+			_handle_disconnect()
+		return
+
+	socket.poll()
+
+	match socket.get_ready_state():
+		WebSocketPeer.STATE_OPEN:
+			if not _is_connected:
+				_handle_connect()
+
+			while socket.get_available_packet_count() > 0:
+				var packet: PackedByteArray = socket.get_packet()
+				_handle_message(packet.get_string_from_utf8())
+
+		WebSocketPeer.STATE_CLOSING:
+			pass
+
+		WebSocketPeer.STATE_CLOSED:
+			if _is_connected:
+				_handle_disconnect()
+
+
+func connect_to_server(url: String = "") -> void:
+	server_url = _resolve_server_url(url)
+	_should_reconnect = true
+	_current_reconnect_delay = RECONNECT_DELAY
+	_attempt_connection()
+
+
+func _resolve_server_url(explicit_url: String) -> String:
+	if explicit_url != "":
+		return explicit_url
+
+	# The same variable the server reads, so the two agree on the port by construction.
+	var raw: String = OS.get_environment("GDHARNESS_BRIDGE_PORT")
+	if raw != "":
+		if raw.is_valid_int() and int(raw) >= 1 and int(raw) <= 65535:
+			return "ws://127.0.0.1:%d/godot" % int(raw)
+		push_error("GDHARNESS_BRIDGE_PORT is %s, not a port; using %s" % [raw, DEFAULT_URL])
+
+	return DEFAULT_URL
+
+
+func disconnect_from_server() -> void:
+	_should_reconnect = false
+	if _reconnect_timer:
+		_reconnect_timer.stop()
+	if socket.get_ready_state() == WebSocketPeer.STATE_OPEN:
+		socket.close()
+	_is_connected = false
+
+
+func _attempt_connection() -> void:
+	if socket.get_ready_state() != WebSocketPeer.STATE_CLOSED:
+		socket.close()
+
+	var err: Error = socket.connect_to_url(server_url)
+	if err != OK:
+		push_error("[gdharness] Failed to connect to %s: %s" % [server_url, error_string(err)])
+		_schedule_reconnect()
+
+
+func _handle_connect() -> void:
+	_is_connected = true
+	_current_reconnect_delay = RECONNECT_DELAY
+
+	# The version reported is the one this editor loaded at startup, not the one on disk: an
+	# upgrade replaces the files under a running editor, which goes on serving the old code until
+	# somebody restarts it, and nothing else can tell the two apart.
+	# The process id with it, because a restarted editor is a different process from the one
+	# whoever started it is holding, and nothing else says which one is now on the other end.
+	_send_message(
+		{
+			"type": "godot_ready",
+			"project_path": _project_path,
+			"addon_version": _loaded_version(),
+			"editor_pid": OS.get_process_id()
+		}
+	)
+
+	connected.emit()
+
+
+## The version marker beside this addon, or "" when the copy was not installed by gdharness.
+func _loaded_version() -> String:
+	if not FileAccess.file_exists(VERSION_MARKER):
+		return ""
+	var file: FileAccess = FileAccess.open(VERSION_MARKER, FileAccess.READ)
+	if file == null:
+		return ""
+	var text: String = file.get_as_text().strip_edges()
+	file.close()
+	return text
+
+
+func _handle_disconnect() -> void:
+	_is_connected = false
+	disconnected.emit()
+
+	if _should_reconnect:
+		_schedule_reconnect()
+
+
+func _schedule_reconnect() -> void:
+	if _reconnect_timer == null:
+		return
+	_reconnect_timer.start(_current_reconnect_delay)
+	_current_reconnect_delay = min(_current_reconnect_delay * 2.0, MAX_RECONNECT_DELAY)
+
+
+func _on_reconnect_timer() -> void:
+	_attempt_connection()
+
+
+func _handle_message(json_string: String) -> void:
+	var parsed: Variant = JSON.parse_string(json_string)
+	if not parsed is Dictionary:
+		push_error("[gdharness] The server sent something that is not a message: %s" % json_string)
+		return
+	var message: Dictionary = parsed
+
+	match message.get("type", ""):
+		"ping":
+			_send_message({"type": "pong"})
+
+		"tool_invoke":
+			var request_id: String = message.get("id", "")
+			var tool_name: String = message.get("tool", "")
+			var args: Dictionary = message.get("args", {})
+			tool_requested.emit(request_id, tool_name, args)
+
+		_:
+			pass
+
+
+func send_tool_result(request_id: String, success: bool, result: Variant = null, error: String = "") -> void:
+	var response: Dictionary = {"type": "tool_result", "id": request_id, "success": success}
+
+	if success:
+		response["result"] = result
+	else:
+		response["error"] = error
+
+	_send_message(response)
+
+
+func _send_message(message: Dictionary) -> void:
+	if socket.get_ready_state() == WebSocketPeer.STATE_OPEN:
+		socket.send_text(JSON.stringify(message))
+
+
+func is_connected_to_server() -> bool:
+	return _is_connected

package/build/godot/addons/gdharness_editor/plugin.cfg

@@ -0,0 +1,6 @@
+[plugin]
+name="gdharness editor"
+description="Connects the editor to the gdharness server, which drives scenes, resources and the filesystem through it."
+author="gdharness"
+version="0.1.0"
+script="plugin.gd"

package/build/godot/addons/gdharness_editor/plugin.gd

@@ -0,0 +1,88 @@
+@tool
+extends EditorPlugin
+
+## The editor half of gdharness: a client that holds a socket to the server and an executor
+## that does what the server asks, with a label in the toolbar saying whether the two are
+## connected.
+
+const BridgeClient = preload("bridge_client.gd")
+const ToolExecutor = preload("tool_executor.gd")
+
+var _client: BridgeClient
+var _tool_executor: ToolExecutor
+var _status_label: Label
+
+
+func _enter_tree() -> void:
+	_client = BridgeClient.new()
+	_client.name = "GdharnessBridgeClient"
+	add_child(_client)
+
+	_tool_executor = ToolExecutor.new()
+	_tool_executor.name = "GdharnessToolExecutor"
+	add_child(_tool_executor)
+	_tool_executor.set_editor_plugin(self)
+
+	_client.connected.connect(_on_connected)
+	_client.disconnected.connect(_on_disconnected)
+	_client.tool_requested.connect(_on_tool_requested)
+
+	_setup_status_indicator()
+	_client.connect_to_server()
+
+
+func _exit_tree() -> void:
+	if _client:
+		if _client.connected.is_connected(_on_connected):
+			_client.connected.disconnect(_on_connected)
+		if _client.disconnected.is_connected(_on_disconnected):
+			_client.disconnected.disconnect(_on_disconnected)
+		if _client.tool_requested.is_connected(_on_tool_requested):
+			_client.tool_requested.disconnect(_on_tool_requested)
+		_client.disconnect_from_server()
+		_client.queue_free()
+		_client = null
+
+	if _tool_executor:
+		_tool_executor.queue_free()
+		_tool_executor = null
+
+	if _status_label:
+		remove_control_from_container(CONTAINER_TOOLBAR, _status_label)
+		_status_label.queue_free()
+		_status_label = null
+
+
+func _setup_status_indicator() -> void:
+	_status_label = Label.new()
+	_status_label.text = "gdharness: connecting"
+	_status_label.add_theme_color_override("font_color", Color.YELLOW)
+	_status_label.add_theme_font_size_override("font_size", 12)
+	add_control_to_container(CONTAINER_TOOLBAR, _status_label)
+
+
+func _on_connected() -> void:
+	if _status_label:
+		_status_label.text = "gdharness: connected"
+		_status_label.add_theme_color_override("font_color", Color.GREEN)
+
+
+func _on_disconnected() -> void:
+	if _status_label:
+		_status_label.text = "gdharness: disconnected"
+		_status_label.add_theme_color_override("font_color", Color.RED)
+
+
+func _on_tool_requested(request_id: String, tool_name: String, args: Dictionary) -> void:
+	if _tool_executor == null or _client == null:
+		return
+
+	var result: Dictionary = _tool_executor.execute_tool(tool_name, args)
+	var success: bool = result.get("ok", false)
+
+	if success:
+		var payload: Dictionary = result.duplicate(true)
+		payload.erase("ok")
+		_client.send_tool_result(request_id, true, payload, "")
+	else:
+		_client.send_tool_result(request_id, false, null, str(result.get("error", "Unknown error")))

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -0,0 +1,104 @@
+@tool
+extends Node
+
+## Routes each command the server sends to the tool module that answers it. The modules are
+## preloaded rather than looked up on disk at runtime, so a missing one fails to parse here
+## instead of leaving a command silently unanswered.
+
+const SceneTools = preload("tools/scene_tools.gd")
+const ResourceTools = preload("tools/resource_tools.gd")
+const AnimationTools = preload("tools/animation_tools.gd")
+const PlayTools = preload("tools/play_tools.gd")
+
+var _editor_plugin: EditorPlugin = null
+
+var _scene_tools: SceneTools = null
+var _resource_tools: ResourceTools = null
+var _animation_tools: AnimationTools = null
+var _play_tools: PlayTools = null
+
+var _tool_map: Dictionary = {}
+var _initialized: bool = false
+
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+	_init_tools()
+	_scene_tools.set_editor_plugin(plugin)
+	_resource_tools.set_editor_plugin(plugin)
+	_animation_tools.set_editor_plugin(plugin)
+	_play_tools.set_editor_plugin(plugin)
+
+
+func _init_tools() -> void:
+	if _initialized:
+		return
+	_initialized = true
+
+	_scene_tools = SceneTools.new()
+	_scene_tools.name = "SceneTools"
+	add_child(_scene_tools)
+
+	_resource_tools = ResourceTools.new()
+	_resource_tools.name = "ResourceTools"
+	add_child(_resource_tools)
+
+	_animation_tools = AnimationTools.new()
+	_animation_tools.name = "AnimationTools"
+	add_child(_animation_tools)
+
+	_play_tools = PlayTools.new()
+	_play_tools.name = "PlayTools"
+	add_child(_play_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"],
+		"save_scene": [_scene_tools, "save_scene"],
+		"connect_signal": [_scene_tools, "connect_signal"],
+		"disconnect_signal": [_scene_tools, "disconnect_signal"],
+		"list_connections": [_scene_tools, "list_connections"],
+		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
+		# Resource tools
+		"create_resource": [_resource_tools, "create_resource"],
+		"modify_resource": [_resource_tools, "modify_resource"],
+		"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"],
+		# Animation tools
+		"play_scene": [_play_tools, "play_scene"],
+		"restart_editor": [_play_tools, "restart_editor"],
+		"stop_playing": [_play_tools, "stop_playing"],
+		"playing_status": [_play_tools, "playing_status"],
+		"create_animation": [_animation_tools, "create_animation"],
+		"add_animation_track": [_animation_tools, "add_animation_track"],
+		"add_animation_state": [_animation_tools, "add_animation_state"],
+		"connect_animation_states": [_animation_tools, "connect_animation_states"],
+	}
+
+
+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 not node.has_method(method):
+		return {"ok": false, "error": "Tool method not found: %s.%s" % [node.name, method]}
+
+	var result: Variant = node.call(method, args)
+	if result is Dictionary:
+		return result
+
+	return {"ok": false, "error": "Invalid tool result from: " + tool_name}