Rijad Zuzo
145 lines
3.9 KiB
GDScript
145 lines
3.9 KiB
GDScript
class_name RegionalStateSupport
|
|
extends RefCounted
|
|
|
|
|
|
static func normalize_id_array(values: Array, allow_empty: bool = true) -> Variant:
|
|
var seen: Dictionary = {}
|
|
var normalized: Array[String] = []
|
|
for value: Variant in values:
|
|
if not value is String and not value is StringName:
|
|
return null
|
|
var id := String(value)
|
|
if id.is_empty() or seen.has(id):
|
|
return null
|
|
seen[id] = true
|
|
normalized.append(id)
|
|
if not allow_empty and normalized.is_empty():
|
|
return null
|
|
normalized.sort()
|
|
return normalized
|
|
|
|
|
|
static func normalize_history_event_ids(values: Array) -> Variant:
|
|
var seen: Dictionary = {}
|
|
var normalized: Array[int] = []
|
|
for value: Variant in values:
|
|
if not value is int:
|
|
return null
|
|
var event_id := int(value)
|
|
if event_id < 0 or seen.has(event_id):
|
|
return null
|
|
seen[event_id] = true
|
|
normalized.append(event_id)
|
|
normalized.sort()
|
|
return normalized
|
|
|
|
|
|
static func normalize_amount_ledger(values: Dictionary) -> Variant:
|
|
var source_keys: Dictionary = {}
|
|
for raw_key: Variant in values:
|
|
if not raw_key is String and not raw_key is StringName:
|
|
return null
|
|
var key := String(raw_key)
|
|
if key.is_empty() or source_keys.has(key):
|
|
return null
|
|
var raw_amount: Variant = values[raw_key]
|
|
if not raw_amount is int and not raw_amount is float:
|
|
return null
|
|
var amount := float(raw_amount)
|
|
if not is_finite(amount) or amount < 0.0:
|
|
return null
|
|
source_keys[key] = raw_key
|
|
var keys: Array = source_keys.keys()
|
|
keys.sort()
|
|
var normalized: Dictionary = {}
|
|
for key: String in keys:
|
|
normalized[key] = float(values[source_keys[key]])
|
|
return normalized
|
|
|
|
|
|
static func normalize_count_ledger(values: Dictionary) -> Variant:
|
|
var source_keys: Dictionary = {}
|
|
for raw_key: Variant in values:
|
|
if not raw_key is String and not raw_key is StringName:
|
|
return null
|
|
var key := String(raw_key)
|
|
if key.is_empty() or source_keys.has(key):
|
|
return null
|
|
var raw_count: Variant = values[raw_key]
|
|
if not raw_count is int or int(raw_count) <= 0:
|
|
return null
|
|
source_keys[key] = raw_key
|
|
var keys: Array = source_keys.keys()
|
|
keys.sort()
|
|
var normalized: Dictionary = {}
|
|
for key: String in keys:
|
|
normalized[key] = int(values[source_keys[key]])
|
|
return normalized
|
|
|
|
|
|
static func amount_ledger_total(values: Dictionary) -> float:
|
|
var total := 0.0
|
|
for value: Variant in values.values():
|
|
total += float(value)
|
|
return total
|
|
|
|
|
|
static func normalize_address(value: Variant) -> Variant:
|
|
var address: SpatialAddress
|
|
if value is SpatialAddress:
|
|
address = value as SpatialAddress
|
|
elif value is Dictionary:
|
|
address = SpatialAddress.from_dictionary(value)
|
|
if address == null or not address.is_valid():
|
|
return null
|
|
return address.to_dictionary()
|
|
|
|
|
|
static func address_from_data(value: Variant) -> SpatialAddress:
|
|
if not value is Dictionary:
|
|
return null
|
|
return SpatialAddress.from_dictionary(value)
|
|
|
|
|
|
static func address_matches(
|
|
value: Variant, expected_world_id: StringName, expected_location_id: StringName
|
|
) -> bool:
|
|
var address := address_from_data(value)
|
|
return (
|
|
address != null
|
|
and address.get_world_id() == expected_world_id
|
|
and address.get_location_id() == expected_location_id
|
|
)
|
|
|
|
|
|
static func copy_string_array(values: Variant) -> Array[StringName]:
|
|
var copied: Array[StringName] = []
|
|
if not values is Array:
|
|
return copied
|
|
for value: Variant in values:
|
|
copied.append(StringName(value))
|
|
return copied
|
|
|
|
|
|
static func copy_int_array(values: Variant) -> Array[int]:
|
|
var copied: Array[int] = []
|
|
if not values is Array:
|
|
return copied
|
|
for value: Variant in values:
|
|
copied.append(int(value))
|
|
return copied
|
|
|
|
|
|
static func pair_key(first_id: StringName, second_id: StringName) -> String:
|
|
var first := String(first_id)
|
|
var second := String(second_id)
|
|
return "%s\u001f%s" % [first, second] if first < second else "%s\u001f%s" % [second, first]
|
|
|
|
|
|
static func is_non_empty_id(value: StringName) -> bool:
|
|
return not value.is_empty()
|
|
|
|
|
|
static func is_valid_tick(value: int, allow_unset: bool = false) -> bool:
|
|
return value >= (-1 if allow_unset else 0)
|