Rijad Zuzo
217 lines
6.7 KiB
GDScript
217 lines
6.7 KiB
GDScript
class_name ActionTargetResolver
|
|
extends RefCounted
|
|
|
|
var last_resource_query_stats: Dictionary = {}
|
|
|
|
|
|
func resolve(
|
|
npc: SimNPC, origin: Vector3, simulation_manager: Node, active_world_adapter: Node
|
|
) -> Dictionary:
|
|
var definition := SimulationDefinitions.get_action(npc.current_task)
|
|
if definition == null:
|
|
return {}
|
|
match definition.target_type:
|
|
SimulationIds.TARGET_RESOURCE:
|
|
return _resolve_resource(
|
|
npc, origin, definition, simulation_manager, active_world_adapter
|
|
)
|
|
SimulationIds.TARGET_ACTIVITY:
|
|
return _resolve_activity(npc, origin, simulation_manager, active_world_adapter)
|
|
SimulationIds.TARGET_FREE:
|
|
return {
|
|
"target_id": "", "position": origin + simulation_manager.get_wander_offset(npc.id)
|
|
}
|
|
return {}
|
|
|
|
|
|
func _resolve_resource(
|
|
npc: SimNPC,
|
|
origin: Vector3,
|
|
definition: ActionDefinition,
|
|
simulation_manager: Node,
|
|
active_world_adapter: Node
|
|
) -> Dictionary:
|
|
last_resource_query_stats = {}
|
|
if (
|
|
active_world_adapter.has_method("get_resource_candidates_in_radius")
|
|
and active_world_adapter.has_method("get_resource_query_profile")
|
|
):
|
|
return _resolve_resource_spatial(
|
|
npc, origin, definition, simulation_manager, active_world_adapter
|
|
)
|
|
return _resolve_resource_linear(
|
|
npc, origin, definition, simulation_manager, active_world_adapter
|
|
)
|
|
|
|
|
|
func _resolve_resource_linear(
|
|
npc: SimNPC,
|
|
origin: Vector3,
|
|
definition: ActionDefinition,
|
|
simulation_manager: Node,
|
|
active_world_adapter: Node
|
|
) -> Dictionary:
|
|
var best: Dictionary = {}
|
|
var best_score := INF
|
|
var candidates: Array[Dictionary] = active_world_adapter.get_resource_candidates(
|
|
definition.resource_action_id
|
|
)
|
|
for candidate in candidates:
|
|
var node_id := StringName(candidate["target_id"])
|
|
var state: ResourceStateRecord = simulation_manager.get_resource_state(node_id)
|
|
if state == null or not state.can_npc_use() or not state.is_available_for(npc.id):
|
|
continue
|
|
var position: Vector3 = candidate["position"]
|
|
var score := score_resource_candidate(npc, origin, position, state)
|
|
if score < best_score:
|
|
best_score = score
|
|
best = candidate
|
|
last_resource_query_stats = {
|
|
"mode": "linear",
|
|
"loaded_candidate_count": candidates.size(),
|
|
"candidates_inspected": candidates.size(),
|
|
"range_pass_count": 1,
|
|
}
|
|
return _reserve_resource_candidate(best, npc, simulation_manager)
|
|
|
|
|
|
func _resolve_resource_spatial(
|
|
npc: SimNPC,
|
|
origin: Vector3,
|
|
definition: ActionDefinition,
|
|
simulation_manager: Node,
|
|
active_world_adapter: Node
|
|
) -> Dictionary:
|
|
var profile: Dictionary = active_world_adapter.get_resource_query_profile(
|
|
definition.resource_action_id, origin
|
|
)
|
|
var loaded_count := int(profile.get("candidate_count", 0))
|
|
if loaded_count == 0:
|
|
last_resource_query_stats = {
|
|
"mode": "spatial",
|
|
"loaded_candidate_count": 0,
|
|
"candidates_inspected": 0,
|
|
"range_pass_count": 0,
|
|
}
|
|
return {}
|
|
|
|
var best: Dictionary = {}
|
|
var best_score := INF
|
|
var best_registration_order := 9223372036854775807
|
|
var maximum_distance := maxf(float(profile["max_distance"]), 0.0)
|
|
var radius := minf(maxf(float(profile["initial_radius"]), 0.1), maximum_distance)
|
|
var previous_radius := -1.0
|
|
var candidates_inspected := 0
|
|
var range_pass_count := 0
|
|
while true:
|
|
var candidates: Array[Dictionary] = active_world_adapter.get_resource_candidates_in_radius(
|
|
definition.resource_action_id, origin, radius, previous_radius
|
|
)
|
|
range_pass_count += 1
|
|
candidates_inspected += candidates.size()
|
|
for candidate in candidates:
|
|
var node_id := StringName(candidate["target_id"])
|
|
var state: ResourceStateRecord = simulation_manager.get_resource_state(node_id)
|
|
if state == null or not state.can_npc_use() or not state.is_available_for(npc.id):
|
|
continue
|
|
var position: Vector3 = candidate["position"]
|
|
var score := score_resource_candidate(npc, origin, position, state)
|
|
var registration_order := int(candidate["registration_order"])
|
|
if (
|
|
score < best_score
|
|
or (score == best_score and registration_order < best_registration_order)
|
|
):
|
|
best_score = score
|
|
best_registration_order = registration_order
|
|
best = candidate
|
|
|
|
if radius >= maximum_distance:
|
|
break
|
|
if (
|
|
not best.is_empty()
|
|
and _minimum_resource_score_beyond(npc, radius, profile) > best_score
|
|
):
|
|
break
|
|
previous_radius = radius
|
|
var next_radius := minf(maximum_distance, radius * 2.0)
|
|
if next_radius <= radius:
|
|
break
|
|
radius = next_radius
|
|
|
|
last_resource_query_stats = {
|
|
"mode": "spatial",
|
|
"loaded_candidate_count": loaded_count,
|
|
"candidates_inspected": candidates_inspected,
|
|
"range_pass_count": range_pass_count,
|
|
"final_radius": radius,
|
|
}
|
|
return _reserve_resource_candidate(best, npc, simulation_manager)
|
|
|
|
|
|
func _minimum_resource_score_beyond(npc: SimNPC, radius: float, profile: Dictionary) -> float:
|
|
var comfort_overage := maxf(radius - float(profile["max_comfort_distance"]), 0.0)
|
|
var risk_weight := 20.0 + maxf(100.0 - npc.energy, 0.0) * 0.2
|
|
return (
|
|
radius
|
|
+ comfort_overage * 2.5
|
|
+ float(profile["min_safety_risk"]) * risk_weight
|
|
- float(profile["max_discovery_priority"])
|
|
)
|
|
|
|
|
|
func _reserve_resource_candidate(
|
|
candidate: Dictionary, npc: SimNPC, simulation_manager: Node
|
|
) -> Dictionary:
|
|
if candidate.is_empty():
|
|
return {}
|
|
var target_id := StringName(candidate["target_id"])
|
|
if not simulation_manager.reserve_resource(target_id, npc.id):
|
|
return {}
|
|
return candidate
|
|
|
|
|
|
func _resolve_activity(
|
|
npc: SimNPC, origin: Vector3, simulation_manager: Node, active_world_adapter: Node
|
|
) -> Dictionary:
|
|
if not active_world_adapter.has_method("get_activity_candidates"):
|
|
return active_world_adapter.get_activity_target(npc.current_task, origin)
|
|
|
|
var best: Dictionary = {}
|
|
var best_distance := INF
|
|
var candidates: Array[Dictionary] = active_world_adapter.get_activity_candidates(
|
|
npc.current_task
|
|
)
|
|
for candidate in candidates:
|
|
var target_id := StringName(candidate["target_id"])
|
|
var capacity := maxi(int(candidate.get("capacity", 1)), 1)
|
|
if (
|
|
simulation_manager.has_method("get_activity_target_claim_count")
|
|
and simulation_manager.get_activity_target_claim_count(target_id, npc.id) >= capacity
|
|
):
|
|
continue
|
|
var position: Vector3 = candidate["position"]
|
|
var distance := origin.distance_squared_to(position)
|
|
if distance < best_distance:
|
|
best_distance = distance
|
|
best = candidate
|
|
|
|
if not best.is_empty():
|
|
return best
|
|
if not candidates.is_empty():
|
|
return {}
|
|
return active_world_adapter.get_activity_target(npc.current_task, origin)
|
|
|
|
|
|
func score_resource_candidate(
|
|
npc: SimNPC, origin: Vector3, position: Vector3, state: ResourceStateRecord
|
|
) -> float:
|
|
var distance := origin.distance_to(position)
|
|
var comfort_overage := maxf(distance - state.get_comfort_distance(), 0.0)
|
|
var risk_weight := 20.0 + maxf(100.0 - npc.energy, 0.0) * 0.2
|
|
return (
|
|
distance
|
|
+ comfort_overage * 2.5
|
|
+ state.get_safety_risk() * risk_weight
|
|
- state.get_discovery_priority()
|
|
)
|