ynerant
/
squirrel-battle
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

Merge branch 'master' into 'equipment' 

# Conflicts:
#   squirrelbattle/display/statsdisplay.py
#   squirrelbattle/entities/items.py
#   squirrelbattle/entities/player.py
#   squirrelbattle/interfaces.py
#   squirrelbattle/locale/de/LC_MESSAGES/squirrelbattle.po
#   squirrelbattle/locale/es/LC_MESSAGES/squirrelbattle.po
#   squirrelbattle/locale/fr/LC_MESSAGES/squirrelbattle.po
#   squirrelbattle/tests/game_test.py
This commit is contained in:
ynerant 2021-01-08 02:11:40 +01:00
parent 7aeb659cf5 da47731faf
commit 451dd9cba7
34 changed files with 1167 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -3,6 +3,7 @@
env/ env/
venv/ venv/
local/
.coverage .coverage
.pytest_cache/ .pytest_cache/

44
squirrelbattle/assets/ascii-art-ecureuil.txt Normal file
View File

@ -0,0 +1,44 @@
⋀
┃|┃
┃|┃ ▓▓▒ ▓▓
┃|┃ ▓▓ ▓▓▒
┃|┃ ▓▓▓ ▓▓ ▓▓▓ ▒▒▒▒▒▒▒▒▒
┃|┃ ▓▓▓▓▓▓▓▓▓▓▓▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒
┃|┃ ▓▓▓▓▓▓▓▓▓▓▓▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
┃|┃ ▓▓▓▬█▓▓▓▓▓▓▬█▓▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
┃|┃ ▓▓▓▓░██░░▓▓░░██░▓▓▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
━━▓▓▓▓━━ ▓▓░░░░░░░░ ░░░░░░░░▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓▓▓ ▓░░░░░░░░░░░░░░░░░░░░▓▓▒▒▒▒▒▒▒▒▒▒▒▒
┃ ▓▓▓▓▓ ▓░░░░░░░░▄▄▄▄░░░░░░░▓▒▒▒▒▒▒▒▒▒▒▒▒▒
┃ ▓▓▓▓▓ ▓▓░░░░░░░░░░░░░░░▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓ ▓▓▓▓░░░░░░░▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓▓▓▒▒░░░░░░░░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓▒░░░░░░░░░░░░▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▒░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒
▓▒▒░░░░░░░░░░░░▓▓▓▓▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒
▓▓▒░░░░░░░░░░░░░░░▓▒▒▒▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒
▓▓▒▒░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒
▓▓▓▒░░░░░░░░░░░░░▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▒▓▒▒░░░░░░░░░░░░░░▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒
▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▒▒▒▒▒
▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▒▒▒
▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓▒
▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▒▒░░░░░░░░░░░░░░▓▓▓▓▓▓▓▓ ░
▓▓▓▓▓▓▓▓▓▒░░░░░░░░░░░░▓▓▓▓▓▓▓▓▓ ░░
▓▓▓▓▓▓▓▓▒▒░░░▒▒▒▒░░░░░░▓▓░▒▒▒▓▓▓▓▓▓▓▓▓▓░░░ ░
▓▓▓▓▓▓▓▒░░░░░░░░░▒░░░░░░░░░░░░▒▒▒▓▓▓▓▓▓▓▓░░ ░░▒
░ ░░░░░▒░░░░░░▒░░░▒░░░░░░░░░░░░░░░░░▒▒▒▒▒▒░░░░░░░▒
▒▒░░▓▓░░▒░░░░░░░░▒░░░░░░▒░░░░░░░░▒░░░░░░░░░░▒░░░░░▒ ░░
▒▒▒▒▒▓▒▒▓░░░░░░░░░▒░░░░░░░░▒░░░░░░░░▒░░░░░░░░▒░░░░░░░░░░░░
▒▒█▒█▒▒▒▓░░▒░░░░░░░░░░░░░░░▒░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░
▒▒▒▒█▒▒▒▒░░░░▒░░░▒░░░░░░░░░░░░░░░░░░░░░░▒░░░░░░░░░░░░▒░░░
▓█▒▒▒▒█▒█▒▒▒▒░░▒░░░░░▒░░░░▒░░░░░░░░░░░░░░░░░▒░░░░▒░░░░░░░▒░░░░░▒▒
██▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░▒░░░░░░▒░░░░░░░░▒░░░░░░▒░░░░░░▒░░░░░▒░░░░░
▒▒▒▒█▒▒▒▒▒▒▒░░░░░░░░░░▒░░░░░░░░░░▒░░░░░░░░░░░▒░░░░░░░░░░░░░░░
▒▒█▒▒▒▒▒░▒░▒░░░░▓▓▓░░░░░░░▒░░░░▒░░░▒░░░░░░░▓▓░░░░░░░░░░░░ ░
▒▒▒▒▒▒▒░▒░░░▓▓▓▓▓▓░░░░░░░▒░░░░░░░░▒░░░░▓▓▓▓▓▓░░░░░░░░ ░
░▓▓▓▓▓▓░░░░░░▒░░░░░░░░▒░░░░░░▓▓▓▓▓░░░ ░ ░░

4
squirrelbattle/assets/example_map.txt
View File

@ -1,8 +1,8 @@
1 6 1 6
####### ############# ####### #############
#.....# #...........# #.H...# #...........#
#.....# #####...........# #.....# #####...........#
#.....# #...............# #.....# #............H..#
#.##### #.###...........# #.##### #.###...........#
#.# #.# #...........# #.# #.# #...........#
#.# #.# ############# #.# #.# #############

4
squirrelbattle/assets/example_map_2.txt
View File

@ -1,6 +1,6 @@
1 17 1 17
########### ######### ########### #########
#.........# #.......# #....H....# #.......#
#.........# ############.......# #.........# ############.......#
#.........###############..........#.......############## #.........###############..........#.......##############
#.........#........................#....................# #.........#........................#....................#
@ -13,7 +13,7 @@
########.##########......# #.........# #.........# ########.##########......# #.........# #.........#
#...........##......# #.........# #.........# #...........##......# #.........# #.........#
#...........##......# #.........# #.........# #...........##......# #.........# #.........#
#...........##......# #.........# ################.###### #...........##..H...# #.........# ################.######
#...........##......# #.........# #.................############ #...........##......# #.........# #.................############
#...........##......# ########.########.......#.........#..........# #...........##......# ########.########.......#.........#..........#
#...........##......# #...............#.......#.........#..........# #...........##......# #...............#.......#.........#..........#

41
squirrelbattle/assets/example_map_3.txt Normal file
View File

@ -0,0 +1,41 @@
1 6
################################################################################
#..............................................................................#
#..#...........................................................................#
#...........#..................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
#..............................................................................#
################################################################################

97
squirrelbattle/display/creditsdisplay.py Normal file
View File

@ -0,0 +1,97 @@
# Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse
# SPDX-License-Identifier: GPL-3.0-or-later
import curses
from ..display.display import Box, Display
from ..game import Game
from ..resources import ResourceManager
from ..translations import gettext as _
class CreditsDisplay(Display):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.box = Box(*args, **kwargs)
self.pad = self.newpad(1, 1)
self.ascii_art_displayed = False
def update(self, game: Game) -> None:
return
def display(self) -> None:
self.box.refresh(self.y, self.x, self.height, self.width)
self.box.display()
self.pad.erase()
messages = [
_("Credits"),
"",
"Squirrel Battle",
"",
_("Developers:"),
"Yohann \"ÿnérant\" D'ANELLO",
"Mathilde \"eichhornchen\" DÉPRÉS",
"Nicolas \"nicomarg\" MARGULIES",
"Charles \"charsle\" PEYRAT",
"",
_("Translators:"),
"Hugo \"ifugao\" JACOB (español)",
]
for i, msg in enumerate(messages):
self.addstr(self.pad, i + (self.height - len(messages)) // 2,
(self.width - len(msg)) // 2, msg,
bold=(i == 0), italic=(":" in msg))
if self.ascii_art_displayed:
self.display_ascii_art()
self.refresh_pad(self.pad, 0, 0, self.y + 1, self.x + 1,
self.height + self.y - 2,
self.width + self.x - 2)
def display_ascii_art(self) -> None:
with open(ResourceManager.get_asset_path("ascii-art-ecureuil.txt"))\
as f:
ascii_art = f.read().split("\n")
height, width = len(ascii_art), len(ascii_art[0])
y_offset, x_offset = (self.height - height) // 2,\
(self.width - width) // 2
for i, line in enumerate(ascii_art):
for j, c in enumerate(line):
bg_color = curses.COLOR_WHITE
fg_color = curses.COLOR_BLACK
bold = False
if c == ' ':
bg_color = curses.COLOR_BLACK
elif c == '━' or c == '┃' or c == '⋀':
bold = True
fg_color = curses.COLOR_WHITE
bg_color = curses.COLOR_BLACK
elif c == '|':
bold = True # c = '┃'
fg_color = (100, 700, 1000)
bg_color = curses.COLOR_BLACK
elif c == '▓':
fg_color = (700, 300, 0)
elif c == '▒':
fg_color = (700, 300, 0)
bg_color = curses.COLOR_BLACK
elif c == '░':
fg_color = (350, 150, 0)
elif c == '█':
fg_color = (0, 0, 0)
bg_color = curses.COLOR_BLACK
elif c == '▬':
c = '█'
fg_color = (1000, 1000, 1000)
bg_color = curses.COLOR_BLACK
self.addstr(self.pad, y_offset + i, x_offset + j, c,
fg_color, bg_color, bold=bold)
def handle_click(self, y: int, x: int, game: Game) -> None:
if self.pad.inch(y - 1, x - 1) != ord(" "):
self.ascii_art_displayed = True

38
squirrelbattle/display/display.py
View File

@ -24,9 +24,16 @@ class Display:
self.pack = pack or TexturePack.get_pack("ascii") self.pack = pack or TexturePack.get_pack("ascii")
def newpad(self, height: int, width: int) -> Union[FakePad, Any]: def newpad(self, height: int, width: int) -> Union[FakePad, Any]:
"""
Overwrites the native curses function of the same name.
"""
return curses.newpad(height, width) if self.screen else FakePad() return curses.newpad(height, width) if self.screen else FakePad()
def truncate(self, msg: str, height: int, width: int) -> str: def truncate(self, msg: str, height: int, width: int) -> str:
"""
Truncates a string into a string adapted to the width and height of
the screen.
"""
height = max(0, height) height = max(0, height)
width = max(0, width) width = max(0, width)
lines = msg.split("\n") lines = msg.split("\n")
@ -36,8 +43,8 @@ class Display:
def translate_color(self, color: Union[int, Tuple[int, int, int]]) -> int: def translate_color(self, color: Union[int, Tuple[int, int, int]]) -> int:
""" """
Translate a tuple (R, G, B) into a curses color index. Translates a tuple (R, G, B) into a curses color index.
If we have already a color index, then nothing is processed. If we already have a color index, then nothing is processed.
If this is a tuple, we construct a new color index if non-existing If this is a tuple, we construct a new color index if non-existing
and we return this index. and we return this index.
The values of R, G and B must be between 0 and 1000, and not The values of R, G and B must be between 0 and 1000, and not
@ -66,9 +73,9 @@ class Display:
low: bool = False, right: bool = False, top: bool = False, low: bool = False, right: bool = False, top: bool = False,
vertical: bool = False, chartext: bool = False) -> None: vertical: bool = False, chartext: bool = False) -> None:
""" """
Display a message onto the pad. Displays a message onto the pad.
If the message is too large, it is truncated vertically and horizontally If the message is too large, it is truncated vertically and horizontally
The text can be bold, italic, blinking, ... if the good parameters are The text can be bold, italic, blinking, ... if the right parameters are
given. These parameters are translated into curses attributes. given. These parameters are translated into curses attributes.
The foreground and background colors can be given as curses constants The foreground and background colors can be given as curses constants
(curses.COLOR_*), or by giving a tuple (R, G, B) that corresponds to (curses.COLOR_*), or by giving a tuple (R, G, B) that corresponds to
@ -126,6 +133,9 @@ class Display:
def resize(self, y: int, x: int, height: int, width: int, def resize(self, y: int, x: int, height: int, width: int,
resize_pad: bool = True) -> None: resize_pad: bool = True) -> None:
"""
Resizes a pad.
"""
self.x = x self.x = x
self.y = y self.y = y
self.width = width self.width = width
@ -136,6 +146,9 @@ class Display:
self.pad.resize(self.height + 1, self.width + 1) self.pad.resize(self.height + 1, self.width + 1)
def refresh(self, *args, resize_pad: bool = True) -> None: def refresh(self, *args, resize_pad: bool = True) -> None:
"""
Refreshes a pad
"""
if len(args) == 4: if len(args) == 4:
self.resize(*args, resize_pad) self.resize(*args, resize_pad)
self.display() self.display()
@ -144,10 +157,10 @@ class Display:
window_y: int, window_x: int, window_y: int, window_x: int,
last_y: int, last_x: int) -> None: last_y: int, last_x: int) -> None:
""" """
Refresh a pad on a part of the window. Refreshes a pad on a part of the window.
The refresh starts at coordinates (top_y, top_x) from the pad, The refresh starts at coordinates (top_y, top_x) from the pad,
and is drawn from (window_y, window_x) to (last_y, last_x). and is drawn from (window_y, window_x) to (last_y, last_x).
If coordinates are invalid (negative indexes/length..., then nothing If coordinates are invalid (negative indexes/length...), then nothing
is drawn and no error is raised. is drawn and no error is raised.
""" """
top_y, top_x = max(0, top_y), max(0, top_x) top_y, top_x = max(0, top_y), max(0, top_x)
@ -177,7 +190,7 @@ class Display:
def handle_click(self, y: int, x: int, game: Game) -> None: def handle_click(self, y: int, x: int, game: Game) -> None:
""" """
A mouse click was performed on the coordinates (y, x) of the pad. A mouse click was performed on the coordinates (y, x) of the pad.
Maybe it can do something. Maybe it should do something.
""" """
pass pass
@ -191,7 +204,9 @@ class Display:
class VerticalSplit(Display): class VerticalSplit(Display):
"""
A class to split the screen in two vertically with a pretty line.
"""
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
self.pad = self.newpad(self.rows, 1) self.pad = self.newpad(self.rows, 1)
@ -212,7 +227,9 @@ class VerticalSplit(Display):
class HorizontalSplit(Display): class HorizontalSplit(Display):
"""
A class to split the screen in two horizontally with a pretty line.
"""
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
self.pad = self.newpad(1, self.cols) self.pad = self.newpad(1, self.cols)
@ -233,6 +250,9 @@ class HorizontalSplit(Display):
class Box(Display): class Box(Display):
"""
A class for pretty boxes to print menus and other content.
"""
title: str = "" title: str = ""
def update_title(self, title: str) -> None: def update_title(self, title: str) -> None:

29
squirrelbattle/display/display_manager.py
View File

@ -2,6 +2,8 @@
# SPDX-License-Identifier: GPL-3.0-or-later # SPDX-License-Identifier: GPL-3.0-or-later
import curses import curses
from squirrelbattle.display.creditsdisplay import CreditsDisplay
from squirrelbattle.display.display import VerticalSplit, HorizontalSplit, \ from squirrelbattle.display.display import VerticalSplit, HorizontalSplit, \
Display Display
from squirrelbattle.display.mapdisplay import MapDisplay from squirrelbattle.display.mapdisplay import MapDisplay
@ -30,17 +32,21 @@ class DisplayManager:
self.mainmenudisplay = MainMenuDisplay(self.game.main_menu, self.mainmenudisplay = MainMenuDisplay(self.game.main_menu,
screen, pack) screen, pack)
self.settingsmenudisplay = SettingsMenuDisplay(screen, pack) self.settingsmenudisplay = SettingsMenuDisplay(screen, pack)
self.messagedisplay = MessageDisplay(screen=screen, pack=None) self.messagedisplay = MessageDisplay(screen, pack)
self.hbar = HorizontalSplit(screen, pack) self.hbar = HorizontalSplit(screen, pack)
self.vbar = VerticalSplit(screen, pack) self.vbar = VerticalSplit(screen, pack)
self.creditsdisplay = CreditsDisplay(screen, pack)
self.displays = [self.statsdisplay, self.mapdisplay, self.displays = [self.statsdisplay, self.mapdisplay,
self.mainmenudisplay, self.settingsmenudisplay, self.mainmenudisplay, self.settingsmenudisplay,
self.logsdisplay, self.messagedisplay, self.logsdisplay, self.messagedisplay,
self.playerinventorydisplay, self.playerinventorydisplay,
self.storeinventorydisplay] self.storeinventorydisplay, self.creditsdisplay]
self.update_game_components() self.update_game_components()
def handle_display_action(self, action: DisplayActions, *params) -> None: def handle_display_action(self, action: DisplayActions, *params) -> None:
"""
Handles the differents values of display action.
"""
if action == DisplayActions.REFRESH: if action == DisplayActions.REFRESH:
self.refresh() self.refresh()
elif action == DisplayActions.UPDATE: elif action == DisplayActions.UPDATE:
@ -58,6 +64,9 @@ class DisplayManager:
d.update(self.game) d.update(self.game)
def handle_mouse_click(self, y: int, x: int) -> None: def handle_mouse_click(self, y: int, x: int) -> None:
"""
Handles the mouse clicks.
"""
displays = self.refresh() displays = self.refresh()
display = None display = None
for d in displays: for d in displays:
@ -70,6 +79,9 @@ class DisplayManager:
display.handle_click(y - display.y, x - display.x, self.game) display.handle_click(y - display.y, x - display.x, self.game)
def refresh(self) -> List[Display]: def refresh(self) -> List[Display]:
"""
Refreshes all components on the screen.
"""
displays = [] displays = []
pack = TexturePack.get_pack(self.game.settings.TEXTURE_PACK) pack = TexturePack.get_pack(self.game.settings.TEXTURE_PACK)
@ -118,6 +130,9 @@ class DisplayManager:
elif self.game.state == GameMode.SETTINGS: elif self.game.state == GameMode.SETTINGS:
self.settingsmenudisplay.refresh(0, 0, self.rows, self.cols) self.settingsmenudisplay.refresh(0, 0, self.rows, self.cols)
displays.append(self.settingsmenudisplay) displays.append(self.settingsmenudisplay)
elif self.game.state == GameMode.CREDITS:
self.creditsdisplay.refresh(0, 0, self.rows, self.cols)
displays.append(self.creditsdisplay)
if self.game.message: if self.game.message:
height, width = 0, 0 height, width = 0, 0
@ -135,7 +150,7 @@ class DisplayManager:
def resize_window(self) -> bool: def resize_window(self) -> bool:
""" """
If the window got resized, ensure that the screen size got updated. When the window is resized, ensures that the screen size is updated.
""" """
y, x = self.screen.getmaxyx() if self.screen else (0, 0) y, x = self.screen.getmaxyx() if self.screen else (0, 0)
if self.screen and curses.is_term_resized(self.rows, if self.screen and curses.is_term_resized(self.rows,
@ -146,8 +161,16 @@ class DisplayManager:
@property @property
def rows(self) -> int: def rows(self) -> int:
"""
Overwrites the native curses attribute of the same name,
for testing purposes.
"""
return curses.LINES if self.screen else 42 return curses.LINES if self.screen else 42
@property @property
def cols(self) -> int: def cols(self) -> int:
"""
Overwrites the native curses attribute of the same name,
for testing purposes.
"""
return curses.COLS if self.screen else 42 return curses.COLS if self.screen else 42

4
squirrelbattle/display/logsdisplay.py
View File

@ -7,6 +7,10 @@ from squirrelbattle.interfaces import Logs
class LogsDisplay(Display): class LogsDisplay(Display):
"""
A class to handle the display of the logs.
"""
logs: Logs logs: Logs
def __init__(self, *args) -> None: def __init__(self, *args) -> None:

24
squirrelbattle/display/mapdisplay.py
View File

@ -7,6 +7,10 @@ from ..game import Game
class MapDisplay(Display): class MapDisplay(Display):
"""
A class to handle the display of the map.
"""
map: Map map: Map
def __init__(self, *args): def __init__(self, *args):
@ -18,13 +22,21 @@ class MapDisplay(Display):
self.pack.tile_width * self.map.width + 1) self.pack.tile_width * self.map.width + 1)
def update_pad(self) -> None: def update_pad(self) -> None:
self.pad.resize(500, 500) for j in range(len(self.map.tiles)):
self.addstr(self.pad, 0, 0, self.map.draw_string(self.pack), for i in range(len(self.map.tiles[j])):
self.pack.tile_fg_color, self.pack.tile_bg_color) if not self.map.seen_tiles[j][i]:
continue
fg, bg = self.map.tiles[j][i].visible_color(self.pack) if \
self.map.visibility[j][i] else \
self.map.tiles[j][i].hidden_color(self.pack)
self.addstr(self.pad, j, self.pack.tile_width * i,
self.map.tiles[j][i].char(self.pack), fg, bg)
for e in self.map.entities: for e in self.map.entities:
self.addstr(self.pad, e.y, self.pack.tile_width * e.x, if self.map.visibility[e.y][e.x]:
self.pack[e.name.upper()], self.addstr(self.pad, e.y, self.pack.tile_width * e.x,
self.pack.entity_fg_color, self.pack.entity_bg_color) self.pack[e.name.upper()],
self.pack.entity_fg_color,
self.pack.entity_bg_color)
# Display Path map for debug purposes # Display Path map for debug purposes
# from squirrelbattle.entities.player import Player # from squirrelbattle.entities.player import Player

17
squirrelbattle/display/menudisplay.py
View File

@ -16,7 +16,7 @@ from ..translations import gettext as _
class MenuDisplay(Display): class MenuDisplay(Display):
""" """
A class to display the menu objects A class to display the menu objects.
""" """
menu: Menu menu: Menu
position: int position: int
@ -80,7 +80,7 @@ class MenuDisplay(Display):
class SettingsMenuDisplay(MenuDisplay): class SettingsMenuDisplay(MenuDisplay):
""" """
A class to display specifically a settingsmenu object A class to display specifically a settingsmenu object.
""" """
menu: SettingsMenu menu: SettingsMenu
@ -98,7 +98,7 @@ class SettingsMenuDisplay(MenuDisplay):
class MainMenuDisplay(Display): class MainMenuDisplay(Display):
""" """
A class to display specifically a mainmenu object A class to display specifically a mainmenu object.
""" """
def __init__(self, menu: MainMenu, *args): def __init__(self, menu: MainMenu, *args):
super().__init__(*args) super().__init__(*args)
@ -120,6 +120,8 @@ class MainMenuDisplay(Display):
self.addstr(self.pad, 4 + i, max(self.width // 2 self.addstr(self.pad, 4 + i, max(self.width // 2
- len(self.title[0]) // 2 - 1, 0), self.title[i], - len(self.title[0]) // 2 - 1, 0), self.title[i],
self.fg_color) self.fg_color)
msg = _("Credits")
self.addstr(self.pad, self.height - 1, self.width - 1 - len(msg), msg)
self.refresh_pad(self.pad, 0, 0, self.y, self.x, self.refresh_pad(self.pad, 0, 0, self.y, self.x,
self.height + self.y - 1, self.height + self.y - 1,
self.width + self.x - 1) self.width + self.x - 1)
@ -143,8 +145,14 @@ class MainMenuDisplay(Display):
if y <= len(self.title): if y <= len(self.title):
self.fg_color = randint(0, 1000), randint(0, 1000), randint(0, 1000) self.fg_color = randint(0, 1000), randint(0, 1000), randint(0, 1000)
if y == self.height - 1 and x >= self.width - 1 - len(_("Credits")):
game.state = GameMode.CREDITS
class PlayerInventoryDisplay(MenuDisplay): class PlayerInventoryDisplay(MenuDisplay):
"""
A class to handle the display of the player's inventory.
"""
player: Player = None player: Player = None
selected: bool = True selected: bool = True
store_mode: bool = False store_mode: bool = False
@ -191,6 +199,9 @@ class PlayerInventoryDisplay(MenuDisplay):
class StoreInventoryDisplay(MenuDisplay): class StoreInventoryDisplay(MenuDisplay):
"""
A class to handle the display of a merchant's inventory.
"""
menu: StoreMenu menu: StoreMenu
selected: bool = False selected: bool = False

2
squirrelbattle/display/messagedisplay.py
View File

@ -8,7 +8,7 @@ from squirrelbattle.game import Game
class MessageDisplay(Display): class MessageDisplay(Display):
""" """
Display a message in a popup. A class to handle the display of popup messages.
""" """
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):

23
squirrelbattle/display/statsdisplay.py
View File

@ -10,6 +10,9 @@ from .display import Display
class StatsDisplay(Display): class StatsDisplay(Display):
"""
A class to handle the display of the stats of the player.
"""
player: Player player: Player
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
@ -20,16 +23,18 @@ class StatsDisplay(Display):
self.player = game.player self.player = game.player
def update_pad(self) -> None: def update_pad(self) -> None:
string2 = _("player").capitalize() + " -- LVL {}\nEXP {}/{}\nHP {}/{}"\ string2 = f"{_(self.player.name).capitalize()} " \
.format(self.player.level, self.player.current_xp, f"-- LVL {self.player.level} -- " \
self.player.max_xp, self.player.health, f"FLOOR {-self.player.map.floor}\n" \
self.player.maxhealth) f"EXP {self.player.current_xp}/{self.player.max_xp}\n" \
f"HP {self.player.health}/{self.player.maxhealth}"
self.addstr(self.pad, 0, 0, string2) self.addstr(self.pad, 0, 0, string2)
string3 = "STR {}\nINT {}\nCHR {}\nDEX {}\nCON {}\nCRI {}%"\ string3 = f"STR {self.player.strength}\n" \
.format(self.player.strength, f"INT {self.player.intelligence}\n" \
self.player.intelligence, self.player.charisma, f"CHR {self.player.charisma}\n" \
self.player.dexterity, self.player.constitution, f"DEX {self.player.dexterity}\n" \
self.player.critical) f"CON {self.player.constitution}\n" \
f"CRI {self.player.critical}%"
self.addstr(self.pad, 3, 0, string3) self.addstr(self.pad, 3, 0, string3)
inventory_str = _("Inventory:") + " " inventory_str = _("Inventory:") + " "

28
squirrelbattle/display/texturepack.py
View File

@ -2,18 +2,22 @@
# SPDX-License-Identifier: GPL-3.0-or-later # SPDX-License-Identifier: GPL-3.0-or-later
import curses import curses
from typing import Any from typing import Any, Union, Tuple
class TexturePack: class TexturePack:
"""
A class to handle displaying several textures.
"""
_packs = dict() _packs = dict()
name: str name: str
tile_width: int tile_width: int
tile_fg_color: int tile_fg_color: Union[int, Tuple[int, int, int]]
tile_bg_color: int tile_fg_visible_color: Union[int, Tuple[int, int, int]]
entity_fg_color: int tile_bg_color: Union[int, Tuple[int, int, int]]
entity_bg_color: int entity_fg_color: Union[int, Tuple[int, int, int]]
entity_bg_color: Union[int, Tuple[int, int, int]]
BODY_SNATCH_POTION: str BODY_SNATCH_POTION: str
BOMB: str BOMB: str
@ -29,6 +33,7 @@ class TexturePack:
SWORD: str SWORD: str
TEDDY_BEAR: str TEDDY_BEAR: str
TIGER: str TIGER: str
TRUMPET: str
WALL: str WALL: str
EAGLE: str EAGLE: str
SHIELD: str SHIELD: str
@ -60,9 +65,10 @@ class TexturePack:
TexturePack.ASCII_PACK = TexturePack( TexturePack.ASCII_PACK = TexturePack(
name="ascii", name="ascii",
tile_width=1, tile_width=1,
tile_fg_visible_color=(1000, 1000, 1000),
tile_fg_color=curses.COLOR_WHITE, tile_fg_color=curses.COLOR_WHITE,
tile_bg_color=curses.COLOR_BLACK, tile_bg_color=curses.COLOR_BLACK,
entity_fg_color=curses.COLOR_WHITE, entity_fg_color=(1000, 1000, 1000),
entity_bg_color=curses.COLOR_BLACK, entity_bg_color=curses.COLOR_BLACK,
BODY_SNATCH_POTION='S', BODY_SNATCH_POTION='S',
@ -70,6 +76,7 @@ TexturePack.ASCII_PACK = TexturePack(
EMPTY=' ', EMPTY=' ',
EXPLOSION='%', EXPLOSION='%',
FLOOR='.', FLOOR='.',
LADDER='H',
HAZELNUT='¤', HAZELNUT='¤',
HEART='❤', HEART='❤',
HEDGEHOG='*', HEDGEHOG='*',
@ -81,6 +88,7 @@ TexturePack.ASCII_PACK = TexturePack(
SWORD='\u2020', SWORD='\u2020',
TEDDY_BEAR='8', TEDDY_BEAR='8',
TIGER='n', TIGER='n',
TRUMPET='/',
WALL='#', WALL='#',
EAGLE='µ', EAGLE='µ',
CHESTPLATE='(', CHESTPLATE='(',
@ -92,16 +100,19 @@ TexturePack.ASCII_PACK = TexturePack(
TexturePack.SQUIRREL_PACK = TexturePack( TexturePack.SQUIRREL_PACK = TexturePack(
name="squirrel", name="squirrel",
tile_width=2, tile_width=2,
tile_fg_visible_color=(1000, 1000, 1000),
tile_fg_color=curses.COLOR_WHITE, tile_fg_color=curses.COLOR_WHITE,
tile_bg_color=curses.COLOR_BLACK, tile_bg_color=curses.COLOR_BLACK,
entity_fg_color=curses.COLOR_WHITE, entity_fg_color=(1000, 1000, 1000),
entity_bg_color=curses.COLOR_WHITE, entity_bg_color=(1000, 1000, 1000),
BODY_SNATCH_POTION='🔀', BODY_SNATCH_POTION='🔀',
BOMB='💣', BOMB='💣',
EMPTY=' ', EMPTY=' ',
EXPLOSION='💥', EXPLOSION='💥',
FLOOR='██', FLOOR='██',
LADDER=('🪜', curses.COLOR_WHITE, (1000, 1000, 1000),
curses.COLOR_WHITE, (1000, 1000, 1000)),
HAZELNUT='🌰', HAZELNUT='🌰',
HEART='💜', HEART='💜',
HEDGEHOG='🦔', HEDGEHOG='🦔',
@ -113,6 +124,7 @@ TexturePack.SQUIRREL_PACK = TexturePack(
SWORD='🗡️ ', SWORD='🗡️ ',
TEDDY_BEAR='🧸', TEDDY_BEAR='🧸',
TIGER='🐅', TIGER='🐅',
TRUMPET='🎺',
WALL='🧱', WALL='🧱',
EAGLE='🦅', EAGLE='🦅',
CHESTPLATE='🦺', CHESTPLATE='🦺',

92
squirrelbattle/entities/friendly.py
View File

@ -1,17 +1,18 @@
from ..interfaces import FriendlyEntity, InventoryHolder from ..interfaces import FriendlyEntity, InventoryHolder, Map, FightingEntity
from ..translations import gettext as _ from ..translations import gettext as _
from .player import Player from .player import Player
from .monsters import Monster
from .items import Item from .items import Item
from random import choice from random import choice, shuffle
class Merchant(InventoryHolder, FriendlyEntity): class Merchant(InventoryHolder, FriendlyEntity):
""" """
The class for merchants in the dungeon The class of merchants in the dungeon.
""" """
def keys(self) -> list: def keys(self) -> list:
""" """
Returns a friendly entitie's specific attributes Returns a friendly entitie's specific attributes.
""" """
return super().keys() + ["inventory", "hazel"] return super().keys() + ["inventory", "hazel"]
@ -20,7 +21,6 @@ class Merchant(InventoryHolder, FriendlyEntity):
super().__init__(name=name, *args, **kwargs) super().__init__(name=name, *args, **kwargs)
self.inventory = self.translate_inventory(inventory or []) self.inventory = self.translate_inventory(inventory or [])
self.hazel = hazel self.hazel = hazel
if not self.inventory: if not self.inventory:
for i in range(5): for i in range(5):
self.inventory.append(choice(Item.get_all_items())()) self.inventory.append(choice(Item.get_all_items())())
@ -28,20 +28,20 @@ class Merchant(InventoryHolder, FriendlyEntity):
def talk_to(self, player: Player) -> str: def talk_to(self, player: Player) -> str:
""" """
This function is used to open the merchant's inventory in a menu, This function is used to open the merchant's inventory in a menu,
and allow the player to buy/sell objects and allows the player to buy/sell objects.
""" """
return _("I don't sell any squirrel") return _("I don't sell any squirrel")
def change_hazel_balance(self, hz: int) -> None: def change_hazel_balance(self, hz: int) -> None:
""" """
Change the number of hazel the merchant has by hz. Changes the number of hazel the merchant has by hz.
""" """
self.hazel += hz self.hazel += hz
class Sunflower(FriendlyEntity): class Sunflower(FriendlyEntity):
""" """
A friendly sunflower A friendly sunflower.
""" """
def __init__(self, maxhealth: int = 15, def __init__(self, maxhealth: int = 15,
*args, **kwargs) -> None: *args, **kwargs) -> None:
@ -49,4 +49,80 @@ class Sunflower(FriendlyEntity):
@property @property
def dialogue_option(self) -> list: def dialogue_option(self) -> list:
"""
Lists all that a sunflower can say to the player.
"""
return [_("Flower power!!"), _("The sun is warm today")] return [_("Flower power!!"), _("The sun is warm today")]
class Familiar(FightingEntity):
"""
A friendly familiar that helps the player defeat monsters.
"""
def __init__(self, maxhealth: int = 25,
*args, **kwargs) -> None:
super().__init__(maxhealth=maxhealth, *args, **kwargs)
self.target = None
# @property
# def dialogue_option(self) -> list:
# """
# Debug function (to see if used in the real game)
# """
# return [_("My target is"+str(self.target))]
def act(self, p: Player, m: Map) -> None:
"""
By default, the familiar tries to stay at distance at most 2 of the
player and if a monster comes in range 3, it focuses on the monster
and attacks it.
"""
if self.target is None:
# If the previous target is dead(or if there was no previous target)
# the familiar tries to get closer to the player.
self.target = p
elif self.target.dead:
self.target = p
if self.target == p:
# Look for monsters around the player to kill TOFIX : if monster is
# out of range, continue targetting player.
for entity in m.entities:
if (p.y - entity.y) ** 2 + (p.x - entity.x) ** 2 <= 9 and\
isinstance(entity, Monster):
self.target = entity
entity.paths = dict() # Allows the paths to be calculated.
break
# Familiars move according to a Dijkstra algorithm
# that targets their target.
# If they can not move and are already close to their target,
# they hit, except if their target is the player.
if self.target and (self.y, self.x) in self.target.paths:
# Moves to target player by choosing the best available path
for next_y, next_x in self.target.paths[(self.y, self.x)]:
moved = self.check_move(next_y, next_x, True)
if moved:
break
if self.distance_squared(self.target) <= 1 and \
not isinstance(self.target, Player):
self.map.logs.add_message(self.hit(self.target))
break
else:
# Moves in a random direction
# If the direction is not available, tries another one
moves = [self.move_up, self.move_down,
self.move_left, self.move_right]
shuffle(moves)
for move in moves:
if move():
break
class Trumpet(Familiar):
"""
A class of familiars.
"""
def __init__(self, name: str = "trumpet", strength: int = 3,
maxhealth: int = 20, *args, **kwargs) -> None:
super().__init__(name=name, strength=strength,
maxhealth=maxhealth, *args, **kwargs)

30
squirrelbattle/entities/items.py
View File

@ -10,7 +10,7 @@ from ..translations import gettext as _
class Item(Entity): class Item(Entity):
""" """
A class for items A class for items.
""" """
held: bool held: bool
held_by: Optional[InventoryHolder] held_by: Optional[InventoryHolder]
@ -26,7 +26,7 @@ class Item(Entity):
def drop(self) -> None: def drop(self) -> None:
""" """
The item is dropped from the inventory onto the floor The item is dropped from the inventory onto the floor.
""" """
if self.held: if self.held:
self.held_by.remove_from_inventory(self) self.held_by.remove_from_inventory(self)
@ -59,7 +59,7 @@ class Item(Entity):
def hold(self, holder: InventoryHolder) -> None: def hold(self, holder: InventoryHolder) -> None:
""" """
The item is taken from the floor and put into the inventory The item is taken from the floor and put into the inventory.
""" """
self.held = True self.held = True
self.held_by = holder self.held_by = holder
@ -68,7 +68,7 @@ class Item(Entity):
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the state of the entity into a dictionary Saves the state of the item into a dictionary.
""" """
d = super().save_state() d = super().save_state()
d["held"] = self.held d["held"] = self.held
@ -76,6 +76,9 @@ class Item(Entity):
@staticmethod @staticmethod
def get_all_items() -> list: def get_all_items() -> list:
"""
Returns the list of all item classes.
"""
return [BodySnatchPotion, Bomb, Heart, Shield, Sword, return [BodySnatchPotion, Bomb, Heart, Shield, Sword,
Chestplate, Helmet, RingCritical, RingXP] Chestplate, Helmet, RingCritical, RingXP]
@ -83,7 +86,7 @@ class Item(Entity):
""" """
Does all necessary actions when an object is to be sold. Does all necessary actions when an object is to be sold.
Is overwritten by some classes that cannot exist in the player's Is overwritten by some classes that cannot exist in the player's
inventory inventory.
""" """
if buyer.hazel >= self.price: if buyer.hazel >= self.price:
self.hold(buyer) self.hold(buyer)
@ -97,7 +100,7 @@ class Item(Entity):
class Heart(Item): class Heart(Item):
""" """
A heart item to return health to the player A heart item to return health to the player.
""" """
healing: int healing: int
@ -108,14 +111,15 @@ class Heart(Item):
def hold(self, entity: InventoryHolder) -> None: def hold(self, entity: InventoryHolder) -> None:
""" """
When holding a heart, heal the player and don't put item in inventory. When holding a heart, the player is healed and
the item is not put in the inventory.
""" """
entity.health = min(entity.maxhealth, entity.health + self.healing) entity.health = min(entity.maxhealth, entity.health + self.healing)
entity.map.remove_entity(self) entity.map.remove_entity(self)
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the state of the header into a dictionary Saves the state of the heart into a dictionary.
""" """
d = super().save_state() d = super().save_state()
d["healing"] = self.healing d["healing"] = self.healing
@ -141,7 +145,7 @@ class Bomb(Item):
def use(self) -> None: def use(self) -> None:
""" """
When the bomb is used, throw it and explodes it. When the bomb is used, it is thrown and then it explodes.
""" """
if self.held: if self.held:
self.owner = self.held_by self.owner = self.held_by
@ -150,7 +154,7 @@ class Bomb(Item):
def act(self, m: Map) -> None: def act(self, m: Map) -> None:
""" """
Special exploding action of the bomb Special exploding action of the bomb.
""" """
if self.exploding: if self.exploding:
if self.tick > 0: if self.tick > 0:
@ -176,7 +180,7 @@ class Bomb(Item):
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the state of the bomb into a dictionary Saves the state of the bomb into a dictionary.
""" """
d = super().save_state() d = super().save_state()
d["exploding"] = self.exploding d["exploding"] = self.exploding
@ -193,13 +197,13 @@ class Explosion(Item):
def act(self, m: Map) -> None: def act(self, m: Map) -> None:
""" """
The explosion instant dies. The bomb disappears after exploding.
""" """
m.remove_entity(self) m.remove_entity(self)
def hold(self, player: InventoryHolder) -> None: def hold(self, player: InventoryHolder) -> None:
""" """
The player can't hold any explosion. The player can't hold an explosion.
""" """

37
squirrelbattle/entities/monsters.py
View File

@ -10,8 +10,8 @@ from ..interfaces import FightingEntity, Map
class Monster(FightingEntity): class Monster(FightingEntity):
""" """
The class for all monsters in the dungeon. The class for all monsters in the dungeon.
A monster must override this class, and the parameters are given All specific monster classes overwrite this class,
in the __init__ function. and the parameters are given in the __init__ function.
An example of the specification of a monster that has a strength of 4 An example of the specification of a monster that has a strength of 4
and 20 max HP: and 20 max HP:
@ -21,7 +21,7 @@ class Monster(FightingEntity):
super().__init__(name="my_monster", strength=strength, super().__init__(name="my_monster", strength=strength,
maxhealth=maxhealth, *args, **kwargs) maxhealth=maxhealth, *args, **kwargs)
With that way, attributes can be overwritten when the entity got created. With that way, attributes can be overwritten when the entity is created.
""" """
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
@ -29,7 +29,7 @@ class Monster(FightingEntity):
def act(self, m: Map) -> None: def act(self, m: Map) -> None:
""" """
By default, a monster will move randomly where it is possible By default, a monster will move randomly where it is possible
And if a player is close to the monster, the monster run on the player. If the player is closeby, the monster runs to the player.
""" """
target = None target = None
for entity in m.entities: for entity in m.entities:
@ -38,12 +38,12 @@ class Monster(FightingEntity):
target = entity target = entity
break break
# A Dijkstra algorithm has ran that targets the player. # Monsters move according to a Dijkstra algorithm
# With that way, monsters can simply follow the path. # that targets the player.
# If they can't move and they are already close to the player, # If they can not move and are already close to the player,
# They hit. # they hit.
if target and (self.y, self.x) in target.paths: if target and (self.y, self.x) in target.paths:
# Move to target player by choosing the best avaliable path # Moves to target player by choosing the best available path
for next_y, next_x in target.paths[(self.y, self.x)]: for next_y, next_x in target.paths[(self.y, self.x)]:
moved = self.check_move(next_y, next_x, True) moved = self.check_move(next_y, next_x, True)
if moved: if moved:
@ -52,8 +52,8 @@ class Monster(FightingEntity):
self.map.logs.add_message(self.hit(target)) self.map.logs.add_message(self.hit(target))
break break
else: else:
# Move in a random direction # Moves in a random direction
# If the direction is not available, try another one # If the direction is not available, tries another one
moves = [self.move_up, self.move_down, moves = [self.move_up, self.move_down,
self.move_left, self.move_right] self.move_left, self.move_right]
shuffle(moves) shuffle(moves)
@ -61,10 +61,17 @@ class Monster(FightingEntity):
if move(): if move():
break break
def move(self, y: int, x: int) -> None:
"""
Overwrites the move function to recalculate paths.
"""
super().move(y, x)
self.recalculate_paths()
class Tiger(Monster): class Tiger(Monster):
""" """
A tiger monster A tiger monster.
""" """
def __init__(self, name: str = "tiger", strength: int = 2, def __init__(self, name: str = "tiger", strength: int = 2,
maxhealth: int = 20, *args, **kwargs) -> None: maxhealth: int = 20, *args, **kwargs) -> None:
@ -74,7 +81,7 @@ class Tiger(Monster):
class Hedgehog(Monster): class Hedgehog(Monster):
""" """
A really mean hedgehog monster A really mean hedgehog monster.
""" """
def __init__(self, name: str = "hedgehog", strength: int = 3, def __init__(self, name: str = "hedgehog", strength: int = 3,
maxhealth: int = 10, *args, **kwargs) -> None: maxhealth: int = 10, *args, **kwargs) -> None:
@ -84,7 +91,7 @@ class Hedgehog(Monster):
class Rabbit(Monster): class Rabbit(Monster):
""" """
A rabbit monster A rabbit monster.
""" """
def __init__(self, name: str = "rabbit", strength: int = 1, def __init__(self, name: str = "rabbit", strength: int = 1,
maxhealth: int = 15, critical: int = 30, maxhealth: int = 15, critical: int = 30,
@ -96,7 +103,7 @@ class Rabbit(Monster):
class TeddyBear(Monster): class TeddyBear(Monster):
""" """
A cute teddybear monster A cute teddybear monster.
""" """
def __init__(self, name: str = "teddy_bear", strength: int = 0, def __init__(self, name: str = "teddy_bear", strength: int = 0,
maxhealth: int = 50, *args, **kwargs) -> None: maxhealth: int = 50, *args, **kwargs) -> None:

67
squirrelbattle/entities/player.py
View File

@ -1,10 +1,11 @@
# Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse # Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse
# SPDX-License-Identifier: GPL-3.0-or-later # SPDX-License-Identifier: GPL-3.0-or-later
from functools import reduce
from queue import PriorityQueue
from random import randint from random import randint
<<<<<<< squirrelbattle/entities/player.py
from typing import Dict, Optional, Tuple from typing import Dict, Optional, Tuple
=======
>>>>>>> squirrelbattle/entities/player.py
from .items import Item from .items import Item
from ..interfaces import FightingEntity, InventoryHolder from ..interfaces import FightingEntity, InventoryHolder
@ -12,7 +13,7 @@ from ..interfaces import FightingEntity, InventoryHolder
class Player(InventoryHolder, FightingEntity): class Player(InventoryHolder, FightingEntity):
""" """
The class of the player The class of the player.
""" """
current_xp: int = 0 current_xp: int = 0
max_xp: int = 10 max_xp: int = 10
@ -31,7 +32,7 @@ class Player(InventoryHolder, FightingEntity):
equipped_armor: Optional[Item] = None, critical: int = 5, equipped_armor: Optional[Item] = None, critical: int = 5,
equipped_secondary: Optional[Item] = None, equipped_secondary: Optional[Item] = None,
equipped_helmet: Optional[Item] = None, xp_buff: float = 1, equipped_helmet: Optional[Item] = None, xp_buff: float = 1,
*args, **kwargs) -> None: vision: int = 5, *args, **kwargs) -> None:
super().__init__(name=name, maxhealth=maxhealth, strength=strength, super().__init__(name=name, maxhealth=maxhealth, strength=strength,
intelligence=intelligence, charisma=charisma, intelligence=intelligence, charisma=charisma,
dexterity=dexterity, constitution=constitution, dexterity=dexterity, constitution=constitution,
@ -50,6 +51,7 @@ class Player(InventoryHolder, FightingEntity):
if isinstance(equipped_secondary, dict) else equipped_secondary if isinstance(equipped_secondary, dict) else equipped_secondary
self.equipped_helmet = self.dict_to_item(equipped_helmet) \ self.equipped_helmet = self.dict_to_item(equipped_helmet) \
if isinstance(equipped_helmet, dict) else equipped_helmet if isinstance(equipped_helmet, dict) else equipped_helmet
self.vision = vision
def move(self, y: int, x: int) -> None: def move(self, y: int, x: int) -> None:
""" """
@ -60,10 +62,11 @@ class Player(InventoryHolder, FightingEntity):
self.map.currenty = y self.map.currenty = y
self.map.currentx = x self.map.currentx = x
self.recalculate_paths() self.recalculate_paths()
self.map.compute_visibility(self.y, self.x, self.vision)
def level_up(self) -> None: def level_up(self) -> None:
""" """
Add levels to the player as much as it is possible. Add as many levels as possible to the player.
""" """
while self.current_xp > self.max_xp: while self.current_xp > self.max_xp:
self.level += 1 self.level += 1
@ -77,8 +80,8 @@ class Player(InventoryHolder, FightingEntity):
def add_xp(self, xp: int) -> None: def add_xp(self, xp: int) -> None:
""" """
Add some experience to the player. Adds some experience to the player.
If the required amount is reached, level up. If the required amount is reached, the player levels up.
""" """
self.current_xp += int(xp * self.xp_buff) self.current_xp += int(xp * self.xp_buff)
self.level_up() self.level_up()
@ -120,56 +123,6 @@ class Player(InventoryHolder, FightingEntity):
entity.hold(self) entity.hold(self)
return super().check_move(y, x, move_if_possible) 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. Actually, the paths are computed for each tile adjacent to
the player then for each step the monsters use the best path avaliable.
"""
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]])]
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the state of the entity into a dictionary Saves the state of the entity into a dictionary

11
squirrelbattle/enums.py
View File

@ -21,20 +21,20 @@ class DisplayActions(Enum):
class GameMode(Enum): class GameMode(Enum):
""" """
Game mode options Game mode options.
""" """
MAINMENU = auto() MAINMENU = auto()
PLAY = auto() PLAY = auto()
SETTINGS = auto() SETTINGS = auto()
INVENTORY = auto() INVENTORY = auto()
STORE = auto() STORE = auto()
CREDITS = auto()
class KeyValues(Enum): class KeyValues(Enum):
""" """
Key values options used in the game Key values options used in the game.
""" """
MOUSE = auto()
UP = auto() UP = auto()
DOWN = auto() DOWN = auto()
LEFT = auto() LEFT = auto()
@ -47,11 +47,12 @@ class KeyValues(Enum):
SPACE = auto() SPACE = auto()
CHAT = auto() CHAT = auto()
WAIT = auto() WAIT = auto()
LADDER = auto()
@staticmethod @staticmethod
def translate_key(key: str, settings: Settings) -> Optional["KeyValues"]: def translate_key(key: str, settings: Settings) -> Optional["KeyValues"]:
""" """
Translate the raw string key into an enum value that we can use. Translates the raw string key into an enum value that we can use.
""" """
if key in (settings.KEY_DOWN_SECONDARY, if key in (settings.KEY_DOWN_SECONDARY,
settings.KEY_DOWN_PRIMARY): settings.KEY_DOWN_PRIMARY):
@ -81,4 +82,6 @@ class KeyValues(Enum):
return KeyValues.CHAT return KeyValues.CHAT
elif key == settings.KEY_WAIT: elif key == settings.KEY_WAIT:
return KeyValues.WAIT return KeyValues.WAIT
elif key == settings.KEY_LADDER:
return KeyValues.LADDER
return None return None

112
squirrelbattle/game.py
View File

@ -3,7 +3,7 @@
from json import JSONDecodeError from json import JSONDecodeError
from random import randint from random import randint
from typing import Any, Optional from typing import Any, Optional, List
import curses import curses
import json import json
import os import os
@ -22,7 +22,8 @@ class Game:
""" """
The game object controls all actions in the game. The game object controls all actions in the game.
""" """
map: Map maps: List[Map]
map_index: int
player: Player player: Player
screen: Any screen: Any
# display_actions is a display interface set by the bootstrapper # display_actions is a display interface set by the bootstrapper
@ -30,7 +31,7 @@ class Game:
def __init__(self) -> None: def __init__(self) -> None:
""" """
Init the game. Initiates the game.
""" """
self.state = GameMode.MAINMENU self.state = GameMode.MAINMENU
self.waiting_for_friendly_key = False self.waiting_for_friendly_key = False
@ -49,10 +50,12 @@ class Game:
def new_game(self) -> None: def new_game(self) -> None:
""" """
Create a new game on the screen. Creates a new game on the screen.
""" """
# TODO generate a new map procedurally # TODO generate a new map procedurally
self.map = Map.load(ResourceManager.get_asset_path("example_map_2.txt")) self.maps = []
self.map_index = 0
self.map = Map.load(ResourceManager.get_asset_path("example_map.txt"))
self.map.logs = self.logs self.map.logs = self.logs
self.logs.clear() self.logs.clear()
self.player = Player() self.player = Player()
@ -61,11 +64,29 @@ class Game:
self.map.spawn_random_entities(randint(3, 10)) self.map.spawn_random_entities(randint(3, 10))
self.inventory_menu.update_player(self.player) self.inventory_menu.update_player(self.player)
@property
def map(self) -> Map:
"""
Return the current map where the user is.
"""
return self.maps[self.map_index]
@map.setter
def map(self, m: Map) -> None:
"""
Redefine the current map.
"""
if len(self.maps) == self.map_index:
# Insert new map
self.maps.append(m)
# Redefine the current map
self.maps[self.map_index] = m
def run(self, screen: Any) -> None: # pragma no cover def run(self, screen: Any) -> None: # pragma no cover
""" """
Main infinite loop. Main infinite loop.
We wait for the player's action, then we do what that should be done We wait for the player's action, then we do what should be done
when the given key gets pressed. when a key gets pressed.
""" """
screen.refresh() screen.refresh()
while True: while True:
@ -84,7 +105,7 @@ class Game:
def handle_key_pressed(self, key: Optional[KeyValues], raw_key: str = '')\ def handle_key_pressed(self, key: Optional[KeyValues], raw_key: str = '')\
-> None: -> None:
""" """
Indicates what should be done when the given key is pressed, Indicates what should be done when a given key is pressed,
according to the current game state. according to the current game state.
""" """
if self.message: if self.message:
@ -106,6 +127,8 @@ class Game:
self.settings_menu.handle_key_pressed(key, raw_key, self) self.settings_menu.handle_key_pressed(key, raw_key, self)
elif self.state == GameMode.STORE: elif self.state == GameMode.STORE:
self.handle_key_pressed_store(key) self.handle_key_pressed_store(key)
elif self.state == GameMode.CREDITS:
self.state = GameMode.MAINMENU
self.display_actions(DisplayActions.REFRESH) self.display_actions(DisplayActions.REFRESH)
def handle_key_pressed_play(self, key: KeyValues) -> None: # noqa: C901 def handle_key_pressed_play(self, key: KeyValues) -> None: # noqa: C901
@ -114,16 +137,16 @@ class Game:
""" """
if key == KeyValues.UP: if key == KeyValues.UP:
if self.player.move_up(): if self.player.move_up():
self.map.tick() self.map.tick(self.player)
elif key == KeyValues.DOWN: elif key == KeyValues.DOWN:
if self.player.move_down(): if self.player.move_down():
self.map.tick() self.map.tick(self.player)
elif key == KeyValues.LEFT: elif key == KeyValues.LEFT:
if self.player.move_left(): if self.player.move_left():
self.map.tick() self.map.tick(self.player)
elif key == KeyValues.RIGHT: elif key == KeyValues.RIGHT:
if self.player.move_right(): if self.player.move_right():
self.map.tick() self.map.tick(self.player)
elif key == KeyValues.INVENTORY: elif key == KeyValues.INVENTORY:
self.state = GameMode.INVENTORY self.state = GameMode.INVENTORY
self.display_actions(DisplayActions.UPDATE) self.display_actions(DisplayActions.UPDATE)
@ -138,12 +161,61 @@ class Game:
# Wait for the direction of the friendly entity # Wait for the direction of the friendly entity
self.waiting_for_friendly_key = True self.waiting_for_friendly_key = True
elif key == KeyValues.WAIT: elif key == KeyValues.WAIT:
self.map.tick() self.map.tick(self.player)
elif key == KeyValues.LADDER:
self.handle_ladder()
def handle_ladder(self) -> None:
"""
The player pressed the ladder key to switch map
"""
# On a ladder, we switch level
y, x = self.player.y, self.player.x
if not self.map.tiles[y][x].is_ladder():
return
# We move up on the ladder of the beginning,
# down at the end of the stage
move_down = y != self.map.start_y and x != self.map.start_x
old_map = self.map
self.map_index += 1 if move_down else -1
if self.map_index == -1:
self.map_index = 0
return
while self.map_index >= len(self.maps):
# TODO: generate a new map
self.maps.append(Map.load(ResourceManager.get_asset_path(
"example_map_2.txt")))
new_map = self.map
new_map.floor = self.map_index
old_map.remove_entity(self.player)
new_map.add_entity(self.player)
if move_down:
self.player.move(self.map.start_y, self.map.start_x)
self.logs.add_message(
_("The player climbs down to the floor {floor}.")
.format(floor=-self.map_index))
else:
# Find the ladder of the end of the game
ladder_y, ladder_x = -1, -1
for y in range(self.map.height):
for x in range(self.map.width):
if (y, x) != (self.map.start_y, self.map.start_x) \
and self.map.tiles[y][x].is_ladder():
ladder_y, ladder_x = y, x
break
self.player.move(ladder_y, ladder_x)
self.logs.add_message(
_("The player climbs up the floor {floor}.")
.format(floor=-self.map_index))
self.display_actions(DisplayActions.UPDATE)
def handle_friendly_entity_chat(self, key: KeyValues) -> None: def handle_friendly_entity_chat(self, key: KeyValues) -> None:
""" """
If the player is talking to a friendly entity, we get the direction If the player tries to talk to a friendly entity, the game waits for
where the entity is, then we interact with it. a directional key to be pressed, verifies there is a friendly entity
in that direction and then lets the player interact with it.
""" """
if not self.waiting_for_friendly_key: if not self.waiting_for_friendly_key:
return return
@ -232,7 +304,7 @@ class Game:
def handle_key_pressed_main_menu(self, key: KeyValues) -> None: def handle_key_pressed_main_menu(self, key: KeyValues) -> None:
""" """
In the main menu, we can navigate through options. In the main menu, we can navigate through different options.
""" """
if key == KeyValues.DOWN: if key == KeyValues.DOWN:
self.main_menu.go_down() self.main_menu.go_down()
@ -257,13 +329,13 @@ class Game:
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the game to a dictionary Saves the game to a dictionary.
""" """
return self.map.save_state() return self.map.save_state()
def load_state(self, d: dict) -> None: def load_state(self, d: dict) -> None:
""" """
Loads the game from a dictionary Loads the game from a dictionary.
""" """
try: try:
self.map.load_state(d) self.map.load_state(d)
@ -287,7 +359,7 @@ class Game:
def load_game(self) -> None: def load_game(self) -> None:
""" """
Loads the game from a file Loads the game from a file.
""" """
file_path = ResourceManager.get_config_path("save.json") file_path = ResourceManager.get_config_path("save.json")
if os.path.isfile(file_path): if os.path.isfile(file_path):
@ -304,7 +376,7 @@ class Game:
def save_game(self) -> None: def save_game(self) -> None:
""" """
Saves the game to a file Saves the game to a file.
""" """
with open(ResourceManager.get_config_path("save.json"), "w") as f: with open(ResourceManager.get_config_path("save.json"), "w") as f:
f.write(json.dumps(self.save_state())) f.write(json.dumps(self.save_state()))

370
squirrelbattle/interfaces.py
View File

@ -2,9 +2,11 @@
# SPDX-License-Identifier: GPL-3.0-or-later # SPDX-License-Identifier: GPL-3.0-or-later
from enum import Enum, auto from enum import Enum, auto
from math import sqrt from math import ceil, sqrt
from random import choice, randint, choices from random import choice, choices, randint
from typing import List, Optional, Any from typing import List, Optional, Any, Dict, Tuple
from queue import PriorityQueue
from functools import reduce
from .display.texturepack import TexturePack from .display.texturepack import TexturePack
from .translations import gettext as _ from .translations import gettext as _
@ -12,7 +14,7 @@ from .translations import gettext as _
class Logs: class Logs:
""" """
The logs object stores the messages to display. It is encapsulating a list 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 of such messages, to allow multiple pointers to keep track of it even if
the list was to be reassigned. the list was to be reassigned.
""" """
@ -30,16 +32,47 @@ class Logs:
self.messages = [] 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: class Map:
""" """
Object that represents a Map with its width, height The Map object represents a with its width, height
and tiles, that have their custom properties. and tiles, that have their custom properties.
""" """
floor: int
width: int width: int
height: int height: int
start_y: int start_y: int
start_x: int start_x: int
tiles: List[List["Tile"]] tiles: List[List["Tile"]]
visibility: List[List[bool]]
seen_tiles: List[List[bool]]
entities: List["Entity"] entities: List["Entity"]
logs: Logs logs: Logs
# coordinates of the point that should be # coordinates of the point that should be
@ -49,24 +82,32 @@ class Map:
def __init__(self, width: int, height: int, tiles: list, def __init__(self, width: int, height: int, tiles: list,
start_y: int, start_x: int): start_y: int, start_x: int):
self.floor = 0
self.width = width self.width = width
self.height = height self.height = height
self.start_y = start_y self.start_y = start_y
self.start_x = start_x self.start_x = start_x
self.tiles = tiles self.tiles = tiles
self.visibility = [[False for _ in range(len(tiles[0]))]
for _ in range(len(tiles))]
self.seen_tiles = [[False for _ in range(len(tiles[0]))]
for _ in range(len(tiles))]
self.entities = [] self.entities = []
self.logs = Logs() self.logs = Logs()
def add_entity(self, entity: "Entity") -> None: def add_entity(self, entity: "Entity") -> None:
""" """
Register a new entity in the map. Registers a new entity in the map.
""" """
self.entities.append(entity) if entity.is_familiar():
self.entities.insert(1, entity)
else:
self.entities.append(entity)
entity.map = self entity.map = self
def remove_entity(self, entity: "Entity") -> None: def remove_entity(self, entity: "Entity") -> None:
""" """
Unregister an entity from the map. Unregisters an entity from the map.
""" """
if entity in self.entities: if entity in self.entities:
self.entities.remove(entity) self.entities.remove(entity)
@ -86,7 +127,7 @@ class Map:
def entity_is_present(self, y: int, x: int) -> bool: def entity_is_present(self, y: int, x: int) -> bool:
""" """
Indicates that the tile at the coordinates (y, x) contains a killable Indicates that the tile at the coordinates (y, x) contains a killable
entity entity.
""" """
return 0 <= y < self.height and 0 <= x < self.width and \ return 0 <= y < self.height and 0 <= x < self.width and \
any(entity.x == x and entity.y == y and entity.is_friendly() any(entity.x == x and entity.y == y and entity.is_friendly()
@ -95,7 +136,8 @@ class Map:
@staticmethod @staticmethod
def load(filename: str) -> "Map": def load(filename: str) -> "Map":
""" """
Read a file that contains the content of a map, and build a Map object. Reads a file that contains the content of a map,
and builds a Map object.
""" """
with open(filename, "r") as f: with open(filename, "r") as f:
file = f.read() file = f.read()
@ -104,7 +146,7 @@ class Map:
@staticmethod @staticmethod
def load_from_string(content: str) -> "Map": def load_from_string(content: str) -> "Map":
""" """
Load a map represented by its characters and build a Map object. Loads a map represented by its characters and builds a Map object.
""" """
lines = content.split("\n") lines = content.split("\n")
first_line = lines[0] first_line = lines[0]
@ -120,7 +162,7 @@ class Map:
@staticmethod @staticmethod
def load_dungeon_from_string(content: str) -> List[List["Tile"]]: def load_dungeon_from_string(content: str) -> List[List["Tile"]]:
""" """
Transforms a string into the list of corresponding tiles Transforms a string into the list of corresponding tiles.
""" """
lines = content.split("\n") lines = content.split("\n")
tiles = [[Tile.from_ascii_char(c) tiles = [[Tile.from_ascii_char(c)
@ -129,7 +171,7 @@ class Map:
def draw_string(self, pack: TexturePack) -> str: def draw_string(self, pack: TexturePack) -> str:
""" """
Draw the current map as a string object that can be rendered Draws the current map as a string object that can be rendered
in the window. in the window.
""" """
return "\n".join("".join(tile.char(pack) for tile in line) return "\n".join("".join(tile.char(pack) for tile in line)
@ -137,9 +179,9 @@ class Map:
def spawn_random_entities(self, count: int) -> None: def spawn_random_entities(self, count: int) -> None:
""" """
Put randomly {count} entities on the map, where it is available. Puts randomly {count} entities on the map, only on empty ground tiles.
""" """
for ignored in range(count): for _ignored in range(count):
y, x = 0, 0 y, x = 0, 0
while True: while True:
y, x = randint(0, self.height - 1), randint(0, self.width - 1) y, x = randint(0, self.height - 1), randint(0, self.width - 1)
@ -151,16 +193,139 @@ class Map:
entity.move(y, x) entity.move(y, x)
self.add_entity(entity) self.add_entity(entity)
def tick(self) -> None: def compute_visibility(self, y: int, x: int, max_range: int) -> None:
""" """
Trigger all entity events. 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):
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
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))
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 * 4 - 1, x * 4 + 1))
and (y != bottom_y
or bottom < Slope(y * 4 + 1, x * 4 - 1)))
# 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
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))
elif y == bottom_y: # pragma: no cover
return
elif not is_opaque and was_opaque == 1:
nx, ny = x * 2, y * 2 + 1
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: for entity in self.entities:
entity.act(self) if entity.is_familiar():
entity.act(p, self)
else:
entity.act(self)
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the map's attributes to a dictionary Saves the map's attributes to a dictionary.
""" """
d = dict() d = dict()
d["width"] = self.width d["width"] = self.width
@ -177,7 +342,7 @@ class Map:
def load_state(self, d: dict) -> None: def load_state(self, d: dict) -> None:
""" """
Loads the map's attributes from a dictionary Loads the map's attributes from a dictionary.
""" """
self.width = d["width"] self.width = d["width"]
self.height = d["height"] self.height = d["height"]
@ -194,16 +359,17 @@ class Map:
class Tile(Enum): class Tile(Enum):
""" """
The internal representation of the tiles of the map The internal representation of the tiles of the map.
""" """
EMPTY = auto() EMPTY = auto()
WALL = auto() WALL = auto()
FLOOR = auto() FLOOR = auto()
LADDER = auto()
@staticmethod @staticmethod
def from_ascii_char(ch: str) -> "Tile": def from_ascii_char(ch: str) -> "Tile":
""" """
Maps an ascii character to its equivalent in the texture pack Maps an ascii character to its equivalent in the texture pack.
""" """
for tile in Tile: for tile in Tile:
if tile.char(TexturePack.ASCII_PACK) == ch: if tile.char(TexturePack.ASCII_PACK) == ch:
@ -213,9 +379,27 @@ class Tile(Enum):
def char(self, pack: TexturePack) -> str: def char(self, pack: TexturePack) -> str:
""" """
Translates a Tile to the corresponding character according Translates a Tile to the corresponding character according
to the texture pack to the texture pack.
""" """
return getattr(pack, self.name) val = getattr(pack, self.name)
return val[0] if isinstance(val, tuple) else val
def visible_color(self, pack: TexturePack) -> Tuple[int, int]:
"""
Retrieve the tuple (fg_color, bg_color) of the current Tile
if it is visible.
"""
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]:
"""
Retrieve the tuple (fg_color, bg_color) of the current Tile.
"""
val = getattr(pack, self.name)
return (val[1], val[3]) if isinstance(val, tuple) else \
(pack.tile_fg_color, pack.tile_bg_color)
def is_wall(self) -> bool: def is_wall(self) -> bool:
""" """
@ -223,21 +407,28 @@ class Tile(Enum):
""" """
return self == Tile.WALL return self == Tile.WALL
def is_ladder(self) -> bool:
"""
Is this Tile a ladder?
"""
return self == Tile.LADDER
def can_walk(self) -> bool: def can_walk(self) -> bool:
""" """
Check if an entity (player or not) can move in this tile. Checks if an entity (player or not) can move in this tile.
""" """
return not self.is_wall() and self != Tile.EMPTY return not self.is_wall() and self != Tile.EMPTY
class Entity: class Entity:
""" """
An Entity object represents any entity present on the map An Entity object represents any entity present on the map.
""" """
y: int y: int
x: int x: int
name: str name: str
map: Map map: Map
paths: Dict[Tuple[int, int], Tuple[int, int]]
# noinspection PyShadowingBuiltins # noinspection PyShadowingBuiltins
def __init__(self, y: int = 0, x: int = 0, name: Optional[str] = None, def __init__(self, y: int = 0, x: int = 0, name: Optional[str] = None,
@ -246,11 +437,12 @@ class Entity:
self.x = x self.x = x
self.name = name self.name = name
self.map = map self.map = map
self.paths = None
def check_move(self, y: int, x: int, move_if_possible: bool = False)\ def check_move(self, y: int, x: int, move_if_possible: bool = False)\
-> bool: -> bool:
""" """
Checks if moving to (y,x) is authorized Checks if moving to (y,x) is authorized.
""" """
free = self.map.is_free(y, x) free = self.map.is_free(y, x)
if free and move_if_possible: if free and move_if_possible:
@ -259,7 +451,7 @@ class Entity:
def move(self, y: int, x: int) -> bool: def move(self, y: int, x: int) -> bool:
""" """
Moves an entity to (y,x) coordinates Moves an entity to (y,x) coordinates.
""" """
self.y = y self.y = y
self.x = x self.x = x
@ -267,49 +459,100 @@ class Entity:
def move_up(self, force: bool = False) -> bool: def move_up(self, force: bool = False) -> bool:
""" """
Moves the entity up one tile, if possible Moves the entity up one tile, if possible.
""" """
return self.move(self.y - 1, self.x) if force else \ return self.move(self.y - 1, self.x) if force else \
self.check_move(self.y - 1, self.x, True) self.check_move(self.y - 1, self.x, True)
def move_down(self, force: bool = False) -> bool: def move_down(self, force: bool = False) -> bool:
""" """
Moves the entity down one tile, if possible Moves the entity down one tile, if possible.
""" """
return self.move(self.y + 1, self.x) if force else \ return self.move(self.y + 1, self.x) if force else \
self.check_move(self.y + 1, self.x, True) self.check_move(self.y + 1, self.x, True)
def move_left(self, force: bool = False) -> bool: def move_left(self, force: bool = False) -> bool:
""" """
Moves the entity left one tile, if possible Moves the entity left one tile, if possible.
""" """
return self.move(self.y, self.x - 1) if force else \ return self.move(self.y, self.x - 1) if force else \
self.check_move(self.y, self.x - 1, True) self.check_move(self.y, self.x - 1, True)
def move_right(self, force: bool = False) -> bool: def move_right(self, force: bool = False) -> bool:
""" """
Moves the entity right one tile, if possible Moves the entity right one tile, if possible.
""" """
return self.move(self.y, self.x + 1) if force else \ return self.move(self.y, self.x + 1) if force else \
self.check_move(self.y, self.x + 1, True) 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.
"""
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]])]
def act(self, m: Map) -> None: def act(self, m: Map) -> None:
""" """
Define the action of the entity that is ran each tick. Defines the action the entity will do at each tick.
By default, does nothing. By default, does nothing.
""" """
pass pass
def distance_squared(self, other: "Entity") -> int: def distance_squared(self, other: "Entity") -> int:
""" """
Get the square of the distance to another entity. Gives the square of the distance to another entity.
Useful to check distances since square root takes time. Useful to check distances since taking the square root takes time.
""" """
return (self.y - other.y) ** 2 + (self.x - other.x) ** 2 return (self.y - other.y) ** 2 + (self.x - other.x) ** 2
def distance(self, other: "Entity") -> float: def distance(self, other: "Entity") -> float:
""" """
Get the cartesian distance to another entity. Gives the cartesian distance to another entity.
""" """
return sqrt(self.distance_squared(other)) return sqrt(self.distance_squared(other))
@ -332,6 +575,13 @@ class Entity:
""" """
return isinstance(self, FriendlyEntity) 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: def is_merchant(self) -> bool:
""" """
Is this entity a merchant? Is this entity a merchant?
@ -341,12 +591,15 @@ class Entity:
@property @property
def translated_name(self) -> str: def translated_name(self) -> str:
"""
Translates the name of entities.
"""
return _(self.name.replace("_", " ")) return _(self.name.replace("_", " "))
@staticmethod @staticmethod
def get_all_entity_classes() -> list: def get_all_entity_classes() -> list:
""" """
Returns all entities subclasses Returns all entities subclasses.
""" """
from squirrelbattle.entities.items import BodySnatchPotion, Bomb, Heart from squirrelbattle.entities.items import BodySnatchPotion, Bomb, Heart
from squirrelbattle.entities.monsters import Tiger, Hedgehog, \ from squirrelbattle.entities.monsters import Tiger, Hedgehog, \
@ -367,12 +620,13 @@ class Entity:
@staticmethod @staticmethod
def get_all_entity_classes_in_a_dict() -> dict: def get_all_entity_classes_in_a_dict() -> dict:
""" """
Returns all entities subclasses in a dictionary Returns all entities subclasses in a dictionary.
""" """
from squirrelbattle.entities.player import Player from squirrelbattle.entities.player import Player
from squirrelbattle.entities.monsters import Tiger, Hedgehog, Rabbit, \ from squirrelbattle.entities.monsters import Tiger, Hedgehog, Rabbit, \
TeddyBear, GiantSeaEagle TeddyBear, GiantSeaEagle
from squirrelbattle.entities.friendly import Merchant, Sunflower from squirrelbattle.entities.friendly import Merchant, Sunflower, \
Trumpet
from squirrelbattle.entities.items import BodySnatchPotion, Bomb, \ from squirrelbattle.entities.items import BodySnatchPotion, Bomb, \
Heart, Sword, Shield, Chestplate, Helmet, RingCritical, RingXP Heart, Sword, Shield, Chestplate, Helmet, RingCritical, RingXP
return { return {
@ -387,6 +641,7 @@ class Entity:
"Merchant": Merchant, "Merchant": Merchant,
"Sunflower": Sunflower, "Sunflower": Sunflower,
"Sword": Sword, "Sword": Sword,
"Trumpet": Trumpet,
"Eagle": GiantSeaEagle, "Eagle": GiantSeaEagle,
"Shield": Shield, "Shield": Shield,
"Chestplate": Chestplate, "Chestplate": Chestplate,
@ -397,7 +652,7 @@ class Entity:
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the coordinates of the entity Saves the coordinates of the entity.
""" """
d = dict() d = dict()
d["x"] = self.x d["x"] = self.x
@ -409,7 +664,7 @@ class Entity:
class FightingEntity(Entity): class FightingEntity(Entity):
""" """
A FightingEntity is an entity that can fight, and thus has a health, A FightingEntity is an entity that can fight, and thus has a health,
level and stats level and stats.
""" """
maxhealth: int maxhealth: int
health: int health: int
@ -438,11 +693,15 @@ class FightingEntity(Entity):
@property @property
def dead(self) -> bool: def dead(self) -> bool:
"""
Is this entity dead ?
"""
return self.health <= 0 return self.health <= 0
def hit(self, opponent: "FightingEntity") -> str: def hit(self, opponent: "FightingEntity") -> str:
""" """
Deals damage to the opponent, based on the stats The entity deals damage to the opponent
based on their respective stats.
""" """
diceroll = randint(1, 100) diceroll = randint(1, 100)
damage = self.strength damage = self.strength
@ -457,7 +716,8 @@ class FightingEntity(Entity):
def take_damage(self, attacker: "Entity", amount: int) -> str: def take_damage(self, attacker: "Entity", amount: int) -> str:
""" """
Take damage from the attacker, based on the stats The entity takes damage from the attacker
based on their respective stats.
""" """
damage = max(0, amount - self.constitution) damage = max(0, amount - self.constitution)
self.health -= damage self.health -= damage
@ -471,20 +731,20 @@ class FightingEntity(Entity):
def die(self) -> None: def die(self) -> None:
""" """
If a fighting entity has no more health, it dies and is removed If a fighting entity has no more health, it dies and is removed.
""" """
self.map.remove_entity(self) self.map.remove_entity(self)
def keys(self) -> list: def keys(self) -> list:
""" """
Returns a fighting entity's specific attributes Returns a fighting entity's specific attributes.
""" """
return ["name", "maxhealth", "health", "level", "strength", return ["name", "maxhealth", "health", "level", "strength",
"intelligence", "charisma", "dexterity", "constitution"] "intelligence", "charisma", "dexterity", "constitution"]
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
Saves the state of the entity into a dictionary Saves the state of the entity into a dictionary.
""" """
d = super().save_state() d = super().save_state()
for name in self.keys(): for name in self.keys():
@ -494,7 +754,7 @@ class FightingEntity(Entity):
class FriendlyEntity(FightingEntity): class FriendlyEntity(FightingEntity):
""" """
Friendly entities are living entities which do not attack the player Friendly entities are living entities which do not attack the player.
""" """
dialogue_option: list dialogue_option: list
@ -505,7 +765,7 @@ class FriendlyEntity(FightingEntity):
def keys(self) -> list: def keys(self) -> list:
""" """
Returns a friendly entity's specific attributes Returns a friendly entity's specific attributes.
""" """
return ["maxhealth", "health"] return ["maxhealth", "health"]
@ -516,7 +776,7 @@ class InventoryHolder(Entity):
def translate_inventory(self, inventory: list) -> list: def translate_inventory(self, inventory: list) -> list:
""" """
Translate the JSON-state of the inventory into a list of the items in Translates the JSON save of the inventory into a list of the items in
the inventory. the inventory.
""" """
for i in range(len(inventory)): for i in range(len(inventory)):
@ -526,7 +786,7 @@ class InventoryHolder(Entity):
def dict_to_item(self, item_dict: dict) -> Entity: def dict_to_item(self, item_dict: dict) -> Entity:
""" """
Translate a dict object that contains the state of an item Translates a dictionnary that contains the state of an item
into an item object. into an item object.
""" """
entity_classes = self.get_all_entity_classes_in_a_dict() entity_classes = self.get_all_entity_classes_in_a_dict()
@ -536,7 +796,7 @@ class InventoryHolder(Entity):
def save_state(self) -> dict: def save_state(self) -> dict:
""" """
We save the inventory of the merchant formatted as JSON The inventory of the merchant is saved in a JSON format.
""" """
d = super().save_state() d = super().save_state()
d["hazel"] = self.hazel d["hazel"] = self.hazel
@ -545,21 +805,21 @@ class InventoryHolder(Entity):
def add_to_inventory(self, obj: Any) -> None: def add_to_inventory(self, obj: Any) -> None:
""" """
Adds an object to inventory Adds an object to the inventory.
""" """
if obj not in self.inventory: if obj not in self.inventory:
self.inventory.append(obj) self.inventory.append(obj)
def remove_from_inventory(self, obj: Any) -> None: def remove_from_inventory(self, obj: Any) -> None:
""" """
Removes an object from the inventory Removes an object from the inventory.
""" """
if obj in self.inventory: if obj in self.inventory:
self.inventory.remove(obj) self.inventory.remove(obj)
def change_hazel_balance(self, hz: int) -> None: def change_hazel_balance(self, hz: int) -> None:
""" """
Change the number of hazel the entity has by hz. hz is negative Changes the number of hazel the entity has by hz. hz is negative
when the player loses money and positive when he gains money when the entity loses money and positive when it gains money.
""" """
self.hazel += hz self.hazel += hz

58
squirrelbattle/locale/de/LC_MESSAGES/squirrelbattle.po
View File

@ -83,11 +83,21 @@ msgstr "Die Bombe explodiert."
msgid "{player} exchanged its body with {entity}." msgid "{player} exchanged its body with {entity}."
msgstr "{player} täuscht seinem Körper mit {entity} aus." msgstr "{player} täuscht seinem Körper mit {entity} aus."
#: squirrelbattle/game.py:228 squirrelbattle/tests/game_test.py:595 #: squirrelbattle/game.py:182
#, python-brace-format
msgid "The player climbs down to the floor {floor}."
msgstr "Der Spieler klettert auf dem Stock {floor} hinunter."
#: squirrelbattle/game.py:195
#, python-brace-format
msgid "The player climbs up the floor {floor}."
msgstr "Der Spieler klettert auf dem Stock {floor} hinoben."
#: squirrelbattle/game.py:285 squirrelbattle/tests/game_test.py:592
msgid "The buyer does not have enough money" msgid "The buyer does not have enough money"
msgstr "Der Kaufer hat nicht genug Geld" msgstr "Der Kaufer hat nicht genug Geld"
#: squirrelbattle/game.py:271 #: squirrelbattle/game.py:328
msgid "" msgid ""
"Some keys are missing in your save file.\n" "Some keys are missing in your save file.\n"
"Your save seems to be corrupt. It got deleted." "Your save seems to be corrupt. It got deleted."
@ -95,7 +105,7 @@ msgstr ""
"In Ihrer Speicherdatei fehlen einige Schlüssel.\n" "In Ihrer Speicherdatei fehlen einige Schlüssel.\n"
"Ihre Speicherung scheint korrupt zu sein. Es wird gelöscht." "Ihre Speicherung scheint korrupt zu sein. Es wird gelöscht."
#: squirrelbattle/game.py:279 #: squirrelbattle/game.py:336
msgid "" msgid ""
"No player was found on this map!\n" "No player was found on this map!\n"
"Maybe you died?" "Maybe you died?"
@ -103,7 +113,7 @@ msgstr ""
"Auf dieser Karte wurde kein Spieler gefunden!\n" "Auf dieser Karte wurde kein Spieler gefunden!\n"
"Vielleicht sind Sie gestorben?" "Vielleicht sind Sie gestorben?"
#: squirrelbattle/game.py:299 #: squirrelbattle/game.py:356
msgid "" msgid ""
"The JSON file is not correct.\n" "The JSON file is not correct.\n"
"Your save seems corrupted. It got deleted." "Your save seems corrupted. It got deleted."
@ -120,17 +130,17 @@ msgstr ""
msgid "{name} hits {opponent}." msgid "{name} hits {opponent}."
msgstr "{name} schlägt {opponent}." msgstr "{name} schlägt {opponent}."
#: squirrelbattle/interfaces.py:466 #: squirrelbattle/interfaces.py:465
#, python-brace-format #, python-brace-format
msgid "{name} takes {damage} damage." msgid "{name} takes {damage} damage."
msgstr "" msgstr ""
#: squirrelbattle/interfaces.py:468 #: squirrelbattle/interfaces.py:467
#, python-brace-format #, python-brace-format
msgid "{name} dies." msgid "{name} dies."
msgstr "{name} stirbt." msgstr "{name} stirbt."
#: squirrelbattle/interfaces.py:502 #: squirrelbattle/interfaces.py:501
#, python-brace-format #, python-brace-format
msgid "{entity} said: {message}" msgid "{entity} said: {message}"
msgstr "{entity} hat gesagt: {message}" msgstr "{entity} hat gesagt: {message}"
@ -139,8 +149,8 @@ msgstr "{entity} hat gesagt: {message}"
msgid "Back" msgid "Back"
msgstr "Zurück" msgstr "Zurück"
#: squirrelbattle/tests/game_test.py:361 squirrelbattle/tests/game_test.py:364 #: squirrelbattle/tests/game_test.py:358 squirrelbattle/tests/game_test.py:361
#: squirrelbattle/tests/game_test.py:367 squirrelbattle/tests/game_test.py:370 #: squirrelbattle/tests/game_test.py:364 squirrelbattle/tests/game_test.py:367
#: squirrelbattle/tests/translations_test.py:16 #: squirrelbattle/tests/translations_test.py:16
msgid "New game" msgid "New game"
msgstr "Neu Spiel" msgstr "Neu Spiel"
@ -226,53 +236,61 @@ msgid "Key used to wait"
msgstr "Wartentaste" msgstr "Wartentaste"
#: squirrelbattle/tests/translations_test.py:56 #: squirrelbattle/tests/translations_test.py:56
msgid "Key used to use ladders"
msgstr "Leitertaste"
#: squirrelbattle/tests/translations_test.py:58
msgid "Texture pack" msgid "Texture pack"
msgstr "Textur-Packung" msgstr "Textur-Packung"
#: squirrelbattle/tests/translations_test.py:57 #: squirrelbattle/tests/translations_test.py:59
msgid "Language" msgid "Language"
msgstr "Sprache" msgstr "Sprache"
#: squirrelbattle/tests/translations_test.py:62 #: squirrelbattle/tests/translations_test.py:62
msgid "player"
msgstr "Spieler"
#: squirrelbattle/tests/translations_test.py:64
msgid "hedgehog" msgid "hedgehog"
msgstr "Igel" msgstr "Igel"
#: squirrelbattle/tests/translations_test.py:63 #: squirrelbattle/tests/translations_test.py:65
msgid "merchant" msgid "merchant"
msgstr "Kaufmann" msgstr "Kaufmann"
#: squirrelbattle/tests/translations_test.py:64 #: squirrelbattle/tests/translations_test.py:66
msgid "rabbit" msgid "rabbit"
msgstr "Kanninchen" msgstr "Kanninchen"
#: squirrelbattle/tests/translations_test.py:65 #: squirrelbattle/tests/translations_test.py:67
msgid "sunflower" msgid "sunflower"
msgstr "Sonnenblume" msgstr "Sonnenblume"
#: squirrelbattle/tests/translations_test.py:66 #: squirrelbattle/tests/translations_test.py:68
msgid "teddy bear" msgid "teddy bear"
msgstr "Teddybär" msgstr "Teddybär"
#: squirrelbattle/tests/translations_test.py:67 #: squirrelbattle/tests/translations_test.py:69
msgid "tiger" msgid "tiger"
msgstr "Tiger" msgstr "Tiger"
#: squirrelbattle/tests/translations_test.py:69 #: squirrelbattle/tests/translations_test.py:71
msgid "body snatch potion" msgid "body snatch potion"
msgstr "Leichenfleddererzaubertrank" msgstr "Leichenfleddererzaubertrank"
#: squirrelbattle/tests/translations_test.py:70 #: squirrelbattle/tests/translations_test.py:72
msgid "bomb" msgid "bomb"
msgstr "Bombe" msgstr "Bombe"
#: squirrelbattle/tests/translations_test.py:71 #: squirrelbattle/tests/translations_test.py:73
msgid "explosion" msgid "explosion"
msgstr "Explosion" msgstr "Explosion"
#: squirrelbattle/tests/translations_test.py:72 #: squirrelbattle/tests/translations_test.py:74
msgid "heart" msgid "heart"
msgstr "Herz" msgstr "Herz"
#: squirrelbattle/tests/translations_test.py:73 #: squirrelbattle/tests/translations_test.py:75
msgid "sword" msgid "sword"
msgstr "schwert" msgstr "schwert"

60
squirrelbattle/locale/es/LC_MESSAGES/squirrelbattle.po
View File

@ -8,7 +8,7 @@ msgid ""
msgstr "" msgstr ""
"Project-Id-Version: squirrelbattle 3.14.1\n" "Project-Id-Version: squirrelbattle 3.14.1\n"
"Report-Msgid-Bugs-To: squirrel-battle@crans.org\n" "Report-Msgid-Bugs-To: squirrel-battle@crans.org\n"
"POT-Creation-Date: 2021-01-08 01:57+0100\n" "POT-Creation-Date: 2021-01-06 15:19+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n" "Language-Team: LANGUAGE <LL@li.org>\n"
@ -82,11 +82,21 @@ msgstr "La bomba está explotando."
msgid "{player} exchanged its body with {entity}." msgid "{player} exchanged its body with {entity}."
msgstr "{player} intercambió su cuerpo con {entity}." msgstr "{player} intercambió su cuerpo con {entity}."
#: squirrelbattle/game.py:228 squirrelbattle/tests/game_test.py:595 #: squirrelbattle/game.py:182
#, python-brace-format
msgid "The player climbs down to the floor {floor}."
msgstr ""
#: squirrelbattle/game.py:195
#, python-brace-format
msgid "The player climbs up the floor {floor}."
msgstr ""
#: squirrelbattle/game.py:285 squirrelbattle/tests/game_test.py:592
msgid "The buyer does not have enough money" msgid "The buyer does not have enough money"
msgstr "El comprador no tiene suficiente dinero" msgstr "El comprador no tiene suficiente dinero"
#: squirrelbattle/game.py:271 #: squirrelbattle/game.py:328
msgid "" msgid ""
"Some keys are missing in your save file.\n" "Some keys are missing in your save file.\n"
"Your save seems to be corrupt. It got deleted." "Your save seems to be corrupt. It got deleted."
@ -94,7 +104,7 @@ msgstr ""
"Algunas claves faltan en su archivo de guarda.\n" "Algunas claves faltan en su archivo de guarda.\n"
"Su guarda parece a ser corruptido. Fue eliminado." "Su guarda parece a ser corruptido. Fue eliminado."
#: squirrelbattle/game.py:279 #: squirrelbattle/game.py:336
msgid "" msgid ""
"No player was found on this map!\n" "No player was found on this map!\n"
"Maybe you died?" "Maybe you died?"
@ -102,7 +112,7 @@ msgstr ""
"No jugador encontrado sobre la carta !\n" "No jugador encontrado sobre la carta !\n"
"¿ Quizas murió ?" "¿ Quizas murió ?"
#: squirrelbattle/game.py:299 #: squirrelbattle/game.py:356
msgid "" msgid ""
"The JSON file is not correct.\n" "The JSON file is not correct.\n"
"Your save seems corrupted. It got deleted." "Your save seems corrupted. It got deleted."
@ -119,17 +129,17 @@ msgstr ""
msgid "{name} hits {opponent}." msgid "{name} hits {opponent}."
msgstr "{name} golpea a {opponent}." msgstr "{name} golpea a {opponent}."
#: squirrelbattle/interfaces.py:466 #: squirrelbattle/interfaces.py:465
#, python-brace-format #, python-brace-format
msgid "{name} takes {damage} damage." msgid "{name} takes {damage} damage."
msgstr "" msgstr ""
#: squirrelbattle/interfaces.py:468 #: squirrelbattle/interfaces.py:467
#, python-brace-format #, python-brace-format
msgid "{name} dies." msgid "{name} dies."
msgstr "{name} se muere." msgstr "{name} se muere."
#: squirrelbattle/interfaces.py:502 #: squirrelbattle/interfaces.py:501
#, python-brace-format #, python-brace-format
msgid "{entity} said: {message}" msgid "{entity} said: {message}"
msgstr "{entity} dijo : {message}" msgstr "{entity} dijo : {message}"
@ -138,8 +148,8 @@ msgstr "{entity} dijo : {message}"
msgid "Back" msgid "Back"
msgstr "Volver" msgstr "Volver"
#: squirrelbattle/tests/game_test.py:361 squirrelbattle/tests/game_test.py:364 #: squirrelbattle/tests/game_test.py:358 squirrelbattle/tests/game_test.py:361
#: squirrelbattle/tests/game_test.py:367 squirrelbattle/tests/game_test.py:370 #: squirrelbattle/tests/game_test.py:364 squirrelbattle/tests/game_test.py:367
#: squirrelbattle/tests/translations_test.py:16 #: squirrelbattle/tests/translations_test.py:16
msgid "New game" msgid "New game"
msgstr "Nuevo partido" msgstr "Nuevo partido"
@ -225,53 +235,61 @@ msgid "Key used to wait"
msgstr "Tecla para espera" msgstr "Tecla para espera"
#: squirrelbattle/tests/translations_test.py:56 #: squirrelbattle/tests/translations_test.py:56
msgid "Key used to use ladders"
msgstr "Tecla para el uso de las escaleras"
#: squirrelbattle/tests/translations_test.py:58
msgid "Texture pack" msgid "Texture pack"
msgstr "Paquete de texturas" msgstr "Paquete de texturas"
#: squirrelbattle/tests/translations_test.py:57 #: squirrelbattle/tests/translations_test.py:59
msgid "Language" msgid "Language"
msgstr "Languaje" msgstr "Languaje"
#: squirrelbattle/tests/translations_test.py:62 #: squirrelbattle/tests/translations_test.py:62
msgid "player"
msgstr "jugador"
#: squirrelbattle/tests/translations_test.py:64
msgid "hedgehog" msgid "hedgehog"
msgstr "erizo" msgstr "erizo"
#: squirrelbattle/tests/translations_test.py:63 #: squirrelbattle/tests/translations_test.py:65
msgid "merchant" msgid "merchant"
msgstr "comerciante" msgstr "comerciante"
#: squirrelbattle/tests/translations_test.py:64 #: squirrelbattle/tests/translations_test.py:66
msgid "rabbit" msgid "rabbit"
msgstr "conejo" msgstr "conejo"
#: squirrelbattle/tests/translations_test.py:65 #: squirrelbattle/tests/translations_test.py:67
msgid "sunflower" msgid "sunflower"
msgstr "girasol" msgstr "girasol"
#: squirrelbattle/tests/translations_test.py:66 #: squirrelbattle/tests/translations_test.py:68
msgid "teddy bear" msgid "teddy bear"
msgstr "osito de peluche" msgstr "osito de peluche"
#: squirrelbattle/tests/translations_test.py:67 #: squirrelbattle/tests/translations_test.py:69
msgid "tiger" msgid "tiger"
msgstr "tigre" msgstr "tigre"
#: squirrelbattle/tests/translations_test.py:69 #: squirrelbattle/tests/translations_test.py:71
msgid "body snatch potion" msgid "body snatch potion"
msgstr "poción de intercambio" msgstr "poción de intercambio"
#: squirrelbattle/tests/translations_test.py:70 #: squirrelbattle/tests/translations_test.py:72
msgid "bomb" msgid "bomb"
msgstr "bomba" msgstr "bomba"
#: squirrelbattle/tests/translations_test.py:71 #: squirrelbattle/tests/translations_test.py:73
msgid "explosion" msgid "explosion"
msgstr "explosión" msgstr "explosión"
#: squirrelbattle/tests/translations_test.py:72 #: squirrelbattle/tests/translations_test.py:74
msgid "heart" msgid "heart"
msgstr "corazón" msgstr "corazón"
#: squirrelbattle/tests/translations_test.py:73 #: squirrelbattle/tests/translations_test.py:75
msgid "sword" msgid "sword"
msgstr "espada" msgstr "espada"

60
squirrelbattle/locale/fr/LC_MESSAGES/squirrelbattle.po
View File

@ -8,7 +8,7 @@ msgid ""
msgstr "" msgstr ""
"Project-Id-Version: squirrelbattle 3.14.1\n" "Project-Id-Version: squirrelbattle 3.14.1\n"
"Report-Msgid-Bugs-To: squirrel-battle@crans.org\n" "Report-Msgid-Bugs-To: squirrel-battle@crans.org\n"
"POT-Creation-Date: 2021-01-08 01:57+0100\n" "POT-Creation-Date: 2021-01-06 15:19+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n" "Language-Team: LANGUAGE <LL@li.org>\n"
@ -83,11 +83,21 @@ msgstr "La bombe explose."
msgid "{player} exchanged its body with {entity}." msgid "{player} exchanged its body with {entity}."
msgstr "{player} a échangé son corps avec {entity}." msgstr "{player} a échangé son corps avec {entity}."
#: squirrelbattle/game.py:228 squirrelbattle/tests/game_test.py:595 #: squirrelbattle/game.py:182
#, python-brace-format
msgid "The player climbs down to the floor {floor}."
msgstr "Le joueur descend à l'étage {floor}."
#: squirrelbattle/game.py:195
#, python-brace-format
msgid "The player climbs up the floor {floor}."
msgstr "Le joueur monte à l'étage {floor}."
#: squirrelbattle/game.py:285 squirrelbattle/tests/game_test.py:592
msgid "The buyer does not have enough money" msgid "The buyer does not have enough money"
msgstr "L'acheteur n'a pas assez d'argent" msgstr "L'acheteur n'a pas assez d'argent"
#: squirrelbattle/game.py:271 #: squirrelbattle/game.py:328
msgid "" msgid ""
"Some keys are missing in your save file.\n" "Some keys are missing in your save file.\n"
"Your save seems to be corrupt. It got deleted." "Your save seems to be corrupt. It got deleted."
@ -95,7 +105,7 @@ msgstr ""
"Certaines clés de votre ficher de sauvegarde sont manquantes.\n" "Certaines clés de votre ficher de sauvegarde sont manquantes.\n"
"Votre sauvegarde semble corrompue. Elle a été supprimée." "Votre sauvegarde semble corrompue. Elle a été supprimée."
#: squirrelbattle/game.py:279 #: squirrelbattle/game.py:336
msgid "" msgid ""
"No player was found on this map!\n" "No player was found on this map!\n"
"Maybe you died?" "Maybe you died?"
@ -103,7 +113,7 @@ msgstr ""
"Aucun joueur n'a été trouvé sur la carte !\n" "Aucun joueur n'a été trouvé sur la carte !\n"
"Peut-être êtes-vous mort ?" "Peut-être êtes-vous mort ?"
#: squirrelbattle/game.py:299 #: squirrelbattle/game.py:356
msgid "" msgid ""
"The JSON file is not correct.\n" "The JSON file is not correct.\n"
"Your save seems corrupted. It got deleted." "Your save seems corrupted. It got deleted."
@ -120,17 +130,17 @@ msgstr "C'est un coup critique !"
msgid "{name} hits {opponent}." msgid "{name} hits {opponent}."
msgstr "{name} frappe {opponent}." msgstr "{name} frappe {opponent}."
#: squirrelbattle/interfaces.py:466 #: squirrelbattle/interfaces.py:465
#, python-brace-format #, python-brace-format
msgid "{name} takes {damage} damage." msgid "{name} takes {damage} damage."
msgstr "{name} prend {damage} dégâts." msgstr "{name} prend {damage} dégâts."
#: squirrelbattle/interfaces.py:468 #: squirrelbattle/interfaces.py:467
#, python-brace-format #, python-brace-format
msgid "{name} dies." msgid "{name} dies."
msgstr "{name} meurt." msgstr "{name} meurt."
#: squirrelbattle/interfaces.py:502 #: squirrelbattle/interfaces.py:501
#, python-brace-format #, python-brace-format
msgid "{entity} said: {message}" msgid "{entity} said: {message}"
msgstr "{entity} a dit : {message}" msgstr "{entity} a dit : {message}"
@ -139,8 +149,8 @@ msgstr "{entity} a dit : {message}"
msgid "Back" msgid "Back"
msgstr "Retour" msgstr "Retour"
#: squirrelbattle/tests/game_test.py:361 squirrelbattle/tests/game_test.py:364 #: squirrelbattle/tests/game_test.py:358 squirrelbattle/tests/game_test.py:361
#: squirrelbattle/tests/game_test.py:367 squirrelbattle/tests/game_test.py:370 #: squirrelbattle/tests/game_test.py:364 squirrelbattle/tests/game_test.py:367
#: squirrelbattle/tests/translations_test.py:16 #: squirrelbattle/tests/translations_test.py:16
msgid "New game" msgid "New game"
msgstr "Nouvelle partie" msgstr "Nouvelle partie"
@ -226,53 +236,61 @@ msgid "Key used to wait"
msgstr "Touche pour attendre" msgstr "Touche pour attendre"
#: squirrelbattle/tests/translations_test.py:56 #: squirrelbattle/tests/translations_test.py:56
msgid "Key used to use ladders"
msgstr "Touche pour utiliser les échelles"
#: squirrelbattle/tests/translations_test.py:58
msgid "Texture pack" msgid "Texture pack"
msgstr "Pack de textures" msgstr "Pack de textures"
#: squirrelbattle/tests/translations_test.py:57 #: squirrelbattle/tests/translations_test.py:59
msgid "Language" msgid "Language"
msgstr "Langue" msgstr "Langue"
#: squirrelbattle/tests/translations_test.py:62 #: squirrelbattle/tests/translations_test.py:62
msgid "player"
msgstr "joueur"
#: squirrelbattle/tests/translations_test.py:64
msgid "hedgehog" msgid "hedgehog"
msgstr "hérisson" msgstr "hérisson"
#: squirrelbattle/tests/translations_test.py:63 #: squirrelbattle/tests/translations_test.py:65
msgid "merchant" msgid "merchant"
msgstr "marchand" msgstr "marchand"
#: squirrelbattle/tests/translations_test.py:64 #: squirrelbattle/tests/translations_test.py:66
msgid "rabbit" msgid "rabbit"
msgstr "lapin" msgstr "lapin"
#: squirrelbattle/tests/translations_test.py:65 #: squirrelbattle/tests/translations_test.py:67
msgid "sunflower" msgid "sunflower"
msgstr "tournesol" msgstr "tournesol"
#: squirrelbattle/tests/translations_test.py:66 #: squirrelbattle/tests/translations_test.py:68
msgid "teddy bear" msgid "teddy bear"
msgstr "nounours" msgstr "nounours"
#: squirrelbattle/tests/translations_test.py:67 #: squirrelbattle/tests/translations_test.py:69
msgid "tiger" msgid "tiger"
msgstr "tigre" msgstr "tigre"
#: squirrelbattle/tests/translations_test.py:69 #: squirrelbattle/tests/translations_test.py:71
msgid "body snatch potion" msgid "body snatch potion"
msgstr "potion d'arrachage de corps" msgstr "potion d'arrachage de corps"
#: squirrelbattle/tests/translations_test.py:70 #: squirrelbattle/tests/translations_test.py:72
msgid "bomb" msgid "bomb"
msgstr "bombe" msgstr "bombe"
#: squirrelbattle/tests/translations_test.py:71 #: squirrelbattle/tests/translations_test.py:73
msgid "explosion" msgid "explosion"
msgstr "explosion" msgstr "explosion"
#: squirrelbattle/tests/translations_test.py:72 #: squirrelbattle/tests/translations_test.py:74
msgid "heart" msgid "heart"
msgstr "cœur" msgstr "cœur"
#: squirrelbattle/tests/translations_test.py:73 #: squirrelbattle/tests/translations_test.py:75
msgid "sword" msgid "sword"
msgstr "épée" msgstr "épée"

34
squirrelbattle/menus.py
View File

@ -14,7 +14,7 @@ from .translations import gettext as _, Translator
class Menu: class Menu:
""" """
A Menu object is the logical representation of a menu in the game A Menu object is the logical representation of a menu in the game.
""" """
values: list values: list
@ -23,26 +23,26 @@ class Menu:
def go_up(self) -> None: def go_up(self) -> None:
""" """
Moves the pointer of the menu on the previous value Moves the pointer of the menu on the previous value.
""" """
self.position = max(0, self.position - 1) self.position = max(0, self.position - 1)
def go_down(self) -> None: def go_down(self) -> None:
""" """
Moves the pointer of the menu on the next value Moves the pointer of the menu on the next value.
""" """
self.position = min(len(self.values) - 1, self.position + 1) self.position = min(len(self.values) - 1, self.position + 1)
def validate(self) -> Any: def validate(self) -> Any:
""" """
Selects the value that is pointed by the menu pointer Selects the value that is pointed by the menu pointer.
""" """
return self.values[self.position] return self.values[self.position]
class MainMenuValues(Enum): class MainMenuValues(Enum):
""" """
Values of the main menu Values of the main menu.
""" """
START = "New game" START = "New game"
RESUME = "Resume" RESUME = "Resume"
@ -57,14 +57,14 @@ class MainMenuValues(Enum):
class MainMenu(Menu): class MainMenu(Menu):
""" """
A special instance of a menu : the main menu A special instance of a menu : the main menu.
""" """
values = [e for e in MainMenuValues] values = [e for e in MainMenuValues]
class SettingsMenu(Menu): class SettingsMenu(Menu):
""" """
A special instance of a menu : the settings menu A special instance of a menu : the settings menu.
""" """
waiting_for_key: bool = False waiting_for_key: bool = False
@ -75,7 +75,7 @@ class SettingsMenu(Menu):
def handle_key_pressed(self, key: Optional[KeyValues], raw_key: str, def handle_key_pressed(self, key: Optional[KeyValues], raw_key: str,
game: Any) -> None: game: Any) -> None:
""" """
In the setting menu, we van select a setting and change it In the setting menu, we can select a setting and change it.
""" """
if not self.waiting_for_key: if not self.waiting_for_key:
# Navigate normally through the menu. # Navigate normally through the menu.
@ -121,22 +121,40 @@ class SettingsMenu(Menu):
class InventoryMenu(Menu): class InventoryMenu(Menu):
"""
A special instance of a menu : the menu for the inventory of the player.
"""
player: Player player: Player
def update_player(self, player: Player) -> None: def update_player(self, player: Player) -> None:
"""
Updates the player.
"""
self.player = player self.player = player
@property @property
def values(self) -> list: def values(self) -> list:
"""
Returns the values of the menu.
"""
return self.player.inventory return self.player.inventory
class StoreMenu(Menu): class StoreMenu(Menu):
"""
A special instance of a menu : the menu for the inventory of a merchant.
"""
merchant: Merchant = None merchant: Merchant = None
def update_merchant(self, merchant: Merchant) -> None: def update_merchant(self, merchant: Merchant) -> None:
"""
Updates the merchant.
"""
self.merchant = merchant self.merchant = merchant
@property @property
def values(self) -> list: def values(self) -> list:
"""
Returns the values of the menu.
"""
return self.merchant.inventory if self.merchant else [] return self.merchant.inventory if self.merchant else []

16
squirrelbattle/settings.py
View File

@ -13,9 +13,10 @@ from .translations import gettext as _
class Settings: class Settings:
""" """
This class stores the settings of the game. This class stores the settings of the game.
Settings can be get by using for example settings.TEXTURE_PACK directly. Settings can be obtained by using for example settings.TEXTURE_PACK
The comment can be get by using settings.get_comment('TEXTURE_PACK'). directly.
We can define the setting by simply use settings.TEXTURE_PACK = 'new_key' The comment can be obtained by using settings.get_comment('TEXTURE_PACK').
We can set the setting by simply using settings.TEXTURE_PACK = 'new_key'
""" """
def __init__(self): def __init__(self):
self.KEY_UP_PRIMARY = ['z', 'Main key to move up'] self.KEY_UP_PRIMARY = ['z', 'Main key to move up']
@ -33,6 +34,7 @@ class Settings:
self.KEY_DROP = ['r', 'Key used to drop an item in the inventory'] self.KEY_DROP = ['r', 'Key used to drop an item in the inventory']
self.KEY_CHAT = ['t', 'Key used to talk to a friendly entity'] self.KEY_CHAT = ['t', 'Key used to talk to a friendly entity']
self.KEY_WAIT = ['w', 'Key used to wait'] self.KEY_WAIT = ['w', 'Key used to wait']
self.KEY_LADDER = ['<', 'Key used to use ladders']
self.TEXTURE_PACK = ['ascii', 'Texture pack'] self.TEXTURE_PACK = ['ascii', 'Texture pack']
self.LOCALE = [locale.getlocale()[0][:2], 'Language'] self.LOCALE = [locale.getlocale()[0][:2], 'Language']
@ -50,7 +52,7 @@ class Settings:
def get_comment(self, item: str) -> str: def get_comment(self, item: str) -> str:
""" """
Retrieve the comment of a setting. Retrieves the comment relative to a setting.
""" """
if item in self.settings_keys: if item in self.settings_keys:
return _(object.__getattribute__(self, item)[1]) return _(object.__getattribute__(self, item)[1])
@ -61,13 +63,13 @@ class Settings:
@property @property
def settings_keys(self) -> Generator[str, Any, None]: def settings_keys(self) -> Generator[str, Any, None]:
""" """
Get the list of all parameters. Gets the list of all parameters.
""" """
return (key for key in self.__dict__) return (key for key in self.__dict__)
def loads_from_string(self, json_str: str) -> None: def loads_from_string(self, json_str: str) -> None:
""" """
Dump settings Loads settings.
""" """
d = json.loads(json_str) d = json.loads(json_str)
for key in d: for key in d:
@ -75,7 +77,7 @@ class Settings:
def dumps_to_string(self) -> str: def dumps_to_string(self) -> str:
""" """
Dump settings Dumps settings.
""" """
d = dict() d = dict()
for key in self.settings_keys: for key in self.settings_keys:

2
squirrelbattle/term_manager.py
View File

@ -8,7 +8,7 @@ from types import TracebackType
class TermManager: # pragma: no cover class TermManager: # pragma: no cover
""" """
The TermManager object initializes the terminal, returns a screen object and The TermManager object initializes the terminal, returns a screen object and
de-initializes the terminal after use de-initializes the terminal after use.
""" """
def __init__(self): def __init__(self):
self.screen = curses.initscr() self.screen = curses.initscr()

66
squirrelbattle/tests/entities_test.py
View File

@ -6,6 +6,7 @@ import unittest
from squirrelbattle.entities.items import BodySnatchPotion, Bomb, Heart, Item, \ from squirrelbattle.entities.items import BodySnatchPotion, Bomb, Heart, Item, \
Explosion Explosion
from squirrelbattle.entities.monsters import Tiger, Hedgehog, Rabbit, TeddyBear from squirrelbattle.entities.monsters import Tiger, Hedgehog, Rabbit, TeddyBear
from squirrelbattle.entities.friendly import Trumpet
from squirrelbattle.entities.player import Player from squirrelbattle.entities.player import Player
from squirrelbattle.interfaces import Entity, Map from squirrelbattle.interfaces import Entity, Map
from squirrelbattle.resources import ResourceManager from squirrelbattle.resources import ResourceManager
@ -14,7 +15,7 @@ from squirrelbattle.resources import ResourceManager
class TestEntities(unittest.TestCase): class TestEntities(unittest.TestCase):
def setUp(self) -> None: def setUp(self) -> None:
""" """
Load example map that can be used in tests. Loads example map that can be used in tests.
""" """
self.map = Map.load(ResourceManager.get_asset_path("example_map.txt")) self.map = Map.load(ResourceManager.get_asset_path("example_map.txt"))
self.player = Player() self.player = Player()
@ -24,7 +25,7 @@ class TestEntities(unittest.TestCase):
def test_basic_entities(self) -> None: def test_basic_entities(self) -> None:
""" """
Test some random stuff with basic entities. Tests some random stuff with basic entities.
""" """
entity = Entity() entity = Entity()
entity.move(42, 64) entity.move(42, 64)
@ -39,7 +40,7 @@ class TestEntities(unittest.TestCase):
def test_fighting_entities(self) -> None: def test_fighting_entities(self) -> None:
""" """
Test some random stuff with fighting entities. Tests some random stuff with fighting entities.
""" """
entity = Tiger() entity = Tiger()
self.map.add_entity(entity) self.map.add_entity(entity)
@ -59,17 +60,17 @@ class TestEntities(unittest.TestCase):
self.map.add_entity(entity) self.map.add_entity(entity)
entity.move(15, 44) entity.move(15, 44)
# Move randomly # Move randomly
self.map.tick() self.map.tick(self.player)
self.assertFalse(entity.y == 15 and entity.x == 44) self.assertFalse(entity.y == 15 and entity.x == 44)
# Move to the player # Move to the player
entity.move(3, 6) entity.move(3, 6)
self.map.tick() self.map.tick(self.player)
self.assertTrue(entity.y == 2 and entity.x == 6) self.assertTrue(entity.y == 2 and entity.x == 6)
# Rabbit should fight # Rabbit should fight
old_health = self.player.health old_health = self.player.health
self.map.tick() self.map.tick(self.player)
self.assertTrue(entity.y == 2 and entity.x == 6) self.assertTrue(entity.y == 2 and entity.x == 6)
self.assertEqual(old_health - entity.strength, self.player.health) self.assertEqual(old_health - entity.strength, self.player.health)
self.assertEqual(self.map.logs.messages[-1], self.assertEqual(self.map.logs.messages[-1],
@ -92,9 +93,50 @@ class TestEntities(unittest.TestCase):
self.assertTrue(entity.dead) self.assertTrue(entity.dead)
self.assertGreaterEqual(self.player.current_xp, 3) self.assertGreaterEqual(self.player.current_xp, 3)
# Test the familiars
fam = Trumpet()
entity = Rabbit()
self.map.add_entity(entity)
self.map.add_entity(fam)
self.player.move(1, 6)
entity.move(2, 6)
fam.move(2, 7)
# Test fighting
entity.health = 2
entity.paths = []
entity.recalculate_paths()
fam.target = entity
self.map.tick(self.player)
self.assertTrue(entity.dead)
# Test finding a new target
entity2 = Rabbit()
self.map.add_entity(entity2)
entity2.move(2, 6)
self.map.tick(self.player)
self.assertTrue(fam.target == entity2)
self.map.remove_entity(entity2)
# Test following the player and finding the player as target
self.player.move(5, 5)
fam.move(4, 5)
fam.target = None
self.player.move_down()
self.map.tick(self.player)
self.assertTrue(fam.target == self.player)
self.assertEqual(fam.y, 5)
self.assertEqual(fam.x, 5)
# Test random move
fam.move(13, 20)
fam.target = self.player
self.map.tick(self.player)
self.assertTrue(fam.x != 20 or fam.y != 13)
def test_items(self) -> None: def test_items(self) -> None:
""" """
Test some random stuff with items. Tests some random stuff with items.
""" """
item = Item() item = Item()
self.map.add_entity(item) self.map.add_entity(item)
@ -115,7 +157,7 @@ class TestEntities(unittest.TestCase):
def test_bombs(self) -> None: def test_bombs(self) -> None:
""" """
Test some random stuff with bombs. Tests some random stuff with bombs.
""" """
item = Bomb() item = Bomb()
hedgehog = Hedgehog() hedgehog = Hedgehog()
@ -136,7 +178,7 @@ class TestEntities(unittest.TestCase):
self.assertEqual(item.y, 42) self.assertEqual(item.y, 42)
self.assertEqual(item.x, 42) self.assertEqual(item.x, 42)
# Wait for the explosion # Wait for the explosion
for ignored in range(5): for _ignored in range(5):
item.act(self.map) item.act(self.map)
self.assertTrue(hedgehog.dead) self.assertTrue(hedgehog.dead)
self.assertTrue(teddy_bear.dead) self.assertTrue(teddy_bear.dead)
@ -159,7 +201,7 @@ class TestEntities(unittest.TestCase):
def test_hearts(self) -> None: def test_hearts(self) -> None:
""" """
Test some random stuff with hearts. Tests some random stuff with hearts.
""" """
item = Heart() item = Heart()
self.map.add_entity(item) self.map.add_entity(item)
@ -174,7 +216,7 @@ class TestEntities(unittest.TestCase):
def test_body_snatch_potion(self) -> None: def test_body_snatch_potion(self) -> None:
""" """
Test some random stuff with body snatch potions. Tests some random stuff with body snatch potions.
""" """
item = BodySnatchPotion() item = BodySnatchPotion()
self.map.add_entity(item) self.map.add_entity(item)
@ -192,7 +234,7 @@ class TestEntities(unittest.TestCase):
def test_players(self) -> None: def test_players(self) -> None:
""" """
Test some random stuff with players. Tests some random stuff with players.
""" """
player = Player() player = Player()
self.map.add_entity(player) self.map.add_entity(player)

80
squirrelbattle/tests/game_test.py
View File

@ -25,7 +25,7 @@ from ..translations import gettext as _, Translator
class TestGame(unittest.TestCase): class TestGame(unittest.TestCase):
def setUp(self) -> None: def setUp(self) -> None:
""" """
Setup game. Sets the game up.
""" """
self.game = Game() self.game = Game()
self.game.new_game() self.game.new_game()
@ -39,7 +39,7 @@ class TestGame(unittest.TestCase):
def test_load_game(self) -> None: def test_load_game(self) -> None:
""" """
Save a game and reload it. Saves a game and reloads it.
""" """
bomb = Bomb() bomb = Bomb()
self.game.map.add_entity(bomb) self.game.map.add_entity(bomb)
@ -93,7 +93,7 @@ class TestGame(unittest.TestCase):
def test_bootstrap_fail(self) -> None: def test_bootstrap_fail(self) -> None:
""" """
Ensure that the test can't play the game, Ensures that the test can't play the game,
because there is no associated shell. because there is no associated shell.
Yeah, that's only for coverage. Yeah, that's only for coverage.
""" """
@ -102,7 +102,7 @@ class TestGame(unittest.TestCase):
def test_key_translation(self) -> None: def test_key_translation(self) -> None:
""" """
Test key bindings. Tests key bindings.
""" """
self.game.settings = Settings() self.game.settings = Settings()
@ -151,6 +151,9 @@ class TestGame(unittest.TestCase):
self.assertEqual(KeyValues.translate_key( self.assertEqual(KeyValues.translate_key(
self.game.settings.KEY_WAIT, self.game.settings), self.game.settings.KEY_WAIT, self.game.settings),
KeyValues.WAIT) KeyValues.WAIT)
self.assertEqual(KeyValues.translate_key(
self.game.settings.KEY_LADDER, self.game.settings),
KeyValues.LADDER)
self.assertEqual(KeyValues.translate_key(' ', self.game.settings), self.assertEqual(KeyValues.translate_key(' ', self.game.settings),
KeyValues.SPACE) KeyValues.SPACE)
self.assertEqual(KeyValues.translate_key('plop', self.game.settings), self.assertEqual(KeyValues.translate_key('plop', self.game.settings),
@ -158,7 +161,7 @@ class TestGame(unittest.TestCase):
def test_key_press(self) -> None: def test_key_press(self) -> None:
""" """
Press a key and see what is done. Presses a key and asserts what is done is correct.
""" """
self.assertEqual(self.game.state, GameMode.MAINMENU) self.assertEqual(self.game.state, GameMode.MAINMENU)
self.assertEqual(self.game.main_menu.validate(), self.assertEqual(self.game.main_menu.validate(),
@ -249,7 +252,7 @@ class TestGame(unittest.TestCase):
def test_mouse_click(self) -> None: def test_mouse_click(self) -> None:
""" """
Simulate mouse clicks. Simulates mouse clicks.
""" """
self.game.state = GameMode.MAINMENU self.game.state = GameMode.MAINMENU
@ -279,7 +282,7 @@ class TestGame(unittest.TestCase):
def test_new_game(self) -> None: def test_new_game(self) -> None:
""" """
Ensure that the start button starts a new game. Ensures that the start button starts a new game.
""" """
old_map = self.game.map old_map = self.game.map
old_player = self.game.player old_player = self.game.player
@ -302,7 +305,7 @@ class TestGame(unittest.TestCase):
def test_settings_menu(self) -> None: def test_settings_menu(self) -> None:
""" """
Ensure that the settings menu is working properly. Ensures that the settings menu is working properly.
""" """
self.game.settings = Settings() self.game.settings = Settings()
@ -341,7 +344,7 @@ class TestGame(unittest.TestCase):
self.assertEqual(self.game.settings.KEY_LEFT_PRIMARY, 'a') self.assertEqual(self.game.settings.KEY_LEFT_PRIMARY, 'a')
# Navigate to "texture pack" # Navigate to "texture pack"
for ignored in range(11): for ignored in range(12):
self.game.handle_key_pressed(KeyValues.DOWN) self.game.handle_key_pressed(KeyValues.DOWN)
# Change texture pack # Change texture pack
@ -388,7 +391,7 @@ class TestGame(unittest.TestCase):
def test_dead_screen(self) -> None: def test_dead_screen(self) -> None:
""" """
Kill player and render dead screen. Kills the player and renders the dead message on the fake screen.
""" """
self.game.state = GameMode.PLAY self.game.state = GameMode.PLAY
# Kill player # Kill player
@ -404,14 +407,14 @@ class TestGame(unittest.TestCase):
def test_not_implemented(self) -> None: def test_not_implemented(self) -> None:
""" """
Check that some functions are not implemented, only for coverage. Checks that some functions are not implemented, only for coverage.
""" """
self.assertRaises(NotImplementedError, Display.display, None) self.assertRaises(NotImplementedError, Display.display, None)
self.assertRaises(NotImplementedError, Display.update, None, self.game) self.assertRaises(NotImplementedError, Display.update, None, self.game)
def test_messages(self) -> None: def test_messages(self) -> None:
""" """
Display error messages. Displays error messages.
""" """
self.game.message = "I am an error" self.game.message = "I am an error"
self.game.display_actions(DisplayActions.UPDATE) self.game.display_actions(DisplayActions.UPDATE)
@ -421,7 +424,7 @@ class TestGame(unittest.TestCase):
def test_inventory_menu(self) -> None: def test_inventory_menu(self) -> None:
""" """
Open the inventory menu and interact with items. Opens the inventory menu and interacts with items.
""" """
self.game.state = GameMode.PLAY self.game.state = GameMode.PLAY
# Open and close the inventory # Open and close the inventory
@ -482,7 +485,7 @@ class TestGame(unittest.TestCase):
def test_talk_to_sunflowers(self) -> None: def test_talk_to_sunflowers(self) -> None:
""" """
Interact with sunflowers Interacts with sunflowers.
""" """
self.game.state = GameMode.PLAY self.game.state = GameMode.PLAY
@ -533,7 +536,7 @@ class TestGame(unittest.TestCase):
def test_talk_to_merchant(self) -> None: def test_talk_to_merchant(self) -> None:
""" """
Interact with merchants Interacts with merchants.
""" """
self.game.state = GameMode.PLAY self.game.state = GameMode.PLAY
@ -706,3 +709,50 @@ class TestGame(unittest.TestCase):
self.game.player.hit(sea_eagle) self.game.player.hit(sea_eagle)
self.assertEqual(sea_eagle.health, self.assertEqual(sea_eagle.health,
old_health - self.game.player.strength * 4) old_health - self.game.player.strength * 4)
def test_ladders(self) -> None:
"""
Ensure that the player can climb on ladders.
"""
self.game.state = GameMode.PLAY
self.assertEqual(self.game.player.map.floor, 0)
self.game.handle_key_pressed(KeyValues.LADDER)
self.assertEqual(self.game.player.map.floor, 0)
# Move nowhere
self.game.player.move(10, 10)
self.game.handle_key_pressed(KeyValues.LADDER)
self.assertEqual(self.game.player.map.floor, 0)
# Move down
self.game.player.move(3, 40) # Move on a ladder
self.game.handle_key_pressed(KeyValues.LADDER)
self.assertEqual(self.game.map_index, 1)
self.assertEqual(self.game.player.map.floor, 1)
self.assertEqual(self.game.player.y, 1)
self.assertEqual(self.game.player.x, 17)
self.game.display_actions(DisplayActions.UPDATE)
# Move up
self.game.handle_key_pressed(KeyValues.LADDER)
self.assertEqual(self.game.player.map.floor, 0)
self.assertEqual(self.game.player.y, 3)
self.assertEqual(self.game.player.x, 40)
self.game.display_actions(DisplayActions.UPDATE)
def test_credits(self) -> None:
"""
Load credits menu.
"""
self.game.state = GameMode.MAINMENU
self.game.display_actions(DisplayActions.MOUSE, 41, 41)
self.assertEqual(self.game.state, GameMode.CREDITS)
self.game.display_actions(DisplayActions.MOUSE, 21, 21)
self.game.display_actions(DisplayActions.REFRESH)
self.game.state = GameMode.CREDITS
self.game.handle_key_pressed(KeyValues.ENTER)
self.assertEqual(self.game.state, GameMode.MAINMENU)

26
squirrelbattle/tests/interfaces_test.py
View File

@ -4,14 +4,14 @@
import unittest import unittest
from squirrelbattle.display.texturepack import TexturePack from squirrelbattle.display.texturepack import TexturePack
from squirrelbattle.interfaces import Map, Tile from squirrelbattle.interfaces import Map, Tile, Slope
from squirrelbattle.resources import ResourceManager from squirrelbattle.resources import ResourceManager
class TestInterfaces(unittest.TestCase): class TestInterfaces(unittest.TestCase):
def test_map(self) -> None: def test_map(self) -> None:
""" """
Create a map and check that it is well parsed. Creates a map and checks that it is well parsed.
""" """
m = Map.load_from_string("0 0\n.#\n#.\n") m = Map.load_from_string("0 0\n.#\n#.\n")
self.assertEqual(m.width, 2) self.assertEqual(m.width, 2)
@ -20,7 +20,7 @@ class TestInterfaces(unittest.TestCase):
def test_load_map(self) -> None: def test_load_map(self) -> None:
""" """
Try to load a map from a file. Tries to load a map from a file.
""" """
m = Map.load(ResourceManager.get_asset_path("example_map.txt")) m = Map.load(ResourceManager.get_asset_path("example_map.txt"))
self.assertEqual(m.width, 52) self.assertEqual(m.width, 52)
@ -28,7 +28,7 @@ class TestInterfaces(unittest.TestCase):
def test_tiles(self) -> None: def test_tiles(self) -> None:
""" """
Test some things about tiles. Tests some things about tiles.
""" """
self.assertFalse(Tile.FLOOR.is_wall()) self.assertFalse(Tile.FLOOR.is_wall())
self.assertTrue(Tile.WALL.is_wall()) self.assertTrue(Tile.WALL.is_wall())
@ -37,3 +37,21 @@ class TestInterfaces(unittest.TestCase):
self.assertFalse(Tile.WALL.can_walk()) self.assertFalse(Tile.WALL.can_walk())
self.assertFalse(Tile.EMPTY.can_walk()) self.assertFalse(Tile.EMPTY.can_walk())
self.assertRaises(ValueError, Tile.from_ascii_char, 'unknown') self.assertRaises(ValueError, Tile.from_ascii_char, 'unknown')
def test_slope(self) -> None:
"""
Test good behaviour of slopes (basically vectors, compared according to
the determinant)
"""
a = Slope(1, 1)
b = Slope(0, 1)
self.assertTrue(b < a)
self.assertTrue(b <= a)
self.assertTrue(a <= a)
self.assertTrue(a == a)
self.assertTrue(a > b)
self.assertTrue(a >= b)
# def test_visibility(self) -> None:
# m = Map.load(ResourceManager.get_asset_path("example_map_3.txt"))
# m.compute_visibility(1, 1, 50)

3
squirrelbattle/tests/screen.py
View File

@ -24,3 +24,6 @@ class FakePad:
def getmaxyx(self) -> Tuple[int, int]: def getmaxyx(self) -> Tuple[int, int]:
return 42, 42 return 42, 42
def inch(self, y: int, x: int) -> str:
return "i"

2
squirrelbattle/tests/settings_test.py
View File

@ -13,7 +13,7 @@ class TestSettings(unittest.TestCase):
def test_settings(self) -> None: def test_settings(self) -> None:
""" """
Ensure that settings are well loaded. Ensures that settings are well loaded.
""" """
settings = Settings() settings = Settings()
self.assertEqual(settings.KEY_UP_PRIMARY, 'z') self.assertEqual(settings.KEY_UP_PRIMARY, 'z')

6
squirrelbattle/tests/translations_test.py
View File

@ -11,7 +11,7 @@ class TestTranslations(unittest.TestCase):
def test_main_menu_translation(self) -> None: def test_main_menu_translation(self) -> None:
""" """
Ensure that the main menu is translated. Ensures that the main menu is translated.
""" """
self.assertEqual(_("New game"), "Nouvelle partie") self.assertEqual(_("New game"), "Nouvelle partie")
self.assertEqual(_("Resume"), "Continuer") self.assertEqual(_("Resume"), "Continuer")
@ -22,7 +22,7 @@ class TestTranslations(unittest.TestCase):
def test_settings_menu_translation(self) -> None: def test_settings_menu_translation(self) -> None:
""" """
Ensure that the settings menu is translated. Ensures that the settings menu is translated.
""" """
self.assertEqual(_("Main key to move up"), self.assertEqual(_("Main key to move up"),
"Touche principale pour aller vers le haut") "Touche principale pour aller vers le haut")
@ -53,6 +53,8 @@ class TestTranslations(unittest.TestCase):
self.assertEqual(_("Key used to talk to a friendly entity"), self.assertEqual(_("Key used to talk to a friendly entity"),
"Touche pour parler à une entité pacifique") "Touche pour parler à une entité pacifique")
self.assertEqual(_("Key used to wait"), "Touche pour attendre") self.assertEqual(_("Key used to wait"), "Touche pour attendre")
self.assertEqual(_("Key used to use ladders"),
"Touche pour utiliser les échelles")
self.assertEqual(_("Texture pack"), "Pack de textures") self.assertEqual(_("Texture pack"), "Pack de textures")
self.assertEqual(_("Language"), "Langue") self.assertEqual(_("Language"), "Langue")

12
squirrelbattle/translations.py
View File

@ -13,7 +13,7 @@ class Translator:
""" """
This module uses gettext to translate strings. This module uses gettext to translate strings.
Translator.setlocale defines the language of the strings, Translator.setlocale defines the language of the strings,
then gettext() translates the message. then gettext() translates the messages.
""" """
SUPPORTED_LOCALES: List[str] = ["de", "en", "es", "fr"] SUPPORTED_LOCALES: List[str] = ["de", "en", "es", "fr"]
locale: str = "en" locale: str = "en"
@ -22,7 +22,7 @@ class Translator:
@classmethod @classmethod
def refresh_translations(cls) -> None: def refresh_translations(cls) -> None:
""" """
Load compiled translations. Loads compiled translations.
""" """
for language in cls.SUPPORTED_LOCALES: for language in cls.SUPPORTED_LOCALES:
rep = Path(__file__).parent / "locale" / language / "LC_MESSAGES" rep = Path(__file__).parent / "locale" / language / "LC_MESSAGES"
@ -37,7 +37,7 @@ class Translator:
@classmethod @classmethod
def setlocale(cls, lang: str) -> None: def setlocale(cls, lang: str) -> None:
""" """
Define the language used to translate the game. Defines the language used to translate the game.
The language must be supported, otherwise nothing is done. The language must be supported, otherwise nothing is done.
""" """
lang = lang[:2] lang = lang[:2]
@ -51,7 +51,7 @@ class Translator:
@classmethod @classmethod
def makemessages(cls) -> None: # pragma: no cover def makemessages(cls) -> None: # pragma: no cover
""" """
Analyse all strings in the project and extract them. Analyses all strings in the project and extracts them.
""" """
for language in cls.SUPPORTED_LOCALES: for language in cls.SUPPORTED_LOCALES:
if language == "en": if language == "en":
@ -83,7 +83,7 @@ class Translator:
@classmethod @classmethod
def compilemessages(cls) -> None: def compilemessages(cls) -> None:
""" """
Compile translation messages from source files. Compiles translation messages from source files.
""" """
for language in cls.SUPPORTED_LOCALES: for language in cls.SUPPORTED_LOCALES:
if language == "en": if language == "en":
@ -99,7 +99,7 @@ class Translator:
def gettext(message: str) -> str: def gettext(message: str) -> str:
""" """
Translate a message. Translates a message.
""" """
return Translator.get_translator().gettext(message) return Translator.get_translator().gettext(message)