淘宝互动游戏之我养的鸡要旅行

// 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;