parts 6 and 7 done!

Author: jossse69

actions.py

@@ -2,13 +2,15 @@
 
 from typing import Optional, Tuple, TYPE_CHECKING
 
+import color
+
 if TYPE_CHECKING:
     from engine import Engine
-    from entity import Entity
+    from entity import Actor, Entity
 
 
 class Action:
-    def __init__(self, entity: Entity) -> None:
+    def __init__(self, entity: Actor) -> None:
         super().__init__()
         self.entity = entity
 
@@ -29,7 +31,7 @@ def perform(self) -> None:
         raise NotImplementedError()
 
 class ActionWithDirection(Action):
-    def __init__(self, entity: Entity, dx: int, dy: int):
+    def __init__(self, entity: Actor, dx: int, dy: int):
         super().__init__(entity)
 
         self.dx = dx
@@ -43,6 +45,11 @@ def dest_xy(self) -> Tuple[int, int]:
         """Returns this actions destination."""
         return self.entity.x + self.dx, self.entity.y + self.dy
 
+    @property
+    def target_actor(self) -> Optional[Actor]:
+        """Return the actor at this actions destination."""
+        return self.engine.game_map.get_actor_at_location(*self.dest_xy)
+
     @property
     def blocking_entity(self) -> Optional[Entity]:
         """Return the blocking entity at this actions destination.."""
@@ -55,11 +62,28 @@ def perform(self) -> None:
 
 class MeleeAction(ActionWithDirection):
     def perform(self) -> None:
-        target = self.blocking_entity
+        target = self.target_actor
         if not target:
             return  # No entity to attack.
 
-        print(f"You punch the {target.name}, it does not seem to be doing much damage...")
+        damage = self.entity.fighter.power - target.fighter.defense
+
+        attack_desc = f"{self.entity.name.capitalize()} attacks {target.name.capitalize()}"
+        if self.entity is self.engine.player:
+            attack_color = color.player_atk
+        else:
+            attack_color = color.enemy_atk
+        if damage > 0:
+            self.engine.message_log.add_message(
+                f"{attack_desc} for {damage} hit points!",
+                attack_color
+            )
+            target.fighter.hp -= damage
+        else:
+            self.engine.message_log.add_message(
+                f"{attack_desc}, but does no damage.",
+                attack_color
+            )
 
 class MovementAction(ActionWithDirection):
     def perform(self) -> None:
@@ -78,8 +102,12 @@ def perform(self) -> None:
 
 class BumpAction(ActionWithDirection):
     def perform(self) -> None:
-        if self.blocking_entity is not None:
+        if self.target_actor:
             return MeleeAction(self.entity, self.dx, self.dy).perform()
 
         else:
-            return MovementAction(self.entity, self.dx, self.dy).perform()
+            return MovementAction(self.entity, self.dx, self.dy).perform()
+        
+class WaitAction(Action):
+    def perform(self) -> None:
+        pass

color.py

@@ -0,0 +1,14 @@
+white = (255, 255, 255)
+black = (0, 0, 0)
+
+player_atk = (255, 153, 0)
+enemy_atk = (153, 0, 0)
+
+player_die = (255, 0, 0)
+enemy_die = (255, 255, 0)
+
+text_console = (204, 255, 51)
+
+bar_text = white
+bar_filled = (255, 0, 0)
+bar_empty = (77, 0, 0)

components/__init__.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import List, Tuple, TYPE_CHECKING
+
+import numpy as np  # type: ignore
+import tcod
+
+from actions import Action, MeleeAction, MovementAction, WaitAction
+from components.base_component import BaseComponent
+
+if TYPE_CHECKING:
+    from entity import Actor
+
+
+class BaseAI(Action, BaseComponent):
+    entity: Actor
+    def perform(self) -> None:
+        raise NotImplementedError()
+
+    def get_path_to(self, dest_x: int, dest_y: int) -> List[Tuple[int, int]]:
+        """Compute and return a path to the target position.
+
+        If there is no valid path then returns an empty list.
+        """
+        # Copy the walkable array.
+        cost = np.array(self.entity.gamemap.tiles["walkable"], dtype=np.int8)
+
+        for entity in self.entity.gamemap.entities:
+            # Check that an enitiy blocks movement and the cost isn't zero (blocking.)
+            if entity.blocks_movement and cost[entity.x, entity.y]:
+                # Add to the cost of a blocked position.
+                # A lower number means more enemies will crowd behind each other in
+                # hallways.  A higher number means enemies will take longer paths in
+                # order to surround the player.
+                cost[entity.x, entity.y] += 10
+
+        # Create a graph from the cost array and pass that graph to a new pathfinder.
+        graph = tcod.path.SimpleGraph(cost=cost, cardinal=2, diagonal=3)
+        pathfinder = tcod.path.Pathfinder(graph)
+
+        pathfinder.add_root((self.entity.x, self.entity.y))  # Start position.
+
+        # Compute the path to the destination and remove the starting point.
+        path: List[List[int]] = pathfinder.path_to((dest_x, dest_y))[1:].tolist()
+
+        # Convert from List[List[int]] to List[Tuple[int, int]].
+        return [(index[0], index[1]) for index in path]
+    
+class HostileEnemy(BaseAI):
+    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
+        dy = target.y - self.entity.y
+        distance = max(abs(dx), abs(dy))  # Chebyshev distance.
+
+        if self.engine.game_map.visible[self.entity.x, self.entity.y]:
+            if distance <= 1:
+                return MeleeAction(self.entity, dx, dy).perform()
+
+            self.path = self.get_path_to(target.x, target.y)
+
+        if self.path:
+            dest_x, dest_y = self.path.pop(0)
+            return MovementAction(
+                self.entity, dest_x - self.entity.x, dest_y - self.entity.y,
+            ).perform()
+
+        return WaitAction(self.entity).perform()

components/ai.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from engine import Engine
+    from entity import Entity
+
+
+class BaseComponent:
+    entity: Entity  # Owning entity instance.
+
+    @property
+    def engine(self) -> Engine:
+        return self.entity.gamemap.engine

components/base_component.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import color
+
+from components.base_component import BaseComponent
+from input_handlers import GameOverEventHandler
+from render_order import RenderOrder
+
+if TYPE_CHECKING:
+    from entity import Actor
+
+class Fighter(BaseComponent):
+    entity: Actor
+    def __init__(self, hp: int, defense: int, power: int):
+        self.max_hp = hp
+        self._hp = hp
+        self.defense = defense
+        self.power = power
+
+    @property
+    def hp(self) -> int:
+        return self._hp
+
+    @hp.setter
+    def hp(self, value: int) -> None:
+        self._hp = max(0, min(value, self.max_hp))
+        if self._hp == 0 and self.entity.ai:
+            self.die()
+
+    def die(self) -> None:
+        if self.engine.player is self.entity:
+            death_message = "You died!"
+            death_message_color = color.player_die
+            self.engine.event_handler = GameOverEventHandler(self.engine)
+        else:
+            death_message = f"{self.entity.name} is dead!"
+            death_message_color = color.enemy_die
+
+        self.entity.char = "%"
+        self.entity.color = (191, 0, 0)
+        self.entity.blocks_movement = False
+        self.entity.ai = None
+        self.entity.name = f"Corpse of {self.entity.name}"
+        self.entity.render_order = RenderOrder.CORPSE
+
+        self.engine.message_log.add_message(death_message, death_message_color)

components/fighter.py

@@ -2,31 +2,37 @@
 
 from typing import TYPE_CHECKING
 
-from tcod.context import Context
 from tcod.console import Console
 from tcod.map import compute_fov
 import tcod.constants
 
-from input_handlers import EventHandler
+from input_handlers import MainGameEventHandler
+from message_log import MessageLog
+from render_functions import render_bar, render_names_at_mouse_location
 
 if TYPE_CHECKING:
-    from entity import Entity
+    from entity import Actor
     from game_map import GameMap
+    from input_handlers import EventHandler
 
 class Engine:
 
     game_map: GameMap
 
-    def __init__(self, player: Entity):
-        self.event_handler: EventHandler = EventHandler(self)
+    def __init__(self, player: Actor):
+        self.event_handler: EventHandler = MainGameEventHandler(self)
+        self.message_log = MessageLog()
+        self.mouse_location = (0, 0)
         self.player = player
 
     def handle_enemy_turns(self) -> None:
-        for entity in self.game_map.entities - {self.player}:
-            print(f'The {entity.name} wonders when it will get to take a real turn.')
+        for entity in set(self.game_map.actors) - {self.player}:
+            if entity.ai:
+                entity.ai.perform()
 
     def update_fov(self) -> None:
         """Recompute the visible area based on the players point of view."""
+
         self.game_map.visible[:] = compute_fov(
             self.game_map.tiles["transparent"],
             (self.player.x, self.player.y),
@@ -38,9 +44,16 @@ def update_fov(self) -> None:
         self.game_map.explored |= self.game_map.visible
 
 
-    def render(self, console: Console, context: Context) -> None:
+    def render(self, console: Console) -> None:
         self.game_map.render(console)
 
-        context.present(console)
+        self.message_log.render(console=console, x=21, y=45, width=40, height=5)
+
+        render_bar(
+            console=console,
+            current_value=self.player.fighter.hp,
+            maximum_value=self.player.fighter.max_hp,
+            total_width=20,
+        )
 
-        console.clear()
+        render_names_at_mouse_location(console=console, x=21, y=44, engine=self)

engine.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
 import copy
-from typing import Optional, Tuple, TypeVar, TYPE_CHECKING
+from typing import Optional, Tuple, Type, TypeVar, TYPE_CHECKING
+
+from render_order import RenderOrder
 
 if TYPE_CHECKING:
+    from components.ai import BaseAI
+    from components.fighter import Fighter
     from game_map import GameMap
 
 T = TypeVar("T", bound="Entity")
@@ -23,6 +27,7 @@ def __init__(
         color: Tuple[int, int, int] = (255, 255, 255),
         name: str = "<Unnamed>",
         blocks_movement: bool = False,
+        render_order: RenderOrder = RenderOrder.CORPSE,
     ):
         """
         Create a new entity with the given properties.
@@ -33,6 +38,7 @@ def __init__(
         self.color = color
         self.name = name
         self.blocks_movement = blocks_movement
+        self.render_order = render_order
         if gamemap:
             # If gamemap isn't provided now then it will be set later.
             self.gamemap = gamemap
@@ -62,4 +68,41 @@ def move(self, dx: int, dy: int) -> None:
         Moves the entity by a given amount
         """
         self.x += dx
-        self.y += dy
+        self.y += dy
+
+
+class Actor(Entity):
+    """
+    A generic object to that can take damage, do turns, etc. for things like enemies, the player, etc.
+    """
+
+    def __init__(
+        self,
+        *,
+        x: int = 0,
+        y: int = 0,
+        char: str = "?",
+        color: Tuple[int, int, int] = (255, 255, 255),
+        name: str = "<Unnamed>",
+        ai_cls: Type[BaseAI],
+        fighter: Fighter
+    ):
+        super().__init__(
+            x=x,
+            y=y,
+            char=char,
+            color=color,
+            name=name,
+            blocks_movement=True,
+            render_order=RenderOrder.ACTOR,
+        )
+
+        self.ai: Optional[BaseAI] = ai_cls(self)
+
+        self.fighter = fighter
+        self.fighter.entity = self
+
+    @property
+    def is_alive(self) -> bool:
+        """Returns True as long as this actor can perform actions."""
+        return bool(self.ai)