调整格子和棋子的结构

assets/bundle/gridMap/UECell.prefab

@@ -494,6 +494,9 @@
     "node_lock": {
       "__id__": 11
     },
+    "cubePrefab": {
+      "__uuid__": "b1448898-31aa-41e2-82e6-34d02a326bd0"
+    },
     "_id": ""
   },
   {

assets/script/data/model/GridMap/GridMapModel.ts

@@ -25,7 +25,7 @@ export default class GridMapModel extends GridMapModelData {
     public formulaMap: { [key: string]: MergeItem[] } = {};
     /** 可合成物品的配方 */
     public itemFormula: { [key: string]: string[] } = {};
-    private ueGridMap: UEGridMap;
+    public ueGridMap: UEGridMap;
     constructor() {
         super('gridMap');
     }

assets/script/logic/gridMap/UECell.ts

@@ -11,8 +11,9 @@ import UECube from "./UECube";
 const { ccclass, property } = cc._decorator;
 
 export interface I_CellData {
+    x: number,
+    y: number,
     idx: number;
-    ueCube: UECube;
     unlock: HcUnlock;
 }
 @ccclass
@@ -27,12 +28,13 @@ export default class UECell extends UEBase {
     private sp_quality: ResSprite = null;
     @property(cc.Node)
     private node_lock: cc.Node = null;
-
+    @property(cc.Prefab)
+    cubePrefab: cc.Prefab = null!;
     cellData: I_CellData = null!;
+    ueCube: UECube = null;
     Init(cellData: I_CellData) {
         this.cellData = cellData;
         this.node.zIndex = cellData.idx;
-        this.SetQuality();
         this.SetLock();
         EventMng.on(GridEvent.HC_CELL_CHANGE, this.OnHcCellChange, this);
         EventMng.on(GridEvent.HC_CELL_SELECT, this.OnHcCellSelect, this);
@@ -58,26 +60,35 @@ export default class UECell extends UEBase {
         }
     }
 
-    /** 创建格子 */
-    CreateCell(i: number, j: number) {
-        // let cell = cc.instantiate(this.cellPrefab).getComponent(UECell);
-        // this.cellLayer.addChild(cell.node);
-        // cell.node.width = GridConstant.CELL_WIDTH;
-        // cell.node.height = GridConstant.CELL_WIDTH;
-        // let pos = GameDataCenter.gridMap.GetPosByVec(i, j);
-        // cell.node.setPosition(pos);
-        // return cell;
+    /** 创建棋子 */
+    CreateCube(info: HcInfoGeziInfo) {
+        let cube = cc.instantiate(this.cubePrefab).getComponent(UECube);
+        GameDataCenter.gridMap.ueGridMap.GetCubeLayer().addChild(cube.node);
+        cube.node.width = GridConstant.CELL_WIDTH;
+        cube.node.height = GridConstant.CELL_WIDTH;
+        let pos = GameDataCenter.gridMap.GetPosByVec(this.cellData.x, this.cellData.y);
+        cube.node.setPosition(pos);
+        let idx = (this.cellData.x + 1) * 10 + (this.cellData.y + 1);
+        cube.Init({
+            type: info.type,
+            id: info.correlationId,
+            idx: idx
+        })
+        this.ueCube = cube;
+        this.SetQuality();
+        this.SetLock();
+        return cube;
     }
 
     SetCube(cube: UECube) {
-        this.cellData.ueCube = cube;
+        this.ueCube = cube;
         this.SetQuality();
     }
 
     SetQuality() {
-        if (this.cellData.ueCube && !this.IsLock()) {
-            this.cellData.ueCube.SetZIndex(this.cellData.idx);
-            let quality = this.cellData.ueCube.GetQuality();
+        if (this.ueCube && !this.IsLock()) {
+            this.ueCube.SetZIndex(this.cellData.idx);
+            let quality = this.ueCube.GetQuality();
             this.sp_quality.setSpriteFrame('gridMap', `qualityBg/Img_zjm_diban0${quality}`);
         } else {
             this.sp_quality.setSpriteFrame('gridMap', `qualityBg/Img_zjm_diban00`);
@@ -96,13 +107,13 @@ export default class UECell extends UEBase {
     SetLock() {
         if (this.cellData.unlock == HcUnlock.off) {
             this.node_lock.active = true;
-            if (this.cellData.ueCube) {
-                this.cellData.ueCube.node.active = false;
+            if (this.ueCube) {
+                this.ueCube.node.active = false;
             }
         } else {
             this.node_lock.active = false;
-            if (this.cellData.ueCube) {
-                this.cellData.ueCube.node.active = true;
+            if (this.ueCube) {
+                this.ueCube.node.active = true;
             }
         }
 
@@ -119,27 +130,27 @@ export default class UECell extends UEBase {
 
     /** 是否有物品可以拖动 */
     CanDrag(): boolean {
-        return !this.IsEmpty() && this.cellData.ueCube.CanDrag() && !this.IsLock();
+        return !this.IsEmpty() && this.ueCube.CanDrag() && !this.IsLock();
     }
 
     GetCube(): UECube {
-        return this.cellData.ueCube;
+        return this.ueCube;
     }
 
     /** 该棋格是否是空的 */
     IsEmpty(): boolean {
-        return this.cellData.ueCube == null;
+        return this.ueCube == null;
     }
 
     /** 清空棋格里的棋子 */
     ClearCube() {
-        this.cellData.ueCube.unUse();
-        this.cellData.ueCube = null;
+        this.ueCube.unUse();
+        this.ueCube = null;
         this.SetQuality();
     }
 
     MoveCubeToCell(toCell: UECell) {
-        this.cellData.ueCube.MoveToNewPos(toCell.node.position.clone());
+        this.ueCube.MoveToNewPos(toCell.node.position.clone());
     }
 
 }

assets/script/logic/gridMap/UEGridMap.ts

@@ -74,6 +74,10 @@ export default class UEGridMap extends UEBase {
         this.initEvent(GridEvent.HC_FIGHT_OVER, this.OnHcFightOver);
     }
 
+    public GetCubeLayer() {
+        return this.cubeLayer;
+    }
+
 
 
     /** 加载地图数据 */
@@ -81,28 +85,21 @@ export default class UEGridMap extends UEBase {
         this.cellMap = {};
         for (let i = 0; i < GridConstant.COL; i++) {
             let rowCells = [];
-            let rowCubes = [];
             for (let j = 0; j < GridConstant.ROW; j++) {
                 let idx = (i + 1) * 10 + (j + 1);
                 let cellData = data.list[idx];
                 if (cellData) {
                     let cell = this.CreateCell(i, j);
                     rowCells.push(cell);
-                    let cube = null;
-                    if (cellData.type > 0) {
-                        cube = this.CreateCube(i, j);
-                        rowCubes.push(cube);
-                        cube.Init({
-                            type: cellData.type,
-                            id: cellData.correlationId,
-                            zIndex: idx
-                        }, idx)
-                    }
                     cell.Init({
+                        x: i,
+                        y: j,
                         idx: idx,
-                        ueCube: cube,
                         unlock: cellData.unlock
                     });
+                    if (cellData.type > 0) {
+                        cell.CreateCube(cellData);
+                    }
                     this.cellMap[idx] = cell;
                 }
             }
@@ -120,27 +117,23 @@ export default class UEGridMap extends UEBase {
                 if (curCell.IsLock()) {
                     curCell.ChangeLockState(geziData.unlock);
                 }
-                let vec = GameDataCenter.gridMap.TranIdxToPos(Number(key));
-                let mergeCube = this.CreateCube(vec.y, vec.x);
+                let mergeCube = curCell.CreateCube(geziData);
                 mergeCube.Init({
                     type: geziData.type,
                     id: geziData.correlationId,
                     idx: Number(key),
                 });
-                curCell.SetCube(mergeCube);
             }
         }
     }
 
     private OnHcMergeRsp(data: { cell: UECell, cube: HcInfoGeziInfo }) {
-        let vec = GameDataCenter.gridMap.TranIdxToPos(data.cell.GetZIndex());
-        let mergeCube = this.CreateCube(vec.y, vec.x);
+        let mergeCube = data.cell.CreateCube(data.cube);
         mergeCube.Init({
             type: data.cube.type,
             id: data.cube.correlationId,
             idx: data.cell.GetZIndex(),
         });
-        data.cell.SetCube(mergeCube);
         //播放经验爆炸飞行动画
 
     }
@@ -158,17 +151,6 @@ export default class UEGridMap extends UEBase {
         return cell;
     }
 
-    /** 创建棋子 */
-    private CreateCube(i: number, j: number) {
-        let cube = cc.instantiate(this.cubePrefab).getComponent(UECube);
-        this.cubeLayer.addChild(cube.node);
-        cube.node.width = GridConstant.CELL_WIDTH;
-        cube.node.height = GridConstant.CELL_WIDTH;
-        let pos = GameDataCenter.gridMap.GetPosByVec(i, j);
-        cube.node.setPosition(pos);
-        return cube;
-    }
-
     private OnTouchStart(event: cc.Event.EventTouch): void {
         const touchPos = this.gridLayer.convertToNodeSpaceAR(event.getLocation());
         const cell = this.GetCellByPos(touchPos);
@@ -310,18 +292,18 @@ export default class UEGridMap extends UEBase {
     private TriggerEmitter(data: { idx: number, item: HcInfoGeziInfo, targetIdx: number }) {
         let targetCell = this.cellMap[data.targetIdx];
         let startPos = GameDataCenter.gridMap.TranIdxToPos(data.idx);
-        let mergeCube = this.CreateCube(startPos.y, startPos.x);
+        let mergeCube = targetCell.CreateCube(data.item);
         mergeCube.Init({
             type: data.item.type,
             id: data.item.correlationId,
             idx: data.idx,
         });
-        targetCell.SetCube(mergeCube);
         mergeCube.SetZIndex(1000);
         let targetPos = GameDataCenter.gridMap.TranIdxToPos(data.targetIdx);
 
         // 计算起点和终点
-        const startWorldPos = mergeCube.node.getPosition();
+        const startWorldPos = GameDataCenter.gridMap.GetPosByVec(startPos.y, startPos.x);
+        mergeCube.node.setPosition(startWorldPos.x, startWorldPos.y);
         const endWorldPos = GameDataCenter.gridMap.GetPosByVec(targetPos.y, targetPos.x);
 
         // 计算方向向量和总距离