@cc-component/cc-pathfinding 1.0.1

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "5599834a-6bc7-46b6-98fe-cd266a07ebea",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/MapViewModel.ts

@@ -0,0 +1,17 @@
+import { Sprite } from 'cc';
+import { Vec3 } from 'cc';
+import { _decorator, Component, Node } from 'cc';
+import { IMapData } from './IMapData';
+const { ccclass, property } = _decorator;
+
+@ccclass('MapViewModel')
+export class MapViewModel implements IMapData {
+    col: number
+    row: number
+    position: Vec3
+    node: Node;
+    node_sp: Sprite;
+    node_chose_sp: Sprite;
+    bottom_positon: Vec3;
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "a60bab4f-11c4-44e8-8036-0c7ceececdd7",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/Mapitem.ts

@@ -0,0 +1,38 @@
+import { Sprite } from 'cc';
+import { _decorator, Component, Node } from 'cc';
+const { ccclass, property } = _decorator;
+
+@ccclass('Mapitem')
+export class Mapitem extends Component {
+    @property({ type: Sprite, displayName: '背景' })
+    bg: Sprite;
+    @property({ type: Sprite, displayName: '背景高亮' })
+    bgHighlight: Sprite;
+
+    row: number;
+    col: number;
+    /**点击回调 */
+    call: (row: number, col: number) => void;
+
+    onLoad() {
+        this.node.on(Node.EventType.TOUCH_END, this.click, this)
+
+    }
+    start() {
+
+    }
+
+    update(deltaTime: number) {
+
+    }
+
+    onDestroy() {
+        this.node.off(Node.EventType.TOUCH_END, this.click, this)
+    }
+
+    click() {
+        this.call?.(this.row, this.col)
+    }
+}
+
+

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "760944a7-bf43-418a-ba1b-fc7ba7bf6958",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/PathGridStateManager.ts

@@ -0,0 +1,94 @@
+import { Cell, cellKey } from './GridMap';
+
+export interface PathGridOccupancy {
+    isOccupied(row: number, col: number): boolean;
+    occupy(row: number, col: number): void;
+    free(row: number, col: number): void;
+}
+
+export class PathGridStateManager {
+    private readonly temporaryCells = new Set<string>();
+    private readonly reservedCells = new Map<string, Set<symbol>>();
+
+    constructor(private readonly occupancy: PathGridOccupancy) {
+    }
+
+    reserveCurrent(cell: Cell, owner: symbol): void {
+        this.occupancy.occupy(cell.row, cell.col);
+        this.temporaryCells.add(cellKey(cell.row, cell.col));
+        this.addReservation(cellKey(cell.row, cell.col), owner);
+    }
+
+    tryReserve(previous: Cell, next: Cell, owner: symbol): boolean {
+        const nextKey = cellKey(next.row, next.col);
+        const nextOwners = this.reservedCells.get(nextKey);
+        if (nextOwners && [...nextOwners].some((reservedOwner) => reservedOwner !== owner)) {
+            return false;
+        }
+        if (this.occupancy.isOccupied(next.row, next.col) && !nextOwners?.has(owner)) {
+            return false;
+        }
+
+        this.occupancy.occupy(previous.row, previous.col);
+        this.occupancy.occupy(next.row, next.col);
+        this.temporaryCells.add(cellKey(previous.row, previous.col));
+        this.temporaryCells.add(nextKey);
+        this.addReservation(cellKey(previous.row, previous.col), owner);
+        this.addReservation(nextKey, owner);
+        return true;
+    }
+
+    completeMove(previous: Cell, next: Cell, owner: symbol): void {
+        const previousKey = cellKey(previous.row, previous.col);
+        if (this.removeReservation(previousKey, owner)) {
+            this.temporaryCells.delete(previousKey);
+            if (!this.reservedCells.has(previousKey)) {
+                this.occupancy.free(previous.row, previous.col);
+            }
+        }
+
+        this.occupancy.occupy(next.row, next.col);
+        this.temporaryCells.add(cellKey(next.row, next.col));
+        this.addReservation(cellKey(next.row, next.col), owner);
+    }
+
+    release(owner?: symbol): void {
+        for (const [key, owners] of this.reservedCells) {
+            if (owner && !owners.has(owner)) {
+                continue;
+            }
+            if (owner) {
+                owners.delete(owner);
+            } else {
+                owners.clear();
+            }
+            if (owners.size > 0) {
+                continue;
+            }
+            const [row, col] = key.split(',').map(Number);
+            this.occupancy.free(row, col);
+            this.reservedCells.delete(key);
+            this.temporaryCells.delete(key);
+        }
+    }
+
+    private addReservation(key: string, owner: symbol): void {
+        let owners = this.reservedCells.get(key);
+        if (!owners) {
+            owners = new Set<symbol>();
+            this.reservedCells.set(key, owners);
+        }
+        owners.add(owner);
+    }
+
+    private removeReservation(key: string, owner: symbol): boolean {
+        const owners = this.reservedCells.get(key);
+        if (!owners || !owners.delete(owner)) {
+            return false;
+        }
+        if (owners.size === 0) {
+            this.reservedCells.delete(key);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "219dad89-34cd-4c9f-8afe-b9d1d8fade3b",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/pathfinding/base/PathfindingModule.ts

@@ -0,0 +1,161 @@
+import { _decorator, Component, Node, v3 } from 'cc';
+import { MapBoxView } from './MapBoxView';
+import { Vec3 } from 'cc';
+import { MapViewModel } from './MapViewModel';
+import { Color } from 'cc';
+import { AttackDistance } from './Common';
+import { GridMovementController } from './GridMovementController';
+const { ccclass, property } = _decorator;
+
+@ccclass('PathfindingModule')
+export class PathfindingModule {
+    private static instance: PathfindingModule;
+    private constructor() {
+
+    }
+    static get Ins() {
+        if (!this.instance) {
+            this.instance = new PathfindingModule();
+        }
+        return this.instance;
+    }
+
+    map_view: MapBoxView;
+    private static movementController: GridMovementController = null;
+
+    static SetMovementController(controller: GridMovementController): void {
+        this.movementController = controller;
+    }
+
+    static InitMovementController(scheduler: Component, options?: { retryDelay?: number; moveDuration?: number }): void {
+        if (!this.movementController) {
+            this.movementController = new GridMovementController(scheduler, options);
+        }
+    }
+
+    static SetPosition(playerNode: Node, position: { row: number, col: number }): void {
+        this.movementController?.setPosition(playerNode, position);
+    }
+
+    static GetPosition(playerNode: Node): { row: number, col: number } {
+        return this.movementController?.getPosition(playerNode) ?? { row: 0, col: 0 };
+    }
+
+    static MoveTo(playerNode: Node, target: { row: number, col: number }, attackDistance: AttackDistance, openColor: boolean, callBack?: () => void): void {
+        this.movementController?.moveTo(playerNode, target, attackDistance, openColor, callBack);
+    }
+
+    static CancelMove(playerNode: Node, preserveCurrent = false): void {
+        this.movementController?.cancel(playerNode, preserveCurrent);
+    }
+
+    static DestroyMovement(): void {
+        this.movementController?.destroy();
+        this.movementController = null;
+    }
+
+    static Init(map_view: MapBoxView) {
+        this.Ins.map_view = map_view;
+        map_view.InitView();
+    }
+    static Destroy() {
+        this.Ins.map_view = null;
+
+    }
+    // 调用 A* 路径寻找，从 (1,1) 到 (5,5)
+    static TracePath(start: { row: number, col: number }, end: { row: number, col: number }, attackDis: AttackDistance, openColor?: boolean): { row: number, col: number }[] {
+        return this.Ins.map_view.TracePath(start, end, attackDis, openColor)
+    }
+
+    // 占用某个节点
+    static OccupyNode(row: number, col: number, openColor?: boolean) {
+        this.Ins.map_view.occupyNode(row, col, openColor)
+    }
+
+    static IsOccupied(row: number, col: number): boolean {
+        return this.Ins.map_view.isOccupied(row, col);
+    }
+
+    // 节点可以用
+    static FreeNode(row: number, col: number) {
+        this.Ins.map_view.freeNode(row, col)
+
+    }
+
+    // 获取指定行列位置的坐标
+    static GetMapPosition(row: number, col: number): Vec3 {
+        return this.Ins.map_view.GetMapPosition(row, col)
+    }
+
+    // 获取指定位置的MapViewModel
+    static CreateMapModel(row: number, col: number): MapViewModel {
+        const map = new MapViewModel();
+        map.row = row;
+        map.col = col;
+        map.position = v3(0, 0, 0)
+        map.bottom_positon = v3(0, 0, 0)
+        return map;
+    }
+    // 获取指定位置的MapViewModel
+    static GetMapModel(row: number, col: number): MapViewModel {
+        return this.Ins.map_view.GetMapModel(row, col)
+    }
+    //获取所有的map
+    static GetSeatModelList(): MapViewModel[][] {
+        return this.Ins.map_view.GetSeatModelList();
+    }
+
+    /*获取目标点周围最近的位置*/
+    static CheckAvailableSurrounding(
+        target: { row: number, col: number, dis: number },
+    ): { row: number, col: number }[] {
+        return this.Ins.map_view.checkAvailableSurrounding(target.row, target.col, target.dis)
+    }
+
+    //在攻击距离内，
+    static IsAttackDistance(model1: MapViewModel, model2: MapViewModel, maxDistance: number): boolean {
+        return this.Ins.map_view.IsAttackDistance(model1, model2, maxDistance)
+    }
+
+    static TargetColor(row, col, dis: number) {
+        const map_row = PathfindingModule.Ins.map_view.row;
+        const map_col = PathfindingModule.Ins.map_view.col;
+        if (row >= 0 && row < map_row && col >= 0 && col < map_col) {
+            PathfindingModule.ClearColor()
+            const list = PathfindingModule.CheckAvailableSurrounding({ row, col, dis })
+            list.forEach(model => {
+                const map = PathfindingModule.GetMapModel(model.row, model.col)
+                map.node_chose_sp.color = Color.GREEN
+                map.node_chose_sp.node.active = true
+            })
+            const map = PathfindingModule.GetMapModel(row, col)
+            map.node_chose_sp.color = Color.YELLOW
+            map.node_chose_sp.node.active = true
+
+        }
+    }
+    static SetColorVisible(visible: boolean) {
+        this.Ins.map_view.SetColorVisible(visible)
+    }
+    static ClearColor() {
+        const all = PathfindingModule.GetSeatModelList()
+        all.forEach(list => {
+            list.forEach(map => {
+                map.node_chose_sp.node.active = false
+            })
+        })
+    }
+    static ClearColorPath() {
+        this.Ins.map_view.ClearColor()
+    }
+    // 判断目标点是否被包围
+    static IsClosedLoop(
+        targetRow: number,
+        targetCol: number, maxDistance: number
+    ): boolean {
+        return this.Ins.map_view.isClosedLoop(targetRow, targetCol, maxDistance)
+
+    }
+}
+
+window.PathfindingModule = PathfindingModule;

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "62642350-f8d4-4516-8def-6fb058e4f52c",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}