spaceship/BuildingField.gd
Loïc Wisniewski 3573ccf44f Buildings produce from their own stock, and queue orders until supplied
Forgejo #16, part 3 of #12. BuildController deducted the cost from the
bank at the moment of purchase and refused outright with "Not enough
rocks", so nothing ever had to be delivered anywhere. Each building now
carries its own stock, and an order it cannot pay for yet is QUEUED and
completes by itself once ore arrives.

Records get an `id` because a building has to be referable across the
space <-> planet-surface scene swap, when every Building NODE has been
destroyed and rebuilt. Position would nearly work and then fail on two
buildings placed on the same spot.

Production advances in the GameState autoload, the same way extractor
haulers already do, so an order can complete while the player is down a
gravity well. A finished vessel becomes `ships_owed` rather than being
handed straight to a Fleet that may not exist, and the fleet claims what
it is owed when it next has room.

The craft menu remembers which crafter it was opened for: _process()
clears current_building while any menu is open, so by the next frame the
menu would no longer know. It shows the ore delivered HERE rather than
the bank, since showing the bank would promise something the crafter
cannot actually build.

Ship crafting cannot be supplied until #17 lands - nothing yet moves ore
into a building.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-11 16:18:44 +02:00

64 lines
2 KiB
GDScript

extends Node2D
# Rebuilds every player-placed structure from GameState when the space
# scene loads, and answers "is the fleet standing on one?".
#
# Buildings live in GameState rather than in the scene because Main.tscn is
# torn down and recreated on every trip to a planet's surface - anything
# kept only as a node would be lost on the first landing.
@onready var fleet: Node2D = get_node("../Fleet")
var building_scene: PackedScene = preload("res://Building.tscn")
var spawned: Array = []
func _ready() -> void:
rebuild_all()
func _process(_delta: float) -> void:
# Unloading the fleet's hold (#14). Done here because this is the node
# that already knows where the buildings are and already answers "is the
# fleet standing on one?" - and it uses the fleet CENTROID, the same
# stable single-number test Planet and Building already use, rather than
# per-ship collision that flickers as ships jostle in formation.
if GameState.fleet_cargo <= 0:
return
var under: Node2D = get_building_fleet_is_on()
if under != null and under.building_type == GameState.BUILDING_MOTHERSHIP:
GameState.deliver_cargo()
func rebuild_all() -> void:
for b in spawned:
if is_instance_valid(b):
b.queue_free()
spawned.clear()
for record in GameState.buildings:
_spawn(record)
func place(type: String, at_position: Vector2) -> void:
GameState.add_building(type, at_position)
_spawn(GameState.buildings[-1])
func get_building_fleet_is_on() -> Node2D:
var centre: Vector2 = fleet.get_centroid()
for b in spawned:
if is_instance_valid(b) and b.position.distance_to(centre) <= b.interact_radius:
return b
return null
func _spawn(record: Dictionary) -> void:
var b: Node2D = building_scene.instantiate()
b.position = record.position
b.building_type = record.type
b.building_id = int(record.get("id", 0))
# Deferred for the same reason as the other field spawners: this can run
# from inside a parent's _ready() chain, where a direct add_child() is
# rejected while the tree is still setting up children.
get_parent().add_child.call_deferred(b)
spawned.append(b)