Part 8: Items and Inventory (with entity parent system refactor and Part 10 refactoring)

Author: jmccardle

game/actions.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, Tuple, TYPE_CHECKING
 
 import game.color
+import game.exceptions
 
 if TYPE_CHECKING:
     import game.engine
     import game.entity
+    import game.components.inventory
 
 
 class Action:
@@ -113,3 +115,60 @@ def perform(self) -> None:
             return MeleeAction(self.entity, self.dx, self.dy).perform()
         else:
             return MovementAction(self.entity, self.dx, self.dy).perform()
+
+
+class PickupAction(Action):
+    """Pickup an item and add it to the inventory, if there is room for it."""
+
+    def __init__(self, entity: game.entity.Actor):
+        super().__init__(entity)
+
+    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"
+        
+        actor_location_x = self.entity.x
+        actor_location_y = self.entity.y
+        inventory = self.entity.inventory
+
+        for item in self.engine.game_map.items:
+            if actor_location_x == item.x and actor_location_y == item.y:
+                if len(inventory.items) >= inventory.capacity:
+                    raise game.exceptions.Impossible("Your inventory is full.")
+
+                self.engine.game_map.entities.remove(item)
+                item.parent = inventory
+                inventory.items.append(item)
+
+                self.engine.message_log.add_message(f"You picked up the {item.name}!")
+                return
+
+        raise game.exceptions.Impossible("There is nothing here to pick up.")
+
+
+class ItemAction(Action):
+    def __init__(self, entity: game.entity.Actor, item: game.entity.Item, target_xy: Optional[Tuple[int, int]] = None):
+        super().__init__(entity)
+        self.item = item
+        if not target_xy:
+            target_xy = entity.x, entity.y
+        self.target_xy = target_xy
+
+    @property
+    def target_actor(self) -> Optional[game.entity.Actor]:
+        """Return the actor at this actions destination."""
+        return self.engine.game_map.get_actor_at_location(*self.target_xy)
+
+    def perform(self) -> None:
+        """Invoke the items ability, this action will be given to provide context."""
+        if self.item.consumable is not None:
+            self.item.consumable.activate(self)
+        else:
+            raise game.exceptions.Impossible("This item cannot be used.")
+
+
+class DropItem(ItemAction):
+    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)

game/color.py

@@ -6,7 +6,11 @@
 player_die = (0xFF, 0x30, 0x30)
 enemy_die = (0xFF, 0xA0, 0x30)
 
+impossible = (0x80, 0x80, 0x80)
+invalid = (0xFF, 0xFF, 0x00)
+
 welcome_text = (0x20, 0xA0, 0xFF)
+health_recovered = (0x0, 0xFF, 0x0)
 
 bar_text = white
 bar_filled = (0x0, 0x60, 0x0)

game/components/consumable.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING
+
+import game.actions
+import game.color
+import game.components.base_component
+import game.exceptions
+
+if TYPE_CHECKING:
+    import game.entity
+
+
+class Consumable(game.components.base_component.BaseComponent):
+    parent: game.entity.Item
+
+    def get_action(self, consumer: game.entity.Actor) -> Optional[game.actions.Action]:
+        """Try to return the action for this item."""
+        return game.actions.ItemAction(consumer, self.parent)
+
+    def activate(self, action: game.actions.ItemAction) -> None:
+        """Invoke this items ability.
+
+        `action` is the context for this activation.
+        """
+        raise NotImplementedError()
+
+    def consume(self) -> None:
+        """Remove the consumed item from its containing inventory."""
+        entity = self.parent
+        inventory = entity.parent
+        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: game.actions.ItemAction) -> None:
+        # Type check to ensure consumer is 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!",
+                game.color.health_recovered,
+            )
+            self.consume()
+        else:
+            raise game.exceptions.Impossible("Your health is already full.")

game/components/fighter.py

@@ -48,3 +48,21 @@ def die(self) -> None:
         self.parent.render_order = game.render_order.RenderOrder.CORPSE
 
         self.engine.message_log.add_message(death_message, death_message_color)
+
+    def heal(self, amount: int) -> int:
+        if self.hp == self.max_hp:
+            return 0
+
+        new_hp_value = self.hp + amount
+
+        if new_hp_value > self.max_hp:
+            new_hp_value = self.max_hp
+
+        amount_recovered = new_hp_value - self.hp
+
+        self.hp = new_hp_value
+
+        return amount_recovered
+
+    def take_damage(self, amount: int) -> None:
+        self.hp -= amount

game/components/inventory.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import List, TYPE_CHECKING
+
+import game.components.base_component
+
+if TYPE_CHECKING:
+    import game.entity
+    import game.game_map
+
+
+class Inventory(game.components.base_component.BaseComponent):
+    parent: game.entity.Actor
+
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.items: List[game.entity.Item] = []
+
+    @property
+    def gamemap(self) -> game.game_map.GameMap:
+        return self.parent.gamemap
+
+    def drop(self, item: game.entity.Item) -> None:
+        """
+        Removes an item from the inventory and restores it to the game map, at the player's current location.
+        """
+        self.items.remove(item)
+        item.place(self.parent.x, self.parent.y, self.gamemap)
+
+        self.engine.message_log.add_message(f"You dropped the {item.name}.")

game/entity.py

@@ -1,26 +1,28 @@
 from __future__ import annotations
 
-from typing import Optional, Tuple, Type, TYPE_CHECKING
+from typing import Optional, Tuple, Type, Union, TYPE_CHECKING
 
 import game.render_order
 
 if TYPE_CHECKING:
     import game.components.ai
+    import game.components.consumable
     import game.components.fighter
-    import game.game_map
+    import game.components.inventory
+    
+import game.game_map
 
 
 class Entity:
     """
     A generic object to represent players, enemies, items, etc.
     """
 
-    # Part 8 refactoring prep: Will become Union[GameMap, Inventory] in Part 8
-    gamemap: Optional[game.game_map.GameMap]
+    parent: Union[game.game_map.GameMap, game.components.inventory.Inventory]
 
     def __init__(
         self,
-        gamemap: Optional[game.game_map.GameMap] = None,
+        parent: Optional[Union[game.game_map.GameMap, game.components.inventory.Inventory]] = None,
         x: int = 0,
         y: int = 0,
         char: str = "?",
@@ -35,19 +37,28 @@ def __init__(
         self.name = name
         self.blocks_movement = blocks_movement
         self.render_order = game.render_order.RenderOrder.CORPSE
-        if gamemap:
-            # If gamemap isn't provided now then it will be set later.
-            self.gamemap = gamemap
-            gamemap.entities.add(self)
+        if parent:
+            # If parent isn't provided now then it will be set later.
+            self.parent = parent
+            if hasattr(parent, 'entities'):
+                parent.entities.add(self)
+
+    @property
+    def gamemap(self) -> game.game_map.GameMap:
+        if isinstance(self.parent, game.game_map.GameMap):
+            return self.parent
+        else:
+            return self.parent.gamemap
 
     def place(self, x: int, y: int, gamemap: Optional[game.game_map.GameMap] = None) -> None:
         """Place this entity at a new location. Handles moving across GameMaps."""
         self.x = x
         self.y = y
         if gamemap:
-            if hasattr(self, "gamemap") and self.gamemap is not None:  # Possibly uninitialized.
-                self.gamemap.entities.remove(self)
-            self.gamemap = gamemap
+            if hasattr(self, "parent"):  # Possibly uninitialized.
+                if hasattr(self.parent, "entities"):
+                    self.parent.entities.remove(self)
+            self.parent = gamemap
             gamemap.entities.add(self)
 
     def move(self, dx: int, dy: int) -> None:
@@ -67,9 +78,10 @@ def __init__(
         name: str = "<Unnamed>",
         ai_cls: Type[game.components.ai.BaseAI],
         fighter: game.components.fighter.Fighter,
+        inventory: game.components.inventory.Inventory,
     ):
         super().__init__(
-            gamemap=None,
+            parent=None,
             x=x,
             y=y,
             char=char,
@@ -83,9 +95,41 @@ def __init__(
         self.fighter = fighter
         self.fighter.parent = self
 
+        self.inventory = inventory
+        self.inventory.parent = self
+
         self.render_order = game.render_order.RenderOrder.ACTOR
 
     @property
     def is_alive(self) -> bool:
         """Returns True as long as this actor can perform actions."""
         return bool(self.ai)
+
+
+class Item(Entity):
+    def __init__(
+        self,
+        *,
+        x: int = 0,
+        y: int = 0,
+        char: str = "?",
+        color: Tuple[int, int, int] = (255, 255, 255),
+        name: str = "<Unnamed>",
+        consumable: Optional[game.components.consumable.Consumable] = None,
+    ):
+        super().__init__(
+            parent=None,
+            x=x,
+            y=y,
+            char=char,
+            color=color,
+            name=name,
+            blocks_movement=False,
+        )
+
+        self.consumable = consumable
+
+        if self.consumable:
+            self.consumable.parent = self
+
+        self.render_order = game.render_order.RenderOrder.ITEM

game/entity_factories.py

@@ -1,13 +1,16 @@
 from game.components.ai import HostileEnemy
+from game.components.consumable import HealingConsumable
 from game.components.fighter import Fighter
-from game.entity import Actor
+from game.components.inventory import Inventory
+from game.entity import Actor, Item
 
 player = Actor(
     char="@",
     color=(255, 255, 255),
     name="Player",
     ai_cls=HostileEnemy,
     fighter=Fighter(hp=30, defense=2, power=5),
+    inventory=Inventory(capacity=26),
 )
 
 orc = Actor(
@@ -16,6 +19,7 @@
     name="Orc",
     ai_cls=HostileEnemy,
     fighter=Fighter(hp=10, defense=0, power=3),
+    inventory=Inventory(capacity=0),
 )
 
 troll = Actor(
@@ -24,4 +28,12 @@
     name="Troll",
     ai_cls=HostileEnemy,
     fighter=Fighter(hp=16, defense=1, power=4),
+    inventory=Inventory(capacity=0),
+)
+
+health_potion = Item(
+    char="!",
+    color=(127, 0, 255),
+    name="Health Potion",
+    consumable=HealingConsumable(amount=4),
 )

game/exceptions.py

@@ -0,0 +1,5 @@
+class Impossible(Exception):
+    """Exception raised when an action is impossible to be performed.
+
+    The reason is given as the exception message.
+    """

game/game_map.py

@@ -32,6 +32,10 @@ def actors(self) -> Iterator[game.entity.Actor]:
         """Iterate over this maps living actors."""
         yield from (entity for entity in self.entities if isinstance(entity, game.entity.Actor) and entity.is_alive)
 
+    @property
+    def items(self) -> Iterator[game.entity.Item]:
+        yield from (entity for entity in self.entities if isinstance(entity, game.entity.Item))
+
     def get_blocking_entity_at_location(
         self,
         location_x: int,
@@ -47,6 +51,13 @@ def get_blocking_entity_at(self, x: int, y: int) -> Optional[game.entity.Entity]
         """Alias for get_blocking_entity_at_location"""
         return self.get_blocking_entity_at_location(x, y)
 
+    def get_actor_at_location(self, x: int, y: int) -> Optional[game.entity.Actor]:
+        for actor in self.actors:
+            if actor.x == x and actor.y == y:
+                return actor
+
+        return None
+
     def in_bounds(self, x: int, y: int) -> bool:
         """Return True if x and y are inside of the bounds of this map."""
         return 0 <= x < self.width and 0 <= y < self.height