A 算法实现指南：优化邻居节点探索，避免提前终止

def AStar(start_node, end_node):
    # ... 初始化代码 ...
    while not openSet.isEmpty():
        current = openSet.dequeue()

        if current == end_node:
            RetracePath(cameFrom, end_node)
            return True # 找到路径后应返回

        # 错误：始终探索起始节点的邻居
        for neighbour in find_neighbors(start_node, graph):
            tempGCost = gCost[current] + 1

            if tempGCost < gCost[neighbour]:
                cameFrom[neighbour] = current
                gCost[neighbour] = tempGCost
                fCost[neighbour] = tempGCost + heuristic(neighbour, end_node)

                if not openSet.contains(neighbour):
                    openSet.enqueue(fCost[neighbour], neighbour)
        # ... 调试输出 ...
    return False

def find_neighbors(node, graph):
    x, y = node
    neighbors = []
    # 假设graph是一个包含所有可行坐标的集合
    possible_neighbors = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
    for neighbor_coords in possible_neighbors:
        if neighbor_coords in graph:
            neighbors.append(neighbor_coords)
    return neighbors

Came from: {(7, 2): (6, 2), (6, 3): (6, 2)}
Current: (6, 2)
Came from: {(7, 2): (6, 2), (6, 3): (6, 2)}
Current: (7, 2)
Came from: {(7, 2): (6, 2), (6, 3): (6, 2)}
Current: (6, 3)

        # 正确：探索当前节点的邻居
        for neighbour in find_neighbors(current, graph):
            # ... 后续逻辑不变 ...

import heapq

# 1. 优先队列实现
class PriorityQueue:
    def __init__(self):
        self._queue = [] # 存储 (priority, index, item)
        self._index = 0  # 用于打破优先级相同的元素的平局

    def enqueue(self, priority, item):
        # heapq 默认是最小堆，所以这里直接用优先级
        heapq.heappush(self._queue, (priority, self._index, item))
        self._index += 1

    def dequeue(self):
        # 返回优先级最高的（fCost最小的）项
        return heapq.heappop(self._queue)[2] # 返回item

    def isEmpty(self):
        return len(self._queue) == 0

    def contains(self, item):
        # 这是一个简化的contains。在更健壮的A*实现中，
        # 通常会维护一个字典来快速查找item是否存在于队列中，
        # 并允许更新其优先级（或者采用"惰性删除"策略）。
        # 对于本教程的示例，假设它能工作。
        for _, _, existing_item in self._queue:
            if existing_item == item:
                return True
        return False

# 2. 启发式函数 (曼哈顿距离)
def heuristic(node_a, node_b):
    """计算两个节点之间的曼哈顿距离作为启发式估计。"""
    return abs(node_a[0] - node_b[0]) + abs(node_a[1] - node_b[1])

# 3. 邻居查找函数 (与原问题一致)
def find_neighbors(node, graph):
    """查找给定节点在图中的所有有效邻居。"""
    x, y = node
    neighbors = []
    # 定义四个方向的邻居
    possible_neighbors = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
    for neighbor_coords in possible_neighbors:
        # 检查邻居是否在图中（即是否是可行区域）
        if neighbor_coords in graph:
            neighbors.append(neighbor_coords)
    return neighbors

# 4. 路径回溯函数
def RetracePath(cameFrom, end_node):
    """从cameFrom字典回溯并重建从起点到终点的路径。"""
    path = []
    current = end_node
    while current in cameFrom:
        path.append(current)
        current = cameFrom[current]
    path.append(current) # 添加起点
    path.reverse()       # 反转路径，使其从起点到终点
    print("Path found:", path)
    return path

# 5. 修正后的 A* 算法主函数
def AStar_corrected(start_node, end_node, graph):
    """
    修正后的A*算法实现。
    Args:
        start_node: 起始节点坐标 (x, y)。
        end_node: 目标节点坐标 (x, y)。
        graph: 表示地图的集合，包含所有可通行的节点坐标。
    Returns:
        如果找到路径，返回路径列表；否则返回False。
    """
    openSet = PriorityQueue()
    openSet.enqueue(0, start_node)

    infinity = float("inf")

    gCost = {}      # 从起点到当前节点的实际代价
    fCost = {}      # 从起点经过当前节点到终点的总估计代价
    cameFrom = {}   # 记录每个节点的父节点，用于路径回溯

    # 初始化所有节点的gCost和fCost为无穷大
    for node in graph:
        gCost[node] = infinity
        fCost[node] = infinity
    gCost[start_node] = 0
    fCost[start_node] = heuristic(start_node, end_node)

    while not openSet.isEmpty():
        current = openSet.dequeue()

        # 如果当前节点是目标节点，则找到了路径
        if current == end_node:
            return RetracePath(cameFrom, end_node)

        # 关键修正：探索当前节点的邻居，而不是起始节点的邻居
        for neighbour in find_neighbors(current, graph):
            # 假设每一步的代价是1
            tempGCost = gCost[current] + 1

            # 如果通过当前节点到达邻居的路径更优
            if tempGCost < gCost[neighbour]:
                cameFrom[neighbour] = current
                gCost[neighbour] = tempGCost
                fCost[neighbour] = tempGCost + heuristic(neighbour, end_node)

                # 如果邻居不在开放集合中，则加入
                if not openSet.contains(neighbour):
                    openSet.enqueue(fCost[neighbour], neighbour)
                # 注意：如果邻居已在开放集合中，且新的fCost更优，
                # 需要更新其优先级。当前的PriorityQueue.contains
                # 不支持更新，更健壮的实现会处理这种情况
                # (例如，重新插入，或者使用字典来跟踪并更新优先级)。

    return False # 如果openSet为空，但未找到路径

# 示例使用
if __name__ == "__main__":
    # 定义一个简单的图（这里用集合表示所有可行的坐标点）
    example_graph = set()
    for x in range(0, 15):
        for y in range(0, 5):
            example_graph.add((x, y))
    # 移除一些障碍物（可选，模拟不可通行区域）
    example_graph.remove((8, 2))
    example_graph.remove((9, 2))
    example_graph.remove((10, 1))
    example_graph.remove((7, 3))

    start_node_example = (6, 2)
    end_node_example = (10, 2) # 目标坐标，与原问题中的'Player coords'类似

    print(f"--- 修正后的A*算法运行结果 ---")
    print(f"起始节点: {start_node_example}")
    print(f"目标节点: {end_node_example}")
    path = AStar_corrected(start_node_example, end_node_example, example_graph)

    if not path:
        print("未找到路径。")

    # 另一个例子，目标不可达
    print("\n--- 目标不可达示例 ---")
    start_node_example_2 = (0, 0)
    end_node_example_2 = (14, 4)
    # 在(7,0)到(7,4)之间设置一堵墙
    for y in range(5):
        if (7, y) in example_graph:
            example_graph.remove((7, y))

    print(f"起始节点: {start_node_example_2}")
    print(f"目标节点: {end_node_example_2}")
    path_2 = AStar_corrected(start_node_example_2, end_node_example_2, example_graph)
    if not path_2:
        print("未找到路径。")