关于#游戏引擎#的问题：有没有人会这个视频里面的AI行为逻辑，光一点向量点积法完全不会

引自免费微信小程序：皆我百晓生

在视频中，AI的行为逻辑是基于路径寻找算法（如A*）以及一个简单的吸引力/排斥力模型来实现的。为了帮助您理解并实现这段逻辑，我会逐步解释每个部分，并提供一些示例代码。

首先，我们需要一个路径寻找算法，这里我们选择A算法。A算法用于找到从起点到终点的最短路径，它结合了两个关键概念：启发式成本函数（h(n)）和实际移动代价（g(n)）。在这个场景中，我们可以将地图上的每个格子视为节点，节点之间的边表示可以行走的距离。

以下是A*算法的基本伪代码：

def a_star_search(start, goal, grid):
    open_set = PriorityQueue()
    open_set.put((0, start))
    came_from = {}
    g_score = {start: 0}
    f_score = {start: heuristic(start, goal)}

    while not open_set.empty():
        current = open_set.get()[1]

        if current == goal:
            break

        for neighbor in get_neighbors(current, grid):
            tentative_g_score = g_score[current] + cost(current, neighbor)

            if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
                came_from[neighbor] = current
                g_score[neighbor] = tentative_g_score
                f_score[neighbor] = tentative_g_score + heuristic(neighbor, goal)
                if neighbor not in open_set.queue:
                    open_set.put((f_score[neighbor], neighbor))

    return reconstruct_path(came_from, goal)

def heuristic(a, b):
    # Manhattan distance is often used as a simple heuristic
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def cost(current, neighbor):
    # Assuming unit cost to move from one cell to another
    return 1

def get_neighbors(node, grid):
    neighbors = []
    # Add code here to find all valid neighbors based on the grid
    return neighbors

接下来，我们需要创建一个吸引力和排斥力模型。这可以通过向量点积来实现。当AI看到目标时，它会产生一个指向目标的向量，并通过点积计算与当前朝向的差异，然后调整其速度向量。同时，为了避免撞上障碍物，可以检测到障碍物后产生一个避开它的向量。

下面是一个简单的吸引和避开行为的Python代码片段：

import math

def calculate_attract_vector(actor_pos, target_pos):
    attract_vec = [target_pos[0] - actor_pos[0], target_pos[1] - actor_pos[1]]
    return attract_vec

def calculate_repel_vector(actor_pos, obstacle_pos, radius):
    repel_vec = [obstacle_pos[0] - actor_pos[0], obstacle_pos[1] - actor_pos[1]]
    length = math.sqrt(repel_vec[0]**2 + repel_vec[1]**2)
    if length > radius:
        repel_vec = [repel_vec[0]/length * (radius - length), repel_vec[1]/length * (radius - length)]
    else:
        repel_vec = [0, 0]
    return repel_vec

def update_actor_speed(actor_pos, actor_direction, target_pos, obstacles, max_speed):
    attract_vec = calculate_attract_vector(actor_pos, target_pos)
    total_vec = [0, 0]
    
    for obstacle in obstacles:
        repel_vec = calculate_repel_vector(actor_pos, obstacle, obstacle_radius)
        total_vec[0] += repel_vec[0]
        total_vec[1] += repel_vec[1]
        
    dot_product = attract_vec[0]*actor_direction[0] + attract_vec[1]*actor_direction[1]
    normalized_attract_vec = [attract_vec[0] / max(abs(attract_vec[0]), 1e-6),
                              attract_vec[1] / max(abs(attract_vec[1]), 1e-6)]
    
    adjusted_attract_vec = [normalized_attract_vec[0] * dot_product,
                            normalized_attract_vec[1] * dot_product]
    
    total_vec[0] += adjusted_attract_vec[0]
    total_vec[1] += adjusted_attract_vec[1]
    
    speed = [total_vec[0] / max(abs(total_vec[0]), 1e-6),
             total_vec[1] / max(abs(total_vec[1]), 1e-6)]
    
    speed[0] *= max_speed
    speed[1] *= max_speed
    
    return speed

这些代码段应该能帮助您实现视频中的AI行为逻辑。您可以根据实际情况调整启发式函数、成本函数、邻居获取方法以及最大速度等参数。如果您需要进一步的帮助，比如如何在具体的游戏引擎中集成这些功能，请随时提问。