// A*算法 Node 类，用于存储节点信息class Node {  constructor(parent = null, position = null) {    this.parent = parent;    // 父节点    this.position = position; // 节点在网格中的坐标位置    this.g = 0;              // G值是从起点走到当前格子的成本    this.h = 0;              // H值是当前格子到终点的估计成本    this.f = 0;              // F值是G值和H值的总和  }
  // 判断两个节点是否位于同一个位置  isEqual(otherNode) {    return this.position[0] === otherNode.position[0] && this.position[1] === otherNode.position[1];  }}
// 启发式函数，用于估计到达目标的成本（此处使用曼哈顿距离）function heuristic(nodeA, nodeB) {  const d1 = Math.abs(nodeB.position[0] - nodeA.position[0]);  const d2 = Math.abs(nodeB.position[1] - nodeA.position[1]);  return d1 + d2;}
// 获取一个节点的所有可能的邻居（包括对角线上的位置）function getNeighbors(currentNode, grid) {  const neighbors = [];  // 这里包括了八个方向上的移动  const directions = [    [-1, -1], [-1, 0], [-1, 1], // 左上 左 左下    [0, -1], [0, 1],  // 上    下    [1, -1], [1, 0], [1, 1],     // 右上 右 右下  ];
  // 查看每个方向的邻居是否可通行（非障碍）且在网格范围内  for (const direction of directions) {    const neighborPos = [      currentNode.position[0] + direction[0],      currentNode.position[1] + direction[1],    ];
    // 确保位置在网格内且不是障碍物    if (      neighborPos[0] >= 0 && neighborPos[0] < grid.length &&      neighborPos[1] >= 0 && neighborPos[1] < grid[0].length &&      grid[neighborPos[0]][neighborPos[1]] === 1    ) {      neighbors.push(new Node(currentNode, neighborPos));    }  }
  return neighbors;}
// A* 算法主函数function aStar(grid, start, end) {  const startNode = new Node(null, start);  const endNode = new Node(null, end);
  let openSet = [startNode]; // 存储待检查的节点  let closedSet = []; // 存储已检查的节点
  while (openSet.length > 0) {    console.log('startNode');    // 在openSet中找到F值最低的节点    let lowestIndex = 0;    for (let i = 0; i < openSet.length; i++) {      if (openSet[i].f < openSet[lowestIndex].f) {        lowestIndex = i;      }    }
    let currentNode = openSet[lowestIndex];
    // 如果当前节点是目的地，那么我们再次构造路径    if (currentNode.isEqual(endNode)) {      let path = [];      let current = currentNode;      while (current != null) {        path.push(current.position);        current = current.parent;      }      return path.reverse(); // 把数组反转，因为我们是从终点回溯到起点存储的    }
    // 当前节点已经被处理过，移出openSet，并加入closedSet    openSet.splice(lowestIndex, 1);    closedSet.push(currentNode);
    // 找到所有邻居    let neighbors = getNeighbors(currentNode, grid);    for (let neighbor of neighbors) {      // 如果邻居是不可访问的或已在closedSet中，忽略它们
      // 如果这个邻居在关闭列表中，跳过它      if (closedSet.some(closedNode => closedNode.isEqual(neighbor))) {        continue;      }
        // 对角线移动的成本要考虑 √2        // 通过查看相邻节点和当前节点的坐标差来判断是否为对角移动          const isDiagonalMove =            Math.abs(currentNode.position[0] - neighbor.position[0]) === 1 &&            Math.abs(currentNode.position[1] - neighbor.position[1]) === 1;
          // 对角线移动的成本假定为 √2，其他为1          const tentativeG = currentNode.g + (isDiagonalMove ? Math.sqrt(2) : 1);
          // 如果新的G值更低，或者邻居节点不在开放列表中          let openNode = openSet.find(openNode => openNode.isEqual(neighbor));          if (!openNode || tentativeG < neighbor.g) {            neighbor.g = tentativeG;            neighbor.h = heuristic(neighbor, endNode);  // H值不变，因为它是启发式估计到终点的成本            neighbor.f = neighbor.g + neighbor.h;            neighbor.parent = currentNode;
            // 如果邻居节点不在开放列表中，加入开放列表            if (!openNode) {              openSet.push(neighbor);            }          }        }      }      // 如果循环结束还没有到达终点，表示没有路径到达终点      return [];    }

// 远景x轴速率export const parallaxFactorFarX = 0.2;// 远景y轴速率export const parallaxFactorFarY = 0.2;// 初始坐标export const farOriginXY = [0, -60];
// 近景x轴速率export const parallaxFactorNearX = 1.8;// 近景y轴速率export const parallaxFactorNearY = 1.05;// 初始坐标export const nearOriginXY = [0, gameHeightBounds - 420];
const { scrollX, scrollY } = this.scene.cameras.main;if (scrollX >= 0 && scrollX <= 750 && scrollY >= 0 && this.bgFar && this.bgNear) {  this.bgFar.x = -scrollX * parallaxFactorFarX;  this.bgFar.y = -scrollY * parallaxFactorFarY + farOriginXY[1];  this.bgNear.x = -scrollX * parallaxFactorNearX;  this.bgNear.y = -scrollY * parallaxFactorNearY + nearOriginXY[1];}

// 划分区间const divideRegional = (blocks: Array<{ id: number, bottomY: number }>) => {  blocks.sort((a, b) => a.bottomY - b.bottomY);  return blocks.map((item, idx) => {    const nextBottomY = blocks[idx + 1] ? blocks[idx + 1].bottomY : Infinity;    return {      regional: [(idx + 1) * 100, (idx + 1) * 100 + 100],      range: [item.bottomY, nextBottomY],      ...item    }  })}
// 行走时的判断const currentY = chicken.getPosition().y + 130;const currentRegion = regionals.find((rengional) => {  const [start, end] = rengional.range;  return currentY >= start && currentY <= end;})if (currentRegion) {  chicken.setDepth(currentRegion.regional[0] + 1);} else {  chicken.setDepth(99);}

function ProcessTimer() {  let id = 0;  let hasEmit = false;  const timers = {};  const flags = {};  const types: any = {};  let func: any;
  const run = (cb) => {    func = cb;  };
  const startTimer = (type, delayTime) => {    // 触发过或者定时器存在    if (hasEmit || timers[type]) return;    timers[type] = setTimeout(() => {      flags[type] = true;      checkTimer();    }, delayTime);  };
  const checkTimer = () => {    const keys = Object.keys(timers) || [];    const notSatisfied = keys.find((key) => !flags[key]);
    // 满足所有的条件，出任务触点，只出一次    if (!notSatisfied && !hasEmit) {      hasEmit = true;      clearAllTimer();
      if (func && typeof func === 'function') {        func();      }    }  };
  const clearAllTimer = () => {    const keys = Object.keys(timers) || [];    keys.forEach((key) => {      clearTimer(key);    });  };
  const clearTimer = (type) => {    flags[type] = false;
    if (timers[type]) {      clearTimeout(timers[type]);      timers[type] = null;    }  };
  const create = (delayTime = 8000) => {    const type = `timer${id++}`;    timers[type] = null; // 所有定时器    flags[type] = false;    types[type] = delayTime;
    return {      start: () => {        startTimer(type, delayTime);      },      end: () => {        clearTimer(type);      },      type,    };  };
  const reset = () => {    hasEmit = false;  }
  return {    create,    run,    clearAllTimer,    reset,  };}
export default ProcessTimer;