refactor: move resource authority into simulation

simulation/state/ResourceStateRecord.gd

@@ -1,42 +1,163 @@
 class_name ResourceStateRecord
 extends RefCounted
 
-const SCHEMA_VERSION := 1
+signal changed(state: ResourceStateRecord)
+signal depleted(state: ResourceStateRecord)
+
+const SCHEMA_VERSION := 2
+const LEGACY_SCHEMA_VERSION := 1
 
 var data: Dictionary
 
 func _init(record_data: Dictionary = {}) -> void:
 	data = record_data.duplicate(true)
 
-static func capture(node: ResourceNode) -> ResourceStateRecord:
+static func create_from_node(node: ResourceNode) -> ResourceStateRecord:
 	return ResourceStateRecord.new({
 		"schema_version": SCHEMA_VERSION,
 		"node_id": String(node.node_id),
-		"amount_remaining": node.amount_remaining,
-		"reserved_by": node.reserved_by,
-		"enabled": node.enabled
+		"action_id": String(node.action_id),
+		"resource_id": String(node.resource_id),
+		"amount_remaining": node.initial_amount,
+		"yield_per_action": node.yield_per_action,
+		"reserved_by": -1,
+		"enabled": node.initial_enabled,
+		"can_npcs_use": node.can_npcs_use,
+		"can_player_use": node.can_player_use
 	})
 
 static func from_dictionary(record_data: Dictionary) -> ResourceStateRecord:
-	if int(record_data.get("schema_version", -1)) != SCHEMA_VERSION:
+	var version := int(record_data.get("schema_version", -1))
+	if version == LEGACY_SCHEMA_VERSION:
+		record_data = _migrate_v1(record_data)
+	elif version != SCHEMA_VERSION:
 		return null
+
 	if not record_data.has_all([
-		"node_id", "amount_remaining", "reserved_by", "enabled"
+		"node_id", "action_id", "resource_id", "amount_remaining",
+		"yield_per_action", "reserved_by", "enabled", "can_npcs_use",
+		"can_player_use"
 	]):
 		return null
 	if String(record_data["node_id"]).is_empty():
 		return null
 	return ResourceStateRecord.new(record_data)
 
-func restore(node: ResourceNode) -> bool:
-	if node == null or node.node_id != StringName(data["node_id"]):
+static func _migrate_v1(legacy_data: Dictionary) -> Dictionary:
+	if not legacy_data.has_all([
+		"node_id", "amount_remaining", "reserved_by", "enabled"
+	]):
+		return {}
+	var migrated := legacy_data.duplicate(true)
+	migrated["schema_version"] = SCHEMA_VERSION
+	migrated["action_id"] = ""
+	migrated["resource_id"] = ""
+	migrated["yield_per_action"] = 0.0
+	migrated["can_npcs_use"] = false
+	migrated["can_player_use"] = false
+	return migrated
+
+func apply_definition(node: ResourceNode) -> bool:
+	if node == null or node.node_id != get_node_id():
 		return false
-	node.restore_persistent_state(
-		float(data["amount_remaining"]),
-		int(data["reserved_by"]),
-		bool(data["enabled"])
+
+	var has_legacy_definition := get_action_id().is_empty()
+	if has_legacy_definition:
+		data["action_id"] = String(node.action_id)
+		data["resource_id"] = String(node.resource_id)
+		data["yield_per_action"] = node.yield_per_action
+		data["can_npcs_use"] = node.can_npcs_use
+		data["can_player_use"] = node.can_player_use
+		data["schema_version"] = SCHEMA_VERSION
+		return true
+
+	return (
+		get_action_id() == node.action_id
+		and get_resource_id() == node.resource_id
+		and is_equal_approx(get_yield_per_action(), node.yield_per_action)
+		and can_npc_use() == node.can_npcs_use
+		and can_player_use_resource() == node.can_player_use
 	)
+
+func get_node_id() -> StringName:
+	return StringName(data["node_id"])
+
+func get_action_id() -> StringName:
+	return StringName(data["action_id"])
+
+func get_resource_id() -> StringName:
+	return StringName(data["resource_id"])
+
+func get_amount_remaining() -> float:
+	return float(data["amount_remaining"])
+
+func get_yield_per_action() -> float:
+	return float(data["yield_per_action"])
+
+func get_reserved_by() -> int:
+	return int(data["reserved_by"])
+
+func is_enabled() -> bool:
+	return bool(data["enabled"])
+
+func can_npc_use() -> bool:
+	return bool(data["can_npcs_use"])
+
+func can_player_use_resource() -> bool:
+	return bool(data["can_player_use"])
+
+func is_depleted() -> bool:
+	return get_amount_remaining() <= 0.0
+
+func can_extract() -> bool:
+	return is_enabled() and not is_depleted()
+
+func is_available_for(agent_id: int) -> bool:
+	return (
+		can_extract()
+		and (get_reserved_by() == -1 or get_reserved_by() == agent_id)
+	)
+
+func reserve(agent_id: int) -> bool:
+	if not is_available_for(agent_id):
+		return false
+	data["reserved_by"] = agent_id
+	changed.emit(self)
 	return true
 
+func release(agent_id: int) -> void:
+	if get_reserved_by() != agent_id:
+		return
+	data["reserved_by"] = -1
+	changed.emit(self)
+
+func extract(requested_amount: float = -1.0) -> float:
+	if not can_extract():
+		return 0.0
+	var amount := requested_amount
+	if amount < 0.0:
+		amount = get_yield_per_action()
+	var extracted := minf(maxf(amount, 0.0), get_amount_remaining())
+	data["amount_remaining"] = get_amount_remaining() - extracted
+	if is_depleted():
+		data["reserved_by"] = -1
+	changed.emit(self)
+	if is_depleted():
+		depleted.emit(self)
+	return extracted
+
+func set_amount_remaining(amount: float) -> void:
+	var was_depleted := is_depleted()
+	data["amount_remaining"] = maxf(amount, 0.0)
+	if is_depleted():
+		data["reserved_by"] = -1
+	changed.emit(self)
+	if not was_depleted and is_depleted():
+		depleted.emit(self)
+
+func set_enabled(value: bool) -> void:
+	data["enabled"] = value
+	changed.emit(self)
+
 func to_dictionary() -> Dictionary:
 	return data.duplicate(true)