Added Status Effects to the game.

Author: jossse69

actions.py

@@ -6,9 +6,11 @@
 from entity import Actor
 import exceptions
 import random
+
 if TYPE_CHECKING:
     from engine import Engine
     from entity import Actor, Entity, Item, NPC
+    from status_effect import StatusEffect
 
 
 class Action:
@@ -83,6 +85,11 @@ def perform(self) -> None:
             self.item.consumable.activate(self)
 
 class MeleeAction(ActionWithDirection):
+
+    def __init__(self, entity: Actor, dx: int, dy: int, effect: Optional[StatusEffect] = None):
+        super().__init__(entity, dx, dy)
+        self.effect = effect
+
     def perform(self) -> None:
         target = self.target_actor
         if not target:
@@ -110,6 +117,10 @@ def perform(self) -> None:
                 attack_color
             )
             target.fighter.hp -= damage
+
+            # Apply the status effect to the target, if any.
+            if self.effect is not None:
+                target.fighter.apply_status_effect(self.effect)
         else:
             self.engine.message_log.add_message(
                 f"{attack_desc}, but does no damage.",
@@ -137,8 +148,10 @@ def perform(self) -> None:
 class BumpAction(ActionWithDirection):
     def perform(self) -> None:
         if self.target_actor:
+                self.entity.last_position = (self.entity.x, self.entity.y)
                 return MeleeAction(self.entity, self.dx, self.dy).perform()
         elif self.target_NPC:
+                self.entity.last_position = (self.entity.x, self.entity.y)
                 return InteractNPCAction(self.entity, self.dx, self.dy).perform()
         else:
             return MovementAction(self.entity, self.dx, self.dy).perform()
@@ -157,7 +170,7 @@ def perform(self) -> None:
 
 class WaitAction(Action):
     def perform(self) -> None:
-        pass
+        self.entity.last_position = (self.entity.x, self.entity.y)
 
 class PickupAction(Action):
     """Pickup an item and add it to the inventory, if there is room for it."""

components/ai.py

@@ -6,15 +6,24 @@
 import numpy as np  # type: ignore
 import tcod
 
-from actions import Action, BumpAction, MeleeAction, MovementAction, WaitAction
+from actions import Action, MeleeAction, MovementAction, WaitAction
+from entity import Actor
 
 
 if TYPE_CHECKING:
     from entity import Actor
+    from status_effect import StatusEffect
 
 
 class BaseAI(Action):
 
+    def __init__(self, entity: Actor) -> None:
+        super().__init__(entity)
+
+    def set_effect(self, effect: Optional[StatusEffect] = None) -> None:
+        self.effect = effect
+ 
+
     def perform(self) -> None:
         raise NotImplementedError()
 
@@ -52,6 +61,7 @@ def __init__(self, entity: Actor):
         super().__init__(entity)
         self.path: List[Tuple[int, int]] = []
 
+
     def perform(self) -> None:
         target = self.engine.player
         dx = target.x - self.entity.x
@@ -60,7 +70,7 @@ def perform(self) -> None:
 
         if self.engine.game_map.visible[self.entity.x, self.entity.y]:
             if distance <= 1:
-                return MeleeAction(self.entity, dx, dy).perform()
+                return MeleeAction(self.entity, dx, dy, self.effect).perform()
 
             self.path = self.get_path_to(target.x, target.y)
 
@@ -110,9 +120,8 @@ def perform(self) -> None:
 
             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()
+            # The actor will either try to move in the randomly chosen direction.
+            return MovementAction(self.entity, direction_x, direction_y,).perform()
 
 
 class SpawnerEnemy(BaseAI):

components/fighter.py

@@ -4,12 +4,14 @@
 from typing import TYPE_CHECKING
 
 import color
+import copy
 
 from components.base_component import BaseComponent
 from render_order import RenderOrder
 
 if TYPE_CHECKING:
     from entity import Actor
+    from status_effect import StatusEffect
 
 class Fighter(BaseComponent):
     parent: Actor
@@ -20,6 +22,8 @@ def __init__(self, hp: int, base_dodge: int, base_defence, base_power: int):
         self.base_dodge = base_dodge
         self.base_defence = base_defence
         self.base_power = base_power
+        self.status_effects = []
+
 
     @property
     def dodge(self) -> int:
@@ -79,6 +83,28 @@ def heal(self, amount: int) -> int:
 
         return amount_recovered
 
+    def apply_status_effect(self, effect: StatusEffect) -> None:
+        for status_effect in self.status_effects:
+            if status_effect.name == effect.name:
+                status_effect.duration += effect.duration
+                return
+        self.status_effects.append(copy.deepcopy(effect))
+
+        self.engine.message_log.add_message(f"{self.parent.name} is now {effect.name}!", color.status_effect_applied)
+
+    def update_status_effects(self) -> None:
+        for status_effect in self.status_effects:
+            status_effect.on_tick(self.parent)
+            if status_effect.duration <= 0:
+                self.status_effects.remove(status_effect)
+                self.engine.message_log.add_message(f"{self.parent.name} is no longer {status_effect.name}.")
+
+    def has_status_effect(self, effect: StatusEffect) -> bool:
+        for status_effect in self.status_effects:
+            if status_effect.name == effect.name:
+                return True
+        return False
+
     def take_damage(self, amount: int) -> None:
         self.hp -= amount
 
@@ -108,4 +134,4 @@ def die(self) -> None:
             if roll <= 45:
                 amount = self.max_hp // 4 # Give 25% of the entity's max HP as credits (rounded down).
                 self.engine.game_world.credits += amount
-                self.engine.message_log.add_message(f"You found {amount} credits!", color.health_recovered)
+                self.engine.message_log.add_message(f"You found {amount} credits!", color.health_recovered)

engine.py

@@ -37,6 +37,11 @@ def handle_enemy_turns(self) -> None:
                 except exceptions.Impossible:
                     pass  # Ignore impossible action exceptions from AI.
 
+    def handle_status_effects(self) -> None:
+        for entity in set(self.game_map.actors):
+            entity.fighter.update_status_effects()
+
+
     def update_fov(self) -> None:
         """Recompute the visible area based on the players point of view."""
 

entity.py

@@ -17,6 +17,7 @@
     from components.level import Level
     from game_map import GameMap
     from input_handlers import EventHandler
+    from status_effect import StatusEffect
 
 
 T = TypeVar("T", bound="Entity")
@@ -52,6 +53,7 @@ def __init__(
         self.render_order = render_order
         self.inspect_message = inspect_message
         self.is_swarm = False
+        self.last_position = (x, y)
         if parent:
             # If parent isn't provided now then it will be set later.
             self.parent = parent
@@ -95,6 +97,7 @@ def move(self, dx: int, dy: int) -> None:
         """
         Moves the entity by a given amount
         """
+        self.last_position = (self.x, self.y)
         self.x += dx
         self.y += dy
 
@@ -118,6 +121,7 @@ def __init__(
         fighter: Fighter,
         inventory: Inventory,
         level: Level,
+        effect: Optional[StatusEffect] = None,
     ):
         super().__init__(
             x=x,
@@ -131,6 +135,7 @@ def __init__(
         )
 
         self.ai: Optional[BaseAI] = ai_cls(self)
+        self.ai.set_effect(effect)
 
         self.equipment: Equipment = equipment
         self.equipment.parent = self

entity_factories.py

@@ -6,6 +6,8 @@
 from entity import NPC, Actor, Item
 from components.equipment import Equipment
 from input_handlers import ShopkeepMenuEventHandler
+from status_effect import Poisoned, bleeding
+
 
 player = Actor(
     char="@",
@@ -50,7 +52,9 @@
     inventory=Inventory(capacity=0),
     level=Level(xp_given=150),
     equipment=Equipment(),
-    inspect_message="It's a mutated human, probably due to being exposed to irradiated places. It's now a reckless hunter, with sharp claws and skinny body, it wants to eat fresh flesh."
+    inspect_message="It's a mutated human, probably due to being exposed to irradiated places. It's now a reckless hunter, with sharp claws and skinny body, it wants to eat fresh flesh.",
+    effect=bleeding(duration=6, value=1),
+
 )
 acid_mold = Actor(
     char="m",
@@ -61,7 +65,9 @@
     inventory=Inventory(capacity=0),
     level=Level(xp_given=50),
     equipment=Equipment(),
-    inspect_message="It's a slime mold, but it's acidic. Don't touch it! It's pains to the touch."
+    inspect_message="It's a slime mold, but it's acidic. Don't touch it! It's hurts to the touch.",
+    effect=Poisoned(duration=4, value=1),
+
 )
 mama_mold = Actor(
     char="M",

input_handlers.py

@@ -154,7 +154,7 @@ def handle_action(self, action: Optional[Action]) -> bool:
             return False  # Skip enemy turn on exceptions.
 
         self.engine.handle_enemy_turns()
-
+        self.engine.handle_status_effects()
         self.engine.update_fov()
         return True
 

status_effect.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from entity import Actor
+
+class StatusEffect:
+    """
+    A class to represent a status effect. Such as "poisoned", "stunned", etc.
+    """
+    def __init__(self, name: str, duration: int, value: int):
+        self.name = name
+        self.duration = duration
+        self.value = value
+
+    def on_tick(self, parent: Actor) -> None:
+        """
+        Called every turn for the duration of the status effect.
+
+        This method must be overridden by subclasses.
+        """
+        raise NotImplementedError()
+    
+class Poisoned(StatusEffect):
+    """
+    A class to represent a poisoned status effect.
+
+    Actors will take damage every turn, based on the value of the status effect.
+
+    """
+    def __init__(self, duration: int, value: int):
+        super().__init__("Poisoned", duration, value)
+
+    def on_tick(self, parent: Actor) -> None:
+        parent.fighter.take_damage(self.value)
+        self.duration -= 1
+
+class bleeding(StatusEffect):
+    """
+    A class to represent a bleeding status effect.
+
+    If the actor moved this turn, they will take damage based on the value of the status effect.
+    """
+    def __init__(self, duration: int, value: int):
+        super().__init__("Bleeding", duration, value)
+        self.last_pos = (0, 0)
+
+    def on_tick(self, parent: Actor) -> None:
+        self.last_pos = (parent.last_position[0], parent.last_position[1])
+
+        if parent.last_position != (parent.x, parent.y):
+            parent.fighter.take_damage(self.value)
+        self.duration -= 1