squirrel-battle/dungeonbattle/interfaces.py

#!/usr/bin/env python
from enum import Enum
from dungeonbattle.settings import Settings
import dungeonbattle.texturepack as tp

class Map:
    """
    Object that represents a Map with its width, height
    and the whole tiles, with their custom properties.
    """
    width: int
    height: int
    tiles: list
    currentx : int #coordinates of the point that should be on the topleft corner of the screen
    currenty : int 

    def __init__(self, width: int, height: int, tiles: list, entities = []):
        self.width = width
        self.height = height
        self.tiles = tiles
        self.entities = entities

    @staticmethod
    def load(filename: str):
        """
        Read a file that contains the content of a map, and build a Map object.
        """
        with open(filename, "r") as f:
            file = f.read()
        return Map.load_from_string(file)

    @staticmethod
    def load_from_string(content: str):
        """
        Load a map represented by its characters and build a Map object.
        """
        lines = content.split("\n")
        lines = [line for line in lines if line]
        height = len(lines)
        width = len(lines[0])
        tiles = [[Tile(c)
                  for x, c in enumerate(line)] for y, line in enumerate(lines)]

        return Map(width, height, tiles, [])


    def draw_string(self) -> str:
        """
        Draw the current map as a string object that can be rendered
        in the window.
        """
        return "\n".join("".join(tile.value for tile in line)
                         for line in self.tiles)


class Tile(Enum):
    if self.settings.TEXTURE_PACK == 'ASCII' :
        self.textures = tp.ascii_textures
    if self.settings.TEXTURE_PACK == 'SQUIRREL' :
        self.textures = tp.squirrel_textures
    
    EMPTY = self.textures["EMPTY"]
    WALL = self.textures["WALL"]
    FLOOR = self.textures["FLOOR"]

    def is_wall(self) -> bool:
        return self == Tile.WALL

    def can_walk(self) -> bool:
        """
        Check if an entity (player or not) can move in this tile.
        """
        return not self.is_wall()


class Entity:
    x: int
    y: int
    name : str

    def move(self, x: int, y: int) -> None:
        self.x = x
        self.y = y
    
    def act(self, m:Map):
        pass

class FightingEntity(Entity):
    maxhealth: int
    health: int
    strength: int

    def __init__(self):
        self.health = self.maxhealth

    def hit(self, opponent) -> None:
        opponent.take_damage(self, self.strength)
    
    def take_damage(self, attacker, amount:int) -> None:
        self.health -= amount
        if self.health <= 0:
            self.die()
    
    def die(self) -> None:
       pass