Preserve approved pixel tower prototype as development baseline

2026-09-09 07:51:16 +09:00
commit 423fd6dd2e
915 changed files with 95193 additions and 0 deletions
@@ -0,0 +1,390 @@
+class_name AuthorityInspection
+extends RefCounted
+
+enum State {
+	SCHEDULED,
+	ARRIVING,
+	CHECK_IN,
+	PATROLLING,
+	REVIEWING,
+	RESOLVING,
+	DEPARTING,
+	CLOSED,
+	BLOCKED_ENTRY,
+	INTERRUPTED,
+	HOSTILE,
+	CANCELLED,
+}
+
+enum Result {
+	PENDING,
+	NO_ACTION,
+	WARNING,
+	FINE,
+	TEMPORARY_CLOSURE,
+	CONFISCATION,
+	ARREST_ATTEMPT,
+	RAID_ESCALATION,
+}
+
+var inspection_id: StringName = &""
+var inspector_id: StringName = &""
+var scheduled_at := 0
+var entrance_cell := Vector3i.ZERO
+var state: State = State.SCHEDULED
+var state_changed_at := 0
+var time_budget_minutes := 120
+var time_spent_minutes := 0
+var waypoint_route: Array[Dictionary] = []
+var current_waypoint_index := 0
+var visited_waypoint_ids: Array[StringName] = []
+var inaccessible_waypoint_ids: Array[StringName] = []
+var discovered_evidence_ids: Array[StringName] = []
+var evidence_score := 0
+var result: Result = Result.PENDING
+var result_reason: StringName = &""
+var exit_reason: StringName = &""
+var resolution_id: StringName = &""
+var closed_at := -1
+var revision := 0
+
+
+func configure(
+	p_inspection_id: StringName,
+	p_inspector_id: StringName,
+	p_scheduled_at: int,
+	options: Dictionary = {}
+) -> AuthorityInspection:
+	inspection_id = p_inspection_id
+	inspector_id = p_inspector_id
+	scheduled_at = maxi(p_scheduled_at, 0)
+	entrance_cell = _vector3i(_value(options, &"entrance_cell", Vector3i.ZERO))
+	state = _state_from_value(_value(options, &"state", State.SCHEDULED))
+	state_changed_at = maxi(int(_value(options, &"state_changed_at", scheduled_at)), 0)
+	time_budget_minutes = maxi(int(_value(options, &"time_budget_minutes", 120)), 1)
+	time_spent_minutes = maxi(int(_value(options, &"time_spent_minutes", 0)), 0)
+	waypoint_route.clear()
+	var raw_route: Variant = _value(options, &"waypoint_route", [])
+	if raw_route is Array:
+		for raw_waypoint: Variant in raw_route:
+			if raw_waypoint is Dictionary:
+				var normalized := normalize_waypoint(raw_waypoint)
+				if not normalized.is_empty():
+					waypoint_route.append(normalized)
+	current_waypoint_index = maxi(int(_value(options, &"current_waypoint_index", 0)), 0)
+	visited_waypoint_ids = _sorted_unique_names(_value(options, &"visited_waypoint_ids", []))
+	inaccessible_waypoint_ids = _sorted_unique_names(_value(options, &"inaccessible_waypoint_ids", []))
+	discovered_evidence_ids = _sorted_unique_names(_value(options, &"discovered_evidence_ids", []))
+	evidence_score = maxi(int(_value(options, &"evidence_score", 0)), 0)
+	result = _result_from_value(_value(options, &"result", Result.PENDING))
+	result_reason = StringName(_value(options, &"result_reason", &""))
+	exit_reason = StringName(_value(options, &"exit_reason", &""))
+	resolution_id = StringName(_value(options, &"resolution_id", &""))
+	closed_at = int(_value(options, &"closed_at", -1))
+	revision = maxi(int(_value(options, &"revision", 0)), 0)
+	return self
+
+
+func set_state(new_state: State, absolute_minute: int, reason: StringName = &"") -> bool:
+	if absolute_minute < state_changed_at or state == new_state:
+		return false
+	state = new_state
+	state_changed_at = absolute_minute
+	if new_state == State.CLOSED:
+		closed_at = absolute_minute
+	if not reason.is_empty():
+		result_reason = reason
+	revision += 1
+	return true
+
+
+func add_visited_waypoint(waypoint_id: StringName, travel_minutes: int) -> bool:
+	if waypoint_id.is_empty() or visited_waypoint_ids.has(waypoint_id):
+		return false
+	visited_waypoint_ids.append(waypoint_id)
+	visited_waypoint_ids.sort_custom(_name_less)
+	time_spent_minutes += maxi(travel_minutes, 0)
+	current_waypoint_index += 1
+	revision += 1
+	return true
+
+
+func add_inaccessible_waypoint(waypoint_id: StringName) -> bool:
+	if waypoint_id.is_empty() or inaccessible_waypoint_ids.has(waypoint_id):
+		return false
+	inaccessible_waypoint_ids.append(waypoint_id)
+	inaccessible_waypoint_ids.sort_custom(_name_less)
+	revision += 1
+	return true
+
+
+func add_discovered_evidence(evidence_id: StringName) -> bool:
+	if evidence_id.is_empty() or discovered_evidence_ids.has(evidence_id):
+		return false
+	discovered_evidence_ids.append(evidence_id)
+	discovered_evidence_ids.sort_custom(_name_less)
+	revision += 1
+	return true
+
+
+func is_terminal() -> bool:
+	return state in [State.CLOSED, State.CANCELLED]
+
+
+func is_valid() -> bool:
+	if inspection_id.is_empty() or inspector_id.is_empty() or scheduled_at < 0:
+		return false
+	if state_changed_at < scheduled_at or time_budget_minutes <= 0 or time_spent_minutes < 0:
+		return false
+	if current_waypoint_index < 0 or current_waypoint_index > waypoint_route.size():
+		return false
+	if evidence_score < 0 or closed_at < -1 or revision < 0:
+		return false
+	if visited_waypoint_ids != _sorted_unique_names(visited_waypoint_ids):
+		return false
+	if inaccessible_waypoint_ids != _sorted_unique_names(inaccessible_waypoint_ids):
+		return false
+	if discovered_evidence_ids != _sorted_unique_names(discovered_evidence_ids):
+		return false
+	var waypoint_ids: Dictionary = {}
+	var previous_waypoint: Dictionary = {}
+	for waypoint: Dictionary in waypoint_route:
+		var normalized := normalize_waypoint(waypoint)
+		if normalized.is_empty():
+			return false
+		var waypoint_id: StringName = normalized[&"waypoint_id"]
+		if waypoint_ids.has(waypoint_id):
+			return false
+		if not previous_waypoint.is_empty():
+			var previous_utility := int(previous_waypoint[&"utility"])
+			var current_utility := int(normalized[&"utility"])
+			if current_utility > previous_utility:
+				return false
+			if current_utility == previous_utility \
+				and String(normalized[&"waypoint_id"]) < String(previous_waypoint[&"waypoint_id"]):
+				return false
+		waypoint_ids[waypoint_id] = true
+		previous_waypoint = normalized
+	if current_waypoint_index != visited_waypoint_ids.size():
+		return false
+	for route_index: int in range(current_waypoint_index):
+		if not visited_waypoint_ids.has(StringName(waypoint_route[route_index][&"waypoint_id"])):
+			return false
+	for waypoint_id: StringName in visited_waypoint_ids:
+		if not waypoint_ids.has(waypoint_id):
+			return false
+	for waypoint_id: StringName in inaccessible_waypoint_ids:
+		if not waypoint_ids.has(waypoint_id):
+			return false
+	if result == Result.PENDING and not resolution_id.is_empty():
+		return false
+	if result != Result.PENDING and resolution_id.is_empty():
+		return false
+	if state == State.CLOSED and closed_at < state_changed_at:
+		return false
+	if state != State.CLOSED and closed_at >= 0:
+		return false
+	return true
+
+
+func create_snapshot() -> Dictionary:
+	var saved_route: Array[Dictionary] = []
+	for waypoint: Dictionary in waypoint_route:
+		saved_route.append({
+			&"waypoint_id": String(waypoint[&"waypoint_id"]),
+			&"cell": _cell_to_array(waypoint[&"cell"]),
+			&"suspect_score": int(waypoint[&"suspect_score"]),
+			&"evidence_potential": int(waypoint[&"evidence_potential"]),
+			&"travel_minutes": int(waypoint[&"travel_minutes"]),
+			&"inspection_minutes": int(waypoint[&"inspection_minutes"]),
+			&"time_budget_penalty": int(waypoint[&"time_budget_penalty"]),
+			&"utility": int(waypoint[&"utility"]),
+		})
+	return {
+		&"inspection_id": String(inspection_id),
+		&"inspector_id": String(inspector_id),
+		&"scheduled_at": scheduled_at,
+		&"entrance_cell": [entrance_cell.x, entrance_cell.y, entrance_cell.z],
+		&"state": State.keys()[state],
+		&"state_changed_at": state_changed_at,
+		&"time_budget_minutes": time_budget_minutes,
+		&"time_spent_minutes": time_spent_minutes,
+		&"waypoint_route": saved_route,
+		&"current_waypoint_index": current_waypoint_index,
+		&"visited_waypoint_ids": _names_to_strings(visited_waypoint_ids),
+		&"inaccessible_waypoint_ids": _names_to_strings(inaccessible_waypoint_ids),
+		&"discovered_evidence_ids": _names_to_strings(discovered_evidence_ids),
+		&"evidence_score": evidence_score,
+		&"result": Result.keys()[result],
+		&"result_reason": String(result_reason),
+		&"exit_reason": String(exit_reason),
+		&"resolution_id": String(resolution_id),
+		&"closed_at": closed_at,
+		&"revision": revision,
+	}
+
+
+static func from_snapshot(snapshot: Dictionary) -> AuthorityInspection:
+	if not _snapshot_is_valid(snapshot):
+		return null
+	var inspection := AuthorityInspection.new().configure(
+		StringName(_value(snapshot, &"inspection_id", &"")),
+		StringName(_value(snapshot, &"inspector_id", &"")),
+		int(_value(snapshot, &"scheduled_at", -1)),
+		snapshot
+	)
+	return inspection if inspection.is_valid() else null
+
+
+static func _snapshot_is_valid(snapshot: Dictionary) -> bool:
+	for key: StringName in [
+		&"inspection_id", &"inspector_id", &"scheduled_at", &"entrance_cell",
+		&"state", &"state_changed_at", &"time_budget_minutes", &"time_spent_minutes",
+		&"waypoint_route", &"current_waypoint_index", &"visited_waypoint_ids",
+		&"inaccessible_waypoint_ids", &"discovered_evidence_ids", &"evidence_score",
+		&"result", &"result_reason", &"exit_reason", &"resolution_id",
+		&"closed_at", &"revision",
+	]:
+		if not _has_key(snapshot, key):
+			return false
+	if StringName(_value(snapshot, &"inspection_id", &"")).is_empty() \
+		or StringName(_value(snapshot, &"inspector_id", &"")).is_empty():
+		return false
+	if not _value(snapshot, &"entrance_cell", null) is Array \
+		or (_value(snapshot, &"entrance_cell", []) as Array).size() != 3:
+		return false
+	for array_key: StringName in [
+		&"waypoint_route", &"visited_waypoint_ids", &"inaccessible_waypoint_ids",
+		&"discovered_evidence_ids",
+	]:
+		if not _value(snapshot, array_key, null) is Array:
+			return false
+	for names_key: StringName in [
+		&"visited_waypoint_ids", &"inaccessible_waypoint_ids", &"discovered_evidence_ids",
+	]:
+		if not _name_array_is_canonical(_value(snapshot, names_key, [])):
+			return false
+	if not State.keys().has(String(_value(snapshot, &"state", ""))) \
+		or not Result.keys().has(String(_value(snapshot, &"result", ""))):
+		return false
+	if int(_value(snapshot, &"scheduled_at", -1)) < 0 \
+		or int(_value(snapshot, &"state_changed_at", -1)) < 0 \
+		or int(_value(snapshot, &"time_budget_minutes", 0)) <= 0 \
+		or int(_value(snapshot, &"time_spent_minutes", -1)) < 0 \
+		or int(_value(snapshot, &"current_waypoint_index", -1)) < 0 \
+		or int(_value(snapshot, &"evidence_score", -1)) < 0 \
+		or int(_value(snapshot, &"closed_at", -2)) < -1 \
+		or int(_value(snapshot, &"revision", -1)) < 0:
+		return false
+	for raw_waypoint: Variant in _value(snapshot, &"waypoint_route", []):
+		if not raw_waypoint is Dictionary:
+			return false
+		for waypoint_key: StringName in [
+			&"waypoint_id", &"cell", &"suspect_score", &"evidence_potential",
+			&"travel_minutes", &"inspection_minutes", &"time_budget_penalty", &"utility",
+		]:
+			if not _has_key(raw_waypoint, waypoint_key):
+				return false
+		if not _value(raw_waypoint, &"cell", null) is Array \
+			or (_value(raw_waypoint, &"cell", []) as Array).size() != 3:
+			return false
+		var normalized := normalize_waypoint(raw_waypoint)
+		if normalized.is_empty() or int(_value(raw_waypoint, &"utility", 2_147_483_647)) != int(normalized[&"utility"]):
+			return false
+	return true
+
+
+static func normalize_waypoint(value: Dictionary) -> Dictionary:
+	var waypoint_id := StringName(_value(value, &"waypoint_id", &""))
+	if waypoint_id.is_empty():
+		return {}
+	var suspect_score := clampi(int(_value(value, &"suspect_score", 0)), 0, 100)
+	var evidence_potential := clampi(int(_value(value, &"evidence_potential", 0)), 0, 100)
+	var travel_minutes := maxi(int(_value(value, &"travel_minutes", 0)), 0)
+	var inspection_minutes := maxi(int(_value(value, &"inspection_minutes", 5)), 1)
+	var time_budget_penalty := maxi(int(_value(value, &"time_budget_penalty", 0)), 0)
+	return {
+		&"waypoint_id": waypoint_id,
+		&"cell": _vector3i(_value(value, &"cell", Vector3i.ZERO)),
+		&"suspect_score": suspect_score,
+		&"evidence_potential": evidence_potential,
+		&"travel_minutes": travel_minutes,
+		&"inspection_minutes": inspection_minutes,
+		&"time_budget_penalty": time_budget_penalty,
+		&"utility": suspect_score * 5 + evidence_potential * 4 - travel_minutes * 2 - time_budget_penalty,
+	}
+
+
+static func _state_from_value(value: Variant) -> State:
+	if value is String or value is StringName:
+		var index := State.keys().find(String(value))
+		return (index as State) if index >= 0 else State.SCHEDULED
+	var number := int(value)
+	return (number as State) if number >= 0 and number < State.size() else State.SCHEDULED
+
+
+static func _result_from_value(value: Variant) -> Result:
+	if value is String or value is StringName:
+		var index := Result.keys().find(String(value))
+		return (index as Result) if index >= 0 else Result.PENDING
+	var number := int(value)
+	return (number as Result) if number >= 0 and number < Result.size() else Result.PENDING
+
+
+static func _vector3i(value: Variant) -> Vector3i:
+	if value is Vector3i:
+		return value
+	if value is Array and value.size() >= 3:
+		return Vector3i(int(value[0]), int(value[1]), int(value[2]))
+	if value is Dictionary:
+		return Vector3i(int(value.get(&"x", 0)), int(value.get(&"y", 0)), int(value.get(&"z", 0)))
+	return Vector3i.ZERO
+
+
+static func _cell_to_array(value: Variant) -> Array[int]:
+	var cell := _vector3i(value)
+	return [cell.x, cell.y, cell.z]
+
+
+static func _sorted_unique_names(values: Variant) -> Array[StringName]:
+	var result: Array[StringName] = []
+	if values is Array:
+		for raw_value: Variant in values:
+			var value := StringName(raw_value)
+			if not value.is_empty() and not result.has(value):
+				result.append(value)
+	result.sort_custom(_name_less)
+	return result
+
+
+static func _names_to_strings(values: Array[StringName]) -> Array[String]:
+	var result: Array[String] = []
+	for value: StringName in values:
+		result.append(String(value))
+	return result
+
+
+static func _name_less(a: StringName, b: StringName) -> bool:
+	return String(a) < String(b)
+
+
+static func _value(source: Dictionary, key: StringName, fallback: Variant) -> Variant:
+	if source.has(key):
+		return source[key]
+	return source.get(String(key), fallback)
+
+
+static func _has_key(source: Dictionary, key: StringName) -> bool:
+	return source.has(key) or source.has(String(key))
+
+
+static func _name_array_is_canonical(value: Variant) -> bool:
+	if not value is Array:
+		return false
+	var previous := ""
+	for index: int in range(value.size()):
+		var current := String(value[index])
+		if current.is_empty() or (index > 0 and current <= previous):
+			return false
+		previous = current
+	return true