Add in-game editor MVP: EditorCore + 2D tile/object editing
Implements the in-game editor's shared, data-native core and a Control-based UI on top of it, per docs/architecture/editor.md §7.1/§7.2, scoped to 2D per §8's own risk mitigation (the default world is flat, CHUNK_SIZE_Z=1 -- no 3D gizmos here). EditorCore (scripts/editor/): - ChunkEditorModel wraps a ChunkDataDecoder.ChunkPayload directly (no parallel data model) and adds a TileLayerData.set_tile() mutator alongside the existing get_tile(). - EditorUndoRedoStack wraps Godot's built-in UndoRedo (game-usable, not the editor-only EditorUndoRedoManager) so every mutation is a real, revertible do/undo Callable pair over ChunkEditorModel's raw setters. - SelectionManager tracks the selected object id as UI state, deliberately outside the undo/redo stack. - ToolRegistry + 5 tools (BrushTool, ObjectPlaceTool, SelectTool, EraseTool, TransformTool -- the 5th covers move/rotate/scale, which the doc's tool list doesn't literally name but the task requires) is the single choke point every mutation goes through. - EditorObjectCatalog (assets/editor/object_catalog.json) is a new, small "placeable object" catalog -- AvatarCatalog and SpawnCatalog were checked first and are both scoped to other concerns, so this mirrors their loading convention rather than reusing either. InGameEditor UI (scripts/editor/ui/): EditorViewport (2D top-down tile grid + object dots), EditorToolbar, PalettePanel, InspectorPanel, wired together in InGameEditor. Built from Control nodes in code (matching game.gd's existing dynamic-UI convention) rather than a hand-authored .tscn. Entry point: game.gd gates build mode behind a new toggle_build_mode input action (F2), freezing the player and opening a fresh empty ChunkEditorModel. Loading a *real* chunk from the backend for editing, and saving edits back, are explicitly out of scope -- a sibling task owns the batch-PUT/conflict-handling save path (world_persistence_impl.md). Verification: scripts/smoke_test_editor_core.gd decodes a real backend fixture (backend/tests/fixtures/chunks/simple_tile_chunk.bin), drives place/move/rotate/scale/delete/paint/erase entirely through EditorCore.use_tool()/ToolRegistry (never touching ChunkEditorModel's raw setters directly), undoes and redoes every step, and round-trips the result through encode_binary()/decode_binary() to prove the edited model stays a valid, byte-compatible ChunkPayload. 69/69 assertions pass. Full existing Godot smoke suite (16 other scripts/smoke_test_*.gd, backend + dedicated-server-dependent ones included) still passes with no regressions. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Y2FESCaMXeJpC9gSctiEeD
This commit is contained in:
@@ -0,0 +1,40 @@
|
||||
{
|
||||
"objects": {
|
||||
"crate_small": {
|
||||
"asset_id": "props/crate_small.glb",
|
||||
"type": "prop",
|
||||
"display_name": "Small Crate",
|
||||
"category": "props"
|
||||
},
|
||||
"rock_01": {
|
||||
"asset_id": "props/rock_01.glb",
|
||||
"type": "prop",
|
||||
"display_name": "Rock",
|
||||
"category": "nature"
|
||||
},
|
||||
"tree_pine_01": {
|
||||
"asset_id": "props/tree_pine_01.glb",
|
||||
"type": "prop",
|
||||
"display_name": "Pine Tree",
|
||||
"category": "nature"
|
||||
},
|
||||
"lamp_post_01": {
|
||||
"asset_id": "props/lamp_post_01.glb",
|
||||
"type": "prop",
|
||||
"display_name": "Lamp Post",
|
||||
"category": "props"
|
||||
},
|
||||
"chest_01": {
|
||||
"asset_id": "props/chest.glb",
|
||||
"type": "interactable",
|
||||
"display_name": "Treasure Chest",
|
||||
"category": "interactables"
|
||||
},
|
||||
"spawn_point": {
|
||||
"asset_id": "",
|
||||
"type": "spawn_point",
|
||||
"display_name": "Spawn Point",
|
||||
"category": "gameplay"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -50,6 +50,11 @@ interact={
|
||||
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":69,"key_label":0,"unicode":101,"location":0,"echo":false,"script":null)
|
||||
]
|
||||
}
|
||||
toggle_build_mode={
|
||||
"deadzone": 0.5,
|
||||
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194333,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
|
||||
]
|
||||
}
|
||||
|
||||
[physics]
|
||||
|
||||
|
||||
@@ -100,6 +100,17 @@ class TileLayerData:
|
||||
return tiles[idx]
|
||||
return 0
|
||||
|
||||
## Editor mutator: writes `tile_id` at (x, y, z). Silently no-ops out of
|
||||
## bounds, mirroring get_tile's "out of bounds is empty" contract rather
|
||||
## than erroring -- callers that need bounds feedback should check first
|
||||
## (see ChunkEditorModel.is_tile_in_bounds in scripts/editor/).
|
||||
func set_tile(x: int, y: int, z: int, tile_id: int) -> void:
|
||||
if x < 0 or x >= width or y < 0 or y >= height or z < 0 or z >= depth:
|
||||
return
|
||||
var idx := (z * height + y) * width + x
|
||||
if idx < tiles.size():
|
||||
tiles[idx] = tile_id
|
||||
|
||||
func get_tile_def(tile_id: int) -> TileDef:
|
||||
for def in palette:
|
||||
if def.id == tile_id:
|
||||
|
||||
@@ -0,0 +1,190 @@
|
||||
class_name ChunkEditorModel
|
||||
extends RefCounted
|
||||
## In-memory chunk being edited (docs/architecture/editor.md §7.1's
|
||||
## `ChunkEditorModel`).
|
||||
##
|
||||
## Wraps a `ChunkDataDecoder.ChunkPayload` directly rather than inventing a
|
||||
## parallel data model -- that payload is already the exact structure that
|
||||
## round-trips through `ChunkDataDecoder.encode_binary()` /
|
||||
## `decode_binary()` (world.md §3.6, and the interop bugs fixed in that file
|
||||
## are proof this contract is exercised for real). Editing this model and
|
||||
## re-encoding it must always produce a valid, byte-compatible chunk, since
|
||||
## the sibling save-path task depends on that being true.
|
||||
##
|
||||
## Every method here is a "raw" mutator: it changes the payload and returns
|
||||
## whatever an undo needs to reverse the change, but it does **not** know
|
||||
## about undo/redo itself. `scripts/editor/editor_core.gd`'s tools
|
||||
## (scripts/editor/tools/*.gd) are the only things that call these -- they
|
||||
## wrap each call in an `EditorUndoRedoStack` action. Nothing here should be
|
||||
## called directly by UI code; that would bypass undo/redo silently.
|
||||
|
||||
var payload: ChunkDataDecoder.ChunkPayload
|
||||
|
||||
## Monotonic counter seeded from the highest existing "obj_NNNN"-style
|
||||
## numeric suffix already in the chunk, so freshly generated ids never
|
||||
## collide with ids that arrived from a decoded chunk.
|
||||
var _next_object_seq: int = 0
|
||||
|
||||
|
||||
func _init(p_payload: ChunkDataDecoder.ChunkPayload = null) -> void:
|
||||
payload = p_payload if p_payload != null else ChunkDataDecoder.ChunkPayload.new()
|
||||
_seed_object_sequence()
|
||||
|
||||
|
||||
func _seed_object_sequence() -> void:
|
||||
for obj in payload.objects:
|
||||
var n := _numeric_suffix(obj.id)
|
||||
if n >= _next_object_seq:
|
||||
_next_object_seq = n + 1
|
||||
|
||||
|
||||
static func _numeric_suffix(id: String) -> int:
|
||||
var digits := ""
|
||||
for i in range(id.length() - 1, -1, -1):
|
||||
var c: String = id[i]
|
||||
if c.is_valid_int():
|
||||
digits = c + digits
|
||||
else:
|
||||
break
|
||||
return int(digits) if digits != "" else -1
|
||||
|
||||
|
||||
## Build a fresh, empty single-layer chunk model -- convenient for tests and
|
||||
## for a "new chunk" starting point in the in-game editor before a real
|
||||
## chunk has been loaded from the backend (loading real chunks over HTTP is
|
||||
## HttpChunkSource's job; this just gives the editor something valid to
|
||||
## operate on).
|
||||
static func create_empty(width: int = 32, height: int = 32, world_id: String = "",
|
||||
room_id: String = "main", coord: Vector3i = Vector3i.ZERO) -> ChunkEditorModel:
|
||||
var layer := ChunkDataDecoder.TileLayerData.new()
|
||||
layer.name = "ground"
|
||||
layer.layer_id = 0
|
||||
layer.width = width
|
||||
layer.height = height
|
||||
layer.depth = 1
|
||||
layer.palette = [
|
||||
TileDef.new(0, "", false, 0, 1),
|
||||
TileDef.new(1, "tiles/default", true, 0, 1),
|
||||
]
|
||||
var tiles := PackedInt32Array()
|
||||
tiles.resize(width * height)
|
||||
layer.tiles = tiles
|
||||
|
||||
var payload := ChunkDataDecoder.ChunkPayload.new()
|
||||
payload.world_id = world_id
|
||||
payload.room_id = room_id
|
||||
payload.coord = coord
|
||||
payload.bounds = AABB(Vector3(coord.x * width, coord.y * height, coord.z), Vector3(width, height, 1))
|
||||
payload.tile_layers = [layer]
|
||||
payload.revision = 0
|
||||
payload.created_at = Time.get_unix_time_from_system()
|
||||
payload.updated_at = payload.created_at
|
||||
return ChunkEditorModel.new(payload)
|
||||
|
||||
|
||||
static func from_binary(data: PackedByteArray) -> ChunkEditorModel:
|
||||
var decoded := ChunkDataDecoder.decode_binary(data)
|
||||
if decoded == null:
|
||||
return null
|
||||
return ChunkEditorModel.new(decoded)
|
||||
|
||||
|
||||
func encode_binary() -> PackedByteArray:
|
||||
return ChunkDataDecoder.encode_binary(payload)
|
||||
|
||||
|
||||
# ───────────────────────── tiles ─────────────────────────
|
||||
|
||||
func get_layer(layer_idx: int) -> ChunkDataDecoder.TileLayerData:
|
||||
if layer_idx < 0 or layer_idx >= payload.tile_layers.size():
|
||||
return null
|
||||
return payload.tile_layers[layer_idx]
|
||||
|
||||
|
||||
func is_tile_in_bounds(layer_idx: int, x: int, y: int, z: int = 0) -> bool:
|
||||
var layer := get_layer(layer_idx)
|
||||
if layer == null:
|
||||
return false
|
||||
return x >= 0 and x < layer.width and y >= 0 and y < layer.height and z >= 0 and z < layer.depth
|
||||
|
||||
|
||||
func get_tile_raw(layer_idx: int, x: int, y: int, z: int = 0) -> int:
|
||||
var layer := get_layer(layer_idx)
|
||||
if layer == null:
|
||||
return 0
|
||||
return layer.get_tile(x, y, z)
|
||||
|
||||
|
||||
## Raw setter -- undo-unaware. Only ever called (in both directions) by
|
||||
## BrushTool/EraseTool via EditorUndoRedoStack.
|
||||
func set_tile_raw(layer_idx: int, x: int, y: int, z: int, tile_id: int) -> void:
|
||||
var layer := get_layer(layer_idx)
|
||||
if layer == null:
|
||||
return
|
||||
layer.set_tile(x, y, z, tile_id)
|
||||
|
||||
|
||||
# ───────────────────────── objects ─────────────────────────
|
||||
|
||||
func find_object(object_id: String) -> ChunkDataDecoder.WorldObjectData:
|
||||
for obj in payload.objects:
|
||||
if obj.id == object_id:
|
||||
return obj
|
||||
return null
|
||||
|
||||
|
||||
func get_object_index(object_id: String) -> int:
|
||||
for i in range(payload.objects.size()):
|
||||
if payload.objects[i].id == object_id:
|
||||
return i
|
||||
return -1
|
||||
|
||||
|
||||
func generate_object_id() -> String:
|
||||
var id := "obj_%04d" % _next_object_seq
|
||||
_next_object_seq += 1
|
||||
return id
|
||||
|
||||
|
||||
## Raw mutators -- undo-unaware. Only ever called (in both directions) by
|
||||
## ObjectPlaceTool/EraseTool/TransformTool via EditorUndoRedoStack.
|
||||
func add_object_raw(obj: ChunkDataDecoder.WorldObjectData) -> void:
|
||||
payload.objects.append(obj)
|
||||
|
||||
|
||||
func insert_object_raw(obj: ChunkDataDecoder.WorldObjectData, index: int) -> void:
|
||||
var clamped: int = clampi(index, 0, payload.objects.size())
|
||||
payload.objects.insert(clamped, obj)
|
||||
|
||||
|
||||
func remove_object_raw(object_id: String) -> ChunkDataDecoder.WorldObjectData:
|
||||
var idx := get_object_index(object_id)
|
||||
if idx == -1:
|
||||
return null
|
||||
var obj := payload.objects[idx]
|
||||
payload.objects.remove_at(idx)
|
||||
return obj
|
||||
|
||||
|
||||
func set_object_position_raw(object_id: String, position: Vector3) -> void:
|
||||
var obj := find_object(object_id)
|
||||
if obj != null:
|
||||
obj.position = position
|
||||
|
||||
|
||||
func set_object_rotation_raw(object_id: String, rotation: Vector4) -> void:
|
||||
var obj := find_object(object_id)
|
||||
if obj != null:
|
||||
obj.rotation = rotation
|
||||
|
||||
|
||||
func set_object_scale_raw(object_id: String, scale: Vector3) -> void:
|
||||
var obj := find_object(object_id)
|
||||
if obj != null:
|
||||
obj.scale = scale
|
||||
|
||||
|
||||
func set_object_property_raw(object_id: String, key: String, value: Variant) -> void:
|
||||
var obj := find_object(object_id)
|
||||
if obj != null:
|
||||
obj.properties[key] = value
|
||||
@@ -0,0 +1,114 @@
|
||||
class_name EditorCore
|
||||
extends RefCounted
|
||||
## Shared, data-native editor core (docs/architecture/editor.md §7.1).
|
||||
##
|
||||
## Both the in-game editor UI (`scripts/editor/ui/in_game_editor.gd`) and,
|
||||
## per the doc's §6.2/§7.3, any future thin dev-plugin surface are meant to
|
||||
## sit on top of this single object. It never touches `Control` nodes,
|
||||
## HTTP, or the live scene tree -- it only knows about the chunk model,
|
||||
## undo/redo, selection, and tools. It owns:
|
||||
##
|
||||
## - `model` (ChunkEditorModel) the chunk being edited
|
||||
## - `undo_redo` (EditorUndoRedoStack) command-pattern history
|
||||
## - `selection` (SelectionManager) selected object id
|
||||
## - `tools` (ToolRegistry) brush / object_place / select /
|
||||
## erase / transform
|
||||
## - `catalog` (EditorObjectCatalog, optional) palette source consumed
|
||||
## by `object_place`
|
||||
##
|
||||
## Every mutating public method here (`paint_tile`, `erase_tile`,
|
||||
## `place_object`, `delete_object`, `move_object`, `rotate_object`,
|
||||
## `scale_object`, `select_object`) is a thin wrapper around `use_tool()` --
|
||||
## it goes through `ToolRegistry`, never straight at `ChunkEditorModel`.
|
||||
## This is the seam this task's verification bar cares about: UI code and
|
||||
## tests mutate the chunk exactly the same way, so a test that calls
|
||||
## `core.move_object(...)` is exercising the same code path a player's
|
||||
## drag-in-the-viewport would.
|
||||
##
|
||||
## Persisting the edited chunk to the backend is explicitly **out of
|
||||
## scope** here (a sibling task owns the batch-PUT/conflict-handling save
|
||||
## path per world_persistence_impl.md) -- `model.encode_binary()` is as far
|
||||
## as this class goes.
|
||||
|
||||
var model: ChunkEditorModel
|
||||
var undo_redo: EditorUndoRedoStack
|
||||
var selection: SelectionManager
|
||||
var tools: ToolRegistry
|
||||
var catalog: EditorObjectCatalog = null
|
||||
|
||||
|
||||
func _init(p_model: ChunkEditorModel, p_catalog: EditorObjectCatalog = null) -> void:
|
||||
model = p_model
|
||||
catalog = p_catalog
|
||||
undo_redo = EditorUndoRedoStack.new()
|
||||
selection = SelectionManager.new()
|
||||
tools = ToolRegistry.new()
|
||||
tools.register_tool(BrushTool.new())
|
||||
tools.register_tool(ObjectPlaceTool.new())
|
||||
tools.register_tool(SelectTool.new())
|
||||
tools.register_tool(EraseTool.new())
|
||||
tools.register_tool(TransformTool.new())
|
||||
tools.set_active_tool("select")
|
||||
|
||||
|
||||
## Route an action through the named tool. This is the single choke point
|
||||
## every mutation (and every convenience wrapper below) goes through.
|
||||
func use_tool(tool_id: String, args: Dictionary) -> Variant:
|
||||
var tool: EditorTool = tools.get_tool(tool_id)
|
||||
if tool == null:
|
||||
push_error("EditorCore: unknown tool '%s'" % tool_id)
|
||||
return null
|
||||
return tool.apply(self, args)
|
||||
|
||||
|
||||
# ───────── convenience wrappers (all route through use_tool/ToolRegistry) ─────────
|
||||
|
||||
func paint_tile(layer_idx: int, x: int, y: int, tile_id: int, z: int = 0) -> bool:
|
||||
return bool(use_tool("brush", {"layer": layer_idx, "x": x, "y": y, "z": z, "tile_id": tile_id}))
|
||||
|
||||
|
||||
func erase_tile(layer_idx: int, x: int, y: int, z: int = 0) -> bool:
|
||||
return bool(use_tool("erase", {"layer": layer_idx, "x": x, "y": y, "z": z}))
|
||||
|
||||
|
||||
func place_object(catalog_id: String, position: Vector3,
|
||||
rotation: Vector4 = Vector4(0, 0, 0, 1), scale: Vector3 = Vector3.ONE) -> String:
|
||||
var result: Variant = use_tool("object_place", {
|
||||
"catalog_id": catalog_id,
|
||||
"position": position,
|
||||
"rotation": rotation,
|
||||
"scale": scale,
|
||||
})
|
||||
return result if result is String else ""
|
||||
|
||||
|
||||
func delete_object(object_id: String) -> bool:
|
||||
return bool(use_tool("erase", {"object_id": object_id}))
|
||||
|
||||
|
||||
func move_object(object_id: String, position: Vector3) -> bool:
|
||||
return bool(use_tool("transform", {"object_id": object_id, "op": "move", "value": position}))
|
||||
|
||||
|
||||
func rotate_object(object_id: String, rotation: Vector4) -> bool:
|
||||
return bool(use_tool("transform", {"object_id": object_id, "op": "rotate", "value": rotation}))
|
||||
|
||||
|
||||
func scale_object(object_id: String, scale: Vector3) -> bool:
|
||||
return bool(use_tool("transform", {"object_id": object_id, "op": "scale", "value": scale}))
|
||||
|
||||
|
||||
func select_object(object_id: String) -> bool:
|
||||
return bool(use_tool("select", {"object_id": object_id}))
|
||||
|
||||
|
||||
func clear_selection() -> void:
|
||||
use_tool("select", {})
|
||||
|
||||
|
||||
func undo() -> bool:
|
||||
return undo_redo.undo()
|
||||
|
||||
|
||||
func redo() -> bool:
|
||||
return undo_redo.redo()
|
||||
@@ -0,0 +1,73 @@
|
||||
class_name EditorUndoRedoStack
|
||||
extends RefCounted
|
||||
## Command pattern over ChunkEditorModel mutations
|
||||
## (docs/architecture/editor.md §7.1 `UndoRedoStack`).
|
||||
##
|
||||
## Thin wrapper around Godot's built-in `UndoRedo` -- the general-purpose
|
||||
## class meant for use in game code (unlike the editor-only
|
||||
## `EditorUndoRedoManager`, which only exists inside `EditorPlugin`s and
|
||||
## isn't available at runtime). Every EditorCore tool (scripts/editor/tools/
|
||||
## *.gd) opens exactly one action per user operation and adds a do/undo
|
||||
## Callable pair that calls the *same* ChunkEditorModel raw setter in both
|
||||
## directions (e.g. `set_tile_raw` with the new id, then again with the old
|
||||
## one) -- so undo genuinely reverts the mutation instead of re-deriving it.
|
||||
##
|
||||
## `UndoRedo` extends `Object`, not `RefCounted`, so it is not automatically
|
||||
## freed; `_notification(NOTIFICATION_PREDELETE)` frees it when this wrapper
|
||||
## (a RefCounted) goes out of scope.
|
||||
|
||||
var _ur := UndoRedo.new()
|
||||
|
||||
|
||||
func _notification(what: int) -> void:
|
||||
if what == NOTIFICATION_PREDELETE and _ur != null:
|
||||
_ur.free()
|
||||
_ur = null
|
||||
|
||||
|
||||
## Begin a new undoable action. Must be paired with `commit()`.
|
||||
func begin(action_name: String) -> void:
|
||||
_ur.create_action(action_name)
|
||||
|
||||
|
||||
## Register the forward step of the current action. Called immediately by
|
||||
## `commit()`, and again on every future `redo()`.
|
||||
func add_do(callable: Callable) -> void:
|
||||
_ur.add_do_method(callable)
|
||||
|
||||
|
||||
## Register the reverse step of the current action. Called on every
|
||||
## `undo()`.
|
||||
func add_undo(callable: Callable) -> void:
|
||||
_ur.add_undo_method(callable)
|
||||
|
||||
|
||||
## Close the current action and execute its do-step once.
|
||||
func commit() -> void:
|
||||
_ur.commit_action()
|
||||
|
||||
|
||||
## Close the current action without executing anything (used when a tool
|
||||
## decides mid-way that there is nothing worth recording).
|
||||
func cancel() -> void:
|
||||
_ur.commit_action(false)
|
||||
|
||||
|
||||
func undo() -> bool:
|
||||
return _ur.undo()
|
||||
|
||||
|
||||
func redo() -> bool:
|
||||
return _ur.redo()
|
||||
|
||||
|
||||
func can_undo() -> bool:
|
||||
return _ur.has_undo()
|
||||
|
||||
|
||||
func can_redo() -> bool:
|
||||
return _ur.has_redo()
|
||||
|
||||
|
||||
func clear_history() -> void:
|
||||
_ur.clear_history()
|
||||
@@ -0,0 +1,68 @@
|
||||
class_name EditorObjectCatalog
|
||||
extends RefCounted
|
||||
## Catalog of placeable world objects for the in-game editor's
|
||||
## `PalettePanel` (docs/architecture/editor.md §7.2).
|
||||
##
|
||||
## Mirrors the loading convention already used twice in this codebase --
|
||||
## `scripts/avatar/avatar_catalog.gd` (AvatarCatalog) and
|
||||
## `scripts/scripting/spawn_catalog.gd` (SpawnCatalog): a data-driven JSON
|
||||
## manifest, loaded once, looked up by id. Checked both before adding this:
|
||||
## `AvatarCatalog` is avatar-attachment-specific (base_body/slot/mount_bone)
|
||||
## and `SpawnCatalog` is scoped to `ScriptBehavior`'s `spawn_from_catalog`
|
||||
## verb specifically (its own doc comment says as much) -- neither is a
|
||||
## general "placeable world object" catalog, so this is a new, small one
|
||||
## rather than a reuse of either.
|
||||
|
||||
## Catalog manifest structure:
|
||||
## { "objects": { "id": { "type", "asset_id", "display_name", ... } } }
|
||||
var _catalog: Dictionary = {}
|
||||
var _loaded: bool = false
|
||||
var _catalog_path: String = "res://assets/editor/object_catalog.json"
|
||||
|
||||
|
||||
func load_catalog(path: String = _catalog_path) -> Error:
|
||||
_catalog_path = path
|
||||
_catalog = {}
|
||||
|
||||
var file := FileAccess.open(path, FileAccess.READ)
|
||||
if file == null:
|
||||
return FileAccess.get_open_error()
|
||||
|
||||
var json_text: String = file.get_as_text()
|
||||
file.close()
|
||||
|
||||
var result: Variant = JSON.parse_string(json_text)
|
||||
if result == null or not (result is Dictionary) or not (result as Dictionary).has("objects"):
|
||||
return ERR_INVALID_DATA
|
||||
|
||||
_catalog = (result as Dictionary)["objects"]
|
||||
_loaded = true
|
||||
return OK
|
||||
|
||||
|
||||
func is_loaded() -> bool:
|
||||
return _loaded
|
||||
|
||||
|
||||
## Resolve a catalog id to its template Dictionary ({} if unknown/unloaded).
|
||||
func resolve(id: String) -> Dictionary:
|
||||
if not _loaded:
|
||||
return {}
|
||||
return _catalog.get(id, {})
|
||||
|
||||
|
||||
func has_object(id: String) -> bool:
|
||||
return _loaded and _catalog.has(id)
|
||||
|
||||
|
||||
func get_all_ids() -> Array[String]:
|
||||
if not _loaded:
|
||||
return []
|
||||
var ids: Array[String] = []
|
||||
for id in _catalog.keys():
|
||||
ids.append(id)
|
||||
return ids
|
||||
|
||||
|
||||
func get_catalog_path() -> String:
|
||||
return _catalog_path
|
||||
@@ -0,0 +1,32 @@
|
||||
class_name SelectionManager
|
||||
extends RefCounted
|
||||
## Tracks the currently-selected object in the in-game editor
|
||||
## (docs/architecture/editor.md §7.1 `SelectionManager`).
|
||||
##
|
||||
## Selection is UI/session state, not chunk data: it is never pushed onto
|
||||
## `EditorUndoRedoStack` and never encoded into the `ChunkPayload`. Scoped
|
||||
## to a single selected object id, matching the 2D-tile-editor scope
|
||||
## (docs/architecture/editor.md §8) -- multi-select is future work.
|
||||
|
||||
signal selection_changed(object_id: String)
|
||||
|
||||
var _selected_id: String = ""
|
||||
|
||||
|
||||
func select(object_id: String) -> void:
|
||||
if _selected_id == object_id:
|
||||
return
|
||||
_selected_id = object_id
|
||||
selection_changed.emit(_selected_id)
|
||||
|
||||
|
||||
func clear() -> void:
|
||||
select("")
|
||||
|
||||
|
||||
func get_selected() -> String:
|
||||
return _selected_id
|
||||
|
||||
|
||||
func has_selection() -> bool:
|
||||
return _selected_id != ""
|
||||
@@ -0,0 +1,41 @@
|
||||
class_name ToolRegistry
|
||||
extends RefCounted
|
||||
## Registry of `EditorTool` instances, keyed by id
|
||||
## (docs/architecture/editor.md §7.1: "brush / object-place / select /
|
||||
## erase, etc."). `EditorCore.use_tool()` is the single choke point every
|
||||
## chunk mutation goes through -- UI code and tests both call tools by id
|
||||
## through here rather than reaching into `ChunkEditorModel` directly.
|
||||
|
||||
var _tools: Dictionary = {}
|
||||
var _active_id: String = ""
|
||||
|
||||
|
||||
func register_tool(tool: EditorTool) -> void:
|
||||
_tools[tool.tool_id] = tool
|
||||
|
||||
|
||||
func get_tool(tool_id: String) -> EditorTool:
|
||||
return _tools.get(tool_id, null)
|
||||
|
||||
|
||||
func has_tool(tool_id: String) -> bool:
|
||||
return _tools.has(tool_id)
|
||||
|
||||
|
||||
func get_tool_ids() -> Array:
|
||||
return _tools.keys()
|
||||
|
||||
|
||||
func set_active_tool(tool_id: String) -> bool:
|
||||
if not _tools.has(tool_id):
|
||||
return false
|
||||
_active_id = tool_id
|
||||
return true
|
||||
|
||||
|
||||
func get_active_tool_id() -> String:
|
||||
return _active_id
|
||||
|
||||
|
||||
func get_active_tool() -> EditorTool:
|
||||
return _tools.get(_active_id, null)
|
||||
@@ -0,0 +1,31 @@
|
||||
class_name BrushTool
|
||||
extends EditorTool
|
||||
## Paints a single tile id into a tile layer at (x, y[, z]).
|
||||
##
|
||||
## `args`: `layer` (int, default 0), `x` (int), `y` (int), `z` (int,
|
||||
## default 0), `tile_id` (int).
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
tool_id = "brush"
|
||||
|
||||
|
||||
func apply(core: EditorCore, args: Dictionary) -> Variant:
|
||||
var layer_idx: int = args.get("layer", 0)
|
||||
var x: int = args.get("x", 0)
|
||||
var y: int = args.get("y", 0)
|
||||
var z: int = args.get("z", 0)
|
||||
var tile_id: int = args.get("tile_id", 0)
|
||||
|
||||
if not core.model.is_tile_in_bounds(layer_idx, x, y, z):
|
||||
return false
|
||||
|
||||
var old_tile_id: int = core.model.get_tile_raw(layer_idx, x, y, z)
|
||||
if old_tile_id == tile_id:
|
||||
return false # no-op -- nothing to undo
|
||||
|
||||
core.undo_redo.begin("Paint tile (%d,%d,%d) -> %d" % [x, y, z, tile_id])
|
||||
core.undo_redo.add_do(core.model.set_tile_raw.bind(layer_idx, x, y, z, tile_id))
|
||||
core.undo_redo.add_undo(core.model.set_tile_raw.bind(layer_idx, x, y, z, old_tile_id))
|
||||
core.undo_redo.commit()
|
||||
return true
|
||||
@@ -0,0 +1,20 @@
|
||||
class_name EditorTool
|
||||
extends RefCounted
|
||||
## Base class for EditorCore tools (docs/architecture/editor.md §7.1
|
||||
## `ToolRegistry`: brush / object-place / select / erase / transform).
|
||||
##
|
||||
## A tool never mutates `ChunkEditorModel` "bare" -- every chunk-data
|
||||
## mutation goes through `EditorCore.undo_redo` so it is always revertible.
|
||||
## (Selection is the one exception: it is UI state, not chunk data, and
|
||||
## `SelectTool` intentionally does not touch undo/redo -- see its comment.)
|
||||
|
||||
var tool_id: String = ""
|
||||
|
||||
|
||||
## Apply this tool's action against `core` with `args`. Returns a
|
||||
## tool-specific result on success (often `true`/a new object id), or a
|
||||
## falsy value (`false`/`""`/`null`) if nothing changed -- callers should
|
||||
## treat falsy as "no-op, nothing to undo".
|
||||
func apply(_core: EditorCore, _args: Dictionary) -> Variant:
|
||||
push_error("EditorTool.apply() not implemented for tool '%s'" % tool_id)
|
||||
return null
|
||||
@@ -0,0 +1,41 @@
|
||||
class_name EraseTool
|
||||
extends EditorTool
|
||||
## Deletes an object, or clears a tile back to id 0 (the reserved empty/air
|
||||
## id -- world.md §3.2 / TileDef doc comment).
|
||||
##
|
||||
## `args`: either `{"object_id": ...}` to delete an object, or
|
||||
## `{"layer", "x", "y", "z"}` to clear a tile (delegates to BrushTool with
|
||||
## `tile_id = 0` so both paths share one undo/redo implementation).
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
tool_id = "erase"
|
||||
|
||||
|
||||
func apply(core: EditorCore, args: Dictionary) -> Variant:
|
||||
if args.has("object_id"):
|
||||
return _erase_object(core, args["object_id"])
|
||||
return _erase_tile(core, args)
|
||||
|
||||
|
||||
func _erase_object(core: EditorCore, object_id: String) -> bool:
|
||||
var idx: int = core.model.get_object_index(object_id)
|
||||
if idx == -1:
|
||||
return false
|
||||
var obj: ChunkDataDecoder.WorldObjectData = core.model.payload.objects[idx]
|
||||
|
||||
core.undo_redo.begin("Delete '%s'" % object_id)
|
||||
core.undo_redo.add_do(core.model.remove_object_raw.bind(object_id))
|
||||
core.undo_redo.add_undo(core.model.insert_object_raw.bind(obj, idx))
|
||||
core.undo_redo.commit()
|
||||
|
||||
if core.selection.get_selected() == object_id:
|
||||
core.selection.clear()
|
||||
return true
|
||||
|
||||
|
||||
func _erase_tile(core: EditorCore, args: Dictionary) -> bool:
|
||||
var brush: EditorTool = core.tools.get_tool("brush")
|
||||
var tile_args: Dictionary = args.duplicate()
|
||||
tile_args["tile_id"] = 0
|
||||
return bool(brush.apply(core, tile_args))
|
||||
@@ -0,0 +1,50 @@
|
||||
class_name ObjectPlaceTool
|
||||
extends EditorTool
|
||||
## Places a new catalog object into the chunk at a given transform.
|
||||
##
|
||||
## `args`: `catalog_id` (String, required), `position` (Vector3), `rotation`
|
||||
## (Vector4 quaternion, optional, default identity), `scale` (Vector3,
|
||||
## optional, default ONE), `properties` (Dictionary, optional, merged in).
|
||||
##
|
||||
## Returns the new object's id (String) on success, or "" on failure
|
||||
## (unknown catalog_id).
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
tool_id = "object_place"
|
||||
|
||||
|
||||
func apply(core: EditorCore, args: Dictionary) -> Variant:
|
||||
var catalog_id: String = args.get("catalog_id", "")
|
||||
if catalog_id == "":
|
||||
push_error("ObjectPlaceTool: missing catalog_id")
|
||||
return ""
|
||||
|
||||
var entry: Dictionary = {}
|
||||
if core.catalog != null:
|
||||
entry = core.catalog.resolve(catalog_id)
|
||||
if entry.is_empty():
|
||||
push_error("ObjectPlaceTool: unknown catalog_id '%s'" % catalog_id)
|
||||
return ""
|
||||
|
||||
var obj := ChunkDataDecoder.WorldObjectData.new()
|
||||
obj.id = core.model.generate_object_id()
|
||||
obj.type = entry.get("type", "prop")
|
||||
obj.asset_id = entry.get("asset_id", catalog_id)
|
||||
obj.position = args.get("position", Vector3.ZERO)
|
||||
obj.rotation = args.get("rotation", Vector4(0, 0, 0, 1))
|
||||
obj.scale = args.get("scale", Vector3.ONE)
|
||||
|
||||
var props: Dictionary = (args.get("properties", {}) as Dictionary).duplicate()
|
||||
if entry.has("display_name"):
|
||||
props["display_name"] = entry["display_name"]
|
||||
props["catalog_id"] = catalog_id
|
||||
obj.properties = props
|
||||
|
||||
core.undo_redo.begin("Place '%s' (%s)" % [obj.id, catalog_id])
|
||||
core.undo_redo.add_do(core.model.add_object_raw.bind(obj))
|
||||
core.undo_redo.add_undo(core.model.remove_object_raw.bind(obj.id))
|
||||
core.undo_redo.commit()
|
||||
|
||||
core.selection.select(obj.id)
|
||||
return obj.id
|
||||
@@ -0,0 +1,24 @@
|
||||
class_name SelectTool
|
||||
extends EditorTool
|
||||
## Selects (or clears) the active object in `EditorCore.selection`.
|
||||
##
|
||||
## `args`: `object_id` (String) -- omitted or "" clears the selection.
|
||||
##
|
||||
## Selection is UI/session state, not chunk data (docs/architecture/editor.md
|
||||
## §7.1 lists `SelectionManager` as a sibling of `UndoRedoStack`, not a
|
||||
## client of it), so this intentionally never touches `core.undo_redo`.
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
tool_id = "select"
|
||||
|
||||
|
||||
func apply(core: EditorCore, args: Dictionary) -> Variant:
|
||||
var object_id: String = args.get("object_id", "")
|
||||
if object_id == "":
|
||||
core.selection.clear()
|
||||
return true
|
||||
if core.model.find_object(object_id) == null:
|
||||
return false
|
||||
core.selection.select(object_id)
|
||||
return true
|
||||
@@ -0,0 +1,62 @@
|
||||
class_name TransformTool
|
||||
extends EditorTool
|
||||
## Moves, rotates, or scales an existing object.
|
||||
##
|
||||
## Not one of the four tools literally named in docs/architecture/editor.md
|
||||
## §7.1's `ToolRegistry` list ("brush / object-place / select / erase,
|
||||
## etc.") but required by this task's brief ("place / move / rotate / scale
|
||||
## / delete") -- the doc's own "etc." leaves room, so this is a fifth
|
||||
## registered tool rather than overloading `ObjectPlaceTool` (placing a new
|
||||
## object and re-transforming an existing one are different undo units)
|
||||
## or `SelectTool` (selection is deliberately not chunk-mutating).
|
||||
##
|
||||
## `args`: `object_id` (String), `op` ("move" | "rotate" | "scale"), `value`
|
||||
## (Vector3 for move/scale, Vector4 quaternion for rotate).
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
tool_id = "transform"
|
||||
|
||||
|
||||
func apply(core: EditorCore, args: Dictionary) -> Variant:
|
||||
var object_id: String = args.get("object_id", "")
|
||||
var op: String = args.get("op", "")
|
||||
var obj := core.model.find_object(object_id)
|
||||
if obj == null:
|
||||
return false
|
||||
|
||||
match op:
|
||||
"move":
|
||||
return _apply_vector3(core, object_id, args.get("value", obj.position),
|
||||
obj.position, "Move", core.model.set_object_position_raw)
|
||||
"rotate":
|
||||
return _apply_vector4(core, object_id, args.get("value", obj.rotation),
|
||||
obj.rotation, "Rotate", core.model.set_object_rotation_raw)
|
||||
"scale":
|
||||
return _apply_vector3(core, object_id, args.get("value", obj.scale),
|
||||
obj.scale, "Scale", core.model.set_object_scale_raw)
|
||||
_:
|
||||
push_error("TransformTool: unknown op '%s'" % op)
|
||||
return false
|
||||
|
||||
|
||||
func _apply_vector3(core: EditorCore, object_id: String, new_value: Vector3,
|
||||
old_value: Vector3, label: String, setter: Callable) -> bool:
|
||||
if new_value.is_equal_approx(old_value):
|
||||
return false
|
||||
core.undo_redo.begin("%s '%s'" % [label, object_id])
|
||||
core.undo_redo.add_do(setter.bind(object_id, new_value))
|
||||
core.undo_redo.add_undo(setter.bind(object_id, old_value))
|
||||
core.undo_redo.commit()
|
||||
return true
|
||||
|
||||
|
||||
func _apply_vector4(core: EditorCore, object_id: String, new_value: Vector4,
|
||||
old_value: Vector4, label: String, setter: Callable) -> bool:
|
||||
if new_value.is_equal_approx(old_value):
|
||||
return false
|
||||
core.undo_redo.begin("%s '%s'" % [label, object_id])
|
||||
core.undo_redo.add_do(setter.bind(object_id, new_value))
|
||||
core.undo_redo.add_undo(setter.bind(object_id, old_value))
|
||||
core.undo_redo.commit()
|
||||
return true
|
||||
@@ -0,0 +1,65 @@
|
||||
class_name EditorToolbar
|
||||
extends HBoxContainer
|
||||
## Tool-mode switcher for the in-game editor (docs/architecture/editor.md
|
||||
## §7.2 `Toolbar`). Pure UI: it only emits signals: `InGameEditor` decides
|
||||
## what to do with them (calling into `EditorCore`/`ToolRegistry`).
|
||||
|
||||
signal tool_selected(tool_id: String)
|
||||
signal undo_pressed
|
||||
signal redo_pressed
|
||||
|
||||
const TOOL_LABELS := {
|
||||
"select": "Select",
|
||||
"brush": "Brush",
|
||||
"object_place": "Place",
|
||||
"erase": "Erase",
|
||||
}
|
||||
|
||||
var _tool_buttons: Dictionary = {}
|
||||
var _undo_button: Button
|
||||
var _redo_button: Button
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
name = "EditorToolbar"
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
for tool_id in TOOL_LABELS:
|
||||
var btn := Button.new()
|
||||
btn.text = TOOL_LABELS[tool_id]
|
||||
btn.toggle_mode = true
|
||||
btn.pressed.connect(_on_tool_button_pressed.bind(tool_id))
|
||||
add_child(btn)
|
||||
_tool_buttons[tool_id] = btn
|
||||
|
||||
add_child(VSeparator.new())
|
||||
|
||||
_undo_button = Button.new()
|
||||
_undo_button.text = "Undo"
|
||||
_undo_button.pressed.connect(func(): undo_pressed.emit())
|
||||
add_child(_undo_button)
|
||||
|
||||
_redo_button = Button.new()
|
||||
_redo_button.text = "Redo"
|
||||
_redo_button.pressed.connect(func(): redo_pressed.emit())
|
||||
add_child(_redo_button)
|
||||
|
||||
|
||||
func _on_tool_button_pressed(tool_id: String) -> void:
|
||||
set_active_tool(tool_id)
|
||||
tool_selected.emit(tool_id)
|
||||
|
||||
|
||||
## Reflect the active tool in the button states without re-emitting the signal.
|
||||
func set_active_tool(tool_id: String) -> void:
|
||||
for id in _tool_buttons:
|
||||
_tool_buttons[id].button_pressed = (id == tool_id)
|
||||
|
||||
|
||||
## Reflect whether undo/redo currently have anything to do.
|
||||
func set_history_state(can_undo: bool, can_redo: bool) -> void:
|
||||
if _undo_button:
|
||||
_undo_button.disabled = not can_undo
|
||||
if _redo_button:
|
||||
_redo_button.disabled = not can_redo
|
||||
@@ -0,0 +1,135 @@
|
||||
class_name EditorViewport
|
||||
extends Control
|
||||
## Custom 2D viewport for the in-game editor (docs/architecture/editor.md
|
||||
## §7.2 `EditorViewport`).
|
||||
##
|
||||
## Deliberately 2D top-down, not a 3D gizmo viewport -- per §8's own risk
|
||||
## mitigation ("start with a 2D tile editor... matches CHUNK_SIZE_Z=1
|
||||
## default; add 3D later"). Renders one tile layer as a grid plus the
|
||||
## chunk's objects as dots, and turns clicks into calls on `EditorCore`
|
||||
## routed through whichever tool is active in `ToolRegistry` -- this is UI
|
||||
## glue, it never mutates `ChunkEditorModel` itself.
|
||||
##
|
||||
## Coordinate convention matches the rest of this codebase's tile system
|
||||
## (scripts/tile_layer_node.gd `_tile_to_world`): chunk-local X/Y are the
|
||||
## flat ground plane, Z is height (CHUNK_SIZE_Z=1 by default -- see
|
||||
## scripts/chunk.gd). One grid cell == one world unit == `cell_size` pixels.
|
||||
|
||||
signal edit_applied
|
||||
|
||||
var core: EditorCore = null
|
||||
var layer_idx: int = 0
|
||||
var cell_size: float = 24.0
|
||||
## Catalog id the next "object_place" click will place. Set by
|
||||
## `InGameEditor` from `PalettePanel.object_selected`.
|
||||
var pending_catalog_id: String = ""
|
||||
## Tile id the next "brush" click paints. Cycled with number keys 0-9.
|
||||
var current_tile_id: int = 1
|
||||
|
||||
const TILE_EMPTY_COLOR := Color(0.15, 0.15, 0.17)
|
||||
const TILE_SOLID_COLOR := Color(0.35, 0.55, 0.35)
|
||||
const GRID_COLOR := Color(0, 0, 0, 0.25)
|
||||
const OBJECT_COLOR := Color(0.9, 0.6, 0.2)
|
||||
const OBJECT_SELECTED_COLOR := Color(1.0, 0.95, 0.2)
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
name = "EditorViewport"
|
||||
mouse_filter = Control.MOUSE_FILTER_STOP
|
||||
focus_mode = Control.FOCUS_ALL
|
||||
|
||||
|
||||
func setup(p_core: EditorCore, p_layer_idx: int = 0) -> void:
|
||||
core = p_core
|
||||
layer_idx = p_layer_idx
|
||||
core.selection.selection_changed.connect(func(_id): queue_redraw())
|
||||
_resize_to_layer()
|
||||
queue_redraw()
|
||||
|
||||
|
||||
func _resize_to_layer() -> void:
|
||||
var layer := core.model.get_layer(layer_idx)
|
||||
if layer == null:
|
||||
custom_minimum_size = Vector2(cell_size * 8, cell_size * 8)
|
||||
return
|
||||
custom_minimum_size = Vector2(layer.width * cell_size, layer.height * cell_size)
|
||||
|
||||
|
||||
func _draw() -> void:
|
||||
if core == null:
|
||||
return
|
||||
var layer := core.model.get_layer(layer_idx)
|
||||
if layer == null:
|
||||
return
|
||||
|
||||
for y in range(layer.height):
|
||||
for x in range(layer.width):
|
||||
var tile_id := layer.get_tile(x, y, 0)
|
||||
var color := TILE_EMPTY_COLOR
|
||||
var tdef := layer.get_tile_def(tile_id)
|
||||
if tdef != null and tdef.solid:
|
||||
color = TILE_SOLID_COLOR
|
||||
draw_rect(Rect2(x * cell_size, y * cell_size, cell_size, cell_size), color, true)
|
||||
|
||||
for x in range(layer.width + 1):
|
||||
draw_line(Vector2(x * cell_size, 0), Vector2(x * cell_size, layer.height * cell_size), GRID_COLOR)
|
||||
for y in range(layer.height + 1):
|
||||
draw_line(Vector2(0, y * cell_size), Vector2(layer.width * cell_size, y * cell_size), GRID_COLOR)
|
||||
|
||||
for obj in core.model.payload.objects:
|
||||
var center := Vector2(obj.position.x * cell_size, obj.position.y * cell_size)
|
||||
var is_selected: bool = core.selection.get_selected() == obj.id
|
||||
var color := OBJECT_SELECTED_COLOR if is_selected else OBJECT_COLOR
|
||||
draw_circle(center, cell_size * 0.3, color)
|
||||
|
||||
|
||||
func _gui_input(event: InputEvent) -> void:
|
||||
if core == null:
|
||||
return
|
||||
if event is InputEventMouseButton:
|
||||
var mb := event as InputEventMouseButton
|
||||
if mb.pressed and mb.button_index == MOUSE_BUTTON_LEFT:
|
||||
_handle_click(mb.position)
|
||||
accept_event()
|
||||
elif event is InputEventKey:
|
||||
var key := event as InputEventKey
|
||||
if key.pressed and not key.echo:
|
||||
_handle_key(key)
|
||||
|
||||
|
||||
func _handle_key(key: InputEventKey) -> void:
|
||||
if key.keycode >= KEY_0 and key.keycode <= KEY_9:
|
||||
current_tile_id = key.keycode - KEY_0
|
||||
|
||||
|
||||
func _handle_click(local_pos: Vector2) -> void:
|
||||
var tx := int(floor(local_pos.x / cell_size))
|
||||
var ty := int(floor(local_pos.y / cell_size))
|
||||
|
||||
match core.tools.get_active_tool_id():
|
||||
"brush":
|
||||
if core.paint_tile(layer_idx, tx, ty, current_tile_id):
|
||||
edit_applied.emit()
|
||||
queue_redraw()
|
||||
"erase":
|
||||
var hit := _object_at(tx, ty)
|
||||
var changed: bool = core.delete_object(hit) if hit != "" else core.erase_tile(layer_idx, tx, ty)
|
||||
if changed:
|
||||
edit_applied.emit()
|
||||
queue_redraw()
|
||||
"object_place":
|
||||
if pending_catalog_id != "":
|
||||
var new_id := core.place_object(pending_catalog_id, Vector3(tx + 0.5, ty + 0.5, 0.0))
|
||||
if new_id != "":
|
||||
edit_applied.emit()
|
||||
queue_redraw()
|
||||
"select":
|
||||
core.select_object(_object_at(tx, ty))
|
||||
queue_redraw()
|
||||
|
||||
|
||||
func _object_at(tx: int, ty: int) -> String:
|
||||
for obj in core.model.payload.objects:
|
||||
if int(floor(obj.position.x)) == tx and int(floor(obj.position.y)) == ty:
|
||||
return obj.id
|
||||
return ""
|
||||
@@ -0,0 +1,169 @@
|
||||
class_name InGameEditor
|
||||
extends Control
|
||||
## In-game "build mode" UI (docs/architecture/editor.md §7.2 `InGameEditor`).
|
||||
##
|
||||
## Built entirely from `Control` nodes in code (matching this codebase's
|
||||
## existing convention for dynamic UI -- see `game.gd`'s `_show_build_stamp`
|
||||
## / `_show_status`) rather than a hand-authored `.tscn`, so there is one
|
||||
## fewer place for a scene-file/script mismatch to hide. It is only ever
|
||||
## instantiated when the player enters build mode (see `game.gd`'s
|
||||
## `_toggle_build_mode`), so it costs nothing during normal play.
|
||||
##
|
||||
## Composition matches the doc exactly:
|
||||
## EditorToolbar -- tool mode switcher
|
||||
## PalettePanel -- catalog-sourced object palette
|
||||
## EditorViewport -- the 2D tile/object canvas
|
||||
## InspectorPanel -- property editor for the selected object
|
||||
## EditorCore -- shared core (passed in, not owned/created here)
|
||||
##
|
||||
## This UI (and `EditorCore`) never talk to the network -- persisting edits
|
||||
## is a sibling task's job (world_persistence_impl.md's batch-PUT save
|
||||
## path). Closing this editor just discards the UI; the in-memory
|
||||
## `ChunkEditorModel` it was pointed at is unaffected either way.
|
||||
|
||||
signal closed
|
||||
|
||||
var core: EditorCore
|
||||
|
||||
var _toolbar: EditorToolbar
|
||||
var _palette: PalettePanel
|
||||
var _inspector: InspectorPanel
|
||||
var _viewport: EditorViewport
|
||||
var _close_button: Button
|
||||
|
||||
|
||||
func _init(p_core: EditorCore) -> void:
|
||||
core = p_core
|
||||
name = "InGameEditor"
|
||||
set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
mouse_filter = Control.MOUSE_FILTER_STOP
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
_build_ui()
|
||||
_refresh_history_buttons()
|
||||
|
||||
|
||||
func _build_ui() -> void:
|
||||
var bg := ColorRect.new()
|
||||
bg.color = Color(0.08, 0.08, 0.09, 0.96)
|
||||
bg.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
bg.mouse_filter = Control.MOUSE_FILTER_IGNORE
|
||||
add_child(bg)
|
||||
|
||||
var root_vbox := VBoxContainer.new()
|
||||
root_vbox.set_anchors_preset(Control.PRESET_FULL_RECT)
|
||||
root_vbox.offset_left = 12
|
||||
root_vbox.offset_top = 12
|
||||
root_vbox.offset_right = -12
|
||||
root_vbox.offset_bottom = -12
|
||||
add_child(root_vbox)
|
||||
|
||||
var top_bar := HBoxContainer.new()
|
||||
root_vbox.add_child(top_bar)
|
||||
|
||||
_toolbar = EditorToolbar.new()
|
||||
_toolbar.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||||
top_bar.add_child(_toolbar)
|
||||
|
||||
_close_button = Button.new()
|
||||
_close_button.text = "Close (F2)"
|
||||
_close_button.pressed.connect(_on_close_pressed)
|
||||
top_bar.add_child(_close_button)
|
||||
|
||||
var body := HBoxContainer.new()
|
||||
body.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||||
root_vbox.add_child(body)
|
||||
|
||||
var viewport_scroll := ScrollContainer.new()
|
||||
viewport_scroll.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
||||
viewport_scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||||
body.add_child(viewport_scroll)
|
||||
|
||||
_viewport = EditorViewport.new()
|
||||
viewport_scroll.add_child(_viewport)
|
||||
|
||||
var sidebar := VBoxContainer.new()
|
||||
sidebar.custom_minimum_size = Vector2(240, 0)
|
||||
body.add_child(sidebar)
|
||||
|
||||
_palette = PalettePanel.new()
|
||||
sidebar.add_child(_palette)
|
||||
|
||||
_inspector = InspectorPanel.new()
|
||||
sidebar.add_child(_inspector)
|
||||
|
||||
_viewport.setup(core, 0)
|
||||
_palette.set_catalog(core.catalog)
|
||||
_inspector.setup(core)
|
||||
|
||||
_toolbar.set_active_tool(core.tools.get_active_tool_id())
|
||||
_toolbar.tool_selected.connect(_on_tool_selected)
|
||||
_toolbar.undo_pressed.connect(_on_undo_pressed)
|
||||
_toolbar.redo_pressed.connect(_on_redo_pressed)
|
||||
_palette.object_selected.connect(_on_palette_object_selected)
|
||||
_inspector.delete_requested.connect(_on_inspector_delete_requested)
|
||||
_viewport.edit_applied.connect(_on_edit_applied)
|
||||
core.selection.selection_changed.connect(_on_selection_changed)
|
||||
|
||||
|
||||
func _unhandled_key_input(event: InputEvent) -> void:
|
||||
if not (event is InputEventKey):
|
||||
return
|
||||
var key := event as InputEventKey
|
||||
if not key.pressed or key.echo:
|
||||
return
|
||||
if key.ctrl_pressed and key.keycode == KEY_Z:
|
||||
_on_undo_pressed()
|
||||
get_viewport().set_input_as_handled()
|
||||
elif key.ctrl_pressed and key.keycode == KEY_Y:
|
||||
_on_redo_pressed()
|
||||
get_viewport().set_input_as_handled()
|
||||
elif key.keycode == KEY_DELETE and core.selection.has_selection():
|
||||
core.delete_object(core.selection.get_selected())
|
||||
_on_edit_applied()
|
||||
get_viewport().set_input_as_handled()
|
||||
|
||||
|
||||
func _on_tool_selected(tool_id: String) -> void:
|
||||
core.tools.set_active_tool(tool_id)
|
||||
|
||||
|
||||
func _on_palette_object_selected(catalog_id: String) -> void:
|
||||
_viewport.pending_catalog_id = catalog_id
|
||||
core.tools.set_active_tool("object_place")
|
||||
_toolbar.set_active_tool("object_place")
|
||||
|
||||
|
||||
func _on_inspector_delete_requested(object_id: String) -> void:
|
||||
core.delete_object(object_id)
|
||||
_on_edit_applied()
|
||||
|
||||
|
||||
func _on_undo_pressed() -> void:
|
||||
core.undo()
|
||||
_on_edit_applied()
|
||||
|
||||
|
||||
func _on_redo_pressed() -> void:
|
||||
core.redo()
|
||||
_on_edit_applied()
|
||||
|
||||
|
||||
func _on_edit_applied() -> void:
|
||||
_viewport.queue_redraw()
|
||||
_inspector.show_object(core.selection.get_selected())
|
||||
_refresh_history_buttons()
|
||||
|
||||
|
||||
func _on_selection_changed(object_id: String) -> void:
|
||||
_inspector.show_object(object_id)
|
||||
|
||||
|
||||
func _refresh_history_buttons() -> void:
|
||||
_toolbar.set_history_state(core.undo_redo.can_undo(), core.undo_redo.can_redo())
|
||||
|
||||
|
||||
func _on_close_pressed() -> void:
|
||||
closed.emit()
|
||||
queue_free()
|
||||
@@ -0,0 +1,166 @@
|
||||
class_name InspectorPanel
|
||||
extends VBoxContainer
|
||||
## Property editor for the selected object (docs/architecture/editor.md
|
||||
## §7.2 `InspectorPanel`).
|
||||
##
|
||||
## 2D-tile-editor scope (docs/architecture/editor.md §8: the default world
|
||||
## is flat, `CHUNK_SIZE_Z=1`): position exposes X/Y (world-plane) plus a
|
||||
## single "height" Z for props that sit above the floor, and rotation
|
||||
## exposes one yaw field (rotation about the vertical axis) rather than a
|
||||
## full 3-axis gizmo -- deliberately not the volumetric 3D editing the doc
|
||||
## says to defer.
|
||||
##
|
||||
## Pure UI: every edit calls back into `EditorCore` (`move_object` /
|
||||
## `rotate_object` / `scale_object` / `delete_object`), so inspector edits
|
||||
## go through the exact same undo/redo path as viewport edits.
|
||||
|
||||
signal delete_requested(object_id: String)
|
||||
|
||||
var _core: EditorCore = null
|
||||
var _object_id: String = ""
|
||||
var _updating := false # guards against feedback loops while refreshing fields
|
||||
|
||||
var _id_label: Label
|
||||
var _type_label: Label
|
||||
var _asset_label: Label
|
||||
var _pos_x: SpinBox
|
||||
var _pos_y: SpinBox
|
||||
var _pos_z: SpinBox
|
||||
var _yaw: SpinBox
|
||||
var _scale_x: SpinBox
|
||||
var _scale_y: SpinBox
|
||||
var _scale_z: SpinBox
|
||||
var _delete_button: Button
|
||||
var _empty_label: Label
|
||||
var _fields_box: VBoxContainer
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
name = "InspectorPanel"
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
var header := Label.new()
|
||||
header.text = "Inspector"
|
||||
add_child(header)
|
||||
|
||||
_empty_label = Label.new()
|
||||
_empty_label.text = "(nothing selected)"
|
||||
add_child(_empty_label)
|
||||
|
||||
_fields_box = VBoxContainer.new()
|
||||
_fields_box.visible = false
|
||||
add_child(_fields_box)
|
||||
|
||||
_id_label = _add_readonly_row("id")
|
||||
_type_label = _add_readonly_row("type")
|
||||
_asset_label = _add_readonly_row("asset")
|
||||
|
||||
_pos_x = _add_spinbox_row("pos x")
|
||||
_pos_y = _add_spinbox_row("pos y")
|
||||
_pos_z = _add_spinbox_row("pos z (height)")
|
||||
_pos_x.value_changed.connect(_on_position_changed)
|
||||
_pos_y.value_changed.connect(_on_position_changed)
|
||||
_pos_z.value_changed.connect(_on_position_changed)
|
||||
|
||||
_yaw = _add_spinbox_row("rotation (deg)")
|
||||
_yaw.min_value = -360.0
|
||||
_yaw.max_value = 360.0
|
||||
_yaw.step = 1.0
|
||||
_yaw.value_changed.connect(_on_yaw_changed)
|
||||
|
||||
_scale_x = _add_spinbox_row("scale x")
|
||||
_scale_y = _add_spinbox_row("scale y")
|
||||
_scale_z = _add_spinbox_row("scale z")
|
||||
_scale_x.value_changed.connect(_on_scale_changed)
|
||||
_scale_y.value_changed.connect(_on_scale_changed)
|
||||
_scale_z.value_changed.connect(_on_scale_changed)
|
||||
|
||||
_delete_button = Button.new()
|
||||
_delete_button.text = "Delete"
|
||||
_delete_button.pressed.connect(_on_delete_pressed)
|
||||
_fields_box.add_child(_delete_button)
|
||||
|
||||
|
||||
func setup(core: EditorCore) -> void:
|
||||
_core = core
|
||||
|
||||
|
||||
func show_object(object_id: String) -> void:
|
||||
_object_id = object_id
|
||||
if object_id == "" or _core == null:
|
||||
_empty_label.visible = true
|
||||
_fields_box.visible = false
|
||||
return
|
||||
|
||||
var obj := _core.model.find_object(object_id)
|
||||
if obj == null:
|
||||
_empty_label.visible = true
|
||||
_fields_box.visible = false
|
||||
return
|
||||
|
||||
_empty_label.visible = false
|
||||
_fields_box.visible = true
|
||||
|
||||
_updating = true
|
||||
_id_label.text = "id: %s" % obj.id
|
||||
_type_label.text = "type: %s" % obj.type
|
||||
_asset_label.text = "asset: %s" % obj.asset_id
|
||||
_pos_x.value = obj.position.x
|
||||
_pos_y.value = obj.position.y
|
||||
_pos_z.value = obj.position.z
|
||||
_yaw.value = rad_to_deg(Quaternion(obj.rotation.x, obj.rotation.y, obj.rotation.z, obj.rotation.w).get_euler().y)
|
||||
_scale_x.value = obj.scale.x
|
||||
_scale_y.value = obj.scale.y
|
||||
_scale_z.value = obj.scale.z
|
||||
_updating = false
|
||||
|
||||
|
||||
func _on_position_changed(_v: float) -> void:
|
||||
if _updating or _core == null or _object_id == "":
|
||||
return
|
||||
_core.move_object(_object_id, Vector3(_pos_x.value, _pos_y.value, _pos_z.value))
|
||||
|
||||
|
||||
func _on_yaw_changed(v: float) -> void:
|
||||
if _updating or _core == null or _object_id == "":
|
||||
return
|
||||
var quat := Quaternion(Vector3.UP, deg_to_rad(v))
|
||||
_core.rotate_object(_object_id, Vector4(quat.x, quat.y, quat.z, quat.w))
|
||||
|
||||
|
||||
func _on_scale_changed(_v: float) -> void:
|
||||
if _updating or _core == null or _object_id == "":
|
||||
return
|
||||
_core.scale_object(_object_id, Vector3(_scale_x.value, _scale_y.value, _scale_z.value))
|
||||
|
||||
|
||||
func _on_delete_pressed() -> void:
|
||||
if _object_id == "":
|
||||
return
|
||||
var id := _object_id
|
||||
delete_requested.emit(id)
|
||||
|
||||
|
||||
func _add_readonly_row(label: String) -> Label:
|
||||
var l := Label.new()
|
||||
l.text = "%s: " % label
|
||||
_fields_box.add_child(l)
|
||||
return l
|
||||
|
||||
|
||||
func _add_spinbox_row(label_text: String) -> SpinBox:
|
||||
var row := HBoxContainer.new()
|
||||
var l := Label.new()
|
||||
l.text = label_text
|
||||
l.custom_minimum_size = Vector2(90, 0)
|
||||
row.add_child(l)
|
||||
var sb := SpinBox.new()
|
||||
sb.min_value = -100000.0
|
||||
sb.max_value = 100000.0
|
||||
sb.step = 0.1
|
||||
sb.allow_greater = true
|
||||
sb.allow_lesser = true
|
||||
row.add_child(sb)
|
||||
_fields_box.add_child(row)
|
||||
return sb
|
||||
@@ -0,0 +1,57 @@
|
||||
class_name PalettePanel
|
||||
extends VBoxContainer
|
||||
## Catalog-sourced object palette (docs/architecture/editor.md §7.2
|
||||
## `PalettePanel`). Lists every id in an `EditorObjectCatalog` and emits
|
||||
## which one the player picked; `InGameEditor` remembers it as the pending
|
||||
## `catalog_id` for the next `ObjectPlaceTool` placement.
|
||||
|
||||
signal object_selected(catalog_id: String)
|
||||
|
||||
var _list: ItemList
|
||||
var _catalog: EditorObjectCatalog = null
|
||||
var _ids: Array[String] = []
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
name = "PalettePanel"
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
var header := Label.new()
|
||||
header.text = "Palette"
|
||||
add_child(header)
|
||||
|
||||
_list = ItemList.new()
|
||||
_list.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
||||
_list.item_selected.connect(_on_item_selected)
|
||||
add_child(_list)
|
||||
|
||||
|
||||
func set_catalog(catalog: EditorObjectCatalog) -> void:
|
||||
_catalog = catalog
|
||||
_refresh()
|
||||
|
||||
|
||||
func _refresh() -> void:
|
||||
_list.clear()
|
||||
_ids.clear()
|
||||
if _catalog == null or not _catalog.is_loaded():
|
||||
return
|
||||
for id in _catalog.get_all_ids():
|
||||
var entry := _catalog.resolve(id)
|
||||
var label: String = entry.get("display_name", id)
|
||||
_list.add_item(label)
|
||||
_ids.append(id)
|
||||
|
||||
|
||||
func _on_item_selected(index: int) -> void:
|
||||
if index < 0 or index >= _ids.size():
|
||||
return
|
||||
object_selected.emit(_ids[index])
|
||||
|
||||
|
||||
func get_selected_catalog_id() -> String:
|
||||
var selected: PackedInt32Array = _list.get_selected_items()
|
||||
if selected.is_empty():
|
||||
return ""
|
||||
return _ids[selected[0]]
|
||||
+61
-2
@@ -28,6 +28,14 @@ var _remotes: Dictionary = {} # peer_id -> Node3D
|
||||
var _remote_prev: Dictionary = {} # peer_id -> Vector3 (last snapshot position)
|
||||
var _status_label: Label = null
|
||||
|
||||
## Build-mode UI, gated behind toggle_build_mode (F2) -- only ever
|
||||
## instantiated once the player actually enters build mode
|
||||
## (docs/architecture/editor.md §7.2: "Instantiated only when the player
|
||||
## enters 'build mode'... so the runtime footprint is negligible during
|
||||
## normal play"). Editing is in-memory only here; the save path to the
|
||||
## backend is a sibling task (world_persistence_impl.md).
|
||||
var _build_editor: InGameEditor = null
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
_show_build_stamp()
|
||||
@@ -36,13 +44,64 @@ func _ready() -> void:
|
||||
|
||||
|
||||
func _unhandled_input(event: InputEvent) -> void:
|
||||
# ESC leaves the world back to the browser. Handled here (the scene root
|
||||
if event.is_action_pressed("toggle_build_mode"):
|
||||
get_viewport().set_input_as_handled()
|
||||
_toggle_build_mode()
|
||||
return
|
||||
|
||||
# ESC leaves the world back to the browser (or, while build mode is
|
||||
# open, just closes build mode instead). Handled here (the scene root
|
||||
# that owns the connection) rather than in player.gd so the teardown is
|
||||
# a single ordered path -- doing it from two places raced _on_server_lost
|
||||
# against the scene change and looked like a crash.
|
||||
if event.is_action_pressed("ui_cancel"):
|
||||
get_viewport().set_input_as_handled()
|
||||
_leave_world()
|
||||
if _build_editor != null and is_instance_valid(_build_editor):
|
||||
_close_build_mode()
|
||||
else:
|
||||
_leave_world()
|
||||
|
||||
|
||||
## Entry point into the in-game editor (docs/architecture/editor.md §7.2).
|
||||
## Freezes the player and opens a fresh, empty in-memory chunk to edit --
|
||||
## loading a *real* chunk from the backend for editing is the sibling
|
||||
## save-path task's territory (it owns the HTTP round-trip); this task's
|
||||
## contract stops at "a correctly-editable in-memory ChunkEditorModel".
|
||||
func _toggle_build_mode() -> void:
|
||||
if _build_editor != null and is_instance_valid(_build_editor):
|
||||
_close_build_mode()
|
||||
else:
|
||||
_open_build_mode()
|
||||
|
||||
|
||||
func _open_build_mode() -> void:
|
||||
var model := ChunkEditorModel.create_empty(32, 32, str(Session.world_id), "main")
|
||||
var catalog := EditorObjectCatalog.new()
|
||||
var err := catalog.load_catalog()
|
||||
if err != OK:
|
||||
push_error("game.gd: failed to load editor object catalog (%d)" % err)
|
||||
var core := EditorCore.new(model, catalog)
|
||||
|
||||
_build_editor = InGameEditor.new(core)
|
||||
_build_editor.closed.connect(_close_build_mode)
|
||||
add_child(_build_editor)
|
||||
|
||||
Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
|
||||
_player.set_physics_process(false)
|
||||
_player.set_process_unhandled_input(false)
|
||||
|
||||
|
||||
## Shared teardown for both close paths (F2 again, or the editor's own
|
||||
## Close button/`closed` signal) -- safe to call twice: `queue_free()` on an
|
||||
## already-freeing node and restoring already-restored player state are
|
||||
## both no-ops.
|
||||
func _close_build_mode() -> void:
|
||||
if _build_editor != null and is_instance_valid(_build_editor):
|
||||
_build_editor.queue_free()
|
||||
_build_editor = null
|
||||
_player.set_physics_process(true)
|
||||
_player.set_process_unhandled_input(true)
|
||||
_player._refresh_mouse_mode()
|
||||
|
||||
|
||||
func _leave_world() -> void:
|
||||
|
||||
@@ -0,0 +1,260 @@
|
||||
extends SceneTree
|
||||
## Real exercise of the in-game editor's data-native core
|
||||
## (docs/architecture/editor.md §7.1/§7.2, scoped to 2D per §8).
|
||||
##
|
||||
## Loads a real chunk (the backend's golden fixture
|
||||
## backend/tests/fixtures/chunks/simple_tile_chunk.bin -- the same file
|
||||
## scripts/smoke_test_chunk_codec_interop.gd proves decodes correctly),
|
||||
## wraps it in a ChunkEditorModel, and drives every operation
|
||||
## (place/move/rotate/scale/delete an object, paint/erase a tile) through
|
||||
## the actual EditorCore.use_tool()/ToolRegistry path -- never by calling
|
||||
## ChunkEditorModel's raw setters directly, which would bypass the tool
|
||||
## layer this task was scoped to build. Then it undoes every single one of
|
||||
## those operations and checks the chunk is back to exactly its starting
|
||||
## state, redoes them all back, and finally round-trips the result through
|
||||
## encode_binary()/decode_binary() to prove the model stays a valid,
|
||||
## byte-compatible ChunkPayload throughout -- the contract the sibling
|
||||
## save-path task depends on.
|
||||
##
|
||||
## Run with:
|
||||
## ~/godot/godot --headless --path . --script res://scripts/smoke_test_editor_core.gd
|
||||
|
||||
const FIXTURE_PATH := "res://backend/tests/fixtures/chunks/simple_tile_chunk.bin"
|
||||
|
||||
var passed := 0
|
||||
var failed := 0
|
||||
|
||||
|
||||
func _check(label: String, cond: bool) -> void:
|
||||
if cond:
|
||||
passed += 1
|
||||
print(" PASS: ", label)
|
||||
else:
|
||||
failed += 1
|
||||
printerr(" FAIL: ", label)
|
||||
|
||||
|
||||
func _initialize() -> void:
|
||||
_run()
|
||||
|
||||
|
||||
func _run() -> void:
|
||||
await _test_full_editing_loop()
|
||||
_test_catalog_rejects_unknown_id()
|
||||
_test_selection_is_not_undoable()
|
||||
|
||||
print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
|
||||
quit(0 if failed == 0 else 1)
|
||||
|
||||
|
||||
func _read_fixture() -> PackedByteArray:
|
||||
var f := FileAccess.open(FIXTURE_PATH, FileAccess.READ)
|
||||
if f == null:
|
||||
push_error("Could not open fixture: " + FIXTURE_PATH)
|
||||
return PackedByteArray()
|
||||
return f.get_buffer(f.get_length())
|
||||
|
||||
|
||||
func _test_full_editing_loop() -> void:
|
||||
print("--- EditorCore/ToolRegistry over a real decoded chunk (simple_tile_chunk.bin) ---")
|
||||
|
||||
var original_bytes := _read_fixture()
|
||||
_check("fixture file read (non-empty)", original_bytes.size() > 0)
|
||||
if original_bytes.is_empty():
|
||||
return
|
||||
|
||||
var model := ChunkEditorModel.from_binary(original_bytes)
|
||||
_check("ChunkEditorModel.from_binary decoded the fixture", model != null)
|
||||
if model == null:
|
||||
return
|
||||
|
||||
# Baseline sanity on the loaded real chunk before touching anything.
|
||||
_check("loaded chunk has 1 tile layer", model.payload.tile_layers.size() == 1)
|
||||
_check("loaded chunk is 4x4", model.get_layer(0).width == 4 and model.get_layer(0).height == 4)
|
||||
var baseline_tiles := (model.get_layer(0).tiles as PackedInt32Array).duplicate()
|
||||
var baseline_object_count := model.payload.objects.size()
|
||||
|
||||
var catalog := EditorObjectCatalog.new()
|
||||
var cat_err := catalog.load_catalog()
|
||||
_check("object catalog loaded", cat_err == OK)
|
||||
|
||||
var core := EditorCore.new(model, catalog)
|
||||
_check("EditorCore registers all 5 tools", core.tools.get_tool_ids().size() == 5)
|
||||
for expected_tool in ["brush", "object_place", "select", "erase", "transform"]:
|
||||
_check("ToolRegistry has tool '%s'" % expected_tool, core.tools.has_tool(expected_tool))
|
||||
|
||||
# ── 1. Paint a tile via the brush tool (through EditorCore/ToolRegistry) ──
|
||||
_check("tile (0,0) starts as 0 in the fixture", model.get_tile_raw(0, 0, 0) == 0)
|
||||
var painted := core.paint_tile(0, 0, 0, 1)
|
||||
_check("core.paint_tile (brush tool) applied", painted)
|
||||
_check("tile (0,0) is now 1 after paint", model.get_tile_raw(0, 0, 0) == 1)
|
||||
|
||||
# ── 2. Place a catalog object (through EditorCore/ToolRegistry) ──
|
||||
var obj_id := core.place_object("crate_small", Vector3(1.5, 1.5, 0.0))
|
||||
_check("core.place_object (object_place tool) returned a real id", obj_id != "")
|
||||
_check("placed object exists in the model", model.find_object(obj_id) != null)
|
||||
_check("placed object got the catalog's asset_id", model.find_object(obj_id).asset_id == "props/crate_small.glb")
|
||||
_check("placing auto-selected the new object", core.selection.get_selected() == obj_id)
|
||||
|
||||
# ── 3. Select it explicitly via the select tool ──
|
||||
_check("core.select_object (select tool)", core.select_object(obj_id))
|
||||
_check("selection reflects it", core.selection.get_selected() == obj_id)
|
||||
|
||||
# ── 4. Move / rotate / scale via the transform tool ──
|
||||
var moved := core.move_object(obj_id, Vector3(5.0, 6.0, 0.0))
|
||||
_check("core.move_object (transform tool) applied", moved)
|
||||
_check("object position updated", model.find_object(obj_id).position.is_equal_approx(Vector3(5.0, 6.0, 0.0)))
|
||||
|
||||
var new_rot := Vector4(0.0, 0.7071068, 0.0, 0.7071068) # 90 deg yaw
|
||||
var rotated := core.rotate_object(obj_id, new_rot)
|
||||
_check("core.rotate_object (transform tool) applied", rotated)
|
||||
_check("object rotation updated", model.find_object(obj_id).rotation.is_equal_approx(new_rot))
|
||||
|
||||
var scaled := core.scale_object(obj_id, Vector3(2.0, 2.0, 2.0))
|
||||
_check("core.scale_object (transform tool) applied", scaled)
|
||||
_check("object scale updated", model.find_object(obj_id).scale.is_equal_approx(Vector3(2.0, 2.0, 2.0)))
|
||||
|
||||
# ── 5. Erase a different tile (the fixture already has a nonzero tile at
|
||||
# (1,0) -- world_id 12's palette makes it a real, non-empty tile id, so
|
||||
# erase has something genuine to clear without needing a manual seed). ──
|
||||
var original_tile_1_0 := model.get_tile_raw(0, 1, 0)
|
||||
_check("tile (1,0) is nonzero in the fixture (something real to erase)", original_tile_1_0 != 0)
|
||||
var erased_tile := core.erase_tile(0, 1, 0)
|
||||
_check("core.erase_tile (erase tool) applied", erased_tile)
|
||||
_check("tile (1,0) is 0 after erase", model.get_tile_raw(0, 1, 0) == 0)
|
||||
|
||||
# ── 6. Delete the object via the erase tool ──
|
||||
var deleted := core.delete_object(obj_id)
|
||||
_check("core.delete_object (erase tool) applied", deleted)
|
||||
_check("object is gone from the model", model.find_object(obj_id) == null)
|
||||
_check("deleting the selected object cleared the selection", not core.selection.has_selection())
|
||||
|
||||
# ── 7. Undo every operation (6 ops) and verify each actually reverts ──
|
||||
print("--- undo/redo actually revert each step ---")
|
||||
_check("undo #1 (re-adds deleted object)", core.undo())
|
||||
_check("object exists again after undo", model.find_object(obj_id) != null)
|
||||
|
||||
_check("undo #2 (un-erases tile)", core.undo())
|
||||
_check("tile (1,0) is back to its original value after undo",
|
||||
model.get_tile_raw(0, 1, 0) == original_tile_1_0)
|
||||
|
||||
_check("undo #3 (un-scales)", core.undo())
|
||||
_check("scale reverted", model.find_object(obj_id).scale.is_equal_approx(Vector3.ONE))
|
||||
|
||||
_check("undo #4 (un-rotates)", core.undo())
|
||||
_check("rotation reverted", model.find_object(obj_id).rotation.is_equal_approx(Vector4(0, 0, 0, 1)))
|
||||
|
||||
_check("undo #5 (un-moves)", core.undo())
|
||||
_check("position reverted", model.find_object(obj_id).position.is_equal_approx(Vector3(1.5, 1.5, 0.0)))
|
||||
|
||||
_check("undo #6 (un-places, object removed)", core.undo())
|
||||
_check("placed object is gone after undo", model.find_object(obj_id) == null)
|
||||
|
||||
_check("undo #7 (un-paints tile)", core.undo())
|
||||
_check("tile (0,0) is back to 0 after undo", model.get_tile_raw(0, 0, 0) == 0)
|
||||
|
||||
_check("no more undo history", not core.undo_redo.can_undo())
|
||||
_check("tiles exactly match the original fixture after full undo",
|
||||
model.get_layer(0).tiles == baseline_tiles)
|
||||
_check("object count matches the original fixture after full undo",
|
||||
model.payload.objects.size() == baseline_object_count)
|
||||
|
||||
# ── 8. Redo everything back ──
|
||||
print("--- redo replays every step forward again ---")
|
||||
var redo_count := 0
|
||||
while core.redo():
|
||||
redo_count += 1
|
||||
_check("redo replayed all 7 recorded actions", redo_count == 7)
|
||||
_check("tile (0,0) painted again after full redo", model.get_tile_raw(0, 0, 0) == 1)
|
||||
_check("object gone again after full redo (last op was delete)", model.find_object(obj_id) == null)
|
||||
|
||||
# ── 9. Round-trip the final state through encode/decode ──
|
||||
print("--- encode_binary()/decode_binary() round-trip after editing ---")
|
||||
var re_encoded := model.encode_binary()
|
||||
_check("re-encoded chunk is non-empty", re_encoded.size() > 0)
|
||||
var re_decoded := ChunkDataDecoder.decode_binary(re_encoded)
|
||||
_check("re-decoded without error", re_decoded != null)
|
||||
if re_decoded != null:
|
||||
_check("re-decoded tile layer matches edited model",
|
||||
re_decoded.tile_layers[0].tiles == model.get_layer(0).tiles)
|
||||
_check("re-decoded world_id preserved", re_decoded.world_id == model.payload.world_id)
|
||||
_check("re-decoded coord preserved", re_decoded.coord == model.payload.coord)
|
||||
_check("re-decoded bounds preserved",
|
||||
re_decoded.bounds.position.is_equal_approx(model.payload.bounds.position)
|
||||
and re_decoded.bounds.size.is_equal_approx(model.payload.bounds.size))
|
||||
_check("re-decoded object count matches", re_decoded.objects.size() == model.payload.objects.size())
|
||||
|
||||
# ── 10. Also prove a fresh in-memory chunk (no fixture) works end to end,
|
||||
# including that the InGameEditor UI wires up against a real EditorCore
|
||||
# without crashing headlessly. ──
|
||||
await _test_ui_smoke()
|
||||
|
||||
|
||||
func _test_ui_smoke() -> void:
|
||||
print("--- InGameEditor UI wires up against a real EditorCore (headless, no crash) ---")
|
||||
var model := ChunkEditorModel.create_empty(8, 8, "1", "main", Vector3i.ZERO)
|
||||
var catalog := EditorObjectCatalog.new()
|
||||
catalog.load_catalog()
|
||||
var core := EditorCore.new(model, catalog)
|
||||
|
||||
var editor := InGameEditor.new(core)
|
||||
root.add_child(editor)
|
||||
await process_frame # let _ready() run so the UI is actually built
|
||||
_check("InGameEditor instantiated and added to the tree without error", is_instance_valid(editor))
|
||||
|
||||
# Drive a real placement through the viewport's own click handler (not a
|
||||
# bare model mutation) to prove the UI layer -> EditorCore wiring works.
|
||||
# EditorViewport is nested a few levels down (ScrollContainer, etc.).
|
||||
var viewport: EditorViewport = _find_viewport(editor)
|
||||
_check("EditorViewport exists in the built UI", viewport != null)
|
||||
if viewport != null:
|
||||
viewport.pending_catalog_id = "rock_01"
|
||||
core.tools.set_active_tool("object_place")
|
||||
viewport._handle_click(Vector2(20, 20)) # inside tile (0,0) at cell_size 24
|
||||
_check("clicking with object_place active through the viewport placed an object",
|
||||
model.payload.objects.size() == 1)
|
||||
|
||||
editor.queue_free()
|
||||
|
||||
|
||||
func _find_viewport(node: Node) -> EditorViewport:
|
||||
if node is EditorViewport:
|
||||
return node
|
||||
for child in node.get_children():
|
||||
var found := _find_viewport(child)
|
||||
if found != null:
|
||||
return found
|
||||
return null
|
||||
|
||||
|
||||
func _test_catalog_rejects_unknown_id() -> void:
|
||||
print("--- object_place tool rejects an unknown catalog id ---")
|
||||
var model := ChunkEditorModel.create_empty()
|
||||
var catalog := EditorObjectCatalog.new()
|
||||
catalog.load_catalog()
|
||||
var core := EditorCore.new(model, catalog)
|
||||
|
||||
var result := core.place_object("does_not_exist", Vector3.ZERO)
|
||||
_check("unknown catalog_id is rejected (empty id returned)", result == "")
|
||||
_check("nothing was added to the model", model.payload.objects.is_empty())
|
||||
_check("nothing was pushed onto the undo stack", not core.undo_redo.can_undo())
|
||||
|
||||
|
||||
func _test_selection_is_not_undoable() -> void:
|
||||
print("--- selection is UI state, not chunk data (not on the undo stack) ---")
|
||||
var model := ChunkEditorModel.create_empty()
|
||||
var catalog := EditorObjectCatalog.new()
|
||||
catalog.load_catalog()
|
||||
var core := EditorCore.new(model, catalog)
|
||||
|
||||
var obj_id := core.place_object("chest_01", Vector3(2, 2, 0))
|
||||
_check("setup: object placed", obj_id != "")
|
||||
core.select_object(obj_id)
|
||||
_check("object selected", core.selection.get_selected() == obj_id)
|
||||
|
||||
# Only one undoable action should exist (the placement) -- selecting it
|
||||
# must not have added a second one.
|
||||
core.undo()
|
||||
_check("a single undo removes the placed object (selection wasn't a 2nd undo step)",
|
||||
model.find_object(obj_id) == null)
|
||||
_check("no further undo history from selection", not core.undo_redo.can_undo())
|
||||
Reference in New Issue
Block a user