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>
84 lines
3 KiB
GDScript
84 lines
3 KiB
GDScript
class_name RecipeCatalog
|
||
## Static registry of all recipes. Each method returns a fresh Recipe instance
|
||
## configured for that product. Extend here as new workbenches land.
|
||
##
|
||
## Phase 6 — two recipes:
|
||
## plank() — wood → plank (Carpenter's bench, Crafting)
|
||
## stone_block() — stone → stone_block (Smelter, Crafting)
|
||
##
|
||
## Phase 7 — cooking chain (grain → flour → bread, vegetable → meal):
|
||
## flour() — grain → flour (Millstone, Crafting)
|
||
## bread() — flour → bread (Hearth, Cooking)
|
||
## meal_from_vegetables() — vegetable → meal (Hearth, Cooking)
|
||
##
|
||
## The full ~22-recipe list per docs/design.md continues in Phase 8+.
|
||
|
||
|
||
static func plank() -> Recipe:
|
||
var r := Recipe.new()
|
||
r.id = &"plank"
|
||
r.label = "Wood plank"
|
||
r.ingredient_type = Item.TYPE_WOOD
|
||
r.output_type = Item.TYPE_PLANK
|
||
r.work_ticks = 60 # ~3 sim seconds at 1× (20 Hz × 3 s = 60 ticks)
|
||
r.required_skill = Recipe.SKILL_CRAFTING
|
||
r.skill_threshold = 0
|
||
return r
|
||
|
||
|
||
static func stone_block() -> Recipe:
|
||
var r := Recipe.new()
|
||
r.id = &"stone_block"
|
||
r.label = "Stone block"
|
||
r.ingredient_type = Item.TYPE_STONE
|
||
r.output_type = Item.TYPE_STONE_BLOCK
|
||
r.work_ticks = 80 # ~4 sim seconds at 1×
|
||
r.required_skill = Recipe.SKILL_CRAFTING
|
||
r.skill_threshold = 0
|
||
return r
|
||
|
||
|
||
# ── Phase 7 — cooking chain ───────────────────────────────────────────────────
|
||
|
||
static func flour() -> Recipe:
|
||
## Step 1 of the grain→flour→bread chain.
|
||
## Ingredient: grain. Output: flour. Worked at the Millstone (accepted_skill = crafting).
|
||
## Any crafter can do this — no culinary expertise required for grinding.
|
||
var r := Recipe.new()
|
||
r.id = &"flour"
|
||
r.label = "Flour"
|
||
r.ingredient_type = Item.TYPE_GRAIN
|
||
r.output_type = Item.TYPE_FLOUR
|
||
r.work_ticks = 50 # ~2.5 sim seconds at 1× — quick grinding pass
|
||
r.required_skill = Recipe.SKILL_CRAFTING
|
||
r.skill_threshold = 0
|
||
return r
|
||
|
||
|
||
static func bread() -> Recipe:
|
||
## Step 2 of the grain→flour→bread chain.
|
||
## Ingredient: flour. Output: bread. Worked at the Hearth (accepted_skill = cooking).
|
||
var r := Recipe.new()
|
||
r.id = &"bread"
|
||
r.label = "Bread"
|
||
r.ingredient_type = Item.TYPE_FLOUR
|
||
r.output_type = Item.TYPE_BREAD
|
||
r.work_ticks = 90 # ~4.5 sim seconds at 1× — baking takes longer
|
||
r.required_skill = Recipe.SKILL_COOKING
|
||
r.skill_threshold = 0
|
||
return r
|
||
|
||
|
||
static func meal_from_vegetables() -> Recipe:
|
||
## Single-step cooking: vegetable → meal. Worked at the Hearth (accepted_skill = cooking).
|
||
## Parallel path so harvested produce (potatoes, etc.) can reach the belly
|
||
## without going through the grain chain.
|
||
var r := Recipe.new()
|
||
r.id = &"meal_veg"
|
||
r.label = "Veggie meal"
|
||
r.ingredient_type = Item.TYPE_VEGETABLE
|
||
r.output_type = Item.TYPE_MEAL
|
||
r.work_ticks = 80 # ~4 sim seconds at 1×
|
||
r.required_skill = Recipe.SKILL_COOKING
|
||
r.skill_threshold = 0
|
||
return r
|