Create Dark Knight enemy.

It uses a new AI that patrols the map until it finds the player.

Author: Julioevm

actor_factories.py

@@ -186,3 +186,19 @@
     level=Level(xp_given=70),
     status=Status(status_effects=[(Confused(duration=3), 0.3)]),
 )
+
+dark_knight = Actor(
+    char="K",
+    color=(0, 0, 0),  # Black color for the "dark" knight
+    name="Dark Knight",
+    ai_cls=components.ai.DarkKnightAI,  # You'll need to define this AI class
+    equipment=Equipment(),  # Add any specific equipment the Dark Knight should have
+    fighter=Fighter(
+        hp=25, base_defense=40, base_power=6, base_damage=(2, 6), base_speed=90
+    ),  # Adjust these values as needed for your game balance
+    inventory=Inventory(
+        capacity=0
+    ),  # Adjust capacity if the Dark Knight should be able to carry items
+    level=Level(xp_given=120),  # Adjust XP given upon defeat
+    status=Status(),  # Add any status effects the Dark Knight should have
+)

components/ai.py

@@ -24,6 +24,7 @@
 from exceptions import Impossible
 
 if TYPE_CHECKING:
+    from game_map import GameMap
     from entity import Actor
 
 
@@ -132,6 +133,38 @@ def get_action(self) -> Action:
         return WaitAction(self.entity)
 
 
+class PatrollingMeleeEnemyAI(BasicMeleeEnemyAI):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.target = None
+
+    def get_action(self) -> Action:
+
+        if self.engine.game_map.visible[self.entity.x, self.entity.y]:
+            # If the player is in sight, behave like the BasicMeleeEnemyAI
+            return super().get_action()
+        else:
+            # Otherwise, patrol the map
+            if self.target is None or (self.entity.x, self.entity.y) == self.target:
+                # If there is no current target or the current target has been reached, find a new target
+                walkable_tiles = self.engine.game_map.get_walkable_tiles_from_position(
+                    (self.entity.x, self.entity.y), self.engine.game_map
+                )
+                self.target = random.choice(walkable_tiles)
+
+            # Move towards the target
+            self.path = self.get_path_to(self.target[0], self.target[1])
+
+            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,
+            )
+
+
 class MoveToTile(BaseAI):
     """AI that moves to a specific tile."""
 
@@ -343,3 +376,8 @@ def is_tile_empty(self, tile: Tuple[int, int]) -> bool:
             for entity in self.engine.game_map.entities
             if entity.blocks_movement and entity.x == x and entity.y == y
         )
+
+
+class DarkKnightAI(PatrollingMeleeEnemyAI):
+    def __init__(self, entity: Actor):
+        super().__init__(entity)

game_map.py

@@ -2,9 +2,7 @@
 import itertools
 
 import random
-from re import S
-from typing import Iterable, Iterator, Optional, TYPE_CHECKING
-from unittest import skip
+from typing import Iterable, Iterator, List, Optional, TYPE_CHECKING, Tuple
 
 import numpy as np
 import tcod  # type: ignore
@@ -149,6 +147,21 @@ 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
 
+    def get_walkable_tiles_from_position(
+        self, origin: Tuple[int, int], game_map: GameMap
+    ) -> List[Tuple[int, int]]:
+        """Perform a flood-fill to find which areas the current position has access to."""
+        walkable_tiles = []
+        stack = [(origin[0], origin[1])]
+        while stack:
+            x, y = stack.pop()
+            if (x, y) not in walkable_tiles and game_map.tiles["walkable"][x, y]:
+                walkable_tiles.append((x, y))
+                stack.extend(
+                    [(x + dx, y + dy) for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]]
+                )
+        return walkable_tiles
+
     def get_walkable_adjacent_tiles(self, x: int, y: int) -> Iterator[tuple[int, int]]:
         """Get all walkable adjacent tiles to the given (x, y) coordinate."""
         for x_offset, y_offset in itertools.product((-1, 0, 1), (-1, 0, 1)):

map_gen/parameters.py

@@ -114,7 +114,11 @@
         (actor_factories.wolf, 20),
         (actor_factories.werewolf, 5),
     ],
-    6: [(actor_factories.vampire, 10), (actor_factories.hound, 40)],
+    6: [
+        (actor_factories.vampire, 10),
+        (actor_factories.hound, 40),
+        (actor_factories.dark_knight, 30),
+    ],
     7: [
         (actor_factories.ghoul, 40),
         (actor_factories.brute_zombie, 35),