227 lines
7.2 KiB
GDScript
227 lines
7.2 KiB
GDScript
class_name AuthorityIncident
|
|
extends RefCounted
|
|
|
|
enum State {
|
|
OPEN,
|
|
RESOLVED,
|
|
DISMISSED,
|
|
}
|
|
|
|
var incident_id: StringName = &""
|
|
var incident_type: StringName = &""
|
|
var created_at := 0
|
|
var location_cell := Vector3i.ZERO
|
|
var facility_id: StringName = &""
|
|
var actor_ids: Array[StringName] = []
|
|
var severity := 0
|
|
var heat_delta := 0
|
|
var detector_ids: Array[StringName] = []
|
|
var evidence_ids: Array[StringName] = []
|
|
var state: State = State.OPEN
|
|
var resolution_id: StringName = &""
|
|
var state_reason: StringName = &""
|
|
var revision := 0
|
|
|
|
|
|
func configure(
|
|
p_incident_id: StringName,
|
|
p_incident_type: StringName,
|
|
p_created_at: int,
|
|
options: Dictionary = {}
|
|
) -> AuthorityIncident:
|
|
incident_id = p_incident_id
|
|
incident_type = p_incident_type
|
|
created_at = maxi(p_created_at, 0)
|
|
location_cell = _vector3i(_value(options, &"location_cell", Vector3i.ZERO))
|
|
facility_id = StringName(_value(options, &"facility_id", &""))
|
|
actor_ids = _sorted_unique_names(_value(options, &"actor_ids", []))
|
|
severity = clampi(int(_value(options, &"severity", 0)), 0, 100)
|
|
heat_delta = clampi(int(_value(options, &"heat_delta", severity / 5)), 0, 100)
|
|
detector_ids = _sorted_unique_names(_value(options, &"detector_ids", []))
|
|
evidence_ids = _sorted_unique_names(_value(options, &"evidence_ids", []))
|
|
state = _state_from_value(_value(options, &"state", State.OPEN))
|
|
resolution_id = StringName(_value(options, &"resolution_id", &""))
|
|
state_reason = StringName(_value(options, &"state_reason", &""))
|
|
revision = maxi(int(_value(options, &"revision", 0)), 0)
|
|
return self
|
|
|
|
|
|
func add_detector(detector_id: StringName) -> bool:
|
|
if detector_id.is_empty() or detector_ids.has(detector_id):
|
|
return false
|
|
detector_ids.append(detector_id)
|
|
detector_ids.sort_custom(_name_less)
|
|
revision += 1
|
|
return true
|
|
|
|
|
|
func add_evidence(evidence_id: StringName) -> bool:
|
|
if evidence_id.is_empty() or evidence_ids.has(evidence_id):
|
|
return false
|
|
evidence_ids.append(evidence_id)
|
|
evidence_ids.sort_custom(_name_less)
|
|
revision += 1
|
|
return true
|
|
|
|
|
|
func resolve(p_resolution_id: StringName, reason: StringName = &"") -> bool:
|
|
if state != State.OPEN or p_resolution_id.is_empty():
|
|
return false
|
|
state = State.RESOLVED
|
|
resolution_id = p_resolution_id
|
|
state_reason = reason
|
|
revision += 1
|
|
return true
|
|
|
|
|
|
func dismiss(reason: StringName) -> bool:
|
|
if state != State.OPEN:
|
|
return false
|
|
state = State.DISMISSED
|
|
state_reason = reason
|
|
revision += 1
|
|
return true
|
|
|
|
|
|
func is_valid() -> bool:
|
|
if incident_id.is_empty() or incident_type.is_empty() or created_at < 0:
|
|
return false
|
|
if severity < 0 or severity > 100 or heat_delta < 0 or heat_delta > 100 or revision < 0:
|
|
return false
|
|
if actor_ids != _sorted_unique_names(actor_ids):
|
|
return false
|
|
if detector_ids != _sorted_unique_names(detector_ids):
|
|
return false
|
|
if evidence_ids != _sorted_unique_names(evidence_ids):
|
|
return false
|
|
if state == State.RESOLVED and resolution_id.is_empty():
|
|
return false
|
|
if state != State.RESOLVED and not resolution_id.is_empty():
|
|
return false
|
|
return true
|
|
|
|
|
|
func create_snapshot() -> Dictionary:
|
|
return {
|
|
&"incident_id": String(incident_id),
|
|
&"incident_type": String(incident_type),
|
|
&"created_at": created_at,
|
|
&"location_cell": [location_cell.x, location_cell.y, location_cell.z],
|
|
&"facility_id": String(facility_id),
|
|
&"actor_ids": _names_to_strings(actor_ids),
|
|
&"severity": severity,
|
|
&"heat_delta": heat_delta,
|
|
&"detector_ids": _names_to_strings(detector_ids),
|
|
&"evidence_ids": _names_to_strings(evidence_ids),
|
|
&"state": State.keys()[state],
|
|
&"resolution_id": String(resolution_id),
|
|
&"state_reason": String(state_reason),
|
|
&"revision": revision,
|
|
}
|
|
|
|
|
|
static func from_snapshot(snapshot: Dictionary) -> AuthorityIncident:
|
|
if not _snapshot_is_valid(snapshot):
|
|
return null
|
|
var incident := AuthorityIncident.new().configure(
|
|
StringName(_value(snapshot, &"incident_id", &"")),
|
|
StringName(_value(snapshot, &"incident_type", &"")),
|
|
int(_value(snapshot, &"created_at", -1)),
|
|
snapshot
|
|
)
|
|
return incident if incident.is_valid() else null
|
|
|
|
|
|
static func _snapshot_is_valid(snapshot: Dictionary) -> bool:
|
|
for key: StringName in [
|
|
&"incident_id", &"incident_type", &"created_at", &"location_cell",
|
|
&"facility_id", &"actor_ids", &"severity", &"heat_delta",
|
|
&"detector_ids", &"evidence_ids", &"state", &"resolution_id",
|
|
&"state_reason", &"revision",
|
|
]:
|
|
if not _has_key(snapshot, key):
|
|
return false
|
|
if StringName(_value(snapshot, &"incident_id", &"")).is_empty() \
|
|
or StringName(_value(snapshot, &"incident_type", &"")).is_empty():
|
|
return false
|
|
if not _value(snapshot, &"location_cell", null) is Array \
|
|
or (_value(snapshot, &"location_cell", []) as Array).size() != 3:
|
|
return false
|
|
if not _value(snapshot, &"actor_ids", null) is Array \
|
|
or not _value(snapshot, &"detector_ids", null) is Array \
|
|
or not _value(snapshot, &"evidence_ids", null) is Array:
|
|
return false
|
|
if not _name_array_is_canonical(_value(snapshot, &"actor_ids", [])) \
|
|
or not _name_array_is_canonical(_value(snapshot, &"detector_ids", [])) \
|
|
or not _name_array_is_canonical(_value(snapshot, &"evidence_ids", [])):
|
|
return false
|
|
var severity_value := int(_value(snapshot, &"severity", -1))
|
|
var heat_value := int(_value(snapshot, &"heat_delta", -1))
|
|
if int(_value(snapshot, &"created_at", -1)) < 0 or severity_value < 0 or severity_value > 100:
|
|
return false
|
|
if heat_value < 0 or heat_value > 100 or int(_value(snapshot, &"revision", -1)) < 0:
|
|
return false
|
|
return State.keys().has(String(_value(snapshot, &"state", "")))
|
|
|
|
|
|
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.OPEN
|
|
var number := int(value)
|
|
return (number as State) if number >= 0 and number < State.size() else State.OPEN
|
|
|
|
|
|
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 _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
|