1
0
python-roguelike/components/ai.py

118 lines
4.1 KiB
Python
Raw Normal View History

2022-01-07 16:39:37 -05:00
from __future__ import annotations
2022-01-14 16:45:07 -05:00
import random
from typing import List, Optional, Tuple, TYPE_CHECKING
2022-01-07 16:39:37 -05:00
import numpy as np # type: ignore
import tcod
2022-01-14 16:45:07 -05:00
from actions import Action, BumpAction, MeleeAction, MovementAction, WaitAction
2022-01-07 16:39:37 -05:00
2022-01-10 13:21:17 -05:00
if TYPE_CHECKING:
from entity import Actor
2022-01-07 16:39:37 -05:00
2022-01-12 13:45:52 -05:00
class BaseAI(Action):
2022-01-07 16:39:37 -05:00
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 entity 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)
2022-01-07 16:39:37 -05:00
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]].
2022-01-07 16:48:49 -05:00
return [(index[0], index[1]) for index in path]
2022-01-10 13:21:17 -05:00
2022-01-14 16:45:07 -05:00
class ConfusedEnemy(BaseAI):
"""
A confused enemy will stumble around aimlessly for a given number of turns, then
reverts back to its previous AI. If an actor occupies a tile it is randomly
moving into, it will attack.
"""
def __init__(
2022-02-08 10:00:28 -05:00
self, entity: Actor, previous_ai: Optional[BaseAI], turns_remaining: int
2022-01-14 16:45:07 -05:00
):
super().__init__(entity)
self.previous_ai = previous_ai
self.turns_remaining = turns_remaining
def perform(self) -> None:
# Rever the AI back to the original state if the effect has run its course.
if self.turns_remaining <= 0:
2022-02-08 10:00:28 -05:00
self.engine.message_log.add_message(
f"The {self.entity.name} is no longer confused."
)
2022-01-14 16:45:07 -05:00
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 BumpAction(self.entity, direction_x, direction_y).perform()
2022-01-10 13:21:17 -05:00
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
# Chebyshev distance
distance = max(abs(dx), abs(dy))
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,
2022-01-10 13:21:17 -05:00
).perform()
return WaitAction(self.entity).perform()