Part 11: Delving into the Dungeon

Author: jmccardle

game/actions.py

@@ -2,7 +2,7 @@
 
 from typing import TYPE_CHECKING, Optional, Tuple
 
-from game.color import enemy_atk, player_atk
+from game.color import descend, enemy_atk, player_atk
 from game.entity import Actor
 from game.exceptions import Impossible
 
@@ -173,3 +173,15 @@ def perform(self) -> None:
         # Type check to ensure entity is an Actor with inventory
         assert isinstance(self.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.", 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,28 +1,28 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union
 
-from game.actions import Action, ItemAction
-from game.color import health_recovered
-from game.components.ai import ConfusedEnemy
-from game.components.base_component import BaseComponent
-from game.components.inventory import Inventory
-from game.entity import Actor, Item
-from game.exceptions import Impossible
-from game.input_handlers import ActionOrHandler, AreaRangedAttackHandler, SingleRangedAttackHandler
+import game.actions
+import game.color
+import game.components.ai
+import game.components.base_component
+import game.exceptions
+import game.input_handlers
 
 if TYPE_CHECKING:
-    import game.actions
+    import game.entity
 
 
-class Consumable(BaseComponent):
-    parent: Item
+class Consumable(game.components.base_component.BaseComponent):
+    parent: game.entity.Item
 
-    def get_action(self, consumer: Actor) -> Optional[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 ItemAction(consumer, self.parent)
+        return game.actions.ItemAction(consumer, self.parent)
 
-    def activate(self, action: ItemAction) -> None:
+    def activate(self, action: game.actions.ItemAction) -> None:
         """Invoke this items ability.
 
         `action` is the context for this activation.
@@ -33,28 +33,28 @@ def consume(self) -> None:
         """Remove the consumed item from its containing inventory."""
         entity = self.parent
         inventory = entity.parent
-        if isinstance(inventory, Inventory):
+        if isinstance(inventory, game.components.inventory.Inventory):
             inventory.items.remove(entity)
 
 
 class HealingConsumable(Consumable):
     def __init__(self, amount: int):
         self.amount = amount
 
-    def activate(self, action: ItemAction) -> None:
+    def activate(self, action: game.actions.ItemAction) -> None:
         # Type check to ensure consumer is an Actor
-        assert isinstance(action.entity, Actor), "Consumer must be an Actor"
+        assert isinstance(action.entity, game.entity.Actor), "Consumer must be an Actor"
         consumer = action.entity
         amount_recovered = consumer.fighter.heal(self.amount)
 
         if amount_recovered > 0:
             self.engine.message_log.add_message(
                 f"You consume the {self.parent.name}, and recover {amount_recovered} HP!",
-                health_recovered,
+                game.color.health_recovered,
             )
             self.consume()
         else:
-            raise Impossible("Your health is already full.")
+            raise game.exceptions.Impossible("Your health is already full.")
 
 
 class LightningDamageConsumable(Consumable):
@@ -89,9 +89,9 @@ class ConfusionConsumable(Consumable):
     def __init__(self, number_of_turns: int):
         self.number_of_turns = number_of_turns
 
-    def get_action(self, consumer: Actor) -> Optional[ActionOrHandler]:
+    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)
-        return SingleRangedAttackHandler(
+        return game.input_handlers.SingleRangedAttackHandler(
             self.engine,
             callback=lambda xy: game.actions.ItemAction(consumer, self.parent, xy),
         )
@@ -111,7 +111,7 @@ def activate(self, action: game.actions.ItemAction) -> None:
             f"The eyes of the {target.name} look vacant, as it starts to stumble around!",
             game.color.status_effect_applied,
         )
-        target.ai = ConfusedEnemy(
+        target.ai = game.components.ai.ConfusedEnemy(
             entity=target,
             previous_ai=target.ai,
             turns_remaining=self.number_of_turns,
@@ -124,9 +124,9 @@ def __init__(self, damage: int, radius: int):
         self.damage = damage
         self.radius = radius
 
-    def get_action(self, consumer: Actor) -> Optional[ActionOrHandler]:
+    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)
-        return AreaRangedAttackHandler(
+        return game.input_handlers.AreaRangedAttackHandler(
             self.engine,
             radius=self.radius,
             callback=lambda xy: game.actions.ItemAction(consumer, self.parent, xy),

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

@@ -6,22 +6,23 @@
 
 import tcod
 
-from game.color import welcome_text
-from game.entity import Actor
-from game.message_log import MessageLog
-from game.render_functions import render_bar, render_names_at_mouse_location
+import game.color
+import game.entity
+import game.message_log
+import game.render_functions
 
 if TYPE_CHECKING:
     import game.game_map
 
 
 class Engine:
     game_map: game.game_map.GameMap
+    game_world: game.game_map.GameWorld
 
-    def __init__(self, player: Actor):
+    def __init__(self, player: game.entity.Actor):
         self.player = player
         self.mouse_location = (0, 0)
-        self.message_log = MessageLog()
+        self.message_log = game.message_log.MessageLog()
 
     def update_fov(self) -> None:
         """Recompute the visible area based on the players point of view."""
@@ -45,14 +46,26 @@ def render(self, console: tcod.console.Console) -> None:
 
         self.message_log.render(console=console, x=21, y=45, width=40, height=5)
 
-        render_bar(
+        game.render_functions.render_bar(
             console=console,
             current_value=self.player.fighter.hp,
             maximum_value=self.player.fighter.max_hp,
             total_width=20,
         )
 
-        render_names_at_mouse_location(console=console, x=21, y=44, engine=self)
+        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:
         """Save this Engine instance as a compressed file."""

game/entity.py

@@ -2,15 +2,16 @@
 
 from typing import TYPE_CHECKING, Optional, Tuple, Type, Union
 
+from game.game_map import GameMap
 from game.render_order import RenderOrder
 
 if TYPE_CHECKING:
     import game.components.ai
     import game.components.consumable
     import game.components.fighter
     import game.components.inventory
-
-from game.game_map import GameMap
+    import game.components.level
+    import game.game_map
 
 
 class Entity:
@@ -85,6 +86,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 +106,9 @@ def __init__(
         self.inventory = inventory
         self.inventory.parent = self
 
+        self.level = level
+        self.level.parent = self
+
         self.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(