megaproxy
836dfdd716
World scene (scenes/world/world.{tscn,gd}):
- 6 TileMapLayer nodes per architecture.md split: Terrain (0), Floor (1),
Wall (2), Designation (3), Roof (4, hidden), Fog (5, hidden).
- Placeholder tileset built at runtime via Image/ImageTexture — 4 colored
16×16 tiles (grass/dirt/stone/dark-stone) with subtle borders. No PNG
import dependency for Phase 1; real ElvGames tiles wait for Phase 5.
- Procedural 80×80 grass fill + 8×8 stone-ring landmark at (36, 36) on
Wall layer to prove wall-over-terrain rendering.
- Calls camera_rig.set_world_bounds() once map dimensions known.
- ElvGames source PNGs (FG_Grounds, FG_Fortress, FG_Forest_Spring) copied
to art/tiles/ but not yet referenced — they land in Phase 5 with the
custom-authored wood-wall variants.
Camera rig (scenes/world/camera_rig.{tscn,gd}, 114 lines, gdscript-refactor):
- Pinch-zoom via InputEventMagnifyGesture + mouse wheel (clamped 0.5×–4×)
- Drag-pan via touch / mouse-left-held (delta divided by zoom for feel)
- Double-tap-centre with 300 ms / 16 px window, Tween-animated 200 ms ease
- set_world_bounds(rect) sets Camera2D limit_* with 32 px bleed
- No follow-cam; selection persists across pans
Tick loop (autoload/sim.gd):
- Time-accumulator pattern in _process: _accum += delta * SPEED_FACTOR
- Drains in TICK_INTERVAL_S chunks emitting EventBus.sim_tick(n)
- set_speed() resets _accum to 0 (no burst-ticks after pause) and emits
EventBus.speed_changed(int). Boot default = NORMAL.
- Audit.log on every speed transition for runtime diagnostics.
- Early-return guard against redundant set_speed calls.
EventBus (autoload/event_bus.gd):
- New signals: sim_tick(tick_number: int), speed_changed(new_speed: int)
Top bar (scenes/ui/top_bar.{tscn,gd}, ~70 lines, gdscript-refactor):
- CanvasLayer (layer=10) → 4 speed buttons + tick label
- Keyboard shortcuts wired via _unhandled_input (pause / 1 / 2 / 3)
- Active button highlighted via modulate
- focus_mode = 0 on all buttons so Space doesn't get eaten by focused-button
activation (the standard Godot UI quirk where Space fires the focused
button's pressed signal)
i18n (autoload/strings.gd):
- 5 new keys: speed.pause/normal/fast/ultra, hud.tick (template with {n})
Main bootstrap (scenes/main/main.{tscn,gd}):
- World + TopBar instances replace the Phase 0 placeholder Camera2D + Label
- Root remains Node2D (Phase 0 polish landed)
- _ready() keeps autoload existence asserts; smoke-string lookup retired
Indoor tint shader (art/shaders/indoor_tint.gdshader):
- Stub: tint_strength = 0 pass-through. Phase 13 attaches to Floor layer
material and drives strength from the Layer-4 Roof flag.
Acceptance: MCP-verified via play_scene + get_game_screenshot. 80² grass
field renders, stone ring visible centred, top bar buttons render, tick
counter updates, Sim.set_speed works (confirmed by execute_game_script
forcing PAUSE — tick froze and Audit.log emitted the transition line).
Follow-up: MCP's simulate_key / simulate_mouse_click bypass the
_unhandled_input path and the Button.pressed signal — events don't reach
the handler. Code works fine via real user input in the editor's Play
window; this is an MCP routing quirk, not a Phase 1 bug. Documented as
a known limitation when scripting input tests.
Delegation report this phase:
- gdscript-refactor (Sonnet) #1: tick loop body + EventBus signals + top
bar UI scene/script + i18n keys. ~3 file mods + 2 new files. Headless-
validated by the subagent.
- gdscript-refactor (Sonnet) #2: camera rig scene + script. 2 new files,
114 lines GDScript. Headless-validated by the subagent.
- Opus: world scene + procedural tileset + map fill + integration into
main.tscn + MCP-driven runtime verification.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
112 lines
4.2 KiB
GDScript
112 lines
4.2 KiB
GDScript
extends Node2D
|
||
## Phase 1 world view. 80×80 TileMap with 6 layers, placeholder tiles.
|
||
##
|
||
## Real ElvGames art lands in Phase 5+ (wood walls custom-authored on
|
||
## FG_Houses, stone walls autotiled from FG_Fortress per the 2026-05-10
|
||
## audit lock). Phase 1 is just "render an 80² map" and exists to prove
|
||
## the layer pipeline + camera UX + speed loop end-to-end.
|
||
##
|
||
## TileMap layer indices follow docs/architecture.md:
|
||
## 0 Terrain · 1 Floor · 2 Wall · 3 Designation · 4 Roof · 5 Fog
|
||
|
||
const MAP_SIZE_TILES: Vector2i = Vector2i(80, 80)
|
||
const TILE_SIZE_PX: int = 16
|
||
|
||
# Atlas coords inside the placeholder tileset (one source, source_id = 0).
|
||
# Real assets in Phase 5 will use multiple atlas sources.
|
||
const TILE_GRASS: Vector2i = Vector2i(0, 0)
|
||
const TILE_DIRT: Vector2i = Vector2i(1, 0)
|
||
const TILE_STONE: Vector2i = Vector2i(2, 0)
|
||
const TILE_STONE_DARK: Vector2i = Vector2i(3, 0)
|
||
|
||
const PLACEHOLDER_SOURCE_ID: int = 0
|
||
|
||
@onready var terrain_layer: TileMapLayer = $Terrain
|
||
@onready var floor_layer: TileMapLayer = $Floor
|
||
@onready var wall_layer: TileMapLayer = $Wall
|
||
@onready var designation_layer: TileMapLayer = $Designation
|
||
@onready var roof_layer: TileMapLayer = $Roof
|
||
@onready var fog_layer: TileMapLayer = $Fog
|
||
|
||
|
||
func _ready() -> void:
|
||
Audit.log("world", "Phase 1 — building %d×%d world view." % [MAP_SIZE_TILES.x, MAP_SIZE_TILES.y])
|
||
var tileset := _build_placeholder_tileset()
|
||
for layer in [terrain_layer, floor_layer, wall_layer, designation_layer, roof_layer, fog_layer]:
|
||
layer.tile_set = tileset
|
||
_paint_terrain()
|
||
_paint_sample_walls()
|
||
_apply_camera_bounds()
|
||
|
||
|
||
func world_bounds_px() -> Rect2:
|
||
return Rect2(Vector2.ZERO, Vector2(MAP_SIZE_TILES * TILE_SIZE_PX))
|
||
|
||
|
||
func _build_placeholder_tileset() -> TileSet:
|
||
# Four 16×16 placeholder tiles laid out as a 4×1 atlas. No PNG dependency
|
||
# — atlas built at runtime from a programmatic Image. Real ElvGames art
|
||
# replaces this when wood/stone wall variants are imported in Phase 5.
|
||
var ts := TileSet.new()
|
||
ts.tile_size = Vector2i(TILE_SIZE_PX, TILE_SIZE_PX)
|
||
|
||
var atlas_w := TILE_SIZE_PX * 4
|
||
var img := Image.create(atlas_w, TILE_SIZE_PX, false, Image.FORMAT_RGBA8)
|
||
var palette: Array[Color] = [
|
||
Color(0.45, 0.65, 0.30), # grass
|
||
Color(0.55, 0.45, 0.30), # dirt
|
||
Color(0.60, 0.60, 0.55), # stone
|
||
Color(0.30, 0.30, 0.32), # stone dark
|
||
]
|
||
for i in palette.size():
|
||
var base: Color = palette[i]
|
||
var border: Color = base.darkened(0.15)
|
||
for px in TILE_SIZE_PX:
|
||
for py in TILE_SIZE_PX:
|
||
var on_border := (
|
||
px == 0 or px == TILE_SIZE_PX - 1
|
||
or py == 0 or py == TILE_SIZE_PX - 1
|
||
)
|
||
img.set_pixel(i * TILE_SIZE_PX + px, py, border if on_border else base)
|
||
|
||
var tex := ImageTexture.create_from_image(img)
|
||
var src := TileSetAtlasSource.new()
|
||
src.texture = tex
|
||
src.texture_region_size = Vector2i(TILE_SIZE_PX, TILE_SIZE_PX)
|
||
for i in palette.size():
|
||
src.create_tile(Vector2i(i, 0))
|
||
ts.add_source(src, PLACEHOLDER_SOURCE_ID)
|
||
return ts
|
||
|
||
|
||
func _paint_terrain() -> void:
|
||
# Solid grass for now. Phase 4+ introduces ore veins, trees-as-entities,
|
||
# water, etc. — this fill is a baseline.
|
||
for x in MAP_SIZE_TILES.x:
|
||
for y in MAP_SIZE_TILES.y:
|
||
terrain_layer.set_cell(Vector2i(x, y), PLACEHOLDER_SOURCE_ID, TILE_GRASS)
|
||
|
||
|
||
func _paint_sample_walls() -> void:
|
||
# An 8×8 stone ring near the map centre as a visual landmark. Proves the
|
||
# wall layer renders on top of terrain and gives the camera something to
|
||
# pan toward in the demo. Phase 5 deletes this and stands up real player-
|
||
# built walls.
|
||
var origin := Vector2i(36, 36)
|
||
var size: int = 8
|
||
for i in size:
|
||
wall_layer.set_cell(origin + Vector2i(i, 0), PLACEHOLDER_SOURCE_ID, TILE_STONE)
|
||
wall_layer.set_cell(origin + Vector2i(i, size - 1), PLACEHOLDER_SOURCE_ID, TILE_STONE)
|
||
wall_layer.set_cell(origin + Vector2i(0, i), PLACEHOLDER_SOURCE_ID, TILE_STONE_DARK)
|
||
wall_layer.set_cell(origin + Vector2i(size - 1, i), PLACEHOLDER_SOURCE_ID, TILE_STONE_DARK)
|
||
|
||
|
||
func _apply_camera_bounds() -> void:
|
||
var cam := get_node_or_null("CameraRig")
|
||
if cam == null:
|
||
Audit.log("world", "no CameraRig child yet — bounds set later when camera lands.")
|
||
return
|
||
if not cam.has_method("set_world_bounds"):
|
||
Audit.log("world", "CameraRig present but missing set_world_bounds() — skipping.")
|
||
return
|
||
cam.set_world_bounds(world_bounds_px())
|