rimlike/scenes/entities/item.gd

## Dropped item entity — a single stack of one item type lying on the world floor.
##
## Visuals are drawn procedurally via _draw() (Phase 4 placeholder). Real
## ElvGames item icons land in Phase 5+.
##
## Item type constants mirror the 16 filter chips in docs/design.md. They are
## used by StockpileZone filter bitmasks and pawn-carry typing.
##
## World registration (World.register_item / World.unregister_item) is called
## here but the methods land in World during Opus integration. The script will
## parse cleanly; the call will fail at runtime until then.

class_name Item extends Node2D

const TILE_SIZE_PX: int = 16

# ── canonical type registry — matches docs/design.md "16 filter chips" ───────

const TYPE_WOOD: StringName       = &"wood"         # Wd
const TYPE_STONE: StringName      = &"stone"        # St
const TYPE_IRON_ORE: StringName   = &"iron_ore"     # Ir
const TYPE_COPPER_ORE: StringName = &"copper_ore"   # Cu
const TYPE_SILVER: StringName     = &"silver"       # Ag
const TYPE_GOLD: StringName       = &"gold"         # Au
const TYPE_CLOTH: StringName      = &"cloth"        # Cl
const TYPE_VEGETABLE: StringName  = &"vegetable"    # Veg
const TYPE_MEAT: StringName       = &"meat"         # Mt
const TYPE_GRAIN: StringName      = &"grain"        # Gr
const TYPE_MEAL: StringName       = &"meal"         # Ck (cooked)
const TYPE_MEDICINE: StringName   = &"medicine"     # Md
const TYPE_TOOL: StringName       = &"tool"         # Tl
const TYPE_WEAPON: StringName     = &"weapon"       # Wp
const TYPE_ARMOR: StringName      = &"armor"        # Ar
const TYPE_CORPSE: StringName     = &"corpse"       # Co

# Phase 6 — intermediate crafted goods (carpenter bench + smelter outputs).
const TYPE_PLANK: StringName      = &"plank"
const TYPE_STONE_BLOCK: StringName = &"stone_block"

const ALL_TYPES: Array[StringName] = [
	TYPE_WOOD, TYPE_STONE, TYPE_IRON_ORE, TYPE_COPPER_ORE,
	TYPE_SILVER, TYPE_GOLD, TYPE_CLOTH, TYPE_VEGETABLE,
	TYPE_MEAT, TYPE_GRAIN, TYPE_MEAL, TYPE_MEDICINE,
	TYPE_TOOL, TYPE_WEAPON, TYPE_ARMOR, TYPE_CORPSE,
	TYPE_PLANK, TYPE_STONE_BLOCK,
]

# ── quality system (docs/architecture.md "Quality system") ───────────────────
# Rolled at craft-completion; stored per item; drives border colour in _draw().
enum Quality { SHODDY, NORMAL, EXCELLENT, MASTERWORK, LEGENDARY }

# ── state ────────────────────────────────────────────────────────────────────

@export var item_type: StringName = TYPE_WOOD
@export var stack_size: int = 1
@export var quality: Quality = Quality.NORMAL

var tile: Vector2i = Vector2i.ZERO

## When true the on-floor visual is suppressed; the carrying pawn renders the
## carry indicator instead.
var being_carried: bool = false


# ── lifecycle ─────────────────────────────────────────────────────────────────

func _ready() -> void:
	position = _tile_to_world(tile)
	visible = not being_carried


func _exit_tree() -> void:
	World.unregister_item(self)


# ── public API ────────────────────────────────────────────────────────────────

## One-shot initialiser called by the spawning code (Tree.fell, Rock.mined, etc.)
## Sets all fields, syncs position, and registers with World.
func setup(p_type: StringName, p_stack: int, p_tile: Vector2i) -> void:
	item_type = p_type
	stack_size = p_stack
	tile = p_tile
	position = _tile_to_world(tile)
	visible = not being_carried
	queue_redraw()
	World.register_item(self)
	Audit.log("item", "spawned %s×%d at %s" % [item_type, stack_size, tile])


## Hide/show the on-floor sprite when the pawn picks up or drops this item.
func set_being_carried(value: bool) -> void:
	being_carried = value
	visible = not being_carried


# ── save / load ───────────────────────────────────────────────────────────────

func to_dict() -> Dictionary:
	return {
		"type": String(item_type),
		"stack_size": stack_size,
		"tile_x": tile.x,
		"tile_y": tile.y,
		"quality": int(quality),
	}


## Returns a plain Dictionary spec for World.load_items() to instantiate from.
## Items 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 {
		"type": StringName(d.get("type", "wood")),
		"stack_size": int(d.get("stack_size", 1)),
		"tile_x": int(d.get("tile_x", 0)),
		"tile_y": int(d.get("tile_y", 0)),
		"quality": int(d.get("quality", Quality.NORMAL)),
	}


# ── render ────────────────────────────────────────────────────────────────────

func _draw() -> void:
	# 12×12 coloured square centered on the tile; colour hashed from item_type.
	var hue := float(item_type.hash() % 360) / 360.0
	var fill := Color.from_hsv(hue, 0.6, 0.85)
	var half: int = 6
	var square := Rect2(Vector2(-half, -half), Vector2(half * 2, half * 2))

	draw_rect(square, fill)
	draw_rect(square, Color(0.0, 0.0, 0.0, 0.75), false, 1.0)

	# Quality border — drawn over the dark outline, colour per quality tier.
	# NORMAL has no extra border (base outline is sufficient).
	match quality:
		Quality.SHODDY:
			draw_rect(square, Color(0.40, 0.40, 0.40), false, 1.0)
		Quality.EXCELLENT:
			draw_rect(square, Color(0.20, 0.55, 0.95), false, 1.0)
		Quality.MASTERWORK:
			draw_rect(square, Color(0.85, 0.55, 0.10), false, 1.0)
		Quality.LEGENDARY:
			draw_rect(square, Color(0.85, 0.10, 0.80), false, 2.0)
		_:
			pass  # NORMAL — no extra border

	# Stack count badge — bottom-right corner of the square, font_size 7.
	if stack_size > 1:
		var label := Strings.t(&"item.stack_count").format({"n": stack_size})
		draw_string(
			ThemeDB.fallback_font,
			Vector2(half - 1, half - 1),
			label,
			HORIZONTAL_ALIGNMENT_RIGHT,
			-1,
			7,
			Color(0.0, 0.0, 0.0, 0.6)  # drop-shadow offset below
		)
		draw_string(
			ThemeDB.fallback_font,
			Vector2(half - 2, half - 2),
			label,
			HORIZONTAL_ALIGNMENT_RIGHT,
			-1,
			7,
			Color(1.0, 1.0, 1.0, 1.0)
		)


# ── helpers ───────────────────────────────────────────────────────────────────

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
	)