squirrel-battle/dungeonbattle/entities/player.py

from random import randint
from typing import Dict, Tuple

from ..interfaces import FightingEntity


class Player(FightingEntity):
    """
    The class of the player
    """
    name = "player"
    maxhealth: int = 20
    strength: int = 5
    intelligence: int = 1
    charisma: int = 1
    dexterity: int = 1
    constitution: int = 1
    level: int = 1
    current_xp: int = 0
    max_xp: int = 10
    inventory: list
    paths: Dict[Tuple[int, int], Tuple[int, int]]

    def __init__(self):
        super().__init__()
        self.inventory = list()

    def move(self, y: int, x: int) -> None:
        """
        When the player moves, move the camera of the map.
        """
        super().move(y, x)
        self.map.currenty = y
        self.map.currentx = x
        self.recalculate_paths()

    def level_up(self) -> None:
        """
        Add levels to the player as much as it is possible.
        """
        while self.current_xp > self.max_xp:
            self.level += 1
            self.current_xp -= self.max_xp
            self.max_xp = self.level * 10
            self.health = self.maxhealth
            # TODO Remove it, that's only fun
            self.map.spawn_random_entities(randint(3 * self.level,
                                                   10 * self.level))

    def add_xp(self, xp: int) -> None:
        """
        Add some experience to the player.
        If the required amount is reached, level up.
        """
        self.current_xp += xp
        self.level_up()

    # noinspection PyTypeChecker,PyUnresolvedReferences
    def check_move(self, y: int, x: int, move_if_possible: bool = False) \
            -> bool:
        """
        If the player tries to move but a fighting entity is there,
        the player fights this entity.
        It rewards some XP if it is dead.
        """
        # Don't move if we are dead
        if self.dead:
            return False
        for entity in self.map.entities:
            if entity.y == y and entity.x == x:
                if entity.is_fighting_entity():
                    self.hit(entity)
                    if entity.dead:
                        self.add_xp(randint(3, 7))
                    return True
                elif entity.is_item():
                    entity.hold(self)
        return super().check_move(y, x, move_if_possible)

    def recalculate_paths(self, max_distance: int = 8) -> None:
        """
        Use Dijkstra algorithm to calculate best paths
        for monsters to go to the player.
        """
        queue = [(self.y, self.x)]
        visited = []
        distances = {(self.y, self.x): 0}
        predecessors = {}
        while queue:
            y, x = queue.pop(0)
            visited.append((y, x))
            if distances[(y, x)] >= max_distance:
                continue
            for diff_y, diff_x in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
                new_y, new_x = y + diff_y, x + diff_x
                if not 0 <= new_y < self.map.height or \
                        not 0 <= new_x < self.map.width or \
                        not self.map.tiles[y][x].can_walk() or \
                        (new_y, new_x) in visited or \
                        (new_y, new_x) in queue:
                    continue
                predecessors[(new_y, new_x)] = (y, x)
                distances[(new_y, new_x)] = distances[(y, x)] + 1
                queue.append((new_y, new_x))
        self.paths = predecessors