Part 11: Delving into the Dungeon

Author: jmccardle

game/actions.py

@@ -172,3 +172,15 @@ def perform(self) -> None:
         # Type check to ensure entity is an Actor with inventory
         assert isinstance(self.entity, game.entity.Actor), "Entity must be an Actor for inventory access"
         self.entity.inventory.drop(self.item)
+
+
+class TakeStairsAction(Action):
+    def perform(self) -> None:
+        """
+        Take the stairs, if any exist at the entity's location.
+        """
+        if (self.entity.x, self.entity.y) == self.engine.game_map.downstairs_location:
+            self.engine.game_world.generate_floor()
+            self.engine.message_log.add_message("You descend the staircase.", game.color.descend)
+        else:
+            raise game.exceptions.Impossible("There are no stairs here.")

game/color.py

@@ -15,6 +15,8 @@
 needs_target = (0x3F, 0xFF, 0xFF)
 status_effect_applied = (0x3F, 0xFF, 0x3F)
 
+descend = (0x9F, 0x3F, 0xFF)
+
 bar_text = white
 bar_filled = (0x0, 0x60, 0x0)
 bar_empty = (0x40, 0x10, 0x10)

game/components/consumable.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union
 
 import game.actions
 import game.color
@@ -16,7 +16,9 @@
 class Consumable(game.components.base_component.BaseComponent):
     parent: game.entity.Item
 
-    def get_action(self, consumer: game.entity.Actor) -> Optional[game.actions.Action]:
+    def get_action(
+        self, consumer: game.entity.Actor
+    ) -> Optional[Union[game.actions.Action, game.input_handlers.BaseEventHandler]]:
         """Try to return the action for this item."""
         return game.actions.ItemAction(consumer, self.parent)
 

game/components/fighter.py

@@ -49,6 +49,8 @@ def die(self) -> None:
 
         self.engine.message_log.add_message(death_message, death_message_color)
 
+        self.engine.player.level.add_xp(self.parent.level.xp_given)
+
     def heal(self, amount: int) -> int:
         if self.hp == self.max_hp:
             return 0

game/components/level.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from game.components.base_component import BaseComponent
+import game.entity
+
+
+class Level(BaseComponent):
+    parent: game.entity.Actor
+
+    def __init__(
+        self,
+        current_level: int = 1,
+        current_xp: int = 0,
+        level_up_base: int = 0,
+        level_up_factor: int = 150,
+        xp_given: int = 0,
+    ):
+        self.current_level = current_level
+        self.current_xp = current_xp
+        self.level_up_base = level_up_base
+        self.level_up_factor = level_up_factor
+        self.xp_given = xp_given
+
+    @property
+    def experience_to_next_level(self) -> int:
+        return self.level_up_base + self.current_level * self.level_up_factor
+
+    @property
+    def requires_level_up(self) -> bool:
+        return self.current_xp > self.experience_to_next_level
+
+    def add_xp(self, xp: int) -> None:
+        if xp == 0 or self.level_up_base == 0:
+            return
+
+        self.current_xp += xp
+
+        self.engine.message_log.add_message(f"You gain {xp} experience points.")
+
+        if self.requires_level_up:
+            self.engine.message_log.add_message(f"You advance to level {self.current_level + 1}!")
+
+    def increase_level(self) -> None:
+        self.current_xp -= self.experience_to_next_level
+
+        self.current_level += 1
+
+    def increase_max_hp(self, amount: int = 20) -> None:
+        self.parent.fighter.max_hp += amount
+        self.parent.fighter.hp += amount
+
+        self.engine.message_log.add_message("Your health improves!")
+
+        self.increase_level()
+
+    def increase_power(self, amount: int = 1) -> None:
+        self.parent.fighter.power += amount
+
+        self.engine.message_log.add_message("You feel stronger!")
+
+        self.increase_level()
+
+    def increase_defense(self, amount: int = 1) -> None:
+        self.parent.fighter.defense += amount
+
+        self.engine.message_log.add_message("Your movements are getting swifter!")
+
+        self.increase_level()

game/engine.py

@@ -17,6 +17,7 @@
 
 class Engine:
     game_map: game.game_map.GameMap
+    game_world: game.game_map.GameWorld
 
     def __init__(self, player: game.entity.Actor):
         self.player = player
@@ -52,6 +53,18 @@ def render(self, console: tcod.console.Console) -> None:
             total_width=20,
         )
 
+        game.render_functions.render_dungeon_level(
+            console=console,
+            dungeon_level=self.game_world.current_floor,
+            location=(0, 47),
+        )
+
+        console.print(
+            x=0,
+            y=46,
+            string=f"LVL: {self.player.level.current_level}",
+        )
+
         game.render_functions.render_names_at_mouse_location(console=console, x=21, y=44, engine=self)
 
     def save_as(self, filename: str) -> None:

game/entity.py

@@ -9,8 +9,8 @@
     import game.components.consumable
     import game.components.fighter
     import game.components.inventory
-
-import game.game_map
+    import game.components.level
+    import game.game_map
 
 
 class Entity:
@@ -85,6 +85,7 @@ def __init__(
         ai_cls: Type[game.components.ai.BaseAI],
         fighter: game.components.fighter.Fighter,
         inventory: game.components.inventory.Inventory,
+        level: game.components.level.Level,
     ):
         super().__init__(
             parent=None,
@@ -104,6 +105,9 @@ def __init__(
         self.inventory = inventory
         self.inventory.parent = self
 
+        self.level = level
+        self.level.parent = self
+
         self.render_order = game.render_order.RenderOrder.ACTOR
 
     @property

game/entity_factories.py

@@ -7,6 +7,7 @@
 )
 from game.components.fighter import Fighter
 from game.components.inventory import Inventory
+from game.components.level import Level
 from game.entity import Actor, Item
 
 player = Actor(
@@ -16,6 +17,7 @@
     ai_cls=HostileEnemy,
     fighter=Fighter(hp=30, defense=2, power=5),
     inventory=Inventory(capacity=26),
+    level=Level(level_up_base=200),
 )
 
 orc = Actor(
@@ -25,6 +27,7 @@
     ai_cls=HostileEnemy,
     fighter=Fighter(hp=10, defense=0, power=3),
     inventory=Inventory(capacity=0),
+    level=Level(xp_given=35),
 )
 
 troll = Actor(
@@ -34,6 +37,7 @@
     ai_cls=HostileEnemy,
     fighter=Fighter(hp=16, defense=1, power=4),
     inventory=Inventory(capacity=0),
+    level=Level(xp_given=100),
 )
 
 health_potion = Item(

game/game_map.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterator, Optional, Set
+from typing import TYPE_CHECKING, Iterable, Iterator, Optional, Set
 
 import numpy as np
 import tcod
@@ -13,15 +13,19 @@
 
 
 class GameMap:
-    def __init__(self, engine: game.engine.Engine, width: int, height: int):
+    def __init__(
+        self, engine: game.engine.Engine, width: int, height: int, entities: Iterable[game.entity.Entity] = ()
+    ):
         self.engine = engine
         self.width, self.height = width, height
-        self.entities: Set[game.entity.Entity] = set()
+        self.entities: Set[game.entity.Entity] = set(entities)
         self.tiles = np.full((width, height), fill_value=game.tiles.wall, order="F")
 
         self.visible = np.full((width, height), fill_value=False, order="F")  # Tiles the player can currently see
         self.explored = np.full((width, height), fill_value=False, order="F")  # Tiles the player has seen before
 
+        self.downstairs_location = (0, 0)
+
     @property
     def gamemap(self) -> GameMap:
         """Part 8 refactoring prep: self reference for parent system"""
@@ -82,3 +86,62 @@ def render(self, console: tcod.console.Console) -> None:
             # Only print entities that are in the FOV
             if self.visible[entity.x, entity.y]:
                 console.print(x=entity.x, y=entity.y, string=entity.char, fg=entity.color)
+
+        # Show stairs
+        if self.visible[self.downstairs_location]:
+            console.print(
+                x=self.downstairs_location[0],
+                y=self.downstairs_location[1],
+                string=">",
+                fg=(255, 255, 255),
+            )
+
+
+class GameWorld:
+    """
+    Holds the settings for the GameMap, and generates new maps when moving down the stairs.
+    """
+
+    def __init__(
+        self,
+        *,
+        engine: game.engine.Engine,
+        map_width: int,
+        map_height: int,
+        max_rooms: int,
+        room_min_size: int,
+        room_max_size: int,
+        max_monsters_per_room: int,
+        max_items_per_room: int,
+        current_floor: int = 0,
+    ):
+        self.engine = engine
+
+        self.map_width = map_width
+        self.map_height = map_height
+
+        self.max_rooms = max_rooms
+
+        self.room_min_size = room_min_size
+        self.room_max_size = room_max_size
+
+        self.max_monsters_per_room = max_monsters_per_room
+        self.max_items_per_room = max_items_per_room
+
+        self.current_floor = current_floor
+
+    def generate_floor(self) -> None:
+        from game.procgen import generate_dungeon
+
+        self.current_floor += 1
+
+        self.engine.game_map = generate_dungeon(
+            max_rooms=self.max_rooms,
+            room_min_size=self.room_min_size,
+            room_max_size=self.room_max_size,
+            map_width=self.map_width,
+            map_height=self.map_height,
+            max_monsters_per_room=self.max_monsters_per_room,
+            max_items_per_room=self.max_items_per_room,
+            engine=self.engine,
+        )

game/input_handlers.py

@@ -91,6 +91,8 @@ def handle_events(self, event: tcod.event.Event) -> BaseEventHandler:
             if not self.engine.player.is_alive:
                 # The player was killed sometime during or after the action.
                 return GameOverEventHandler(self.engine)
+            elif self.engine.player.level.requires_level_up:
+                return LevelUpEventHandler(self.engine)
             return MainGameEventHandler(self.engine)  # Return to the main handler.
         return self
 
@@ -144,9 +146,13 @@ def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[ActionOrHandler]:
             return InventoryDropHandler(self.engine)
         elif key == tcod.event.KeySym.SLASH:
             return LookHandler(self.engine)
-        elif key == tcod.event.KeySym.PERIOD and modifiers & (tcod.event.KMOD_LSHIFT | tcod.event.KMOD_RSHIFT):
-            # Wait if user presses '>' (shift + period)
-            action = game.actions.WaitAction(player)
+        elif key == tcod.event.KeySym.PERIOD:
+            if modifiers & (tcod.event.KMOD_LSHIFT | tcod.event.KMOD_RSHIFT):
+                # Take stairs down if user presses '>'
+                return game.actions.TakeStairsAction(player)
+            else:
+                # Wait if user presses '.'
+                action = game.actions.WaitAction(player)
 
         # No valid key was pressed
         return action
@@ -457,3 +463,70 @@ def on_render(self, console: tcod.console.Console) -> None:
     def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseEventHandler]:
         """Any key returns to the parent handler."""
         return self.parent
+
+
+class LevelUpEventHandler(AskUserEventHandler):
+    TITLE = "Level Up"
+
+    def on_render(self, console: tcod.console.Console) -> None:
+        super().on_render(console)
+
+        if self.engine.player.x <= 30:
+            x = 40
+        else:
+            x = 0
+
+        console.draw_frame(
+            x=x,
+            y=0,
+            width=35,
+            height=8,
+            title=self.TITLE,
+            clear=True,
+            fg=(255, 255, 255),
+            bg=(0, 0, 0),
+        )
+
+        console.print(x=x + 1, y=1, string="Congratulations! You level up!")
+        console.print(x=x + 1, y=2, string="Select an attribute to increase.")
+
+        console.print(
+            x=x + 1,
+            y=4,
+            string=f"a) Constitution (+20 HP, from {self.engine.player.fighter.max_hp})",
+        )
+        console.print(
+            x=x + 1,
+            y=5,
+            string=f"b) Strength (+1 attack, from {self.engine.player.fighter.power})",
+        )
+        console.print(
+            x=x + 1,
+            y=6,
+            string=f"c) Agility (+1 defense, from {self.engine.player.fighter.defense})",
+        )
+
+    def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[ActionOrHandler]:
+        player = self.engine.player
+        key = event.sym
+        index = key - tcod.event.KeySym.A
+
+        if 0 <= index <= 2:
+            if index == 0:
+                player.level.increase_max_hp()
+            elif index == 1:
+                player.level.increase_power()
+            else:
+                player.level.increase_defense()
+        else:
+            self.engine.message_log.add_message("Invalid entry.", game.color.invalid)
+
+            return None
+
+        return super().ev_keydown(event)
+
+    def ev_mousebuttondown(self, event: tcod.event.MouseButtonDown) -> Optional[ActionOrHandler]:
+        """
+        Don't allow the player to click to exit the menu, like normal.
+        """
+        return None