nodes/enemy_types.py

Part of Dungeon Explorer.

"""Concrete enemy variants: melee, ranged, swarm, boss."""

import random as _rng_mod

from simvx.core import Vec2

from .enemy_base import (
    AFFIX_FAST,
    ALL_AFFIXES,
    ATTACK,
    CHASE,
    IDLE,
    EnemyBase,
)

_ARCHETYPE_COLOURS = {
    "skeleton": (0.85, 0.82, 0.75, 1.0),
    "archer_skeleton": (0.7, 0.5, 0.8, 1.0),
    "slime": (0.3, 0.8, 0.2, 1.0),
    "bat_swarm": (0.4, 0.3, 0.25, 1.0),
    "goblin": (0.35, 0.55, 0.25, 1.0),
    "wraith": (0.5, 0.3, 0.7, 0.6),
    "golem": (0.5, 0.45, 0.35, 1.0),
    "demon": (0.85, 0.15, 0.1, 1.0),
}


class MeleeEnemy(EnemyBase):
    """Standard melee enemy that chases and attacks."""

    def __init__(self, **kwargs):
        super().__init__(ai_type="chase", **kwargs)
        self._colour = (0.8, 0.3, 0.2, 1.0)


class RangedEnemy(EnemyBase):
    """Ranged enemy that kites: approaches to range then retreats. Hits hard from distance."""

    def __init__(self, **kwargs):
        super().__init__(ai_type="kite", **kwargs)
        self.attack_range = 180.0
        self.attack_cooldown = 0.8  # Faster than melee default (1.0)
        self._colour = (0.6, 0.2, 0.7, 1.0)


class SwarmEnemy(EnemyBase):
    """Weak, fast enemy that chases aggressively."""

    def __init__(self, **kwargs):
        super().__init__(ai_type="chase", **kwargs)
        self.hp = 10
        self.max_hp = 10
        self.speed = 90.0
        self.damage = 2
        self.attack_range = 24.0  # Same as default: attack when close
        self.attack_cooldown = 0.4  # Attacks frequently
        self._colour = (0.4, 0.3, 0.2, 1.0)


class PatrolEnemy(EnemyBase):
    """Slow, tough enemy that patrols an area."""

    def __init__(self, **kwargs):
        super().__init__(ai_type="patrol", **kwargs)
        self.hp = 80
        self.max_hp = 80
        self.speed = 30.0
        self.damage = 15
        self.detection_range = 120.0
        self._colour = (0.5, 0.5, 0.3, 1.0)


class WraithEnemy(RangedEnemy):
    """Wraith: phases through walls periodically."""

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._phase_timer = 0.0
        self._phasing = False

    def on_fixed_update(self, dt: float):
        self._phase_timer += dt
        # Phase through walls for 2s every 6s
        self._phasing = (self._phase_timer % 6.0) < 2.0
        super().on_fixed_update(dt)

    def _process_chase(self, dt: float):
        """Override chase to ignore walls while phasing."""
        if self._phasing and self._target:
            dist = self._dist_to_target()
            if dist > self.detection_range * 1.5:
                self._state = IDLE
                return
            if dist <= self.attack_range and self._attack_timer <= 0:
                self._state = ATTACK
                return
            # Direct movement ignoring walls
            direction = self._dir_to_target()
            self.velocity = direction * self.speed
            self.position = Vec2(
                self.position.x + self.velocity.x * dt,
                self.position.y + self.velocity.y * dt,
            )
        else:
            super()._process_chase(dt)


class GolemEnemy(PatrolEnemy):
    """Golem: ground-pound AoE attack."""

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._slam_cooldown = 0.0

    def on_fixed_update(self, dt: float):
        self._slam_cooldown = max(0.0, self._slam_cooldown - dt)
        super().on_fixed_update(dt)
        # Ground pound when target is close
        if self._state == CHASE and self._target and self._slam_cooldown <= 0 and self._dist_to_target() < 60:
            self._ground_pound()

    def _ground_pound(self):
        """Large AoE slam centred on self."""
        if self.parent is None:
            return
        from .combat import Hitbox

        hitbox = Hitbox(damage=int(self.damage * 1.5), direction=Vec2(0, 1), name="EnemyHit")
        hitbox.position = Vec2(self.position.x, self.position.y)
        if hasattr(hitbox, "radius"):
            hitbox.radius = 50
        hitbox.lifetime = 0.2
        self.parent.add_child(hitbox)
        self._slam_cooldown = 8.0


class DemonEnemy(MeleeEnemy):
    """Demon: charge attack toward player."""

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._charge_cooldown = 0.0

    def on_fixed_update(self, dt: float):
        self._charge_cooldown = max(0.0, self._charge_cooldown - dt)
        super().on_fixed_update(dt)
        # Charge when target is in range
        if self._state == CHASE and self._target and self._charge_cooldown <= 0 and 50 < self._dist_to_target() < 200:
            self._charge_attack()

    def _charge_attack(self):
        """Dash toward player with a damaging hitbox."""
        if self.parent is None or self._target is None:
            return
        direction = self._dir_to_target()
        self.position = Vec2(
            self.position.x + direction.x * 80,
            self.position.y + direction.y * 80,
        )
        from .combat import Hitbox

        hitbox = Hitbox(damage=int(self.damage * 1.8), direction=direction, name="EnemyHit")
        hitbox.position = Vec2(
            self.position.x + direction.x * 15,
            self.position.y + direction.y * 15,
        )
        hitbox.lifetime = 0.15
        self.parent.add_child(hitbox)
        self._charge_cooldown = 6.0


def create_enemy(archetype: str, dungeon_level: int = 1) -> EnemyBase:
    """Factory: create a scaled enemy from an archetype name.

    Scaling (linear, balanced for 100 levels):
        HP *= 1 + (level-1) * 0.20   (level 100 = ~21x base)
        Damage *= 1 + (level-1) * 0.12  (level 100 = ~13x base)
        Speed *= 1 + (level-1) * 0.006  (level 100 = ~1.6x base)
        XP *= 1 + (level-1) * 0.06  (level 100 = ~7x base)
    """
    # (class, base_hp, base_dmg, base_speed, base_xp)
    # Ranged enemies deal significantly more damage to compensate for kiting safety
    configs = {
        "skeleton": (MeleeEnemy, 40, 5, 60, 10),  # Basic melee, moderate damage
        "archer_skeleton": (RangedEnemy, 25, 12, 50, 15),  # Ranged: high damage, low HP
        "slime": (SwarmEnemy, 20, 3, 45, 5),  # Weak but numerous
        "bat_swarm": (SwarmEnemy, 12, 3, 95, 4),  # Fast, low damage
        "goblin": (MeleeEnemy, 35, 7, 75, 12),  # Slightly tougher melee
        "wraith": (WraithEnemy, 45, 15, 55, 25),  # Ranged: very high damage
        "golem": (GolemEnemy, 100, 12, 30, 40),  # Tanky, moderate damage
        "demon": (DemonEnemy, 75, 18, 65, 50),  # Late-game, strong melee
    }

    cls, base_hp, base_dmg, base_spd, base_xp = configs.get(archetype, (MeleeEnemy, 30, 5, 60, 10))
    level = max(1, dungeon_level)
    lm = level - 1  # Level multiplier base (0 at level 1)

    enemy = cls(name=archetype.replace("_", " ").title())
    enemy._archetype = archetype
    enemy._colour = _ARCHETYPE_COLOURS.get(archetype, (0.8, 0.2, 0.2, 1.0))
    enemy.hp = int(base_hp * (1 + lm * 0.20))
    enemy.max_hp = enemy.hp
    enemy.damage = int(base_dmg * (1 + lm * 0.12))
    enemy.speed = base_spd * (1 + lm * 0.006)
    enemy.xp_reward = int(base_xp * (1 + lm * 0.05))
    enemy.display_name = archetype.replace("_", " ").title()
    return enemy


def make_elite(enemy: EnemyBase, rng: _rng_mod.Random | None = None) -> EnemyBase:
    """Promote an enemy to elite status: 2x HP, 1.5x damage, random affix."""
    rng = rng or _rng_mod.Random()
    enemy._is_elite = True
    enemy.hp = int(enemy.hp * 2)
    enemy.max_hp = int(enemy.max_hp * 2)
    enemy.damage = int(enemy.damage * 1.5)
    enemy.xp_reward = int(enemy.xp_reward * 2.5)
    # 1-2 random affixes
    count = rng.randint(1, 2)
    enemy._elite_affixes = rng.sample(ALL_AFFIXES, min(count, len(ALL_AFFIXES)))
    # Apply fast affix immediately
    if AFFIX_FAST in enemy._elite_affixes:
        enemy.speed *= 1.4
    enemy.display_name = f"Elite {enemy.display_name}"
    return enemy