Rename dungeonbattle to squirrelbattle

squirrelbattle/display/display.py

@@ -0,0 +1,52 @@
+import curses
+from typing import Any, Optional, Union
+
+from squirrelbattle.display.texturepack import TexturePack
+from squirrelbattle.tests.screen import FakePad
+
+
+class Display:
+    x: int
+    y: int
+    width: int
+    height: int
+    pad: Any
+
+    def __init__(self, screen: Any, pack: Optional[TexturePack] = None):
+        self.screen = screen
+        self.pack = pack or TexturePack.get_pack("ascii")
+
+    def newpad(self, height: int, width: int) -> Union[FakePad, Any]:
+        return curses.newpad(height, width) if self.screen else FakePad()
+
+    def init_pair(self, number: int, foreground: int, background: int) -> None:
+        return curses.init_pair(number, foreground, background) \
+            if self.screen else None
+
+    def color_pair(self, number: int) -> int:
+        return curses.color_pair(number) if self.screen else 0
+
+    def resize(self, y: int, x: int, height: int, width: int,
+               resize_pad: bool = True) -> None:
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        if hasattr(self, "pad") and resize_pad:
+            self.pad.resize(self.height - 1, self.width - 1)
+
+    def refresh(self, *args, resize_pad: bool = True) -> None:
+        if len(args) == 4:
+            self.resize(*args, resize_pad)
+        self.display()
+
+    def display(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def rows(self) -> int:
+        return curses.LINES if self.screen else 42
+
+    @property
+    def cols(self) -> int:
+        return curses.COLS if self.screen else 42

squirrelbattle/display/display_manager.py

@@ -0,0 +1,70 @@
+import curses
+from squirrelbattle.display.mapdisplay import MapDisplay
+from squirrelbattle.display.statsdisplay import StatsDisplay
+from squirrelbattle.display.menudisplay import SettingsMenuDisplay, \
+    MainMenuDisplay
+from squirrelbattle.display.texturepack import TexturePack
+from typing import Any
+from squirrelbattle.game import Game, GameMode
+from squirrelbattle.enums import DisplayActions
+
+
+class DisplayManager:
+
+    def __init__(self, screen: Any, g: Game):
+        self.game = g
+        self.screen = screen
+        pack = TexturePack.get_pack(self.game.settings.TEXTURE_PACK)
+        self.mapdisplay = MapDisplay(screen, pack)
+        self.statsdisplay = StatsDisplay(screen, pack)
+        self.mainmenudisplay = MainMenuDisplay(self.game.main_menu,
+                                               screen, pack)
+        self.settingsmenudisplay = SettingsMenuDisplay(screen, pack)
+        self.displays = [self.statsdisplay, self.mapdisplay,
+                         self.mainmenudisplay, self.settingsmenudisplay]
+        self.update_game_components()
+
+    def handle_display_action(self, action: DisplayActions) -> None:
+        if action == DisplayActions.REFRESH:
+            self.refresh()
+        elif action == DisplayActions.UPDATE:
+            self.update_game_components()
+
+    def update_game_components(self) -> None:
+        for d in self.displays:
+            d.pack = TexturePack.get_pack(self.game.settings.TEXTURE_PACK)
+        self.mapdisplay.update_map(self.game.map)
+        self.statsdisplay.update_player(self.game.player)
+        self.settingsmenudisplay.update_menu(self.game.settings_menu)
+
+    def refresh(self) -> None:
+        if self.game.state == GameMode.PLAY:
+            # The map pad has already the good size
+            self.mapdisplay.refresh(0, 0, self.rows * 4 // 5, self.cols,
+                                    resize_pad=False)
+            self.statsdisplay.refresh(self.rows * 4 // 5, 0,
+                                      self.rows // 5, self.cols)
+        if self.game.state == GameMode.MAINMENU:
+            self.mainmenudisplay.refresh(0, 0, self.rows, self.cols)
+        if self.game.state == GameMode.SETTINGS:
+            self.settingsmenudisplay.refresh(0, 0, self.rows, self.cols - 1)
+        self.resize_window()
+
+    def resize_window(self) -> bool:
+        """
+        If the window got resized, ensure that the screen size got updated.
+        """
+        y, x = self.screen.getmaxyx() if self.screen else (0, 0)
+        if self.screen and curses.is_term_resized(self.rows,
+                                                  self.cols):  # pragma: nocover
+            curses.resizeterm(y, x)
+            return True
+        return False
+
+    @property
+    def rows(self) -> int:
+        return curses.LINES if self.screen else 42
+
+    @property
+    def cols(self) -> int:
+        return curses.COLS if self.screen else 42

squirrelbattle/display/mapdisplay.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+from squirrelbattle.interfaces import Map
+from .display import Display
+
+
+class MapDisplay(Display):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def update_map(self, m: Map) -> None:
+        self.map = m
+        self.pad = self.newpad(m.height, self.pack.tile_width * m.width + 1)
+
+    def update_pad(self) -> None:
+        self.init_pair(1, self.pack.tile_fg_color, self.pack.tile_bg_color)
+        self.init_pair(2, self.pack.entity_fg_color, self.pack.entity_bg_color)
+        self.pad.addstr(0, 0, self.map.draw_string(self.pack),
+                        self.color_pair(1))
+        for e in self.map.entities:
+            self.pad.addstr(e.y, self.pack.tile_width * e.x,
+                            self.pack[e.name.upper()], self.color_pair(2))
+
+    def display(self) -> None:
+        y, x = self.map.currenty, self.pack.tile_width * self.map.currentx
+        deltay, deltax = (self.height // 2) + 1, (self.width // 2) + 1
+        pminrow, pmincol = y - deltay, x - deltax
+        sminrow, smincol = max(-pminrow, 0), max(-pmincol, 0)
+        deltay, deltax = self.height - deltay, self.width - deltax
+        smaxrow = self.map.height - (y + deltay) + self.height - 1
+        smaxrow = min(smaxrow, self.height - 1)
+        smaxcol = self.pack.tile_width * self.map.width - \
+            (x + deltax) + self.width - 1
+        smaxcol = min(smaxcol, self.width - 1)
+        pminrow = max(0, min(self.map.height, pminrow))
+        pmincol = max(0, min(self.pack.tile_width * self.map.width, pmincol))
+        self.pad.clear()
+        self.update_pad()
+        self.pad.refresh(pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol)

squirrelbattle/display/menudisplay.py

@@ -0,0 +1,94 @@
+from typing import List
+
+from squirrelbattle.menus import Menu, MainMenu
+from .display import Display
+
+
+class MenuDisplay(Display):
+    position: int
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.menubox = self.newpad(self.rows, self.cols)
+
+    def update_menu(self, menu: Menu) -> None:
+        self.menu = menu
+        self.trueheight = len(self.values)
+        self.truewidth = max([len(a) for a in self.values])
+
+        # Menu values are printed in pad
+        self.pad = self.newpad(self.trueheight, self.truewidth + 2)
+        for i in range(self.trueheight):
+            self.pad.addstr(i, 0, "  " + self.values[i])
+
+    def update_pad(self) -> None:
+        for i in range(self.trueheight):
+            self.pad.addstr(i, 0, "  " + self.values[i])
+        # set a marker on the selected line
+        self.pad.addstr(self.menu.position, 0, ">")
+
+    def display(self) -> None:
+        cornery = 0 if self.height - 2 >= self.menu.position - 1 \
+            else self.trueheight - self.height + 2 \
+            if self.height - 2 >= self.trueheight - self.menu.position else 0
+
+        # Menu box
+        self.menubox.addstr(0, 0, "┏" + "━" * (self.width - 2) + "┓")
+        for i in range(1, self.height - 1):
+            self.menubox.addstr(i, 0, "┃" + " " * (self.width - 2) + "┃")
+        self.menubox.addstr(self.height - 1, 0,
+                            "┗" + "━" * (self.width - 2) + "┛")
+
+        self.menubox.refresh(0, 0, self.y, self.x,
+                             self.height + self.y,
+                             self.width + self.x)
+        self.update_pad()
+        self.pad.refresh(cornery, 0, self.y + 1, self.x + 2,
+                         self.height - 2 + self.y,
+                         self.width - 2 + self.x)
+
+    @property
+    def preferred_width(self) -> int:
+        return self.truewidth + 6
+
+    @property
+    def preferred_height(self) -> int:
+        return self.trueheight + 2
+
+    @property
+    def values(self) -> List[str]:
+        return [str(a) for a in self.menu.values]
+
+
+class SettingsMenuDisplay(MenuDisplay):
+    @property
+    def values(self) -> List[str]:
+        return [a[1][1] + (" : "
+                + ("?" if self.menu.waiting_for_key else a[1][0])
+            if a[1][0] else "") for a in self.menu.values]
+
+
+class MainMenuDisplay(Display):
+    def __init__(self, menu: MainMenu, *args):
+        super().__init__(*args)
+        self.menu = menu
+
+        with open("squirrelbattle/assets/ascii_art.txt", "r") as file:
+            self.title = file.read().split("\n")
+
+        self.pad = self.newpad(max(self.rows, len(self.title) + 30),
+                               max(len(self.title[0]) + 5, self.cols))
+
+        self.menudisplay = MenuDisplay(self.screen, self.pack)
+        self.menudisplay.update_menu(self.menu)
+
+    def display(self) -> None:
+        for i in range(len(self.title)):
+            self.pad.addstr(4 + i, max(self.width // 2
+                            - len(self.title[0]) // 2 - 1, 0), self.title[i])
+        self.pad.refresh(0, 0, self.y, self.x, self.height, self.width)
+        menuwidth = min(self.menudisplay.preferred_width, self.width)
+        menuy, menux = len(self.title) + 8, self.width // 2 - menuwidth // 2 - 1
+        self.menudisplay.refresh(
+            menuy, menux, min(self.menudisplay.preferred_height,
+                              self.height - menuy), menuwidth)

squirrelbattle/display/statsdisplay.py

@@ -0,0 +1,52 @@
+import curses
+
+from .display import Display
+
+from squirrelbattle.entities.player import Player
+
+
+class StatsDisplay(Display):
+    player: Player
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pad = self.newpad(self.rows, self.cols)
+        self.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK)
+
+    def update_player(self, p: Player) -> None:
+        self.player = p
+
+    def update_pad(self) -> None:
+        string = ""
+        for _ in range(self.width - 1):
+            string = string + "-"
+        self.pad.addstr(0, 0, string)
+        string2 = "Player -- LVL {}  EXP {}/{}  HP {}/{}"\
+            .format(self.player.level, self.player.current_xp,
+                    self.player.max_xp, self.player.health,
+                    self.player.maxhealth)
+        for _ in range(self.width - len(string2) - 1):
+            string2 = string2 + " "
+        self.pad.addstr(1, 0, string2)
+        string3 = "Stats : STR {}  INT {}  CHR {}  DEX {} CON {}"\
+            .format(self.player.strength,
+                    self.player.intelligence, self.player.charisma,
+                    self.player.dexterity, self.player.constitution)
+        for _ in range(self.width - len(string3) - 1):
+            string3 = string3 + " "
+        self.pad.addstr(2, 0, string3)
+
+        inventory_str = "Inventaire : " + "".join(
+            self.pack[item.name.upper()] for item in self.player.inventory)
+        self.pad.addstr(3, 0, inventory_str)
+
+        if self.player.dead:
+            self.pad.addstr(4, 0, "VOUS ÊTES MORT",
+                            curses.A_BOLD | curses.A_BLINK | curses.A_STANDOUT
+                            | self.color_pair(3))
+
+    def display(self) -> None:
+        self.pad.clear()
+        self.update_pad()
+        self.pad.refresh(0, 0, self.y, self.x,
+                         4 + self.y, self.width + self.x)

squirrelbattle/display/texturepack.py

@@ -0,0 +1,75 @@
+import curses
+from typing import Any
+
+
+class TexturePack:
+    _packs = dict()
+
+    name: str
+    tile_width: int
+    tile_fg_color: int
+    tile_bg_color: int
+    entity_fg_color: int
+    entity_bg_color: int
+    EMPTY: str
+    WALL: str
+    FLOOR: str
+    PLAYER: str
+
+    ASCII_PACK: "TexturePack"
+    SQUIRREL_PACK: "TexturePack"
+
+    def __init__(self, name: str, **kwargs):
+        self.name = name
+        self.__dict__.update(**kwargs)
+        TexturePack._packs[name] = self
+
+    def __getitem__(self, item: str) -> Any:
+        return self.__dict__[item]
+
+    @classmethod
+    def get_pack(cls, name: str) -> "TexturePack":
+        return cls._packs[name.lower()]
+
+    @classmethod
+    def get_next_pack_name(cls, name: str) -> str:
+        return "squirrel" if name == "ascii" else "ascii"
+
+
+TexturePack.ASCII_PACK = TexturePack(
+    name="ascii",
+    tile_width=1,
+    tile_fg_color=curses.COLOR_WHITE,
+    tile_bg_color=curses.COLOR_BLACK,
+    entity_fg_color=curses.COLOR_WHITE,
+    entity_bg_color=curses.COLOR_BLACK,
+    EMPTY=' ',
+    WALL='#',
+    FLOOR='.',
+    PLAYER='@',
+    HEDGEHOG='*',
+    HEART='❤',
+    BOMB='o',
+    RABBIT='Y',
+    BEAVER='_',
+    TEDDY_BEAR='8',
+)
+
+TexturePack.SQUIRREL_PACK = TexturePack(
+    name="squirrel",
+    tile_width=2,
+    tile_fg_color=curses.COLOR_WHITE,
+    tile_bg_color=curses.COLOR_BLACK,
+    entity_fg_color=curses.COLOR_WHITE,
+    entity_bg_color=curses.COLOR_WHITE,
+    EMPTY='  ',
+    WALL='🧱',
+    FLOOR='██',
+    PLAYER='🐿 ️',
+    HEDGEHOG='🦔',
+    HEART='💜',
+    BOMB='💣',
+    RABBIT='🐇',
+    BEAVER='🦫',
+    TEDDY_BEAR='🧸',
+)