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/ai.py

@@ -70,7 +70,9 @@ def perform(self) -> None:
         if self.path:
             dest_x, dest_y = self.path.pop(0)
             return game.actions.MovementAction(
-                self.entity, dest_x - self.entity.x, dest_y - self.entity.y,
+                self.entity,
+                dest_x - self.entity.x,
+                dest_y - self.entity.y,
             ).perform()
 
 
@@ -80,9 +82,7 @@ class ConfusedEnemy(BaseAI):
     If an actor occupies a tile it is randomly moving into, it will attack.
     """
 
-    def __init__(
-        self, entity: game.entity.Actor, previous_ai: Optional[BaseAI], turns_remaining: int
-    ):
+    def __init__(self, entity: game.entity.Actor, previous_ai: Optional[BaseAI], turns_remaining: int):
         super().__init__(entity)
 
         self.previous_ai = previous_ai
@@ -91,9 +91,7 @@ def __init__(
     def perform(self) -> None:
         # Revert the AI back to the original state if the effect has run its course.
         if self.turns_remaining <= 0:
-            self.engine.message_log.add_message(
-                f"The {self.entity.name} is no longer confused."
-            )
+            self.engine.message_log.add_message(f"The {self.entity.name} is no longer confused.")
             self.entity.ai = self.previous_ai
         else:
             # Pick a random direction
@@ -114,4 +112,8 @@ def perform(self) -> None:
 
             # The actor will either try to move or attack in the chosen random direction.
             # It's possible the actor will just bump into the wall, wasting a turn.
-            return game.actions.BumpAction(self.entity, direction_x, direction_y,).perform()
+            return game.actions.BumpAction(
+                self.entity,
+                direction_x,
+                direction_y,
+            ).perform()

game/components/consumable.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Union
 
 import game.actions
 import game.color
@@ -16,7 +16,7 @@
 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)
 
@@ -88,9 +88,7 @@ def __init__(self, number_of_turns: int):
         self.number_of_turns = number_of_turns
 
     def get_action(self, consumer: game.entity.Actor) -> Optional[game.input_handlers.ActionOrHandler]:
-        self.engine.message_log.add_message(
-            "Select a target location.", game.color.needs_target
-        )
+        self.engine.message_log.add_message("Select a target location.", game.color.needs_target)
         return game.input_handlers.SingleRangedAttackHandler(
             self.engine,
             callback=lambda xy: game.actions.ItemAction(consumer, self.parent, xy),
@@ -112,7 +110,9 @@ def activate(self, action: game.actions.ItemAction) -> None:
             game.color.status_effect_applied,
         )
         target.ai = game.components.ai.ConfusedEnemy(
-            entity=target, previous_ai=target.ai, turns_remaining=self.number_of_turns,
+            entity=target,
+            previous_ai=target.ai,
+            turns_remaining=self.number_of_turns,
         )
         self.consume()
 
@@ -123,9 +123,7 @@ def __init__(self, damage: int, radius: int):
         self.radius = radius
 
     def get_action(self, consumer: game.entity.Actor) -> Optional[game.input_handlers.ActionOrHandler]:
-        self.engine.message_log.add_message(
-            "Select a target location.", game.color.needs_target
-        )
+        self.engine.message_log.add_message("Select a target location.", game.color.needs_target)
         return game.input_handlers.AreaRangedAttackHandler(
             self.engine,
             radius=self.radius,

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 Iterator, Optional, Set, TYPE_CHECKING
+from typing import Iterable, Iterator, Optional, Set, TYPE_CHECKING
 
 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,
+        )