squirrel-battle/dungeonbattle/interfaces.py

136 lines
3.3 KiB
Python

#!/usr/bin/env python
from enum import Enum, auto
from dungeonbattle.display.texturepack import TexturePack
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):
self.width = width
self.height = height
self.tiles = tiles
self.entities = []
def add_entity(self, entity: "Entity") -> None:
"""
Register a new entity in the map.
"""
self.entities.append(entity)
entity.map = self
@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, pack: TexturePack) -> str:
"""
Draw the current map as a string object that can be rendered
in the window.
"""
return "\n".join("".join(tile.char(pack) for tile in line)
for line in self.tiles)
class Tile(Enum):
EMPTY = auto()
WALL = auto()
FLOOR = auto()
def char(self, pack: TexturePack) -> str:
return getattr(pack, self.name)
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:
y: int
x: int
name : str
map: Map
def __init__(self):
self.y = 0
self.x = 0
def check_move(self, y: int, x: int, move_if_possible: bool = False)\
-> bool:
tile = self.map.tiles[y][x]
if tile.can_walk() and move_if_possible:
self.move(y, x)
return tile.can_walk()
def move(self, y: int, x: int) -> None:
self.y = y
self.x = x
def act(self, m: Map) -> None:
"""
Define the action of the entity that is ran each tick.
By default, does nothing.
"""
pass
class FightingEntity(Entity):
maxhealth: int
health: int
strength: int
dead: bool
intelligence: int
charisma: int
dexterity: int
constitution: int
level: int
def __init__(self):
super().__init__()
self.health = self.maxhealth
self.dead = False
def hit(self, opponent: "FightingEntity") -> None:
opponent.take_damage(self, self.strength)
def take_damage(self, attacker: "Entity", amount: int) -> None:
self.health -= amount
if self.health <= 0:
self.die()
def die(self) -> None:
self.dead = True