finished parts 8 and 9!

Author: jossse69

actions.py

@@ -3,10 +3,10 @@
 from typing import Optional, Tuple, TYPE_CHECKING
 
 import color
-
+import exceptions
 if TYPE_CHECKING:
     from engine import Engine
-    from entity import Actor, Entity
+    from entity import Actor, Entity, Item
 
 
 class Action:
@@ -17,7 +17,7 @@ def __init__(self, entity: Actor) -> None:
     @property
     def engine(self) -> Engine:
         """Return the engine this action belongs to."""
-        return self.entity.gamemap.engine
+        return self.entity.parent.engine
 
     def perform(self) -> None:
         """Perform this action with the objects needed to determine its scope.
@@ -55,16 +55,30 @@ def blocking_entity(self) -> Optional[Entity]:
         """Return the blocking entity at this actions destination.."""
         return self.engine.game_map.get_blocking_entity_at_location(*self.dest_xy)
 
-class EscapeAction(Action):
+class ItemAction(Action):
+    def __init__(
+        self, entity: Actor, item: 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[Actor]:
+        """Return the actor at this actions destination."""
+        return self.engine.game_map.get_actor_at_location(*self.target_xy)
 
     def perform(self) -> None:
-        raise SystemExit()
+        """Invoke the items ability, this action will be given to provide context."""
+        self.item.consumable.activate(self)
 
 class MeleeAction(ActionWithDirection):
     def perform(self) -> None:
         target = self.target_actor
         if not target:
-            return  # No entity to attack.
+            raise exceptions.Impossible("Nothing to attack.")
 
         damage = self.entity.fighter.power - target.fighter.defense
 
@@ -90,11 +104,14 @@ def perform(self) -> None:
         dest_x, dest_y = self.dest_xy
 
         if not self.engine.game_map.in_bounds(dest_x, dest_y):
-            return  # Destination is out of bounds.
+            # Destination is out of bounds.
+            raise exceptions.Impossible("That way is blocked.")
         if not self.engine.game_map.tiles["walkable"][dest_x, dest_y]:
-            return  # Destination is blocked by a tile.
+            # Destination is blocked by a tile.
+            raise exceptions.Impossible("That way is blocked.")
         if self.engine.game_map.get_blocking_entity_at_location(dest_x, dest_y):
-            return  # Destination is blocked by an entity.
+            # Destination is blocked by an entity.
+            raise exceptions.Impossible("There's something blocking the way!")
 
 
         self.entity.move(self.dx, self.dy)
@@ -110,4 +127,42 @@ def perform(self) -> None:
 
 class WaitAction(Action):
     def perform(self) -> None:
-        pass
+        pass
+
+class PickupAction(Action):
+    """Pickup an item and add it to the inventory, if there is room for it."""
+
+    def __init__(self, entity: Actor):
+        super().__init__(entity)
+
+    def perform(self) -> None:
+        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 exceptions.Impossible("Your inventory is full.")
+
+                self.engine.game_map.entities.remove(item)
+                item.parent = self.entity.inventory
+                inventory.items.append(item)
+
+                self.engine.message_log.add_message(f"You picked up the {item.name}!")
+                return
+
+        raise exceptions.Impossible("There is nothing here to pick up.")
+
+class DropItem(ItemAction):
+    def perform(self) -> None:
+        self.entity.inventory.drop(self.item)
+
+class InspectAction(Action):
+    def __init__(self, actor: Actor, target: Entity):
+        super().__init__(actor)
+
+        self.message = target.inspect_message
+
+    def perform(self) -> None:
+        self.engine.message_log.add_message(self.message.upper(), color.text_console)

color.py

@@ -1,14 +1,23 @@
 white = (255, 255, 255)
 black = (0, 0, 0)
+red = (255, 0, 0)
 
 player_atk = (255, 153, 0)
 enemy_atk = (153, 0, 0)
+needs_target = (51, 153, 255)
+status_effect_applied = (153, 0, 255)
 
 player_die = (255, 0, 0)
 enemy_die = (255, 255, 0)
 
+invalid = (255, 255, 0)
+impossible = (255, 153, 153)
+error = (204, 0, 0)
+
 text_console = (204, 255, 51)
 
 bar_text = white
 bar_filled = (255, 0, 0)
-bar_empty = (77, 0, 0)
+bar_empty = (77, 0, 0)
+
+health_recovered = (102, 255, 102)

components/ai.py

@@ -1,19 +1,20 @@
 from __future__ import annotations
 
-from typing import List, Tuple, TYPE_CHECKING
+import random
+from typing import List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np  # type: ignore
 import tcod
 
-from actions import Action, MeleeAction, MovementAction, WaitAction
-from components.base_component import BaseComponent
+from actions import Action, BumpAction, MeleeAction, MovementAction, WaitAction
+
 
 if TYPE_CHECKING:
     from entity import Actor
 
 
-class BaseAI(Action, BaseComponent):
-    entity: Actor
+class BaseAI(Action):
+
     def perform(self) -> None:
         raise NotImplementedError()
 
@@ -69,4 +70,46 @@ def perform(self) -> None:
                 self.entity, dest_x - self.entity.x, dest_y - self.entity.y,
             ).perform()
 
-        return WaitAction(self.entity).perform()
+        return WaitAction(self.entity).perform()
+    
+class ConfusedEnemy(BaseAI):
+    """
+    A confused enemy will stumble around aimlessly for a given number of turns, then revert back to its previous AI.
+    If an actor occupies a tile it is randomly moving into, it will attack.
+    """
+
+    def __init__(
+        self, entity: Actor, previous_ai: Optional[BaseAI], turns_remaining: int
+    ):
+        super().__init__(entity)
+
+        self.previous_ai = previous_ai
+        self.turns_remaining = turns_remaining
+
+    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.entity.ai = self.previous_ai
+        else:
+            # Pick a random direction
+            direction_x, direction_y = random.choice(
+                [
+                    (-1, -1),  # Northwest
+                    (0, -1),  # North
+                    (1, -1),  # Northeast
+                    (-1, 0),  # West
+                    (1, 0),  # East
+                    (-1, 1),  # Southwest
+                    (0, 1),  # South
+                    (1, 1),  # Southeast
+                ]
+            )
+
+            self.turns_remaining -= 1
+
+            # The actor will either try to move or attack in the chosen random direction.
+            # Its possible the actor will just bump into the wall, wasting a turn.
+            return BumpAction(self.entity, direction_x, direction_y,).perform()

components/base_component.py

@@ -5,11 +5,16 @@
 if TYPE_CHECKING:
     from engine import Engine
     from entity import Entity
+    from game_map import GameMap
 
 
 class BaseComponent:
-    entity: Entity  # Owning entity instance.
+    parent: Entity  # Owning entity instance.
 
+    @property
+    def gamemap(self) -> GameMap:
+        return self.parent.gamemap
+    
     @property
     def engine(self) -> Engine:
-        return self.entity.gamemap.engine
+        return self.gamemap.engine

components/consumable.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING
+
+import actions
+import color
+import components.ai
+import components.inventory
+from components.base_component import BaseComponent
+from exceptions import Impossible
+from input_handlers import AreaRangedAttackHandler, SingleRangedAttackHandler
+
+if TYPE_CHECKING:
+    from entity import Actor, Item
+
+
+class Consumable(BaseComponent):
+    parent: Item
+
+    def get_action(self, consumer: Actor) -> Optional[actions.Action]:
+        """Try to return the action for this item."""
+        return actions.ItemAction(consumer, self.parent)
+
+    def activate(self, action: 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, components.inventory.Inventory):
+            inventory.items.remove(entity)
+
+
+
+class HealingConsumable(Consumable):
+    def __init__(self, amount: int):
+        self.amount = amount
+
+    def activate(self, action: actions.ItemAction) -> None:
+        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!",
+                color.health_recovered,
+            )
+            self.consume()
+        else:
+            raise Impossible(f"Your health is already full.")
+
+class EletricDamageConsumable(Consumable):
+    def __init__(self, damage: int, maximum_range: int):
+        self.damage = damage
+        self.maximum_range = maximum_range
+
+    def activate(self, action: actions.ItemAction) -> None:
+        consumer = action.entity
+        target = None
+        closest_distance = self.maximum_range + 1.0
+
+        for actor in self.engine.game_map.actors:
+            if actor is not consumer and self.parent.gamemap.visible[actor.x, actor.y]:
+                distance = consumer.distance(actor.x, actor.y)
+
+                if distance < closest_distance:
+                    target = actor
+                    closest_distance = distance
+
+        if target:
+            self.engine.message_log.add_message(
+                f"ZAP! A bright eletric bolt strikes the {target.name} for {self.damage} damage!"
+            )
+            target.fighter.take_damage(self.damage)
+            self.consume()
+        else:
+            raise Impossible("No enemy is close enough to strike.")
+        
+class ConfusionConsumable(Consumable):
+    def __init__(self, number_of_turns: int):
+        self.number_of_turns = number_of_turns
+
+    def get_action(self, consumer: Actor) -> Optional[actions.Action]:
+        self.engine.message_log.add_message(
+            "Select a target location.", color.needs_target
+        )
+        self.engine.event_handler = SingleRangedAttackHandler(
+            self.engine,
+            callback=lambda xy: actions.ItemAction(consumer, self.parent, xy),
+        )
+        return None
+
+    def activate(self, action: actions.ItemAction) -> None:
+        consumer = action.entity
+        target = action.target_actor
+
+        if not self.engine.game_map.visible[action.target_xy]:
+            raise Impossible("You cannot target an area that you cannot see.")
+        if not target:
+            raise Impossible("You must select an enemy to target.")
+        if target is consumer:
+            raise Impossible("You cannot confuse yourself!")
+
+        self.engine.message_log.add_message(
+            f"The eyes of the {target.name} look vacant, as it starts to stumble around!",
+            color.status_effect_applied,
+        )
+        target.ai = components.ai.ConfusedEnemy(
+            entity=target, previous_ai=target.ai, turns_remaining=self.number_of_turns,
+        )
+        self.consume()
+
+class FireballDamageConsumable(Consumable):
+    def __init__(self, damage: int, radius: int):
+        self.damage = damage
+        self.radius = radius
+
+    def get_action(self, consumer: Actor) -> Optional[actions.Action]:
+        self.engine.message_log.add_message(
+            "Select a target location.", color.needs_target
+        )
+        self.engine.event_handler = AreaRangedAttackHandler(
+            self.engine,
+            radius=self.radius,
+            callback=lambda xy: actions.ItemAction(consumer, self.parent, xy),
+        )
+        return None
+
+    def activate(self, action: actions.ItemAction) -> None:
+        target_xy = action.target_xy
+
+        if not self.engine.game_map.visible[target_xy]:
+            raise Impossible("You cannot target an area that you cannot see.")
+
+        targets_hit = False
+        for actor in self.engine.game_map.actors:
+            if actor.distance(*target_xy) <= self.radius:
+                self.engine.message_log.add_message(
+                    f"The {actor.name} is engulfed in a fiery explosion, taking {self.damage} damage!"
+                )
+                actor.fighter.take_damage(self.damage)
+                targets_hit = True
+
+        if not targets_hit:
+            raise Impossible("There are no targets in the radius.")
+        self.consume()