@cc-component/cc-pathfinding 1.0.1

package/assets/pathfinding/base/GridMovementController.ts

@@ -0,0 +1,257 @@
+import { Component, Node, Tween, tween } from 'cc';
+import { AttackDistance } from './Common';
+import { Cell } from './GridMap';
+import { PathGridStateManager } from './PathGridStateManager';
+import { PathfindingModule } from './PathfindingModule';
+
+export interface GridMovementOptions {
+    /** 每次重试前的等待时间，单位秒 */
+    retryDelay?: number;
+    /** 单格移动动画时长，单位秒 */
+    moveDuration?: number;
+}
+
+/**
+ * 统一管理单位移动、格子占用状态、重试寻路和移动版本控制。
+ * 负责把节点位置、临时占用、动画回调串起来，避免多个单位相互污染同一张地图状态。
+ */
+export class GridMovementController {
+    private readonly movementVersions = new Map<Node, number>();
+    private readonly movementOwners = new Map<Node, symbol>();
+    private readonly movementRetryCallbacks = new Map<Node, () => void>();
+    private readonly positions = new Map<Node, Cell>();
+    private readonly retryDelay: number;
+    private readonly moveDuration: number;
+    private readonly pathState: PathGridStateManager;
+
+    constructor(private readonly scheduler: Component, options: GridMovementOptions = {}) {
+        // 允许外部按场景调整重试间隔和动画时长，默认值保持兼容。
+        this.retryDelay = options.retryDelay ?? 1;
+        this.moveDuration = options.moveDuration ?? 0.5;
+        this.pathState = new PathGridStateManager({
+            isOccupied: (row, col) => PathfindingModule.IsOccupied(row, col),
+            occupy: (row, col) => PathfindingModule.OccupyNode(row, col, true),
+            free: (row, col) => PathfindingModule.FreeNode(row, col),
+        });
+    }
+
+    /** 设定单位当前格子，并同步到节点世界坐标。 */
+    setPosition(playerNode: Node, position: Cell): void {
+        this.positions.set(playerNode, { row: position.row, col: position.col });
+        playerNode.worldPosition = PathfindingModule.GetMapPosition(position.row, position.col);
+    }
+
+    /** 获取单位当前格子，未记录时返回默认起点。 */
+    getPosition(playerNode: Node): Cell {
+        return this.positions.get(playerNode) ?? { row: 0, col: 0 };
+    }
+
+    /**
+     * 开始移动到目标格子。
+     * 1. 先取消旧移动和重试。
+     * 2. 计算路径，路径无效则延时重试。
+     * 3. 成功后进入逐格动画。
+     */
+    moveTo(playerNode: Node, target: Cell, attackDistance: AttackDistance, openColor: boolean, callBack?: () => void): void {
+        const start = this.getPosition(playerNode);
+        if (start.row === target.row && start.col === target.col) {
+            return;
+        }
+
+        this.cancel(playerNode, true);
+        const route = PathfindingModule.TracePath(start, target, attackDistance, openColor);
+        if (!route || route.length === 0 || this.isPathBlocked(start, target, route, attackDistance)) {
+            this.retryPathfinding(playerNode, target, attackDistance, openColor, callBack);
+            return;
+        }
+
+        this.clearPathfindingRetry(playerNode);
+        route.shift();
+        this.startMovement(playerNode, route, start, target, attackDistance, openColor, callBack);
+    }
+
+    /** 强制中止当前移动，可选择保留当前格子的临时占用。 */
+    cancel(playerNode: Node, preserveCurrent = false): void {
+        Tween.stopAllByTarget(playerNode);
+        this.clearPathfindingRetry(playerNode);
+        this.clearMovementRetry(playerNode);
+
+        const owner = this.movementOwners.get(playerNode);
+        if (owner) {
+            this.pathState.release(owner);
+        }
+
+        if (preserveCurrent) {
+            const current = this.getPosition(playerNode);
+            const currentOwner = Symbol(playerNode.name);
+            this.movementOwners.set(playerNode, currentOwner);
+            this.pathState.reserveCurrent(current, currentOwner);
+        } else {
+            this.movementOwners.delete(playerNode);
+        }
+
+        this.bumpVersion(playerNode);
+    }
+
+    /** 销毁控制器，并清理所有单位的动画、重试和格子占用状态。 */
+    destroy(): void {
+        this.movementVersions.clear();
+        this.movementOwners.forEach((owner, playerNode) => {
+            this.pathState.release(owner);
+            Tween.stopAllByTarget(playerNode);
+        });
+        this.movementOwners.clear();
+
+        for (const playerNode of this.movementRetryCallbacks.keys()) {
+            this.clearPathfindingRetry(playerNode);
+            this.clearMovementRetry(playerNode);
+        }
+
+        this.positions.clear();
+    }
+
+    /**
+     * 执行逐格移动。
+     * 每次移动前会尝试保留下一格，失败说明被占用，就重新规划路径或延时重试。
+     */
+    private startMovement(playerNode: Node, route: Cell[], start: Cell, target: Cell, attackDistance: AttackDistance, openColor: boolean, callBack?: () => void): void {
+        const previousOwner = this.movementOwners.get(playerNode);
+        if (previousOwner) {
+            this.pathState.release(previousOwner);
+        }
+        const owner = Symbol(playerNode.name);
+        this.movementOwners.set(playerNode, owner);
+        this.pathState.reserveCurrent(start, owner);
+        const version = this.bumpVersion(playerNode);
+        let previous = start;
+        let index = 0;
+
+        const reachedAttackDistance = () => this.isAttackDistance(previous, target, attackDistance);
+        // 当前格子/目标格子无法继续前进时，重新尝试路径计算或等待下一轮继续。
+        const retry = () => {
+            this.clearMovementRetry(playerNode);
+            if (route.length === 0) {
+                const retryRoute = PathfindingModule.TracePath(previous, target, attackDistance, openColor);
+                if (retryRoute.length <= 1) {
+                    if (reachedAttackDistance()) {
+                        moveNext();
+                    } else {
+                        this.scheduleMovementRetry(playerNode, retry);
+                    }
+                    return;
+                }
+                retryRoute.shift();
+                route.push(...retryRoute);
+                index = 0;
+            }
+            moveNext();
+        };
+
+        const scheduleRetry = () => this.scheduleMovementRetry(playerNode, retry);
+
+        const moveNext = () => {
+            if (version !== this.movementVersions.get(playerNode)) {
+                return;
+            }
+            if (index >= route.length) {
+                if (!reachedAttackDistance()) {
+                    route.length = 0;
+                    scheduleRetry();
+                    return;
+                }
+                this.clearMovementRetry(playerNode);
+                callBack?.();
+                return;
+            }
+
+            const next = route[index];
+            // 只要下一格被占用，就不继续移动，重新规划路线，避免穿透同一格子。
+            if (!this.pathState.tryReserve(previous, next, owner)) {
+                this.pathState.release(owner);
+                PathfindingModule.OccupyNode(previous.row, previous.col, true);
+                const newRoute = PathfindingModule.TracePath(previous, target, attackDistance, openColor);
+                if (newRoute.length > 1) {
+                    newRoute.shift();
+                    route.splice(0, route.length, ...newRoute);
+                    index = 0;
+                } else if (reachedAttackDistance()) {
+                    callBack?.();
+                    return;
+                } else {
+                    route.length = 0;
+                }
+                scheduleRetry();
+                return;
+            }
+
+            tween(playerNode)
+                .to(this.moveDuration, { worldPosition: PathfindingModule.GetMapPosition(next.row, next.col) })
+                .call(() => {
+                    this.pathState.completeMove(previous, next, owner);
+                    this.positions.set(playerNode, { row: next.row, col: next.col });
+                    previous = next;
+                    index++;
+                    moveNext();
+                })
+                .start();
+        };
+
+        moveNext();
+    }
+
+    /** 路径规划失败时，做一次延迟重试，避免因为瞬时占用导致立刻失败。 */
+    private retryPathfinding(playerNode: Node, target: Cell, attackDistance: AttackDistance, openColor: boolean, callBack?: () => void): void {
+        this.clearPathfindingRetry(playerNode);
+        const retry = () => {
+            this.clearPathfindingRetry(playerNode);
+            this.moveTo(playerNode, target, attackDistance, openColor, callBack);
+        };
+        this.movementRetryCallbacks.set(playerNode, retry);
+        this.scheduler.scheduleOnce(retry, this.retryDelay);
+    }
+
+    /** 移动过程中的中断重试，通常用于路径被占用或目标暂时不可达。 */
+    private scheduleMovementRetry(playerNode: Node, retry: () => void): void {
+        this.clearMovementRetry(playerNode);
+        this.movementRetryCallbacks.set(playerNode, retry);
+        this.scheduler.scheduleOnce(retry, this.retryDelay);
+    }
+
+    private clearPathfindingRetry(playerNode: Node): void {
+        const retry = this.movementRetryCallbacks.get(playerNode);
+        if (retry) {
+            this.scheduler.unschedule(retry);
+            this.movementRetryCallbacks.delete(playerNode);
+        }
+    }
+
+    private clearMovementRetry(playerNode: Node): void {
+        const retry = this.movementRetryCallbacks.get(playerNode);
+        if (retry) {
+            this.scheduler.unschedule(retry);
+            this.movementRetryCallbacks.delete(playerNode);
+        }
+    }
+
+    /** 每次启动/取消移动时更新版本号，旧动画和旧重试都会被忽略。 */
+    private bumpVersion(playerNode: Node): number {
+        const version = (this.movementVersions.get(playerNode) ?? 0) + 1;
+        this.movementVersions.set(playerNode, version);
+        return version;
+    }
+
+    private isPathBlocked(start: Cell, target: Cell, route: Cell[], attackDistance: AttackDistance): boolean {
+        if (route.length !== 1) {
+            return false;
+        }
+        return !this.isAttackDistance(start, target, attackDistance);
+    }
+
+    private isAttackDistance(start: Cell, target: Cell, attackDistance: AttackDistance): boolean {
+        return PathfindingModule.IsAttackDistance(
+            PathfindingModule.GetMapModel(start.row, start.col),
+            PathfindingModule.GetMapModel(target.row, target.col),
+            attackDistance,
+        );
+    }
+}

package/assets/pathfinding/base/GridMovementController.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "5b0e786e-7b99-447b-ae52-12e9c8a10e70",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/IMapData.ts

@@ -0,0 +1,13 @@
+import { Sprite, Node, Vec3 } from "cc";
+
+export interface IMapData {
+    col: number
+    row: number
+    position: Vec3
+    node: Node;
+    node_sp: Sprite;
+    node_chose_sp: Sprite;
+    bottom_positon: Vec3;
+
+}
+

package/assets/pathfinding/base/IMapData.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "46edad01-0ea3-4d52-957f-edf0abfd3cae",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/IPlayerBuff.ts

@@ -0,0 +1 @@
+

package/assets/pathfinding/base/IPlayerBuff.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "c4d84f04-c054-4cc4-9a3d-0ffd162d95d1",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/MapBoxView.ts

@@ -0,0 +1,386 @@
+import { _decorator, Component, UITransform, Vec3, v3 } from 'cc';
+import { MapViewModel } from './MapViewModel';
+import { Sprite } from 'cc';
+import { Color } from 'cc';
+import { AttackDistance } from './Common';
+import { Mapitem } from './Mapitem';
+import { instantiate } from 'cc';
+import { Cell, GridMap } from './GridMap';
+import { AStarPathfinder } from './AStarPathfinder';
+const { ccclass, property } = _decorator;
+
+/**
+ * 地图格子视图层
+ *
+ * 三层分离架构中的视图层，只负责：
+ *  1. 生命周期与地图初始化（格子创建、蜂窝/方格布局）
+ *  2. 颜色渲染（占用红 / 路径绿 / 起点黄 / 终点蓝）
+ *  3. 对外业务编排（TracePath 等，算法与数据全部委托给逻辑层）
+ *
+ * 逻辑层：
+ *  - GridMap          网格数据 / 占用 / 方向 / 距离 / 包围判断
+ *  - AStarPathfinder  A* 寻路算法 / 攻击位查找
+ */
+@ccclass('MapBoxView')
+export class MapBoxView extends Component {
+
+    // ==================== 1. 编辑器属性 ====================
+
+    @property({ type: Mapitem })
+    mapItem: Mapitem;
+    @property()
+    row = 6;
+    @property()
+    col = 6;
+    @property({ displayName: "顶部偏移位置" })
+    topStart = 50
+    /** 六方向模式：开启后按蜂窝规则（左上/左/左下/右上/右/右下）移动、寻路、判包围 */
+    @property({ tooltip: '开启后按蜂窝(六方向)规则寻路：左上/左/左下/右上/右/右下' })
+    useSixDirection = true
+
+    // ==================== 2. 内部数据 ====================
+
+    seat_model_list: MapViewModel[][] = [];
+    item_width = 125;
+    item_height = 110;
+    content_tf: UITransform;
+
+    /** 逻辑层：网格数据 + 寻路算法 */
+    grid: GridMap;
+    pathfinder: AStarPathfinder;
+    private colorVisible = true;
+
+    protected onLoad(): void {
+        this.content_tf = this.node.getComponent(UITransform);
+        this.grid = new GridMap(this.row, this.col, this.useSixDirection);
+        this.pathfinder = new AStarPathfinder(this.grid);
+        PathfindingModule.Init(this);
+    }
+
+    onDestroy() {
+        PathfindingModule.Destroy();
+    }
+
+    // ==================== 3. 视图：地图初始化 ====================
+
+    /** 创建整张地图（六方向模式：奇数行右移半格的蜂窝交错布局） */
+    InitView() {
+        this.node.removeAllChildren();
+        this.item_width = this.mapItem.node.getComponent(UITransform).contentSize.width;
+        this.item_height = this.mapItem.node.getComponent(UITransform).contentSize.height;
+
+        const start_x = this.content_tf.contentSize.width / 2
+        const start_y = this.content_tf.contentSize.height / 2
+        const space_x = this.item_width / 2;
+        const space_y = this.item_height / 2;
+
+        const padding_left = this.item_height / 2
+        let top = 0
+
+        for (let i = 0; i < this.row; i++) {
+            this.seat_model_list[i] = [];
+            top += i > 0 ? this.topStart : 0
+            for (let j = 0; j < this.col; j++) {
+                const model = new MapViewModel();
+                model.row = i;
+                model.col = j;
+                const node = instantiate(this.mapItem.node);
+                this.node.addChild(node);
+                node.name = `${i}_${j}`
+                const mapItem = node.getComponent(Mapitem);
+                mapItem.row = i
+                mapItem.col = j
+
+                const pos = v3(
+                    this.item_width * j + space_x + (i % 2 === 1 ? (this.useSixDirection ? padding_left : 0) : 0) - start_x,
+                    -(this.item_height * i + space_y - (this.useSixDirection ? top : 0)) + start_y,
+                    0);
+                model.position = this.content_tf.convertToWorldSpaceAR(pos);
+                model.bottom_positon = v3(model.position.x, model.position.y - this.item_height / 2, 0);
+
+                node.worldPosition = model.position;
+
+                model.node = node;
+                model.node_sp = mapItem.bg
+                model.node_chose_sp = mapItem.bgHighlight
+                this.seat_model_list[i][j] = model;
+            }
+        }
+    }
+
+    // ==================== 4. 视图：地图数据查询 ====================
+
+    GetMapModel(row: number, col: number): MapViewModel {
+        return this.seat_model_list[row][col];
+    }
+
+    GetMapPosition(row: number, col: number): Vec3 {
+        return this.seat_model_list[row][col].position;
+    }
+
+    GetSeatModelList() {
+        return this.seat_model_list;
+    }
+
+    // ==================== 5. 逻辑委托：距离 / 方向 ====================
+
+    /** 两格之间的距离（八方向：切比雪夫，命名保留兼容） */
+    getManhattanDistance(model1: MapViewModel, model2: MapViewModel): number {
+        return this.grid.getChebyshevDistance(model1, model2);
+    }
+
+    /** 是否在攻击距离内 */
+    IsAttackDistance(model1: MapViewModel, model2: MapViewModel, maxDistance: number): boolean {
+        return this.grid.getChebyshevDistance(model1, model2) <= maxDistance;
+    }
+
+    /** 获取从 row 行出发的移动方向偏移（六方向蜂窝 / 八方向） */
+    getDirections(row: number): [number, number][] {
+        return this.grid.getDirections(row);
+    }
+
+    /** 判断两个格子是否相邻（按当前模式的移动规则） */
+    isNeighborCell(a: Cell, b: Cell): boolean {
+        return this.grid.isNeighborCell(a, b);
+    }
+
+    // ==================== 6. 逻辑委托：占用（含高亮渲染） ====================
+
+    isOccupied(row: number, col: number): boolean {
+        return this.grid.isOccupied(row, col);
+    }
+
+    occupyNode(row: number, col: number, openColor?: boolean) {
+        this.grid.occupy(row, col);
+        const seatModel = this.GetMapModel(row, col);
+        if (openColor && this.colorVisible) {
+            seatModel.node_chose_sp.color = Color.RED;
+            seatModel.node_chose_sp.node.active = true
+        } else {
+            seatModel.node_chose_sp.color = Color.WHITE;
+            seatModel.node_chose_sp.node.active = false
+        }
+    }
+
+    /** row/col < 0 时释放全部 */
+    freeNode(row: number, col: number) {
+        if (row < 0 || col < 0) {
+            this.grid.freeAll();
+            this.clearColorAll();
+        } else {
+            this.grid.free(row, col);
+            this.clearColortarget(row, col);
+        }
+    }
+
+    GetOccupyNodeNot() {
+        return this.grid.getOccupiedSet();
+    }
+
+    // ==================== 7. 逻辑委托：寻路 / 攻击位 / 包围 ====================
+
+    /** A* 寻路：返回起点到终点的路径（含起终点），找不到返回空数组 */
+    findPath(startRow: number, startCol: number, endRow: number, endCol: number): Cell[] {
+        return this.pathfinder.findPath({ row: startRow, col: startCol }, { row: endRow, col: endCol });
+    }
+
+    /**
+     * 找到"从 start 出发、能走到 end 身边"的路径：
+     * 动态扩大搜索半径，找 end 周围可站且 A* 可达的最近格子。
+     */
+    FindPathPoint(start: Cell, end: Cell, maxDistance: number): Cell[] {
+        return this.pathfinder.findPathToNearby(start, end, maxDistance);
+    }
+
+    /** 判断目标点是否被包围 */
+    isClosedLoop(targetRow: number, targetCol: number, maxDistance: number): boolean {
+        return this.grid.isClosedLoop(targetRow, targetCol, maxDistance);
+    }
+
+    /** 检查目标周围的点（不判断占用，仅范围内所有点） */
+    checkAvailableSurrounding(targetRow: number, targetCol: number, maxDistance: number): Cell[] {
+        return this.grid.checkAvailableSurrounding(targetRow, targetCol, maxDistance);
+    }
+
+    // ==================== 8. 对外业务编排 ====================
+
+    /** 寻路并显示路径，返回路径上的 MapViewModel 列表 */
+    FindRote(start: Cell, end: Cell) {
+        const path = this.findPath(start.row, start.col, end.row, end.col);
+        const seat_model_list: MapViewModel[] = []
+        if (path.length > 0) {
+            path.forEach((node, index) => {
+                const seatModel = this.GetMapModel(node.row, node.col);
+                seatModel.node_chose_sp.color = Color.GREEN;
+                // 起点标记为黄色
+                if (index === 0) {
+                    seatModel.node_chose_sp.color = Color.YELLOW;
+                }
+                seat_model_list.push(seatModel)
+            });
+        } else {
+            console.log('No path found');
+        }
+        return seat_model_list
+    }
+
+    /** 计算路径：只负责寻找起点到终点/附近可站点的路径，不处理渲染 */
+    private computeTracePath(start: Cell, end: Cell, attackDis: AttackDistance): Cell[] {
+        // 起点即终点
+        if (start.row === end.row && start.col === end.col) {
+            return [start]
+        }
+
+        let list = this.pathfinder.findPathToNearby(start, end, 1);
+
+        // 如果只有 2 个点（起点 + 终点），处理"很近"的边界情况
+        if (list.length === 2) {
+            if (this.grid.useSixDirection) {
+                // 六方向：相邻时终点保留为终点
+                if (this.grid.isNeighborCell(start, end)) {
+                    list = list.slice(0, 1)
+                    list.push({ row: end.row, col: end.col })
+                }
+            } else {
+                // 原逻辑：攻击距离为 0 且终点被占用时，去掉终点
+                const last = list[list.length - 1]
+                if (attackDis == AttackDistance.attack_0 && this.grid.isOccupied(last.row, last.col)) {
+                    list.pop()
+                }
+            }
+        }
+
+        // 没有结束点就补上结束点
+        const hasEnd = list.some((element) => element.row == end.row && element.col == end.col);
+        if (!hasEnd) {
+            list.push({ row: end.row, col: end.col })
+        }
+
+        return list;
+    }
+
+    /** 根据攻击距离裁剪路径，只返回真实可走到的有效段，不处理渲染 */
+    private trimPathByAttackDistance(path: Cell[], attackDis: AttackDistance): Cell[] {
+        if (path.length === 0) {
+            return path;
+        }
+
+        let index = 0;
+        if (attackDis > path.length) {
+            // 攻击距离覆盖整条路径：站在原地就能打到
+            index = 0;
+        } else {
+            // 截断到攻击距离处
+            index = path.length - 1 - attackDis
+            // 末位不可站就退后一格，站到真实可达的最近点上：
+            //  1. 末端两点不连续 → 末尾是补上去的“假终点”（目标被围住，走不到）
+            //  2. 末位被占用 → 终点被占（敌人站在终点上），不能踩上去
+            if (attackDis <= 0 && path.length >= 2) {
+                const last = path[path.length - 1];
+                const isContinuous = this.grid.isNeighborCell(path[path.length - 2], last);
+                if (!isContinuous || this.grid.isOccupied(last.row, last.col)) {
+                    index = path.length - 2;
+                }
+            }
+        }
+
+        return path.filter((_, i) => i <= index);
+    }
+
+    /** 只负责渲染路径颜色，不处理搜索与裁剪逻辑 */
+    private renderPath(path: Cell[], openColor?: boolean): void {
+        if (!path || path.length === 0 || !this.colorVisible) {
+            return;
+        }
+
+        if (openColor) {
+            const stopCell = path[path.length - 1];
+            const stopModel = this.GetMapModel(stopCell.row, stopCell.col);
+            stopModel.node.children[1].getComponent(Sprite).color = Color.YELLOW;
+        }
+        path.forEach((model, index) => {
+            const seatModel = this.GetMapModel(model.row, model.col);
+            seatModel.node_chose_sp.color = Color.GREEN;
+            if (openColor) {
+                seatModel.node_chose_sp.node.active = true
+            }
+            if (index === path.length - 1) {
+                seatModel.node_chose_sp.color = Color.BLUE;
+            }
+        })
+
+
+    }
+
+    /**
+     * 寻路主入口：从 start 走到 end 身边的攻击位。
+     * - attackDis：攻击距离，用于截断路径（只需走到攻击范围内即可）
+     * - openColor：是否高亮显示
+     */
+    TracePath(start: Cell, end: Cell, attackDis: AttackDistance, openColor?: boolean): Cell[] {
+        if (!openColor) {
+            this.ClearColor()
+        }
+
+        const path = this.computeTracePath(start, end, attackDis);
+        const validPath = this.trimPathByAttackDistance(path, attackDis);
+        this.renderPath(validPath, openColor);
+
+        return validPath;
+    }
+
+    // ==================== 9. 显示辅助 ====================
+
+    /** 开启或关闭所有格子的高亮颜色 */
+    SetColorVisible(visible: boolean) {
+        this.colorVisible = visible;
+        this.seat_model_list.forEach(list => {
+            list.forEach(item => {
+                if (!this.grid.isOccupied(item.row, item.col)) {
+                    item.node_chose_sp.node.active = visible;
+                    if (!visible) {
+                        item.node_chose_sp.color = Color.WHITE;
+                    }
+                }
+            })
+        })
+    }
+
+    /** 清除路径颜色（保留被占用格子的红色高亮） */
+    ClearColor() {
+        this.seat_model_list.map(list => {
+            list.map(item => {
+                if (!this.grid.isOccupied(item.row, item.col)) {
+                    item.node_chose_sp.color = Color.WHITE;
+                    item.node_chose_sp.node.active = false
+                }
+            })
+        })
+    }
+
+    /** 清除所有高亮 */
+    clearColorAll() {
+        this.seat_model_list.forEach(list => {
+            list.forEach(map => {
+                map.node_chose_sp.node.active = false
+            })
+        })
+    }
+
+    /** 清除所有高亮 */
+    clearColortarget(row: number, col: number) {
+        this.seat_model_list[row][col].node_chose_sp.color = Color.WHITE;
+        this.seat_model_list[row][col].node_chose_sp.node.active = false
+    }
+
+    /** 显示/隐藏下半部分地图块（row >= 3） */
+    ShowBox(show: boolean) {
+        this.seat_model_list.map(list => {
+            list.map(item => {
+                if (item.row >= 3) {
+                    item.node_sp.node.active = show;
+                }
+            })
+        })
+    }
+}