@cc-component/cc-pathfinding 1.0.1

package/assets/pathfinding/base/Common.ts

@@ -0,0 +1,342 @@
+
+
+export enum HeroType {
+    Hero = 1,
+    Home = 2,
+    XiaoBing = 3,
+
+}
+export enum RaceType {
+    /**人族 */
+    Ren = 0,
+    /**兽族 */
+    Shou = 1,
+    /**精灵 */
+    JingLin = 2,
+    /**魔族 */
+    BOSS = 3
+}
+export enum AttackDistance {
+    attack_0 = 0,
+    attack_1 = 1,
+    attack_2 = 2,
+    attack_3 = 3,
+    attack_4 = 4,
+    attack_5 = 5,
+    attack_6 = 6,
+    attack_7 = 7,
+    attack_8 = 8,
+    attack_9 = 9,
+    attack_10 = 10
+}
+export enum PlayerAnimation {
+    NONE = "NONE",
+    IDLE = "idle",
+    WALK = "walk",
+    ATTACK = "attack",
+    DEAD = "dead",
+
+}
+export const AttackDistanceConfig = {
+    [100]: AttackDistance.attack_1,
+    [200]: AttackDistance.attack_2,
+    [300]: AttackDistance.attack_3,
+    [400]: AttackDistance.attack_4,
+    [500]: AttackDistance.attack_5,
+}
+
+
+export interface IBaseSkill {
+    /**技能图标 */
+    iconPath: string;
+    /**是否添加技能 */
+    isAdd: boolean;
+    /**技能名称 */
+    name: string
+    /**技能描述 */
+    des: string;
+    /**buff类型 */
+    buffType: BuffType;
+    /**技能id */
+    id: number;
+}
+
+export enum PlayerCamp {
+    None = -1,
+    Red = 1,
+    Blue = 2,
+    Yellow = 3,
+    Green = 4,
+    White = 5,
+    Black = 6,
+    Purple = 7,
+    Orange = 8,
+    Pink = 9,
+    Gray = 10,
+    Brown = 11,
+    Cyan = 12,
+    Magenta = 13,
+    Turquoise = 14,
+}
+export enum BuffType {
+    Buff_none = -1,
+
+    /**暴击 */
+    Buff_BaoJi = 1,
+    /**暴击 */
+    Buff_BaoJi_zd,
+    /** 杀死敌人增加攻击力，2.5% */
+    AttackAdd,
+    /** 杀死敌人增加攻击速度，2.5% */
+    AttackAddSpeed,
+
+    /**加攻速-光环 */
+    AttackSpeedAll,
+    AttackSpeedAll_zd,
+    /**加攻击力-光环-百分比 */
+    AttackValueScaleAll,
+    AttackValueScaleAll_zd,
+
+
+    /**加固定攻击力-光环 */
+    AttackValueAll,
+    AttackValueAll_zd,
+
+    /**死亡加金币 */
+    DeadAddCoin,
+    /**吸血 */
+    Buff_XiXie,
+    Buff_XiXie_zd,
+    /**中毒百分比 */
+    Buff_DuScale,
+    Buff_DuScale_zd,
+    /**中毒固定 */
+    Buff_Du,
+    Buff_Du_zd,
+    /**攻击百分比伤害 */
+    AttackScale,
+    AttackScale_zd,
+
+
+    /**伤害减免*/
+    DamageReduction,
+    DamageReduction_zd,
+
+    /**伤害减免-固定值 */
+    DamageReductionGD,
+    DamageReductionGD_zd,
+
+    /**加物理防御和魔法防御 */
+    // Defense,
+    // Defense_zd,
+
+    /**魔法防御-物理防御 */
+    PhysicalDdefense,
+    MagicDefense,
+    /**破甲-魔法 */
+    Buff_PoJia_MF,
+    Buff_PoJia_MF_zd,
+    /**破甲-物理 */
+    Buff_PoJia_WL,
+    Buff_PoJia_WL_zd,
+
+    /** 眩晕*/
+    Buff_XuanYun,
+    Buff_XuanYun_baotou,
+    Buff_XuanYun_zd,
+    /**生命-固定 */
+    HP,
+    //HP_zd,
+    /**生命-百分比 */
+    HPScale,
+    //HPScale_zd,
+
+    // Buff_DianRan_zd,
+
+
+
+
+    /**闪避率 */
+    Dodge,
+    /**命中率 */
+    Hit,
+    /**生命回复-固定 */
+    HPAdd,
+    /**生命回复-百分比 */
+    HPAddScale,
+    /**魔法回复-固定 */
+    MPAdd,
+    /**点燃 */
+    Buff_DianRan,
+    //主动技能>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+    /**雷电术 */
+    Lightning = 200,
+    /**冰冻术 */
+    BDS,
+    /**流星雨 */
+    LXY,
+    /**冰咆哮-范围 */
+    BPX,
+
+}
+
+
+export enum AttackType {
+    /**物理攻击 */
+    Physical = 1,
+    /**魔法攻击 */
+    Magic = 2,
+}
+export enum AttackTypeBullet {
+    /**抛物线 */
+    Parabola = 1,
+    /**直线 */
+    Line = 2,
+}
+
+// export class TWeapon {
+//     id: ZBType;
+//     name: string;
+//     long: boolean;//长期永久装备
+//     iconPath: string;
+//     des_list: string[];
+//     des_skill_list: string[];
+//     buffList: BaseSkill[] = [];
+//     isZhuDong: boolean;//是主动技能
+
+
+//     constructor(weaponData?: TWeapon) {
+//         if (weaponData) {
+//             // 创建目标类型的新实例
+//             const instance = this
+//             // 深拷贝所有属性
+//             Object.keys(weaponData).forEach(key => {
+//                 const value = weaponData[key as keyof TWeapon];
+//                 if (Array.isArray(value)) {
+//                     // 特殊处理 BaseSkill 数组
+//                     if (key === 'buffList') {
+//                         // 对 BaseSkill[] 进行深度克隆
+//                         (instance as any)[key] = (value as BaseSkill[]).map(skill => {
+//                             const newSkill = new BaseSkill();
+//                             return Object.assign(newSkill, skill);
+//                         });
+//                     } else {
+//                         // 对其他数组进行浅拷贝
+//                         (instance as any)[key] = [...value];
+//                     }
+//                 } else {
+//                     // 对基本类型和对象引用进行浅拷贝
+//                     (instance as any)[key] = value;
+//                 }
+//             });
+//         }
+//     }
+//     /**
+//      * 深克隆方法，用于将当前实例转换为指定的子类类型，同时处理嵌套对象
+//      * @param ctor - 目标类的构造函数
+//      * @returns 返回指定类型的实例，包含当前实例的所有属性值（深度复制）
+//      * @template T - 继承自 TWeapon 的泛型类型
+//      */
+//     deepClone<T extends TWeapon>(ctor: new () => T): T {
+//         // 创建目标类型的新实例
+//         const instance = new ctor();
+//         // 深拷贝所有属性
+//         Object.keys(this).forEach(key => {
+//             const value = this[key as keyof TWeapon];
+//             if (Array.isArray(value)) {
+//                 // 特殊处理 BaseSkill 数组
+//                 if (key === 'buffList') {
+//                     // 对 BaseSkill[] 进行深度克隆
+//                     (instance as any)[key] = (value as any[]).map(skill => {
+//                         const newSkill = new BaseSkill();
+//                         return Object.assign(newSkill, skill);
+//                     });
+//                 } else {
+//                     // 对其他数组进行浅拷贝
+//                     (instance as any)[key] = [...value];
+//                 }
+//             } else {
+//                 // 对基本类型和对象引用进行浅拷贝
+//                 (instance as any)[key] = value;
+//             }
+//         });
+
+//         return instance;
+//     }
+// }
+
+// export class TWeapon extends TWeapon {
+//     /**是否携带武器 */
+//     is_carry = false;
+//     /**
+//      * 构造函数，可选择性地使用 Partial<TWeapon> 对象初始化属性
+//      * @param weaponData - 包含部分或全部 TWeapon 属性的对象，用于初始化实例
+//      */
+//     constructor(weaponData?: TWeapon) {
+//         super();
+//         if (weaponData) {
+//             // 使用 Object.assign 将传入对象的属性复制到当前实例
+//             Object.assign(this, weaponData);
+//         }
+//     }
+// }
+
+export class BaseSkill implements IBaseSkill {
+    /**技能id */
+    id: number;
+    /**技能名称 */
+    name: string;
+    /**技能图标*/
+    iconPath: string;
+    /**技能类型*/
+    buffType: BuffType;
+    /**是被动技能还是主动技能,默认主动技能*/
+    isZhuDong: boolean = true;
+    /**技能描述 */
+    des: string;
+    /**技能时间 */
+    time: number = 0
+    /**技能值 */
+    attackValue: number = 0
+    /**概率触发 */
+    attackValueRatio: number = 0
+    /**是否群体技能 */
+    isAll: boolean = false
+    //#region 动态属性
+    /*释放技能*/
+    isPlaySkill: boolean = false
+    /**是否添加了这个技能 */
+    isAdd: boolean;
+
+    constructor(data?: BaseSkill) {
+        Object.assign(this, data)
+
+    }
+
+}
+
+/**英雄类型 */
+export enum PlayerType {
+    /**士兵 */
+    shibing = 0,
+    /**火枪手 */
+    huo_qiang = 1,
+    /**火枪手 */
+    qs = 2,
+    /**飞机 */
+    fei_ji = 3,
+    /**圣骑士 */
+    sqs = 4,
+    /**山丘之王 */
+    sqzw = 5,
+    /**牧师 */
+    mu_shi = 6,
+    /**光明女巫 */
+    nw = 7,
+    /**天空骑士 */
+    tkqs = 8,
+    /**大魔法师 */
+    dmfs = 9,
+    /**火魔法师 */
+    hmfs = 10
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "149ef51b-697e-469e-8ba6-1feb40e9e2b6",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/GridMap.ts

@@ -0,0 +1,314 @@
+/**
+ * 网格数据层（纯逻辑，不依赖任何 cc 视图，可独立单元测试）
+ *
+ * 职责：
+ *  1. 边界 / 占用管理
+ *  2. 方向规则（八方向 / 六方向蜂窝，蜂窝按行奇偶取对角）
+ *  3. 距离计算（蜂窝步数 / 切比雪夫 / 曼哈顿）
+ *  4. 范围查询（目标周围可站点等）
+ *  5. 包围判断（四方向原逻辑 / 蜂窝逻辑）
+ */
+
+/** 格子坐标 */
+export type Cell = { row: number; col: number };
+
+/** 格子的唯一 key："row,col" */
+export function cellKey(row: number, col: number): string {
+    return `${row},${col}`;
+}
+
+export class GridMap {
+
+    readonly rowCount: number;
+    readonly colCount: number;
+    /** 六方向模式：按蜂窝规则（左上/左/左下/右上/右/右下）移动、寻路、判包围 */
+    readonly useSixDirection: boolean;
+
+    /** 被占用格子的 key 集合 */
+    private readonly occupied: Set<string> = new Set();
+
+    constructor(rowCount: number, colCount: number, useSixDirection: boolean) {
+        this.rowCount = rowCount;
+        this.colCount = colCount;
+        this.useSixDirection = useSixDirection;
+    }
+
+    // ==================== 1. 边界 / 占用 ====================
+
+    /** 检查格子是否在地图范围内 */
+    isWithinBounds(row: number, col: number): boolean {
+        return row >= 0 && row < this.rowCount && col >= 0 && col < this.colCount;
+    }
+
+    isOccupied(row: number, col: number): boolean {
+        return this.occupied.has(cellKey(row, col));
+    }
+
+    occupy(row: number, col: number): void {
+        this.occupied.add(cellKey(row, col));
+    }
+
+    free(row: number, col: number): void {
+        this.occupied.delete(cellKey(row, col));
+    }
+
+    freeAll(): void {
+        this.occupied.clear();
+    }
+
+    /** 被占用格子的 key 集合（兼容旧接口 GetOccupyNodeNot） */
+    getOccupiedSet(): Set<string> {
+        return this.occupied;
+    }
+
+    // ==================== 2. 方向 / 距离 ====================
+
+    /**
+     * 六方向（蜂窝）模式下两格之间的步数距离
+     * 奇数行右移半格的交错布局（odd-r）：offset 转 cube 坐标
+     */
+    getHexDistance(row1: number, col1: number, row2: number, col2: number): number {
+        const x1 = col1 - (row1 - (row1 & 1)) / 2;
+        const z1 = row1;
+        const y1 = -x1 - z1;
+        const x2 = col2 - (row2 - (row2 & 1)) / 2;
+        const z2 = row2;
+        const y2 = -x2 - z2;
+        return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2), Math.abs(z1 - z2));
+    }
+
+    /** 切比雪夫距离（原逻辑的 getManhattanDistance，八方向攻击距离判定用） */
+    getChebyshevDistance(a: Cell, b: Cell): number {
+        const row = Math.abs(a.row - b.row);
+        const col = Math.abs(a.col - b.col);
+        return row > col ? row : col;
+    }
+
+    /** 曼哈顿距离（攻击位排序用） */
+    getManhattanDistance(a: Cell, b: Cell): number {
+        return Math.abs(a.row - b.row) + Math.abs(a.col - b.col);
+    }
+
+    /** 当前移动模式下不会高估的“步数距离”下界（A* 启发函数用，保证最优路径） */
+    getStepDistance(a: Cell, b: Cell): number {
+        if (this.useSixDirection) {
+            return this.getHexDistance(a.row, a.col, b.row, b.col);
+        }
+        return this.getChebyshevDistance(a, b);
+    }
+
+    /**
+     * 获取从 row 行出发的移动方向偏移
+     * 六方向模式：左上、左、左下、右上、右、右下（对角按行奇偶取）
+     * 八方向模式：上下左右 + 四个对角
+     */
+    getDirections(row: number): [number, number][] {
+        if (this.useSixDirection) {
+            const isEvenRow = row % 2 === 0;
+            return [
+                isEvenRow ? [-1, -1] : [-1, 0], // 左上
+                [0, -1],                        // 左
+                isEvenRow ? [1, -1] : [1, 0],   // 左下
+                isEvenRow ? [-1, 0] : [-1, 1],  // 右上
+                [0, 1],                         // 右
+                isEvenRow ? [1, 0] : [1, 1],    // 右下
+            ];
+        }
+        return [
+            [-1, 0],  // 上
+            [1, 0],   // 下
+            [0, -1],  // 左
+            [0, 1],   // 右
+            [-1, -1], // 左上
+            [-1, 1],  // 右上
+            [1, -1],  // 左下
+            [1, 1],   // 右下
+        ];
+    }
+
+    /** 判断两个格子是否相邻（按当前模式的移动规则） */
+    isNeighborCell(a: Cell, b: Cell): boolean {
+        return this.getDirections(a.row).some(([dr, dc]) =>
+            a.row + dr === b.row && a.col + dc === b.col
+        );
+    }
+
+    // ==================== 3. 范围查询 ====================
+
+    /**
+     * 查找目标周围 maxDistance 范围内、在地图内且未被占用的点。
+     *
+     * 注意：这里不能用 isClosedLoop 做提前返回——目标的“被包围”语义包含
+     * “目标自身被占用”，而那正是需要找攻击位的场景（终点被占用/敌人站在终点上）。
+     * 只按 边界 + 占用 过滤即可，范围内没有可站点时自然返回空数组，
+     * 由上层 findPathToNearby 继续扩大半径。
+     */
+    findAvailablePointsInRange(targetRow: number, targetCol: number, maxDistance: number): Cell[] {
+        const availablePoints: Cell[] = [];
+        const visited = new Set<string>();
+        // 遍历目标点周围 maxDistance 范围内的所有格子
+        for (let dRow = -maxDistance; dRow <= maxDistance; dRow++) {
+            for (let dCol = -maxDistance; dCol <= maxDistance; dCol++) {
+                const newRow = targetRow + dRow;
+                const newCol = targetCol + dCol;
+                // 跳过目标点本身
+                if (newRow === targetRow && newCol === targetCol) {
+                    continue;
+                }
+                // 六方向模式：只保留蜂窝距离 ≤ maxDistance 的格子（去掉正方形的四个角）
+                if (this.useSixDirection
+                    && this.getHexDistance(targetRow, targetCol, newRow, newCol) > maxDistance) {
+                    continue;
+                }
+                if (this.isWithinBounds(newRow, newCol) && !this.isOccupied(newRow, newCol)) {
+                    const key = cellKey(newRow, newCol);
+                    if (!visited.has(key)) {
+                        visited.add(key);
+                        availablePoints.push({ row: newRow, col: newCol });
+                    }
+                }
+            }
+        }
+        return availablePoints;
+    }
+
+    /** 目标周围 maxDistance 范围内的所有点（不判断占用，仅边界内） */
+    checkAvailableSurrounding(targetRow: number, targetCol: number, maxDistance: number): Cell[] {
+        const points: Cell[] = [];
+        for (let dRow = -maxDistance; dRow <= maxDistance; dRow++) {
+            for (let dCol = -maxDistance; dCol <= maxDistance; dCol++) {
+                const newRow = targetRow + dRow;
+                const newCol = targetCol + dCol;
+                // 跳过目标点本身
+                if (newRow === targetRow && newCol === targetCol) {
+                    continue;
+                }
+                if (this.isWithinBounds(newRow, newCol)) {
+                    points.push({ row: newRow, col: newCol });
+                }
+            }
+        }
+        return points;
+    }
+
+    // ==================== 4. 包围判断 ====================
+
+    /** 判断目标点是否被包围 */
+    isClosedLoop(targetRow: number, targetCol: number, maxDistance: number): boolean {
+        if (this.useSixDirection) {
+            return this.isClosedLoopSix(targetRow, targetCol, maxDistance);
+        }
+        return this.isClosedLoopFour(targetRow, targetCol, maxDistance);
+    }
+
+    /** 原有四方向逻辑：四个面全部被堵住才算被包围 */
+    private isClosedLoopFour(targetRow: number, targetCol: number, maxDistance: number): boolean {
+        const value = maxDistance;
+
+        const shang = [
+            { row: -value, col: -value },  // 左上
+            { row: -value, col: 0 },       // 上
+            { row: -value, col: value },   // 右上
+        ];
+        const zuo = [
+            { row: -value, col: -value },  // 左上
+            { row: 0, col: -value },       // 左
+            { row: value, col: -value },   // 左下
+        ];
+        const xia = [
+            { row: value, col: -value },   // 左下
+            { row: value, col: 0 },        // 下
+            { row: value, col: value },    // 右下
+        ];
+        const you = [
+            { row: -value, col: value },   // 右上
+            { row: 0, col: value },        // 右
+            { row: value, col: value },    // 右下
+        ];
+
+        let is_shang = false;
+        let is_zuo = false;
+        let is_xia = false;
+        let is_you = false;
+
+        let shang_model = this.isMan(targetRow, targetCol, shang, 0, 0);
+        is_shang = shang_model.is_man
+        if (!shang_model.is_man) {
+            shang_model = this.isMan(targetRow, targetCol, shang, -1, 0);
+            is_shang = shang_model.is_man_bounds
+        }
+
+        let zuo_model = this.isMan(targetRow, targetCol, zuo, 0, 0);
+        is_zuo = zuo_model.is_man
+        if (!zuo_model.is_man) {
+            zuo_model = this.isMan(targetRow, targetCol, zuo, 0, -1);
+            is_zuo = zuo_model.is_man_bounds
+        }
+
+        let xia_model = this.isMan(targetRow, targetCol, xia, 0, 0);
+        is_xia = xia_model.is_man
+        if (!xia_model.is_man) {
+            xia_model = this.isMan(targetRow, targetCol, xia, 1, 0);
+            is_xia = xia_model.is_man_bounds
+        }
+
+        let you_model = this.isMan(targetRow, targetCol, you, 0, 0);
+        is_you = you_model.is_man
+        if (!you_model.is_man) {
+            you_model = this.isMan(targetRow, targetCol, you, 0, 1);
+            is_you = you_model.is_man_bounds
+        }
+
+        // 四个面全部被堵住才算被包围
+        return is_shang && is_zuo && is_xia && is_you;
+    }
+
+    /**
+     * 六方向（蜂窝）模式的包围判断：
+     * 目标点周围蜂窝距离 maxDistance 以内（不含自身）的所有格子，
+     * 只要有一个既在地图内又没被占用，就没被包围；
+     * 全部被堵住（出界或被占用都算堵住）才算被包围。
+     */
+    private isClosedLoopSix(targetRow: number, targetCol: number, maxDistance: number): boolean {
+        // 目标点本身出界 / 被占用，也算“被围住”
+        if (!this.isWithinBounds(targetRow, targetCol) || this.isOccupied(targetRow, targetCol)) {
+            return true;
+        }
+        // 蜂窝范围一定落在这个正方形包围盒里，遍历后按蜂窝距离过滤即可
+        for (let row = targetRow - maxDistance; row <= targetRow + maxDistance; row++) {
+            for (let col = targetCol - maxDistance; col <= targetCol + maxDistance; col++) {
+                if (row === targetRow && col === targetCol) {
+                    continue;
+                }
+                if (this.getHexDistance(targetRow, targetCol, row, col) > maxDistance) {
+                    continue;
+                }
+                // 出界或被占用都算“堵住”；发现一个能站的空格就没被包围
+                if (this.isWithinBounds(row, col) && !this.isOccupied(row, col)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    /** 检查一组格子是否全部被占据（is_man）或全部出界（is_man_bounds），四方向包围判断用 */
+    private isMan(targetRow: number, targetCol: number, list: { row: number, col: number }[], row: number, col: number) {
+        let count = 0
+        let count_bounds = 0
+
+        for (const dir of list) {
+            const newRow = targetRow + dir.row + row;
+            const newCol = targetCol + dir.col + col;
+            // 出界算被占据
+            if (!this.isWithinBounds(newRow, newCol)) {
+                count++
+                count_bounds++
+            }
+            if (this.isOccupied(newRow, newCol)) {
+                count++
+            }
+        }
+        return { is_man_bounds: count_bounds === list.length, is_man: count === list.length }
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "5d3a8f21-7c4e-4b6a-9f2d-8e1c0a4b7d92",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}