Takeshi
5dde0c5ec2
Capture current source, content data, tests, asset licenses, and original-specification traceability. Original implementation remains incomplete. The accepted matching UI generation passed 154 suites and 12,253 checks, with eight rendered staff-contract screens reviewed. Latest native Windows and full-original acceptance remain outstanding.
304 lines
14 KiB
GDScript
304 lines
14 KiB
GDScript
extends SceneTree
|
|
|
|
const DefinitionRegistryScript := preload("res://scripts/core/definition_registry.gd")
|
|
const FacilityCatalogScript := preload("res://scripts/data/facility_catalog.gd")
|
|
|
|
var _checks := 0
|
|
var _failures := 0
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
_test_catalog_references()
|
|
_test_normal_catalog_lookup()
|
|
_test_expansion_catalog()
|
|
_test_default_registry()
|
|
_test_detailed_definition_schema()
|
|
_test_invalid_detailed_service_is_rejected()
|
|
_test_canonical_added_baselines()
|
|
_test_queries()
|
|
_test_duplicate_detection_is_deterministic()
|
|
_test_missing_path_is_structured()
|
|
if _failures == 0:
|
|
print("PASS: DefinitionRegistry (%d checks)" % _checks)
|
|
else:
|
|
push_error("FAIL: DefinitionRegistry (%d of %d checks failed)" % [_failures, _checks])
|
|
quit(_failures)
|
|
|
|
|
|
func _test_default_registry() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
var report: Dictionary = registry.rebuild()
|
|
_expect(bool(report[&"valid"]), "all baseline definitions pass registry schema validation")
|
|
_expect(int(report[&"source_count"]) == 16, "all sixteen baseline source files are inspected")
|
|
_expect(int(report[&"definition_count"]) == 16, "all sixteen valid definitions are indexed")
|
|
_expect(int(report[&"error_count"]) == 0, "baseline definitions have no fatal schema errors")
|
|
_expect(int(report[&"warning_count"]) == 0, "baseline definitions have no schema warnings")
|
|
var expected_ids: Array[StringName] = [
|
|
&"adult_private_room",
|
|
&"cafeteria",
|
|
&"guest_corridor",
|
|
&"guest_elevator",
|
|
&"kitchen",
|
|
&"massage_room",
|
|
&"public_bath",
|
|
&"reception",
|
|
&"security_station",
|
|
&"service_corridor",
|
|
&"service_elevator",
|
|
&"staff_door",
|
|
&"staff_waiting_room",
|
|
&"standard_room",
|
|
&"tavern",
|
|
&"warehouse",
|
|
]
|
|
_expect(
|
|
registry.get_facility_ids() == expected_ids,
|
|
"all sixteen facility IDs are returned in deterministic lexical order"
|
|
)
|
|
_expect(registry.has_facility(&"reception"), "has_facility finds a known ID")
|
|
_expect(registry.has_facility(&"adult_private_room"), "has_facility finds the underground baseline ID")
|
|
_expect(registry.get_facility(&"missing") == null, "unknown lookup returns null")
|
|
|
|
|
|
func _test_catalog_references() -> void:
|
|
_expect(FacilityCatalogScript.FACILITY_PATHS.size() == 16, "catalog exposes sixteen stable resource references")
|
|
_expect(FacilityCatalogScript.BASELINE_FACILITY_IDS.size() == 16, "catalog exposes sixteen stable baseline IDs")
|
|
var loaded: Array[FacilityDefinition] = FacilityCatalogScript.load_all()
|
|
_expect(loaded.size() == 16, "every catalog resource reference resolves")
|
|
var loaded_ids: Array[StringName] = []
|
|
for index in FacilityCatalogScript.FACILITY_PATHS.size():
|
|
var path: String = FacilityCatalogScript.FACILITY_PATHS[index]
|
|
var expected_id: StringName = FacilityCatalogScript.BASELINE_FACILITY_IDS[index]
|
|
_expect(FileAccess.file_exists(path), "catalog reference %s exists" % path)
|
|
var definition := load(path) as FacilityDefinition
|
|
_expect(definition != null, "catalog reference %s loads as FacilityDefinition" % path)
|
|
if definition != null:
|
|
loaded_ids.append(definition.id)
|
|
_expect(definition.id == expected_id, "catalog reference %s preserves its expected ID" % path)
|
|
_expect(loaded_ids == FacilityCatalogScript.BASELINE_FACILITY_IDS, "catalog loading preserves the design-table order")
|
|
_expect(FacilityCatalogScript.by_id(&"service_elevator") != null, "catalog by_id resolves an added baseline")
|
|
_expect(FacilityCatalogScript.by_id(&"not_a_facility") == null, "catalog by_id rejects an unknown reference")
|
|
|
|
|
|
func _test_normal_catalog_lookup() -> void:
|
|
# Every normal-build registration must also resolve through the public catalog.
|
|
var paths: Array[String] = FacilityCatalogScript.FACILITY_PATHS + FacilityCatalogScript.INFRASTRUCTURE_FACILITY_PATHS + FacilityCatalogScript.RESCUE_FACILITY_PATHS + FacilityCatalogScript.ORIGINAL_FACILITY_PATHS
|
|
for path: String in paths:
|
|
var registered := load(path) as FacilityDefinition
|
|
_expect(registered != null, "normal catalog resource loads: %s" % path)
|
|
if registered != null:
|
|
_expect(FacilityCatalogScript.by_id(registered.id) == registered, "normal registration resolves to identical definition: %s" % registered.id)
|
|
|
|
|
|
func _test_detailed_definition_schema() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
registry.rebuild()
|
|
var reception: FacilityDefinition = registry.get_facility(&"reception")
|
|
var kitchen: FacilityDefinition = registry.get_facility(&"kitchen")
|
|
var restricted: FacilityDefinition = registry.get_facility(&"adult_private_room")
|
|
_expect(reception.has_detailed_profile(), "reception uses the detailed facility schema")
|
|
_expect(reception.default_service_type == &"check_in", "reception declares its default service")
|
|
_expect(reception.service_profiles.size() == 2, "reception defines check-in and check-out profiles")
|
|
_expect(reception.service_profiles[&"check_out"][&"duration_minutes"] == 6, "check-out has an independent duration")
|
|
_expect(kitchen.has_detailed_profile(), "kitchen uses the detailed facility schema")
|
|
_expect(kitchen.service_profiles[&"meal_batch"][&"capacity_units"] == 4, "kitchen service produces a four-unit batch")
|
|
_expect(restricted.has_detailed_profile(), "restricted room uses the detailed facility schema")
|
|
_expect(restricted.opening_schedule == {&"morning": false, &"day": false, &"night": true}, "restricted room is night-only")
|
|
_expect(restricted.service_profiles[&"private_adult_service"][&"need_effects"][&"intimacy"] == -70, "restricted service records need relief")
|
|
_expect(restricted.content_replacement_id == &"massage_room", "restricted service declares a safe replacement")
|
|
|
|
|
|
func _test_invalid_detailed_service_is_rejected() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
var paths: Array[String] = ["res://tests/fixtures/facilities/invalid_service_profile.tres"]
|
|
var report: Dictionary = registry.rebuild_from_paths(paths)
|
|
var errors: Array[Dictionary] = registry.get_fatal_errors()
|
|
_expect(not bool(report[&"valid"]), "an invalid detailed service profile makes the registry invalid")
|
|
_expect(registry.facility_count() == 0, "an invalid detailed facility is not exposed through lookup")
|
|
_expect(errors.size() == 1, "invalid service duration produces one focused issue")
|
|
_expect(errors[0][&"code"] == &"invalid_service_profile_value", "invalid service duration has a stable issue code")
|
|
_expect(errors[0][&"field"] == &"service_profiles", "invalid service issue identifies its owning field")
|
|
|
|
|
|
func _test_expansion_catalog() -> void:
|
|
_expect(FacilityCatalogScript.EXPANSION_FACILITY_IDS.size() == 16, "catalog exposes sixteen optional expansion IDs")
|
|
_expect(FacilityCatalogScript.EXPANSION_FACILITY_PATHS.size() == 16, "catalog exposes sixteen optional expansion resources")
|
|
var loaded: Array[FacilityDefinition] = FacilityCatalogScript.load_expansion()
|
|
_expect(loaded.size() == 16, "every optional expansion resource resolves")
|
|
var loaded_ids: Array[StringName] = []
|
|
for index in FacilityCatalogScript.EXPANSION_FACILITY_PATHS.size():
|
|
var path: String = FacilityCatalogScript.EXPANSION_FACILITY_PATHS[index]
|
|
var expected_id: StringName = FacilityCatalogScript.EXPANSION_FACILITY_IDS[index]
|
|
_expect(FileAccess.file_exists(path), "expansion catalog reference %s exists" % path)
|
|
var definition := load(path) as FacilityDefinition
|
|
_expect(definition != null, "expansion catalog reference %s loads" % path)
|
|
if definition != null:
|
|
loaded_ids.append(definition.id)
|
|
_expect(definition.id == expected_id, "expansion resource preserves %s" % expected_id)
|
|
_expect(definition.is_valid(), "expansion definition %s passes its resource schema" % expected_id)
|
|
_expect(loaded_ids == FacilityCatalogScript.EXPANSION_FACILITY_IDS, "expansion loading preserves design order")
|
|
_expect(FacilityCatalogScript.by_id(&"clinic") != null, "catalog by_id resolves an optional expansion")
|
|
_expect(
|
|
FacilityCatalogScript.by_id(&"vip_private_salon").zone == FacilityDefinition.MapZone.UNDERGROUND,
|
|
"restricted expansion is constrained to the underground zone"
|
|
)
|
|
_expect(
|
|
FacilityCatalogScript.by_id(&"mana_control_room").layer == FacilityDefinition.ViewLayer.BACK,
|
|
"infrastructure expansion is constrained to the BACK layer"
|
|
)
|
|
|
|
|
|
func _test_canonical_added_baselines() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
registry.rebuild()
|
|
var rows: Array = [
|
|
[&"kitchen", 700, 10, Vector2i(4, 2), 1, 3, 20, 15, 0],
|
|
[&"public_bath", 1200, 16, Vector2i(6, 2), 1, 2, 12, 60, 20],
|
|
[&"staff_waiting_room", 400, 6, Vector2i(4, 2), 0, 0, 8, 1, 0],
|
|
[&"security_station", 900, 10, Vector2i(2, 2), 1, 3, 3, 1, 0],
|
|
[&"tavern", 1000, 12, Vector2i(4, 2), 2, 4, 14, 50, 40],
|
|
[&"massage_room", 800, 8, Vector2i(2, 1), 1, 2, 2, 60, 100],
|
|
[&"guest_elevator", 1500, 15, Vector2i(2, 2), 0, 0, 4, 10, 0],
|
|
[&"service_elevator", 2200, 20, Vector2i(3, 2), 0, 0, 8, 5, 0],
|
|
[&"staff_door", 100, 1, Vector2i(1, 1), 0, 0, 1, 1, 0],
|
|
[&"guest_corridor", 20, 0, Vector2i(1, 1), 0, 0, 3, 1, 0],
|
|
[&"service_corridor", 25, 0, Vector2i(1, 1), 0, 0, 2, 1, 0],
|
|
[&"adult_private_room", 1500, 14, Vector2i(2, 1), 1, 1, 2, 90, 250],
|
|
]
|
|
for raw_row: Variant in rows:
|
|
var row := raw_row as Array
|
|
var facility_id: StringName = row[0]
|
|
var definition: FacilityDefinition = registry.get_facility(facility_id)
|
|
_expect(definition != null, "%s canonical baseline is registered" % facility_id)
|
|
if definition == null:
|
|
continue
|
|
_expect(
|
|
definition.construction_cost == {&"gold": row[1], &"materials": row[2]},
|
|
"%s uses canonical Gold and Materials cost" % facility_id
|
|
)
|
|
_expect(definition.footprint == row[3], "%s uses canonical footprint" % facility_id)
|
|
_expect(
|
|
definition.staff_min == row[4] and definition.staff_max == row[5],
|
|
"%s uses canonical Min/Max staffing" % facility_id
|
|
)
|
|
_expect(definition.capacity == row[6], "%s uses canonical capacity" % facility_id)
|
|
_expect(definition.base_service_minutes == row[7], "%s uses canonical duration or one-minute proxy" % facility_id)
|
|
_expect(definition.base_price == row[8], "%s uses canonical direct price" % facility_id)
|
|
_expect(definition.is_valid(), "%s passes the FacilityDefinition schema" % facility_id)
|
|
|
|
var kitchen: FacilityDefinition = registry.get_facility(&"kitchen")
|
|
_expect(kitchen.inventory_outputs.get(&"ingredient/basic_meal", 0) == 4, "kitchen models the canonical four-meal production batch")
|
|
var restricted: FacilityDefinition = registry.get_facility(&"adult_private_room")
|
|
_expect(restricted.zone == FacilityDefinition.MapZone.UNDERGROUND, "restricted private room is constrained to the underground zone")
|
|
_expect(&"adult_only" in restricted.tags, "restricted private room carries an explicit adult-only systems guard tag")
|
|
|
|
|
|
func _test_queries() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
registry.rebuild()
|
|
var service_facilities: Array[StringName] = [
|
|
&"adult_private_room", &"massage_room", &"public_bath", &"reception", &"tavern",
|
|
]
|
|
var any_zone: Array[StringName] = [
|
|
&"cafeteria",
|
|
&"guest_corridor",
|
|
&"guest_elevator",
|
|
&"kitchen",
|
|
&"massage_room",
|
|
&"public_bath",
|
|
&"security_station",
|
|
&"service_corridor",
|
|
&"service_elevator",
|
|
&"staff_door",
|
|
&"staff_waiting_room",
|
|
&"standard_room",
|
|
&"tavern",
|
|
&"warehouse",
|
|
]
|
|
var back_facilities: Array[StringName] = [
|
|
&"kitchen",
|
|
&"security_station",
|
|
&"service_corridor",
|
|
&"service_elevator",
|
|
&"staff_door",
|
|
&"staff_waiting_room",
|
|
&"warehouse",
|
|
]
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_tag(&"service")) == service_facilities,
|
|
"service tag query returns every matching definition in stable order"
|
|
)
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_zone(FacilityDefinition.MapZone.ANY)) == any_zone,
|
|
"zone query preserves ID order"
|
|
)
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_zone(FacilityDefinition.MapZone.UNDERGROUND)) == [&"adult_private_room"],
|
|
"underground query isolates its restricted baseline"
|
|
)
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_layer(FacilityDefinition.ViewLayer.BACK)) == back_facilities,
|
|
"BACK layer query returns all logistics and staff definitions"
|
|
)
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_tag(&"corridor")) == [&"guest_corridor", &"service_corridor"],
|
|
"corridor tag identifies both route-subslot proxies"
|
|
)
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_tag(&"vertical_connector")) == [&"guest_elevator", &"service_elevator"],
|
|
"vertical connector tag identifies both elevators"
|
|
)
|
|
_expect(
|
|
_ids_of(registry.query_facilities_by_tag(&"cross_layer_connector")) == [&"staff_door"],
|
|
"cross-layer connector query identifies the staff door proxy"
|
|
)
|
|
|
|
|
|
func _test_duplicate_detection_is_deterministic() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
var duplicate_paths: Array[String] = [
|
|
"res://data/facilities/reception.tres",
|
|
"res://data/facilities/reception.tres",
|
|
]
|
|
var first_report: Dictionary = registry.rebuild_from_paths(duplicate_paths)
|
|
var first_errors: Array[Dictionary] = registry.get_fatal_errors()
|
|
var second_report: Dictionary = registry.rebuild_from_paths(duplicate_paths)
|
|
_expect(not bool(first_report[&"valid"]), "duplicate IDs make the registry invalid")
|
|
_expect(int(first_report[&"error_count"]) == 2, "every duplicate source receives a fatal issue")
|
|
_expect(registry.facility_count() == 0, "duplicate definitions are excluded from lookup")
|
|
_expect(first_errors == registry.get_fatal_errors(), "issue order is deterministic across rebuilds")
|
|
_expect(first_report[&"errors"][0][&"code"] == &"duplicate_id", "duplicate issue has a stable code")
|
|
_expect(int(second_report[&"warning_count"]) == 1, "duplicate source paths produce a warning")
|
|
|
|
|
|
func _test_missing_path_is_structured() -> void:
|
|
var registry = DefinitionRegistryScript.new()
|
|
var paths: Array[String] = ["res://data/facilities/does_not_exist.tres"]
|
|
registry.rebuild_from_paths(paths)
|
|
var errors: Array[Dictionary] = registry.get_fatal_errors()
|
|
_expect(errors.size() == 1, "missing path produces one fatal issue")
|
|
_expect(errors[0][&"severity"] == &"error", "issue carries severity")
|
|
_expect(errors[0][&"code"] == &"resource_not_found", "missing path has a stable code")
|
|
_expect(errors[0][&"field"] == &"resource_path", "issue identifies its field")
|
|
_expect(errors[0][&"resource_path"] == paths[0], "issue identifies its source")
|
|
|
|
|
|
func _ids_of(definitions: Array[FacilityDefinition]) -> Array[StringName]:
|
|
var result: Array[StringName] = []
|
|
for definition in definitions:
|
|
result.append(definition.id)
|
|
return result
|
|
|
|
|
|
func _expect(condition: bool, label: String) -> void:
|
|
_checks += 1
|
|
if condition:
|
|
print(" ✓ %s" % label)
|
|
return
|
|
_failures += 1
|
|
push_error(" ✗ %s" % label)
|