scripts/item.py

Part of Dungeon Explorer.

"""Item class: base template + affixes + stat rolls.

An Item is composed of:
- A base template (from items.toml)
- 0+ prefix affixes
- 0+ suffix affixes
- A rarity tier (common=0, uncommon=1, rare=2, epic=3, legendary=4)
- Stat rolls derived from the item level (ilvl)
"""

from dataclasses import dataclass, field
from enum import IntEnum


class Rarity(IntEnum):
    COMMON = 0
    UNCOMMON = 1
    RARE = 2
    EPIC = 3
    LEGENDARY = 4


RARITY_NAMES = {
    Rarity.COMMON: "Common",
    Rarity.UNCOMMON: "Uncommon",
    Rarity.RARE: "Rare",
    Rarity.EPIC: "Epic",
    Rarity.LEGENDARY: "Legendary",
}

RARITY_COLOURS = {
    Rarity.COMMON: (0.7, 0.7, 0.7, 1.0),
    Rarity.UNCOMMON: (0.3, 0.8, 0.3, 1.0),
    Rarity.RARE: (0.3, 0.5, 1.0, 1.0),
    Rarity.EPIC: (0.7, 0.3, 0.9, 1.0),
    Rarity.LEGENDARY: (1.0, 0.65, 0.0, 1.0),
}

EQUIPMENT_SLOTS = ("weapon", "offhand", "head", "body", "feet", "ring", "neck")


@dataclass
class Affix:
    """A single prefix or suffix on an item."""

    name: str  # e.g. "Keen", "of Fire"
    affix_type: str  # "prefix" or "suffix"
    stat: str  # e.g. "damage", "crit_chance"
    value: float  # Rolled value

    def display_text(self) -> str:
        if isinstance(self.value, float) and self.value < 1:
            return f"+{self.value:.0%} {self.stat.replace('_', ' ')}"
        return f"+{int(self.value)} {self.stat.replace('_', ' ')}"


@dataclass
class Item:
    """A single item instance with template, affixes, and stats."""

    template_key: str  # e.g. "sword"
    display_base: str  # e.g. "Iron Sword"
    slot: str  # e.g. "weapon", "head", "body"
    rarity: Rarity = Rarity.COMMON
    ilvl: int = 1
    prefixes: list[Affix] = field(default_factory=list)
    suffixes: list[Affix] = field(default_factory=list)
    base_stats: dict[str, float] = field(default_factory=dict)
    stack_size: int = 1
    stack_count: int = 1
    durability: int = 100  # Current durability (0 = broken)
    max_durability: int = 100  # Max durability

    @property
    def display_name(self) -> str:
        """Full item name: '{Prefix} {Base} {Suffix}'."""
        parts = []
        if self.prefixes:
            parts.append(self.prefixes[0].name)
        parts.append(self.display_base)
        if self.suffixes:
            parts.append(self.suffixes[0].name)
        return " ".join(parts)

    @property
    def colour(self) -> tuple:
        return RARITY_COLOURS[self.rarity]

    @property
    def rarity_name(self) -> str:
        return RARITY_NAMES[self.rarity]

    @property
    def is_equipment(self) -> bool:
        return self.slot in EQUIPMENT_SLOTS

    @property
    def is_consumable(self) -> bool:
        return self.slot == "consumable"

    @property
    def is_stackable(self) -> bool:
        return self.stack_size > 1

    @property
    def is_broken(self) -> bool:
        """Equipment with 0 durability provides no stats."""
        return self.is_equipment and self.durability <= 0

    def degrade(self, amount: int = 1):
        """Reduce durability. Only affects equipment."""
        if self.is_equipment and self.durability > 0:
            self.durability = max(0, self.durability - amount)

    def repair(self, amount: int | None = None):
        """Restore durability. None = full repair."""
        if amount is None:
            self.durability = self.max_durability
        else:
            self.durability = min(self.max_durability, self.durability + amount)

    @property
    def durability_ratio(self) -> float:
        return self.durability / max(1, self.max_durability)

    def total_stats(self) -> dict[str, float]:
        """Compute total stats from base + all affixes. Broken items give nothing."""
        if self.is_broken:
            return {}
        stats = dict(self.base_stats)
        for affix in self.prefixes + self.suffixes:
            stats[affix.stat] = stats.get(affix.stat, 0) + affix.value
        return stats

    def get_stat(self, key: str, default: float = 0) -> float:
        return self.total_stats().get(key, default)

    def to_dict(self) -> dict:
        """Serialise to a JSON-compatible dict."""
        return {
            "template_key": self.template_key,
            "display_base": self.display_base,
            "slot": self.slot,
            "rarity": int(self.rarity),
            "ilvl": self.ilvl,
            "prefixes": [
                {"name": a.name, "type": a.affix_type, "stat": a.stat, "value": a.value} for a in self.prefixes
            ],
            "suffixes": [
                {"name": a.name, "type": a.affix_type, "stat": a.stat, "value": a.value} for a in self.suffixes
            ],
            "base_stats": self.base_stats,
            "stack_size": self.stack_size,
            "stack_count": self.stack_count,
            "durability": self.durability,
            "max_durability": self.max_durability,
        }

    @classmethod
    def from_dict(cls, d: dict) -> Item:
        """Deserialise from a dict."""
        prefixes = [
            Affix(name=a["name"], affix_type=a["type"], stat=a["stat"], value=a["value"]) for a in d.get("prefixes", [])
        ]
        suffixes = [
            Affix(name=a["name"], affix_type=a["type"], stat=a["stat"], value=a["value"]) for a in d.get("suffixes", [])
        ]
        return cls(
            template_key=d["template_key"],
            display_base=d["display_base"],
            slot=d["slot"],
            rarity=Rarity(d.get("rarity", 0)),
            ilvl=d.get("ilvl", 1),
            prefixes=prefixes,
            suffixes=suffixes,
            base_stats=d.get("base_stats", {}),
            stack_size=d.get("stack_size", 1),
            stack_count=d.get("stack_count", 1),
            durability=d.get("durability", 100),
            max_durability=d.get("max_durability", 100),
        )