megaproxy
413054157a
Wheat + corn both produce TYPE_GRAIN; potato + strawberry both produce TYPE_VEGETABLE. Until now they rendered identically (yellow stalks for both grains, green-leafed root for both vegetables) since shape was driven by item_type alone. Added an Item.subtype field that carries the origin crop_kind through harvest. draw_item_shape dispatches on subtype FIRST then falls back to item_type — so storage filters (which match on item_type) still treat wheat+corn as one Grain category and potato+strawberry as one Vegetable category, but the visuals are now distinct. New procedural shapes: - wheat: 3 yellow stalks with grain-heads (same as existing grain) - corn: yellow cob with kernel dots wrapped in green husk leaves - potato: 2 brown overlapping lumps with sprout-eye dots - strawberry: red heart-shape body with green calyx + yellow seeds Crop.on_harvest_tick assigns subtype = crop_kind on spawn. SaveSystem._spawn_item now round-trips subtype through saves. Pawn carry indicator + Item._draw both pass subtype to draw_item_shape.
261 lines
9.9 KiB
GDScript
261 lines
9.9 KiB
GDScript
class_name Crop extends Node2D
|
||
## Crop entity — a farm plant tile that grows through stages and is harvested by a pawn.
|
||
##
|
||
## Growth model (docs/implementation.md Phase 7):
|
||
## SOWN → GROWING_1 → GROWING_2 → GROWING_3 → READY, each stage taking STAGE_TICKS sim ticks.
|
||
## At 20 Hz, 200 ticks ≈ 10 sim seconds ≈ 2 in-game minutes at Fast speed.
|
||
## "No growth indoors" rule (docs/design.md) lands in Phase 13 when the Roof flag
|
||
## system is fully wired; for now crops always grow.
|
||
##
|
||
## A PlantProvider creates a Job whose INTERACT toil calls on_harvest_tick() or
|
||
## on_sow_tick() once per sim tick via JobRunner. Both are single-tick completions.
|
||
## The INTERACT toil finishes when is_harvestable() / is_sowable() returns false.
|
||
##
|
||
## World registration (World.register_crop / World.unregister_crop) is called here.
|
||
|
||
const TILE_SIZE_PX: int = 16
|
||
|
||
## Available crop kinds. Each maps to an ElvGames 64×32 sprite sheet
|
||
## (4 stages × 16w × 32h, plant anchored to bottom row).
|
||
const KIND_WHEAT: StringName = &"wheat"
|
||
const KIND_POTATO: StringName = &"potato"
|
||
const KIND_CORN: StringName = &"corn"
|
||
const KIND_STRAWBERRY: StringName = &"strawberry"
|
||
|
||
## Sim ticks per growth stage. 200 ticks × 4 stages = 800 total.
|
||
## At 20 Hz × 5× speed = 100 ticks/sec → 8 real seconds per stage, 32 seconds full grow.
|
||
const STAGE_TICKS: int = 200
|
||
const STAGE_COUNT: int = 4
|
||
|
||
enum Stage { TILLED, SOWN, GROWING_1, GROWING_2, GROWING_3, READY }
|
||
|
||
## Per-kind sprite atlas. Strawberry / Corn are 80×32 (5 stages) — we still slice
|
||
## the first 4 cols, which gives the same progression (the 5th col is a
|
||
## post-harvest regrow frame we don't use).
|
||
const _CROP_TEXTURES: Dictionary = {
|
||
KIND_WHEAT: preload("res://art/sprites/crops/FG_Crops_Wheat.png"),
|
||
KIND_POTATO: preload("res://art/sprites/crops/FG_Crops_Potato.png"),
|
||
KIND_CORN: preload("res://art/sprites/crops/FG_Crops_Corns.png"),
|
||
KIND_STRAWBERRY: preload("res://art/sprites/crops/FG_Crops_Strawberry.png"),
|
||
}
|
||
|
||
## Width / height of one stage cell in pixels.
|
||
const _STAGE_W: int = 16
|
||
const _STAGE_H: int = 32
|
||
|
||
@export var crop_kind: StringName = KIND_WHEAT
|
||
@export var tile: Vector2i = Vector2i.ZERO
|
||
|
||
var stage: Stage = Stage.SOWN
|
||
## Progress within the current growth stage; 0..STAGE_TICKS.
|
||
var stage_progress: int = 0
|
||
|
||
# Phase 13 — "no growth indoors" rule. True once we've logged the first
|
||
# indoor detection for this crop instance so we don't flood the audit log.
|
||
var _logged_indoor: bool = false
|
||
|
||
# Child Sprite2D — created in _ready, region_rect updated whenever stage flips.
|
||
var _sprite: Sprite2D = null
|
||
|
||
const ITEM_SCENE: PackedScene = preload("res://scenes/entities/item.tscn")
|
||
|
||
|
||
# ── lifecycle ─────────────────────────────────────────────────────────────────
|
||
|
||
func _ready() -> void:
|
||
position = _tile_to_world(tile)
|
||
_build_sprite()
|
||
World.register_crop(self)
|
||
EventBus.sim_tick.connect(_on_sim_tick)
|
||
queue_redraw()
|
||
|
||
|
||
func _exit_tree() -> void:
|
||
World.unregister_crop(self)
|
||
|
||
|
||
# ── public API ────────────────────────────────────────────────────────────────
|
||
|
||
## One-shot initialiser. Call after add_child() so _ready() has already fired.
|
||
func setup(p_tile: Vector2i, p_kind: StringName, p_stage: Stage = Stage.SOWN) -> void:
|
||
tile = p_tile
|
||
crop_kind = p_kind
|
||
stage = p_stage
|
||
stage_progress = 0
|
||
position = _tile_to_world(tile)
|
||
if _sprite != null:
|
||
_sprite.texture = _texture_for(crop_kind)
|
||
_refresh_sprite_region()
|
||
queue_redraw()
|
||
Audit.log("crop", "spawned %s at %s (stage=%s)" % [crop_kind, tile, Stage.keys()[stage]])
|
||
|
||
|
||
## True when this crop can be harvested by a pawn.
|
||
func is_harvestable() -> bool:
|
||
return stage == Stage.READY
|
||
|
||
|
||
## True when this crop can be sown by a pawn (bare tilled soil, no plant yet).
|
||
func is_sowable() -> bool:
|
||
return stage == Stage.TILLED
|
||
|
||
|
||
## Called by the INTERACT toil in JobRunner once per sim tick while a pawn harvests.
|
||
## Single-tick harvest: drops an output Item and resets to TILLED (re-sowable).
|
||
func on_harvest_tick() -> void:
|
||
if not is_harvestable():
|
||
return
|
||
var item_type := _harvest_output_for(crop_kind)
|
||
var it: Item = ITEM_SCENE.instantiate()
|
||
get_parent().add_child(it)
|
||
it.setup(item_type, 1, tile)
|
||
# Carry the crop_kind through as a visual subtype so wheat / corn /
|
||
# potato / strawberry each render distinctly, while item_type stays
|
||
# generic (TYPE_GRAIN / TYPE_VEGETABLE) for stockpile filter purposes.
|
||
it.subtype = crop_kind
|
||
it.queue_redraw()
|
||
stage = Stage.TILLED
|
||
stage_progress = 0
|
||
_refresh_sprite_region()
|
||
Audit.log("crop", "harvested %s at %s → %s" % [crop_kind, tile, item_type])
|
||
queue_redraw()
|
||
|
||
|
||
## Called by the INTERACT toil in JobRunner once per sim tick while a pawn sows.
|
||
## Single-tick sow: transitions TILLED → SOWN so growth begins on the next sim tick.
|
||
func on_sow_tick() -> void:
|
||
if not is_sowable():
|
||
return
|
||
stage = Stage.SOWN
|
||
stage_progress = 0
|
||
_refresh_sprite_region()
|
||
Audit.log("crop", "sown %s at %s" % [crop_kind, tile])
|
||
queue_redraw()
|
||
|
||
|
||
# ── growth ────────────────────────────────────────────────────────────────────
|
||
|
||
func _on_sim_tick(_n: int) -> void:
|
||
if stage == Stage.READY or stage == Stage.TILLED:
|
||
return
|
||
# Phase 13 — crops don't grow indoors (no sunlight under a roof).
|
||
# World.is_indoor() returns false while RoomDetector has not yet fired, so
|
||
# outdoor crops planted during boot are unaffected.
|
||
if World.is_indoor(tile):
|
||
if not _logged_indoor:
|
||
Audit.log("crop", "%s at %s won't grow (indoor)" % [crop_kind, tile])
|
||
_logged_indoor = true
|
||
return
|
||
# Crop has moved outdoors or was never indoors — reset the log flag so a
|
||
# future re-roofing produces another audit line.
|
||
_logged_indoor = false
|
||
stage_progress += 1
|
||
if stage_progress >= STAGE_TICKS:
|
||
stage_progress = 0
|
||
stage = (int(stage) + 1) as Stage
|
||
_refresh_sprite_region()
|
||
queue_redraw()
|
||
if stage == Stage.READY:
|
||
Audit.log("crop", "%s ready at %s" % [crop_kind, tile])
|
||
|
||
|
||
# ── save / load ───────────────────────────────────────────────────────────────
|
||
|
||
func to_dict() -> Dictionary:
|
||
return {
|
||
"class_id": &"crop",
|
||
"tile_x": tile.x,
|
||
"tile_y": tile.y,
|
||
"crop_kind": String(crop_kind),
|
||
"stage": int(stage),
|
||
"stage_progress": stage_progress,
|
||
}
|
||
|
||
|
||
## Returns a plain Dictionary spec for World to instantiate from.
|
||
## Crops cannot reconstruct themselves standalone — they need a parent in the
|
||
## scene tree. World adds the node, then calls setup() from the returned dict.
|
||
static func from_dict(d: Dictionary) -> Dictionary:
|
||
return {
|
||
"tile_x": int(d.get("tile_x", 0)),
|
||
"tile_y": int(d.get("tile_y", 0)),
|
||
"crop_kind": StringName(d.get("crop_kind", "wheat")),
|
||
"stage": int(d.get("stage", Stage.SOWN)),
|
||
"stage_progress": int(d.get("stage_progress", 0)),
|
||
}
|
||
|
||
|
||
# ── render ────────────────────────────────────────────────────────────────────
|
||
|
||
func _draw() -> void:
|
||
# Tilled-soil base draws under the plant sprite. Stays visible at every stage
|
||
# so the player sees the patch as cultivated.
|
||
var soil_color := Color(0.32, 0.20, 0.10)
|
||
var soil_dark := Color(0.22, 0.14, 0.06)
|
||
draw_rect(Rect2(Vector2(-7.0, -7.0), Vector2(14.0, 14.0)), soil_color)
|
||
draw_rect(Rect2(Vector2(-7.0, -7.0), Vector2(14.0, 14.0)), soil_dark, false, 1.0)
|
||
|
||
|
||
# ── sprite helpers ────────────────────────────────────────────────────────────
|
||
|
||
func _build_sprite() -> void:
|
||
_sprite = Sprite2D.new()
|
||
_sprite.name = "Sprite"
|
||
_sprite.texture = _texture_for(crop_kind)
|
||
_sprite.region_enabled = true
|
||
_sprite.centered = true
|
||
# 32-tall sprite anchored so its bottom edge sits at the tile's bottom row
|
||
# (local +8 from tile centre). Sprite half-height = 16 → offset.y = 8 - 16 = -8.
|
||
_sprite.offset = Vector2(0, -8)
|
||
# Draw the plant above the soil rect but below pawns/items.
|
||
_sprite.z_index = 0
|
||
add_child(_sprite)
|
||
_refresh_sprite_region()
|
||
|
||
|
||
func _refresh_sprite_region() -> void:
|
||
if _sprite == null:
|
||
return
|
||
var idx := _sprite_stage_index(stage)
|
||
if idx < 0:
|
||
_sprite.visible = false
|
||
return
|
||
_sprite.visible = true
|
||
_sprite.region_rect = Rect2(idx * _STAGE_W, 0, _STAGE_W, _STAGE_H)
|
||
|
||
|
||
## Map game-stage to one of the 4 sprite columns. TILLED has no plant frame.
|
||
## SOWN..GROWING_2 step through cols 0..2; GROWING_3 and READY both land on
|
||
## col 3 (mature). The harvest designation overlay is what cues the player
|
||
## that READY is ready — sprite alone doesn't need a fifth frame.
|
||
func _sprite_stage_index(s: Stage) -> int:
|
||
match s:
|
||
Stage.TILLED: return -1
|
||
Stage.SOWN: return 0
|
||
Stage.GROWING_1: return 1
|
||
Stage.GROWING_2: return 2
|
||
Stage.GROWING_3: return 3
|
||
Stage.READY: return 3
|
||
_: return 0
|
||
|
||
|
||
# ── helpers ───────────────────────────────────────────────────────────────────
|
||
|
||
func _texture_for(kind: StringName) -> Texture2D:
|
||
return _CROP_TEXTURES.get(kind, _CROP_TEXTURES[KIND_WHEAT])
|
||
|
||
|
||
func _harvest_output_for(kind: StringName) -> StringName:
|
||
match kind:
|
||
KIND_WHEAT: return Item.TYPE_GRAIN
|
||
KIND_POTATO: return Item.TYPE_VEGETABLE
|
||
KIND_CORN: return Item.TYPE_GRAIN
|
||
KIND_STRAWBERRY: return Item.TYPE_VEGETABLE
|
||
_: return Item.TYPE_VEGETABLE
|
||
|
||
|
||
func _tile_to_world(t: Vector2i) -> Vector2:
|
||
return Vector2(
|
||
t.x * TILE_SIZE_PX + TILE_SIZE_PX / 2.0,
|
||
t.y * TILE_SIZE_PX + TILE_SIZE_PX / 2.0
|
||
)
|