jpoke 0.1.0__py3-none-any.whl

jpoke/__init__.py

@@ -0,0 +1,22 @@
+"""jpokeパッケージ - ポケモンバトルシミュレータ。
+
+バトル、プレイヤー、ポケモン、技、特性、アイテムなどの主要クラスと、
+ポケモン図鑑データを提供します。
+"""
+from importlib.metadata import version as _version
+
+from .core import Battle, Player
+from .model import Pokemon, Ability, Item, Move
+from .data import POKEDEX
+
+__version__ = _version("jpoke")
+
+__all__ = [
+    "Battle",
+    "Player",
+    "Pokemon",
+    "Ability",
+    "Item",
+    "Move",
+    "POKEDEX",
+]

jpoke/core/__init__.py

@@ -0,0 +1,12 @@
+from .handler import Handler, HandlerReturn
+from .lethal import StateDist, LethalHandler, LethalContext
+from .context import BaseContext, EventContext, AttackContext
+from .event_manager import EventManager
+from .battle import Battle
+from .player import Player
+from .player_state import PlayerState
+from .ailment_manager import AilmentManager
+from .volatile_manager import VolatileManager
+from .field_manager import SideFieldManager
+from .status_manager import StatusManager
+from .query import PokemonQuery

jpoke/core/ability_manager.py

@@ -0,0 +1,167 @@
+"""特性の有効/無効状態管理モジュール。"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast
+if TYPE_CHECKING:
+    from .battle import Battle
+    from jpoke.model import Pokemon
+
+from jpoke.utils import fast_copy
+from jpoke.types import AbilityDisabledReason, AbilityName
+from jpoke.enums import Event
+from jpoke.model import Ability
+from .context import EventContext
+
+
+class AbilityManager:
+    """場の特性の有効/無効状態と発動状態を管理するクラス。
+
+    Attributes:
+        battle: 親となるBattleインスタンス
+    """
+
+    def __init__(self, battle: Battle):
+        self.battle = battle
+
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        new = cls.__new__(cls)
+        memo[id(self)] = new
+        fast_copy(self, new, keys_to_deepcopy=[])
+        return new
+
+    def update_reference(self, battle: Battle):
+        """Battleインスタンスの参照を更新する。
+
+        Args:
+            battle: 新しいBattleインスタンス
+        """
+        self.battle = battle
+
+    @property
+    def _events(self):
+        return self.battle.events
+
+    def _register_ability_handlers(self, mon: Pokemon):
+        """ポケモンの特性のハンドラをイベントマネージャに登録する。
+
+        Args:
+            mon: 対象のポケモン
+        """
+        mon.ability.register_handlers(self._events, mon)
+
+    def _unregister_ability_handlers(self, mon: Pokemon):
+        """ポケモンの特性のハンドラをイベントマネージャから解除する。
+
+        Args:
+            mon: 対象のポケモン
+        """
+        mon.ability.unregister_handlers(self._events, mon)
+
+    def is_change_blocked(self, mon: Pokemon) -> bool:
+        """特性の変更・入れ替えがとくせいガード等により防がれるかどうかを判定する。
+
+        Args:
+            mon: 特性を変更しようとしているポケモン
+
+        Returns:
+            変更が防がれる場合はTrue
+        """
+        ctx = EventContext(source=mon)
+        return self._events.emit(Event.ON_CHECK_ABILITY_DISABLE, ctx, False)
+
+    def change_ability(self, mon: Pokemon, ability: AbilityName) -> None:
+        """ポケモンの特性を更新し、ハンドラの登録/解除やイベントの発火を行う。
+        Args:
+            mon: 特性を変更するポケモン
+            ability: 新しい特性の名前
+        """
+        if mon.ability.base_name == ability:
+            return
+
+        if self.is_change_blocked(mon):
+            return
+
+        ctx = EventContext(source=mon)
+        is_active = self.battle.is_active(mon)
+
+        # 対象のポケモンが場に出ている場合は、古い特性のハンドラを解除し、イベントを発火する
+        if is_active:
+            self._unregister_ability_handlers(mon)
+            self._events.emit(Event.ON_ABILITY_DISABLED, ctx)
+
+        # 新しい特性に更新して公開する
+        mon.ability = Ability(ability)
+        mon.ability.revealed = True
+
+        # 対象のポケモンが場に出ている場合は、新しい特性のハンドラを登録し、イベントを発火する
+        if is_active:
+            self._register_ability_handlers(mon)
+            self._events.emit(Event.ON_ABILITY_ENABLED, ctx)
+
+    def swap_ability(self, mon1: Pokemon, mon2: Pokemon) -> None:
+        """2体のポケモンの特性を入れ替える。
+
+        どちらかの特性の変更がとくせいガード等により防がれる場合、
+        入れ替えは行われない（片方だけ入れ替わることはない）。
+
+        Args:
+            mon1: 1体目のポケモン
+            mon2: 2体目のポケモン
+        """
+        if self.is_change_blocked(mon1) or self.is_change_blocked(mon2):
+            return
+
+        ability1 = mon1.ability.base_name
+        ability2 = mon2.ability.base_name
+
+        # 両者の特性の無効化イベントをまとめて発火する
+        self._events.emit(Event.ON_ABILITY_DISABLED)
+
+        for mon, ability in ((mon1, ability2), (mon2, ability1)):
+            self._unregister_ability_handlers(mon)
+            mon.ability = Ability(cast(AbilityName, ability))
+            self._register_ability_handlers(mon)
+
+        # 両者の特性の有効化イベントをまとめて発火する
+        self._events.emit(Event.ON_ABILITY_ENABLED)
+
+    def add_disabled_reason(self, mon: Pokemon, reason: AbilityDisabledReason) -> bool:
+        """特性を無効にする理由を追加し、有効状態に変化があればイベントを発火する。
+        Args:
+            mon: 対象のポケモン
+            reason: 無効化の理由を示すキー
+        Returns:
+            特性の有効状態に変化があった場合はTrue、そうでない場合はFalse
+        """
+        ctx = EventContext(source=mon)
+        if self._events.emit(Event.ON_CHECK_ABILITY_DISABLE, ctx, False):
+            return False
+
+        was_enabled = mon.ability.enabled
+        mon.ability.add_disable_reason(reason)
+        is_enabled = mon.ability.enabled
+
+        if was_enabled and not is_enabled:
+            self._events.emit(Event.ON_ABILITY_DISABLED, ctx)
+            return True
+        return False
+
+    def remove_disabled_reason(self, mon: Pokemon, reason: AbilityDisabledReason) -> bool:
+        """特性を無効にする理由を削除し、有効状態に変化があればイベントを発火する。
+        Args:
+            mon: 対象のポケモン
+            reason: 無効化の理由を示すキー
+        Returns:
+            特性の有効状態に変化があった場合はTrue、そうでない場合はFalse
+        """
+        was_enabled = mon.ability.enabled
+        mon.ability.remove_disable_reason(reason)
+        is_enabled = mon.ability.enabled
+
+        if not was_enabled and is_enabled:
+            self._events.emit(
+                Event.ON_ABILITY_ENABLED,
+                EventContext(source=mon)
+            )
+            return True
+        return False

jpoke/core/ailment_manager.py

@@ -0,0 +1,181 @@
+"""ポケモンの状態管理（状態異常・揮発状態）を行うモジュール。
+
+Pokemonクラスから状態管理ロジックを分離し、Battleクラスに集約する。
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from jpoke.core import Battle, EventManager
+
+from jpoke.model import Pokemon, Ailment
+from jpoke.types import AilmentName
+from jpoke.enums import Event, LogCode
+from jpoke.core import EventContext, BaseContext
+from .log_payload import AilmentPayload
+from jpoke.utils import fast_copy
+
+
+class AilmentManager:
+    """ポケモンの状態異常を管理するクラス。
+
+    状態異常の付与、治療、ターン経過処理を担当。
+    Pokemonクラスから状態異常管理を分離し、単一責任原則を実現。
+
+    Attributes:
+        battle: 親となるBattleインスタンス
+    """
+
+    def __init__(self, battle: Battle):
+        self.battle = battle
+
+    def __deepcopy__(self, memo):
+        cls = self.__class__
+        new = cls.__new__(cls)
+        memo[id(self)] = new
+        fast_copy(self, new, keys_to_deepcopy=[])
+        return new
+
+    def update_reference(self, battle: Battle):
+        """Battleインスタンスの参照を更新。
+
+        Args:
+            battle: 新しいBattleインスタンス
+        """
+        self.battle = battle
+
+    @property
+    def _events(self) -> EventManager:
+        return self.battle.events
+
+    def apply(self,
+              target: Pokemon,
+              name: AilmentName,
+              count: int | None = None,
+              source: Pokemon | None = None,
+              overwrite: bool = False,
+              ctx: BaseContext | None = None) -> bool:
+        """状態異常を付与する。
+
+        Args:
+            target: 対象のポケモン
+            name: 状態異常名
+            count: 継続ターン数（ねむりは省略時に Champions 仕様で自動決定）
+            source: 状態異常の原因となったポケモン
+            overwrite: Trueの場合、既存の状態異常を上書き
+            ctx: ON_BEFORE_APPLY_AILMENT イベントの EventContext
+        Returns:
+            付与に成功したTrue
+
+        Note:
+            - overwrite=Falseの場合、既に状態異常があれば失敗
+            - 同じ状態異常の重ね掛けは不可
+            - ねむりの count=None 時は Champions 仕様で自動決定（2: 1/3、3: 2/3）
+        """
+        # ねむりのcountをChampions仕様で自動決定（count=Noneのとき）
+        if name == "ねむり" and count is None:
+            count = 2 if self.battle.random.random() < 1 / 3 else 3
+
+        # overwrite=True でない限り上書き不可
+        if target.ailment.is_active and not overwrite:
+            return False
+
+        # overwrite=True でも uncurable は上書き不可
+        if target.ailment.is_active and target.ailment.uncurable:
+            return False
+
+        # 重ねがけ不可
+        if name == target.ailment.name:
+            return False
+
+        # タイプによる無効化をチェック
+        if not self._can_apply_by_type(name, target, source):
+            return False
+
+        # ON_BEFORE_APPLY_AILMENT イベントを発火して特性などによる無効化をチェック
+        if ctx is not None:
+            apply_ctx = EventContext(source=source, target=target)
+        else:
+            apply_ctx = EventContext(target=target, source=source)
+
+        # ハンドラーが空値を返した場合は状態異常を付与しない
+        resolved_name = self._events.emit(Event.ON_BEFORE_APPLY_AILMENT, apply_ctx, name)
+        if not resolved_name:
+            return False
+
+        # 既存のハンドラを削除
+        target.ailment.unregister_handlers(self._events, target)
+
+        # 新しい状態異常を設定してハンドラ登録
+        self.battle.add_event_log(
+            target,
+            LogCode.AILMENT_APPLIED,
+            payload=AilmentPayload(ailment=resolved_name, source=source.name if source else None)
+        )
+        target.ailment = Ailment(resolved_name, count=count)
+        target.ailment.register_handlers(self._events, target)
+
+        # 付与後イベントを発火（シンクロ等のリアクション用）
+        self._events.emit(Event.ON_APPLY_AILMENT, apply_ctx, resolved_name)
+        return True
+
+    def _can_apply_by_type(self,
+                           ailment: AilmentName,
+                           target: Pokemon,
+                           source: Pokemon | None) -> bool:
+        """タイプによって状態異常を付与できるか判定する。"""
+        match ailment:
+            case "どく" | "もうどく":
+                if source is not None and source.ability.name == "ふしょく":
+                    return True
+                return not (target.has_type("どく") or target.has_type("はがね"))
+            case "やけど":
+                return not target.has_type("ほのお")
+
+            case "まひ":
+                return not target.has_type("でんき")
+
+            case "こおり":
+                return not target.has_type("こおり")
+
+        return True
+
+    def remove(self, target: Pokemon) -> bool:
+        """状態異常を解除する。
+
+        Args:
+            target: 対象のポケモン
+
+        Returns:
+            解除に成功したらTrue
+        """
+        if not target.ailment.is_active:
+            return False
+
+        # 回復不能な状態異常は解除しない
+        if target.ailment.uncurable:
+            return False
+
+        self.battle.add_event_log(
+            target,
+            LogCode.AILMENT_REMOVED,
+            payload=AilmentPayload(ailment=target.ailment.name)
+        )
+        target.ailment.unregister_handlers(self._events, target)
+        target.ailment = Ailment()
+        return True
+
+    def tick(self, target: Pokemon) -> bool:
+        """状態異常のターン経過処理を行う。
+
+        Args:
+            target: 対象のポケモン
+
+        Returns:
+            ターン経過処理を行った場合True、状態異常がない場合False
+        """
+        if not target.ailment.is_active:
+            return False
+        target.ailment.tick()
+        if target.ailment.count == 0:
+            self.remove(target)
+        return True