battle.py

"""Battle engine: handles all combat calculations and the battle loop."""

from __future__ import annotations

import random

import math

from typing import List, Optional, Tuple, Dict

from data_types import *

from character import Character

from monster_unit import MonsterUnit

from monsters_db import MonsterTemplate

from skills_db import SKILL_DB

from items_db import ITEM_DB

def _clear():

 import os; os.system('clear' if os.name == 'posix' else 'cls')

def calculate_physical_damage(attacker_patk: int, target_pdef: int,

 power: float = 1.0, crit: bool = False,

 element_bonus: float = 1.0,

 weakness_bonus: float = 1.0,

 break_bonus: float = 1.0) -> int:

 base = max(1, attacker_patk - target_pdef // 2)

 dmg = int(base * power * element_bonus * weakness_bonus * break_bonus)

 if crit:

 dmg = int(dmg * 1.5)

 dmg = max(1, int(dmg * random.uniform(0.9, 1.1)))

 return dmg

def calculate_magical_damage(attacker_matk: int, target_mdef: int,

 power: float = 1.0, crit: bool = False,

 element_bonus: float = 1.0,

 weakness_bonus: float = 1.0,

 break_bonus: float = 1.0) -> int:

 base = max(1, attacker_matk - target_mdef // 3)

 dmg = int(base * power * element_bonus * weakness_bonus * break_bonus)

 if crit:

 dmg = int(dmg * 1.5)

 dmg = max(1, int(dmg * random.uniform(0.9, 1.1)))

 return dmg

def calculate_heal(healer_mdef: int, power: float = 1.0) -> int:

 return max(1, int(healer_mdef * 2.5 * power * random.uniform(0.9, 1.1)))

def check_hit(attacker_acc: float, target_eva: float) -> bool:

 hit_chance = min(0.99, max(0.01, attacker_acc - target_eva))

 return random.random() < hit_chance

def check_crit(crit_rate: float) -> bool:

 return random.random() < crit_rate

class Battle:

 def __init__(self, party: List[Character], monsters: List[MonsterUnit]):

 self.party = party

 self.monsters = monsters

 self.turn = 0

 self.battle_log: List[str] = []

 self._defending: set = set() # character names defending this round

 # ── Display helpers ───────────────────────────────────────────────────

 def display_battle_state(self):

 print("\n" + "═"*65)

 print(" BATTLE STATUS")

 print("═"*65)

 print(" ENEMIES:")

 for i, mu in enumerate(self.monsters):

 if mu.is_dead:

 print(f" [{i+1}] {mu.instance_name} - ☠ DEFEATED")

 else:

 broken = " ⚡BREAK!" if mu.is_broken else ""

 print(f" [{i+1}] {mu.instance_name} Lv{mu.template.level}{broken}")

 print(f" HP: {mu.hp_bar()}")

 print(f" Shield: {mu.shield_bar()}{mu.status_str()}")

 print()

 print(" ALLIES:")

 for i, ch in enumerate(self.party):

 if ch.is_dead:

 print(f" [{i+1}] {ch.name} [DEAD]")

 elif ch.is_ko:

 print(f" [{i+1}] {ch.name} [KO - {3 - ch.ko_turns} turns left]")

 else:

 print(f" [{i+1}] {ch.name} Lv{ch.level} {ch.job.value}{ch.status_str()}")

 print(f" HP: {ch.hp_bar()} | MP: {ch.mp_bar()}")

 print("═"*65)

 def display_turn_order(self, order: List):

 units = []

 for u in order:

 if isinstance(u, Character):

 units.append(f"{u.name}({u.spd})")

 elif isinstance(u, MonsterUnit):

 units.append(f"{u.instance_name}({u.spd})")

 print(f"\n Turn Order: {' → '.join(units)}")

 def _log(self, msg: str):

 self.battle_log.append(msg)

 print(msg)

 # ── Turn order ────────────────────────────────────────────────────────

 def get_turn_order(self) -> List:

 units = []

 for ch in self.party:

 if not ch.is_ko and not ch.is_dead:

 units.append(ch)

 for mu in self.monsters:

 if not mu.is_dead:

 units.append(mu)

 # Sort by speed descending; defenders get priority

 units.sort(key=lambda u: (

 1 if (isinstance(u, Character) and u.name in self._defending) else 0,

 u.spd

 ), reverse=True)

 return units

 # ── Main battle loop ──────────────────────────────────────────────────

 def run(self) -> bool:

 """Returns True if party wins."""

 print("\n" + "★"*65)

 print(" ★ BATTLE START! ★")

 print("★"*65)

 input(" [Press Enter]")

 while True:

 self.turn += 1

 self._defending.clear()

 print(f"\n{'─'*65}")

 print(f" ── TURN {self.turn} ──")

 self.display_battle_state()

 order = self.get_turn_order()

 self.display_turn_order(order)

 for unit in order:

 if self._check_battle_end():

 break

 if isinstance(unit, Character):

 if unit.is_ko or unit.is_dead:

 continue

 self._player_turn(unit)

 elif isinstance(unit, MonsterUnit):

 if unit.is_dead:

 continue

 self._monster_turn(unit)

 # End of round: status ticks, KO timers, break recovery

 self._end_of_round()

 if self._check_battle_end():

 break

 return self._is_victory()

 def _check_battle_end(self) -> bool:

 all_monsters_dead = all(mu.is_dead for mu in self.monsters)

 all_party_out = all(ch.is_ko or ch.is_dead for ch in self.party)

 return all_monsters_dead or all_party_out

 def _is_victory(self) -> bool:

 return all(mu.is_dead for mu in self.monsters)

 # ── Player turn ───────────────────────────────────────────────────────

 def _player_turn(self, ch: Character):

 print(f"\n ── {ch.name}'s Turn ({ch.job.value}) ──")

 if ch.is_incapacitated():

 incap_se = [se for se in ch.status_effects

 if se.effect_type in {StatusEffectType.SLEEP, StatusEffectType.STUN,

 StatusEffectType.FREEZE, StatusEffectType.PARALYZE,

 StatusEffectType.PETRIFY}]

 if incap_se:

 self._log(f" {ch.name} is {incap_se[0].effect_type.value}! Can't act.")

 # Wake up chance for sleep

 if incap_se[0].effect_type == StatusEffectType.SLEEP:

 if random.random() < 0.25:

 ch.remove_status(StatusEffectType.SLEEP)

 self._log(f" {ch.name} woke up!")

 return

 while True:

 print(f"\n Actions: [1] Attack [2] Skill [3] Item [4] Defend")

 choice = input(" > ").strip()

 if choice == "1":

 target = self._pick_enemy_target()

 if target:

 self._do_basic_attack(ch, target)

 break

 elif choice == "2":

 if not ch.can_use_skills():

 print(" Skills are sealed!")

 continue

 skill_id = self._pick_skill(ch)

 if skill_id is None:

 continue

 skill = SKILL_DB[skill_id]

 if not ch.can_use_magic() and skill.skill_type == SkillType.MAGICAL:

 print(" Cannot use magic (Silenced)!")

 continue

 if ch.current_mp < skill.mp_cost:

 print(f" Not enough MP! (Need {skill.mp_cost}, have {ch.current_mp})")

 continue

 self._do_skill(ch, skill)

 break

 elif choice == "3":

 if not ch.can_use_items():

 print(" Items are sealed!")

 continue

 used = self._use_item_menu(ch)

 if used:

 break

 elif choice == "4":

 self._do_defend(ch)

 break

 else:

 print(" Invalid choice.")

 def _pick_enemy_target(self) -> Optional[MonsterUnit]:

 alive = [mu for mu in self.monsters if not mu.is_dead]

 if not alive:

 return None

 if len(alive) == 1:

 return alive[0]

 print(" Choose target:")

 for i, mu in enumerate(alive):

 broken = " ⚡BREAK" if mu.is_broken else ""

 print(f" [{i+1}] {mu.instance_name} HP:{mu.current_hp}/{mu.max_hp}{broken}")

 while True:

 try:

 idx = int(input(" > ")) - 1

 if 0 <= idx < len(alive):

 return alive[idx]

 except ValueError:

 pass

 print(" Invalid choice.")

 def _pick_ally_target(self, include_ko=False) -> Optional[Character]:

 if include_ko:

 valid = [ch for ch in self.party if not ch.is_dead]

 else:

 valid = [ch for ch in self.party if not ch.is_ko and not ch.is_dead]

 if not valid:

 return None

 if len(valid) == 1:

 return valid[0]

 print(" Choose ally:")

 for i, ch in enumerate(valid):

 status = "KO" if ch.is_ko else f"HP:{ch.current_hp}/{ch.max_hp}"

 print(f" [{i+1}] {ch.name} ({status})")

 while True:

 try:

 idx = int(input(" > ")) - 1

 if 0 <= idx < len(valid):

 return valid[idx]

 except ValueError:

 pass

 print(" Invalid choice.")

 def _pick_skill(self, ch: Character) -> Optional[int]:

 if not ch.unlocked_skills:

 print(" No skills available!")

 return None

 print(" Choose skill (0=back):")

 for i, sid in enumerate(ch.unlocked_skills):

 if sid in SKILL_DB:

 sk = SKILL_DB[sid]

 print(f" [{i+1}] {sk.name} "

 f"[{sk.tier.value}|{sk.skill_type.value}|{sk.element.value}] "

 f"MP:{sk.mp_cost} PWR:{sk.power} ACC:{int(sk.accuracy*100)}%")

 while True:

 raw = input(" > ").strip()

 if raw == "0":

 return None

 try:

 idx = int(raw) - 1

 if 0 <= idx < len(ch.unlocked_skills):

 return ch.unlocked_skills[idx]

 except ValueError:

 pass

 print(" Invalid choice.")

 def _use_item_menu(self, ch: Character) -> bool:

 """Returns True if an item was successfully used."""

 from game_state import GameState

 # Items accessed via global inventory - we'll use a simplified approach

 # The GameState will be passed in during actual game run

 print(" (Item system: handled by game state)")

 return False # placeholder - overridden in actual game

 def _do_basic_attack(self, ch: Character, target: MonsterUnit):

 # Hit check

 hit = check_hit(ch.acc, target.eva)

 if not hit:

 self._log(f" {ch.name} attacks {target.instance_name}... MISS!")

 return

 is_crit = check_crit(ch.crit)

 # Weakness check

 is_weak = target.hit_weakness(ch.weapon, ch.element)

 weakness_bonus = 1.3 if is_weak else 1.0

 break_bonus = 1.5 if target.is_broken else 1.0

 dmg = calculate_physical_damage(

 ch.patk, target.pdef, power=1.0,

 crit=is_crit, weakness_bonus=weakness_bonus, break_bonus=break_bonus

 )

 # Defending reduction

 if ch.name in self._defending:

 dmg = int(dmg * 0.7)

 actual = target.take_damage(dmg)

 crit_str = " CRITICAL!" if is_crit else ""

 weak_str = " 【WEAKNESS】" if is_weak else ""

 self._log(f" {ch.name} attacks {target.instance_name}!{crit_str}{weak_str}")

 self._log(f" Dealt {actual} damage!")

 # Shield break

 if is_weak:

 broke = target.reduce_shield(1)

 if broke:

 self._log(f" ⚡ {target.instance_name} is BROKEN! All defenses down for 1 turn!")

 else:

 self._log(f" Shield: {target.shield_bar()} ({target.shield_points} remaining)")

 # Counter

 if target.has_status(StatusEffectType.COUNTER) and not target.is_dead:

 cdmg = calculate_physical_damage(target.patk, ch.pdef, power=0.5)

 ch.take_damage(cdmg)

 self._log(f" {target.instance_name} COUNTER! {ch.name} takes {cdmg} damage!")

 def _do_skill(self, ch: Character, skill: Skill):

 ch.current_mp -= skill.mp_cost

 # Determine targets

 targets_enemies = []

 targets_allies = []

 if skill.target == SkillTarget.SINGLE_ENEMY:

 t = self._pick_enemy_target()

 if t: targets_enemies = [t]

 elif skill.target == SkillTarget.ALL_ENEMIES:

 targets_enemies = [m for m in self.monsters if not m.is_dead]

 elif skill.target == SkillTarget.RANDOM_ENEMY:

 alive = [m for m in self.monsters if not m.is_dead]

 if alive:

 targets_enemies = random.choices(alive, k=skill.hits)

 elif skill.target == SkillTarget.SINGLE_ALLY:

 t = self._pick_ally_target(include_ko=skill.skill_type == SkillType.HEAL)

 if t: targets_allies = [t]

 elif skill.target == SkillTarget.ALL_ALLIES:

 targets_allies = [c for c in self.party if not c.is_dead]

 elif skill.target == SkillTarget.SELF:

 targets_allies = [ch]

 elem_name = f"[{skill.element.value}]" if skill.element != Element.NONE else ""

 self._log(f"\n ✦ {ch.name} uses {skill.name}!{elem_name}")

 # Heal skills

 if skill.skill_type == SkillType.HEAL:

 for target in targets_allies:

 if skill.mp_cost == 20 and skill.id == 46: # Resurrection special case

 if target.is_ko:

 target.revive(100)

 self._log(f" {target.name} is REVIVED with full HP!")

 else:

 self._log(f" {target.name} is already standing.")

 else:

 heal_amt = calculate_heal(ch.mdef, skill.power)

 actual = target.heal(heal_amt)

 self._log(f" {target.name} recovers {actual} HP!")

 return

 # Buff skills

 if skill.skill_type == SkillType.BUFF:

 if skill.effect:

 for target in targets_allies:

 se = StatusEffect(skill.effect.status, skill.effect.duration, skill.effect.stat_modifier)

 target.add_status(se)

 self._log(f" {target.name} gains {skill.effect.status.value}!")

 return

 # Debuff skills

 if skill.skill_type == SkillType.DEBUFF:

 for target in targets_enemies:

 if skill.effect and skill.effect.status:

 chance = skill.effect.chance if skill.effect.chance > 0 else 0.8

 if random.random() < chance:

 se = StatusEffect(skill.effect.status, skill.effect.duration)

 target.add_status(se)

 self._log(f" {target.instance_name} is afflicted with {skill.effect.status.value}!")

 else:

 self._log(f" {target.instance_name} resists!")

 return

 # Damage skills (physical / magical / special)

 num_hits = skill.hits if skill.target != SkillTarget.RANDOM_ENEMY else 1

 raw_targets = targets_enemies

 if skill.target == SkillTarget.RANDOM_ENEMY:

 alive = [m for m in self.monsters if not m.is_dead]

 raw_targets = []

 for _ in range(skill.hits):

 if alive: raw_targets.append(random.choice(alive))

 for target in raw_targets:

 for hit_n in range(num_hits if skill.target != SkillTarget.RANDOM_ENEMY else 1):

 # Hit check

 if not check_hit(ch.acc * skill.accuracy, target.eva):

 self._log(f" Hit {hit_n+1}: MISS on {target.instance_name}!")

 continue

 is_crit = check_crit(ch.crit)

 is_weak = target.hit_weakness(

 ch.weapon if skill.skill_type == SkillType.PHYSICAL else None,

 skill.element if skill.element != Element.NONE else ch.element

 )

 weakness_bonus = 1.3 if is_weak else 1.0

 break_bonus = 1.5 if target.is_broken else 1.0

 # Weakness mark doubles weakness

 if target.has_status(StatusEffectType.WEAKNESS_MARK) and is_weak:

 weakness_bonus *= 1.3

 if skill.skill_type == SkillType.PHYSICAL:

 dmg = calculate_physical_damage(

 ch.patk, target.pdef, skill.power,

 is_crit, weakness_bonus=weakness_bonus, break_bonus=break_bonus)

 else:

 # Magic boost

 matk = ch.matk

 if ch.has_status(StatusEffectType.MAGIC_BOOST):

 matk = int(matk * 1.4)

 # Reflect check

 if target.has_status(StatusEffectType.REFLECT):

 self._log(f" {target.instance_name} REFLECTS the spell!")

 friendly = [c for c in self.party if not c.is_ko and not c.is_dead]

 if friendly:

 rf_target = random.choice(friendly)

 rdmg = calculate_magical_damage(matk, rf_target.mdef, skill.power)

 rf_target.take_damage(rdmg)

 self._log(f" Reflected! {rf_target.name} takes {rdmg} damage!")

 continue

 dmg = calculate_magical_damage(

 matk, target.mdef, skill.power,

 is_crit, weakness_bonus=weakness_bonus, break_bonus=break_bonus)

 actual = target.take_damage(dmg)

 crit_str = " CRITICAL!" if is_crit else ""

 weak_str = " 【WEAKNESS】" if is_weak else ""

 self._log(f" {target.instance_name} takes {actual} damage!{crit_str}{weak_str}")

 # Shield damage for weakness hits

 if is_weak:

 broke = target.reduce_shield(1)

 if broke:

 self._log(f" ⚡ {target.instance_name} is BROKEN!")

 else:

 self._log(f" Shield: {target.shield_bar()}")

 # Apply effect

 if skill.effect and skill.effect.status and not target.is_dead:

 chance = skill.effect.chance if skill.effect.chance > 0 else 0.5

 if random.random() < chance:

 se = StatusEffect(skill.effect.status, skill.effect.duration,

 skill.effect.stat_modifier)

 target.add_status(se)

 self._log(f" {target.instance_name} afflicted with {skill.effect.status.value}!")

 def _do_defend(self, ch: Character):

 self._defending.add(ch.name)

 ch.add_status(StatusEffect(StatusEffectType.DEFENDING, 1))

 self._log(f" {ch.name} takes a defensive stance! (DMG -30% next turn, speed priority)")

 # ── Monster turn ──────────────────────────────────────────────────────

 def _monster_turn(self, mu: MonsterUnit):

 if mu.is_incapacitated():

 self._log(f"\n {mu.instance_name} is incapacitated and cannot act!")

 return

 alive_party = [ch for ch in self.party if not ch.is_ko and not ch.is_dead]

 if not alive_party:

 return

 action = mu.choose_action(alive_party)

 target = random.choice(alive_party)

 if action["action"] == "attack":

 self._monster_basic_attack(mu, target)

 elif action["action"] == "skill":

 skill_id = action["skill_id"]

 if skill_id in SKILL_DB:

 skill = SKILL_DB[skill_id]

 self._monster_skill(mu, skill, alive_party)

 else:

 self._monster_basic_attack(mu, target)

 elif action["action"] == "defend":

 self._log(f" {mu.instance_name} braces for impact!")

 def _monster_basic_attack(self, mu: MonsterUnit, target: Character):

 hit = check_hit(mu.acc, target.eva)

 if not hit:

 self._log(f"\n {mu.instance_name} attacks {target.name}... MISS!")

 return

 is_crit = check_crit(mu.template.base_stats.crit)

 # Defend reduction

 defending = target.has_status(StatusEffectType.DEFENDING)

 dmg = calculate_physical_damage(

 mu.patk, target.pdef, crit=is_crit)

 if defending:

 dmg = int(dmg * 0.7)

 # Confusion: might attack ally

 if mu.has_status(StatusEffectType.CONFUSION):

 alive_enemies = [m for m in self.monsters if not m.is_dead and m != mu]

 if alive_enemies and random.random() < 0.5:

 friendly_target = random.choice(alive_enemies)

 actual = friendly_target.take_damage(dmg)

 self._log(f"\n {mu.instance_name} is confused and attacks {friendly_target.instance_name}! ({actual} dmg)")

 return

 crit_str = " CRITICAL!" if is_crit else ""

 self._log(f"\n {mu.instance_name} attacks {target.name}!{crit_str}")

 target.take_damage(dmg)

 self._log(f" {target.name} takes {dmg} damage!")

 # Counter

 if target.has_status(StatusEffectType.COUNTER) and not target.is_ko:

 cdmg = calculate_physical_damage(target.patk, mu.pdef, power=0.5)

 mu.take_damage(cdmg)

 self._log(f" {target.name} COUNTER! {mu.instance_name} takes {cdmg}!")

 def _monster_skill(self, mu: MonsterUnit, skill: Skill, alive_party: List[Character]):

 self._log(f"\n {mu.instance_name} uses {skill.name}!")

 # Silence check for magic

 if skill.skill_type == SkillType.MAGICAL and mu.has_status(StatusEffectType.SILENCE):

 self._log(f" {mu.instance_name} is silenced!")

 return

 target = random.choice(alive_party)

 if skill.skill_type in (SkillType.PHYSICAL, SkillType.MAGICAL, SkillType.SPECIAL):

 for _ in range(skill.hits):

 if target.is_ko: break

 hit = check_hit(mu.acc * skill.accuracy, target.eva)

 if not hit:

 self._log(f" MISS on {target.name}!")

 continue

 is_crit = check_crit(mu.template.base_stats.crit)

 defending = target.has_status(StatusEffectType.DEFENDING)

 if skill.skill_type == SkillType.PHYSICAL:

 dmg = calculate_physical_damage(mu.patk, target.pdef, skill.power, is_crit)

 else:

 # Reflect check

 if target.has_status(StatusEffectType.REFLECT):

 self._log(f" {target.name} REFLECTS the spell!")

 rdmg = calculate_magical_damage(mu.matk, mu.mdef, skill.power)

 mu.take_damage(rdmg)

 self._log(f" Reflected! {mu.instance_name} takes {rdmg} damage!")

 continue

 dmg = calculate_magical_damage(mu.matk, target.mdef, skill.power, is_crit)

 if defending:

 dmg = int(dmg * 0.7)

 crit_str = " CRITICAL!" if is_crit else ""

 target.take_damage(dmg)

 self._log(f" {target.name} takes {dmg} damage!{crit_str}")

 if skill.effect and skill.effect.status and not target.is_ko:

 chance = skill.effect.chance if skill.effect.chance > 0 else 0.4

 if random.random() < chance:

 se = StatusEffect(skill.effect.status, skill.effect.duration,

 skill.effect.stat_modifier)

 target.add_status(se)

 self._log(f" {target.name} afflicted with {skill.effect.status.value}!")

 elif skill.skill_type == SkillType.HEAL:

 heal_amt = calculate_heal(mu.template.base_stats.mdef, skill.power)

 # Heal self or an alive ally monster

 alive_m = [m for m in [mu] if not m.is_dead]

 for m in alive_m:

 old = m.current_hp

 m.current_hp = min(m.max_hp, m.current_hp + heal_amt)

 self._log(f" {m.instance_name} recovers {m.current_hp - old} HP!")

 # ── End of round processing ───────────────────────────────────────────

 def _end_of_round(self):

 print(f"\n ── End of Turn {self.turn} ──")

 # Status effect ticks for party

 for ch in self.party:

 if not ch.is_ko and not ch.is_dead:

 msgs = ch.tick_status_effects()

 msgs += ch.tick_buffs()

 for m in msgs: self._log(m)

 # KO timer management

 for ch in self.party:

 if ch.is_ko and not ch.is_dead:

 ch.ko_turns += 1

 if ch.ko_turns >= 3:

 ch.is_dead = True

 self._log(f" 💀 {ch.name} has DIED! (Too long KO'd)")

 # Status ticks for monsters

 for mu in self.monsters:

 if not mu.is_dead:

 msgs = mu.tick_status_effects()

 for m in msgs: self._log(m)

 mu.tick_break()

 # Remove Defending status

 for ch in self.party:

 ch.remove_status(StatusEffectType.DEFENDING)

 if not self._check_battle_end():

 input("\n [Press Enter to continue]")

 def calculate_exp_reward(self) -> int:

 total = sum(mu.template.exp_reward for mu in self.monsters)

 return total

 def use_item_in_battle(self, ch: Character, item_id: int,

 inventory: Dict[int,int]) -> bool:

 """Use an item from inventory in battle. Returns True if used."""

 if item_id not in inventory or inventory[item_id] <= 0:

 print(" You don't have that item!")

 return False

 item = ITEM_DB[item_id]

 inventory[item_id] -= 1

 if inventory[item_id] <= 0:

 del inventory[item_id]

 self._log(f" {ch.name} uses {item.name}!")

 if item.item_type == ItemType.RECOVERY:

 # Determine target

 if item.target in (SkillTarget.SINGLE_ALLY, SkillTarget.SELF):

 valid = [c for c in self.party if not c.is_dead]

 if item.target == SkillTarget.SELF:

 valid = [ch]

 if not valid: return True

 target = valid[0] if len(valid)==1 else self._pick_ally_target()

 if not target: return True

 targets = [target]

 else:

 targets = [c for c in self.party if not c.is_dead]

 for t in targets:

 if item.effect_value == -100:

 t.current_hp = t.max_hp

 t.current_mp = t.max_mp

 self._log(f" {t.name} fully restored!")

 elif item.effect_value < 0:

 pct = abs(item.effect_value)

 amt = int(t.max_hp * pct / 100)

 actual = t.heal(amt)

 self._log(f" {t.name} recovers {actual} HP!")

 elif item.id in (6,7,8,9,12,20): # MP items

 mp_gain = min(item.effect_value, t.max_mp - t.current_mp)

 t.current_mp += mp_gain

 self._log(f" {t.name} recovers {mp_gain} MP!")

 else:

 actual = t.heal(item.effect_value)

 self._log(f" {t.name} recovers {actual} HP!")

 elif item.item_type == ItemType.REVIVAL:

 valid = [c for c in self.party if c.is_ko and not c.is_dead]

 if not valid:

 self._log(" No KO'd allies to revive!")

 return True

 target = valid[0] if len(valid)==1 else self._pick_ally_target(include_ko=True)

 if not target or not target.is_ko: return True

 if item.target == SkillTarget.ALL_ALLIES:

 for t in valid:

 t.revive(item.effect_value)

 self._log(f" {t.name} revived with {item.effect_value}% HP!")

 else:

 target.revive(item.effect_value)

 self._log(f" {target.name} revived with {item.effect_value}% HP!")

 elif item.item_type == ItemType.STATUS_CURE:

 valid = [c for c in self.party if not c.is_dead]

 if item.target == SkillTarget.ALL_ALLIES:

 targets = valid

 else:

 t = self._pick_ally_target()

 targets = [t] if t else []

 for t in targets:

 if item.status_cure:

 for stype in item.status_cure:

 t.remove_status(stype)

 self._log(f" {t.name} cleansed of ailments!")

 elif item.item_type == ItemType.BUFF:

 valid = [c for c in self.party if not c.is_dead and not c.is_ko]

 if item.target == SkillTarget.ALL_ALLIES:

 targets = valid

 elif item.target == SkillTarget.SELF:

 targets = [ch]

 else:

 t = self._pick_ally_target()

 targets = [t] if t else []

 for t in targets:

 if item.stat_buff:

 for stat, mult in item.stat_buff.items():

 t.add_buff(stat, mult, item.buff_duration)

 self._log(f" {t.name} gains buffs!")

 elif item.item_type == ItemType.OFFENSIVE:

 alive_enemies = [m for m in self.monsters if not m.is_dead]

 if item.target in (SkillTarget.SINGLE_ENEMY,):

 t = self._pick_enemy_target()

 if not t: return True

 targets = [t]

 else:

 targets = alive_enemies

 for t in targets:

 is_weak = item.element and t.hit_weakness(None, item.element)

 w_bonus = 1.3 if is_weak else 1.0

 b_bonus = 1.5 if t.is_broken else 1.0

 dmg = int(item.effect_value * w_bonus * b_bonus)

 actual = t.take_damage(dmg)

 w_str = " 【WEAKNESS】" if is_weak else ""

 self._log(f" {t.instance_name} takes {actual} damage!{w_str}")

 if is_weak:

 broke = t.reduce_shield(1)

 if broke:

 self._log(f" ⚡ {t.instance_name} is BROKEN!")

 elif item.item_type in (ItemType.ADVANCED, ItemType.REVIVAL):

 # Handle advanced items

 if item.effect_value == -100 or item.effect_value == 9999:

 valid = [c for c in self.party if not c.is_dead]

 for t in valid:

 if item.target == SkillTarget.ALL_ALLIES:

 pass

 elif item.target == SkillTarget.SINGLE_ALLY:

 t = self._pick_ally_target()

 valid = [t] if t else []

 break

 for t in valid:

 if item.effect_value == 9999:

 actual = t.heal(9999)

 self._log(f" {t.name} recovers {actual} HP!")

 else:

 t.current_hp = t.max_hp

 t.current_mp = t.max_mp

 self._log(f" {t.name} fully restored!")

 if item.stat_buff:

 for stat, mult in item.stat_buff.items():

 t.add_buff(stat, mult, item.buff_duration)

 return True