megaproxy
ab4d62889b
Items without an atlas entry were rendering as a hue-hashed coloured square — bread/grain/vegetable hashed to pink-magenta, indistinguish- able from a missing-texture placeholder. Added _draw_item_shape() dispatcher with category-appropriate silhouettes for: bread (brown loaf), grain (wheat stalks), vegetable (root with leaves), flour (cream sack), meal (wooden bowl with steam), meat (red steak with marbling), cloth (blue pleated bolt), medicine (white phial with red cross), tool (hammer), weapon (sword), armor (helmet), stone_block (pale brick), copper_ore (copper chunks), silver (silver nuggets), ash (grey pile with smoke). Hue-hashed fallback retained for safety but should be unreachable now that every ALL_TYPES entry is handled by either _ITEM_SPRITES or _draw_item_shape.
410 lines
17 KiB
GDScript
410 lines
17 KiB
GDScript
## Dropped item entity — a single stack of one item type lying on the world floor.
|
||
##
|
||
## Render model:
|
||
## For types in _ITEM_SPRITES (stone, wood, plank, iron_ore, gold, …) a Sprite2D
|
||
## child draws the ElvGames icon. For all other types _draw() falls back to a
|
||
## hue-hashed coloured square — the original Phase 4 placeholder kept around
|
||
## for the long tail of items (cloth, meals, corpses, ash, etc.).
|
||
## Quality border + stack-count badge are always drawn procedurally on top of
|
||
## whichever base layer renders, so the sprite swap is purely additive.
|
||
##
|
||
## 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
|
||
|
||
## ElvGames FG_Abandoned_Mines icons used for the most-spawned item types.
|
||
## Picked in the 2026-05-12 visual pass — see /tmp/item_finals.png for the
|
||
## side-by-side that produced these atlas coords. Other types still fall back
|
||
## to the procedural hue-hashed square in _draw().
|
||
const _MINES_TEX: Texture2D = preload("res://art/tiles/FG_Abandoned_Mines.png")
|
||
const _ITEM_SPRITES: Dictionary = {
|
||
&"stone": {"tex": _MINES_TEX, "coord": Vector2i(5, 33)},
|
||
&"iron_ore": {"tex": _MINES_TEX, "coord": Vector2i(9, 33)},
|
||
&"gold": {"tex": _MINES_TEX, "coord": Vector2i(13, 33)},
|
||
&"wood": {"tex": _MINES_TEX, "coord": Vector2i(20, 13)},
|
||
&"plank": {"tex": _MINES_TEX, "coord": Vector2i(28, 18)},
|
||
}
|
||
|
||
# ── 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"
|
||
|
||
# Phase 7 — cooking chain. Grain → Flour (millstone) → Bread (hearth).
|
||
# TYPE_MEAL (&"meal") is the generic cooked-dish output and already lives above
|
||
# in the 16-chip base set.
|
||
const TYPE_FLOUR: StringName = &"flour"
|
||
const TYPE_BREAD: StringName = &"bread"
|
||
|
||
# Phase 14 — cremation output. One ash item drops per cremated corpse.
|
||
const TYPE_ASH: StringName = &"ash"
|
||
|
||
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,
|
||
TYPE_FLOUR, TYPE_BREAD,
|
||
TYPE_ASH,
|
||
]
|
||
|
||
# ── 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
|
||
_build_sprite()
|
||
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
|
||
|
||
|
||
## Build the Sprite2D child for item_type, if a tileset icon is registered.
|
||
## Idempotent: re-running drops the previous sprite first. Types without an
|
||
## entry in _ITEM_SPRITES render via the procedural fallback in _draw().
|
||
func _build_sprite() -> void:
|
||
var prev := get_node_or_null("Sprite")
|
||
if prev != null:
|
||
prev.queue_free()
|
||
var data = _ITEM_SPRITES.get(item_type)
|
||
if data == null:
|
||
return
|
||
var sprite := Sprite2D.new()
|
||
sprite.name = "Sprite"
|
||
sprite.texture = data["tex"]
|
||
sprite.region_enabled = true
|
||
var coord: Vector2i = data["coord"]
|
||
sprite.region_rect = Rect2(coord.x * TILE_SIZE_PX, coord.y * TILE_SIZE_PX, TILE_SIZE_PX, TILE_SIZE_PX)
|
||
sprite.centered = true
|
||
# Item position is the tile centre — Sprite2D centred at (0, 0) fills the
|
||
# 16×16 cell exactly. No bottom-anchoring offset (items are flat on the floor).
|
||
sprite.offset = Vector2.ZERO
|
||
sprite.z_index = 0
|
||
add_child(sprite)
|
||
|
||
|
||
# ── save / load ───────────────────────────────────────────────────────────────
|
||
|
||
func to_dict() -> Dictionary:
|
||
return {
|
||
"class_id": &"item",
|
||
"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 ────────────────────────────────────────────────────────────────────
|
||
|
||
## Procedural shape per item type. All shapes draw inside a -6..+6 box so the
|
||
## quality border (half=6) wraps the result. Returns true if the type was
|
||
## handled; false sends the caller to the hue-hashed fallback.
|
||
##
|
||
## Shape language is loose silhouette + a category-appropriate colour: bread =
|
||
## brown loaf, grain = wheat-amber stalks, vegetable = green disc, meal = bowl,
|
||
## etc. Better than rendering 18 different magenta-pink squares; later art pass
|
||
## can lift these to atlas crops where the bundle has a fitting icon.
|
||
func _draw_item_shape(t: StringName) -> bool:
|
||
var dark := Color(0.10, 0.07, 0.05, 0.85) # shared outline
|
||
match t:
|
||
TYPE_BREAD:
|
||
# Two stacked brown loaves with a slash on the upper crust.
|
||
var crust := Color(0.62, 0.40, 0.18)
|
||
var glaze := Color(0.82, 0.58, 0.30)
|
||
draw_rect(Rect2(-6.0, -1.0, 12.0, 5.0), crust)
|
||
draw_rect(Rect2(-5.0, -5.0, 10.0, 4.0), glaze)
|
||
draw_line(Vector2(-3.0, -4.0), Vector2(0.0, -2.0), dark, 1.0)
|
||
draw_line(Vector2(0.0, -4.0), Vector2(3.0, -2.0), dark, 1.0)
|
||
draw_rect(Rect2(-6.0, -5.0, 12.0, 9.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_GRAIN:
|
||
# Three vertical wheat stalks tied in the middle.
|
||
var stalk := Color(0.85, 0.70, 0.20)
|
||
var tie := Color(0.55, 0.35, 0.10)
|
||
draw_rect(Rect2(-4.0, -6.0, 1.5, 12.0), stalk)
|
||
draw_rect(Rect2(-0.75, -6.0, 1.5, 12.0), stalk)
|
||
draw_rect(Rect2(2.5, -6.0, 1.5, 12.0), stalk)
|
||
# Grain heads (small dots near top).
|
||
draw_circle(Vector2(-3.2, -5.0), 1.2, Color(0.95, 0.78, 0.25))
|
||
draw_circle(Vector2(0.0, -5.5), 1.2, Color(0.95, 0.78, 0.25))
|
||
draw_circle(Vector2(3.2, -5.0), 1.2, Color(0.95, 0.78, 0.25))
|
||
draw_rect(Rect2(-5.0, 0.0, 10.0, 2.0), tie)
|
||
return true
|
||
TYPE_FLOUR:
|
||
# Cream-white sack with a darker drawstring at the neck.
|
||
var sack := Color(0.93, 0.90, 0.78)
|
||
var shadow := Color(0.78, 0.74, 0.60)
|
||
draw_rect(Rect2(-5.0, -3.0, 10.0, 8.0), sack)
|
||
draw_rect(Rect2(3.0, -3.0, 2.0, 8.0), shadow)
|
||
draw_rect(Rect2(-4.0, -5.0, 8.0, 2.0), Color(0.45, 0.30, 0.10)) # drawstring band
|
||
draw_circle(Vector2(0.0, -5.5), 1.0, sack) # gathered top puff
|
||
draw_rect(Rect2(-5.0, -6.0, 10.0, 11.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_VEGETABLE:
|
||
# Green-leafed root vegetable (think turnip).
|
||
var leaf := Color(0.25, 0.65, 0.20)
|
||
var root := Color(0.92, 0.88, 0.70)
|
||
draw_circle(Vector2(0.0, 1.0), 5.0, root)
|
||
draw_arc(Vector2(0.0, 1.0), 5.0, 0.0, TAU, 16, dark, 1.0)
|
||
# Leaves
|
||
draw_rect(Rect2(-3.0, -5.0, 2.0, 3.0), leaf)
|
||
draw_rect(Rect2(-1.0, -6.0, 2.0, 4.0), leaf)
|
||
draw_rect(Rect2( 1.0, -5.0, 2.0, 3.0), leaf)
|
||
return true
|
||
TYPE_MEAL:
|
||
# Wooden bowl with a steamy meal heap.
|
||
var bowl := Color(0.50, 0.30, 0.12)
|
||
var bowl_rim := Color(0.30, 0.18, 0.08)
|
||
var food := Color(0.85, 0.55, 0.20)
|
||
# Bowl as a half-disc.
|
||
draw_circle(Vector2(0.0, 1.0), 6.0, bowl)
|
||
draw_rect(Rect2(-6.0, -5.0, 12.0, 6.0), Color(0, 0, 0, 0)) # cover top half (no-op, rely on z)
|
||
draw_arc(Vector2(0.0, 1.0), 6.0, 0.0, PI, 16, bowl_rim, 1.0)
|
||
draw_line(Vector2(-6.0, 1.0), Vector2(6.0, 1.0), bowl_rim, 1.0)
|
||
# Food mound on top.
|
||
draw_circle(Vector2(0.0, 0.0), 3.5, food)
|
||
# Two steam wisps.
|
||
draw_line(Vector2(-2.0, -5.0), Vector2(-1.0, -3.0), Color(0.9, 0.9, 0.9, 0.7), 1.0)
|
||
draw_line(Vector2(2.0, -5.0), Vector2(1.0, -3.0), Color(0.9, 0.9, 0.9, 0.7), 1.0)
|
||
return true
|
||
TYPE_MEAT:
|
||
# Raw red steak with a pale fat marbling line.
|
||
var meat := Color(0.78, 0.20, 0.20)
|
||
var fat := Color(0.95, 0.85, 0.70)
|
||
draw_rect(Rect2(-5.0, -3.0, 10.0, 7.0), meat)
|
||
draw_line(Vector2(-5.0, 0.0), Vector2(5.0, 0.5), fat, 1.0)
|
||
draw_rect(Rect2(-5.0, -3.0, 10.0, 7.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_CLOTH:
|
||
# Folded cloth bolt — light blue with horizontal pleats.
|
||
var cloth := Color(0.50, 0.65, 0.85)
|
||
var pleat := Color(0.32, 0.42, 0.58)
|
||
draw_rect(Rect2(-5.0, -4.0, 10.0, 8.0), cloth)
|
||
draw_line(Vector2(-5.0, -1.5), Vector2(5.0, -1.5), pleat, 1.0)
|
||
draw_line(Vector2(-5.0, 1.5), Vector2(5.0, 1.5), pleat, 1.0)
|
||
draw_rect(Rect2(-5.0, -4.0, 10.0, 8.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_MEDICINE:
|
||
# White phial with a red cross — medieval-ish but reads instantly.
|
||
var phial := Color(0.95, 0.95, 0.95)
|
||
var cross := Color(0.80, 0.15, 0.15)
|
||
draw_rect(Rect2(-4.0, -5.0, 8.0, 10.0), phial)
|
||
draw_rect(Rect2(-1.0, -3.0, 2.0, 6.0), cross)
|
||
draw_rect(Rect2(-3.0, -1.0, 6.0, 2.0), cross)
|
||
draw_rect(Rect2(-4.0, -5.0, 8.0, 10.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_TOOL:
|
||
# Brown-handled hammer.
|
||
var handle := Color(0.50, 0.30, 0.12)
|
||
var head := Color(0.45, 0.45, 0.48)
|
||
draw_rect(Rect2(-1.0, -2.0, 2.0, 8.0), handle)
|
||
draw_rect(Rect2(-5.0, -5.0, 10.0, 4.0), head)
|
||
draw_rect(Rect2(-5.0, -5.0, 10.0, 4.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_WEAPON:
|
||
# Sword: triangular blade + brown grip + crossguard.
|
||
var blade := Color(0.78, 0.80, 0.85)
|
||
var guard := Color(0.45, 0.30, 0.10)
|
||
# Blade (pointing up)
|
||
var pts: PackedVector2Array = PackedVector2Array([Vector2(0.0, -6.0), Vector2(2.5, 1.0), Vector2(-2.5, 1.0)])
|
||
draw_colored_polygon(pts, blade)
|
||
# Crossguard
|
||
draw_rect(Rect2(-4.0, 1.0, 8.0, 2.0), guard)
|
||
# Grip
|
||
draw_rect(Rect2(-1.0, 3.0, 2.0, 3.0), guard)
|
||
return true
|
||
TYPE_ARMOR:
|
||
# Helmet silhouette — rounded grey dome with a nose-guard slit.
|
||
var steel := Color(0.65, 0.65, 0.70)
|
||
var visor := Color(0.20, 0.20, 0.25)
|
||
draw_circle(Vector2(0.0, 0.0), 5.5, steel)
|
||
draw_rect(Rect2(-1.0, -2.0, 2.0, 4.0), visor)
|
||
draw_rect(Rect2(-6.0, 4.0, 12.0, 2.0), steel)
|
||
draw_arc(Vector2(0.0, 0.0), 5.5, 0.0, TAU, 16, dark, 1.0)
|
||
return true
|
||
TYPE_STONE_BLOCK:
|
||
# Cleaned-up stone brick: pale grey rect with a chiseled corner.
|
||
var stone := Color(0.62, 0.60, 0.58)
|
||
var stone_hi := Color(0.78, 0.76, 0.72)
|
||
draw_rect(Rect2(-6.0, -4.0, 12.0, 8.0), stone)
|
||
draw_rect(Rect2(-6.0, -4.0, 12.0, 2.0), stone_hi)
|
||
draw_line(Vector2(-6.0, 0.0), Vector2(6.0, 0.0), Color(0.42, 0.40, 0.38), 1.0)
|
||
draw_rect(Rect2(-6.0, -4.0, 12.0, 8.0), dark, false, 1.0)
|
||
return true
|
||
TYPE_COPPER_ORE:
|
||
# Copper chunks — warm brown with bright highlights.
|
||
var copper := Color(0.65, 0.35, 0.18)
|
||
var hi := Color(0.92, 0.55, 0.20)
|
||
draw_circle(Vector2(-2.0, 1.0), 3.5, copper)
|
||
draw_circle(Vector2(2.0, -1.0), 2.8, copper)
|
||
draw_circle(Vector2(-2.0, 1.0), 1.5, hi)
|
||
draw_circle(Vector2(2.0, -1.0), 1.0, hi)
|
||
return true
|
||
TYPE_SILVER:
|
||
# Silver nugget — cool grey with a white highlight.
|
||
var silver := Color(0.78, 0.80, 0.85)
|
||
var hi := Color(0.98, 0.98, 1.00)
|
||
draw_circle(Vector2(-2.0, 1.0), 3.5, silver)
|
||
draw_circle(Vector2(2.0, -1.0), 2.8, silver)
|
||
draw_circle(Vector2(-2.0, 0.5), 1.2, hi)
|
||
return true
|
||
TYPE_ASH:
|
||
# Grey pile with faint smoke wisps.
|
||
var ash := Color(0.55, 0.55, 0.55)
|
||
var ash_hi := Color(0.78, 0.78, 0.78)
|
||
# Heap (low triangle)
|
||
var pts: PackedVector2Array = PackedVector2Array([Vector2(-6.0, 4.0), Vector2(6.0, 4.0), Vector2(0.0, -2.0)])
|
||
draw_colored_polygon(pts, ash)
|
||
draw_line(Vector2(-3.0, 1.0), Vector2(3.0, 1.0), ash_hi, 1.0)
|
||
# Smoke wisps
|
||
draw_line(Vector2(-1.0, -3.0), Vector2(0.0, -5.0), Color(0.85, 0.85, 0.85, 0.6), 1.0)
|
||
draw_line(Vector2(1.5, -3.0), Vector2(2.5, -5.0), Color(0.85, 0.85, 0.85, 0.6), 1.0)
|
||
return true
|
||
_:
|
||
return false
|
||
|
||
|
||
func _draw() -> void:
|
||
# Three render paths:
|
||
# 1. Atlas sprite (_ITEM_SPRITES): a Sprite2D child paints the icon;
|
||
# _draw() adds quality border + stack badge on top.
|
||
# 2. Procedural shape (_draw_item_shape returns true): bread/grain/
|
||
# vegetable/meal/flour/meat/cloth/medicine/etc. get a recognisable
|
||
# silhouette in their category colour.
|
||
# 3. Unknown fallback: hue-hashed coloured square. Should be unreachable
|
||
# once every ALL_TYPES entry is handled above — kept for safety.
|
||
var has_sprite: bool = _ITEM_SPRITES.has(item_type)
|
||
var half: int = 6 if not has_sprite else 8 # border hugs the 16×16 sprite
|
||
var square := Rect2(Vector2(-half, -half), Vector2(half * 2, half * 2))
|
||
|
||
if not has_sprite:
|
||
if not _draw_item_shape(item_type):
|
||
var hue := float(item_type.hash() % 360) / 360.0
|
||
var fill := Color.from_hsv(hue, 0.6, 0.85)
|
||
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 (or sprite), colour per quality tier.
|
||
# NORMAL has no extra border.
|
||
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
|
||
)
|