squirrel-battle/squirrelbattle/interfaces.py

872 lines
29 KiB
Python
Raw Normal View History

2020-11-27 15:33:17 +00:00
# Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse
# SPDX-License-Identifier: GPL-3.0-or-later
2020-11-06 16:43:30 +00:00
from enum import Enum, auto
from math import ceil, sqrt
from random import choice, choices, randint
from typing import List, Optional, Any, Dict, Tuple
from queue import PriorityQueue
from functools import reduce
from copy import deepcopy
2020-11-06 16:43:30 +00:00
2020-11-27 19:42:19 +00:00
from .display.texturepack import TexturePack
from .translations import gettext as _
2020-11-06 16:43:30 +00:00
class Logs:
"""
The logs object stores the messages to display. It encapsulates a list
of such messages, to allow multiple pointers to keep track of it even if
the list was to be reassigned.
"""
def __init__(self) -> None:
self.messages = []
def add_message(self, msg: str) -> None:
self.messages.append(msg)
def add_messages(self, msg: List[str]) -> None:
self.messages += msg
def clear(self) -> None:
self.messages = []
class Slope():
X: int
Y: int
def __init__(self, y: int, x: int) -> None:
self.Y = y
self.X = x
def compare(self, other: "Slope") -> int:
y, x = other.Y, other.X
return self.Y * x - self.X * y
def __lt__(self, other: "Slope") -> bool:
return self.compare(other) < 0
def __eq__(self, other: "Slope") -> bool:
return self.compare(other) == 0
def __gt__(self, other: "Slope") -> bool:
return self.compare(other) > 0
def __le__(self, other: "Slope") -> bool:
return self.compare(other) <= 0
def __ge__(self, other: "Slope") -> bool:
return self.compare(other) >= 0
class Map:
2020-10-16 16:05:49 +00:00
"""
The Map object represents a with its width, height
and tiles, that have their custom properties.
2020-10-16 16:05:49 +00:00
"""
floor: int
width: int
height: int
2020-11-11 15:09:03 +00:00
start_y: int
start_x: int
tiles: List[List["Tile"]]
visibility: List[List[bool]]
seen_tiles: List[List[bool]]
2020-11-10 20:47:36 +00:00
entities: List["Entity"]
logs: Logs
2020-11-06 20:15:09 +00:00
# coordinates of the point that should be
# on the topleft corner of the screen
currentx: int
currenty: int
2021-01-08 13:23:57 +00:00
def __init__(self, width: int = 0, height: int = 0, tiles: list = None,
start_y: int = 0, start_x: int = 0):
self.floor = 0
self.width = width
self.height = height
2020-11-11 15:09:03 +00:00
self.start_y = start_y
self.start_x = start_x
2021-01-08 13:23:57 +00:00
self.tiles = tiles or []
self.visibility = [[False for _ in range(len(self.tiles[0]))]
for _ in range(len(self.tiles))]
self.seen_tiles = [[False for _ in range(len(tiles[0]))]
2021-01-08 13:23:57 +00:00
for _ in range(len(self.tiles))]
2020-11-06 16:59:19 +00:00
self.entities = []
2020-11-19 19:02:44 +00:00
self.logs = Logs()
2020-11-06 16:59:19 +00:00
def add_entity(self, entity: "Entity") -> None:
"""
Registers a new entity in the map.
2020-11-06 16:59:19 +00:00
"""
2020-12-18 16:46:38 +00:00
if entity.is_familiar():
self.entities.insert(1, entity)
else:
self.entities.append(entity)
2020-11-06 16:59:19 +00:00
entity.map = self
2020-11-10 21:44:53 +00:00
def remove_entity(self, entity: "Entity") -> None:
"""
Unregisters an entity from the map.
2020-11-10 21:44:53 +00:00
"""
if entity in self.entities:
self.entities.remove(entity)
2020-11-10 21:44:53 +00:00
2020-11-18 23:33:50 +00:00
def find_entities(self, entity_class: type) -> list:
return [entity for entity in self.entities
if isinstance(entity, entity_class)]
def is_free(self, y: int, x: int) -> bool:
"""
Indicates that the tile at the coordinates (y, x) is empty.
"""
return 0 <= y < self.height and 0 <= x < self.width and \
self.tiles[y][x].can_walk() and \
not any(entity.x == x and entity.y == y for entity in self.entities)
2020-12-07 20:22:06 +00:00
def entity_is_present(self, y: int, x: int) -> bool:
"""
2020-12-07 20:22:06 +00:00
Indicates that the tile at the coordinates (y, x) contains a killable
entity.
"""
return 0 <= y < self.height and 0 <= x < self.width and \
2020-12-07 20:22:06 +00:00
any(entity.x == x and entity.y == y and entity.is_friendly()
for entity in self.entities)
@staticmethod
def load(filename: str) -> "Map":
2020-10-16 16:05:49 +00:00
"""
2020-12-18 16:46:38 +00:00
Reads a file that contains the content of a map,
and builds a Map object.
2020-10-16 16:05:49 +00:00
"""
with open(filename, "r") as f:
file = f.read()
return Map.load_from_string(file)
@staticmethod
def load_from_string(content: str) -> "Map":
2020-10-16 16:05:49 +00:00
"""
Loads a map represented by its characters and builds a Map object.
2020-10-16 16:05:49 +00:00
"""
lines = content.split("\n")
2020-11-11 15:09:03 +00:00
first_line = lines[0]
start_y, start_x = map(int, first_line.split(" "))
lines = [line for line in lines[1:] if line]
height = len(lines)
2020-10-09 16:24:13 +00:00
width = len(lines[0])
2020-11-06 19:18:27 +00:00
tiles = [[Tile.from_ascii_char(c)
2020-10-16 13:41:25 +00:00
for x, c in enumerate(line)] for y, line in enumerate(lines)]
2020-10-23 13:55:30 +00:00
2020-11-11 15:09:03 +00:00
return Map(width, height, tiles, start_y, start_x)
2020-10-16 13:41:25 +00:00
@staticmethod
def load_dungeon_from_string(content: str) -> List[List["Tile"]]:
"""
Transforms a string into the list of corresponding tiles.
"""
lines = content.split("\n")
tiles = [[Tile.from_ascii_char(c)
for x, c in enumerate(line)] for y, line in enumerate(lines)]
return tiles
2020-11-06 16:43:30 +00:00
def draw_string(self, pack: TexturePack) -> str:
2020-10-16 16:05:49 +00:00
"""
Draws the current map as a string object that can be rendered
2020-10-16 16:05:49 +00:00
in the window.
"""
2020-11-06 16:43:30 +00:00
return "\n".join("".join(tile.char(pack) for tile in line)
2020-10-16 14:41:38 +00:00
for line in self.tiles)
def spawn_random_entities(self, count: int) -> None:
"""
Puts randomly {count} entities on the map, only on empty ground tiles.
"""
for _ignored in range(count):
y, x = 0, 0
while True:
y, x = randint(0, self.height - 1), randint(0, self.width - 1)
tile = self.tiles[y][x]
if tile.can_walk():
break
2021-01-06 17:02:58 +00:00
entity = choices(Entity.get_all_entity_classes(),
weights=Entity.get_weights(), k=1)[0]()
2020-11-11 15:23:27 +00:00
entity.move(y, x)
self.add_entity(entity)
def is_visible_from(self, starty: int, startx: int, desty: int, destx: int,
max_range: int) -> bool:
oldvisibility = deepcopy(self.visibility)
self.compute_visibility(starty, startx, max_range)
result = self.visibility[desty][destx]
self.visibility = oldvisibility
return result
def compute_visibility(self, y: int, x: int, max_range: int) -> None:
"""
Sets the visible tiles to be the ones visible by an entity at point
(y, x), using a twaked shadow casting algorithm
"""
for line in self.visibility:
for i in range(len(line)):
line[i] = False
self.set_visible(0, 0, 0, (y, x))
for octant in range(8):
self.compute_visibility_octant(octant, (y, x), max_range, 1,
Slope(1, 1), Slope(0, 1))
def crop_top_visibility(self, octant: int, origin: Tuple[int, int],
x: int, top: Slope) -> int:
if top.X == 1:
top_y = x
else:
top_y = ceil(((x * 2 - 1) * top.Y + top.X) / (top.X * 2))
if self.is_wall(top_y, x, octant, origin):
2021-01-07 15:31:39 +00:00
top_y += top >= Slope(top_y * 2 + 1, x * 2) and not \
self.is_wall(top_y + 1, x, octant, origin)
else:
ax = x * 2
2021-01-07 15:31:39 +00:00
ax += self.is_wall(top_y + 1, x + 1, octant, origin)
top_y += top > Slope(top_y * 2 + 1, ax)
return top_y
def crop_bottom_visibility(self, octant: int, origin: Tuple[int, int],
x: int, bottom: Slope) -> int:
if bottom.Y == 0:
bottom_y = 0
else:
bottom_y = ceil(((x * 2 - 1) * bottom.Y + bottom.X)
/ (bottom.X * 2))
2021-01-07 15:31:39 +00:00
bottom_y += bottom >= Slope(bottom_y * 2 + 1, x * 2) and \
self.is_wall(bottom_y, x, octant, origin) and \
not self.is_wall(bottom_y + 1, x, octant, origin)
return bottom_y
def compute_visibility_octant(self, octant: int, origin: Tuple[int, int],
max_range: int, distance: int, top: Slope,
bottom: Slope) -> None:
for x in range(distance, max_range + 1):
top_y = self.crop_top_visibility(octant, origin, x, top)
bottom_y = self.crop_bottom_visibility(octant, origin, x, bottom)
was_opaque = -1
for y in range(top_y, bottom_y - 1, -1):
if x + y > max_range:
continue
is_opaque = self.is_wall(y, x, octant, origin)
is_visible = is_opaque\
or ((y != top_y or top >= Slope(y, x))
and (y != bottom_y
or bottom <= Slope(y, x)))
# is_visible = is_opaque\
# or ((y != top_y or top >= Slope(y, x))
# and (y != bottom_y or bottom <= Slope(y, x)))
if is_visible:
self.set_visible(y, x, octant, origin)
if x == max_range:
continue
if is_opaque and was_opaque == 0:
nx, ny = x * 2, y * 2 + 1
2021-01-07 15:31:39 +00:00
nx -= self.is_wall(y + 1, x, octant, origin)
if top > Slope(ny, nx):
if y == bottom_y:
bottom = Slope(ny, nx)
break
else:
self.compute_visibility_octant(
octant, origin, max_range, x + 1, top,
Slope(ny, nx))
2021-01-07 15:31:39 +00:00
elif y == bottom_y: # pragma: no cover
return
elif not is_opaque and was_opaque == 1:
nx, ny = x * 2, y * 2 + 1
2021-01-07 15:31:39 +00:00
nx += self.is_wall(y + 1, x + 1, octant, origin)
if bottom >= Slope(ny, nx): # pragma: no cover
return
top = Slope(ny, nx)
was_opaque = is_opaque
if was_opaque != 0:
break
@staticmethod
def translate_coord(y: int, x: int, octant: int,
origin: Tuple[int, int]) -> Tuple[int, int]:
ny, nx = origin
if octant == 0:
return ny - y, nx + x
elif octant == 1:
return ny - x, nx + y
elif octant == 2:
return ny - x, nx - y
elif octant == 3:
return ny - y, nx - x
elif octant == 4:
return ny + y, nx - x
elif octant == 5:
return ny + x, nx - y
elif octant == 6:
return ny + x, nx + y
elif octant == 7:
return ny + y, nx + x
def is_wall(self, y: int, x: int, octant: int,
origin: Tuple[int, int]) -> bool:
y, x = self.translate_coord(y, x, octant, origin)
return 0 <= y < len(self.tiles) and 0 <= x < len(self.tiles[0]) and \
self.tiles[y][x].is_wall()
def set_visible(self, y: int, x: int, octant: int,
origin: Tuple[int, int]) -> None:
y, x = self.translate_coord(y, x, octant, origin)
if 0 <= y < len(self.tiles) and 0 <= x < len(self.tiles[0]):
self.visibility[y][x] = True
self.seen_tiles[y][x] = True
def tick(self, p: Any) -> None:
"""
Triggers all entity events.
"""
for entity in self.entities:
if entity.is_familiar():
entity.act(p, self)
2020-12-18 16:46:38 +00:00
else:
entity.act(self)
def save_state(self) -> dict:
"""
Saves the map's attributes to a dictionary.
"""
d = dict()
d["width"] = self.width
d["height"] = self.height
d["start_y"] = self.start_y
d["start_x"] = self.start_x
d["currentx"] = self.currentx
d["currenty"] = self.currenty
d["entities"] = []
for enti in self.entities:
2020-11-18 23:10:37 +00:00
d["entities"].append(enti.save_state())
d["map"] = self.draw_string(TexturePack.ASCII_PACK)
2021-01-08 13:23:57 +00:00
d["seen_tiles"] = self.seen_tiles
return d
2021-01-08 13:23:57 +00:00
def load_state(self, d: dict) -> "Map":
"""
Loads the map's attributes from a dictionary.
"""
self.width = d["width"]
self.height = d["height"]
self.start_y = d["start_y"]
self.start_x = d["start_x"]
self.currentx = d["currentx"]
self.currenty = d["currenty"]
self.tiles = self.load_dungeon_from_string(d["map"])
2021-01-08 13:23:57 +00:00
self.seen_tiles = d["seen_tiles"]
self.visibility = [[False for _ in range(len(self.tiles[0]))]
for _ in range(len(self.tiles))]
self.entities = []
2020-11-18 23:10:37 +00:00
dictclasses = Entity.get_all_entity_classes_in_a_dict()
for entisave in d["entities"]:
self.add_entity(dictclasses[entisave["type"]](**entisave))
2020-11-18 13:56:59 +00:00
2021-01-08 13:23:57 +00:00
return self
2020-10-16 13:41:25 +00:00
class Tile(Enum):
"""
The internal representation of the tiles of the map.
"""
2020-11-06 16:43:30 +00:00
EMPTY = auto()
WALL = auto()
FLOOR = auto()
2020-12-25 23:52:47 +00:00
LADDER = auto()
2020-11-06 16:43:30 +00:00
@staticmethod
def from_ascii_char(ch: str) -> "Tile":
"""
Maps an ascii character to its equivalent in the texture pack.
"""
2020-11-06 19:18:27 +00:00
for tile in Tile:
if tile.char(TexturePack.ASCII_PACK) == ch:
return tile
raise ValueError(ch)
2020-11-06 16:43:30 +00:00
def char(self, pack: TexturePack) -> str:
"""
2020-11-18 13:56:59 +00:00
Translates a Tile to the corresponding character according
to the texture pack.
"""
2020-12-26 13:02:35 +00:00
val = getattr(pack, self.name)
return val[0] if isinstance(val, tuple) else val
2020-12-26 13:02:35 +00:00
2021-01-07 15:49:40 +00:00
def visible_color(self, pack: TexturePack) -> Tuple[int, int]:
"""
Retrieve the tuple (fg_color, bg_color) of the current Tile
if it is visible.
"""
2021-01-07 15:49:40 +00:00
val = getattr(pack, self.name)
return (val[2], val[4]) if isinstance(val, tuple) else \
(pack.tile_fg_visible_color, pack.tile_bg_color)
def hidden_color(self, pack: TexturePack) -> Tuple[int, int]:
2020-12-26 13:02:35 +00:00
"""
Retrieve the tuple (fg_color, bg_color) of the current Tile.
"""
2020-12-26 13:02:35 +00:00
val = getattr(pack, self.name)
2021-01-07 15:49:40 +00:00
return (val[1], val[3]) if isinstance(val, tuple) else \
(pack.tile_fg_color, pack.tile_bg_color)
2020-10-16 13:41:25 +00:00
def is_wall(self) -> bool:
"""
Is this Tile a wall?
"""
return self == Tile.WALL
2020-12-25 23:52:47 +00:00
def is_ladder(self) -> bool:
"""
Is this Tile a ladder?
"""
return self == Tile.LADDER
def can_walk(self) -> bool:
2020-10-16 16:05:49 +00:00
"""
Checks if an entity (player or not) can move in this tile.
2020-10-16 16:05:49 +00:00
"""
return not self.is_wall() and self != Tile.EMPTY
2020-10-11 13:24:51 +00:00
class Entity:
"""
An Entity object represents any entity present on the map.
"""
2020-10-16 13:41:25 +00:00
y: int
2020-11-06 15:13:28 +00:00
x: int
2020-11-06 20:15:09 +00:00
name: str
map: Map
paths: Dict[Tuple[int, int], Tuple[int, int]]
2020-11-18 23:10:37 +00:00
# noinspection PyShadowingBuiltins
def __init__(self, y: int = 0, x: int = 0, name: Optional[str] = None,
map: Optional[Map] = None, *ignored, **ignored2):
self.y = y
self.x = x
self.name = name
self.map = map
self.paths = None
2020-11-06 15:13:28 +00:00
2020-11-06 16:59:19 +00:00
def check_move(self, y: int, x: int, move_if_possible: bool = False)\
-> bool:
"""
Checks if moving to (y,x) is authorized.
"""
free = self.map.is_free(y, x)
if free and move_if_possible:
2020-11-06 16:59:19 +00:00
self.move(y, x)
return free
2020-11-06 16:59:19 +00:00
2020-11-10 21:44:53 +00:00
def move(self, y: int, x: int) -> bool:
"""
Moves an entity to (y,x) coordinates.
"""
2020-10-11 13:24:51 +00:00
self.y = y
2020-11-06 15:13:28 +00:00
self.x = x
2020-11-10 21:44:53 +00:00
return True
2020-11-06 14:33:26 +00:00
def move_up(self, force: bool = False) -> bool:
"""
Moves the entity up one tile, if possible.
"""
return self.move(self.y - 1, self.x) if force else \
self.check_move(self.y - 1, self.x, True)
def move_down(self, force: bool = False) -> bool:
"""
Moves the entity down one tile, if possible.
"""
return self.move(self.y + 1, self.x) if force else \
self.check_move(self.y + 1, self.x, True)
def move_left(self, force: bool = False) -> bool:
"""
Moves the entity left one tile, if possible.
"""
return self.move(self.y, self.x - 1) if force else \
self.check_move(self.y, self.x - 1, True)
def move_right(self, force: bool = False) -> bool:
"""
Moves the entity right one tile, if possible.
"""
return self.move(self.y, self.x + 1) if force else \
self.check_move(self.y, self.x + 1, True)
def recalculate_paths(self, max_distance: int = 12) -> None:
"""
Uses Dijkstra algorithm to calculate best paths for other entities to
go to this entity. If self.paths is None, does nothing.
"""
2020-12-18 16:46:38 +00:00
if self.paths is None:
return
distances = []
predecessors = []
# four Dijkstras, one for each adjacent tile
for dir_y, dir_x in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
queue = PriorityQueue()
new_y, new_x = self.y + dir_y, self.x + dir_x
if not 0 <= new_y < self.map.height or \
not 0 <= new_x < self.map.width or \
not self.map.tiles[new_y][new_x].can_walk():
continue
queue.put(((1, 0), (new_y, new_x)))
visited = [(self.y, self.x)]
distances.append({(self.y, self.x): (0, 0), (new_y, new_x): (1, 0)})
predecessors.append({(new_y, new_x): (self.y, self.x)})
while not queue.empty():
dist, (y, x) = queue.get()
if dist[0] >= max_distance or (y, x) in visited:
continue
visited.append((y, x))
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[new_y][new_x].can_walk():
continue
new_distance = (dist[0] + 1,
dist[1] + (not self.map.is_free(y, x)))
if not (new_y, new_x) in distances[-1] or \
distances[-1][(new_y, new_x)] > new_distance:
predecessors[-1][(new_y, new_x)] = (y, x)
distances[-1][(new_y, new_x)] = new_distance
queue.put((new_distance, (new_y, new_x)))
# For each tile that is reached by at least one Dijkstra, sort the
# different paths by distance to the player. For the technical bits :
# The reduce function is a fold starting on the first element of the
# iterable, and we associate the points to their distance, sort
# along the distance, then only keep the points.
self.paths = {}
for y, x in reduce(set.union,
[set(p.keys()) for p in predecessors], set()):
self.paths[(y, x)] = [p for d, p in sorted(
[(distances[i][(y, x)], predecessors[i][(y, x)])
for i in range(len(distances)) if (y, x) in predecessors[i]])]
2020-12-18 16:46:38 +00:00
2020-11-06 14:33:26 +00:00
def act(self, m: Map) -> None:
"""
Defines the action the entity will do at each tick.
2020-11-06 14:33:26 +00:00
By default, does nothing.
"""
2020-10-23 16:02:57 +00:00
pass
2020-11-10 21:59:02 +00:00
def distance_squared(self, other: "Entity") -> int:
"""
Gives the square of the distance to another entity.
Useful to check distances since taking the square root takes time.
2020-11-10 21:59:02 +00:00
"""
return (self.y - other.y) ** 2 + (self.x - other.x) ** 2
def distance(self, other: "Entity") -> float:
"""
Gives the cartesian distance to another entity.
2020-11-10 21:59:02 +00:00
"""
return sqrt(self.distance_squared(other))
2020-11-11 15:47:19 +00:00
def is_fighting_entity(self) -> bool:
"""
Is this entity a fighting entity?
"""
2020-11-11 15:47:19 +00:00
return isinstance(self, FightingEntity)
def is_item(self) -> bool:
"""
Is this entity an item?
"""
2020-11-19 01:18:08 +00:00
from squirrelbattle.entities.items import Item
2020-11-11 15:47:19 +00:00
return isinstance(self, Item)
def is_friendly(self) -> bool:
"""
Is this entity a friendly entity?
"""
return isinstance(self, FriendlyEntity)
def is_familiar(self) -> bool:
"""
Is this entity a familiar?
"""
from squirrelbattle.entities.friendly import Familiar
return isinstance(self, Familiar)
def is_merchant(self) -> bool:
"""
Is this entity a merchant?
"""
from squirrelbattle.entities.friendly import Merchant
return isinstance(self, Merchant)
def is_chest(self) -> bool:
"""
Is this entity a chest?
"""
from squirrelbattle.entities.friendly import Chest
return isinstance(self, Chest)
2020-11-27 21:33:58 +00:00
@property
def translated_name(self) -> str:
"""
Translates the name of entities.
"""
2020-11-27 21:33:58 +00:00
return _(self.name.replace("_", " "))
2020-11-11 15:23:27 +00:00
@staticmethod
def get_all_entity_classes() -> list:
"""
Returns all entities subclasses.
"""
from squirrelbattle.entities.items import BodySnatchPotion, Bomb, Heart
2020-11-20 17:02:08 +00:00
from squirrelbattle.entities.monsters import Tiger, Hedgehog, \
Rabbit, TeddyBear, GiantSeaEagle
from squirrelbattle.entities.friendly import Merchant, Sunflower, \
Trumpet, Chest
2020-12-07 20:22:06 +00:00
return [BodySnatchPotion, Bomb, Heart, Hedgehog, Rabbit, TeddyBear,
Sunflower, Tiger, Merchant, GiantSeaEagle, Trumpet, Chest]
@staticmethod
def get_weights() -> list:
"""
Returns a weigth list associated to the above function, to
be used to spawn random entities with a certain probability.
"""
return [3, 5, 6, 5, 5, 5, 5, 4, 3, 1, 2, 4]
2020-11-11 15:23:27 +00:00
@staticmethod
def get_all_entity_classes_in_a_dict() -> dict:
"""
Returns all entities subclasses in a dictionary.
"""
2020-11-19 01:18:08 +00:00
from squirrelbattle.entities.player import Player
2020-11-20 17:02:08 +00:00
from squirrelbattle.entities.monsters import Tiger, Hedgehog, Rabbit, \
TeddyBear, GiantSeaEagle
2020-12-18 17:13:39 +00:00
from squirrelbattle.entities.friendly import Merchant, Sunflower, \
Trumpet, Chest
2020-12-07 20:48:56 +00:00
from squirrelbattle.entities.items import BodySnatchPotion, Bomb, \
Heart, Sword, Shield, Chestplate, Helmet, RingCritical, RingXP, \
ScrollofDamage, ScrollofWeakening, Ruler, Bow, FireBallStaff, \
Monocle
2020-11-18 23:10:37 +00:00
return {
"BodySnatchPotion": BodySnatchPotion,
2020-11-18 23:10:37 +00:00
"Bomb": Bomb,
"Bow": Bow,
"Chest": Chest,
"Chestplate": Chestplate,
"Eagle": GiantSeaEagle,
"FireBallStaff": FireBallStaff,
2020-11-18 23:10:37 +00:00
"Heart": Heart,
"Hedgehog": Hedgehog,
"Helmet": Helmet,
"Merchant": Merchant,
"Monocle": Monocle,
"Player": Player,
"Rabbit": Rabbit,
"RingCritical": RingCritical,
"RingXP": RingXP,
2021-01-08 17:06:26 +00:00
"Ruler": Ruler,
"ScrollofDamage": ScrollofDamage,
"ScrollofWeakening": ScrollofWeakening,
"Shield": Shield,
"Sunflower": Sunflower,
2020-12-07 20:48:56 +00:00
"Sword": Sword,
2020-12-18 17:13:39 +00:00
"Trumpet": Trumpet,
"TeddyBear": TeddyBear,
"Tiger": Tiger,
2020-11-18 23:10:37 +00:00
}
def save_state(self) -> dict:
"""
Saves the coordinates of the entity.
"""
d = dict()
d["x"] = self.x
d["y"] = self.y
2020-11-18 23:10:37 +00:00
d["type"] = self.__class__.__name__
return d
2020-11-06 14:33:26 +00:00
class FightingEntity(Entity):
"""
A FightingEntity is an entity that can fight, and thus has a health,
level and stats.
"""
maxhealth: int
health: int
strength: int
2020-11-06 17:08:10 +00:00
intelligence: int
charisma: int
dexterity: int
constitution: int
level: int
critical: int
2020-11-18 23:10:37 +00:00
def __init__(self, maxhealth: int = 0, health: Optional[int] = None,
strength: int = 0, intelligence: int = 0, charisma: int = 0,
dexterity: int = 0, constitution: int = 0, level: int = 0,
critical: int = 0, *args, **kwargs) -> None:
2020-11-18 23:10:37 +00:00
super().__init__(*args, **kwargs)
self.maxhealth = maxhealth
self.health = maxhealth if health is None else health
self.strength = strength
self.intelligence = intelligence
self.charisma = charisma
self.dexterity = dexterity
self.constitution = constitution
self.level = level
self.critical = critical
2021-01-08 21:25:00 +00:00
self.effects = [] # effects = temporary buff or weakening of the stats.
2020-11-18 13:29:54 +00:00
@property
def dead(self) -> bool:
"""
Is this entity dead ?
"""
2020-11-18 13:29:54 +00:00
return self.health <= 0
def act(self, m: Map) -> None:
"""
Refreshes all current effects.
"""
for i in range(len(self.effects)):
self.effects[i][2] -= 1
2021-01-08 21:25:00 +00:00
copy = self.effects[:]
for i in range(len(copy)):
if copy[i][2] <= 0:
setattr(self, copy[i][0],
getattr(self, copy[i][0]) - copy[i][1])
self.effects.remove(copy[i])
def hit(self, opponent: "FightingEntity") -> str:
"""
The entity deals damage to the opponent
based on their respective stats.
"""
2021-01-06 16:39:13 +00:00
diceroll = randint(1, 100)
damage = max(0, self.strength)
string = " "
2021-01-06 16:39:13 +00:00
if diceroll <= self.critical: # It is a critical hit
damage *= 4
2021-01-08 01:00:22 +00:00
string = " " + _("It's a critical hit!") + " "
2020-11-27 19:42:19 +00:00
return _("{name} hits {opponent}.")\
2020-11-27 21:33:58 +00:00
.format(name=_(self.translated_name.capitalize()),
opponent=_(opponent.translated_name)) + string + \
opponent.take_damage(self, damage)
2020-11-06 14:33:26 +00:00
def take_damage(self, attacker: "Entity", amount: int) -> str:
"""
The entity takes damage from the attacker
based on their respective stats.
"""
damage = max(0, amount - self.constitution)
self.health -= damage
if self.health <= 0:
self.die()
return _("{name} takes {damage} damage.")\
.format(name=self.translated_name.capitalize(), damage=str(damage))\
2020-11-27 21:33:58 +00:00
+ (" " + _("{name} dies.")
.format(name=self.translated_name.capitalize())
2020-11-27 19:42:19 +00:00
if self.health <= 0 else "")
2020-11-06 14:33:26 +00:00
def die(self) -> None:
"""
If a fighting entity has no more health, it dies and is removed.
"""
2020-11-10 21:44:53 +00:00
self.map.remove_entity(self)
def keys(self) -> list:
"""
Returns a fighting entity's specific attributes.
"""
return ["name", "maxhealth", "health", "level", "strength",
2020-11-18 13:56:59 +00:00
"intelligence", "charisma", "dexterity", "constitution"]
def save_state(self) -> dict:
"""
Saves the state of the entity into a dictionary.
"""
d = super().save_state()
for name in self.keys():
2020-11-18 23:10:37 +00:00
d[name] = getattr(self, name)
return d
2020-11-20 16:42:56 +00:00
2020-12-07 20:22:06 +00:00
class FriendlyEntity(FightingEntity):
2020-11-20 16:42:56 +00:00
"""
Friendly entities are living entities which do not attack the player.
2020-11-20 16:42:56 +00:00
"""
2020-12-07 20:22:06 +00:00
dialogue_option: list
2020-11-20 16:42:56 +00:00
2020-12-07 20:22:06 +00:00
def talk_to(self, player: Any) -> str:
return _("{entity} said: {message}").format(
entity=self.translated_name.capitalize(),
message=choice(self.dialogue_option))
2020-12-07 20:22:06 +00:00
def keys(self) -> list:
"""
Returns a friendly entity's specific attributes.
"""
2020-12-09 14:32:37 +00:00
return ["maxhealth", "health"]
class InventoryHolder(Entity):
hazel: int # Currency of the game
inventory: list
def translate_inventory(self, inventory: list) -> list:
"""
Translates the JSON save of the inventory into a list of the items in
the inventory.
"""
for i in range(len(inventory)):
if isinstance(inventory[i], dict):
2020-12-18 16:30:03 +00:00
inventory[i] = self.dict_to_item(inventory[i])
return inventory
2020-12-18 16:30:03 +00:00
def dict_to_item(self, item_dict: dict) -> Entity:
"""
Translates a dictionnary that contains the state of an item
into an item object.
"""
entity_classes = self.get_all_entity_classes_in_a_dict()
item_class = entity_classes[item_dict["type"]]
return item_class(**item_dict)
def save_state(self) -> dict:
"""
The inventory of the merchant is saved in a JSON format.
"""
d = super().save_state()
d["hazel"] = self.hazel
d["inventory"] = [item.save_state() for item in self.inventory]
return d
def add_to_inventory(self, obj: Any) -> None:
"""
Adds an object to the inventory.
"""
2020-12-18 16:30:03 +00:00
if obj not in self.inventory:
self.inventory.append(obj)
def remove_from_inventory(self, obj: Any) -> None:
"""
Removes an object from the inventory.
"""
2020-12-18 16:30:03 +00:00
if obj in self.inventory:
self.inventory.remove(obj)
def change_hazel_balance(self, hz: int) -> None:
"""
Changes the number of hazel the entity has by hz. hz is negative
when the entity loses money and positive when it gains money.
"""
self.hazel += hz