Rijad Zuzo
703 lines
21 KiB
GDScript
703 lines
21 KiB
GDScript
class_name RegionalCaravanService
|
|
extends RefCounted
|
|
|
|
const SCHEMA_VERSION := 1
|
|
const JOB_TYPE_ARRIVAL := &"caravan_arrival"
|
|
const JOB_PHASE_ARRIVAL := 10
|
|
const EVENT_CARGO_LOADED := &"caravan_cargo_loaded"
|
|
const EVENT_DEPARTED := &"caravan_departed"
|
|
const EVENT_ARRIVED := &"caravan_arrived"
|
|
const EVENT_CARGO_DEPOSITED := &"caravan_cargo_deposited"
|
|
const ENTITY_TYPE_SETTLEMENT := &"settlement"
|
|
const ENTITY_TYPE_MOBILE_GROUP := &"mobile_group"
|
|
const ENTITY_TYPE_ROUTE := &"route"
|
|
const ROLE_CARAVAN := &"caravan"
|
|
const ROLE_ROUTE := &"route"
|
|
const ROLE_ORIGIN := &"origin"
|
|
const ROLE_DESTINATION := &"destination"
|
|
|
|
var _world_state: RegionalWorldState
|
|
var _scheduler: RegionalJobScheduler
|
|
var _event_store: WorldEventStore
|
|
var _next_event_id := 0
|
|
var _job_handlers: Dictionary = {}
|
|
var _last_error := ""
|
|
|
|
|
|
func _init(
|
|
world_state: RegionalWorldState = null,
|
|
scheduler: RegionalJobScheduler = null,
|
|
event_store: WorldEventStore = null,
|
|
next_event_id: int = 0
|
|
) -> void:
|
|
_world_state = world_state
|
|
_scheduler = scheduler
|
|
_event_store = event_store
|
|
_next_event_id = next_event_id
|
|
_register_builtin_handlers()
|
|
|
|
|
|
static func create(
|
|
world_state: RegionalWorldState,
|
|
scheduler: RegionalJobScheduler,
|
|
event_store: WorldEventStore,
|
|
next_event_id: int = 0
|
|
) -> RegionalCaravanService:
|
|
var service := RegionalCaravanService.new(world_state, scheduler, event_store, next_event_id)
|
|
return service if service.is_valid() else null
|
|
|
|
|
|
static func from_dictionary(envelope: Dictionary) -> RegionalCaravanService:
|
|
if int(envelope.get("schema_version", -1)) != SCHEMA_VERSION:
|
|
return null
|
|
if not envelope.has_all(["next_event_id", "world_state", "scheduler", "event_store"]):
|
|
return null
|
|
if (
|
|
not envelope["next_event_id"] is int
|
|
or not envelope["world_state"] is Dictionary
|
|
or not envelope["scheduler"] is Dictionary
|
|
or not envelope["event_store"] is Dictionary
|
|
):
|
|
return null
|
|
var world_state := RegionalWorldState.from_dictionary(envelope["world_state"])
|
|
var scheduler := RegionalJobScheduler.from_dictionary(envelope["scheduler"])
|
|
var event_store := WorldEventStore.from_dictionary(envelope["event_store"])
|
|
if world_state == null or scheduler == null or event_store == null:
|
|
return null
|
|
return create(world_state, scheduler, event_store, int(envelope["next_event_id"]))
|
|
|
|
|
|
func is_valid() -> bool:
|
|
return (
|
|
_world_state != null
|
|
and _scheduler != null
|
|
and _event_store != null
|
|
and _event_cursor_is_valid()
|
|
and _job_handlers.has(JOB_TYPE_ARRIVAL)
|
|
and (_job_handlers[JOB_TYPE_ARRIVAL] as Callable).is_valid()
|
|
and _pending_arrival_jobs_are_valid()
|
|
)
|
|
|
|
|
|
func get_world_state() -> RegionalWorldState:
|
|
return _world_state
|
|
|
|
|
|
func get_scheduler() -> RegionalJobScheduler:
|
|
return _scheduler
|
|
|
|
|
|
func get_event_store() -> WorldEventStore:
|
|
return _event_store
|
|
|
|
|
|
func get_next_event_id() -> int:
|
|
return _next_event_id
|
|
|
|
|
|
func get_last_error() -> String:
|
|
return _last_error
|
|
|
|
|
|
func get_registered_job_types() -> Array[StringName]:
|
|
var job_types: Array[StringName] = []
|
|
for job_type: Variant in _job_handlers:
|
|
job_types.append(StringName(job_type))
|
|
job_types.sort_custom(
|
|
func(first: StringName, second: StringName) -> bool: return String(first) < String(second)
|
|
)
|
|
return job_types
|
|
|
|
|
|
func depart(
|
|
group_id: StringName,
|
|
origin_settlement_id: StringName,
|
|
destination_settlement_id: StringName,
|
|
route_id: StringName,
|
|
cargo_to_load: Dictionary,
|
|
departure_tick: int,
|
|
presentation_mode: StringName = &"never"
|
|
) -> bool:
|
|
_last_error = ""
|
|
var normalized_cargo: Variant = RegionalStateSupport.normalize_amount_ledger(cargo_to_load)
|
|
if (
|
|
departure_tick < 0
|
|
or normalized_cargo == null
|
|
or normalized_cargo.is_empty()
|
|
or not _all_amounts_positive(normalized_cargo)
|
|
):
|
|
return _fail("invalid cargo or departure tick")
|
|
var group := _world_state.get_mobile_group(group_id)
|
|
var origin := _world_state.get_settlement(origin_settlement_id)
|
|
var destination := _world_state.get_settlement(destination_settlement_id)
|
|
var route := _world_state.get_route(route_id)
|
|
if group == null or origin == null or destination == null or route == null:
|
|
return _fail("caravan departure references a missing regional record")
|
|
if origin.get_settlement_id() == destination.get_settlement_id():
|
|
return _fail("caravan origin and destination must differ")
|
|
if (
|
|
not group.is_at_location()
|
|
or group.get_current_location_id() != origin.get_location_id()
|
|
or not route.connects(origin.get_location_id(), destination.get_location_id())
|
|
):
|
|
return _fail("caravan is not at the route origin")
|
|
var next_origin_ledger: Variant = _subtract_ledgers(
|
|
origin.get_stockpile_ledger(), normalized_cargo
|
|
)
|
|
var next_group_ledger: Variant = _add_ledgers(group.get_cargo_ledger(), normalized_cargo)
|
|
if next_origin_ledger == null or next_group_ledger == null:
|
|
return _fail("origin stockpile cannot supply requested cargo")
|
|
if RegionalStateSupport.amount_ledger_total(next_group_ledger) > group.get_cargo_capacity():
|
|
return _fail("requested cargo exceeds caravan capacity")
|
|
var load_event_id := _next_event_id
|
|
var depart_event_id := load_event_id + 1
|
|
if _event_store.has_event(load_event_id) or _event_store.has_event(depart_event_id):
|
|
return _fail("next caravan event ID is already in use")
|
|
var arrival_tick := departure_tick + route.get_travel_ticks()
|
|
var job_id := _arrival_job_id(group_id, departure_tick)
|
|
var dedupe_key := _arrival_dedupe_key(group_id)
|
|
var event_payload := _journey_payload(
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
normalized_cargo,
|
|
departure_tick,
|
|
arrival_tick,
|
|
-1,
|
|
presentation_mode
|
|
)
|
|
var load_event := _create_event(
|
|
load_event_id,
|
|
EVENT_CARGO_LOADED,
|
|
departure_tick,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
origin.get_location_id(),
|
|
event_payload
|
|
)
|
|
var depart_payload := event_payload.duplicate(true)
|
|
depart_payload["cause_event_id"] = load_event_id
|
|
var depart_event := _create_event(
|
|
depart_event_id,
|
|
EVENT_DEPARTED,
|
|
departure_tick,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
origin.get_location_id(),
|
|
depart_payload
|
|
)
|
|
var next_origin := origin.with_stockpile_ledger(next_origin_ledger, load_event_id)
|
|
var loaded_group := group.with_cargo_ledger(next_group_ledger, load_event_id)
|
|
var journey_group := (
|
|
loaded_group.with_route_journey(
|
|
route_id,
|
|
origin.get_location_id(),
|
|
destination.get_location_id(),
|
|
departure_tick,
|
|
arrival_tick,
|
|
depart_event_id
|
|
)
|
|
if loaded_group != null
|
|
else null
|
|
)
|
|
var job_payload := {
|
|
"group_id": String(group_id),
|
|
"origin_settlement_id": String(origin_settlement_id),
|
|
"destination_settlement_id": String(destination_settlement_id),
|
|
"route_id": String(route_id),
|
|
"departure_tick": departure_tick,
|
|
"arrival_tick": arrival_tick,
|
|
"depart_event_id": depart_event_id,
|
|
"cargo_ledger": normalized_cargo,
|
|
}
|
|
if load_event == null or depart_event == null or next_origin == null or journey_group == null:
|
|
return _fail("caravan departure could not build valid replacement records")
|
|
var snapshot := _snapshot()
|
|
if (
|
|
_scheduler.schedule_new(
|
|
job_id,
|
|
JOB_TYPE_ARRIVAL,
|
|
arrival_tick,
|
|
JOB_PHASE_ARRIVAL,
|
|
group_id,
|
|
job_payload,
|
|
dedupe_key
|
|
)
|
|
== null
|
|
):
|
|
return _fail("arrival job conflicts with an existing job")
|
|
if not _world_state.replace_settlement_and_mobile_group(next_origin, journey_group):
|
|
_restore_snapshot(snapshot)
|
|
return _fail("caravan departure state transaction failed")
|
|
if not _event_store.append(load_event) or not _event_store.append(depart_event):
|
|
_restore_snapshot(snapshot)
|
|
return _fail("caravan departure event transaction failed")
|
|
_next_event_id += 2
|
|
return true
|
|
|
|
|
|
func process_due(
|
|
current_tick: int,
|
|
execution_budget: int = RegionalJobScheduler.UNLIMITED_BUDGET,
|
|
presentation_mode: StringName = &"never"
|
|
) -> Array[ScheduledJobRecord]:
|
|
_last_error = ""
|
|
var executed: Array[ScheduledJobRecord] = []
|
|
if execution_budget < RegionalJobScheduler.UNLIMITED_BUDGET:
|
|
_fail("invalid regional execution budget")
|
|
return executed
|
|
var remaining := execution_budget
|
|
while remaining != 0:
|
|
var scheduler_snapshot := _scheduler.to_dictionary()
|
|
var batch := _scheduler.take_due(current_tick, 1)
|
|
if batch.is_empty():
|
|
break
|
|
var job := batch[0]
|
|
var handler := _job_handlers.get(job.get_job_type()) as Callable
|
|
if (
|
|
handler == null
|
|
or not handler.is_valid()
|
|
or not bool(handler.call(job, presentation_mode))
|
|
):
|
|
_scheduler.restore_from_dictionary(scheduler_snapshot)
|
|
_fail("scheduled regional job '%s' failed atomically" % job.get_job_id())
|
|
break
|
|
executed.append(job)
|
|
if remaining > 0:
|
|
remaining -= 1
|
|
return executed
|
|
|
|
|
|
func to_dictionary() -> Dictionary:
|
|
return {
|
|
"schema_version": SCHEMA_VERSION,
|
|
"next_event_id": _next_event_id,
|
|
"world_state": _world_state.to_dictionary(),
|
|
"scheduler": _scheduler.to_dictionary(),
|
|
"event_store": _event_store.to_dictionary(),
|
|
}
|
|
|
|
|
|
func checksum() -> String:
|
|
return JSON.stringify(to_dictionary()).sha256_text()
|
|
|
|
|
|
func _register_builtin_handlers() -> void:
|
|
_job_handlers.clear()
|
|
_register_handler(JOB_TYPE_ARRIVAL, _handle_arrival)
|
|
|
|
|
|
func _register_handler(job_type: StringName, handler: Callable) -> bool:
|
|
if job_type.is_empty() or not handler.is_valid() or _job_handlers.has(job_type):
|
|
return false
|
|
_job_handlers[job_type] = handler
|
|
return true
|
|
|
|
|
|
func _pending_arrival_jobs_are_valid() -> bool:
|
|
for job: ScheduledJobRecord in _scheduler.get_all_sorted():
|
|
if job.get_job_type() == JOB_TYPE_ARRIVAL and _validated_arrival_context(job).is_empty():
|
|
return false
|
|
return true
|
|
|
|
|
|
func _validated_arrival_context(job: ScheduledJobRecord) -> Dictionary:
|
|
if (
|
|
job == null
|
|
or job.get_job_type() != JOB_TYPE_ARRIVAL
|
|
or job.get_due_tick() < 0
|
|
or job.get_phase() != JOB_PHASE_ARRIVAL
|
|
or job.get_repeat_interval() != ScheduledJobRecord.NO_REPEAT
|
|
or job.get_occurrence() != 0
|
|
):
|
|
return {}
|
|
var payload := job.get_payload()
|
|
if not (
|
|
payload
|
|
. has_all(
|
|
[
|
|
"group_id",
|
|
"origin_settlement_id",
|
|
"destination_settlement_id",
|
|
"route_id",
|
|
"departure_tick",
|
|
"arrival_tick",
|
|
"depart_event_id",
|
|
"cargo_ledger",
|
|
]
|
|
)
|
|
):
|
|
return {}
|
|
if (
|
|
not payload["group_id"] is String
|
|
or not payload["origin_settlement_id"] is String
|
|
or not payload["destination_settlement_id"] is String
|
|
or not payload["route_id"] is String
|
|
or not payload["departure_tick"] is int
|
|
or not payload["arrival_tick"] is int
|
|
or not payload["depart_event_id"] is int
|
|
or not payload["cargo_ledger"] is Dictionary
|
|
):
|
|
return {}
|
|
var normalized_cargo: Variant = RegionalStateSupport.normalize_amount_ledger(
|
|
payload["cargo_ledger"]
|
|
)
|
|
var group := _world_state.get_mobile_group(StringName(payload["group_id"]))
|
|
var origin := _world_state.get_settlement(StringName(payload["origin_settlement_id"]))
|
|
var destination := _world_state.get_settlement(StringName(payload["destination_settlement_id"]))
|
|
var route := _world_state.get_route(StringName(payload["route_id"]))
|
|
var departure_tick := int(payload["departure_tick"])
|
|
var arrival_tick := int(payload["arrival_tick"])
|
|
var depart_event_id := int(payload["depart_event_id"])
|
|
if (
|
|
normalized_cargo == null
|
|
or not _all_amounts_positive(normalized_cargo)
|
|
or group == null
|
|
or origin == null
|
|
or destination == null
|
|
or route == null
|
|
or job.get_entity_id() != group.get_group_id()
|
|
or job.get_job_id() != _arrival_job_id(group.get_group_id(), departure_tick)
|
|
or job.get_dedupe_key() != _arrival_dedupe_key(group.get_group_id())
|
|
or job.get_due_tick() != arrival_tick
|
|
or not group.is_on_route()
|
|
or group.get_route_id() != route.get_route_id()
|
|
or group.get_departure_location_id() != origin.get_location_id()
|
|
or group.get_arrival_location_id() != destination.get_location_id()
|
|
or group.get_departure_tick() != departure_tick
|
|
or group.get_arrival_tick() != arrival_tick
|
|
or not route.connects(origin.get_location_id(), destination.get_location_id())
|
|
or arrival_tick - departure_tick != route.get_travel_ticks()
|
|
or not _departure_facts_match(
|
|
depart_event_id,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
normalized_cargo,
|
|
departure_tick,
|
|
arrival_tick
|
|
)
|
|
or group.get_last_cargo_event_id() != depart_event_id - 1
|
|
or depart_event_id not in group.get_history_event_ids()
|
|
or depart_event_id - 1 not in group.get_history_event_ids()
|
|
or depart_event_id - 1 not in origin.get_history_event_ids()
|
|
):
|
|
return {}
|
|
for cargo_key: Variant in normalized_cargo:
|
|
if group.get_cargo_amount(StringName(cargo_key)) < float(normalized_cargo[cargo_key]):
|
|
return {}
|
|
return {
|
|
"group": group,
|
|
"origin": origin,
|
|
"destination": destination,
|
|
"route": route,
|
|
"cargo_ledger": normalized_cargo,
|
|
"departure_tick": departure_tick,
|
|
"arrival_tick": arrival_tick,
|
|
"depart_event_id": depart_event_id,
|
|
}
|
|
|
|
|
|
func _handle_arrival(job: ScheduledJobRecord, _presentation_mode: StringName) -> bool:
|
|
var context := _validated_arrival_context(job)
|
|
if context.is_empty():
|
|
return false
|
|
var group := context["group"] as MobileGroupStateRecord
|
|
var origin := context["origin"] as SettlementStateRecord
|
|
var destination := context["destination"] as SettlementStateRecord
|
|
var route := context["route"] as RouteStateRecord
|
|
var normalized_cargo: Dictionary = context["cargo_ledger"]
|
|
var departure_tick := int(context["departure_tick"])
|
|
var arrival_tick := int(context["arrival_tick"])
|
|
var depart_event_id := int(context["depart_event_id"])
|
|
var arrive_event_id := _next_event_id
|
|
var deposit_event_id := arrive_event_id + 1
|
|
if _event_store.has_event(arrive_event_id) or _event_store.has_event(deposit_event_id):
|
|
return false
|
|
var arrival_payload := _journey_payload(
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
normalized_cargo,
|
|
departure_tick,
|
|
arrival_tick,
|
|
depart_event_id,
|
|
&""
|
|
)
|
|
var arrive_event := _create_event(
|
|
arrive_event_id,
|
|
EVENT_ARRIVED,
|
|
arrival_tick,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
destination.get_location_id(),
|
|
arrival_payload
|
|
)
|
|
var deposit_payload := arrival_payload.duplicate(true)
|
|
deposit_payload["cause_event_id"] = arrive_event_id
|
|
var deposit_event := _create_event(
|
|
deposit_event_id,
|
|
EVENT_CARGO_DEPOSITED,
|
|
arrival_tick,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
destination.get_location_id(),
|
|
deposit_payload
|
|
)
|
|
var next_group_ledger: Variant = _subtract_ledgers(group.get_cargo_ledger(), normalized_cargo)
|
|
var next_destination_ledger: Variant = _add_ledgers(
|
|
destination.get_stockpile_ledger(), normalized_cargo
|
|
)
|
|
var arrived_group := group.with_location(
|
|
SpatialAddress.create(
|
|
_world_state.get_world_id(), destination.get_location_id(), Vector3.ZERO
|
|
),
|
|
arrive_event_id
|
|
)
|
|
var empty_group := (
|
|
arrived_group.with_cargo_ledger(next_group_ledger, deposit_event_id)
|
|
if arrived_group != null and next_group_ledger != null
|
|
else null
|
|
)
|
|
var next_destination := destination.with_stockpile_ledger(
|
|
next_destination_ledger, deposit_event_id
|
|
)
|
|
if (
|
|
arrive_event == null
|
|
or deposit_event == null
|
|
or empty_group == null
|
|
or next_destination == null
|
|
):
|
|
return false
|
|
var snapshot := _snapshot()
|
|
if not _world_state.replace_settlement_and_mobile_group(next_destination, empty_group):
|
|
return false
|
|
if not _event_store.append(arrive_event) or not _event_store.append(deposit_event):
|
|
_restore_snapshot(snapshot)
|
|
return false
|
|
_next_event_id += 2
|
|
return true
|
|
|
|
|
|
func _create_event(
|
|
event_id: int,
|
|
event_type: StringName,
|
|
tick: int,
|
|
group: MobileGroupStateRecord,
|
|
origin: SettlementStateRecord,
|
|
destination: SettlementStateRecord,
|
|
route: RouteStateRecord,
|
|
location_id: StringName,
|
|
payload: Dictionary
|
|
) -> WorldEventRecord:
|
|
return (
|
|
WorldEventRecord
|
|
. create(
|
|
event_id,
|
|
event_type,
|
|
tick,
|
|
{
|
|
ROLE_CARAVAN: WorldEntityRef.create(ENTITY_TYPE_MOBILE_GROUP, group.get_group_id()),
|
|
ROLE_ROUTE: WorldEntityRef.create(ENTITY_TYPE_ROUTE, route.get_route_id()),
|
|
ROLE_ORIGIN:
|
|
WorldEntityRef.create(ENTITY_TYPE_SETTLEMENT, origin.get_settlement_id()),
|
|
ROLE_DESTINATION:
|
|
WorldEntityRef.create(ENTITY_TYPE_SETTLEMENT, destination.get_settlement_id()),
|
|
},
|
|
SpatialAddress.create(_world_state.get_world_id(), location_id, Vector3.ZERO),
|
|
payload
|
|
)
|
|
)
|
|
|
|
|
|
func _departure_facts_match(
|
|
depart_event_id: int,
|
|
group: MobileGroupStateRecord,
|
|
origin: SettlementStateRecord,
|
|
destination: SettlementStateRecord,
|
|
route: RouteStateRecord,
|
|
cargo_ledger: Dictionary,
|
|
departure_tick: int,
|
|
arrival_tick: int
|
|
) -> bool:
|
|
var load_event := _event_store.get_by_id(depart_event_id - 1)
|
|
var depart_event := _event_store.get_by_id(depart_event_id)
|
|
return (
|
|
_event_matches_journey(
|
|
load_event,
|
|
EVENT_CARGO_LOADED,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
cargo_ledger,
|
|
departure_tick,
|
|
arrival_tick,
|
|
-1
|
|
)
|
|
and _event_matches_journey(
|
|
depart_event,
|
|
EVENT_DEPARTED,
|
|
group,
|
|
origin,
|
|
destination,
|
|
route,
|
|
cargo_ledger,
|
|
departure_tick,
|
|
arrival_tick,
|
|
depart_event_id - 1
|
|
)
|
|
)
|
|
|
|
|
|
func _event_matches_journey(
|
|
event: WorldEventRecord,
|
|
event_type: StringName,
|
|
group: MobileGroupStateRecord,
|
|
origin: SettlementStateRecord,
|
|
destination: SettlementStateRecord,
|
|
route: RouteStateRecord,
|
|
cargo_ledger: Dictionary,
|
|
departure_tick: int,
|
|
arrival_tick: int,
|
|
cause_event_id: int
|
|
) -> bool:
|
|
if event == null or event.get_event_type() != event_type or event.get_tick() != departure_tick:
|
|
return false
|
|
var payload := event.get_payload()
|
|
return (
|
|
event.has_location()
|
|
and event.get_location().get_world_id() == _world_state.get_world_id()
|
|
and event.get_location().get_location_id() == origin.get_location_id()
|
|
and _participant_matches(
|
|
event, ROLE_CARAVAN, ENTITY_TYPE_MOBILE_GROUP, group.get_group_id()
|
|
)
|
|
and _participant_matches(event, ROLE_ROUTE, ENTITY_TYPE_ROUTE, route.get_route_id())
|
|
and _participant_matches(
|
|
event, ROLE_ORIGIN, ENTITY_TYPE_SETTLEMENT, origin.get_settlement_id()
|
|
)
|
|
and _participant_matches(
|
|
event, ROLE_DESTINATION, ENTITY_TYPE_SETTLEMENT, destination.get_settlement_id()
|
|
)
|
|
and payload.get("group_id") == String(group.get_group_id())
|
|
and payload.get("origin_settlement_id") == String(origin.get_settlement_id())
|
|
and payload.get("destination_settlement_id") == String(destination.get_settlement_id())
|
|
and payload.get("route_id") == String(route.get_route_id())
|
|
and payload.get("cargo_ledger") == cargo_ledger
|
|
and int(payload.get("headcount", -1)) == group.get_headcount()
|
|
and int(payload.get("departure_tick", -1)) == departure_tick
|
|
and int(payload.get("arrival_tick", -1)) == arrival_tick
|
|
and int(payload.get("cause_event_id", -2)) == cause_event_id
|
|
)
|
|
|
|
|
|
static func _participant_matches(
|
|
event: WorldEventRecord, role: StringName, entity_type: StringName, entity_id: StringName
|
|
) -> bool:
|
|
var participant := event.get_participant(role)
|
|
return (
|
|
participant != null
|
|
and participant.get_entity_type() == entity_type
|
|
and participant.get_entity_id() == entity_id
|
|
)
|
|
|
|
|
|
func _journey_payload(
|
|
group: MobileGroupStateRecord,
|
|
origin: SettlementStateRecord,
|
|
destination: SettlementStateRecord,
|
|
route: RouteStateRecord,
|
|
cargo_ledger: Dictionary,
|
|
departure_tick: int,
|
|
arrival_tick: int,
|
|
cause_event_id: int,
|
|
_presentation_mode: StringName
|
|
) -> Dictionary:
|
|
return {
|
|
"group_id": String(group.get_group_id()),
|
|
"origin_settlement_id": String(origin.get_settlement_id()),
|
|
"destination_settlement_id": String(destination.get_settlement_id()),
|
|
"route_id": String(route.get_route_id()),
|
|
"cargo_ledger": cargo_ledger,
|
|
"headcount": group.get_headcount(),
|
|
"departure_tick": departure_tick,
|
|
"arrival_tick": arrival_tick,
|
|
"cause_event_id": cause_event_id,
|
|
}
|
|
|
|
|
|
func _snapshot() -> Dictionary:
|
|
return {
|
|
"world_state": _world_state.to_dictionary(),
|
|
"scheduler": _scheduler.to_dictionary(),
|
|
"event_store": _event_store.to_dictionary(),
|
|
"next_event_id": _next_event_id,
|
|
}
|
|
|
|
|
|
func _restore_snapshot(snapshot: Dictionary) -> bool:
|
|
var world_ok := _world_state.restore_from_dictionary(snapshot["world_state"])
|
|
var scheduler_ok := _scheduler.restore_from_dictionary(snapshot["scheduler"])
|
|
var events_ok := _event_store.restore_from_dictionary(snapshot["event_store"])
|
|
_next_event_id = int(snapshot["next_event_id"])
|
|
return world_ok and scheduler_ok and events_ok
|
|
|
|
|
|
static func _arrival_job_id(group_id: StringName, departure_tick: int) -> StringName:
|
|
return StringName("caravan_arrival:%s:%d" % [group_id, departure_tick])
|
|
|
|
|
|
static func _arrival_dedupe_key(group_id: StringName) -> StringName:
|
|
return StringName("caravan_arrival:%s" % group_id)
|
|
|
|
|
|
func _event_cursor_is_valid() -> bool:
|
|
if _next_event_id < 0:
|
|
return false
|
|
var highest_event_id := -1
|
|
for event: WorldEventRecord in _event_store.get_all():
|
|
highest_event_id = maxi(highest_event_id, event.get_event_id())
|
|
return _next_event_id == highest_event_id + 1
|
|
|
|
|
|
static func _all_amounts_positive(ledger: Dictionary) -> bool:
|
|
for amount: Variant in ledger.values():
|
|
if float(amount) <= 0.0:
|
|
return false
|
|
return not ledger.is_empty()
|
|
|
|
|
|
static func _add_ledgers(first: Dictionary, second: Dictionary) -> Variant:
|
|
var result: Dictionary = first.duplicate(true)
|
|
for key: Variant in second:
|
|
var item_id := String(key)
|
|
result[item_id] = float(result.get(item_id, 0.0)) + float(second[key])
|
|
return RegionalStateSupport.normalize_amount_ledger(result)
|
|
|
|
|
|
static func _subtract_ledgers(first: Dictionary, second: Dictionary) -> Variant:
|
|
var result: Dictionary = first.duplicate(true)
|
|
for key: Variant in second:
|
|
var item_id := String(key)
|
|
var remaining := float(result.get(item_id, 0.0)) - float(second[key])
|
|
if remaining < 0.0:
|
|
return null
|
|
result[item_id] = remaining
|
|
return RegionalStateSupport.normalize_amount_ledger(result)
|
|
|
|
|
|
func _fail(message: String) -> bool:
|
|
_last_error = message
|
|
return false
|