Phase 16: Save/load full coverage + autosave + UI
Three-agent fan-out reusing the contracts-first pattern: Opus pre-wrote
World.clear_all + 4 EventBus signals (save_started/finished, load_started/
finished) before dispatch. Pattern proven across Phases 12/13/14/15/16.
Entity to_dict/from_dict + class_id tagging (Agent A):
- class_id tag added to all 18 entity to_dict methods for loader routing
- Missing pairs filled in: wolf, grave_slot, graveyard_zone, stockpile_zone,
crate (from_dict). All defensive with d.get(field, default).
- Workbench round-trips label_text so Carpenter/Smelter/Millstone/Hearth/
Pyre kinds survive reload
- BeautySystem + DirtinessSystem save_dict/apply_dict for sparse maps
- World.save_tilemap_layers / apply_tilemap_layers covering 5 layers
(Terrain/Floor/Wall/Designation/Roof; Fog runtime-only skipped)
SaveSystem v2 rewrite (Agent B):
- SAVE_VERSION bumped from 1 to 2
- write_save(slot) pauses Sim, emits save_started, collects every entity
via _collect_entities iterating all World registries, writes payload to
user://save_<slot>.json
- apply_save full rewrite: pause sim → emit load_started → World.clear_all
→ apply autoloads (GameState/Clock/Weather/Storyteller) → apply tilemap
layers → iterate payload.entities and dispatch to per-class factories
→ apply beauty/dirt maps → emit load_finished(slot, ok, real_seconds_away)
- Per-class factory registry: 18 class_ids dispatched to setup+add_child+
from_dict patterns. CremationPyre detected via workbench.label_text == 'Pyre'
- Public slot API: save_to_slot/load_from_slot/has_save/delete_save/
peek_save_metadata. Slots locked: &manual + &autosave
Autosave + UI + Resume toast (Agent C):
- autoload/autosave.gd — new Autosave autoload. Periodic every
AUTOSAVE_INTERVAL_TICKS = 6000 (~5 in-game min at 20 Hz) + NOTIFICATION_
APPLICATION_PAUSED (mobile) + NOTIFICATION_WM_WINDOW_FOCUS_OUT (desktop).
Gated by _busy flag tied to EventBus.save_started/save_finished.
- TopBar extended with SaveBtn (💾) + LoadBtn buttons, 48×48 min hit area
- scenes/ui/load_menu.gd — CanvasLayer slot picker. Reads peek_save_metadata
to show 'Manual save (Date Time)' / 'Autosave (Date Time)' rows.
Version-mismatch warning dialog before continuing on older saves.
- scenes/ui/resume_toast.gd — top-center toast. On load_finished(ok=true):
'Welcome back — N minutes/hours away' for 5s + 0.8s fade.
On ok=false: 'Load failed (corrupt or version mismatch)'.
- Strings catalog: 14 new keys (ui.save / ui.load / ui.welcome_back_* /
ui.load_failed etc.)
- main.gd mounts LoadMenu + ResumeToast as runtime CanvasLayer children
MCP runtime verified:
- Saved at tick 1137 → [save] wrote slot 'manual': 113 entities at tick 1137
- Advanced sim to tick 4600 at ULTRA speed (different state)
- load_from_slot(&manual) → [save] applied slot 'manual': 113 entities,
0 errors, tick=1137, away=34s
- post-load: Sim.tick=1137 (restored), pawns alive=3, all furniture +
workbenches + crops + walls + floors back in place
- Resume toast fires: [resume_toast] showing — ok=true seconds_away=34
- Autosave on focus-loss verified: [autosave] focus-loss → wrote autosave
- Screenshot shows TopBar with Save + Load buttons + post-load Lone Wolf
storyteller modal from fresh dawn roll
Known acceptable gaps (deferred to Phase 20 tuning):
- Pawn JobRunner mid-INTERACT/mid-BUILD restarts from toil 0 on reload
(walk toil round-trips; multi-step interact does not). Pawns lose a few
seconds of work.
- Workbench bill mid-craft fetch state isn't fully serialized.
- Wolf.target_pawn re-resolution from name string is Agent A's documented
pattern; Agent B's apply_save respects pawn-restoration ordering so the
resolution works after pawns are back.
Delegation: 3× gdscript-refactor (Sonnet) agents in parallel; integration
+ MCP verify on Opus.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
parent
3da7353387
commit
19d28ca9f8
37 changed files with 1546 additions and 63 deletions
|
|
@ -116,6 +116,55 @@ func clear_pawns() -> void:
|
|||
pawns.clear()
|
||||
|
||||
|
||||
## Phase 16 — wipe every entity registry on the autoload AND queue_free the
|
||||
## live Nodes inside the World scene so apply_save can rebuild from scratch.
|
||||
## The World *scene* (TileMapLayers, providers, autoloads) survives — only the
|
||||
## per-entity registrations + their Node2D children get cleared.
|
||||
##
|
||||
## Safe to call between sim ticks. Called by SaveSystem.apply_save.
|
||||
func clear_all() -> void:
|
||||
# 1. queue_free every registered entity Node so it leaves the tree.
|
||||
var to_free: Array = []
|
||||
to_free.append_array(pawns)
|
||||
to_free.append_array(items)
|
||||
to_free.append_array(trees)
|
||||
to_free.append_array(rocks)
|
||||
to_free.append_array(build_queue) # ghost entities
|
||||
to_free.append_array(doors)
|
||||
to_free.append_array(workbenches)
|
||||
to_free.append_array(crops)
|
||||
to_free.append_array(beds)
|
||||
to_free.append_array(light_sources)
|
||||
to_free.append_array(wolves)
|
||||
to_free.append_array(corpses)
|
||||
to_free.append_array(grave_markers)
|
||||
to_free.append_array(stockpiles)
|
||||
for ent in to_free:
|
||||
if ent != null and is_instance_valid(ent) and ent.has_method("queue_free"):
|
||||
ent.queue_free()
|
||||
# 2. Clear every registry (entity _exit_tree handlers will also try to erase
|
||||
# themselves; double-clear is harmless on a Dictionary/Array).
|
||||
pawns.clear()
|
||||
items.clear()
|
||||
trees.clear()
|
||||
rocks.clear()
|
||||
build_queue.clear()
|
||||
doors.clear()
|
||||
workbenches.clear()
|
||||
crops.clear()
|
||||
beds.clear()
|
||||
light_sources.clear()
|
||||
wolves.clear()
|
||||
corpses.clear()
|
||||
grave_markers.clear()
|
||||
stockpiles.clear()
|
||||
items_needing_haul.clear()
|
||||
rooms.clear()
|
||||
# BeautySystem / DirtinessSystem maps survive (their owning Nodes do too);
|
||||
# their .clear_all() helpers (if any) live on the system itself.
|
||||
Audit.log("world", "clear_all: registries wiped, %d nodes queue_freed" % to_free.size())
|
||||
|
||||
|
||||
# ── Phase 4: harvestables + items + stockpiles ──────────────────────────────
|
||||
|
||||
func register_tree(t) -> void:
|
||||
|
|
@ -283,9 +332,11 @@ func is_tile_lit(p_tile: Vector2i) -> bool:
|
|||
# Called by Wall.on_build_tick() when construction completes.
|
||||
# Stamps the data-only Wall TileMap layer so room/roof/save logic sees the
|
||||
# wall. World scene exposes wall_layer via a getter set during _ready.
|
||||
var terrain_layer = null
|
||||
var wall_layer = null
|
||||
var floor_layer = null
|
||||
var designation_layer = null
|
||||
var roof_layer = null
|
||||
|
||||
|
||||
func mark_wall_tile(tile: Vector2i, material: StringName) -> void:
|
||||
|
|
@ -393,3 +444,74 @@ var beauty_system = null
|
|||
## Exposes: dirt_at(tile), bump(tile, amount), bump_clean(tile, amount),
|
||||
## bump_pawn_traffic(tile, indoor).
|
||||
var dirtiness_system = null
|
||||
|
||||
|
||||
# ── Phase 16: TileMap layer serialisation helpers ────────────────────────────
|
||||
|
||||
## Serialize the five sim-relevant TileMap layers (Terrain, Floor, Wall,
|
||||
## Designation, Roof) into a plain Dictionary. Fog layer is runtime-only and
|
||||
## is NOT serialized.
|
||||
##
|
||||
## Returns:
|
||||
## {
|
||||
## "terrain": [{x, y, source_id, atlas_x, atlas_y}, ...],
|
||||
## "floor": [...],
|
||||
## "wall": [...],
|
||||
## "designation": [...],
|
||||
## "roof": [...],
|
||||
## }
|
||||
##
|
||||
## Called by SaveSystem.build_save() between sim ticks.
|
||||
func save_tilemap_layers() -> Dictionary:
|
||||
var result: Dictionary = {}
|
||||
var layer_map: Dictionary = {
|
||||
"terrain": terrain_layer,
|
||||
"floor": floor_layer,
|
||||
"wall": wall_layer,
|
||||
"designation": designation_layer,
|
||||
"roof": roof_layer,
|
||||
}
|
||||
for layer_name in layer_map:
|
||||
var layer = layer_map[layer_name]
|
||||
var entries: Array = []
|
||||
if layer == null:
|
||||
result[layer_name] = entries
|
||||
continue
|
||||
for cell in layer.get_used_cells():
|
||||
var src_id: int = layer.get_cell_source_id(cell)
|
||||
var atlas: Vector2i = layer.get_cell_atlas_coords(cell)
|
||||
entries.append({
|
||||
"x": cell.x,
|
||||
"y": cell.y,
|
||||
"source_id": src_id,
|
||||
"atlas_x": atlas.x,
|
||||
"atlas_y": atlas.y,
|
||||
})
|
||||
result[layer_name] = entries
|
||||
return result
|
||||
|
||||
|
||||
## Restore the five TileMap layers from a dict produced by save_tilemap_layers().
|
||||
## Clears each layer first, then stamps every saved cell.
|
||||
##
|
||||
## Called by SaveSystem.apply_save() before respawning entities.
|
||||
func apply_tilemap_layers(d: Dictionary) -> void:
|
||||
var layer_map: Dictionary = {
|
||||
"terrain": terrain_layer,
|
||||
"floor": floor_layer,
|
||||
"wall": wall_layer,
|
||||
"designation": designation_layer,
|
||||
"roof": roof_layer,
|
||||
}
|
||||
for layer_name in layer_map:
|
||||
var layer = layer_map[layer_name]
|
||||
if layer == null:
|
||||
continue
|
||||
layer.clear()
|
||||
for entry in d.get(layer_name, []):
|
||||
if not entry is Dictionary:
|
||||
continue
|
||||
var cell := Vector2i(int(entry.get("x", 0)), int(entry.get("y", 0)))
|
||||
var src_id: int = int(entry.get("source_id", 0))
|
||||
var atlas := Vector2i(int(entry.get("atlas_x", 0)), int(entry.get("atlas_y", 0)))
|
||||
layer.set_cell(cell, src_id, atlas)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue