528 lines
21 KiB
GDScript
528 lines
21 KiB
GDScript
class_name P97BattleService
|
|
extends RefCounted
|
|
|
|
const Content = preload("res://content/p9_7_content.gd")
|
|
const MarketState = preload("res://p9_7/market_state.gd")
|
|
const State = preload("res://p9_7/battle_state.gd")
|
|
|
|
const CONTACT_RANGE := 10
|
|
const TIMEOUT_TICK := 1500
|
|
|
|
const LEGACY_DEFINITIONS := {
|
|
"PF-B01": {"max_hp": 130, "damage": 10, "cooldown": 10, "role": "contact_guard", "behavior": "guard_strike"},
|
|
"PF-B04": {"max_hp": 100, "damage": 12, "cooldown": 8, "role": "flank", "behavior": "passing_strike"},
|
|
"PF-B05": {"max_hp": 85, "damage": 14, "cooldown": 12, "role": "ranged", "behavior": "ranged_shot"},
|
|
"PF-B07": {"max_hp": 90, "damage": 5, "cooldown": 10, "heal": 10, "role": "healer", "behavior": "healing"},
|
|
}
|
|
|
|
var content: Dictionary = Content.snapshot()
|
|
var state := State.new()
|
|
var team_last_role := ""
|
|
|
|
|
|
func start_from_market(market_state) -> Dictionary:
|
|
if market_state.phase != MarketState.Phase.ENCOUNTER or market_state.selected_route.is_empty():
|
|
return _reject("committed_route_required")
|
|
if not content.routes.has(market_state.selected_route):
|
|
return _reject("unknown_route")
|
|
if market_state.deployed_recruit_ids.is_empty():
|
|
return _reject("deployment_required")
|
|
state.reset()
|
|
team_last_role = ""
|
|
var route: Dictionary = content.routes[market_state.selected_route]
|
|
state.route_id = String(route.id)
|
|
state.seed = int(route.seed)
|
|
state.member_ids.assign(market_state.deployed_recruit_ids)
|
|
for index in state.member_ids.size():
|
|
var recruit_id: String = state.member_ids[index]
|
|
if not market_state.recruit_records.has(recruit_id):
|
|
state.reset()
|
|
return _reject("recruit_record_missing")
|
|
var profession_id := String(market_state.recruit_records[recruit_id].profession_id)
|
|
var definition := member_definition(profession_id)
|
|
if definition.is_empty():
|
|
state.reset()
|
|
return _reject("profession_unknown")
|
|
var maximum := int(definition.max_hp)
|
|
var equipment_id := _equipped_catalog(market_state, recruit_id)
|
|
if not equipment_id.is_empty() and equipment_id not in MarketState.LEGACY_EQUIPMENT and not content.equipment.has(equipment_id):
|
|
state.reset()
|
|
return _reject("equipment_unknown")
|
|
state.member_professions[recruit_id] = profession_id
|
|
state.member_max_hp[recruit_id] = maximum
|
|
state.member_hp[recruit_id] = clampi(int(market_state.member_condition.get(recruit_id, maximum)), 0, maximum)
|
|
state.member_positions[recruit_id] = -index * 12
|
|
state.member_next_action[recruit_id] = 8 if profession_id == "PF-B06" else 0
|
|
state.member_action_counts[recruit_id] = 0
|
|
state.member_last_targets[recruit_id] = ""
|
|
state.member_flags[recruit_id] = {
|
|
"item_triggered": false,
|
|
"item_waited": false,
|
|
"guard": 0,
|
|
"pierce_ready": true,
|
|
"post_pending": false,
|
|
"post_ready_tick": 0,
|
|
"equipment_id": equipment_id,
|
|
}
|
|
state.enemy_ids.assign(route.enemy_ids)
|
|
for index in state.enemy_ids.size():
|
|
var enemy_id: String = state.enemy_ids[index]
|
|
if not content.enemies.has(enemy_id):
|
|
state.reset()
|
|
return _reject("enemy_unknown")
|
|
var definition: Dictionary = content.enemies[enemy_id]
|
|
state.enemy_max_hp[enemy_id] = int(definition.max_hp)
|
|
state.enemy_hp[enemy_id] = int(definition.max_hp)
|
|
state.enemy_positions[enemy_id] = 100 + index * 12
|
|
state.enemy_next_action[enemy_id] = 0
|
|
state.enemy_action_counts[enemy_id] = 0
|
|
state.enemy_flags[enemy_id] = {"screen_active": enemy_id == "EN-R1-05", "reflected": false, "growth": 0}
|
|
state.revision = 1
|
|
_event("battle_started", {
|
|
"route_id": state.route_id,
|
|
"members": state.member_ids.duplicate(),
|
|
"enemies": state.enemy_ids.duplicate(),
|
|
"seed": state.seed,
|
|
})
|
|
assert(state.invariants_hold())
|
|
return _success("battle_started", [])
|
|
|
|
|
|
func advance_ticks(requested_ticks := 1) -> Dictionary:
|
|
if requested_ticks < 0:
|
|
return _reject("invalid_tick_count")
|
|
var events: Array[Dictionary] = []
|
|
for _index in requested_ticks:
|
|
if state.terminal:
|
|
break
|
|
for event in _advance_one_tick():
|
|
events.append(event)
|
|
return _success("advanced", events)
|
|
|
|
|
|
func member_definition(profession_id: String) -> Dictionary:
|
|
if content.professions.has(profession_id):
|
|
return Dictionary(content.professions[profession_id]).duplicate(true)
|
|
return Dictionary(LEGACY_DEFINITIONS.get(profession_id, {})).duplicate(true)
|
|
|
|
|
|
func _advance_one_tick() -> Array[Dictionary]:
|
|
state.tick += 1
|
|
var start_index := state.event_log.size()
|
|
_resolve_pending_posts()
|
|
_move_lines()
|
|
_resolve_member_actions()
|
|
_resolve_enemy_actions()
|
|
_check_terminal()
|
|
if not state.terminal and state.tick >= TIMEOUT_TICK:
|
|
_lock_outcome("timeout", "hard_time_limit")
|
|
state.revision += 1
|
|
return state.event_log.slice(start_index)
|
|
|
|
|
|
func _move_lines() -> void:
|
|
var members := state.living_member_ids()
|
|
var enemies := state.living_enemy_ids()
|
|
if members.is_empty() or enemies.is_empty():
|
|
return
|
|
var lead_id := members[0]
|
|
var enemy_id := enemies[0]
|
|
var lead_position := int(state.member_positions[lead_id])
|
|
var enemy_position := int(state.enemy_positions[enemy_id])
|
|
if enemy_position - lead_position > CONTACT_RANGE:
|
|
lead_position += 2
|
|
enemy_position -= 2
|
|
state.member_positions[lead_id] = lead_position
|
|
state.enemy_positions[enemy_id] = enemy_position
|
|
if enemy_position - lead_position <= CONTACT_RANGE:
|
|
_event("contact", {"member_id": lead_id, "enemy_id": enemy_id})
|
|
for index in range(1, members.size()):
|
|
var member_id: String = members[index]
|
|
var desired := lead_position - index * 12
|
|
var current := int(state.member_positions[member_id])
|
|
state.member_positions[member_id] = mini(current + 2, desired) if current < desired else maxi(current - 2, desired)
|
|
|
|
|
|
func _resolve_member_actions() -> void:
|
|
for recruit_id in state.member_ids.duplicate():
|
|
if int(state.member_hp.get(recruit_id, 0)) <= 0 or state.living_enemy_ids().is_empty():
|
|
continue
|
|
if state.tick < int(state.member_next_action[recruit_id]):
|
|
continue
|
|
var profession_id := String(state.member_professions[recruit_id])
|
|
var definition := member_definition(profession_id)
|
|
var role := String(definition.role)
|
|
if role in ["contact_guard", "flank", "edge_contact"] and not _contact_reached():
|
|
continue
|
|
var acted := false
|
|
if role == "healer":
|
|
acted = _resolve_heal(recruit_id, definition)
|
|
if not acted:
|
|
acted = _resolve_attack(recruit_id, profession_id, definition)
|
|
if not acted:
|
|
continue
|
|
var counts := int(state.member_action_counts[recruit_id]) + 1
|
|
state.member_action_counts[recruit_id] = counts
|
|
state.member_next_action[recruit_id] = max(int(state.member_next_action[recruit_id]), state.tick + int(definition.cooldown))
|
|
_apply_profession_followup(recruit_id, profession_id, role, counts)
|
|
team_last_role = role
|
|
|
|
|
|
func _resolve_heal(recruit_id: String, definition: Dictionary) -> bool:
|
|
var target := _lowest_ratio_member()
|
|
if target.is_empty() or _member_ratio(target) >= 0.82:
|
|
return false
|
|
var before := int(state.member_hp[target])
|
|
var after := mini(int(state.member_max_hp[target]), before + int(definition.heal))
|
|
state.member_hp[target] = after
|
|
_event("member_action", {
|
|
"source_member_id": recruit_id,
|
|
"target_member_id": target,
|
|
"delta": after - before,
|
|
"qualifier": "healing",
|
|
"action_tag": "restore",
|
|
})
|
|
return true
|
|
|
|
|
|
func _resolve_attack(recruit_id: String, profession_id: String, definition: Dictionary) -> bool:
|
|
var enemies := state.living_enemy_ids()
|
|
if enemies.is_empty():
|
|
return false
|
|
var flags: Dictionary = state.member_flags[recruit_id]
|
|
var equipment_id := String(flags.equipment_id)
|
|
var target := _default_target(recruit_id, profession_id, enemies)
|
|
var rider_enabled := true
|
|
var nonlethal := false
|
|
var rearcall_triggered := false
|
|
if not bool(flags.item_triggered):
|
|
if equipment_id == "EQ-021":
|
|
target = _longest_windup_enemy(enemies)
|
|
if target.is_empty() and not bool(flags.item_waited):
|
|
flags.item_waited = true
|
|
state.member_flags[recruit_id] = flags
|
|
state.member_next_action[recruit_id] = state.tick + 1
|
|
_event("equipment_wait", {"member_id": recruit_id, "catalog_id": equipment_id, "reason": "no_enemy_windup"})
|
|
return false
|
|
if target.is_empty():
|
|
target = _default_target(recruit_id, profession_id, enemies)
|
|
flags.item_triggered = true
|
|
_event("equipment_trigger", {"member_id": recruit_id, "catalog_id": equipment_id, "target_enemy_id": target})
|
|
elif equipment_id == "EQ-023" and profession_id in ["PF-B03", "PF-B05", "PF-B06"]:
|
|
target = enemies[-1]
|
|
rider_enabled = false
|
|
rearcall_triggered = true
|
|
flags.item_triggered = true
|
|
_event("equipment_trigger", {"member_id": recruit_id, "catalog_id": equipment_id, "target_enemy_id": target})
|
|
elif equipment_id == "EQ-028":
|
|
target = _protecting_enemy(enemies)
|
|
nonlethal = true
|
|
flags.item_triggered = true
|
|
_event("equipment_trigger", {"member_id": recruit_id, "catalog_id": equipment_id, "target_enemy_id": target})
|
|
elif equipment_id == "EQ-036" and profession_id == "PF-B06" and enemies.size() >= 2:
|
|
flags.item_triggered = true
|
|
_event("equipment_trigger", {"member_id": recruit_id, "catalog_id": equipment_id, "targets": enemies.slice(0, 2)})
|
|
state.member_flags[recruit_id] = flags
|
|
var damage := int(definition.damage)
|
|
if profession_id == "PF-B03" and rider_enabled and bool(flags.pierce_ready) and enemies.size() >= 2:
|
|
_apply_member_damage(recruit_id, enemies[0], damage, "reach", false)
|
|
_apply_member_damage(recruit_id, enemies[1], maxi(1, damage - 6), "reach", false)
|
|
return true
|
|
if profession_id == "PF-B03" and not bool(flags.pierce_ready):
|
|
state.member_flags[recruit_id].pierce_ready = true
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "pierce_rearmed"})
|
|
if profession_id == "PF-B06" and rider_enabled and enemies.size() >= 2:
|
|
_apply_member_damage(recruit_id, enemies[0], damage, "area", false)
|
|
_apply_member_damage(recruit_id, enemies[1], damage, "area", false)
|
|
return true
|
|
var projectile := profession_id in ["PF-B05", "PF-B06"] and not rearcall_triggered
|
|
if projectile:
|
|
var screen := _active_projectile_screen(enemies)
|
|
if not screen.is_empty() and target != screen:
|
|
_event("enemy_rule", {"enemy_id": screen, "rule": "projectile_redirected", "original_target_enemy_id": target})
|
|
target = screen
|
|
_apply_member_damage(recruit_id, target, damage, "projectile" if projectile else "reach" if rearcall_triggered else "direct", nonlethal)
|
|
return true
|
|
|
|
|
|
func _apply_member_damage(recruit_id: String, enemy_id: String, damage: int, action_tag: String, nonlethal: bool) -> void:
|
|
if int(state.enemy_hp.get(enemy_id, 0)) <= 0:
|
|
return
|
|
if action_tag == "projectile" and enemy_id == "EN-R1-05" and not bool(state.enemy_flags[enemy_id].reflected):
|
|
state.enemy_flags[enemy_id].reflected = true
|
|
_damage_member(recruit_id, 8, enemy_id, "projectile_reflected")
|
|
_event("enemy_rule", {"enemy_id": enemy_id, "rule": "first_projectile_reflect", "source_member_id": recruit_id})
|
|
return
|
|
var before := int(state.enemy_hp[enemy_id])
|
|
var after := maxi(1, before - damage) if nonlethal and before > 0 else maxi(0, before - damage)
|
|
state.enemy_hp[enemy_id] = after
|
|
state.member_last_targets[recruit_id] = enemy_id
|
|
_event("member_action", {
|
|
"source_member_id": recruit_id,
|
|
"target_enemy_id": enemy_id,
|
|
"delta": after - before,
|
|
"qualifier": member_definition(String(state.member_professions[recruit_id])).behavior,
|
|
"action_tag": action_tag,
|
|
})
|
|
|
|
|
|
func _apply_profession_followup(recruit_id: String, profession_id: String, role: String, count: int) -> void:
|
|
if profession_id == "PF-B01":
|
|
state.member_flags[recruit_id].guard = 6
|
|
elif profession_id == "PF-B02":
|
|
var previous := String(state.member_last_targets.get(recruit_id, ""))
|
|
if not previous.is_empty() and int(state.enemy_hp.get(previous, 0)) == 0:
|
|
state.member_next_action[recruit_id] = maxi(state.tick + 1, int(state.member_next_action[recruit_id]) - 2)
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "finish_accelerated"})
|
|
elif profession_id == "PF-B08" and not team_last_role.is_empty() and team_last_role != role:
|
|
var ally := _slowest_living_ally(recruit_id)
|
|
if not ally.is_empty():
|
|
state.member_next_action[ally] = maxi(state.tick + 1, int(state.member_next_action[ally]) - 2)
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "mixed_role_advance", "target_member_id": ally})
|
|
elif profession_id == "PF-B09" and count % 2 == 0:
|
|
state.member_flags[recruit_id].post_pending = true
|
|
state.member_flags[recruit_id].post_ready_tick = state.tick + 1
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "needle_post_deployed"})
|
|
elif profession_id == "PF-B11" and count % 3 == 0:
|
|
var enemy := _longest_windup_enemy(state.living_enemy_ids())
|
|
if not enemy.is_empty():
|
|
state.enemy_next_action[enemy] = int(state.enemy_next_action[enemy]) + 4
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "windup_delayed", "target_enemy_id": enemy})
|
|
|
|
|
|
func _resolve_enemy_actions() -> void:
|
|
for enemy_id in state.enemy_ids.duplicate():
|
|
if int(state.enemy_hp.get(enemy_id, 0)) <= 0 or state.living_member_ids().is_empty():
|
|
continue
|
|
if state.tick < int(state.enemy_next_action[enemy_id]):
|
|
continue
|
|
var definition: Dictionary = content.enemies[enemy_id]
|
|
var role := String(definition.role)
|
|
if role in ["contact_biter", "contact_push", "projectile_screen"] and not _contact_reached():
|
|
continue
|
|
state.enemy_action_counts[enemy_id] = int(state.enemy_action_counts[enemy_id]) + 1
|
|
if role == "elite_command":
|
|
_interrupt_riftcaller(enemy_id)
|
|
if role == "growing_screen":
|
|
var growth := int(state.enemy_flags[enemy_id].growth) + 1
|
|
state.enemy_flags[enemy_id].growth = growth
|
|
if growth >= 3:
|
|
state.enemy_flags[enemy_id].screen_active = true
|
|
_event("enemy_rule", {"enemy_id": enemy_id, "rule": "growth", "stage": growth})
|
|
var target := _enemy_target(role)
|
|
if not target.is_empty():
|
|
_damage_member(target, int(definition.damage), enemy_id, String(definition.pressure))
|
|
if role == "contact_biter" and int(state.enemy_action_counts[enemy_id]) % 2 == 0:
|
|
var neighbor := _living_neighbor_after(target)
|
|
if not neighbor.is_empty():
|
|
_damage_member(neighbor, 5, enemy_id, "guard_chip_neighbor")
|
|
if role == "contact_push":
|
|
_push_front(enemy_id)
|
|
if role == "rear_projectile":
|
|
_destroy_pending_posts(enemy_id)
|
|
state.enemy_next_action[enemy_id] = state.tick + int(definition.cooldown)
|
|
|
|
|
|
func _resolve_pending_posts() -> void:
|
|
for recruit_id in state.living_member_ids():
|
|
var flags: Dictionary = state.member_flags[recruit_id]
|
|
if not bool(flags.get("post_pending", false)) or state.tick < int(flags.get("post_ready_tick", 0)):
|
|
continue
|
|
var enemies := state.living_enemy_ids()
|
|
flags.post_pending = false
|
|
state.member_flags[recruit_id] = flags
|
|
if enemies.is_empty():
|
|
continue
|
|
_apply_member_damage(recruit_id, enemies[-1], 8, "construct", false)
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "needle_post_fired", "target_enemy_id": enemies[-1]})
|
|
|
|
|
|
func _destroy_pending_posts(enemy_id: String) -> void:
|
|
for recruit_id in state.living_member_ids():
|
|
if not bool(state.member_flags[recruit_id].get("post_pending", false)):
|
|
continue
|
|
state.member_flags[recruit_id].post_pending = false
|
|
_event("profession_rule", {"member_id": recruit_id, "rule": "needle_post_destroyed", "source_enemy_id": enemy_id})
|
|
|
|
|
|
func _damage_member(recruit_id: String, damage: int, enemy_id: String, qualifier: String) -> void:
|
|
if recruit_id.is_empty() or int(state.member_hp.get(recruit_id, 0)) <= 0:
|
|
return
|
|
var guard := int(state.member_flags[recruit_id].get("guard", 0))
|
|
var applied := maxi(0, damage - guard)
|
|
state.member_flags[recruit_id].guard = 0
|
|
var before := int(state.member_hp[recruit_id])
|
|
var after := maxi(0, before - applied)
|
|
state.member_hp[recruit_id] = after
|
|
_event("enemy_action", {
|
|
"source_enemy_id": enemy_id,
|
|
"target_member_id": recruit_id,
|
|
"delta": after - before,
|
|
"qualifier": qualifier,
|
|
})
|
|
|
|
|
|
func _interrupt_riftcaller(enemy_id: String) -> void:
|
|
for recruit_id in state.living_member_ids():
|
|
if String(state.member_professions[recruit_id]) != "PF-B06":
|
|
continue
|
|
if int(state.member_next_action[recruit_id]) > state.tick and int(state.member_next_action[recruit_id]) <= state.tick + 7:
|
|
state.member_next_action[recruit_id] = int(state.member_next_action[recruit_id]) + 5
|
|
_event("enemy_rule", {"enemy_id": enemy_id, "rule": "command_interrupt", "target_member_id": recruit_id})
|
|
return
|
|
|
|
|
|
func _push_front(enemy_id: String) -> void:
|
|
var members := state.living_member_ids()
|
|
if members.size() < 2:
|
|
return
|
|
var front := members[0]
|
|
if String(state.member_flags[front].equipment_id) == "EQ-002":
|
|
_event("equipment_trigger", {"member_id": front, "catalog_id": "EQ-002", "rule": "push_resisted", "source_enemy_id": enemy_id})
|
|
state.member_flags[front].equipment_id = ""
|
|
return
|
|
var front_index := state.member_ids.find(front)
|
|
var next_id := members[1]
|
|
var next_index := state.member_ids.find(next_id)
|
|
state.member_ids[front_index] = next_id
|
|
state.member_ids[next_index] = front
|
|
var front_position := int(state.member_positions[front])
|
|
state.member_positions[front] = int(state.member_positions[next_id])
|
|
state.member_positions[next_id] = front_position
|
|
for moved_id in [front, next_id]:
|
|
if String(state.member_professions[moved_id]) == "PF-B03":
|
|
state.member_flags[moved_id].pierce_ready = false
|
|
_event("enemy_rule", {"enemy_id": enemy_id, "rule": "front_pushed", "from_member_id": front, "to_member_id": next_id})
|
|
|
|
|
|
func _default_target(recruit_id: String, profession_id: String, enemies: Array[String]) -> String:
|
|
if profession_id == "PF-B02" and enemies.size() > 1:
|
|
var previous := String(state.member_last_targets.get(recruit_id, ""))
|
|
for enemy_id in enemies:
|
|
if enemy_id != previous:
|
|
return enemy_id
|
|
return enemies[0]
|
|
|
|
|
|
func _protecting_enemy(enemies: Array[String]) -> String:
|
|
for enemy_id in enemies:
|
|
if String(content.enemies[enemy_id].role) in ["projectile_screen", "growing_screen"]:
|
|
return enemy_id
|
|
return enemies[0]
|
|
|
|
|
|
func _longest_windup_enemy(enemies: Array[String]) -> String:
|
|
var result := ""
|
|
var longest := -1
|
|
for enemy_id in enemies:
|
|
var remaining := int(state.enemy_next_action.get(enemy_id, state.tick)) - state.tick
|
|
if remaining > 0 and remaining > longest:
|
|
longest = remaining
|
|
result = enemy_id
|
|
return result
|
|
|
|
|
|
func _active_projectile_screen(enemies: Array[String]) -> String:
|
|
for enemy_id in enemies:
|
|
if bool(state.enemy_flags[enemy_id].get("screen_active", false)):
|
|
return enemy_id
|
|
return ""
|
|
|
|
|
|
func _enemy_target(role: String) -> String:
|
|
var members := state.living_member_ids()
|
|
if members.is_empty():
|
|
return ""
|
|
if role == "rear_projectile":
|
|
return members[-1]
|
|
if role == "elite_command" and members.size() > 1:
|
|
return members[1]
|
|
return members[0]
|
|
|
|
|
|
func _lowest_ratio_member() -> String:
|
|
var result := ""
|
|
var ratio := 2.0
|
|
for recruit_id in state.living_member_ids():
|
|
var current := _member_ratio(recruit_id)
|
|
if current < ratio:
|
|
ratio = current
|
|
result = recruit_id
|
|
return result
|
|
|
|
|
|
func _member_ratio(recruit_id: String) -> float:
|
|
return float(state.member_hp.get(recruit_id, 0)) / maxf(1.0, float(state.member_max_hp.get(recruit_id, 1)))
|
|
|
|
|
|
func _slowest_living_ally(source_id: String) -> String:
|
|
var result := ""
|
|
var latest := -1
|
|
for recruit_id in state.living_member_ids():
|
|
if recruit_id == source_id:
|
|
continue
|
|
var ready := int(state.member_next_action[recruit_id])
|
|
if ready > latest:
|
|
latest = ready
|
|
result = recruit_id
|
|
return result
|
|
|
|
|
|
func _living_enemy_with_role(role: String) -> String:
|
|
for enemy_id in state.living_enemy_ids():
|
|
if String(content.enemies[enemy_id].role) == role:
|
|
return enemy_id
|
|
return ""
|
|
|
|
|
|
func _living_neighbor_after(recruit_id: String) -> String:
|
|
var members := state.living_member_ids()
|
|
var index := members.find(recruit_id)
|
|
return members[index + 1] if index >= 0 and index + 1 < members.size() else ""
|
|
|
|
|
|
func _contact_reached() -> bool:
|
|
var members := state.living_member_ids()
|
|
var enemies := state.living_enemy_ids()
|
|
if members.is_empty() or enemies.is_empty():
|
|
return false
|
|
return int(state.enemy_positions[enemies[0]]) - int(state.member_positions[members[0]]) <= CONTACT_RANGE
|
|
|
|
|
|
func _check_terminal() -> void:
|
|
if state.living_enemy_ids().is_empty():
|
|
_lock_outcome("victory", "all_enemies_defeated")
|
|
elif state.living_member_ids().is_empty():
|
|
_lock_outcome("defeat", "all_members_fallen")
|
|
|
|
|
|
func _lock_outcome(kind: String, cause: String) -> void:
|
|
if state.terminal:
|
|
return
|
|
state.terminal = true
|
|
state.outcome = kind
|
|
state.outcome_cause = cause
|
|
_event("outcome_locked", {"outcome": kind, "cause": cause, "tick": state.tick})
|
|
|
|
|
|
func _equipped_catalog(market_state, recruit_id: String) -> String:
|
|
var instance_id := String(market_state.equipped_by_recruit.get(recruit_id, ""))
|
|
return String(market_state.inventory.get(instance_id, {}).get("catalog_id", "")) if not instance_id.is_empty() else ""
|
|
|
|
|
|
func _event(kind: String, payload: Dictionary) -> Dictionary:
|
|
var event := {"index": state.event_log.size(), "tick": state.tick, "kind": kind}
|
|
for key in payload:
|
|
event[key] = payload[key]
|
|
state.event_log.append(event)
|
|
return event
|
|
|
|
|
|
func _success(code: String, events: Array) -> Dictionary:
|
|
assert(state.invariants_hold())
|
|
return {"ok": true, "code": code, "events": events, "snapshot": state.snapshot()}
|
|
|
|
|
|
func _reject(code: String) -> Dictionary:
|
|
return {"ok": false, "code": code, "events": [], "snapshot": state.snapshot()}
|