megaproxy
61dcf6760b
Three gdscript-refactor agents in parallel; Opus integrated and tuned
the priority + hunger-decay numbers via MCP runtime observation.
Crop entity + PlantProvider (Agent A, scenes/entities/crop.{gd,tscn} +
scenes/ai/plant_provider.gd, ~225 lines):
- Crop: 6-stage state machine (TILLED → SOWN → GROWING_1/2/3 → READY).
STAGE_TICKS=200 sim ticks per stage × 4 stages = 800 total to maturity.
Listens to EventBus.sim_tick for growth. Procedural _draw with growing
plant + ready-state golden grain accent.
- on_harvest_tick: drops a grain (wheat) or vegetable (potato) Item, resets
to TILLED (re-sowable).
- on_sow_tick: TILLED → SOWN — used when Phase 17 paint UI lands.
- PlantProvider priority=5 (above crafting=4) — harvest-only for Phase 7.
Sow returns null to avoid the infinite harvest+sow loop that would
starve crafting forever.
- JobRunner._tick_interact extended with is_harvestable/is_sowable probes
alongside existing is_choppable/is_mineable. Unified probe array.
Hunger + Eating (Agent B, scenes/pawn/pawn.gd + scenes/ai/eat_provider.gd +
toil.gd/job_runner.gd extensions, ~150 lines):
- Pawn.hunger: float 0..100. HUNGER_DECAY_PER_TICK=0.02 (tuned down 5×
from agent's 0.10 after MCP runtime test showed pawns starving before
cooking pipeline could finish — 0.02 means 100→0 in 5000 ticks =
~4 min at 1× / ~20s at Ultra).
- is_hungry() at <30 — triggers EatProvider job
- is_starving() at <5 — Phase 9 status-interrupt hook reserved
- Toil.KIND_EAT + JobRunner._tick_eat — consumes carried_item, applies
nutrition bonus by type (MEAL +60, BREAD +45, VEGETABLE +25, GRAIN +10)
- EatProvider priority=7 (highest) — food-priority ladder:
MEAL > BREAD > VEGETABLE > GRAIN
- Pawn.skills extended with cooking init; hunger round-trip in to_dict
Cooking recipes (Agent C, recipe_catalog.gd + item.gd + workbench.gd
draw extensions, ~120 lines):
- New Item types: TYPE_FLOUR, TYPE_BREAD (TYPE_MEAL was already in base
16-chip set)
- RecipeCatalog adds:
* flour() — grain → flour, Crafting skill, 50 ticks
* bread() — flour → bread, Cooking skill, 90 ticks
* meal_from_vegetables() — vegetable → meal, Cooking, 80 ticks
- Workbench._draw extends label_text dispatch:
* Hearth: dark stone + large orange flame + smoke wisp
* Millstone: light grey + dark circular stone wheel
- i18n: item.flour, item.bread, item.meal, workbench.hearth, workbench.millstone
Opus integration:
- world.tscn: PlantProvider + EatProvider nodes (8 providers total)
- world.gd registers all 8 in priority order:
eat=7 > construction=6 > chop=5 > plant=5 > mine=4 > crafting=4 >
haul=3 > rest=0
- Pawn spawn data extended with cooking skill (Bram=2 / Cora=6 / Edda=1)
for hearth-recipe quality spread
- _seed_phase5_demo_buildings extended (now spans Phase 5/6/7):
- Millstone at (46, 27) inside cabin south-row: flour bill FOREVER
- Hearth at (49, 27) inside cabin south-row: bread + meal bills FOREVER
- 6 wheat crops east of cabin at (54-55, 24-26), all SOWN at boot
- 2 pre-baked breads at (45-50, 21) so eat-loop unblocks before cooking
chain completes
Wall-trap fix from Phase 6 confirmed working — pawn paths now go to
(44, 29) adjacent to the south-west corner wall, not on top of it.
Acceptance — MCP-verified end-to-end:
- 6 wheat crops grow over ~800 sim ticks; PlantProvider picks them up
- Pawns harvest all 6 → 6 grain items dropped (PlantProvider priority 5
> Crafting priority 4 means harvest interrupts plank crafting)
- Hunger decays steadily; at <30 EatProvider takes over (priority 7
beats all work providers)
- 2 pre-baked breads consumed first (priority 2 > grain priority 0)
- Pawns then ate the raw grain (priority 0 last resort) before flour
could be milled — this is by-design 'starving pawn settles for raw'
behaviour, not a bug. Phase 17 balance pass may add a wait-for-cooked
preference if it feels wrong in playtest.
- Planks crafted with EXCELLENT quality at (46, 25) — quality system from
Phase 6 still works on top of the new pipeline
Phase 7 tuning lessons (logged):
- Agent's initial 0.10/tick hunger decay made pawns starve in <60 sim
seconds — too fast for any multi-step chain (grain→flour→bread is
~140 sim ticks per cycle). Tuned to 0.02/tick post-runtime.
- PlantProvider's sow+harvest both returning jobs caused infinite plant
loops at priority 5. Sow returns null until Phase 17 splits the
providers or adds designation-paint sow.
- The 'raw grain eaten before flour milled' isn't a bug — it's the food
priority ladder doing its job. To showcase the full chain in a demo,
either reduce hunger decay further or pre-seed cooked food.
Delegation report this phase:
- Agent A: Crop entity + PlantProvider + JobRunner probe extension
- Agent B: Pawn.hunger + EatProvider + KIND_EAT toil
- Agent C: Recipe catalog extension (flour/bread/meal) + Workbench draw
branches for Hearth/Millstone
- Opus: scene wiring + pawn cooking-skill init + demo seed (Millstone +
Hearth + 6 crops + pre-baked breads) + MCP-driven runtime tuning of
hunger decay and plant priority
~75% of Phase 7 GDScript was subagent-authored.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
356 lines
14 KiB
GDScript
356 lines
14 KiB
GDScript
class_name Workbench extends Node2D
|
||
## Workbench entity — buildable structure where pawns craft items per bills.
|
||
##
|
||
## Rendered as a bottom-anchored sprite (Y-sorted) matching the 3/4-perspective
|
||
## convention from Wall/Door. Ghost state (40% alpha) while construction is
|
||
## in progress; solid once _completed.
|
||
##
|
||
## Variant appearance is driven by label_text:
|
||
## "Carpenter" → warm-brown wood bench with a vise detail
|
||
## "Smelter" → dark grey stone block with an orange ember glow
|
||
## Other → generic warm-grey fallback
|
||
##
|
||
## Bill model (architecture.md "Production: workbenches, recipes, bills"):
|
||
## bills[] — ordered queue of Bill objects (untyped; Bill class
|
||
## is authored by a sibling agent and may not be
|
||
## registered when this file compiles).
|
||
## current_bill — the Bill actively being worked; null when idle.
|
||
## current_work_progress — tick counter within the current craft cycle.
|
||
## JobRunner._tick_craft increments this each sim tick.
|
||
## Workbench resets it to 0 on cycle completion or
|
||
## when the pawn leaves mid-craft.
|
||
##
|
||
## Save/load: to_dict / from_dict capture all persistent fields, including
|
||
## each bill via bill.to_dict(). Mirrors the Crate save pattern.
|
||
##
|
||
## World registration: World.register_workbench / World.unregister_workbench
|
||
## are called from _ready / _exit_tree.
|
||
|
||
const TILE_SIZE_PX: int = 16
|
||
|
||
## Sim ticks to build a workbench (90 ticks ≈ 4.5 sim seconds at 1×).
|
||
const BUILD_TICKS: int = 90
|
||
|
||
# ── exports ───────────────────────────────────────────────────────────────────
|
||
|
||
## Tile position of this workbench in world-tile coordinates.
|
||
@export var tile: Vector2i = Vector2i.ZERO
|
||
|
||
## Player-visible label. Also drives the _draw() variant.
|
||
## Recognised values: "Carpenter", "Smelter", "Hearth", "Millstone". Others render generic.
|
||
@export var label_text: String = "Workbench"
|
||
|
||
## Which skill category this bench accepts.
|
||
## CraftingProvider filters by this before assigning a pawn.
|
||
@export var accepted_skill: StringName = &"crafting"
|
||
|
||
# ── state ─────────────────────────────────────────────────────────────────────
|
||
|
||
## Ticks of construction work applied so far. 0..BUILD_TICKS.
|
||
var build_progress: int = 0
|
||
|
||
## True once build_progress >= BUILD_TICKS.
|
||
var _completed: bool = false
|
||
|
||
## Ordered queue of Bill objects. Untyped so this file compiles before the
|
||
## Bill class is registered by the sibling agent. CraftingProvider reads this.
|
||
var bills: Array = []
|
||
|
||
## The Bill being actively worked right now. null when idle.
|
||
## Set by JobRunner when it begins a craft toil; cleared on completion or
|
||
## when the pawn walks away (job cancelled / interrupted).
|
||
var current_bill = null
|
||
|
||
## Sim-tick progress within the current craft cycle. Incremented by
|
||
## JobRunner._tick_craft once per sim tick. Reset to 0:
|
||
## - when a craft completes (on_craft_complete)
|
||
## - when no pawn is actively crafting (JobRunner cancel / pawn interruption)
|
||
## JobRunner reads this to decide whether the recipe's work_ticks are done.
|
||
var current_work_progress: int = 0
|
||
|
||
|
||
# ── lifecycle ─────────────────────────────────────────────────────────────────
|
||
|
||
func _ready() -> void:
|
||
# Position is bottom-anchored so Y-sort occludes pawns correctly.
|
||
position = Vector2(
|
||
tile.x * TILE_SIZE_PX + TILE_SIZE_PX / 2.0,
|
||
tile.y * TILE_SIZE_PX + TILE_SIZE_PX
|
||
)
|
||
World.register_workbench(self)
|
||
queue_redraw()
|
||
|
||
|
||
func _exit_tree() -> void:
|
||
World.unregister_workbench(self)
|
||
|
||
|
||
## One-shot initialiser. Call after add_child() so _ready() has fired.
|
||
func setup(p_tile: Vector2i) -> void:
|
||
tile = p_tile
|
||
position = Vector2(
|
||
tile.x * TILE_SIZE_PX + TILE_SIZE_PX / 2.0,
|
||
tile.y * TILE_SIZE_PX + TILE_SIZE_PX
|
||
)
|
||
queue_redraw()
|
||
|
||
|
||
# ── BuildJob interface ────────────────────────────────────────────────────────
|
||
|
||
## True while the workbench still needs construction work.
|
||
## JobRunner's BUILD toil checks this to decide when the toil is done.
|
||
func is_buildable() -> bool:
|
||
return not _completed
|
||
|
||
|
||
## Human-readable label for job descriptions and Audit logs.
|
||
func label() -> String:
|
||
return label_text
|
||
|
||
|
||
## Called by the BUILD toil in JobRunner once per sim tick.
|
||
## Advances build_progress; completes the workbench at BUILD_TICKS.
|
||
func on_build_tick() -> void:
|
||
if _completed:
|
||
return
|
||
build_progress += 1
|
||
queue_redraw()
|
||
if build_progress >= BUILD_TICKS:
|
||
_complete()
|
||
|
||
|
||
## True once the workbench has been fully built.
|
||
func is_completed() -> bool:
|
||
return _completed
|
||
|
||
|
||
# ── Bills ─────────────────────────────────────────────────────────────────────
|
||
|
||
## Append a bill to the queue.
|
||
func add_bill(b) -> void:
|
||
bills.append(b)
|
||
Audit.log("workbench", "%s: bill added — recipe '%s'" % [label_text, b.recipe.id])
|
||
|
||
|
||
## Return the first bill that is active and whose required_skill matches
|
||
## this bench's accepted_skill. Returns null when none qualify.
|
||
## CraftingProvider calls this; JobRunner also calls it when the current_bill
|
||
## becomes inactive (UNTIL_N threshold reached, paused, etc.).
|
||
func find_active_bill():
|
||
for b in bills:
|
||
if not b.is_active():
|
||
continue
|
||
if b.recipe.required_skill != accepted_skill:
|
||
continue
|
||
return b
|
||
return null
|
||
|
||
|
||
# ── Craft-cycle hooks (called by JobRunner) ───────────────────────────────────
|
||
|
||
## JobRunner calls this when it starts working a bill on this bench.
|
||
## Stores the active bill and resets the tick counter.
|
||
func begin_craft(b) -> void:
|
||
current_bill = b
|
||
current_work_progress = 0
|
||
|
||
|
||
## JobRunner calls this once per sim tick while a pawn is actively crafting.
|
||
## Returns true when the recipe's work_ticks have been reached (craft done).
|
||
func tick_craft() -> bool:
|
||
if current_bill == null:
|
||
return false
|
||
current_work_progress += 1
|
||
return current_work_progress >= current_bill.recipe.work_ticks
|
||
|
||
|
||
## JobRunner calls this on craft completion before spawning the output item.
|
||
## Records the completion on the bill, resets state.
|
||
func on_craft_complete() -> void:
|
||
if current_bill != null:
|
||
current_bill.record_completion()
|
||
current_bill = null
|
||
current_work_progress = 0
|
||
|
||
|
||
## JobRunner calls this when the craft is interrupted (pawn leaves, cancel, etc.).
|
||
## Resets in-progress state so another pawn can start fresh.
|
||
func on_craft_interrupted() -> void:
|
||
current_bill = null
|
||
current_work_progress = 0
|
||
|
||
|
||
# ── save / load ───────────────────────────────────────────────────────────────
|
||
|
||
## Serialise workbench state for World save (wired in Phase 16).
|
||
func to_dict() -> Dictionary:
|
||
var bills_data: Array = []
|
||
for b in bills:
|
||
bills_data.append(b.to_dict())
|
||
return {
|
||
"tile_x": tile.x,
|
||
"tile_y": tile.y,
|
||
"label_text": label_text,
|
||
"accepted_skill": String(accepted_skill),
|
||
"build_progress": build_progress,
|
||
"completed": _completed,
|
||
"current_work_progress": current_work_progress,
|
||
"bills": bills_data,
|
||
}
|
||
|
||
|
||
## Restore from a dict produced by to_dict().
|
||
## Bill objects are reconstructed by the caller using Bill.from_dict() once the
|
||
## Bill class is registered. current_bill is left null — JobRunner reconnects
|
||
## from its own saved state on the next sim tick.
|
||
func from_dict(d: Dictionary) -> void:
|
||
tile = Vector2i(int(d.get("tile_x", 0)), int(d.get("tile_y", 0)))
|
||
label_text = str(d.get("label_text", "Workbench"))
|
||
accepted_skill = StringName(d.get("accepted_skill", "crafting"))
|
||
build_progress = int(d.get("build_progress", 0))
|
||
_completed = bool(d.get("completed", false))
|
||
current_work_progress = int(d.get("current_work_progress", 0))
|
||
# Bills are re-populated by World.load_workbenches() after Bill class loads.
|
||
# Raw dicts are kept in the dict; the caller handles reconstruction.
|
||
setup(tile)
|
||
|
||
|
||
# ── render ─────────────────────────────────────────────────────────────────────
|
||
|
||
func _draw() -> void:
|
||
# 3/4-perspective bench rendering — fits within the tile (16×16 local box).
|
||
# Origin (0,0) = tile bottom-centre. Tile spans local Y: -16 to 0.
|
||
# Two-band look (matches Wall): lit top band + shaded front face.
|
||
# Ghost (not yet built) draws at 0.4 alpha.
|
||
var alpha: float = 1.0 if _completed else 0.4
|
||
|
||
match label_text:
|
||
"Carpenter":
|
||
_draw_carpenter(alpha)
|
||
"Smelter":
|
||
_draw_smelter(alpha)
|
||
"Hearth":
|
||
_draw_hearth(alpha)
|
||
"Millstone":
|
||
_draw_millstone(alpha)
|
||
_:
|
||
_draw_generic(alpha)
|
||
|
||
|
||
func _draw_carpenter(alpha: float) -> void:
|
||
# Warm-brown wood bench. Top band lit, front face darker.
|
||
# Vise/saw detail: a small darker square at the top-right corner of the
|
||
# front face to suggest a mounted tool.
|
||
var top_face := Color(0.62, 0.45, 0.25, alpha)
|
||
var front_face := Color(0.52, 0.36, 0.18, alpha)
|
||
var plank := Color(0.34, 0.22, 0.10, alpha)
|
||
var vise := Color(0.28, 0.18, 0.08, alpha)
|
||
var outline := Color(0.20, 0.12, 0.04, 0.7 * alpha)
|
||
|
||
# Top face — lit strip at upper-third of tile.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
|
||
# Front face — lower body.
|
||
draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
|
||
# Horizontal plank seam across the front face.
|
||
draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), plank, 1.0)
|
||
# Vise detail: 4×4 px darker square at top-right of front face.
|
||
draw_rect(Rect2(Vector2(3.0, -11.0), Vector2(4.0, 4.0)), vise)
|
||
# Top/front edge horizon line.
|
||
draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), plank, 1.0)
|
||
# Tile outline.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
|
||
|
||
|
||
func _draw_smelter(alpha: float) -> void:
|
||
# Dark grey stone block. Top band slightly lighter.
|
||
# Ember glow: orange rect centred at the bottom of the front face.
|
||
var top_face := Color(0.42, 0.42, 0.40, alpha)
|
||
var front_face := Color(0.32, 0.32, 0.30, alpha)
|
||
var mortar := Color(0.20, 0.20, 0.18, alpha)
|
||
var ember := Color(0.95, 0.45, 0.10, alpha)
|
||
var outline := Color(0.14, 0.14, 0.12, 0.7 * alpha)
|
||
|
||
# Top face.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
|
||
# Front face.
|
||
draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
|
||
# Mortar line.
|
||
draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), mortar, 1.0)
|
||
# Ember glow: 6×3 px orange rect, horizontally centred, at bottom of front face.
|
||
draw_rect(Rect2(Vector2(-3.0, -3.0), Vector2(6.0, 3.0)), ember)
|
||
# Top/front edge horizon line.
|
||
draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), mortar, 1.0)
|
||
# Tile outline.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
|
||
|
||
|
||
func _draw_hearth(alpha: float) -> void:
|
||
# Dark grey stone block with a large orange flame at centre of front face and
|
||
# a thin smoke wisp poking above the top face. Visually heavier than the
|
||
# Smelter (which has a small ember) to signal open-fire cooking.
|
||
var top_face := Color(0.35, 0.30, 0.25, alpha)
|
||
var front_face := Color(0.28, 0.24, 0.20, alpha)
|
||
var mortar := Color(0.18, 0.14, 0.12, alpha)
|
||
var flame := Color(0.95, 0.55, 0.10, alpha)
|
||
var smoke := Color(0.72, 0.70, 0.68, alpha * 0.6)
|
||
var outline := Color(0.14, 0.10, 0.08, 0.7 * alpha)
|
||
|
||
# Top face.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
|
||
# Front face.
|
||
draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
|
||
# Mortar seam.
|
||
draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), mortar, 1.0)
|
||
# Flame: 6×4 px orange rect, horizontally centred in the front face.
|
||
draw_rect(Rect2(Vector2(-3.0, -8.0), Vector2(6.0, 4.0)), flame)
|
||
# Smoke wisp: 1×2 px vertical light-grey rect rising above the top face.
|
||
draw_rect(Rect2(Vector2(-0.5, -18.0), Vector2(1.0, 2.0)), smoke)
|
||
# Top/front edge horizon line.
|
||
draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), mortar, 1.0)
|
||
# Tile outline.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
|
||
|
||
|
||
func _draw_millstone(alpha: float) -> void:
|
||
# Very light grey stone block with a circular dark-grey stone wheel inset
|
||
# at the centre of the front face. Suggests a grinding wheel.
|
||
var top_face := Color(0.78, 0.78, 0.72, alpha)
|
||
var front_face := Color(0.65, 0.65, 0.60, alpha)
|
||
var seam := Color(0.45, 0.45, 0.42, alpha)
|
||
var wheel := Color(0.40, 0.40, 0.36, alpha)
|
||
var outline := Color(0.28, 0.28, 0.26, 0.7 * alpha)
|
||
|
||
# Top face.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
|
||
# Front face.
|
||
draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
|
||
# Seam.
|
||
draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), seam, 1.0)
|
||
# Stone wheel: filled circle radius 5 px, centred on the front face.
|
||
draw_circle(Vector2(0.0, -5.5), 5.0, wheel)
|
||
# Top/front edge horizon line.
|
||
draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), seam, 1.0)
|
||
# Tile outline.
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
|
||
|
||
|
||
func _draw_generic(alpha: float) -> void:
|
||
# Warm-grey fallback bench. Simple two-band block with a single seam.
|
||
var top_face := Color(0.58, 0.55, 0.50, alpha)
|
||
var front_face := Color(0.42, 0.40, 0.36, alpha)
|
||
var seam := Color(0.30, 0.28, 0.25, alpha)
|
||
var outline := Color(0.20, 0.18, 0.16, 0.7 * alpha)
|
||
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 5.0)), top_face)
|
||
draw_rect(Rect2(Vector2(-8.0, -11.0), Vector2(16.0, 11.0)), front_face)
|
||
draw_line(Vector2(-8.0, -6.0), Vector2(8.0, -6.0), seam, 1.0)
|
||
draw_line(Vector2(-8.0, -11.0), Vector2(8.0, -11.0), seam, 1.0)
|
||
draw_rect(Rect2(Vector2(-8.0, -16.0), Vector2(16.0, 16.0)), outline, false, 1.0)
|
||
|
||
|
||
# ── internal ──────────────────────────────────────────────────────────────────
|
||
|
||
func _complete() -> void:
|
||
_completed = true
|
||
queue_redraw()
|
||
Audit.log("workbench", "%s built at %s" % [label_text, tile])
|