400 lines
11 KiB
GDScript
400 lines
11 KiB
GDScript
extends Node
|
|
|
|
signal npc_task_changed(npc: SimNPC, old_task: String, new_task: String)
|
|
signal village_changed(village: SimVillage)
|
|
signal npc_died(npc: SimNPC)
|
|
|
|
var village := SimVillage.new()
|
|
|
|
var npcs: Array[SimNPC] = []
|
|
@export var tick_interval := 1.2
|
|
@export var simulation_seed: int = 1337
|
|
@export var debug_logs := true
|
|
|
|
var clock: SimulationClock
|
|
var tick_count := 0
|
|
var wander_random_sources := {}
|
|
|
|
var names := [
|
|
"Amina", "Tarik", "Jasmin"
|
|
]
|
|
|
|
var professions := [
|
|
"farmer",
|
|
"woodcutter",
|
|
"guard",
|
|
"scholar",
|
|
"wanderer"
|
|
]
|
|
|
|
func _ready() -> void:
|
|
clock = SimulationClock.new(tick_interval)
|
|
village.debug_logs = debug_logs
|
|
village.update_modifiers()
|
|
village.update_priorities()
|
|
generate_npcs()
|
|
if debug_logs:
|
|
print("--- Simulation started ---")
|
|
|
|
func _process(delta: float) -> void:
|
|
var ticks_due := clock.advance(delta)
|
|
for tick in ticks_due:
|
|
simulate_tick()
|
|
|
|
func generate_npcs() -> void:
|
|
for i in range(names.size()):
|
|
var npc_random := _create_random_source(i, 0)
|
|
var profession_index := npc_random.randi_range(0, professions.size() - 1)
|
|
var npc := SimNPC.new(
|
|
i,
|
|
names[i],
|
|
professions[profession_index],
|
|
npc_random.randf_range(1.0, 10.0),
|
|
npc_random.randf_range(1.0, 10.0),
|
|
npc_random
|
|
)
|
|
|
|
npc.debug_logs = debug_logs
|
|
npcs.append(npc)
|
|
wander_random_sources[i] = _create_random_source(i, 1)
|
|
|
|
func _create_random_source(npc_id: int, stream_id: int) -> RandomNumberGenerator:
|
|
var source := RandomNumberGenerator.new()
|
|
source.seed = simulation_seed + (npc_id + 1) * 1000003 + stream_id * 7919
|
|
return source
|
|
|
|
func get_wander_offset(npc_id: int) -> Vector3:
|
|
var source: RandomNumberGenerator = wander_random_sources.get(npc_id)
|
|
if source == null:
|
|
source = _create_random_source(npc_id, 1)
|
|
wander_random_sources[npc_id] = source
|
|
return Vector3(
|
|
source.randf_range(-6.0, 6.0),
|
|
0.0,
|
|
source.randf_range(-6.0, 6.0)
|
|
)
|
|
|
|
func simulate_tick() -> void:
|
|
tick_count += 1
|
|
if debug_logs:
|
|
print("--- Tick ", tick_count, " ---")
|
|
|
|
var village_was_changed := false
|
|
|
|
for npc in npcs:
|
|
var old_task := npc.current_task
|
|
var old_target := npc.target_id
|
|
var old_state := npc.task_state
|
|
var was_complete := npc.task_complete
|
|
var was_dead := npc.is_dead
|
|
|
|
npc.simulate_tick(village)
|
|
|
|
if old_task != npc.current_task and old_target != &"":
|
|
release_npc_reservation(npc.id)
|
|
|
|
if not was_dead and npc.is_dead:
|
|
if old_target != &"":
|
|
release_npc_reservation(npc.id)
|
|
npc_died.emit(npc)
|
|
npc_task_changed.emit(npc, old_task, npc.current_task)
|
|
|
|
if debug_logs:
|
|
print("[SimulationManager] NPC died: ", npc.npc_name)
|
|
|
|
if old_task != npc.current_task and not npc.is_dead:
|
|
npc_task_changed.emit(npc, old_task, npc.current_task)
|
|
|
|
if not was_complete and npc.task_complete and not npc.is_dead:
|
|
var completed_task := npc.current_task
|
|
var needs_immediate_food_after_gather := npc.should_eat_immediately_after_task()
|
|
|
|
if npc.target_id != &"":
|
|
var node := ResourceNode.get_by_id(npc.target_id)
|
|
if node != null and node.reserved_by == npc.id:
|
|
var extracted := node.extract()
|
|
if extracted > 0:
|
|
village.apply_resource_delta(node.resource_id, extracted)
|
|
if debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " extracted ", extracted, " ", node.resource_id, " from ", node.node_id)
|
|
elif debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " could not complete ", completed_task, ": target reservation was invalid")
|
|
release_npc_reservation(npc.id)
|
|
elif completed_task not in ["gather_food", "gather_wood"]:
|
|
village.apply_npc_task(npc)
|
|
elif debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " could not complete ", completed_task, ": no resource target")
|
|
|
|
village_was_changed = true
|
|
|
|
npc.task_complete = true
|
|
npc.task_state = SimNPC.TASK_STATE_IDLE
|
|
npc.last_task = completed_task
|
|
npc.current_task = "idle"
|
|
|
|
if needs_immediate_food_after_gather and village.food > 0:
|
|
npc.set_task("eat", 1.0)
|
|
npc_task_changed.emit(npc, completed_task, npc.current_task)
|
|
|
|
if debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " gathered food while starving and is going to eat immediately.")
|
|
|
|
if debug_logs:
|
|
print(
|
|
npc.npc_name,
|
|
" | ",
|
|
npc.profession,
|
|
" | task: ",
|
|
npc.current_task,
|
|
" | state: ",
|
|
npc.task_state,
|
|
" | progress: ",
|
|
npc.task_progress,
|
|
"/",
|
|
npc.task_duration,
|
|
" | complete: ",
|
|
npc.task_complete,
|
|
" | hunger: ",
|
|
round(npc.hunger),
|
|
" | energy: ",
|
|
round(npc.energy),
|
|
" | starving: ",
|
|
npc.is_starving,
|
|
" | starvation_ticks: ",
|
|
npc.starvation_ticks,
|
|
" | dead: ",
|
|
npc.is_dead
|
|
)
|
|
|
|
if old_state != npc.task_state:
|
|
print("[SimulationManager] State changed: ", npc.npc_name, " ", old_state, " -> ", npc.task_state)
|
|
|
|
if village_was_changed:
|
|
village_changed.emit(village)
|
|
|
|
if debug_logs:
|
|
print(village.get_summary())
|
|
|
|
func set_npc_target_id(npc_id: int, target_id: StringName) -> void:
|
|
for npc in npcs:
|
|
if npc.id == npc_id:
|
|
npc.target_id = target_id
|
|
return
|
|
|
|
func release_npc_reservation(npc_id: int) -> void:
|
|
for npc in npcs:
|
|
if npc.id == npc_id:
|
|
if npc.target_id != &"":
|
|
var node := ResourceNode.get_by_id(npc.target_id)
|
|
if node != null:
|
|
node.release(npc.id)
|
|
npc.target_id = &""
|
|
return
|
|
|
|
func notify_npc_arrived(npc_id: int) -> void:
|
|
for npc in npcs:
|
|
if npc.id == npc_id:
|
|
if npc.is_dead:
|
|
return
|
|
|
|
if npc.task_state == SimNPC.TASK_STATE_TRAVELING:
|
|
if npc.target_id != &"":
|
|
var node := ResourceNode.get_by_id(npc.target_id)
|
|
if node == null or not node.can_extract():
|
|
if debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " arrived but target ", npc.target_id, " is unavailable, replanning")
|
|
notify_npc_navigation_failed(npc.id)
|
|
return
|
|
|
|
npc.start_working()
|
|
|
|
if debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " arrived and started working on: ", npc.current_task)
|
|
return
|
|
|
|
func notify_npc_navigation_failed(npc_id: int) -> void:
|
|
for npc in npcs:
|
|
if npc.id != npc_id:
|
|
continue
|
|
if npc.is_dead or npc.task_state != SimNPC.TASK_STATE_TRAVELING:
|
|
return
|
|
|
|
var failed_task := npc.current_task
|
|
release_npc_reservation(npc.id)
|
|
npc.last_task = failed_task
|
|
npc.set_task("wander", 2.0)
|
|
npc_task_changed.emit(npc, failed_task, npc.current_task)
|
|
|
|
if debug_logs:
|
|
print("[SimulationManager] ", npc.npc_name, " could not navigate for ", failed_task, " and is trying a wander target")
|
|
return
|
|
|
|
func notify_npc_target_unavailable(npc_id: int) -> void:
|
|
notify_npc_navigation_failed(npc_id)
|
|
|
|
func harvest_resource_node(node: ResourceNode) -> float:
|
|
if node == null or not node.can_player_use:
|
|
return 0.0
|
|
|
|
var extracted := node.extract()
|
|
if extracted <= 0.0:
|
|
return 0.0
|
|
|
|
village.apply_resource_delta(node.resource_id, extracted)
|
|
village_changed.emit(village)
|
|
|
|
if debug_logs:
|
|
print("[SimulationManager] Player extracted ", extracted, " ", node.resource_id, " from ", node.node_id)
|
|
|
|
return extracted
|
|
|
|
func eat_food(amount: float) -> void:
|
|
village.apply_resource_delta(&"food", -amount)
|
|
village_changed.emit(village)
|
|
|
|
func add_food(amount: float) -> void:
|
|
village.apply_resource_delta(&"food", amount)
|
|
village_changed.emit(village)
|
|
|
|
func add_wood(amount: float) -> void:
|
|
village.apply_resource_delta(&"wood", amount)
|
|
village_changed.emit(village)
|
|
|
|
func add_safety(amount: float) -> void:
|
|
village.apply_resource_delta(&"safety", amount)
|
|
village_changed.emit(village)
|
|
|
|
func add_knowledge(amount: float) -> void:
|
|
village.apply_resource_delta(&"knowledge", amount)
|
|
village_changed.emit(village)
|
|
|
|
func get_starving_count() -> int:
|
|
var count := 0
|
|
for npc in npcs:
|
|
if npc.is_starving:
|
|
count += 1
|
|
return count
|
|
|
|
func get_state_snapshot() -> Dictionary:
|
|
var npc_snapshots: Array[Dictionary] = []
|
|
for npc in npcs:
|
|
npc_snapshots.append({
|
|
"id": npc.id,
|
|
"name": npc.npc_name,
|
|
"profession": npc.profession,
|
|
"hunger": npc.hunger,
|
|
"energy": npc.energy,
|
|
"strength": npc.strength,
|
|
"intelligence": npc.intelligence,
|
|
"task": npc.current_task,
|
|
"task_state": npc.task_state,
|
|
"task_duration": npc.task_duration,
|
|
"task_progress": npc.task_progress,
|
|
"target_id": String(npc.target_id),
|
|
"position": [npc.position.x, npc.position.y, npc.position.z],
|
|
"starvation_ticks": npc.starvation_ticks,
|
|
"is_dead": npc.is_dead
|
|
})
|
|
|
|
return {
|
|
"seed": simulation_seed,
|
|
"tick_count": tick_count,
|
|
"village": {
|
|
"food": village.food,
|
|
"wood": village.wood,
|
|
"safety": village.safety,
|
|
"knowledge": village.knowledge
|
|
},
|
|
"npcs": npc_snapshots
|
|
}
|
|
|
|
func get_state_checksum() -> String:
|
|
return create_state_record().to_json().sha256_text()
|
|
|
|
func create_state_record() -> SimulationStateRecord:
|
|
var record := SimulationStateRecord.new()
|
|
var wander_streams: Array[Dictionary] = []
|
|
var sorted_npc_ids: Array = wander_random_sources.keys()
|
|
sorted_npc_ids.sort()
|
|
for npc_id in sorted_npc_ids:
|
|
var source: RandomNumberGenerator = wander_random_sources[npc_id]
|
|
wander_streams.append({
|
|
"npc_id": int(npc_id),
|
|
"seed": str(source.seed),
|
|
"state": str(source.state)
|
|
})
|
|
|
|
record.simulation = {
|
|
"seed": simulation_seed,
|
|
"tick_interval": tick_interval,
|
|
"tick_count": tick_count,
|
|
"clock_accumulator": clock.accumulator,
|
|
"clock_elapsed_ticks": clock.elapsed_ticks,
|
|
"wander_random_streams": wander_streams
|
|
}
|
|
record.village = VillageStateRecord.capture(village)
|
|
for npc in npcs:
|
|
record.npcs.append(NPCStateRecord.capture(npc))
|
|
|
|
var resource_nodes := ResourceNode.get_all()
|
|
resource_nodes.sort_custom(
|
|
func(a: ResourceNode, b: ResourceNode) -> bool:
|
|
return String(a.node_id) < String(b.node_id)
|
|
)
|
|
var captured_resource_ids := {}
|
|
for node in resource_nodes:
|
|
if captured_resource_ids.has(node.node_id):
|
|
continue
|
|
captured_resource_ids[node.node_id] = true
|
|
record.resources.append(ResourceStateRecord.capture(node))
|
|
return record
|
|
|
|
func serialize_state() -> String:
|
|
return create_state_record().to_json()
|
|
|
|
func restore_state_from_json(json_text: String) -> bool:
|
|
var record := SimulationStateRecord.from_json(json_text)
|
|
if record == null:
|
|
push_error("SimulationManager: refused invalid or unsupported simulation state")
|
|
return false
|
|
return restore_state(record)
|
|
|
|
func restore_state(record: SimulationStateRecord) -> bool:
|
|
if record == null:
|
|
return false
|
|
|
|
simulation_seed = int(record.simulation["seed"])
|
|
tick_interval = float(record.simulation["tick_interval"])
|
|
tick_count = int(record.simulation["tick_count"])
|
|
clock = SimulationClock.new(tick_interval)
|
|
clock.accumulator = float(record.simulation["clock_accumulator"])
|
|
clock.elapsed_ticks = int(record.simulation["clock_elapsed_ticks"])
|
|
village = record.village.restore(debug_logs)
|
|
|
|
npcs.clear()
|
|
for npc_record in record.npcs:
|
|
npcs.append(npc_record.restore(debug_logs))
|
|
|
|
wander_random_sources.clear()
|
|
var wander_streams: Array = record.simulation["wander_random_streams"]
|
|
for stream_data in wander_streams:
|
|
var source := RandomNumberGenerator.new()
|
|
source.seed = String(stream_data["seed"]).to_int()
|
|
source.state = String(stream_data["state"]).to_int()
|
|
wander_random_sources[int(stream_data["npc_id"])] = source
|
|
|
|
for resource_record in record.resources:
|
|
var node_id := StringName(resource_record.data["node_id"])
|
|
var node := ResourceNode.get_by_id(node_id)
|
|
if node == null:
|
|
push_warning(
|
|
"SimulationManager: resource state '%s' has no loaded presentation node"
|
|
% node_id
|
|
)
|
|
continue
|
|
if not resource_record.restore(node):
|
|
return false
|
|
|
|
village_changed.emit(village)
|
|
return true
|