Part 9: Ranged Scrolls and Targeting

Author: jmccardle

game/actions.py

@@ -126,7 +126,7 @@ def __init__(self, entity: game.entity.Actor):
     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

game/color.py

@@ -12,6 +12,11 @@
 welcome_text = (0x20, 0xA0, 0xFF)
 health_recovered = (0x0, 0xFF, 0x0)
 
+needs_target = (0x3F, 0xFF, 0xFF)
+status_effect_applied = (0x3F, 0xFF, 0x3F)
+
 bar_text = white
 bar_filled = (0x0, 0x60, 0x0)
 bar_empty = (0x40, 0x10, 0x10)
+
+red = (0xFF, 0x00, 0x00)

game/components/ai.py

@@ -1,6 +1,7 @@
 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
 import tcod
@@ -69,7 +70,48 @@ 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()
+
+
+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: game.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.
+            # 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()

game/components/consumable.py

@@ -4,8 +4,10 @@
 
 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.entity
@@ -51,3 +53,100 @@ def activate(self, action: game.actions.ItemAction) -> None:
             self.consume()
         else:
             raise game.exceptions.Impossible("Your health is already full.")
+
+
+class LightningDamageConsumable(Consumable):
+    def __init__(self, damage: int, maximum_range: int):
+        self.damage = damage
+        self.maximum_range = maximum_range
+
+    def activate(self, action: game.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"A lighting bolt strikes the {target.name} with a loud thunder, for {self.damage} damage!"
+            )
+            target.fighter.take_damage(self.damage)
+            self.consume()
+        else:
+            raise game.exceptions.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: game.entity.Actor) -> Optional[game.input_handlers.ActionOrHandler]:
+        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),
+        )
+
+    def activate(self, action: game.actions.ItemAction) -> None:
+        consumer = action.entity
+        target = action.target_actor
+
+        if not self.engine.game_map.visible[action.target_xy]:
+            raise game.exceptions.Impossible("You cannot target an area that you cannot see.")
+        if not target:
+            raise game.exceptions.Impossible("You must select an enemy to target.")
+        if target is consumer:
+            raise game.exceptions.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!",
+            game.color.status_effect_applied,
+        )
+        target.ai = game.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: game.entity.Actor) -> Optional[game.input_handlers.ActionOrHandler]:
+        self.engine.message_log.add_message(
+            "Select a target location.", game.color.needs_target
+        )
+        return game.input_handlers.AreaRangedAttackHandler(
+            self.engine,
+            radius=self.radius,
+            callback=lambda xy: game.actions.ItemAction(consumer, self.parent, xy),
+        )
+
+    def activate(self, action: game.actions.ItemAction) -> None:
+        target_xy = action.target_xy
+
+        if not self.engine.game_map.visible[target_xy]:
+            raise game.exceptions.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 game.exceptions.Impossible("There are no targets in the radius.")
+        self.consume()

game/entity.py

@@ -9,7 +9,7 @@
     import game.components.consumable
     import game.components.fighter
     import game.components.inventory
-    
+
 import game.game_map
 
 
@@ -40,7 +40,7 @@ def __init__(
         if parent:
             # If parent isn't provided now then it will be set later.
             self.parent = parent
-            if hasattr(parent, 'entities'):
+            if hasattr(parent, "entities"):
                 parent.entities.add(self)
 
     @property
@@ -66,6 +66,12 @@ def move(self, dx: int, dy: int) -> None:
         self.x += dx
         self.y += dy
 
+    def distance(self, x: int, y: int) -> float:
+        """
+        Return the distance between the current entity and the given (x, y) coordinate.
+        """
+        return float(((x - self.x) ** 2 + (y - self.y) ** 2) ** 0.5)
+
 
 class Actor(Entity):
     def __init__(

game/entity_factories.py

@@ -1,5 +1,10 @@
 from game.components.ai import HostileEnemy
-from game.components.consumable import HealingConsumable
+from game.components.consumable import (
+    ConfusionConsumable,
+    FireballDamageConsumable,
+    HealingConsumable,
+    LightningDamageConsumable,
+)
 from game.components.fighter import Fighter
 from game.components.inventory import Inventory
 from game.entity import Actor, Item
@@ -37,3 +42,24 @@
     name="Health Potion",
     consumable=HealingConsumable(amount=4),
 )
+
+lightning_scroll = Item(
+    char="~",
+    color=(255, 255, 0),
+    name="Lightning Scroll",
+    consumable=LightningDamageConsumable(damage=20, maximum_range=5),
+)
+
+confusion_scroll = Item(
+    char="~",
+    color=(207, 63, 255),
+    name="Confusion Scroll",
+    consumable=ConfusionConsumable(number_of_turns=10),
+)
+
+fireball_scroll = Item(
+    char="~",
+    color=(255, 0, 0),
+    name="Fireball Scroll",
+    consumable=FireballDamageConsumable(damage=12, radius=3),
+)

game/input_handlers.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING, Union
+from typing import Callable, Optional, Tuple, TYPE_CHECKING, Union
 
 from tcod import libtcodpy
 import tcod.event
@@ -382,3 +382,51 @@ class LookHandler(SelectIndexHandler):
     def on_index_selected(self, x: int, y: int) -> MainGameEventHandler:
         """Return to main handler."""
         return MainGameEventHandler(self.engine)
+
+
+class SingleRangedAttackHandler(SelectIndexHandler):
+    """Handles targeting a single enemy. Only the enemy selected will be affected."""
+
+    def __init__(
+        self, engine: game.engine.Engine, callback: Callable[[Tuple[int, int]], Optional[game.actions.Action]]
+    ):
+        super().__init__(engine)
+
+        self.callback = callback
+
+    def on_index_selected(self, x: int, y: int) -> Optional[game.actions.Action]:
+        return self.callback((x, y))
+
+
+class AreaRangedAttackHandler(SelectIndexHandler):
+    """Handles targeting an area within a given radius. Any entity within the area will be affected."""
+
+    def __init__(
+        self,
+        engine: game.engine.Engine,
+        radius: int,
+        callback: Callable[[Tuple[int, int]], Optional[game.actions.Action]],
+    ):
+        super().__init__(engine)
+
+        self.radius = radius
+        self.callback = callback
+
+    def on_render(self, console: tcod.console.Console) -> None:
+        """Highlight the tile under the cursor."""
+        super().on_render(console)
+
+        x, y = self.engine.mouse_location
+
+        # Draw a rectangle around the targeted area, so the player can see the affected tiles.
+        console.draw_frame(
+            x=x - self.radius - 1,
+            y=y - self.radius - 1,
+            width=self.radius**2,
+            height=self.radius**2,
+            fg=game.color.red,
+            clear=False,
+        )
+
+    def on_index_selected(self, x: int, y: int) -> Optional[game.actions.Action]:
+        return self.callback((x, y))

game/procgen.py

@@ -83,7 +83,16 @@ def place_entities(
         y = random.randint(room.y1 + 1, room.y2 - 1)
 
         if not any(entity.x == x and entity.y == y for entity in dungeon.entities):
-            item = copy.deepcopy(game.entity_factories.health_potion)
+            item_chance = random.random()
+
+            if item_chance < 0.7:
+                item = copy.deepcopy(game.entity_factories.health_potion)
+            elif item_chance < 0.8:
+                item = copy.deepcopy(game.entity_factories.fireball_scroll)
+            elif item_chance < 0.9:
+                item = copy.deepcopy(game.entity_factories.confusion_scroll)
+            else:
+                item = copy.deepcopy(game.entity_factories.lightning_scroll)
 
             item.place(x, y, dungeon)