megaproxy/rimlike
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
rimlike/memory.md
megaproxy f82807ff3d Phase 5 — Designation, BuildJob, Wall/Floor/Door, Crate; 3/4 perspective pivot 
Three gdscript-refactor agents in parallel + Opus integration.

Architectural pivot (memory.md Decisions table updated):
- View: top-down grid for gameplay + 3/4-perspective rendering for vertical
  structures (Stardew/Going Medieval style). Walls/doors/crates are Y-sorted
  entity sprites, not TileMap cells.
- Wall TileMap layer (Layer 2) becomes data-only — used for room detection,
  roof BFS, save serialization. Visual rendering happens at entity level.
- Asset reality check baked into the decision: the entire asset library is
  RPG-style perspective art; pivoting the renderer is cheaper than authoring
  or commissioning top-down 47-tile autotile sets.

Designation paint (scenes/world/, Agent A — ~170 lines):
- class_name Designation extends Node, lives as DesignationCtl child of World
- TOOL_NONE / TOOL_BUILD_WALL / TOOL_BUILD_FLOOR
- _unhandled_input captures left-mouse press/drag/release
- Drag-paints ghost tiles on Layer 3 via paint_layer.set_cell
- Green/red modulate based on World.pathfinder.is_walkable + cell occupancy
- Emits EventBus.designation_added/cleared per cell
- Selection.designation_active guard prevents double-handling clicks

EventBus signals added:
- designation_added(cell: Vector2i, tool: StringName)
- designation_cleared(cell: Vector2i)

BuildJob + Wall/Floor/Door entities (scenes/ai/ + scenes/entities/, Agent B — ~530 lines):
- Toil.KIND_BUILD + Toil.build_at(target_path) factory
- JobRunner._tick_build: resolves NodePath target, calls on_build_tick() per
  sim tick, marks toil done when is_buildable() returns false
- ConstructionProvider (priority=6, highest): nearest is_buildable() site in
  World.build_queue → Job=[walk_to(site.tile), build_at(site.get_path())]
- Wall entity: BUILD_TICKS=100, 40% alpha ghost; _complete() calls
  pathfinder.set_cell_walkable(false) + World.mark_wall_tile + Audit.log
- Floor entity: BUILD_TICKS=30, ground-level (no y_sort), does NOT block
  pathfinding, calls mark_floor_tile on complete
- Door entity: BUILD_TICKS=80, bottom-anchored, walkable when built (no
  pathfinder block); registers with World.doors for Phase 7 open/close logic
- ALL wall/door scenes have y_sort_enabled=true on root; floors don't (always
  on ground plane)

Crate furniture (scenes/world/, Agent C — ~270 lines):
- class_name Crate extends StorageDestination (Phase 4's abstract base)
- CAPACITY=4 stacks; accepts() gates on _completed + _filter_accepts + room
- find_drop_position returns tile when room exists, (-1,-1) otherwise
- BUILD_TICKS=60; on_build_tick mirrors Wall's pattern
- _draw procedural brown crate body + slat lines + fill-level dots

World autoload extensions (Opus):
- build_queue: Array — Wall/Floor/Door/Crate ghost entities awaiting
  construction. ConstructionProvider iterates by .priority desc; Phase 6+
  prepends material-haul toils.
- doors: Array — completed doors for future open/close (Phase 7+)
- wall_layer / floor_layer / designation_layer refs exposed for entity code
- mark_wall_tile(tile, material) / mark_floor_tile(tile, material) —
  stamps data-only TileMap layer with material-encoded atlas coord
- stockpile_at_tile(tile) — finds StockpileZone OR Crate covering a tile;
  used by JobRunner._tick_deposit to route Crate deposits

JobRunner._tick_deposit refactor (Opus):
- After clearing the haul-dirty flag, looks up stockpile_at_tile(pawn.tile)
- If destination is a Crate (has_method('register_item')), calls
  dest.register_item(item) so the crate's _contents tracks the stack

World scene integration (Opus):
- y_sort_enabled=true on World root so all entity sprites sort correctly
- DesignationCtl, ConstructionProvider, Wall TileMap (data-only, visible=false)
- World._ready wires:
  * World.wall_layer / floor_layer / designation_layer
  * designation.bind(designation_layer, selection)
  * Register 5 work providers (construction=6 > chop=5 > mine=4 > haul=3 > rest=0)
  * EventBus.designation_added → _on_designation_added (spawns Wall/Floor entity)
- _seed_phase5_demo_buildings: pre-queues 14 wall designations forming a
  5×4 cabin outline at (45, 25) so pawns visibly construct walls without
  player-paint UI (deferred to Phase 17). Spawns 2 fully-built crates at
  (17-18, 60) for hauling routing.

Acceptance — MCP-verified end-to-end:
- 14 wall designations seeded at boot, 2 crates pre-built
- All 3 pawns picked construction (highest priority work) and walked to
  build sites (paths 37/32/27 from spawn). Walls built one by one.
- Wall layer post-construction has 42 cells: 28 (Phase 1 stone ring) +
  14 (Phase 5 cabin) — both rendering paths (placeholder TileMap from
  Phase 1, plus new entity sprites from Phase 5) coexist correctly.
- Pathfinder set_cell_walkable(false) fired on each wall completion.
- Pawns transitioned from construction to hauling once all walls done.
- Final visual: 5×4 stone-walled cabin with mortar lines, Y-sorted entity
  rendering, wood items scattered east of the cabin awaiting haul.

Phase 5 gotchas (logged):
- 'material' as a member var shadows CanvasItem.material (Node2D inherits
  it). Renamed to wall_material / floor_material via quick-edit agent.
  Save-format dict KEYS stay as 'material' for stability.
- Class-name registration cache lag bit again (Tree/Pawn pattern from
  earlier phases). Workflow stays: agent writes class_name file → MCP
  reload_project → godot --headless --editor --quit → headless validate.
- ConstructionProvider scans build_queue every tick including completed
  walls; is_buildable() filters them out but the queue keeps growing.
  Phase 16+ should add an unregister_build_site call from _complete or
  a periodic queue compaction.

Delegation report this phase:
- Agent A (Sonnet, gdscript-refactor): Designation paint mode + EventBus
  signals + Selection guard. ~180 lines.
- Agent B (Sonnet, gdscript-refactor): Toil.KIND_BUILD + JobRunner._tick_build
  + ConstructionProvider + Wall/Floor/Door entities + scenes. ~530 lines.
- Agent C (Sonnet, gdscript-refactor): Crate furniture extending
  StorageDestination. ~270 lines.
- quick-edit (Haiku): material → wall_material/floor_material rename. ~14
  occurrences across 2 files.
- Opus: World autoload extensions + JobRunner _tick_deposit refactor +
  World scene integration (DesignationCtl + ConstructionProvider + new
  scene preloads + _seed_phase5_demo_buildings) + MCP runtime verification
  + the material-shadow + class-cache-lag debugging.

Pivot decision worth flagging: the asset library audit revealed that no
pack we own ships top-down 47-tile autotile walls. After multiple
researcher-overpromise cycles, the pragmatic call was to pivot the
rendering model itself. Walls now render as bottom-anchored tall sprites
with Y-sort; the entire asset library becomes usable as-is. Phase 17
polish will swap procedural _draw() with AtlasTexture regions from
Pixel Crawler / FG_Houses / Ventilatore Castle_Building.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-10 22:11:40 +01:00

22 KiB
Raw Blame History

memory — rimlike

Durable memory for this project. Read at session start, update before session end. Date format: YYYY-MM-DD.

A 2D, tile-based cute-farming-RPG-meets-colony-sim — Rimworld DNA, Going Medieval × Stardew lodestars — shaped for mobile and handheld. Promoted from ~/claude/ideas/rimlike on 2026-05-10 after a single deep brainstorm session. Realistic MVP timeline: 3–6 months solo.

How to read this project

memory.md is the index of decisions and open questions. The deep specs live alongside in docs/:

File Contents
docs/design.md Game design — core loop, simplifications, skills, statuses, mood, weather, stockpiles, production, combat, death/burial, storyteller corpus
docs/architecture.md Tech — pawn AI / job system, time/tick model, Godot 4 engine layout, TileMap split, all subsystems (mood, lighting, rooms, hauling, production, combat, storyteller)
docs/ui.md Touch UX — work-priority matrix, stockpile/container screens, mood/lighting/rooms cues, combat banners, storyteller event UI, screens still to design
docs/art.md Owned assets (ElvGames bundle primary, Ventilatore secondary), license, autotile gotcha, audit list, candidates kept for record
docs/implementation.md Phased build plan — 21 phases (audit → P0 scaffold → … → P20 export). Checklists, acceptance demos, scope-cut levers, de-risking spikes. Track progress here.

When working on a feature, read memory.md first, then the relevant docs/ file(s). For "what do I build next?" check the Status row at the top of docs/implementation.md.

Decisions & rationale

Distilled from the brainstorm. Each lock has a "why" — change with deliberate intent.

Pillars

Decision Choice Why
View Top-down grid for gameplay (pathfinding, designation, floor) + 3/4-perspective rendering for vertical structures (walls, doors, furniture). Re-decided 2026-05-10 after exhausting the asset library: every wall pack we own is RPG-style perspective (Stardew / Going Medieval style), not Rimworld-style top-down. Pivoting the renderer (Y-sorted entity sprites for walls) makes the entire library usable as-is and replaces the "we need to author or commission" bottleneck. Gameplay grid + pathfinding stay identical; only the rendering of vertical structures shifts.
Wall layer rendering Walls are entity sprites (Sprite2D / Y-sorted Node2D), not TileMap cells. Wall TileMap layer (Layer 2) becomes data-only — used for pathfinding-impassable + room-detection BFS, but doesn't render. Same source as the view-style pivot above. Consequence: doors, crates, furniture all live as entities with Y-sort; floor and designation-paint still tile-based. Architecture.md TileMap-layer section needs an annotation.
Primary platforms iOS + Android touch, then Steam Deck / ROG Ally gamepad. Desktop falls out for free. Mobile is the hard constraint; Deck inherits.
Ambition itch.io + TestFlight release. Real artifact, small audience. Drives engine choice; no app-store polish-tax.
Engine Godot 4 (GDScript) 2D-first, free, exports everywhere we need, fast iteration.
Tile size / style 16×16 pixel art, cute-farming-RPG primary (ElvGames bundle), Ventilatore as medieval accent ElvGames "Ultimate Farming RPG" Humble bundle owned (~2.8 GB, 70+ packs). Tone: Stardew × Going Medieval × Rimworld.
Setting Medieval fantasy with cute palette Owned-art alignment + clearer scope (no electricity / hydroponics / energy weapons) + underexplored on mobile.
Run shape Open-ended sandbox, autosave, persistent world Player picks up where they left off.
Session length 5–15 min target Drives every UI and pacing choice.
Default speed Fast (5×), with auto-pause on event 1 in-game day ≈ 5 min real time. Solves the "watch a pawn walk for 60s" problem; 1× exists for combat / fine work.
Goal scaffolding Light storyteller prompts Soft, dismissible nudges give each short session shape without forcing scenarios.
Combat Realtime with auto-pause on threat Rimworld-feel; touch-friendly.
Health Single HP per pawn + status effects (Bleeding/Sick/Tired/Hungry/Wet/Cold/Downed/...) ~80% of the drama for ~5% of Rimworld's health-system code.
Scale 3–6 pawns, 80×80 MVP map (architecture sized to ~120² ceiling) Roughly Stardew-farm size; readable when zoomed in, doesn't fit a phone screen — forces the world-view camera (pinch / pan / jump-to-alert) rather than strategic-overview-on-phone.
Priority levels 5 (Critical / High / Normal / When idle / Off) Matches Rimworld + Going Medieval contract.
Failure state Ghost colony — no game over; storyteller drops wanderer in 3–5 days Mobile-friendly; preserves player investment.
Engine version Godot 4.6.2 stable (Win64 binary at D:\godot\Godot_v4.6.2-stable_win64.exe) Locked for reproducibility; pinned in project.godot features.
Renderer GL Compatibility (mobile + desktop), not Forward+ Max device reach; Forward+ would lock out older phones.
Repo location Physical: /mnt/d/godot/rimlike/ (D: drive, fast for Windows-side editor). Symlink: ~/claude/projects/rimlike → physical. Mirrors tavernkeep's pattern. Both WSL and Windows access without crossing the WSL net bridge.
Player walls Wood + stone via Pixel Crawler Walls.png (entity sprites, Y-sorted; no autotile in Phase 5). Single-sprite-per-material is the Phase 5 ship; per-direction variants are a polish item. After the rendering pivot to 3/4 perspective, the Pixel Crawler Walls.png pack becomes directly usable. It has 4 wood materials + a sandstone variant with clear corner/edge pieces. Phase 5 ships with one sprite per material (uniform-looking walls); Phase 17 can add per-direction variants if playtest reveals the visuals feel flat. Stardew-cabin warmth restored without authoring or commission.

Architecture (tech)

  • Sim tick 20 Hz, render 60 Hz, decoupled. Pawn positions lerp between sim ticks. (docs/architecture.md Time / tick model)
  • Pawn AI: 5-layer pipeline (Decision → WorkProvider → Job + JobRunner → Status interrupts → Player overrides). Slimmer than Rimworld's ThinkTree. ~800–1500 LOC GDScript for full MVP.
  • TileMap layers: 0 Terrain · 1 Floor · 2 Wall · 3 Designation · 4 Roof · 5 Fog. Furniture / Pawn / Item / EffectFX as scene-instanced entities (not TileMap).
  • Pathfinding: AStarGrid2D (built-in), updated on wall/door/furniture changes.
  • No background simulation — app backgrounded = sim paused. Avoids "lost colony to a raid while at work."
  • Save format: between sim ticks only; JobRunner mid-toil state round-trips from day one.

Game design

  • 5 skills (Manual Labor / Crafting / Cooking / Medicine / Combat), 0–10 each, level by use, multiplicative speed/quality bonus. Skills modify duration and quality, never permission.
  • 9 work categories (Construction / Mining / Hauling / Cleaning / Crafting / Cooking / Plant / Doctor / Combat). 5-level priority matrix per pawn.
  • Storage: floor zones AND independent crate furniture (4 stacks each), unified by StorageDestination interface. 16 filter chips (Wd/St/Ir/Cu/Ag/Au/Cl/Veg/Mt/Gr/Ck/Md/Tl/Wp/Ar/Co), 5 priorities with Rimworld flow semantics. One stack per tile, one type per tile.
  • Production: 2-step where medieval-sense (Iron→Ingot→Weapon, Grain→Flour→Bread); 1-step otherwise. 5 workbenches (Carpenter, Smelter, Smithy, Cooking hearth, Millstone), ~22 recipes. Full Rimworld bill semantics (one-shot count / forever / until-N + ingredient-quality filter + skill threshold).
  • Quality system (Shoddy/Normal/Excellent/Masterwork/Legendary) on every crafted item; multiplicative stat bonus. Quality from crafter skill + RNG only (inputs are just resources).
  • Mood: ~13 thoughts (data-driven registry, mix persistent + event-driven). Soft breaks at sustained mood < 25 for 30 in-game min — Sulking or Wandering, recover at mood ≥ 35.
  • Lighting (real shader at night), auto-detected rooms (named by furniture, scored for beauty + dirtiness), dirtiness + Cleaning (8th work category), beauty score with Quality multiplier.
  • Roofing: indoor = Layer-4 Roof flag, sim-data only (no rendering, just an indoor tint on floors). Auto-roof when walls enclose ≤8 cells (BFS); No-Roof designation for courtyards. Plants don't grow indoors.
  • Weather: 4 types (Clear / Rain / Storm / Cold snap), daily roll, season-weighted. Wet status accumulates outside in rain, decays indoors. 4 seasons × 12 days = 48-day year.
  • Combat: 3 weapons (sword/axe/bow), 3 armor slots (helm/cuirass/boots). Walls + trees provide cover. Two-roll resolution (hit, then damage with armor reduction). Downed-then-rescue death model; doctors auto-prioritize. Combat=Off "defends if cornered, won't volunteer." Friendly fire ON.
  • Death / corpses: Both burial AND cremation. Graveyard = special stockpile (Corpses-only); pawns dig graves, place permanent grave markers (tap → deceased pawn-detail). Cremation pyre = furniture with single recipe (1 corpse + 5 wood). Corpses decay 0–50 fresh / 50–100 rotting (no butcher) / 100 rotted.
  • Storyteller: 25 prompts written in docs/design.md. Daily 6am roll, weighted pool, per-category cooldowns, tension model alternates quiet/threat per Tynan Sylvester pacing. Ambient banner for low-stakes, modal auto-pause for choice events.

Touch UX

  • Bottom-sheet menus instead of right-side panels. Long-press = inspect/context. Tap world = select. Speed/pause buttons fixed top.
  • Work-priority matrix: 9 columns × N pawns, sticky pawn-name column, horizontal scroll on phone. Tap-to-cycle priority, long-press for 5-chip picker, swipe column for bulk-set. Per-pawn and per-job views layered on top.
  • Stockpile/container UI: 4×4 chip grid for the 16 filter categories; same UI for floor zones and crates.
  • Storyteller events: ambient banners for nudges/seasonal/lore; modal auto-pause for wanderer/threat/disease/milestone. Events log + "while you were away" digest at resume.
  • Indoor tint marks "this is inside" without needing roof rendering — matches Stardew/Rimworld convention.
  • World-view camera: pinch-zoom + drag-pan + double-tap-to-center; selected pawn does not force-follow. Storyteller alerts/banners include a Go there tap that pans the camera to the event tile. No minimap in MVP — revisit if playtest shows people getting lost on the 80² map.

Art strategy

  • ElvGames "Ultimate Farming RPG" Humble bundle is the primary art (/mnt/d/godot/assets/humble set new/, ~2.8 GB, 70+ packs, all 16×16, ElvGames license: commercial OK with credit).
  • Ventilatore Fantasy Tileset Complete Bundle stays as medieval accent for biome variety / decorative props / animated water.
  • Mana Seed series considered but dropped from buy plan (the bundle covers what we'd planned).
  • Authoring still required: designation overlays (~2 hrs custom), possibly autotile bits on bundle wall sheets, possibly wolf sprite, possibly grave marker.

Open questions / TODOs

Audit / unblock-the-prototype action items

Total ~75 min. 3 of 5 closed on 2026-05-10; see session log + docs/art.md for findings. Two open.

  • Aesthetic harmony test — needs your eye. ElvGames Forest tile vs Ventilatore tile, side-by-side. Decides whether Ventilatore stays as accent or gets shelved. ~15 min.
  • ElvGames autotile audit — done. FG_Fortress.png IS autotile-solvable (tan stone, ~20–30 modular pieces); FG_Houses.png is NOT (pre-built decorative house compositions, not modular wall variants). Iconic Homestead $19.99 fallback not needed. New decision required — see Open questions below.
  • Wolf sprite source — done. No wolf in the bundle anywhere. Need a custom commission, a CC0 sprite, or a Ventilatore find. New decision required — see Open questions below.
  • Grave marker source — done. Retro Graveyard 16x16 Tileset [Kingdom Explorer] confirmed in Tier 3, full graveyard suite. Direct use, no custom work.
  • License compilation — maintain credits string for every pack used (ElvGames + Ventilatore + Kingdom Explorer + any others). Display in game's credits screen. Confirm specific terms per pack before any commercial release.

Design topics still open

Resolved: wall material strategy. Lock = custom-author wood + stone walls (option b). Player builds wood-cabin walls from day one (corner/T/cap variants authored on top of FG_Houses.png wood-and-blue-roof material, ~½ day work) then upgrades to stone fortress walls later (FG_Fortress.png autotile-solvable as-is, ~few hours). Phase 5 slips ~3 days but the Stardew-cabin-warmth aesthetic survives, which was the original anchor. See docs/art.md Wall-material decision.

  • Wolf sprite acquisition (NEW from 2026-05-10 audit): bundle has nothing canine-predator; Ventilatore checked 2026-05-10, also nothing (Ventilatore is character + terrain + decoration; no animal/creature sprites at all besides player + slimes). Remaining options: (a) commission a 16×16 wolf (idle + 2–4-frame walk × 4 directions; ~$30–60 paid commission); (b) source a CC0 wolf from OpenGameArt; (c) reskin a bundle animal placeholder for MVP (e.g. recolor a dog from Animal Sprites Pixelart) and replace later. Phase 10 blocker — can defer until then; placeholder from option (c) unblocks the combat/AI work meanwhile.
  • Auto-roof big-room UX: the ≤8-cell BFS cap silently fails on rooms larger than 8×8. Decide whether to (a) keep the cap and surface "this area is too large to roof — split with an interior wall" hint when the player encloses one, (b) bump the cap to ~16 with the same hint at the new threshold, or (c) detect any enclosed area regardless of size. Affects EnclosureDetector + a new room-feedback UI.
  • Onboarding / first 60 seconds: mobile-specific. Don't copy Rimworld's tutorial.
  • Touch UI for non-priority screens: world view, build drawer, alerts, day-summary, pawn detail. See docs/ui.md "Screens still to design."
  • Background time / "while you were away" mechanic — locked to no background simulation in MVP; revisit if it feels bad in playtest.
  • Audio direction — who/where for SFX + ambient track? Bundle has 11 music + 8 SFX packs covering most needs.
  • Steam Deck input parity — gamepad-driven cursor, or full menu navigation by D-pad? Probably both.
  • Localization stance — English-only for MVP, but architect strings for i18n (already locked in CLAUDE.md).
  • Pawn name/backstory generation — hand-curated list vs simple generator.
  • Naming the game — "rimlike" is a working title.
  • Monetization stance — free? PWYW? Premium?
  • Tech / research progression — medieval tech tree shape.
  • Map / world generation — fixed seed for slice; procgen later.

Tunable in prototype (not real "open Qs", just numbers to playtest)

  • Sleep mood gradient values (+5/+0/−2/−5/−8)
  • Wet status thresholds (25 / 60) and accumulation rates
  • Season weather weights (Spring/Summer/Autumn/Winter distributions)
  • Hit-chance bonuses (skill ×5%, range ×5%, cover 40/20%)
  • Bleed-out timer (6 in-game hours)
  • Various mood thought magnitudes and decay times

Vertical slice (MVP target)

Same scope as locked in ~/claude/ideas/rimlike/plan.md. Realistic timeline 3–6 months solo for an MVP this rich.

  • 1 biome (temperate forest, ElvGames Forest Tileset 4 Seasons; Ventilatore foliage accents).
  • 1 map, 80×80 tiles, fixed seed for now.
  • 3 starting pawns ("settlers" / "villagers"), each with name + portrait + one-sentence backstory.
  • Verbs: chop wood, mine stone & ore, build walls/floors/furniture/crates, plant/harvest crops (3–4 types), cook meals (recipes), haul, repair, clean.
  • Needs: hunger, sleep, mood (~13 distinct thoughts, soft breaks at sustained mood < 25).
  • Status effects: Hungry, Tired, Bleeding, Sick, Downed, Wet (Damp/Soaked), Cold.
  • Storage: floor zones AND containers, 16 filter chips, 5 priorities.
  • Quality system on all crafted items.
  • Lighting — torches + hearths emit light; visual darkness at night.
  • Rooms — auto-detected, named by contents, beauty + dirtiness scored.
  • Cleaning as 8th work category.
  • Day/night cycle, ~5 min per day at default speed. Seasons (Spring/Summer/Autumn/Winter, 12 days each).
  • Weather: Clear / Rain / Storm / Cold snap.
  • One disaster type: wolves at night (bandit raids deferred).
  • One storyteller: random quiet/threat alternation, 25 prompt corpus.
  • Save/load, autosave on suspend, single slot.
  • Touch UI end-to-end (no desktop-only gestures).
  • Sound: minimal — UI clicks, ambient day/night loop, alert sting.

Session log

2026-05-10

  • Promoted from ~/claude/ideas/rimlike/ (single multi-hour brainstorm session).
  • Scaffolded projects/rimlike/ from _templates/project/. Customized CLAUDE.md. Distilled plan.md into this memory.md. Moved companion files (design / architecture / ui / art) into docs/. git init, first commit "Initial scaffold". Created Forgejo repo rimlike (private), set HTTPS remote, pushed main. Archived idea folder to ~/claude/archive/ideas/rimlike/.
  • Wired Godot MCP Pro: .mcp.json, .claude/settings.local.json allowlist, three project-local subagents (quick-edit, researcher, gdscript-refactor). Added the MCP-Pro and tiered-delegation sections to CLAUDE.md. Editor plugin / addons/godot_mcp/ re-copy still pending Godot project scaffold.
  • Reviewed docs/ against memory.md and CLAUDE.md. Decisions made:
    • Map size bumped from 40² → 80² for the MVP slice; architecture sized to ~120² ceiling. Pawn count stays at 3 start / 6 cap (frontier feel was rejected in favor of "split-the-difference" sizing — Stardew-farm scale, not Going-Medieval scale).
    • World-view camera = pinch-zoom + drag-pan + double-tap-to-center; storyteller alerts include a Go there tap. No minimap in MVP. No follow-cam (avoids fighting the player when issuing build orders across the map).
    • Storyteller cooldown semantics: per-event AND per-category, both gates must pass (resolves the design.md vs architecture.md disagreement).
    • MAX_STACKS_PER_THOUGHT = 5 (was named-but-unset).
    • Hauling-loop fallback: items that fail to find any valid destination after 3 retry passes drop on the floor and surface as a passive "No stockpile accepts X" alert.
  • Cleaned up doc rot in docs/design.md and docs/architecture.md — both had stale "8 work categories" intermediate sections still next to the canonical "9" lists. Removed the (8) snapshots.
  • Updated docs/architecture.md perf assumptions (60² → 80² with 120² ceiling).
  • docs/ui.md got a new World view camera (locked) section; removed the world-view bullet from "Screens still to design".
  • Open: auto-roof big-room UX (added to TODOs above) — the ≤8-cell BFS cap silently fails on bigger rooms; player feedback path needs a decision before EnclosureDetector lands.
  • Wrote docs/implementation.md — 21-phase build plan with checkboxes, acceptance demos, scope-cut levers, and de-risking spikes. Status row at the top of that file is the canonical "where are we now" pointer.
  • Project location moved from /home/megaproxy/claude/projects/rimlike/ to /mnt/d/godot/rimlike/ (D: drive). Symlink at the original WSL path preserves the home-CLAUDE.md layout convention. Set git config core.filemode false to silence DrvFs's everything-is-0777 false-positive. Mirrors tavernkeep's pattern; both WSL and Windows access without crossing the WSL net bridge.
  • Phase 0 scaffold landed. project.godot + 7 autoloads + smoke-test scene + addons re-copy + folder layout. Used GL Compatibility renderer (not Forward+) for max mobile reach. Folder layout matches tavernkeep (autoload/ at root, scripts co-located in scenes/) — not the scripts/autoloads/ mirror layout originally sketched in implementation.md. Headless verification: godot --headless --path . --quit exits 0 with the smoke-test message. Editor-side green-dot check pending — needs you to open the editor once.
  • Asset audit ran via researcher subagent (Haiku). 3 of 5 items closed. Findings:
    • FG_Fortress.png autotile-solvable (tan stone). FG_Houses.png NOT autotile-solvable (pre-built decorative compositions). Iconic Homestead fallback not needed. Opens a new wall-material decision (see Open questions).
    • No wolf sprite anywhere in the bundle. Opens a wolf-acquisition decision (see Open questions).
    • Retro Graveyard 16x16 Tileset [Kingdom Explorer] confirmed in Tier 3 — full graveyard suite, ready for direct use in Phase 14.

External references

  • Forgejo repo: https://git.rdx4.com/megaproxy/rimlike (private)
  • Owned art bundle (primary): ElvGames "Ultimate Farming RPG" Humble bundle, local at /mnt/d/godot/assets/humble set new/. License: ElvGames terms (https://elv-games.itch.io/terms). Commercial OK with credit; no NFT/crypto/resale.
  • Owned art bundle (secondary): Ventilatore Fantasy Tileset Complete Bundle — https://itch.io/s/117124/the-fantasy-tileset-complete-bundle
  • Mana Seed catalog (fallback if bundle gaps surface): https://seliel-the-shaper.itch.io/
  • Iconic Homestead (autotile-ready wall fallback, $19.99): https://seliel-the-shaper.itch.io/iconic-homestead
  • Lodestars: Rimworld (Tynan Sylvester / Ludeon Studios), Going Medieval (Foxy Voxel), Stardew Valley (ConcernedApe).
  • Original brainstorm history: archived to ~/claude/archive/ideas/rimlike/ after promotion. The session log there captures every decision's rationale.
  • Brainstorming-mode preference: see ~/.claude/projects/-home-megaproxy-claude-ideas/memory/brainstorm-ask-dont-decide.md (not directly applicable to projects but captures interaction style).