character.py

"""Character class - handles stats, leveling, skills, status effects."""

from __future__ import annotations

import random

from dataclasses import dataclass, field

from typing import List, Dict, Optional, Tuple

from data_types import *

from skills_db import SKILL_DB, JOB_SKILL_POOL

# ── Base stats per job ────────────────────────────────────────────────────────

JOB_BASE_STATS: Dict[JobClass, Stats] = {

 JobClass.WARRIOR: Stats(220,40, 28,8, 18,12,12,0.06,0.88,0.10),

 JobClass.KNIGHT: Stats(280,50, 22,8, 28,18,10,0.04,0.87,0.06),

 JobClass.PALADIN: Stats(260,80, 20,18, 24,22,11,0.05,0.87,0.07),

 JobClass.BERSERKER: Stats(240,30, 35,6, 14,10,13,0.05,0.83,0.18),

 JobClass.ASSASSIN: Stats(180,60, 26,14, 12,14,20,0.18,0.90,0.22),

 JobClass.RANGER: Stats(190,55, 24,12, 14,14,18,0.14,0.92,0.16),

 JobClass.HUNTER: Stats(195,55, 24,12, 15,14,17,0.13,0.91,0.15),

 JobClass.SPEARMAN: Stats(210,45, 26,8, 16,14,15,0.08,0.88,0.10),

 JobClass.DRAGOON: Stats(220,50, 28,10, 16,15,16,0.09,0.88,0.12),

 JobClass.MONK: Stats(230,45, 30,8, 16,12,18,0.10,0.89,0.12),

 JobClass.CLERIC: Stats(180,100,14,26, 16,24,12,0.05,0.87,0.05),

 JobClass.PRIEST: Stats(170,120,12,28, 14,26,11,0.04,0.86,0.04),

 JobClass.FIRE_MAGE: Stats(160,110,10,34, 10,18,13,0.07,0.87,0.08),

 JobClass.ICE_MAGE: Stats(160,110,10,32, 12,20,12,0.07,0.87,0.08),

 JobClass.STORM_MAGE: Stats(160,110,10,33, 10,18,14,0.08,0.87,0.08),

 JobClass.WIND_MAGE: Stats(155,105,10,30, 10,18,16,0.10,0.88,0.08),

 JobClass.EARTH_MAGE: Stats(170,105,12,30, 14,20,11,0.06,0.87,0.07),

 JobClass.DARK_MAGE: Stats(165,110,10,35, 10,16,14,0.09,0.87,0.12),

 JobClass.LIGHT_MAGE: Stats(165,110,10,33, 12,20,13,0.07,0.87,0.08),

 JobClass.ARCANE_SAGE:Stats(175,130,12,36, 12,22,12,0.07,0.88,0.10),

}

JOB_GROWTH: Dict[JobClass, GrowthRates] = {

 JobClass.WARRIOR: GrowthRates(0.85,0.40,0.65,0.30,0.55,0.40,0.40,0.20,0.35,0.25),

 JobClass.KNIGHT: GrowthRates(0.90,0.45,0.50,0.25,0.70,0.55,0.30,0.15,0.30,0.15),

 JobClass.PALADIN: GrowthRates(0.88,0.60,0.48,0.42,0.60,0.60,0.32,0.18,0.32,0.18),

 JobClass.BERSERKER: GrowthRates(0.82,0.30,0.75,0.20,0.40,0.30,0.45,0.15,0.28,0.40),

 JobClass.ASSASSIN: GrowthRates(0.65,0.55,0.58,0.35,0.35,0.42,0.65,0.50,0.55,0.60),

 JobClass.RANGER: GrowthRates(0.70,0.55,0.55,0.38,0.38,0.42,0.55,0.45,0.60,0.45),

 JobClass.HUNTER: GrowthRates(0.72,0.55,0.55,0.38,0.40,0.42,0.52,0.42,0.58,0.42),

 JobClass.SPEARMAN: GrowthRates(0.78,0.45,0.60,0.28,0.48,0.40,0.50,0.25,0.40,0.28),

 JobClass.DRAGOON: GrowthRates(0.80,0.48,0.62,0.32,0.48,0.42,0.52,0.28,0.42,0.32),

 JobClass.MONK: GrowthRates(0.80,0.42,0.65,0.25,0.50,0.38,0.55,0.30,0.45,0.35),

 JobClass.CLERIC: GrowthRates(0.72,0.75,0.28,0.58,0.45,0.65,0.35,0.20,0.32,0.15),

 JobClass.PRIEST: GrowthRates(0.68,0.80,0.25,0.62,0.42,0.70,0.32,0.18,0.30,0.12),

 JobClass.FIRE_MAGE: GrowthRates(0.60,0.78,0.22,0.72,0.28,0.48,0.40,0.22,0.35,0.22),

 JobClass.ICE_MAGE: GrowthRates(0.60,0.78,0.22,0.70,0.30,0.50,0.38,0.22,0.35,0.22),

 JobClass.STORM_MAGE: GrowthRates(0.60,0.78,0.22,0.72,0.28,0.48,0.42,0.22,0.35,0.22),

 JobClass.WIND_MAGE: GrowthRates(0.58,0.75,0.22,0.68,0.28,0.48,0.50,0.28,0.38,0.20),

 JobClass.EARTH_MAGE: GrowthRates(0.65,0.75,0.25,0.68,0.35,0.50,0.35,0.18,0.32,0.18),

 JobClass.DARK_MAGE: GrowthRates(0.60,0.78,0.20,0.75,0.26,0.46,0.42,0.28,0.35,0.30),

 JobClass.LIGHT_MAGE: GrowthRates(0.62,0.78,0.22,0.72,0.30,0.52,0.40,0.22,0.34,0.20),

 JobClass.ARCANE_SAGE:GrowthRates(0.65,0.82,0.28,0.78,0.32,0.55,0.42,0.25,0.38,0.25),

}

@dataclass

class Character:

 name: str

 job: JobClass

 weapon: WeaponType

 element: Element

 rarity: int # 0=player, 3/4/5=companion

 base_stats: Stats

 growth: GrowthRates

 # All skills the character CAN have (assigned at creation)

 skill_pool: List[int] = field(default_factory=list) # 5 skill ids

 # Skills currently UNLOCKED

 unlocked_skills: List[int] = field(default_factory=list)

 level: int = 1

 exp: int = 0

 exp_to_next: int = 100

 # Runtime state

 current_hp: int = 0

 current_mp: int = 0

 status_effects: List[StatusEffect] = field(default_factory=list)

 temp_buffs: Dict[str, Tuple[float,int]] = field(default_factory=dict) # stat -> (mult, turns_remaining)

 is_dead: bool = False # permanent death

 ko_turns: int = 0 # turns spent at 0 hp (KO counter)

 is_ko: bool = False # currently knocked out in battle

 battle_count: int = 0 # total battles participated

 def __post_init__(self):

 if self.current_hp == 0:

 self.current_hp = self.base_stats.hp

 if self.current_mp == 0:

 self.current_mp = self.base_stats.mp

 # ── Stat helpers ─────────────────────────────────────────────────────

 def effective_stat(self, stat_name: str) -> float:

 base = getattr(self.base_stats, stat_name)

 mult = 1.0

 for effect_name, (m, turns) in self.temp_buffs.items():

 if effect_name == stat_name:

 mult *= m

 # Status effects

 for se in self.status_effects:

 if se.effect_type == StatusEffectType.ATTACK_DOWN and stat_name == "patk":

 mult *= 0.7

 elif se.effect_type == StatusEffectType.DEFENSE_DOWN and stat_name == "pdef":

 mult *= 0.7

 elif se.effect_type == StatusEffectType.MAGIC_DOWN and stat_name == "matk":

 mult *= 0.7

 elif se.effect_type == StatusEffectType.SPEED_DOWN and stat_name == "spd":

 mult *= 0.7

 elif se.effect_type == StatusEffectType.ACCURACY_DOWN and stat_name == "acc":

 mult *= 0.6

 elif se.effect_type == StatusEffectType.BERSERK:

 if stat_name == "patk": mult *= 1.5

 if stat_name == "pdef": mult *= 0.7

 elif se.effect_type == StatusEffectType.GUARD_UP:

 if stat_name in ("pdef","mdef"): mult *= 1.4

 elif se.effect_type == StatusEffectType.FOCUS:

 if stat_name in ("acc","crit"): mult *= 1.5

 elif se.effect_type == StatusEffectType.MAGIC_BOOST:

 if stat_name == "matk": mult *= 1.4

 elif se.effect_type == StatusEffectType.HASTE:

 if stat_name == "spd": mult *= 1.5

 return base * mult

 @property

 def max_hp(self): return self.base_stats.hp

 @property

 def max_mp(self): return self.base_stats.mp

 @property

 def spd(self): return int(self.effective_stat("spd"))

 @property

 def patk(self): return int(self.effective_stat("patk"))

 @property

 def matk(self): return int(self.effective_stat("matk"))

 @property

 def pdef(self): return int(self.effective_stat("pdef"))

 @property

 def mdef(self): return int(self.effective_stat("mdef"))

 @property

 def eva(self): return self.effective_stat("eva")

 @property

 def acc(self): return self.effective_stat("acc")

 @property

 def crit(self): return self.effective_stat("crit")

 def is_incapacitated(self) -> bool:

 """Cannot act at all."""

 incap = {StatusEffectType.SLEEP, StatusEffectType.STUN,

 StatusEffectType.FREEZE, StatusEffectType.PARALYZE,

 StatusEffectType.PETRIFY, StatusEffectType.TIME_STOP}

 return any(se.effect_type in incap for se in self.status_effects) or self.is_ko

 def can_use_magic(self) -> bool:

 blocked = {StatusEffectType.SILENCE, StatusEffectType.MANA_BURN}

 return not any(se.effect_type in blocked for se in self.status_effects)

 def can_use_skills(self) -> bool:

 return not any(se.effect_type == StatusEffectType.SKILL_SEAL for se in self.status_effects)

 def can_use_items(self) -> bool:

 return not any(se.effect_type == StatusEffectType.ITEM_SEAL for se in self.status_effects)

 def can_be_healed(self) -> bool:

 return not any(se.effect_type == StatusEffectType.HEAL_BLOCK for se in self.status_effects)

 def has_status(self, stype: StatusEffectType) -> bool:

 return any(se.effect_type == stype for se in self.status_effects)

 def add_status(self, effect: StatusEffect):

 # Don't stack same type (refresh duration instead)

 for existing in self.status_effects:

 if existing.effect_type == effect.effect_type:

 existing.duration = max(existing.duration, effect.duration)

 return

 self.status_effects.append(effect)

 def remove_status(self, stype: StatusEffectType):

 self.status_effects = [s for s in self.status_effects if s.effect_type != stype]

 def add_buff(self, stat: str, mult: float, duration: int):

 if stat in self.temp_buffs:

 old_mult, old_dur = self.temp_buffs[stat]

 self.temp_buffs[stat] = (max(old_mult, mult), max(old_dur, duration))

 else:

 self.temp_buffs[stat] = (mult, duration)

 def tick_status_effects(self) -> List[str]:

 """Process status effects at turn end. Returns list of messages."""

 messages = []

 to_remove = []

 for se in self.status_effects:

 msg = self._apply_status_tick(se)

 if msg:

 messages.append(msg)

 if not se.tick():

 to_remove.append(se)

 self.status_effects = [s for s in self.status_effects if s not in to_remove]

 for expired in to_remove:

 messages.append(f" {self.name}'s {expired.effect_type.value} wore off.")

 return messages

 def _apply_status_tick(self, se: StatusEffect) -> Optional[str]:

 if se.effect_type == StatusEffectType.POISON:

 dmg = max(1, int(self.max_hp * 0.05))

 self.take_damage(dmg)

 return f" {self.name} is poisoned! (-{dmg} HP)"

 elif se.effect_type == StatusEffectType.VENOM:

 dmg = max(1, int(self.max_hp * 0.08))

 self.take_damage(dmg)

 return f" {self.name} suffers venom! (-{dmg} HP)"

 elif se.effect_type == StatusEffectType.BURN:

 dmg = max(1, int(self.max_hp * 0.06))

 self.take_damage(dmg)

 return f" {self.name} is burning! (-{dmg} HP)"

 elif se.effect_type == StatusEffectType.BLEED:

 dmg = max(1, int(self.max_hp * 0.04))

 self.take_damage(dmg)

 return f" {self.name} bleeds! (-{dmg} HP)"

 elif se.effect_type == StatusEffectType.CURSE:

 dmg = max(1, int(self.max_hp * 0.03))

 self.take_damage(dmg)

 return f" {self.name} is cursed! (-{dmg} HP)"

 elif se.effect_type == StatusEffectType.REGEN:

 heal = max(1, int(self.mdef * 1.5))

 self.heal(heal)

 return f" {self.name} regenerates! (+{heal} HP)"

 elif se.effect_type == StatusEffectType.MANA_REGEN:

 mp = max(1, int(self.max_mp * 0.05))

 self.current_mp = min(self.max_mp, self.current_mp + mp)

 return f" {self.name} regenerates MP! (+{mp} MP)"

 elif se.effect_type == StatusEffectType.DOOM:

 if se.duration <= 1:

 self.current_hp = 0

 self.is_ko = True

 return f" ☠ DOOM strikes {self.name}! Instant KO!"

 else:

 return f" ⏳ DOOM countdown: {se.duration} turns left for {self.name}!"

 return None

 def tick_buffs(self) -> List[str]:

 messages = []

 expired = [k for k,(m,d) in self.temp_buffs.items() if d <= 1]

 self.temp_buffs = {k:(m,d-1) for k,(m,d) in self.temp_buffs.items() if d > 1}

 for k in expired:

 messages.append(f" {self.name}'s {k} buff expired.")

 return messages

 def take_damage(self, amount: int):

 # Check shield

 if self.has_status(StatusEffectType.SHIELD):

 se = next(s for s in self.status_effects if s.effect_type == StatusEffectType.SHIELD)

 shield_val = int(se.power)

 if shield_val >= amount:

 se.power -= amount

 if se.power <= 0:

 self.remove_status(StatusEffectType.SHIELD)

 return

 else:

 amount -= shield_val

 self.remove_status(StatusEffectType.SHIELD)

 self.current_hp = max(0, self.current_hp - amount)

 if self.current_hp == 0:

 self.is_ko = True

 def heal(self, amount: int):

 if not self.can_be_healed():

 return 0

 actual = min(amount, self.max_hp - self.current_hp)

 self.current_hp += actual

 if self.current_hp > 0:

 self.is_ko = False

 self.ko_turns = 0

 return actual

 def revive(self, hp_percent: int):

 self.is_ko = False

 self.ko_turns = 0

 self.current_hp = max(1, int(self.max_hp * hp_percent / 100))

 # ── Leveling ─────────────────────────────────────────────────────────

 def gain_exp(self, amount: int) -> List[str]:

 messages = []

 self.exp += amount

 while self.exp >= self.exp_to_next:

 self.exp -= self.exp_to_next

 messages += self._level_up()

 return messages

 def _level_up(self) -> List[str]:

 self.level += 1

 self.exp_to_next = int(self.exp_to_next * 1.15)

 g = self.growth

 messages = [f" ★ {self.name} reached Level {self.level}!"]

 def roll(rate, lo, hi):

 return random.randint(lo, hi) if random.random() < rate else 0

 hp_gain = roll(g.hp, 5, 12)

 mp_gain = roll(g.mp, 3, 8)

 patk_gain = roll(g.patk, 1, 4)

 matk_gain = roll(g.matk, 1, 4)

 pdef_gain = roll(g.pdef, 1, 3)

 mdef_gain = roll(g.mdef, 1, 3)

 spd_gain = roll(g.spd, 1, 1)

 eva_gain = roll(g.eva, 0, 0) # tracked differently

 acc_gain = 0

 crit_gain = 0

 self.base_stats.hp += hp_gain

 self.base_stats.mp += mp_gain

 self.base_stats.patk += patk_gain

 self.base_stats.matk += matk_gain

 self.base_stats.pdef += pdef_gain

 self.base_stats.mdef += mdef_gain

 self.base_stats.spd += spd_gain

 if random.random() < g.eva: self.base_stats.eva = min(0.95, self.base_stats.eva + 0.01)

 if random.random() < g.acc: self.base_stats.acc = min(1.0, self.base_stats.acc + 0.005)

 if random.random() < g.crit: self.base_stats.crit= min(0.95, self.base_stats.crit+ 0.005)

 # Heal to full on level up

 self.current_hp = self.base_stats.hp

 self.current_mp = self.base_stats.mp

 gains = []

 if hp_gain: gains.append(f"HP+{hp_gain}")

 if mp_gain: gains.append(f"MP+{mp_gain}")

 if patk_gain: gains.append(f"PATK+{patk_gain}")

 if matk_gain: gains.append(f"MATK+{matk_gain}")

 if pdef_gain: gains.append(f"PDEF+{pdef_gain}")

 if mdef_gain: gains.append(f"MDEF+{mdef_gain}")

 if spd_gain: gains.append(f"SPD+{spd_gain}")

 if gains:

 messages.append(f" Stats: {', '.join(gains)}")

 # Unlock skills

 unlock_msgs = self._check_skill_unlocks()

 messages.extend(unlock_msgs)

 return messages

 def _check_skill_unlocks(self) -> List[str]:

 msgs = []

 # Intermediate: lv 5 and 10

 intermediate_ids = [sid for sid in self.skill_pool

 if sid in SKILL_DB and SKILL_DB[sid].tier == SkillTier.INTERMEDIATE]

 if self.level == 5 and len(intermediate_ids) >= 1:

 sid = intermediate_ids[0]

 if sid not in self.unlocked_skills:

 self.unlocked_skills.append(sid)

 msgs.append(f" ✦ Skill Unlocked: {SKILL_DB[sid].name}!")

 if self.level == 10 and len(intermediate_ids) >= 2:

 sid = intermediate_ids[1]

 if sid not in self.unlocked_skills:

 self.unlocked_skills.append(sid)

 msgs.append(f" ✦ Skill Unlocked: {SKILL_DB[sid].name}!")

 # Ultimate: lv 20

 if self.level == 20:

 ultimate_ids = [sid for sid in self.skill_pool

 if sid in SKILL_DB and SKILL_DB[sid].tier == SkillTier.ULTIMATE]

 if ultimate_ids:

 sid = ultimate_ids[0]

 if sid not in self.unlocked_skills:

 self.unlocked_skills.append(sid)

 msgs.append(f" ★ ULTIMATE SKILL UNLOCKED: {SKILL_DB[sid].name}!!")

 return msgs

 def hp_bar(self, width=20) -> str:

 ratio = self.current_hp / max(1, self.max_hp)

 filled = int(ratio * width)

 bar = "█" * filled + "░" * (width - filled)

 return f"[{bar}] {self.current_hp}/{self.max_hp}"

 def mp_bar(self, width=10) -> str:

 ratio = self.current_mp / max(1, self.max_mp)

 filled = int(ratio * width)

 bar = "▓" * filled + "░" * (width - filled)

 return f"[{bar}] {self.current_mp}/{self.max_mp}"

 def status_str(self) -> str:

 if not self.status_effects:

 return ""

 tags = [se.effect_type.value[:3].upper() for se in self.status_effects]

 return " [" + ",".join(tags) + "]"

 def short_status(self) -> str:

 if self.is_dead: return "DEAD"

 if self.is_ko: return f"KO({self.ko_turns})"

 return "OK"

def create_player_character(name: str, job: JobClass,

 weapon: WeaponType, element: Element) -> Character:

 base = JOB_BASE_STATS[job].copy()

 growth = JOB_GROWTH[job]

 pool = JOB_SKILL_POOL[job]

 # Pick 2 basic, 2 intermediate, 1 ultimate from pool

 basics = [sid for sid in pool if SKILL_DB[sid].tier == SkillTier.BASIC][:4]

 inters = [sid for sid in pool if SKILL_DB[sid].tier == SkillTier.INTERMEDIATE][:4]

 ultims = [sid for sid in pool if SKILL_DB[sid].tier == SkillTier.ULTIMATE][:2]

 chosen_basic = random.sample(basics, min(2, len(basics)))

 chosen_inter = random.sample(inters, min(2, len(inters)))

 chosen_ultim = random.sample(ultims, min(1, len(ultims)))

 skill_pool = chosen_basic + chosen_inter + chosen_ultim

 unlocked = chosen_basic[:] # Only basics at level 1

 char = Character(

 name=name, job=job, weapon=weapon, element=element, rarity=0,

 base_stats=base, growth=growth,

 skill_pool=skill_pool, unlocked_skills=unlocked

 )

 return char