1387 lines
38 KiB
TypeScript
1387 lines
38 KiB
TypeScript
import {
|
||
_decorator,
|
||
Component,
|
||
Node,
|
||
Prefab,
|
||
instantiate,
|
||
Sprite,
|
||
SpriteFrame,
|
||
Vec2,
|
||
Vec3,
|
||
input,
|
||
Input,
|
||
EventTouch,
|
||
UITransform,
|
||
Size,
|
||
Color,
|
||
Graphics,
|
||
Tween,
|
||
tween,
|
||
AudioClip,
|
||
AudioSource,
|
||
UIOpacity,
|
||
resources,
|
||
} from "cc";
|
||
import { AudioManager, BGMType, SFXType } from "./AudioManager";
|
||
import { ButtonBadge } from "./ButtonBadge";
|
||
import { DragManager } from "./DragManager";
|
||
import { HintManager } from "./HintManager";
|
||
import { LevelBuilder } from "./LevelBuilder";
|
||
import { LevelManager } from "./LevelManager";
|
||
import { loadSpriteFrames } from "./utils/loadResources";
|
||
const { ccclass, property } = _decorator;
|
||
|
||
@ccclass("GameManager")
|
||
export class GameManager extends Component {
|
||
@property(Prefab)
|
||
blockPrefab: Prefab = null!;
|
||
|
||
@property(Node)
|
||
lineLayer: Node = null;
|
||
|
||
@property(Node)
|
||
Function_Node: Node = null;
|
||
|
||
@property(AudioClip)
|
||
remove_audio: AudioClip = null;
|
||
|
||
@property(AudioClip)
|
||
levle_audio: AudioClip = null;
|
||
|
||
@property(AudioClip)
|
||
victory_sfx_audio: AudioClip = null;
|
||
|
||
@property(AudioClip)
|
||
magic_sfx_audio: AudioClip = null;
|
||
|
||
@property(AudioClip)
|
||
hint_sfx_audio: AudioClip = null;
|
||
|
||
@property(AudioClip)
|
||
shuffle_sfx_audio: AudioClip = null;
|
||
|
||
@property(HintManager)
|
||
hintManager: HintManager | null = null;
|
||
|
||
@property
|
||
rows: number = 5;
|
||
|
||
@property
|
||
cols: number = 6;
|
||
|
||
@property
|
||
blockSize: number = 128;
|
||
|
||
@property
|
||
tileTypes: number = 5;
|
||
|
||
@property
|
||
level: number = 1; // 当前关卡
|
||
|
||
private toolBadge: ButtonBadge | null = null;
|
||
|
||
private board: number[][] = [];
|
||
private blockNodes: (Node | null)[][] = [];
|
||
private spriteFrames: SpriteFrame[] = [];
|
||
|
||
private draggingBlock: Node | null = null;
|
||
private dragStartPos: Vec2 = new Vec2();
|
||
private dragStartBlockPos: Vec3 = new Vec3();
|
||
private dragRow = -1;
|
||
private dragCol = -1;
|
||
private slidingDir: { dirR: number; dirC: number } | null = null;
|
||
private threshold: number = 10; // 触发滑动阈值
|
||
|
||
private hintPair: {
|
||
from: { r?: number; c?: number };
|
||
to: { r?: number; c?: number };
|
||
} = { from: {}, to: {} };
|
||
|
||
// 新增成员变量，标记可消除的方块集合
|
||
private markedBlocks: Set<string> = new Set();
|
||
private firstClicked: { r: number; c: number } | null = null;
|
||
|
||
// 组合移动
|
||
private draggingGroup: { r: number; c: number }[] = [];
|
||
private dragManager: DragManager | null = null;
|
||
|
||
private levelBuilder: LevelBuilder;
|
||
|
||
@property
|
||
currentShape: string = "rectangle";
|
||
|
||
private currentShapeNode: Node = null!;
|
||
|
||
private isTutorial: boolean = false;
|
||
private tutorialStep: number = 0;
|
||
private handNode: Node = null;
|
||
|
||
async onLoad() {
|
||
AudioManager.instance.registerBGM(BGMType.Level, this.levle_audio);
|
||
AudioManager.instance.registerSFX(SFXType.Remove, this.remove_audio);
|
||
AudioManager.instance.registerSFX(SFXType.Victory, this.victory_sfx_audio);
|
||
AudioManager.instance.registerSFX(SFXType.Magic, this.magic_sfx_audio);
|
||
AudioManager.instance.registerSFX(SFXType.Hint, this.hint_sfx_audio);
|
||
AudioManager.instance.registerSFX(SFXType.Shuffle, this.shuffle_sfx_audio);
|
||
|
||
AudioManager.instance.setCurBgm(BGMType.Level);
|
||
AudioManager.instance.playBGM(BGMType.Level);
|
||
|
||
this.toolBadge = this.Function_Node.getComponent(ButtonBadge);
|
||
|
||
const frames = await loadSpriteFrames("textures");
|
||
this.spriteFrames = frames;
|
||
|
||
this.currentShapeNode = new Node("BoardRoot");
|
||
this.currentShapeNode.addComponent(UITransform);
|
||
this.node.addChild(this.currentShapeNode);
|
||
|
||
// 开始关卡
|
||
this.startLevel(LevelManager.instance.getCurrentLevel());
|
||
|
||
this.bindGlobalTouch();
|
||
}
|
||
|
||
private startLevel(config) {
|
||
this.isTutorial = !!config.isTutorial;
|
||
this.tutorialStep = 1;
|
||
this.currentShapeNode.removeAllChildren();
|
||
if (this.handNode && this.handNode !== this.hintManager?.handNode) {
|
||
this.handNode.destroy();
|
||
}
|
||
this.handNode = null;
|
||
|
||
this.levelBuilder = new LevelBuilder(
|
||
this.currentShapeNode,
|
||
this.blockPrefab,
|
||
this.spriteFrames,
|
||
config,
|
||
);
|
||
this.levelBuilder.buildBoard();
|
||
|
||
// 赋值给 GameManager
|
||
this.board = this.levelBuilder.board;
|
||
this.blockNodes = this.levelBuilder.blockNodes;
|
||
this.rows = this.levelBuilder.rows;
|
||
this.cols = this.levelBuilder.cols;
|
||
this.blockSize = config.blockSize;
|
||
this.playEnterAnimation();
|
||
this.dragManager = new DragManager(
|
||
this.board,
|
||
this.blockNodes,
|
||
this.rows,
|
||
this.cols,
|
||
this.blockSize,
|
||
);
|
||
console.log("关卡生成完成", this.board, this.blockNodes);
|
||
|
||
if (this.isTutorial) {
|
||
this.initTutorial();
|
||
}
|
||
}
|
||
|
||
private initTutorial() {
|
||
// 尝试获取 HintManager
|
||
if (!this.hintManager) {
|
||
this.hintManager = this.getComponent(HintManager);
|
||
}
|
||
|
||
// 尝试获取 Hand 节点
|
||
if (this.hintManager && this.hintManager.handNode) {
|
||
this.handNode = this.hintManager.handNode;
|
||
} else {
|
||
// 尝试在场景中查找 Hand
|
||
const foundHand =
|
||
this.node.getChildByName("Hand") ||
|
||
this.node.scene.getChildByName("Hand");
|
||
if (foundHand) {
|
||
this.handNode = foundHand;
|
||
} else {
|
||
console.warn(
|
||
"HintManager.handNode is not set, trying to load dynamically...",
|
||
);
|
||
// 动态加载手势资源作为后备方案
|
||
resources.load(
|
||
"ui/hand/spriteFrame",
|
||
SpriteFrame,
|
||
(err, spriteFrame) => {
|
||
if (err) {
|
||
console.error("动态加载手势失败", err);
|
||
return;
|
||
}
|
||
const node = new Node("Hand");
|
||
const sprite = node.addComponent(Sprite);
|
||
sprite.spriteFrame = spriteFrame;
|
||
this.node.addChild(node);
|
||
this.handNode = node;
|
||
node.layer = this.node.layer;
|
||
this.updateTutorialStep();
|
||
},
|
||
);
|
||
return; // 等待加载完成
|
||
}
|
||
}
|
||
|
||
if (this.handNode) {
|
||
this.updateTutorialStep();
|
||
} else {
|
||
console.error("无法找到手势节点 (Hand Node)，教学引导可能无法显示");
|
||
}
|
||
}
|
||
|
||
private updateTutorialStep() {
|
||
if (!this.handNode) return;
|
||
this.handNode.active = true;
|
||
this.handNode.setSiblingIndex(999); // Ensure on top
|
||
Tween.stopAllByTarget(this.handNode); // Clean existing tweens
|
||
|
||
// Fixed board:
|
||
// [0, 0, -1]
|
||
// [1, -1, 1]
|
||
// Step 1: Click (0,0)
|
||
// Step 2: Click (0,1)
|
||
// Step 3: Drag (1,0) -> (1,1)
|
||
|
||
let targetPos: Vec3;
|
||
let targetPos2: Vec3;
|
||
|
||
switch (this.tutorialStep) {
|
||
case 1: // Point at (0,0)
|
||
targetPos = this.getPos(0, 0);
|
||
this.handNode.setPosition(targetPos.x + 30, targetPos.y - 30, 0);
|
||
tween(this.handNode)
|
||
.repeatForever(
|
||
tween()
|
||
.to(0.5, { scale: new Vec3(1.2, 1.2, 1) })
|
||
.to(0.5, { scale: new Vec3(1, 1, 1) }),
|
||
)
|
||
.start();
|
||
break;
|
||
case 2: // Point at (0,1)
|
||
targetPos = this.getPos(0, 1);
|
||
this.handNode.setPosition(targetPos.x + 30, targetPos.y - 30, 0);
|
||
tween(this.handNode)
|
||
.repeatForever(
|
||
tween()
|
||
.to(0.5, { scale: new Vec3(1.2, 1.2, 1) })
|
||
.to(0.5, { scale: new Vec3(1, 1, 1) }),
|
||
)
|
||
.start();
|
||
break;
|
||
case 3: // Drag (1,0) -> (1,1)
|
||
targetPos = this.getPos(1, 0);
|
||
targetPos2 = this.getPos(1, 1);
|
||
this.handNode.setPosition(targetPos);
|
||
tween(this.handNode)
|
||
.repeatForever(
|
||
tween()
|
||
.to(1.0, { position: targetPos2 })
|
||
.delay(0.2)
|
||
.set({ position: targetPos }),
|
||
)
|
||
.start();
|
||
break;
|
||
default:
|
||
this.handNode.active = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* resetState
|
||
*/
|
||
public resetState() {
|
||
this.firstClicked = null;
|
||
this.markedBlocks.clear();
|
||
}
|
||
|
||
/** 播放进入关卡时的淡入动画 */
|
||
private playEnterAnimation() {
|
||
for (let r = 0; r < this.levelBuilder.blockNodes.length; r++) {
|
||
for (let c = 0; c < this.levelBuilder.blockNodes[r].length; c++) {
|
||
const node = this.levelBuilder.blockNodes[r][c];
|
||
if (node && node.isValid) {
|
||
node.setScale(0, 0, 0);
|
||
tween(node)
|
||
.to(0.3, { scale: new Vec3(1, 1, 1) })
|
||
.start();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public async onLevelComplete() {
|
||
this.resetState();
|
||
const oldNodes: Node[] = [];
|
||
for (let r = 0; r < this.levelBuilder.blockNodes.length; r++) {
|
||
for (let c = 0; c < this.levelBuilder.blockNodes[r].length; c++) {
|
||
const node = this.levelBuilder.blockNodes[r][c];
|
||
if (node && node.isValid) oldNodes.push(node);
|
||
}
|
||
}
|
||
console.log(3333, oldNodes);
|
||
// 等待旧棋盘缩小消失
|
||
await Promise.all(
|
||
oldNodes.map(
|
||
(n) =>
|
||
new Promise<void>((resolve) => {
|
||
tween(n)
|
||
.to(0.3, { scale: new Vec3(0, 0, 0) })
|
||
.call(() => {
|
||
n.destroy();
|
||
resolve();
|
||
})
|
||
.start();
|
||
}),
|
||
),
|
||
);
|
||
// 进入下一关
|
||
const next = LevelManager.instance.nextLevel();
|
||
if (next) {
|
||
console.log("恭喜，下一关");
|
||
AudioManager.instance.playSFX(SFXType.Victory);
|
||
this.startLevel(next);
|
||
} else {
|
||
console.log("恭喜，全部关卡通关！");
|
||
// 这里可以加个结算UI 或者重新开始
|
||
LevelManager.instance.reset();
|
||
this.startLevel(LevelManager.instance.getCurrentLevel());
|
||
}
|
||
}
|
||
|
||
start() {}
|
||
|
||
getPos(row: number, col: number): Vec3 {
|
||
const x =
|
||
col * this.blockSize -
|
||
(this.cols * this.blockSize) / 2 +
|
||
this.blockSize / 2;
|
||
const y =
|
||
(this.rows * this.blockSize) / 2 -
|
||
row * this.blockSize -
|
||
this.blockSize / 2;
|
||
return new Vec3(x, y, 0);
|
||
}
|
||
|
||
setBlockBgColor(block: Node, color: Color) {
|
||
if (block) {
|
||
const bgNode = block.getChildByName("Bg");
|
||
const bgSprite = bgNode.getComponent(Sprite)!;
|
||
bgSprite.color = color;
|
||
}
|
||
}
|
||
|
||
bindGlobalTouch() {
|
||
input.on(Input.EventType.TOUCH_START, (event: EventTouch) =>
|
||
this.handleTouchStart(event),
|
||
);
|
||
|
||
input.on(Input.EventType.TOUCH_MOVE, (event: EventTouch) =>
|
||
this.handleTouchMove(event),
|
||
);
|
||
|
||
input.on(Input.EventType.TOUCH_END, () => this.handleTouchEnd());
|
||
|
||
input.on(Input.EventType.TOUCH_CANCEL, (event: EventTouch) =>
|
||
this.handleTouchCancel(),
|
||
);
|
||
}
|
||
|
||
// 开始滑动
|
||
handleTouchStart(event) {
|
||
this.hintManager.cancelHint();
|
||
this.resetHintPair();
|
||
this.clearMarkVisuals();
|
||
const pos = event.getUILocation();
|
||
const res = this.findBlockAtPosition(pos);
|
||
if (!res) return;
|
||
|
||
const { block, r, c } = res;
|
||
|
||
if (this.isTutorial) {
|
||
if (this.tutorialStep === 1 && (r !== 0 || c !== 0)) return;
|
||
if (this.tutorialStep === 2 && (r !== 0 || c !== 1)) return;
|
||
if (this.tutorialStep === 3 && (r !== 1 || c !== 0)) return;
|
||
if (this.tutorialStep > 3) return;
|
||
}
|
||
|
||
this.draggingBlock = block;
|
||
this.dragRow = r;
|
||
this.dragCol = c;
|
||
this.dragStartPos = pos.clone();
|
||
this.dragStartBlockPos = block.getPosition().clone();
|
||
this.slidingDir = null;
|
||
this.draggingGroup = []; // 初始化空数组
|
||
|
||
this.setBlockBgColor(this.draggingBlock, new Color(255, 100, 100));
|
||
}
|
||
|
||
// 拖动中
|
||
handleTouchMove(event) {
|
||
if (!this.draggingBlock) return;
|
||
|
||
if (this.isTutorial && this.tutorialStep < 3) return;
|
||
|
||
const pos = event.getUILocation();
|
||
const dx = pos.x - this.dragStartPos.x;
|
||
const dy = pos.y - this.dragStartPos.y;
|
||
|
||
// 没锁定滑动方向前
|
||
if (!this.slidingDir) {
|
||
if (Math.abs(dx) < this.threshold && Math.abs(dy) < this.threshold)
|
||
return;
|
||
|
||
// 根据滑动方向锁定行或列滑动
|
||
if (Math.abs(dx) > Math.abs(dy)) {
|
||
this.slidingDir = { dirR: 0, dirC: dx > 0 ? 1 : -1 };
|
||
} else {
|
||
this.slidingDir = { dirR: dy > 0 ? -1 : 1, dirC: 0 };
|
||
}
|
||
}
|
||
|
||
this.draggingGroup = this.dragManager.findDragGroup(
|
||
this.dragRow,
|
||
this.dragCol,
|
||
this.slidingDir.dirR,
|
||
this.slidingDir.dirC,
|
||
);
|
||
// 检查整组前方空格是否足够滑动
|
||
const maxSteps = this.dragManager.countEmptyStepsGroup(
|
||
this.draggingGroup,
|
||
this.slidingDir.dirR,
|
||
this.slidingDir.dirC,
|
||
);
|
||
if (maxSteps === 0) {
|
||
this.slidingDir = null;
|
||
this.draggingGroup = [];
|
||
return;
|
||
}
|
||
|
||
this.dragManager.applyDragOffset(
|
||
this.draggingGroup,
|
||
maxSteps,
|
||
this.slidingDir.dirR,
|
||
this.slidingDir.dirC,
|
||
dy,
|
||
dx,
|
||
);
|
||
}
|
||
|
||
// 滑动结束
|
||
async handleTouchEnd() {
|
||
if (!this.draggingBlock) return;
|
||
|
||
if (!this.slidingDir) {
|
||
// 没滑动，单击消除逻辑复用
|
||
this.onBlockClick(this.dragRow, this.dragCol);
|
||
|
||
// 复位单个方块位置
|
||
this.draggingBlock.setPosition(this.getPos(this.dragRow, this.dragCol));
|
||
} else {
|
||
// 计算滑动步数
|
||
let steps = 0;
|
||
const firstBlockPos = this.getPos(this.dragRow, this.dragCol);
|
||
const curPos = this.draggingBlock.getPosition();
|
||
|
||
if (this.slidingDir.dirR !== 0) {
|
||
const delta = curPos.y - firstBlockPos.y;
|
||
steps = Math.round(delta / this.blockSize) * this.slidingDir.dirR * -1;
|
||
} else {
|
||
const delta = curPos.x - firstBlockPos.x;
|
||
steps = Math.round(delta / this.blockSize) * this.slidingDir.dirC;
|
||
}
|
||
|
||
const maxSteps = this.dragManager.countEmptyStepsGroup(
|
||
this.draggingGroup,
|
||
this.slidingDir.dirR,
|
||
this.slidingDir.dirC,
|
||
);
|
||
if (steps > maxSteps) steps = maxSteps;
|
||
if (steps < 0) steps = 0;
|
||
|
||
if (steps === 0) {
|
||
// 无滑动，复位所有方块位置
|
||
this.draggingGroup.forEach(({ r, c }) => {
|
||
const block = this.blockNodes[r][c];
|
||
if (block) block.setPosition(this.getPos(r, c));
|
||
});
|
||
} else {
|
||
// 有滑动的情况
|
||
|
||
const type = this.board[this.dragRow][this.dragCol];
|
||
// 先缓存所有方块类型，拖动多块时保持准确
|
||
const blocksInfo = this.draggingGroup.map(({ r, c }) => ({
|
||
r,
|
||
c,
|
||
type: this.board[r][c],
|
||
node: this.blockNodes[r][c],
|
||
}));
|
||
// 先把原位置置空
|
||
blocksInfo.forEach(({ r, c }) => {
|
||
this.board[r][c] = -1;
|
||
this.blockNodes[r][c] = null;
|
||
});
|
||
|
||
// 按拖动方向排序，避免位置覆盖冲突
|
||
const sortedBlocks = [...blocksInfo].sort((a, b) => {
|
||
if (this.slidingDir.dirR !== 0) {
|
||
return this.slidingDir.dirR === 1 ? b.r - a.r : a.r - b.r;
|
||
} else {
|
||
return this.slidingDir.dirC === 1 ? b.c - a.c : a.c - b.c;
|
||
}
|
||
});
|
||
|
||
// 清理状态
|
||
this.firstClicked = null;
|
||
this.markedBlocks.clear();
|
||
|
||
// 只针对发起拖动的方块（起点）
|
||
const startTr = this.dragRow + this.slidingDir.dirR * steps;
|
||
const startTc = this.dragCol + this.slidingDir.dirC * steps;
|
||
const startType = type;
|
||
|
||
const neighbors = this.findAdjacentSameType(
|
||
startTr,
|
||
startTc,
|
||
startType,
|
||
blocksInfo,
|
||
this.slidingDir,
|
||
);
|
||
|
||
if (neighbors.length === 0) {
|
||
this.dragManager.settleDrag(blocksInfo, true);
|
||
this.setBlockBgColor(this.draggingBlock, new Color(255, 255, 255));
|
||
} else {
|
||
// 移动到新位置，更新board和blockNodes
|
||
this.dragManager.settleDrag(
|
||
sortedBlocks,
|
||
false,
|
||
steps,
|
||
this.slidingDir,
|
||
);
|
||
if (neighbors.length === 1) {
|
||
this.playRemoveAudio();
|
||
// 唯一邻居，连线并消除起点和邻居
|
||
const onlyNeighbor = neighbors[0];
|
||
this.setBlockBgColor(
|
||
this.blockNodes[onlyNeighbor.nr][onlyNeighbor.nc],
|
||
new Color(255, 100, 100),
|
||
);
|
||
|
||
this.drawLinkLine(
|
||
this.blockNodes[startTr][startTc],
|
||
this.blockNodes[onlyNeighbor.nr][onlyNeighbor.nc],
|
||
);
|
||
this.scheduleOnce(() => {
|
||
this.removeBlock(startTr, startTc);
|
||
this.removeBlock(onlyNeighbor.nr, onlyNeighbor.nc);
|
||
const empty = this.isBoardEmpty();
|
||
if (empty) {
|
||
this.onLevelComplete();
|
||
console.log("下一关");
|
||
} else {
|
||
const result = this.hasAvailableMove();
|
||
console.log(`${result ? "还有可移动的了" : "没有可移动的了"}`);
|
||
}
|
||
}, 0.5);
|
||
} else {
|
||
// 多邻居，标记高亮起点和邻居
|
||
this.markedBlocks.clear();
|
||
// this.markedBlocks.add(`${startTr},${startTc}`);
|
||
this.setBlockBgColor(
|
||
this.blockNodes[startTr][startTc],
|
||
new Color(255, 100, 100),
|
||
);
|
||
|
||
neighbors.forEach(({ nr, nc }) =>
|
||
this.markedBlocks.add(`${nr},${nc}`),
|
||
);
|
||
this.updateMarkVisuals();
|
||
this.firstClicked = { r: startTr, c: startTc };
|
||
}
|
||
}
|
||
}
|
||
}
|
||
this.setBlockBgColor(this.draggingBlock, new Color(255, 255, 255));
|
||
|
||
this.draggingBlock = null;
|
||
this.draggingGroup = [];
|
||
this.slidingDir = null;
|
||
}
|
||
|
||
// 取消滑动
|
||
handleTouchCancel() {
|
||
if (!this.draggingBlock) return;
|
||
// 复位所有拖动方块位置
|
||
this.setBlockBgColor(this.draggingBlock, new Color(255, 255, 255));
|
||
if (this.draggingGroup.length > 0) {
|
||
this.draggingGroup.forEach(({ r, c }) => {
|
||
const block = this.blockNodes[r][c];
|
||
if (block) block.setPosition(this.getPos(r, c));
|
||
});
|
||
} else {
|
||
this.draggingBlock.setPosition(this.getPos(this.dragRow, this.dragCol));
|
||
}
|
||
this.draggingBlock = null;
|
||
this.draggingGroup = [];
|
||
this.slidingDir = null;
|
||
}
|
||
|
||
findBlockAtPosition(pos: Vec2): { block: Node; r: number; c: number } | null {
|
||
const uiTransform =
|
||
this.currentShapeNode.getComponent(UITransform) ||
|
||
this.currentShapeNode.addComponent(UITransform);
|
||
const localPos = uiTransform.convertToNodeSpaceAR(
|
||
new Vec3(pos.x, pos.y, 0),
|
||
);
|
||
|
||
const c = Math.floor(
|
||
(localPos.x + (this.cols * this.blockSize) / 2) / this.blockSize,
|
||
);
|
||
const r = Math.floor(
|
||
((this.rows * this.blockSize) / 2 - localPos.y) / this.blockSize,
|
||
);
|
||
|
||
if (r >= 0 && r < this.rows && c >= 0 && c < this.cols) {
|
||
const block = this.blockNodes[r][c];
|
||
if (block) {
|
||
return { block, r, c };
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
countEmptySteps(r: number, c: number, dirR: number, dirC: number): number {
|
||
let count = 0;
|
||
let nr = r + dirR;
|
||
let nc = c + dirC;
|
||
while (nr >= 0 && nr < this.rows && nc >= 0 && nc < this.cols) {
|
||
if (this.board[nr][nc] === -1) count++;
|
||
else break;
|
||
nr += dirR;
|
||
nc += dirC;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
// 点击方块处理 zzc
|
||
onBlockClick(r: number, c: number) {
|
||
if (this.isTutorial) {
|
||
if (this.tutorialStep === 1 && r === 0 && c === 0) {
|
||
this.tutorialStep = 2;
|
||
this.updateTutorialStep();
|
||
} else if (this.tutorialStep === 2 && r === 0 && c === 1) {
|
||
this.tutorialStep = 3;
|
||
this.updateTutorialStep();
|
||
}
|
||
}
|
||
|
||
const key = `${r},${c}`;
|
||
const type = this.board[r][c];
|
||
if (type < 0) return; // 空格不处理
|
||
if (!this.firstClicked) {
|
||
// 第一次点击
|
||
this.firstClicked = { r, c };
|
||
this.markedBlocks.clear();
|
||
|
||
// 四个方向找邻居
|
||
const dirs = [
|
||
{ dr: -1, dc: 0 }, // 上
|
||
{ dr: 1, dc: 0 }, // 下
|
||
{ dr: 0, dc: -1 }, // 左
|
||
{ dr: 0, dc: 1 }, // 右
|
||
];
|
||
|
||
let validNeighbors: { nr: number; nc: number }[] = [];
|
||
|
||
dirs.forEach(({ dr, dc }) => {
|
||
const neighbor = this.findFirstNeighbor(r, c, dr, dc);
|
||
if (neighbor && this.board[neighbor.nr][neighbor.nc] === type) {
|
||
validNeighbors.push(neighbor);
|
||
this.markedBlocks.add(`${neighbor.nr},${neighbor.nc}`);
|
||
}
|
||
});
|
||
if (validNeighbors.length === 1) {
|
||
// 唯一邻居 → 直接消除
|
||
const onlyNeighbor = validNeighbors[0];
|
||
this.setBlockBgColor(
|
||
this.blockNodes[onlyNeighbor.nr][onlyNeighbor.nc],
|
||
new Color(255, 100, 100),
|
||
);
|
||
this.drawLinkLine(
|
||
this.blockNodes[r][c],
|
||
this.blockNodes[onlyNeighbor.nr][onlyNeighbor.nc],
|
||
);
|
||
|
||
this.playRemoveAudio();
|
||
|
||
this.scheduleOnce(() => {
|
||
this.removeBlock(r, c);
|
||
this.removeBlock(onlyNeighbor.nr, onlyNeighbor.nc);
|
||
|
||
this.firstClicked = null;
|
||
this.markedBlocks.clear();
|
||
const empty = this.isBoardEmpty();
|
||
if (empty) {
|
||
this.onLevelComplete();
|
||
console.log("下一关");
|
||
} else {
|
||
const result = this.hasAvailableMove();
|
||
console.log(`${result ? "还有可移动的了" : "没有可移动的了"}`);
|
||
}
|
||
}, 0.5);
|
||
|
||
return;
|
||
}
|
||
|
||
// 否则高亮标记
|
||
this.updateMarkVisuals();
|
||
return;
|
||
}
|
||
|
||
// 第二次点击
|
||
if (this.markedBlocks.has(key)) {
|
||
this.playRemoveAudio();
|
||
this.drawLinkLine(
|
||
this.blockNodes[this.firstClicked.r][this.firstClicked.c],
|
||
this.blockNodes[r][c],
|
||
);
|
||
const targets = [this.firstClicked, { r, c }];
|
||
this.scheduleOnce(() => {
|
||
targets.forEach(({ r, c }) => this.removeBlock(r, c));
|
||
}, 0.5);
|
||
this.clearMarkVisuals();
|
||
|
||
this.markedBlocks.clear();
|
||
this.firstClicked = null;
|
||
const empty = this.isBoardEmpty();
|
||
if (empty) {
|
||
this.onLevelComplete();
|
||
console.log("下一关");
|
||
} else {
|
||
const result = this.hasAvailableMove();
|
||
console.log(`${result ? "还有可移动的了" : "没有可移动的了"}`);
|
||
}
|
||
} else {
|
||
// 重新选择
|
||
this.clearMarkVisuals();
|
||
this.markedBlocks.clear();
|
||
this.firstClicked = null;
|
||
this.onBlockClick(r, c);
|
||
}
|
||
}
|
||
|
||
findFirstNeighbor(r: number, c: number, dr: number, dc: number) {
|
||
let nr = r + dr;
|
||
let nc = c + dc;
|
||
while (nr >= 0 && nr < this.rows && nc >= 0 && nc < this.cols) {
|
||
if (this.board[nr][nc] >= 0) {
|
||
return { nr, nc }; // 找到第一个非空
|
||
}
|
||
nr += dr;
|
||
nc += dc;
|
||
}
|
||
return null; // 这个方向没有邻居
|
||
}
|
||
|
||
removeBlock(r: number, c: number) {
|
||
this.board[r][c] = -1;
|
||
if (this.blockNodes[r][c]) {
|
||
this.blockNodes[r][c].destroy();
|
||
this.blockNodes[r][c] = null;
|
||
}
|
||
}
|
||
|
||
// 找当前方块上下左右相邻且同类型的方块（单格，不连线）
|
||
findAdjacentSameType(
|
||
r: number,
|
||
c: number,
|
||
type: number,
|
||
dragGroup: { r: number; c: number }[] = [],
|
||
slidingDir: { dirR: number; dirC: number } | null = null,
|
||
): { nr: number; nc: number }[] {
|
||
const dirs = [
|
||
{ dr: -1, dc: 0 }, // 上
|
||
{ dr: 1, dc: 0 }, // 下
|
||
{ dr: 0, dc: -1 }, // 左
|
||
{ dr: 0, dc: 1 }, // 右
|
||
];
|
||
|
||
const neighbors: { nr: number; nc: number }[] = [];
|
||
|
||
dirs.forEach(({ dr, dc }) => {
|
||
const neighbor = this.findFirstNeighbor(r, c, dr, dc);
|
||
if (neighbor && this.board[neighbor.nr][neighbor.nc] === type) {
|
||
if (
|
||
dr === slidingDir.dirR &&
|
||
dc === slidingDir.dirC &&
|
||
dragGroup.length > 1
|
||
) {
|
||
} else {
|
||
neighbors.push(neighbor);
|
||
this.markedBlocks.add(`${neighbor.nr},${neighbor.nc}`);
|
||
}
|
||
}
|
||
});
|
||
|
||
return neighbors;
|
||
}
|
||
|
||
updateMarkVisuals() {
|
||
this.markedBlocks.forEach((key) => {
|
||
const [r, c] = key.split(",").map(Number);
|
||
this.setBlockBgColor(this.blockNodes[r][c], new Color(255, 255, 0));
|
||
});
|
||
}
|
||
|
||
hasSameNeighbor(row: number, col: number, type: number): boolean {
|
||
const dirs = [
|
||
{ dr: -1, dc: 0 }, // 上
|
||
{ dr: 1, dc: 0 }, // 下
|
||
{ dr: 0, dc: -1 }, // 左
|
||
{ dr: 0, dc: 1 }, // 右
|
||
];
|
||
for (const { dr, dc } of dirs) {
|
||
const nr = row + dr;
|
||
const nc = col + dc;
|
||
if (nr >= 0 && nr < this.rows && nc >= 0 && nc < this.cols) {
|
||
if (this.board[nr][nc] === type) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
clearMarkVisuals() {
|
||
this.markedBlocks.forEach((key) => {
|
||
const [r, c] = key.split(",").map(Number);
|
||
this.setBlockBgColor(this.blockNodes[r][c], new Color(255, 255, 255));
|
||
});
|
||
}
|
||
// 消除所有标记的方块，并清理状态
|
||
clearMarkedBlocks() {
|
||
if (this.markedBlocks.size === 0) return;
|
||
|
||
for (const key of this.markedBlocks) {
|
||
const [r, c] = key.split(",").map(Number);
|
||
this.board[r][c] = -1;
|
||
const block = this.blockNodes[r][c];
|
||
if (block) {
|
||
block.active = false;
|
||
this.blockNodes[r][c] = null;
|
||
}
|
||
}
|
||
|
||
this.markedBlocks.clear();
|
||
// this.selectedBlock = null;
|
||
this.clearMarkVisuals();
|
||
}
|
||
|
||
drawLinkLine(blockA: Node, blockB: Node) {
|
||
const g = this.lineLayer.getComponent(Graphics);
|
||
g.clear();
|
||
|
||
// 获取世界坐标
|
||
const posAWorld = blockA.worldPosition;
|
||
const posBWorld = blockB.worldPosition;
|
||
// 转换到 lineLayer 本地坐标
|
||
const posA = this.lineLayer
|
||
.getComponent(UITransform)
|
||
.convertToNodeSpaceAR(posAWorld);
|
||
const posB = this.lineLayer
|
||
.getComponent(UITransform)
|
||
.convertToNodeSpaceAR(posBWorld);
|
||
|
||
// 绘制线
|
||
g.lineWidth = 5;
|
||
g.strokeColor = Color.YELLOW;
|
||
g.moveTo(posA.x, posA.y);
|
||
g.lineTo(posB.x, posB.y);
|
||
g.stroke();
|
||
|
||
// 1 秒后清除
|
||
this.scheduleOnce(() => {
|
||
g.clear();
|
||
}, 0.5);
|
||
}
|
||
|
||
isBoardEmpty(): boolean {
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
if (this.board[r][c] >= 0) return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
hasAvailableMove(): boolean {
|
||
return this.findFirstEliminablePair() !== null;
|
||
}
|
||
|
||
// 辅助函数：模拟 group 移动 step 步后，是否有可消除邻居
|
||
getNeighborsAfterMove(
|
||
r: number,
|
||
c: number,
|
||
step: number,
|
||
dragGroup: { r: number; c: number }[] = [],
|
||
slidingDir: { dr: number; dc: number } | null = null,
|
||
): { nr: number; nc: number }[] {
|
||
const type = this.board[r][c];
|
||
|
||
// 预计算移动后的位置和原位置
|
||
const newPositions = new Set<string>();
|
||
const oldPositions = new Set<string>();
|
||
|
||
dragGroup.forEach(({ r: gr, c: gc }) => {
|
||
const tr = gr + slidingDir.dr * step;
|
||
const tc = gc + slidingDir.dc * step;
|
||
newPositions.add(`${tr},${tc}`);
|
||
oldPositions.add(`${gr},${gc}`);
|
||
});
|
||
|
||
const dirs = [
|
||
{ dr: -1, dc: 0 }, // 上
|
||
{ dr: 1, dc: 0 }, // 下
|
||
{ dr: 0, dc: -1 }, // 左
|
||
{ dr: 0, dc: 1 }, // 右
|
||
];
|
||
|
||
const neighbors: { nr: number; nc: number }[] = [];
|
||
|
||
// 目标位置（也就是当前检查的方块移动后的位置）
|
||
const tr = r + slidingDir.dr * step;
|
||
const tc = c + slidingDir.dc * step;
|
||
|
||
dirs.forEach(({ dr, dc }) => {
|
||
let nr = tr + dr;
|
||
let nc = tc + dc;
|
||
|
||
while (nr >= 0 && nr < this.rows && nc >= 0 && nc < this.cols) {
|
||
const key = `${nr},${nc}`;
|
||
let cellType = -1;
|
||
|
||
if (newPositions.has(key)) {
|
||
// 是移动过来的方块，找到它的原始位置获取类型
|
||
const or = nr - slidingDir.dr * step;
|
||
const oc = nc - slidingDir.dc * step;
|
||
cellType = this.board[or][oc];
|
||
} else if (oldPositions.has(key)) {
|
||
// 是原来的位置，但现在空了（且没被新方块占据）
|
||
cellType = -1;
|
||
} else {
|
||
// 静态方块
|
||
cellType = this.board[nr][nc];
|
||
}
|
||
|
||
if (cellType >= 0) {
|
||
// 找到第一个非空
|
||
if (cellType === type) {
|
||
// 排除自身移动方向上的内部连接（通常不需要消除）
|
||
if (
|
||
dr === slidingDir.dr &&
|
||
dc === slidingDir.dc &&
|
||
dragGroup.length > 1
|
||
) {
|
||
// ignore
|
||
} else {
|
||
neighbors.push({ nr, nc });
|
||
}
|
||
}
|
||
break;
|
||
} else if (cellType === -2) {
|
||
// 石头，阻挡
|
||
break;
|
||
}
|
||
|
||
nr += dr;
|
||
nc += dc;
|
||
}
|
||
});
|
||
|
||
return neighbors;
|
||
}
|
||
|
||
/** 四方向常量 */
|
||
private static readonly DIRS = [
|
||
{ dr: -1, dc: 0 }, // 上
|
||
{ dr: 1, dc: 0 }, // 下
|
||
{ dr: 0, dc: -1 }, // 左
|
||
{ dr: 0, dc: 1 }, // 右
|
||
];
|
||
|
||
/**
|
||
* 核心：找到第一对“可以消除”的方块
|
||
* 规则覆盖：
|
||
* - 直接相邻；
|
||
* - 单格滑动（穿过空格）；
|
||
* - 多块组（连续段）从两端向外滑动（两端之外第一非空如果同色就可消）
|
||
* 返回 null 表示不存在
|
||
*/
|
||
private findFirstEliminablePair(): {
|
||
from: { r: number; c: number };
|
||
to: { r: number; c: number };
|
||
} | null {
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
const type = this.board[r][c];
|
||
if (type < 0) continue;
|
||
|
||
// 1️⃣ 单格邻居提示
|
||
const hint = this.checkSingleNeighbor(r, c);
|
||
if (hint) return hint;
|
||
|
||
// 2️⃣ 滑动提示
|
||
const hint2 = this.checkMoveNeighbor(r, c);
|
||
if (hint2) return hint2;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 提示函数
|
||
* 返回可操作消除的一组方块坐标 [{r, c}, ...]
|
||
* 如果没有可消除组，返回空数组 []
|
||
*/
|
||
getHint(): {
|
||
from: { r: number; c: number };
|
||
to: { r: number; c: number };
|
||
steps?: number;
|
||
dir?: { dr: number; dc: number };
|
||
} | null {
|
||
return this.findFirstEliminablePair();
|
||
}
|
||
|
||
// 单格邻居检测
|
||
checkSingleNeighbor(r: number, c: number) {
|
||
const type = this.board[r][c];
|
||
for (const { dr, dc } of GameManager.DIRS) {
|
||
const nr = r + dr;
|
||
const nc = c + dc;
|
||
if (nr < 0 || nr >= this.rows || nc < 0 || nc >= this.cols) continue;
|
||
if (this.board[nr][nc] === type) {
|
||
return { from: { r, c }, to: { r: nr, c: nc } };
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// 滑动提示
|
||
checkMoveNeighbor(r: number, c: number) {
|
||
for (const { dr, dc } of GameManager.DIRS) {
|
||
const group = this.dragManager.findDragGroup(r, c, dr, dc);
|
||
const maxSteps = this.dragManager.countEmptyStepsGroup(group, dr, dc);
|
||
if (maxSteps === 0) continue;
|
||
|
||
for (let step = 1; step <= maxSteps; step++) {
|
||
const neighbors = this.getNeighborsAfterMove(r, c, step, group, {
|
||
dr,
|
||
dc,
|
||
});
|
||
if (neighbors.length > 0) {
|
||
const { nr, nc } = neighbors[0];
|
||
return {
|
||
from: { r, c },
|
||
to: { r: nr, c: nc },
|
||
steps: step,
|
||
dir: { dr, dc },
|
||
};
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
highlightHint() {
|
||
const count = this.toolBadge.getHintCount();
|
||
if (count <= 0) {
|
||
console.log("看广告");
|
||
this.toolBadge.showAdAndReward("hint");
|
||
return;
|
||
}
|
||
const hint = this.getHint();
|
||
if (hint) {
|
||
AudioManager.instance.playSFX(SFXType.Hint);
|
||
if (hint?.steps) {
|
||
this.hintManager.showHint(hint, this.getPos.bind(this));
|
||
}
|
||
this.toolBadge.useHintOnce();
|
||
|
||
this.hintPair.from = hint.from;
|
||
this.hintPair.to = hint.to;
|
||
|
||
this.setBlockBgColor(
|
||
this.blockNodes[hint.from.r][hint.from.c],
|
||
new Color(255, 100, 100),
|
||
);
|
||
|
||
this.setBlockBgColor(
|
||
this.blockNodes[hint.to.r][hint.to.c],
|
||
new Color(255, 100, 100),
|
||
);
|
||
} else {
|
||
console.log("没有可消除的组合");
|
||
}
|
||
// if (hintBlocks.length === 0) return;
|
||
|
||
// hintBlocks.forEach(({ nr, nc }) => {
|
||
// const node = this.blockNodes[nr][nc];
|
||
// if (!node) return;
|
||
|
||
// // 闪烁动画：颜色在原色和高亮色之间切换
|
||
// const originalColor = node.getComponent(Sprite)!.color.clone();
|
||
// const highlightColor = new Color(255, 255, 0); // 黄色高亮
|
||
|
||
// tween(node.getComponent(Sprite)!)
|
||
// .to(0.3, { color: highlightColor })
|
||
// .to(0.3, { color: originalColor })
|
||
// .to(0.3, { color: highlightColor })
|
||
// .to(0.3, { color: originalColor })
|
||
// .start();
|
||
// });
|
||
}
|
||
|
||
playRemoveAudio() {
|
||
AudioManager.instance.playSFX(SFXType.Remove);
|
||
}
|
||
|
||
shuffleBoard(): void {
|
||
const count = this.toolBadge.getShuffleCount();
|
||
console.log("打乱次数", count);
|
||
if (count <= 0) {
|
||
console.log("看广告");
|
||
this.toolBadge.showAdAndReward("shuffle");
|
||
return;
|
||
}
|
||
|
||
// 1. 收集剩余方块类型
|
||
const blocks: number[] = [];
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
if (this.board[r][c] >= 0) {
|
||
blocks.push(this.board[r][c]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 2. Fisher–Yates 随机打乱
|
||
for (let i = blocks.length - 1; i > 0; i--) {
|
||
const j = Math.floor(Math.random() * (i + 1));
|
||
[blocks[i], blocks[j]] = [blocks[j], blocks[i]];
|
||
}
|
||
|
||
// 3. 重新写入 this.board
|
||
let idx = 0;
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
if (this.board[r][c] >= 0) {
|
||
this.board[r][c] = blocks[idx++];
|
||
}
|
||
}
|
||
}
|
||
AudioManager.instance.playSFX(SFXType.Shuffle);
|
||
// 4. 更新渲染状态 blockNodes
|
||
this.updateBlockNodes();
|
||
|
||
// 5. 确保有解，没有就重新 shuffle
|
||
this.toolBadge.useShuffleOnce();
|
||
|
||
if (!this.getHint()) {
|
||
this.shuffleBoard(); // 递归重新打乱直到有解
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 遍历 board 更新所有 blockNodes
|
||
*/
|
||
updateBlockNodes(): void {
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
const type = this.board[r][c];
|
||
|
||
if (type >= 0) {
|
||
let node = this.blockNodes[r][c];
|
||
if (!node) {
|
||
// 如果之前是空格，新建节点
|
||
// node = this.createBlockNode(type, r, c);
|
||
// this.blockNodes[r][c] = node;
|
||
// this.board[r][c] = type;
|
||
const block = this.levelBuilder.createBlockNode(type, r, c);
|
||
this.blockNodes[r][c] = block;
|
||
} else {
|
||
// 更新已有节点的类型显示
|
||
this.levelBuilder.setBlockType(node, type);
|
||
this.levelBuilder.setBlockPosition(node, r, c);
|
||
}
|
||
} else if (type === -1) {
|
||
// 空格 → 清理节点
|
||
if (this.blockNodes[r][c]) {
|
||
this.levelBuilder.destroyBlockNode(this.blockNodes[r][c]);
|
||
this.blockNodes[r][c] = null;
|
||
}
|
||
} else if (type === -2) {
|
||
// 石头 不处理
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Fisher–Yates 洗牌
|
||
shuffleArray<T>(arr: T[]): T[] {
|
||
for (let i = arr.length - 1; i > 0; i--) {
|
||
const j = Math.floor(Math.random() * (i + 1));
|
||
[arr[i], arr[j]] = [arr[j], arr[i]];
|
||
}
|
||
return arr;
|
||
}
|
||
|
||
// 检查棋盘是否有解
|
||
hasSolution(board: number[][]): boolean {
|
||
// 临时替换 this.board
|
||
const backup = this.board;
|
||
this.board = board;
|
||
|
||
const hint = this.findFirstEliminablePair();
|
||
|
||
this.board = backup; // 恢复
|
||
return !!hint;
|
||
}
|
||
|
||
public eliminateRandomType(): void {
|
||
const count = this.toolBadge.getMagicCount();
|
||
if (count <= 0) {
|
||
console.log("看广告");
|
||
this.toolBadge.showAdAndReward("magic");
|
||
return;
|
||
}
|
||
|
||
const types = new Set<number>();
|
||
|
||
// 收集当前所有存在的方块类型
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
const val = this.board[r][c];
|
||
if (val >= 0) {
|
||
types.add(val);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (types.size === 0) {
|
||
console.warn("没有可消除的方块了");
|
||
this.onLevelComplete();
|
||
return;
|
||
}
|
||
|
||
// 转成数组，随机挑一个
|
||
const typeArray = Array.from(types);
|
||
const randType = typeArray[Math.floor(Math.random() * typeArray.length)];
|
||
|
||
console.log("随机消除类型:", randType);
|
||
|
||
this.eliminateType(randType);
|
||
}
|
||
|
||
public eliminateType(type: number): void {
|
||
this.toolBadge.useMagicOnce();
|
||
AudioManager.instance.playSFX(SFXType.Magic);
|
||
for (let r = 0; r < this.rows; r++) {
|
||
for (let c = 0; c < this.cols; c++) {
|
||
if (this.board[r][c] === type) {
|
||
this.board[r][c] = -1;
|
||
|
||
const node = this.blockNodes[r][c];
|
||
if (node) {
|
||
this.playEliminateAnimation(node, () => {
|
||
this.destroyBlockNode(node);
|
||
this.blockNodes[r][c] = null;
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const empty = this.isBoardEmpty();
|
||
|
||
if (empty) {
|
||
setTimeout(() => {
|
||
this.onLevelComplete();
|
||
console.log("下一关");
|
||
}, 1000);
|
||
}
|
||
}
|
||
|
||
private playEliminateAnimation(node: Node, onFinish: () => void) {
|
||
// 确保有透明组件
|
||
let opacityComp = node.getComponent(UIOpacity);
|
||
if (!opacityComp) {
|
||
opacityComp = node.addComponent(UIOpacity);
|
||
}
|
||
opacityComp.opacity = 255;
|
||
|
||
// 动画：缩放 → 轻微旋转 → 弹缩 → 渐隐消失
|
||
tween(node)
|
||
.parallel(
|
||
tween().to(0.15, { scale: new Vec3(1.2, 1.2, 1) }), // 先放大一点
|
||
tween().to(0.15, { angle: 30 }), // 顺时针轻微旋转
|
||
)
|
||
.parallel(
|
||
tween().to(
|
||
0.25,
|
||
{ scale: new Vec3(0.8, 0.8, 1) },
|
||
{ easing: "quadOut" },
|
||
), // 缩小回弹
|
||
tween().to(0.25, { angle: -30 }), // 逆时针旋转
|
||
)
|
||
.parallel(
|
||
tween().to(0.2, { scale: new Vec3(0, 0, 0) }), // 最终缩小
|
||
tween(opacityComp).to(0.2, { opacity: 0 }), // 渐隐
|
||
)
|
||
.call(() => {
|
||
onFinish();
|
||
})
|
||
.start();
|
||
}
|
||
|
||
public destroyBlockNode(node: Node): void {
|
||
if (node && node.isValid) {
|
||
node.removeFromParent();
|
||
node.destroy();
|
||
}
|
||
}
|
||
|
||
public resetHintPair() {
|
||
if (
|
||
this.isNumber(this.hintPair?.from?.r) &&
|
||
this.isNumber(this.hintPair?.from?.c)
|
||
) {
|
||
this.setBlockBgColor(
|
||
this.blockNodes[this.hintPair?.from?.r][this.hintPair?.from?.c],
|
||
new Color(255, 255, 255),
|
||
);
|
||
}
|
||
|
||
if (
|
||
this.isNumber(this.hintPair?.to?.r) &&
|
||
this.isNumber(this.hintPair?.to?.c)
|
||
) {
|
||
this.setBlockBgColor(
|
||
this.blockNodes[this.hintPair.to.r][this.hintPair.to.c],
|
||
new Color(255, 255, 255),
|
||
);
|
||
}
|
||
|
||
this.hintPair = { from: {}, to: {} };
|
||
}
|
||
|
||
public isNumber(value) {
|
||
return (
|
||
value !== null &&
|
||
value !== undefined &&
|
||
typeof value === "number" &&
|
||
!isNaN(value)
|
||
);
|
||
}
|
||
}
|