Files
aetherbound-guild/runtime/p9_7/battle_service.gd
T

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()}