Искусственный интеллект в играх: принципы создания и реализация

class AIAgent:
def __init__(self, game_world, position, stats):
self.world = game_world
self.position = position
self.stats = stats
self.memory = [] # Хранит информацию о прошлых событиях
self.current_goal = None
self.path = [] # Текущий путь навигации

def sense_environment(self):
# Получение информации об окружающем мире
visible_objects = self.world.get_visible_objects(self.position, self.stats['vision_range'])
return visible_objects

def make_decision(self, sensory_input):
# Принятие решения на основе полученных данных
# Возвращает конкретное действие
pass

def execute_action(self, action):
# Выполнение выбранного действия
pass

def update(self, delta_time):
# Основной цикл обновления состояния AI
sensory_input = self.sense_environment()
action = self.make_decision(sensory_input)
self.execute_action(action)

import heapq

def astar_pathfinding(game_map, start, goal):
# Функция эвристики: манхэттенское расстояние
def heuristic(a, b):
return abs(a[0] – b[0]) + abs(a[1] – b[1])

# Возможные направления движения (включая диагонали)
directions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]

# Очередь с приоритетом для открытых узлов
open_set = []
heapq.heappush(open_set, (0, start))

# Для каждой точки сохраняем, откуда мы в неё пришли
came_from = {}

# Стоимость пути от начала до данной точки
g_score = {start: 0}

# Предполагаемая полная стоимость пути через данную точку
f_score = {start: heuristic(start, goal)}

# Набор открытых узлов для быстрого поиска
open_set_hash = {start}

while open_set_hash:
# Извлекаем узел с наименьшей оценкой f
current = heapq.heappop(open_set)[1]
open_set_hash.remove(current)

# Достигли цели
if current == goal:
path = []
while current in came_from:
path.append(current)
current = came_from[current]
path.append(start)
path.reverse()
return path

# Проверяем соседние клетки
for dx, dy in directions:
neighbor = (current[0] + dx, current[1] + dy)

# Проверяем границы карты и проходимость
if (0 <= neighbor[0] < len(game_map) and 
0 <= neighbor[1] < len(game_map[0]) and 
game_map[neighbor[0]][neighbor[1]] == 0): # 0 означает проходимую клетку

# Диагональное движение стоит дороже
move_cost = 1.4 if abs(dx) + abs(dy) == 2 else 1
tentative_g = g_score.get(current, float('inf')) + move_cost

if neighbor not in g_score or tentative_g < g_score[neighbor]:
# Нашли лучший путь к этому соседу
came_from[neighbor] = current
g_score[neighbor] = tentative_g
f_score[neighbor] = tentative_g + heuristic(neighbor, goal)

if neighbor not in open_set_hash:
heapq.heappush(open_set, (f_score[neighbor], neighbor))
open_set_hash.add(neighbor)

# Путь не найден
return None

class AINavigationSystem:
def __init__(self, game_map):
self.game_map = game_map
self.navigation_map = self.precompute_navigation_map()

def precompute_navigation_map(self):
# Создаём навигационную сетку на основе карты
# Это ускорит поиск пути при выполнении
pass

def find_path(self, start, goal):
return astar_pathfinding(self.game_map, start, goal)

def follow_path(self, agent, path, speed, delta_time):
if not path or len(path) <= 1:
return False

# Определяем следующую точку назначения
next_point = path[1]

# Вычисляем направление
direction_x = next_point[0] – agent.position[0]
direction_y = next_point[1] – agent.position[1]

# Нормализуем вектор направления
length = (direction_x**2 + direction_y**2)**0.5
if length > 0:
direction_x /= length
direction_y /= length

# Перемещаем агента
agent.position[0] += direction_x * speed * delta_time
agent.position[1] += direction_y * speed * delta_time

# Проверяем, достигли ли мы следующей точки
new_distance = ((agent.position[0] – next_point[0])**2 + 
(agent.position[1] – next_point[1])**2)**0.5

if new_distance < 0.1: # Порог достижения точки
path.pop(0) # Удаляем достигнутую точку из пути

return True # Продолжаем движение

class State:
def enter(self, agent):
# Вызывается при входе в состояние
pass

def execute(self, agent, delta_time):
# Логика поведения в данном состоянии
pass

def exit(self, agent):
# Вызывается при выходе из состояния
pass

def check_transitions(self, agent):
# Проверяет условия для перехода в другие состояния
# Возвращает новое состояние или None
pass

class PatrolState(State):
def __init__(self, patrol_points):
self.patrol_points = patrol_points
self.current_target = 0

def enter(self, agent):
agent.animation = "walk"
agent.speed = 1.0

def execute(self, agent, delta_time):
target = self.patrol_points[self.current_target]

# Если достигли текущей точки патрулирования
if agent.move_to(target, delta_time):
# Переходим к следующей точке
self.current_target = (self.current_target + 1) % len(self.patrol_points)

def check_transitions(self, agent):
# Проверяем, видим ли игрока
if agent.can_see_player():
return ChaseState() # Переходим к преследованию
return None

class ChaseState(State):
def enter(self, agent):
agent.animation = "run"
agent.speed = 2.0
agent.play_sound("alert")

def execute(self, agent, delta_time):
if agent.can_see_player():
# Обновляем путь до игрока
agent.path = agent.find_path(agent.position, agent.player_position)

# Следуем по пути
if agent.path:
agent.follow_path(delta_time)

def check_transitions(self, agent):
# Потеряли игрока из виду
if not agent.can_see_player() and not agent.was_damaged:
return SearchState(agent.player_last_seen_position)

# Игрок достаточно близко для атаки
if agent.distance_to_player < agent.attack_range:
return AttackState()

return None

class FiniteStateMachine:
def __init__(self, initial_state):
self.current_state = initial_state

def update(self, agent, delta_time):
# Проверяем возможные переходы
new_state = self.current_state.check_transitions(agent)

if new_state:
self.current_state.exit(agent)
self.current_state = new_state
self.current_state.enter(agent)

# Выполняем логику текущего состояния
self.current_state.execute(agent, delta_time)

class BTNode:
def tick(self, agent, delta_time):
# Абстрактный метод для выполнения узла
# Возвращает SUCCESS, FAILURE или RUNNING
pass

class BTSequence(BTNode):
def __init__(self, children):
self.children = children
self.current_child = 0

def tick(self, agent, delta_time):
while self.current_child < len(self.children):
status = self.children[self.current_child].tick(agent, delta_time)

# Если дочерний узел не выполнился успешно, прерываем последовательность
if status != "SUCCESS":
return status

self.current_child += 1

# Все дочерние узлы выполнились успешно
self.current_child = 0
return "SUCCESS"

class BTSelector(BTNode):
def __init__(self, children):
self.children = children
self.current_child = 0

def tick(self, agent, delta_time):
while self.current_child < len(self.children):
status = self.children[self.current_child].tick(agent, delta_time)

# Если дочерний узел выполнился успешно, прекращаем выбор
if status != "FAILURE":
return status

self.current_child += 1

# Все дочерние узлы завершились неудачей
self.current_child = 0
return "FAILURE"

# Пример конкретных узлов действий
class IsPlayerVisible(BTNode):
def tick(self, agent, delta_time):
return "SUCCESS" if agent.can_see_player() else "FAILURE"

class MoveToPlayer(BTNode):
def tick(self, agent, delta_time):
if not agent.path:
agent.path = agent.find_path(agent.position, agent.player_position)

if agent.follow_path(delta_time):
return "RUNNING" # Всё ещё движемся
else:
return "SUCCESS" # Достигли цели

# Создаём дерево поведения для врага
enemy_behavior_tree = BTSelector([
# Ветка атаки
BTSequence([
IsPlayerVisible(), # Проверяем, видим ли игрока
IsPlayerInAttackRange(), # Проверяем дистанцию до игрока
AttackPlayer() # Атакуем
]),

# Ветка преследования
BTSequence([
IsPlayerVisible(),
MoveToPlayer()
]),

# Ветка патрулирования (запасной вариант)
Patrol()
])

# Использование в главном цикле AI
def update_ai(agent, delta_time):
enemy_behavior_tree.tick(agent, delta_time)

class PlayerActionTracker:
def __init__(self):
self.action_history = []
self.pattern_frequency = {} # Хранит частоту определенных последовательностей действий
self.preferred_weapons = {} # Счетчик использования оружия
self.common_positions = [] # Популярные позиции игрока

def record_action(self, player_action):
# Записываем действие игрока с временной меткой
self.action_history.append({
"action": player_action.type,
"position": player_action.position,
"weapon": player_action.weapon,
"timestamp": player_action.timestamp
})

# Обновляем счетчик оружия
if player_action.weapon:
self.preferred_weapons[player_action.weapon] = self.preferred_weapons.get(player_action.weapon, 0) + 1

# Добавляем позицию в список
self.common_positions.append(player_action.position)
if len(self.common_positions) > 100: # Хранение ограниченной истории
self.common_positions.pop(0)

# Анализируем последовательности действий (последние 5 действий)
if len(self.action_history) >= 5:
pattern = tuple([a["action"] for a in self.action_history[-5:]])
self.pattern_frequency[pattern] = self.pattern_frequency.get(pattern, 0) + 1

def get_player_favorite_weapon(self):
if not self.preferred_weapons:
return None
return max(self.preferred_weapons.items(), key=lambda x: x[1])[0]

def predict_next_action(self):
# Если у нас недостаточно истории, возвращаем None
if len(self.action_history) < 4:
return None

# Получаем последние 4 действия
recent_actions = tuple([a["action"] for a in self.action_history[-4:]])

# Ищем наиболее вероятное следующее действие
best_prediction = None
highest_frequency = 0

for pattern, frequency in self.pattern_frequency.items():
if pattern[:-1] == recent_actions and frequency > highest_frequency:
best_prediction = pattern[-1]
highest_frequency = frequency

return best_prediction

def get_player_hotspots(self, num_clusters=3):
# Используем простую кластеризацию для нахождения популярных позиций
if len(self.common_positions) < 10:
return []

# В реальном проекте здесь можно использовать K-means или другие алгоритмы кластеризации
# Для примера используем упрощенный подход
hotspots = []
# ... логика кластеризации ...
return hotspots

class AdaptiveEnemy:
def __init__(self, game_world, tracker):
self.world = game_world
self.tracker = tracker # Трекер действий игрока

# Начальные тактические предпочтения (будут меняться)
self.tactical_preferences = {
"aggression": 0.5, # 0 – оборонительно, 1 – агрессивно
"grouping": 0.5, # 0 – предпочитает действовать один, 1 – в группе
"weapon_preference": "balanced" # может быть "ranged", "melee", "balanced"
}

self.adaptation_rate = 0.1 # Скорость адаптации к стилю игрока

def update_preferences(self):
# Анализируем действия игрока и корректируем свои предпочтения

# Если игрок часто использует дальнобойное оружие
player_weapon = self.tracker.get_player_favorite_weapon()
if player_weapon in ["rifle", "bow", "pistol"]:
# Увеличиваем своё предпочтение ближнего боя, чтобы противодействовать
self.tactical_preferences["weapon_preference"] = "melee"
# Увеличиваем агрессию, чтобы быстрее сближаться с игроком
self.tactical_preferences["aggression"] += self.adaptation_rate

# Если игрок предпочитает ближний бой
elif player_weapon in ["sword", "axe", "fists"]:
# Предпочитаем дальний бой
self.tactical_preferences["weapon_preference"] = "ranged"
# Уменьшаем агрессию, чтобы держать дистанцию
self.tactical_preferences["aggression"] -= self.adaptation_rate

# Ограничиваем значения в диапазоне [0, 1]
self.tactical_preferences["aggression"] = max(0, min(1, self.tactical_preferences["aggression"]))
self.tactical_preferences["grouping"] = max(0, min(1, self.tactical_preferences["grouping"]))

def select_tactic(self):
self.update_preferences()

# Предсказываем следующее действие игрока
predicted_action = self.tracker.predict_next_action()

if predicted_action == "reload":
# Если игрок скоро будет перезаряжаться, планируем атаку
return "aggressive_charge"

if self.tactical_preferences["aggression"] > 0.7:
if self.tactical_preferences["weapon_preference"] == "ranged":
return "aggressive_ranged_attack"
else:
return "rush_attack"
else:
# Получаем популярные позиции игрока для засады
hotspots = self.tracker.get_player_hotspots()
if hotspots:
return ("ambush", hotspots[0]) # Устраиваем засаду в популярном месте
else:
return "defensive_position"

def execute_tactic(self, tactic, delta_time):
# Реализация выбранной тактики
if tactic == "aggressive_charge":
# Код для агрессивной атаки
pass
elif tactic == "ambush":
# Код для засады
pass
# ... другие тактики ...

# Пример интеграции простой Q-learning для выбора тактики
class QLearningTacticalAI:
def __init__(self):
self.q_table = {} # Состояние -> (Действие -> Значение)
self.learning_rate = 0.1
self.discount_factor = 0.9
self.exploration_rate = 0.3 # Вероятность случайного действия
self.available_tactics = ["aggressive", "defensive", "flanking", "ambush"]

def get_state_representation(self, game_state):
# Упрощенное представление состояния игры
player_health = game_state.player.health // 25 # Квантуем здоровье на 4 уровня
player_weapon = game_state.player.current_weapon.type
distance_to_player = min(5, int(game_state.distance_to_player // 5)) # 0-5 шагов по 5 единиц

return (player_health, player_weapon, distance_to_player)

def select_action(self, state):
# Исследование: случайное действие с вероятностью exploration_rate
if random.random() < self.exploration_rate:
return random.choice(self.available_tactics)

# Использование: выбираем действие с наибольшим Q-значением
if state not in self.q_table:
self.q_table[state] = {tactic: 0 for tactic in self.available_tactics}

return max(self.q_table[state].items(), key=lambda x: x[1])[0]

def update_q_value(self, state, action, reward, next_state):
# Если это новое состояние, инициализируем его в Q-таблице
if state not in self.q_table:
self.q_table[state] = {tactic: 0 for tactic in self.available_tactics}
if next_state not in self.q_table:
self.q_table[next_state] = {tactic: 0 for tactic in self.available_tactics}

# Формула Q-learning
current_q = self.q_table[state][action]
max_next_q = max(self.q_table[next_state].values())

new_q = current_q + self.learning_rate * (reward + self.discount_factor * max_next_q – current_q)
self.q_table[state][action] = new_q

class AIManager:
def __init__(self):
self.agents = []
self.update_frequency = {
"critical": 1, # Каждый кадр
"normal": 3, # Каждый третий кадр
"background": 10 # Каждый десятый кадр
}
self.current_frame = 0

def add_agent(self, agent):
self.agents.append(agent)

def update(self, delta_time, player_position):
self.current_frame += 1

for agent in self.agents:
distance_to_player = calculate_distance(agent.position, player_position)

# Определяем приоритет обновления на основе расстояния и видимости
if distance_to_player < 10 or agent.is_in_combat:
priority = "critical"
elif distance_to_player < 50 and agent.is_visible_to_player:
priority = "normal"
else:
priority = "background"

# Обновляем агента с соответствующей частотой
if self.current_frame % self.update_frequency[priority] == 0:
agent.update_full(delta_time)
else:
agent.update_minimal(delta_time) # Только базовые обновления

class PathCache:
def __init__(self, max_cache_size=1000):
self.cache = {}
self.max_cache_size = max_cache_size
self.hits = 0
self.misses = 0

def get_path(self, start, end, tolerance=1.0):
# Округляем координаты для увеличения вероятности кэш-хита
cache_key = (self.round_position(start), self.round_position(end))

if cache_key in self.cache:
self.hits += 1
return self.cache[cache_key].copy() # Возвращаем копию пути

self.misses += 1
return None

def add_path(self, start, end, path):
cache_key = (self.round_position(start), self.round_position(end))

# Если кэш полон, удаляем случайный элемент
if len(self.cache) >= self.max_cache_size:
random_key = random.choice(list(self.cache.keys()))
del self.cache[random_key]

self.cache[cache_key] = path.copy()

def round_position(self, position, grid_size=5.0):
# Округляем позицию до сетки для увеличения повторного использования
return (round(position[0] / grid_size) * grid_size, 
round(position[1] / grid_size) * grid_size)

def get_hit_ratio(self):
total = self.hits + self.misses
if total == 0:
return 0
return self.hits / total

class AIDebugger:
def __init__(self):
self.is_enabled = False
self.visualize_paths = True
self.visualize_states = True
self.visualize_sensors = True
self.log_decisions = False
self.selected_agent = None

def toggle_debug(self):
self.is_enabled = not self.is_enabled

def select_agent(self, agent):
self.selected_agent = agent

def render_debug_info(self, renderer, agent):
if not self.is_enabled:
return

# Отображение текущего состояния
if self.visualize_states:
state_text = f"State: {agent.current_state.__class__.__name__}"
renderer.draw_text(agent.position[0], agent.position[1] – 20, state_text, color=(255, 255, 0))

# Отображение пути
if self.visualize_paths and agent.path:
for i in range(len(agent.path) – 1):
renderer.draw_line(agent.path[i], agent.path[i+1], color=(0, 255, 0))

# Отображение сенсоров
if self.visualize_sensors:
# Круг видимости
renderer.draw_circle(agent.position, agent.stats["vision_range"], color=(255, 0, 0, 50))

# Поле зрения
direction = agent.facing_direction
renderer.draw_arc(agent.position, agent.stats["vision_range"], 
agent.stats["field_of_view"], direction, color=(0, 0, 255, 50))

def log_agent_decision(self, agent, decision, reason):
if not self.is_enabled or not self.log_decisions:
return

log_entry = f"Agent {agent.id}: {decision} – {reason}"
print(log_entry) # В реальном проекте следует использовать систему логирования

class StateMachineVisualizer:
def __init__(self, state_machine):
self.state_machine = state_machine
self.state_positions = {} # Позиции состояний на экране
self.transition_history = [] # История переходов

def update(self):
# Добавляем текущее состояние в историю
current_state_name = self.state_machine.current_state.__class__.__name__
if not self.transition_history or self.transition_history[-1] != current_state_name:
self.transition_history.append(current_state_name)

# Ограничиваем длину истории
if len(self.transition_history) > 10:
self.transition_history.pop(0)

def render(self, renderer, x, y, width, height):
# Рисуем прямоугольник для фона
renderer.draw_rect(x, y, width, height, color=(0, 0, 0, 150))

# Заголовок
renderer.draw_text(x + 10, y + 10, "AI State Machine", color=(255, 255, 255))

# Текущее состояние
current_state_name = self.state_machine.current_state.__class__.__name__
renderer.draw_text(x + 10, y + 40, f"Current: {current_state_name}", color=(255, 255, 0))

# История переходов
renderer.draw_text(x + 10, y + 70, "Transition History:", color=(255, 255, 255))
for i, state_name in enumerate(self.transition_history):
renderer.draw_text(x + 20, y + 100 + i * 20, state_name, color=(200, 200, 200))