import { _decorator, Component, Node, Vec2, Vec3, UITransform, Collider2D, Contact2DType, IPhysics2DContact, RigidBody2D, Prefab, instantiate, find, CircleCollider2D, JsonAsset, ERigidBody2DType } from 'cc'; import { PhysicsManager } from '../Core/PhysicsManager'; import { WeaponBullet, BulletInitData } from './WeaponBullet'; import { WeaponConfig } from '../Core/ConfigManager'; import EventBus, { GameEvents } from '../Core/EventBus'; import { PersistentSkillManager } from '../FourUI/SkillSystem/PersistentSkillManager'; import { BallAni } from '../Animations/BallAni'; import { BallControllerConfig } from '../Core/ConfigManager'; import { WeaponInfo } from './BlockSelection/WeaponInfo'; import { BlockInfo } from './BlockSelection/BlockInfo'; const { ccclass, property } = _decorator; @ccclass('BallController') export class BallController extends Component { // 球的预制体 @property({ type: Prefab, tooltip: '拖拽Ball预制体到这里' }) public ballPrefab: Prefab = null; // 已放置方块容器节点 @property({ type: Node, tooltip: '拖拽PlacedBlocks节点到这里（Canvas/GameLevelUI/GameArea/PlacedBlocks）' }) public placedBlocksContainer: Node = null; // 球控制器配置文件 @property({ type: JsonAsset, tooltip: '拖拽ballController.json配置文件到这里' }) public ballControllerConfig: JsonAsset = null; // 球的移动速度（从配置文件加载） public baseSpeed: number = 60; public currentSpeed: number = 60; // 反弹随机偏移最大角度（弧度）（从配置文件加载） public maxReflectionRandomness: number = 0.2; // 当前活动的球 private activeBall: Node = null; // 球的方向向量 private direction: Vec2 = new Vec2(); // GameArea区域边界 private gameBounds = { left: 0, right: 0, top: 0, bottom: 0 }; // 球的半径 private radius: number = 0; // 配置数据 private config: BallControllerConfig = null; // 是否已初始化 private initialized: boolean = false; // 子弹预制体 @property({ type: Prefab, tooltip: '拖拽子弹预制体到这里' }) public bulletPrefab: Prefab = null; // 小球是否已开始运动 private ballStarted: boolean = false; // 小球暂停时记录的速度 private pausedVelocity: Vec2 = new Vec2(); // 标记是否处于暂停状态 private isPaused: boolean = false; // 在类字段区添加 private blockFireCooldown: Map = new Map(); private FIRE_COOLDOWN = 0.05; // 防围困机制配置（从配置文件加载） public antiTrapTimeWindow: number = 5.0; public antiTrapHitThreshold: number = 5; public deflectionAttemptThreshold: number = 3; public antiTrapDeflectionMultiplier: number = 3.0; // 增强防围困机制配置 @property({ tooltip: '振荡检测时间窗口（秒）：检测小球往复运动的时间范围' }) public oscillationTimeWindow: number = 3.0; @property({ tooltip: '方向改变阈值：触发振荡检测的方向改变次数' }) public directionChangeThreshold: number = 4; @property({ tooltip: '位置历史记录数量：用于检测往复运动的位置样本数' }) public positionHistorySize: number = 20; @property({ tooltip: '振荡距离阈值：判定为往复运动的最小距离范围' }) public oscillationDistanceThreshold: number = 100; // 测试模式开关 @property({ tooltip: '启用测试模式：小球只会向上/下/左/右四个基本方向移动，便于测试防围困机制' }) public testMode: boolean = true; // 小球位置检查配置 @property({ tooltip: '启用小球位置检查：定期检查小球是否在游戏区域内，如果不在则找回' }) public enableBallPositionCheck: boolean = true; @property({ tooltip: '位置检查间隔（秒）：多久检查一次小球位置' }) public positionCheckInterval: number = 2.0; @property({ tooltip: '位置检查边界扩展（像素）：检查边界比游戏区域稍大，避免误判' }) public positionCheckBoundaryExtension: number = 50; // 防围困机制状态 private ballHitHistory: Map = new Map(); // 记录每个球的撞击时间历史 private ballPhaseThrough: Map = new Map(); // 记录每个球的穿透结束时间 private ballDeflectionAttempts: Map = new Map(); // 记录每个球的偏移尝试次数 // 增强防围困机制：运动模式检测 private ballPositionHistory: Map = new Map(); // 记录小球位置历史 private ballDirectionHistory: Map = new Map(); // 记录小球方向历史 private ballOscillationDetection: Map = new Map(); // 振荡检测数据 // 带尾部特效的子弹容器预制体 @property({ type: Prefab, tooltip: '拖拽带尾部特效的子弹容器预制体到这里（例如 PelletContainer）' }) public bulletContainerPrefab: Prefab = null; // 正在被拖拽的方块集合 private draggingBlocks: Set = new Set(); // 小球位置检查相关变量 private lastPositionCheckTime: number = 0; // 上次位置检查的时间 start() { // 如果没有指定placedBlocksContainer，尝试找到它 if (!this.placedBlocksContainer) { this.placedBlocksContainer = find('Canvas/GameLevelUI/GameArea/PlacedBlocks'); if (!this.placedBlocksContainer) { // 找不到PlacedBlocks节点，某些功能可能无法正常工作 } } // 加载配置 this.loadConfig(); // 只进行初始设置，不创建小球 this.calculateGameBounds(); // 监听游戏事件 this.setupEventListeners(); // 监听球速技能变化并更新球速 this.updateBallSpeed(); } /** * 设置事件监听器 */ // 加载配置 private loadConfig() { if (this.ballControllerConfig && this.ballControllerConfig.json) { this.config = this.ballControllerConfig.json as BallControllerConfig; this.applyConfig(); console.log('[BallController] ✅ 配置文件通过装饰器加载成功:', this.config); } else { console.warn('[BallController] ⚠️ 配置文件未设置，使用默认值'); // 使用默认配置 this.config = { baseSpeed: 60, maxReflectionRandomness: 0.2, antiTrapTimeWindow: 5.0, antiTrapHitThreshold: 5, deflectionAttemptThreshold: 3, antiTrapDeflectionMultiplier: 3.0, FIRE_COOLDOWN: 0.05, ballRadius: 10, gravityScale: 0, linearDamping: 0, angularDamping: 0, colliderGroup: 1, colliderTag: 1, friction: 0, restitution: 1, safeDistance: 50, edgeOffset: 20, sensor: false, maxAttempts: 50 }; this.applyConfig(); } } // 应用配置 private applyConfig() { if (!this.config) return; this.baseSpeed = this.config.baseSpeed; this.currentSpeed = this.config.baseSpeed; this.maxReflectionRandomness = this.config.maxReflectionRandomness; this.antiTrapTimeWindow = this.config.antiTrapTimeWindow; this.antiTrapHitThreshold = this.config.antiTrapHitThreshold; this.deflectionAttemptThreshold = this.config.deflectionAttemptThreshold; this.antiTrapDeflectionMultiplier = this.config.antiTrapDeflectionMultiplier; this.FIRE_COOLDOWN = this.config.FIRE_COOLDOWN; console.log('BallController配置已应用:', this.config); } // 从配置中获取参数值的辅助方法 private getConfigValue(key: keyof BallControllerConfig, defaultValue: T): T { return this.config && this.config[key] !== undefined ? this.config[key] as T : defaultValue; } // 配置参数的getter方法 private get ballRadius(): number { return this.getConfigValue('ballRadius', 10); } private get gravityScale(): number { return this.getConfigValue('gravityScale', 0); } private get linearDamping(): number { return this.getConfigValue('linearDamping', 0); } private get angularDamping(): number { return this.getConfigValue('angularDamping', 0); } private get colliderGroup(): number { return this.getConfigValue('colliderGroup', 2); } private get colliderTag(): number { return this.getConfigValue('colliderTag', 1); } private get friction(): number { return this.getConfigValue('friction', 0); } private get restitution(): number { return this.getConfigValue('restitution', 1); } private get safeDistance(): number { return this.getConfigValue('safeDistance', 50); } private get edgeOffset(): number { return this.getConfigValue('edgeOffset', 20); } private get sensor(): boolean { return this.getConfigValue('sensor', false); } private get maxAttempts(): number { return this.getConfigValue('maxAttempts', 50); } private setupEventListeners() { const eventBus = EventBus.getInstance(); // 监听暂停事件 eventBus.on(GameEvents.GAME_PAUSE, this.onGamePauseEvent, this); // 监听恢复事件 eventBus.on(GameEvents.GAME_RESUME, this.onGameResumeEvent, this); // 监听重置球控制器事件 eventBus.on(GameEvents.RESET_BALL_CONTROLLER, this.onResetBallControllerEvent, this); // 监听球创建事件 eventBus.on(GameEvents.BALL_CREATE, this.onBallCreateEvent, this); // 监听球启动事件 eventBus.on(GameEvents.BALL_START, this.onBallStartEvent, this); // 监听创建额外球事件 eventBus.on(GameEvents.BALL_CREATE_ADDITIONAL, this.onBallCreateAdditionalEvent, this); // 监听子弹发射检查事件 eventBus.on(GameEvents.BALL_FIRE_BULLET, this.onBallFireBulletEvent, this); // 监听方块拖拽开始事件 eventBus.on(GameEvents.BLOCK_DRAG_START, this.onBlockDragStartEvent, this); // 监听方块拖拽结束事件 eventBus.on(GameEvents.BLOCK_DRAG_END, this.onBlockDragEndEvent, this); } /** * 处理游戏暂停事件 */ private onGamePauseEvent() { console.log('[BallController] 接收到游戏暂停事件，暂停小球运动'); this.pauseBall(); } /** * 处理游戏恢复事件 */ private onGameResumeEvent() { console.log('[BallController] 接收到游戏恢复事件，恢复小球运动'); this.resumeBall(); } /** * 处理重置球控制器事件 */ private onResetBallControllerEvent() { console.log('[BallController] 接收到重置球控制器事件'); this.resetBallController(); } /** * 处理球创建事件 */ private onBallCreateEvent() { console.log('[BallController] 接收到球创建事件'); this.createBall(); } /** * 处理球启动事件 */ private onBallStartEvent() { console.log('[BallController] 接收到球启动事件'); this.startBall(); } /** * 处理创建额外球事件 */ private onBallCreateAdditionalEvent() { console.log('[BallController] 接收到创建额外球事件'); this.createAdditionalBall(); } /** * 处理子弹发射检查事件 */ private onBallFireBulletEvent(blockNode: Node, fireWorldPos: Vec3) { // 如果游戏暂停，则不允许发射子弹 if (this.isPaused) { console.log('[BallController] 游戏暂停中，阻止子弹发射'); return; } // 如果游戏未暂停，则继续执行子弹发射逻辑 this.fireBulletAt(blockNode, fireWorldPos); } /** * 处理方块拖拽开始事件 */ private onBlockDragStartEvent(data: { block: Node }) { if (data && data.block) { console.log('[BallController] 方块开始拖拽:', data.block.name, '路径:', this.getNodePath(data.block)); this.draggingBlocks.add(data.block); console.log('[BallController] 当前拖拽方块数量:', this.draggingBlocks.size); } } /** * 处理方块拖拽结束事件 */ private onBlockDragEndEvent(data: { block: Node }) { if (data && data.block) { console.log('[BallController] 方块结束拖拽:', data.block.name, '路径:', this.getNodePath(data.block)); const wasDeleted = this.draggingBlocks.delete(data.block); console.log('[BallController] 删除成功:', wasDeleted, '当前拖拽方块数量:', this.draggingBlocks.size); } } /** * 调试方法：显示当前拖拽的方块 */ private debugDraggingBlocks() { console.log('[BallController] 当前拖拽方块列表:'); this.draggingBlocks.forEach((block, index) => { // console.log(` ${index + 1}. ${block.name} - 路径: ${this.getNodePath(block)} - 有效: ${block.isValid}`); }); } // 计算游戏边界（使用GameArea节点） calculateGameBounds() { // 获取GameArea节点 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (!gameArea) { return; } const gameAreaUI = gameArea.getComponent(UITransform); if (!gameAreaUI) { return; } // 获取GameArea的尺寸 const areaWidth = gameAreaUI.width; const areaHeight = gameAreaUI.height; // 获取GameArea的世界坐标位置 const worldPos = gameArea.worldPosition; // 计算GameArea的世界坐标边界 this.gameBounds.left = worldPos.x - areaWidth / 2; this.gameBounds.right = worldPos.x + areaWidth / 2; this.gameBounds.bottom = worldPos.y - areaHeight / 2; this.gameBounds.top = worldPos.y + areaHeight / 2; } // 创建小球 createBall() { if (!this.ballPrefab) { console.error('[BallController] ballPrefab 未设置，无法创建小球'); return; } // 实例化小球 this.activeBall = instantiate(this.ballPrefab); if (!this.activeBall) { console.error('[BallController] 小球实例化失败'); return; } // 将小球添加到GameArea中 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (gameArea) { gameArea.addChild(this.activeBall); } else { console.warn('[BallController] 未找到GameArea，将小球添加到当前节点'); this.node.addChild(this.activeBall); } // 随机位置小球 this.positionBallRandomly(); // 设置球的半径 const transform = this.activeBall.getComponent(UITransform); if (transform) { this.radius = transform.width / 2; } else { this.radius = 25; // 默认半径 } // 确保有碰撞组件 this.setupCollider(); // 注意：不在这里初始化方向，等待 startBall() 调用 this.initialized = true; } // 创建额外的小球（不替换现有的小球） public createAdditionalBall() { if (!this.ballPrefab) { console.error('无法创建额外小球：ballPrefab 未设置'); return; } // 实例化新的小球 const newBall = instantiate(this.ballPrefab); newBall.name = 'AdditionalBall'; // 将小球添加到GameArea中 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (gameArea) { gameArea.addChild(newBall); } else { this.node.addChild(newBall); } // 随机位置小球 this.positionAdditionalBall(newBall); // 设置球的碰撞组件 this.setupBallCollider(newBall); // 设置初始方向和速度 this.initializeBallDirection(newBall); console.log('创建了额外的小球'); return newBall; } // 为额外小球设置随机位置 private positionAdditionalBall(ball: Node) { if (!ball) return; const transform = ball.getComponent(UITransform); const ballRadius = transform ? transform.width / 2 : this.ballRadius; // 计算可生成的范围（考虑小球半径，避免生成在边缘） const minX = this.gameBounds.left + ballRadius + this.edgeOffset; const maxX = this.gameBounds.right - ballRadius - this.edgeOffset; const minY = this.gameBounds.bottom + ballRadius + this.edgeOffset; const maxY = this.gameBounds.top - ballRadius - this.edgeOffset; // 获取GameArea节点 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (!gameArea) { return; } // 随机生成位置 const randomX = Math.random() * (maxX - minX) + minX; const randomY = Math.random() * (maxY - minY) + minY; // 将世界坐标转换为相对于GameArea的本地坐标 const localPos = gameArea.getComponent(UITransform).convertToNodeSpaceAR(new Vec3(randomX, randomY, 0)); ball.position = localPos; } // 为额外小球设置碰撞组件 private setupBallCollider(ball: Node) { // 确保有碰撞组件 let collider = ball.getComponent(CircleCollider2D); if (!collider) { collider = ball.addComponent(CircleCollider2D); } // 设置碰撞属性（使用配置值） collider.radius = this.ballRadius; collider.group = this.colliderGroup; collider.tag = this.colliderTag; collider.sensor = this.sensor; collider.friction = this.friction; collider.restitution = this.restitution; // 添加刚体组件 let rigidBody = ball.getComponent(RigidBody2D); if (!rigidBody) { rigidBody = ball.addComponent(RigidBody2D); } // 设置刚体属性（使用配置值） rigidBody.type = ERigidBody2DType.Dynamic; // 动态刚体 rigidBody.allowSleep = false; rigidBody.gravityScale = this.gravityScale; rigidBody.linearDamping = this.linearDamping; rigidBody.angularDamping = this.angularDamping; rigidBody.fixedRotation = true; rigidBody.enabledContactListener = true; // 启用碰撞监听 // 注意：不需要为每个小球单独添加碰撞回调， // 因为我们使用的是全局物理系统回调 } // 为额外小球初始化方向和速度 private initializeBallDirection(ball: Node) { // 随机初始方向 const angle = Math.random() * Math.PI * 2; // 0-2π之间的随机角度 const direction = new Vec2(Math.cos(angle), Math.sin(angle)).normalize(); // 设置初始速度 const rigidBody = ball.getComponent(RigidBody2D); if (rigidBody) { rigidBody.linearVelocity = new Vec2( direction.x * this.currentSpeed, direction.y * this.currentSpeed ); } } // 检查所有已放置方块的碰撞体组件 private checkBlockColliders() { if (!this.placedBlocksContainer) { return; } if (!this.placedBlocksContainer.isValid) { return; } const blocks = []; for (let i = 0; i < this.placedBlocksContainer.children.length; i++) { const block = this.placedBlocksContainer.children[i]; if (block.name.includes('Block') || block.getChildByName('B1')) { blocks.push(block); } } let fixedCount = 0; for (let i = 0; i < blocks.length; i++) { const block = blocks[i]; // 检查方块本身的碰撞体 const blockCollider = block.getComponent(Collider2D); if (blockCollider) { // 🔧 自动修复碰撞组设置 if (blockCollider.group !== 2) { blockCollider.group = 2; // 设置为Block组 fixedCount++; } // 确保不是传感器 if (blockCollider.sensor) { blockCollider.sensor = false; } } // 检查B1子节点的碰撞体 const b1Node = block.getChildByName('B1'); if (b1Node) { const b1Collider = b1Node.getComponent(Collider2D); if (b1Collider) { // 🔧 修复B1子节点的碰撞设置 if (b1Collider.group !== 2) { b1Collider.group = 2; // 设置为Block组 fixedCount++; } // 确保B1不是传感器（需要实际碰撞） if (b1Collider.sensor) { b1Collider.sensor = false; } } } // 检查Weapon子节点 const weaponNode = this.findWeaponNode(block); if (weaponNode) { // 武器节点存在 } } } // 随机位置小球 positionBallRandomly() { if (!this.activeBall) return; const transform = this.activeBall.getComponent(UITransform); const ballRadius = transform ? transform.width / 2 : this.ballRadius; // 计算可生成的范围（考虑小球半径，避免生成在边缘） const minX = this.gameBounds.left + ballRadius + this.edgeOffset; // 额外偏移，避免生成在边缘 const maxX = this.gameBounds.right - ballRadius - this.edgeOffset; const minY = this.gameBounds.bottom + ballRadius + this.edgeOffset; const maxY = this.gameBounds.top - ballRadius - this.edgeOffset; // 获取GameArea节点 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (!gameArea) { return; } // 查找PlacedBlocks节点，它包含所有放置的方块 if (!this.placedBlocksContainer) { this.setRandomPositionDefault(this.activeBall, minX, maxX, minY, maxY); return; } // 获取所有已放置的方块 const placedBlocks = []; for (let i = 0; i < this.placedBlocksContainer.children.length; i++) { const block = this.placedBlocksContainer.children[i]; // 检查是否是方块节点（通常以Block命名或有特定标识） if (block.name.includes('Block') || block.getChildByName('B1')) { placedBlocks.push(block); } } // 如果没有方块，使用默认随机位置 if (placedBlocks.length === 0) { this.setRandomPositionDefault(this.activeBall, minX, maxX, minY, maxY); return; } // 尝试找到一个不与任何方块重叠的位置 let validPosition = false; let attempts = 0; const maxAttempts = this.maxAttempts; // 从配置中获取最大尝试次数 let randomX, randomY; while (!validPosition && attempts < maxAttempts) { // 随机生成位置 randomX = Math.random() * (maxX - minX) + minX; randomY = Math.random() * (maxY - minY) + minY; // 检查是否与任何方块重叠 let overlapping = false; for (const block of placedBlocks) { // 获取方块的世界坐标 const blockWorldPos = block.worldPosition; // 计算小球与方块的距离 const distance = Math.sqrt( Math.pow(randomX - blockWorldPos.x, 2) + Math.pow(randomY - blockWorldPos.y, 2) ); // 获取方块的尺寸 const blockTransform = block.getComponent(UITransform); const blockSize = blockTransform ? Math.max(blockTransform.width, blockTransform.height) / 2 : this.safeDistance; // 如果距离小于小球半径+方块尺寸的一半+安全距离，认为重叠 if (distance < ballRadius + blockSize + this.safeDistance) { overlapping = true; break; } } // 如果没有重叠，找到了有效位置 if (!overlapping) { validPosition = true; } attempts++; } // 如果找不到有效位置，使用默认位置（游戏区域底部中心） if (!validPosition) { randomX = (this.gameBounds.left + this.gameBounds.right) / 2; randomY = this.gameBounds.bottom + ballRadius + this.safeDistance; // 底部上方安全距离单位 } // 将世界坐标转换为相对于GameArea的本地坐标 const localPos = gameArea.getComponent(UITransform).convertToNodeSpaceAR(new Vec3(randomX, randomY, 0)); this.activeBall.position = localPos; } // 设置碰撞组件 setupCollider() { if (!this.activeBall) return; // 确保小球有刚体组件 let rigidBody = this.activeBall.getComponent(RigidBody2D); if (!rigidBody) { rigidBody = this.activeBall.addComponent(RigidBody2D); rigidBody.type = ERigidBody2DType.Dynamic; // Dynamic rigidBody.gravityScale = this.gravityScale; // 从配置获取重力缩放 rigidBody.enabledContactListener = true; // 启用碰撞监听 rigidBody.fixedRotation = true; // 固定旋转 rigidBody.allowSleep = false; // 不允许休眠 rigidBody.linearDamping = this.linearDamping; // 从配置获取线性阻尼 rigidBody.angularDamping = this.angularDamping; // 从配置获取角阻尼 } else { // 确保已有的刚体组件设置正确 rigidBody.enabledContactListener = true; rigidBody.gravityScale = this.gravityScale; rigidBody.linearDamping = this.linearDamping; // 从配置获取线性阻尼 rigidBody.angularDamping = this.angularDamping; // 从配置获取角阻尼 rigidBody.allowSleep = false; // 不允许休眠 } // 确保小球有碰撞组件 let collider = this.activeBall.getComponent(CircleCollider2D); if (!collider) { collider = this.activeBall.addComponent(CircleCollider2D); collider.radius = this.radius || this.ballRadius; // 使用已计算的半径或配置值 collider.tag = this.colliderTag; // 从配置获取小球标签 collider.group = this.colliderGroup; // 从配置获取碰撞组 collider.sensor = this.sensor; // 从配置获取传感器设置 collider.friction = this.friction; // 从配置获取摩擦系数 collider.restitution = this.restitution; // 从配置获取恢复系数 } else { // 确保已有的碰撞组件设置正确 collider.sensor = this.sensor; collider.restitution = this.restitution; collider.group = this.colliderGroup; // 从配置获取碰撞组 collider.tag = this.colliderTag; // 从配置获取标签 } // === 使用全局回调监听器 === const physics = PhysicsManager.getInstance()?.getSystem(); if (physics) { // 先移除旧监听，避免重复注册 physics.off(Contact2DType.BEGIN_CONTACT, this.onBeginContact, this); // 只注册实际需要的碰撞开始事件 physics.on(Contact2DType.BEGIN_CONTACT, this.onBeginContact, this); } } // 碰撞回调 - 处理小球与方块以及小球之间的碰撞 onBeginContact(selfCollider: Collider2D, otherCollider: Collider2D, contact: IPhysics2DContact | null) { // 检查是否为小球之间的碰撞 if (selfCollider.group === 1 && otherCollider.group === 1) { // 小球之间的碰撞 - 防止速度改变 this.handleBallToBallCollision(selfCollider, otherCollider, contact); return; } // 判断哪个是小球，哪个是碰撞对象 let ballNode: Node = null; let otherNode: Node = null; // 检查self是否为小球（组1） if (selfCollider.group === 1) { ballNode = selfCollider.node; otherNode = otherCollider.node; } // 检查other是否为小球（组1） else if (otherCollider.group === 1) { ballNode = otherCollider.node; otherNode = selfCollider.node; } // 如果没有找到小球，跳过处理 if (!ballNode || !otherNode) { return; } // 检查是否为方块碰撞 const nodeName = otherNode.name; const nodePath = this.getNodePath(otherNode); // 根据新的预制体结构，检查B1/Weapon路径 const b1Node = otherNode.getChildByName('B1'); const hasWeaponChild = b1Node ? b1Node.getChildByName('Weapon') !== null : otherNode.getChildByName('Weapon') !== null; const isBlock = nodeName.includes('Block') || nodePath.includes('Block') || hasWeaponChild; // 如果是方块碰撞，检查防围困机制 if (isBlock) { // 检查方块是否正在被拖拽，如果是则忽略碰撞 // 需要检查碰撞节点本身或其父节点是否在拖拽列表中 let isDragging = false; let currentNode = otherNode; // 向上遍历节点树，检查是否有父节点在拖拽列表中 while (currentNode && !isDragging) { if (this.draggingBlocks.has(currentNode)) { isDragging = true; console.log('[BallController] 发现拖拽方块，忽略碰撞:', currentNode.name, '碰撞节点:', otherNode.name, '路径:', nodePath); break; } currentNode = currentNode.parent; } if (isDragging) { console.log('[BallController] 当前拖拽方块数量:', this.draggingBlocks.size); if (contact) { contact.disabled = true; } return; } const ballId = ballNode.uuid; const currentTime = performance.now() / 1000; // 转换为秒 // 检查是否处于穿透状态 const phaseThroughEndTime = this.ballPhaseThrough.get(ballId); if (phaseThroughEndTime && currentTime < phaseThroughEndTime) { // 处于穿透状态，忽略碰撞但仍播放特效 const ballAni = BallAni.getInstance(); if (ballAni) { let contactPos: Vec3 = null; if (contact && (contact as any).getWorldManifold) { const wm = (contact as any).getWorldManifold(); if (wm && wm.points && wm.points.length > 0) { contactPos = new Vec3(wm.points[0].x, wm.points[0].y, 0); } } if (!contactPos) { contactPos = otherNode.worldPosition.clone(); } ballAni.playImpactEffect(contactPos); } // 禁用碰撞 if (contact) { contact.disabled = true; } return; } // 记录撞击历史 if (!this.ballHitHistory.has(ballId)) { this.ballHitHistory.set(ballId, []); } const hitHistory = this.ballHitHistory.get(ballId); hitHistory.push(currentTime); // 清理过期的撞击记录 const timeThreshold = currentTime - this.antiTrapTimeWindow; while (hitHistory.length > 0 && hitHistory[0] < timeThreshold) { hitHistory.shift(); } // 测试模式：显示详细的防围困信息 console.log(`[BallController] 测试模式 - 小球撞击统计: 撞击次数=${hitHistory.length}/${this.antiTrapHitThreshold}, 时间窗口=${this.antiTrapTimeWindow}秒, 方块=${otherNode.name}`); // 检查是否达到防围困条件 if (hitHistory.length >= this.antiTrapHitThreshold) { console.log(`[BallController] 测试模式 - 触发防围困机制! 撞击次数已达到阈值 ${this.antiTrapHitThreshold}`); // 获取当前偏移尝试次数 const deflectionAttempts = this.ballDeflectionAttempts.get(ballId) || 0; if (deflectionAttempts < this.deflectionAttemptThreshold) { // 优先使用偏移方式 this.ballDeflectionAttempts.set(ballId, deflectionAttempts + 1); console.log(`[BallController] 测试模式 - 应用防围困偏移 (第${deflectionAttempts + 1}/${this.deflectionAttemptThreshold}次尝试)`); // 应用增强偏移反弹 const rigidBody = ballNode.getComponent(RigidBody2D); if (rigidBody && contact) { // 获取碰撞法线 let normal = new Vec2(0, 1); if ((contact as any).getWorldManifold) { const wm = (contact as any).getWorldManifold(); if (wm && wm.normal) { normal = new Vec2(wm.normal.x, wm.normal.y); } } // 计算增强偏移反弹方向 const currentVelocity = rigidBody.linearVelocity; const currentDirection = new Vec2(currentVelocity.x, currentVelocity.y).normalize(); const oldDirection = `(${currentDirection.x.toFixed(2)}, ${currentDirection.y.toFixed(2)})`; const newDirection = this.calculateAntiTrapReflection(currentDirection, normal); const newDirectionStr = `(${newDirection.x.toFixed(2)}, ${newDirection.y.toFixed(2)})`; console.log(`[BallController] 测试模式 - 方向改变: ${oldDirection} -> ${newDirectionStr}`); // 应用新的速度方向 const speed = currentVelocity.length(); rigidBody.linearVelocity = new Vec2(newDirection.x * speed, newDirection.y * speed); } // 清空撞击历史，给偏移一个机会 hitHistory.length = 0; } else { // 偏移尝试次数已达上限，使用穿透 console.log(`[BallController] 测试模式 - 偏移尝试已达上限，启用穿透模式 (0.5秒)`); this.ballPhaseThrough.set(ballId, currentTime + 0.5); // 重置偏移尝试次数 this.ballDeflectionAttempts.set(ballId, 0); // 清空撞击历史 hitHistory.length = 0; // 禁用当前碰撞 if (contact) { contact.disabled = true; } return; } } } // 计算碰撞世界坐标 let contactPos: Vec3 = null; if (contact && (contact as any).getWorldManifold) { const wm = (contact as any).getWorldManifold(); if (wm && wm.points && wm.points.length > 0) { contactPos = new Vec3(wm.points[0].x, wm.points[0].y, 0); } } if (!contactPos) { contactPos = otherNode.worldPosition.clone(); } // 播放撞击特效 - 对所有碰撞都播放特效 const ballAni = BallAni.getInstance(); if (ballAni) { ballAni.playImpactEffect(contactPos); } if (isBlock) { // 播放方块撞击动画 if (ballAni) { ballAni.playBlockHitAnimation(otherNode); } // 通过事件检查是否可以发射子弹 const eventBus = EventBus.getInstance(); let canFire = true; // 发送检查事件，如果有监听器返回false则不发射 eventBus.emit(GameEvents.BALL_FIRE_BULLET, { canFire: (value: boolean) => { canFire = value; } }); if (canFire) { const now = performance.now(); const lastTime = this.blockFireCooldown.get(otherNode.uuid) || 0; if (now - lastTime > this.FIRE_COOLDOWN * 1000) { this.blockFireCooldown.set(otherNode.uuid, now); this.fireBulletAt(otherNode, contactPos); } } } } /** * 处理小球之间的碰撞 - 保持恒定速度 */ private handleBallToBallCollision(selfCollider: Collider2D, otherCollider: Collider2D, contact: IPhysics2DContact | null) { const ball1 = selfCollider.node; const ball2 = otherCollider.node; const rigidBody1 = ball1.getComponent(RigidBody2D); const rigidBody2 = ball2.getComponent(RigidBody2D); if (!rigidBody1 || !rigidBody2) { return; } // 计算碰撞位置并播放撞击特效 let contactPos: Vec3 = null; if (contact && (contact as any).getWorldManifold) { const wm = (contact as any).getWorldManifold(); if (wm && wm.points && wm.points.length > 0) { contactPos = new Vec3(wm.points[0].x, wm.points[0].y, 0); } } if (!contactPos) { // 使用两个小球位置的中点作为碰撞位置 const pos1 = ball1.worldPosition; const pos2 = ball2.worldPosition; contactPos = new Vec3( (pos1.x + pos2.x) / 2, (pos1.y + pos2.y) / 2, 0 ); } // 播放撞击特效 const ballAni = BallAni.getInstance(); if (ballAni) { ballAni.playImpactEffect(contactPos); } // 获取碰撞前的速度 const velocity1 = rigidBody1.linearVelocity.clone(); const velocity2 = rigidBody2.linearVelocity.clone(); // 计算速度大小 const speed1 = Math.sqrt(velocity1.x * velocity1.x + velocity1.y * velocity1.y); const speed2 = Math.sqrt(velocity2.x * velocity2.x + velocity2.y * velocity2.y); // 延迟一帧后恢复正确的速度，避免物理引擎的速度改变 this.scheduleOnce(() => { if (ball1.isValid && rigidBody1.isValid) { const currentVel1 = rigidBody1.linearVelocity; const currentSpeed1 = Math.sqrt(currentVel1.x * currentVel1.x + currentVel1.y * currentVel1.y); // 如果速度发生了显著变化，恢复到目标速度 if (Math.abs(currentSpeed1 - this.currentSpeed) > 5) { const normalizedVel1 = currentVel1.clone().normalize(); rigidBody1.linearVelocity = new Vec2( normalizedVel1.x * this.currentSpeed, normalizedVel1.y * this.currentSpeed ); } } if (ball2.isValid && rigidBody2.isValid) { const currentVel2 = rigidBody2.linearVelocity; const currentSpeed2 = Math.sqrt(currentVel2.x * currentVel2.x + currentVel2.y * currentVel2.y); // 如果速度发生了显著变化，恢复到目标速度 if (Math.abs(currentSpeed2 - this.currentSpeed) > 5) { const normalizedVel2 = currentVel2.clone().normalize(); rigidBody2.linearVelocity = new Vec2( normalizedVel2.x * this.currentSpeed, normalizedVel2.y * this.currentSpeed ); } } }, 0.016); // 约一帧的时间 } // 计算反射向量 calculateReflection(direction: Vec2, normal: Vec2): Vec2 { // 使用反射公式: R = V - 2(V·N)N const dot = direction.x * normal.x + direction.y * normal.y; const reflection = new Vec2( direction.x - 2 * dot * normal.x, direction.y - 2 * dot * normal.y ); reflection.normalize(); // 添加一些随机性，避免重复的反弹路径 const randomAngle = (Math.random() - 0.5) * this.maxReflectionRandomness; // 随机角度 const cos = Math.cos(randomAngle); const sin = Math.sin(randomAngle); // 应用随机旋转 const randomizedReflection = new Vec2( reflection.x * cos - reflection.y * sin, reflection.x * sin + reflection.y * cos ); // 更强的防水平/垂直往复运动机制 // 增大最小角度阈值，并添加更强的随机偏移 const minAngleFromAxis = 0.5; // 从0.3增加到0.5，约28.6度 const strongRandomOffset = 0.2; // 增加随机偏移范围 // 检查是否接近水平方向（y分量过小） if (Math.abs(randomizedReflection.y) < minAngleFromAxis) { // 调整y分量，使其远离水平方向，并添加更大的随机偏移 const sign = randomizedReflection.y >= 0 ? 1 : -1; randomizedReflection.y = sign * (minAngleFromAxis + Math.random() * strongRandomOffset); // 重新归一化 randomizedReflection.normalize(); } // 检查是否接近垂直方向（x分量过小） if (Math.abs(randomizedReflection.x) < minAngleFromAxis) { // 调整x分量，使其远离垂直方向，并添加更大的随机偏移 const sign = randomizedReflection.x >= 0 ? 1 : -1; randomizedReflection.x = sign * (minAngleFromAxis + Math.random() * strongRandomOffset); // 重新归一化 randomizedReflection.normalize(); } // 额外检查：如果仍然太接近轴向，强制添加对角分量 const finalCheck = 0.4; if (Math.abs(randomizedReflection.y) < finalCheck || Math.abs(randomizedReflection.x) < finalCheck) { // 强制添加对角分量，确保既有x又有y的显著分量 const angle = Math.PI / 4 + (Math.random() - 0.5) * Math.PI / 6; // 45度±15度 const signX = randomizedReflection.x >= 0 ? 1 : -1; const signY = randomizedReflection.y >= 0 ? 1 : -1; randomizedReflection.x = signX * Math.cos(angle); randomizedReflection.y = signY * Math.sin(angle); } randomizedReflection.normalize(); return randomizedReflection; } /** * 计算防围困增强偏移反弹方向 * @param direction 当前方向 * @param normal 碰撞法线 * @returns 增强偏移后的反弹方向 */ calculateAntiTrapReflection(direction: Vec2, normal: Vec2): Vec2 { // 使用反射公式: R = V - 2(V·N)N const dot = direction.x * normal.x + direction.y * normal.y; const reflection = new Vec2( direction.x - 2 * dot * normal.x, direction.y - 2 * dot * normal.y ); reflection.normalize(); // 应用更强的随机偏移来帮助脱困 const enhancedRandomness = this.maxReflectionRandomness * this.antiTrapDeflectionMultiplier; const randomAngle = (Math.random() - 0.5) * enhancedRandomness; const cos = Math.cos(randomAngle); const sin = Math.sin(randomAngle); // 应用随机旋转 const randomizedReflection = new Vec2( reflection.x * cos - reflection.y * sin, reflection.x * sin + reflection.y * cos ); // 更强的轴向偏移避免 const minAngleFromAxis = 0.3; // 约17度，比普通反弹更大的偏移 // 检查是否接近水平方向 if (Math.abs(randomizedReflection.y) < minAngleFromAxis) { const sign = randomizedReflection.y >= 0 ? 1 : -1; randomizedReflection.y = sign * (minAngleFromAxis + Math.random() * 0.2); randomizedReflection.normalize(); } // 检查是否接近垂直方向 if (Math.abs(randomizedReflection.x) < minAngleFromAxis) { const sign = randomizedReflection.x >= 0 ? 1 : -1; randomizedReflection.x = sign * (minAngleFromAxis + Math.random() * 0.2); randomizedReflection.normalize(); } randomizedReflection.normalize(); console.log(`Applied anti-trap enhanced deflection with angle: ${randomAngle}`); return randomizedReflection; } /** * 从方块武器发射子弹攻击敌人 - 重构版本 * 现在直接创建子弹实例并使用BulletController的实例方法 * @param blockNode 激活的方块节点 */ fireBullet(blockNode: Node) { // 检查子弹预制体是否存在 if (!this.bulletPrefab) { return; } // 查找方块中的Weapon节点 const weaponNode = this.findWeaponNode(blockNode); let firePosition: Vec3; if (!weaponNode) { firePosition = blockNode.worldPosition; } else { // 获取武器的世界坐标作为发射位置 try { firePosition = weaponNode.worldPosition; } catch (error) { // 备用方案：使用方块坐标 firePosition = blockNode.worldPosition; } } // 通过事件系统发射子弹，这样可以被暂停检查拦截 EventBus.getInstance().emit(GameEvents.BALL_FIRE_BULLET, blockNode, firePosition); } /** * 创建并发射子弹 - 使用新的WeaponBullet系统 * @param firePosition 发射位置（世界坐标） * @param weaponNode 武器节点（包含WeaponInfo组件） */ private createAndFireBullet(firePosition: Vec3, weaponNode: Node | null) { // 确保武器配置加载 WeaponBullet.loadWeaponsData().then(() => { let finalConfig: WeaponConfig | null = null; // 优先从武器节点的WeaponInfo组件获取配置 if (weaponNode && weaponNode.isValid) { const weaponInfo = weaponNode.getComponent(WeaponInfo); if (weaponInfo) { finalConfig = weaponInfo.getWeaponConfig(); console.log(`[BallController] 从武器节点获取武器配置: ${finalConfig?.name || '未知'}`); // 检查武器是否可以开火 if (!weaponInfo.canFire()) { console.log(`[BallController] 武器 ${finalConfig?.name || '未知'} 冷却中，无法开火`); return; } // 记录开火时间 weaponInfo.recordFireTime(); } } // 如果没有从武器节点获取到配置，使用默认配置 if (!finalConfig) { const defaultWeaponId = 'pea_shooter'; finalConfig = WeaponBullet.getWeaponConfig(defaultWeaponId); console.log(`[BallController] 使用默认武器配置: ${defaultWeaponId}`); } if (!finalConfig) { console.warn(`[BallController] 无法获取武器配置，取消发射`); return; } // 获取WeaponInfo组件（如果有的话） let weaponInfoComponent: WeaponInfo | null = null; if (weaponNode && weaponNode.isValid) { weaponInfoComponent = weaponNode.getComponent(WeaponInfo); } // 获取BlockInfo组件（如果有的话） // BlockInfo组件位于方块的Node子节点上，而不是Weapon子节点上 let blockInfoComponent: BlockInfo | null = null; if (weaponNode && weaponNode.isValid && weaponNode.parent) { // 从weaponNode的父节点（方块根节点）查找Node子节点 const blockRootNode = weaponNode.parent; const nodeChild = blockRootNode.getChildByName('Node'); if (nodeChild) { blockInfoComponent = nodeChild.getComponent(BlockInfo); if (blockInfoComponent) { console.log(`[BallController] 找到BlockInfo组件，稀有度等级: ${blockInfoComponent.rarity}, 稀有度名称: ${blockInfoComponent.getRarityName()}`); } else { console.log(`[BallController] Node子节点上未找到BlockInfo组件`); } } else { console.log(`[BallController] 未找到Node子节点`); } // 如果还是没找到，尝试直接从weaponNode上获取（兼容旧结构） if (!blockInfoComponent) { blockInfoComponent = weaponNode.getComponent(BlockInfo); if (blockInfoComponent) { console.log(`[BallController] 从weaponNode上找到BlockInfo组件，稀有度等级: ${blockInfoComponent.rarity}, 稀有度名称: ${blockInfoComponent.getRarityName()}`); } else { console.log(`[BallController] 未找到BlockInfo组件，将使用JSON配置中的稀有度`); } } } // 创建子弹初始化数据 const initData: BulletInitData = { weaponId: finalConfig.id, firePosition: firePosition, autoTarget: true, weaponConfig: finalConfig, weaponInfo: weaponInfoComponent, blockInfo: blockInfoComponent }; // 验证初始化数据 if (!WeaponBullet.validateInitData(initData)) { console.warn(`[BallController] 子弹初始化数据验证失败`); return; } // 查找GameArea（子弹统一添加到此节点） const gameArea = find('Canvas/GameLevelUI/GameArea'); if (!gameArea) { console.warn(`[BallController] 未找到GameArea节点，无法发射子弹`); return; } // === 根据武器配置选择合适的预制体 === const trailEffect = finalConfig.bulletConfig?.visual?.trailEffect; // 尖胡萝卜特殊处理：使用PelletContainer预制体但激活Spine节点 const isSharpCarrot = finalConfig.id === 'sharp_carrot'; // 当trailEffect为true或者是尖胡萝卜时都使用容器预制体 const needsContainerPrefab = Boolean(trailEffect) || isSharpCarrot; const prefabToUse: Prefab = (needsContainerPrefab && this.bulletContainerPrefab) ? this.bulletContainerPrefab : this.bulletPrefab; if (!prefabToUse) { console.warn(`[BallController] 没有可用的子弹预制体`); return; } // 使用批量创建逻辑 console.log(`[BallController] 开始创建子弹 - 武器: ${finalConfig.name}, 预制体: ${prefabToUse ? prefabToUse.name : 'null'}`); const bullets = WeaponBullet.createBullets(initData, prefabToUse as any); console.log(`[BallController] WeaponBullet.createBullets 返回了 ${bullets.length} 个子弹`); bullets.forEach((b, index) => { console.log(`[BallController] 添加第 ${index + 1} 个子弹到场景 - 子弹节点: ${b ? b.name : 'null'}, 是否有效: ${b ? b.isValid : 'false'}`); if (b && b.isValid) { gameArea.addChild(b); console.log(`[BallController] 子弹 ${index + 1} 成功添加到场景，世界坐标: ${b.worldPosition}`); } else { console.error(`[BallController] 子弹 ${index + 1} 无效，无法添加到场景`); } }); console.log(`[BallController] 成功发射 ${bullets.length} 发子弹，武器: ${finalConfig.name}`); }).catch(error => { console.error(`[BallController] 武器配置加载失败:`, error); }); } // 递归查找Weapon节点 private findWeaponNode(node: Node): Node | null { // 检查节点是否有效 if (!node || !node.isValid) { console.warn('[BallController] findWeaponNode: 传入的节点无效'); return null; } // 根据新的预制体结构，武器节点直接位于方块根节点下 // 首先检查当前节点是否有Weapon子节点 const weaponNode = node.getChildByName('Weapon'); if (weaponNode) { return weaponNode; } // 如果当前节点没有Weapon子节点，检查父节点（可能传入的是Node子节点而不是预制体根节点） if (node.parent) { const parentWeaponNode = node.parent.getChildByName('Weapon'); if (parentWeaponNode) { return parentWeaponNode; } } // 最后使用递归方式查找（兼容其他可能的结构） for (let i = 0; i < node.children.length; i++) { const child = node.children[i]; const foundWeapon = this.findWeaponNode(child); if (foundWeapon) { return foundWeapon; } } // 如果都没找到，返回null console.warn('[BallController] 方块', node.name, '中未找到武器节点'); return null; } // 获取节点的完整路径 private getNodePath(node: Node): string { let path = node.name; let current = node; while (current.parent) { current = current.parent; path = current.name + '/' + path; } return path; } private debugDragCounter = 0; update(dt: number) { // 只有当小球已启动时才执行运动逻辑 if (!this.ballStarted || !this.initialized) { return; } // 维持所有小球的恒定速度 this.maintainAllBallsSpeed(); // 更新小球运动历史数据（用于检测振荡模式） this.updateBallMovementHistory(); // 清理过期的防围困状态 this.cleanupExpiredAntiTrapStates(); // 定期检查小球位置，防止小球被挤出游戏区域 this.lastPositionCheckTime += dt; if (this.lastPositionCheckTime >= this.positionCheckInterval) { this.checkAndRescueAllBalls(); this.lastPositionCheckTime = 0; } // 定期检查小球是否接近方块但没有触发碰撞（调试用） if (this.activeBall && this.activeBall.isValid) { this.debugCheckNearBlocks(); } // 定期调试拖拽状态（每5秒一次） this.debugDragCounter += dt; if (this.debugDragCounter >= 5.0 && this.draggingBlocks.size > 0) { console.log('[BallController] 定期调试 - 当前拖拽状态:'); this.debugDraggingBlocks(); this.debugDragCounter = 0; } } /** * 更新小球运动历史数据（用于检测振荡模式） */ private updateBallMovementHistory() { if (!this.activeBall || !this.activeBall.isValid) { return; } const ballId = this.activeBall.uuid; const currentTime = Date.now() / 1000; // 转换为秒 const currentPos = this.activeBall.getWorldPosition(); const rigidBody = this.activeBall.getComponent(RigidBody2D); if (!rigidBody) { return; } const currentVelocity = rigidBody.linearVelocity; const currentDirection = new Vec2(currentVelocity.x, currentVelocity.y).normalize(); // 初始化历史记录 if (!this.ballPositionHistory.has(ballId)) { this.ballPositionHistory.set(ballId, []); this.ballDirectionHistory.set(ballId, []); this.ballOscillationDetection.set(ballId, { lastDirectionChange: currentTime, directionChangeCount: 0, oscillationAxis: 'none', oscillationStartTime: 0 }); } const posHistory = this.ballPositionHistory.get(ballId); const dirHistory = this.ballDirectionHistory.get(ballId); const oscillationData = this.ballOscillationDetection.get(ballId); // 更新位置历史 posHistory.push(new Vec2(currentPos.x, currentPos.y)); if (posHistory.length > this.positionHistorySize) { posHistory.shift(); } // 更新方向历史 dirHistory.push(currentDirection.clone()); if (dirHistory.length > this.positionHistorySize) { dirHistory.shift(); } // 检测方向改变 if (dirHistory.length >= 2) { const prevDirection = dirHistory[dirHistory.length - 2]; const dotProduct = Vec2.dot(prevDirection, currentDirection); // 如果方向改变超过90度（点积小于0），认为是显著的方向改变 if (dotProduct < 0) { oscillationData.directionChangeCount++; oscillationData.lastDirectionChange = currentTime; if (this.testMode) { console.log(`[防围困] 小球 ${ballId.substring(0, 8)} 方向改变，累计次数: ${oscillationData.directionChangeCount}`); } } } // 检测振荡模式 this.detectOscillationPattern(ballId, currentTime); } /** * 检测振荡模式 */ private detectOscillationPattern(ballId: string, currentTime: number) { const oscillationData = this.ballOscillationDetection.get(ballId); const posHistory = this.ballPositionHistory.get(ballId); if (!oscillationData || !posHistory || posHistory.length < 10) { return; } // 检查是否在时间窗口内有足够的方向改变 const timeSinceLastChange = currentTime - oscillationData.lastDirectionChange; if (timeSinceLastChange > this.oscillationTimeWindow) { // 重置计数器 oscillationData.directionChangeCount = 0; oscillationData.oscillationAxis = 'none'; return; } // 如果方向改变次数超过阈值，分析振荡轴向 if (oscillationData.directionChangeCount >= this.directionChangeThreshold) { const axis = this.analyzeOscillationAxis(posHistory); if (axis !== 'none' && oscillationData.oscillationAxis === 'none') { // 开始振荡检测 oscillationData.oscillationAxis = axis; oscillationData.oscillationStartTime = currentTime; if (this.testMode) { console.log(`[防围困] 检测到小球 ${ballId.substring(0, 8)} 在${axis === 'horizontal' ? '水平' : '垂直'}方向振荡`); } // 触发增强防围困机制 this.triggerEnhancedAntiTrap(ballId, axis); } } } /** * 分析振荡轴向 */ private analyzeOscillationAxis(posHistory: Vec2[]): 'horizontal' | 'vertical' | 'none' { if (posHistory.length < 10) { return 'none'; } const recentPositions = posHistory.slice(-10); let minX = recentPositions[0].x, maxX = recentPositions[0].x; let minY = recentPositions[0].y, maxY = recentPositions[0].y; for (const pos of recentPositions) { minX = Math.min(minX, pos.x); maxX = Math.max(maxX, pos.x); minY = Math.min(minY, pos.y); maxY = Math.max(maxY, pos.y); } const xRange = maxX - minX; const yRange = maxY - minY; // 判断主要运动方向 if (xRange > this.oscillationDistanceThreshold && yRange < this.oscillationDistanceThreshold / 2) { return 'horizontal'; } else if (yRange > this.oscillationDistanceThreshold && xRange < this.oscillationDistanceThreshold / 2) { return 'vertical'; } return 'none'; } /** * 触发增强防围困机制 */ private triggerEnhancedAntiTrap(ballId: string, oscillationAxis: 'horizontal' | 'vertical') { const ball = this.activeBall; if (!ball || !ball.isValid || ball.uuid !== ballId) { return; } const rigidBody = ball.getComponent(RigidBody2D); if (!rigidBody) { return; } if (this.testMode) { console.log(`[防围困] 触发增强防围困机制 - 小球 ${ballId.substring(0, 8)}，轴向: ${oscillationAxis}`); } // 根据振荡轴向应用不同的策略 if (oscillationAxis === 'horizontal') { // 水平振荡：给予垂直方向的随机冲量 const verticalImpulse = (Math.random() - 0.5) * this.baseSpeed * 0.8; const newVelocity = new Vec2(rigidBody.linearVelocity.x * 0.3, verticalImpulse); rigidBody.linearVelocity = newVelocity; if (this.testMode) { console.log(`[防围困] 水平振荡处理 - 应用垂直冲量: ${verticalImpulse.toFixed(2)}`); } } else if (oscillationAxis === 'vertical') { // 垂直振荡：给予水平方向的随机冲量 const horizontalImpulse = (Math.random() - 0.5) * this.baseSpeed * 0.8; const newVelocity = new Vec2(horizontalImpulse, rigidBody.linearVelocity.y * 0.3); rigidBody.linearVelocity = newVelocity; if (this.testMode) { console.log(`[防围困] 垂直振荡处理 - 应用水平冲量: ${horizontalImpulse.toFixed(2)}`); } } // 重置振荡检测数据 const oscillationData = this.ballOscillationDetection.get(ballId); if (oscillationData) { oscillationData.directionChangeCount = 0; oscillationData.oscillationAxis = 'none'; } } /** * 维持所有小球的恒定速度 */ private maintainAllBallsSpeed() { // 维持主小球速度 if (this.activeBall && this.activeBall.isValid) { this.maintainBallSpeed(this.activeBall); } // 维持额外小球的速度 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (gameArea) { const additionalBalls = gameArea.children.filter(child => child.name === 'AdditionalBall' && child.isValid ); for (const ball of additionalBalls) { this.maintainBallSpeed(ball); } } } /** * 维持单个小球的恒定速度 */ private maintainBallSpeed(ball: Node) { const rigidBody = ball.getComponent(RigidBody2D); if (!rigidBody) return; // 获取当前速度 const currentVelocity = rigidBody.linearVelocity; const speed = Math.sqrt(currentVelocity.x * currentVelocity.x + currentVelocity.y * currentVelocity.y); // 如果速度过低或过高，重新设置速度以维持恒定运动 if (speed < this.currentSpeed * 0.85 || speed > this.currentSpeed * 1.15) { // 保持当前方向，但调整速度大小 if (speed > 0.1) { const normalizedVelocity = currentVelocity.clone().normalize(); rigidBody.linearVelocity = new Vec2( normalizedVelocity.x * this.currentSpeed, normalizedVelocity.y * this.currentSpeed ); } else { // 如果速度几乎为0，给一个随机方向 const angle = Math.random() * Math.PI * 2; rigidBody.linearVelocity = new Vec2( Math.cos(angle) * this.currentSpeed, Math.sin(angle) * this.currentSpeed ); } } // 更新主小球的方向向量（用于其他逻辑） if (ball === this.activeBall && speed > 1.0) { this.direction.x = currentVelocity.x / speed; this.direction.y = currentVelocity.y / speed; } } // 调试方法：检查小球是否接近方块但没有触发物理碰撞 private debugCheckCounter = 0; private debugCheckNearBlocks() { this.debugCheckCounter++; // 每60帧（约1秒）检查一次 if (this.debugCheckCounter % 60 !== 0) return; const ballPos = this.activeBall.worldPosition; if (!this.placedBlocksContainer || !this.placedBlocksContainer.isValid) return; let nearestDistance = Infinity; let nearestBlock = null; for (let i = 0; i < this.placedBlocksContainer.children.length; i++) { const block = this.placedBlocksContainer.children[i]; if (block.name.includes('Block') || block.getChildByName('B1')) { const blockPos = block.worldPosition; const distance = Math.sqrt( Math.pow(ballPos.x - blockPos.x, 2) + Math.pow(ballPos.y - blockPos.y, 2) ); if (distance < nearestDistance) { nearestDistance = distance; nearestBlock = block; } } } if (nearestBlock && nearestDistance < 100) { // 检查小球的碰撞体状态 const ballCollider = this.activeBall.getComponent(Collider2D); if (ballCollider) { if (ballCollider instanceof CircleCollider2D) { // 小球碰撞半径检查 } } // 检查小球的刚体状态 const ballRigidBody = this.activeBall.getComponent(RigidBody2D); if (ballRigidBody) { // 刚体状态检查 } // 检查最近的方块碰撞体 const blockCollider = nearestBlock.getComponent(Collider2D); if (blockCollider) { // 方块碰撞体检查 } } } // 初始化方向 initializeDirection() { // 测试模式：使用完全垂直或水平方向来测试防围困机制 if (this.testMode) { // 四个基本方向：上、下、左、右 const directions = [ { x: 0, y: 1 }, // 向上 { x: 0, y: -1 }, // 向下 { x: 1, y: 0 }, // 向右 { x: -1, y: 0 } // 向左 ]; // 随机选择一个基本方向 const randomIndex = Math.floor(Math.random() * directions.length); const selectedDirection = directions[randomIndex]; this.direction.x = selectedDirection.x; this.direction.y = selectedDirection.y; this.direction.normalize(); console.log(`[BallController] 测试模式 - 小球初始方向: ${randomIndex === 0 ? '向上' : randomIndex === 1 ? '向下' : randomIndex === 2 ? '向右' : '向左'}`); } else { // 原始随机方向模式 const angle = Math.random() * Math.PI * 2; // 0-2π之间的随机角度 this.direction.x = Math.cos(angle); this.direction.y = Math.sin(angle); this.direction.normalize(); } // 设置初始速度 if (this.activeBall) { const rigidBody = this.activeBall.getComponent(RigidBody2D); if (rigidBody) { rigidBody.linearVelocity = new Vec2( this.direction.x * this.currentSpeed, this.direction.y * this.currentSpeed ); } } } // 初始化球的参数 - 公开方法，供GameManager调用 public initialize() { this.calculateGameBounds(); this.createBall(); // 检查方块碰撞体（延迟执行，确保方块已放置） this.scheduleOnce(() => { this.checkBlockColliders(); }, 0.5); } // 启动小球 - 公开方法，在确定按钮点击后调用 public startBall() { // 检查ballPrefab是否设置 if (!this.ballPrefab) { console.error('[BallController] ballPrefab 未设置，无法创建小球'); return; } // 如果还没有初始化，先初始化 if (!this.initialized) { this.initialize(); } // 确保小球存在且有效 if (!this.activeBall || !this.activeBall.isValid) { this.createBall(); } // 检查小球是否成功创建 if (!this.activeBall) { console.error('[BallController] 小球创建失败'); return; } // 重新定位小球，避免与方块重叠 this.positionBallRandomly(); // 确保物理组件设置正确 this.setupCollider(); // 初始化运动方向并开始运动 this.initializeDirection(); // 设置运动状态 this.ballStarted = true; console.log('[BallController] 小球启动完成'); } /** * 暂停小球运动：记录当前速度并停止刚体 */ public pauseBall() { if (this.isPaused) return; this.isPaused = true; this.ballStarted = false; if (this.activeBall && this.activeBall.isValid) { const rb = this.activeBall.getComponent(RigidBody2D); if (rb) { this.pausedVelocity = rb.linearVelocity.clone(); rb.linearVelocity = new Vec2(0, 0); rb.sleep(); } } } /** * 恢复小球运动：恢复暂停前的速度 */ public resumeBall() { if (!this.isPaused) return; this.isPaused = false; this.ballStarted = true; console.log('恢复小球运动'); if (this.activeBall && this.activeBall.isValid) { const rb = this.activeBall.getComponent(RigidBody2D); if (rb) { rb.wakeUp(); const hasPrevVelocity = this.pausedVelocity && (this.pausedVelocity.x !== 0 || this.pausedVelocity.y !== 0); if (hasPrevVelocity) { rb.linearVelocity = this.pausedVelocity.clone(); } else { // 若没有记录速度，则重新初始化方向 this.initializeDirection(); } } } } /** * 从给定世界坐标发射子弹 */ private fireBulletAt(blockNode: Node, fireWorldPos: Vec3) { // 检查方块节点是否有效 if (!blockNode || !blockNode.isValid) { return; } // 检查子弹预制体是否存在 if (!this.bulletPrefab) { console.warn(`[BallController] 子弹预制体未设置，无法发射`); return; } // 查找方块中的武器节点 const weaponNode = this.findWeaponNode(blockNode); if (!weaponNode) { const blockName = blockNode && blockNode.isValid ? blockNode.name : 'unknown'; console.warn(`[BallController] 方块 ${blockName} 中未找到武器节点`); } // 传递武器节点给createAndFireBullet方法 this.createAndFireBullet(fireWorldPos, weaponNode); } /** * 重置球控制器状态 - 游戏重置时调用 */ public resetBallController() { console.log('[BallController] 重置球控制器状态'); // 停止球的运动 this.ballStarted = false; this.isPaused = false; // 清理暂停状态 this.pausedVelocity = new Vec2(); // 销毁当前活动的球 if (this.activeBall && this.activeBall.isValid) { console.log('[BallController] 销毁当前活动的球'); this.activeBall.destroy(); } this.activeBall = null; // 销毁所有额外创建的球 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (gameArea) { const additionalBalls = gameArea.children.filter(child => child.name === 'AdditionalBall' && child.isValid ); for (const ball of additionalBalls) { console.log('[BallController] 销毁额外球:', ball.name); ball.destroy(); } if (additionalBalls.length > 0) { console.log(`[BallController] 已清理 ${additionalBalls.length} 个额外球`); } } // 重置初始化状态 this.initialized = false; // 清理冷却时间 this.blockFireCooldown.clear(); // 清理防围困状态数据 this.ballHitHistory.clear(); this.ballPhaseThrough.clear(); this.ballDeflectionAttempts.clear(); // 清理增强防围困机制的历史数据 this.ballPositionHistory.clear(); this.ballDirectionHistory.clear(); this.ballOscillationDetection.clear(); // 清理拖拽方块集合 this.draggingBlocks.clear(); // 重置球速 this.updateBallSpeed(); console.log('[BallController] 球控制器重置完成'); } /** * 清理过期的防围困状态 */ private cleanupExpiredAntiTrapStates() { const currentTime = performance.now() / 1000; // 清理过期的穿透状态 for (const [ballId, endTime] of this.ballPhaseThrough.entries()) { if (currentTime >= endTime) { this.ballPhaseThrough.delete(ballId); } } // 检查并重置长时间未频繁撞击的球的偏移尝试次数 for (const [ballId, hitHistory] of this.ballHitHistory.entries()) { // 如果撞击历史为空或最近一次撞击超过时间窗口的一半，重置偏移尝试次数 if (hitHistory.length === 0 || (hitHistory.length > 0 && currentTime - hitHistory[hitHistory.length - 1] > this.antiTrapTimeWindow / 2)) { if (this.ballDeflectionAttempts.has(ballId)) { this.ballDeflectionAttempts.set(ballId, 0); } } } } /** * 清理单个小球的防围困状态数据 * @param ballId 小球的唯一标识符 */ public cleanupBallAntiTrapState(ballId: string) { this.ballHitHistory.delete(ballId); this.ballPhaseThrough.delete(ballId); this.ballDeflectionAttempts.delete(ballId); console.log(`Cleaned up anti-trap state for ball ${ballId}`); } onDestroy() { // 清理事件监听 const eventBus = EventBus.getInstance(); eventBus.off(GameEvents.GAME_PAUSE, this.onGamePauseEvent, this); eventBus.off(GameEvents.GAME_RESUME, this.onGameResumeEvent, this); eventBus.off(GameEvents.RESET_BALL_CONTROLLER, this.onResetBallControllerEvent, this); eventBus.off(GameEvents.BALL_CREATE, this.onBallCreateEvent, this); eventBus.off(GameEvents.BALL_START, this.onBallStartEvent, this); eventBus.off(GameEvents.BALL_CREATE_ADDITIONAL, this.onBallCreateAdditionalEvent, this); eventBus.off(GameEvents.BALL_FIRE_BULLET, this.onBallFireBulletEvent, this); eventBus.off(GameEvents.BLOCK_DRAG_START, this.onBlockDragStartEvent, this); eventBus.off(GameEvents.BLOCK_DRAG_END, this.onBlockDragEndEvent, this); // 清理物理事件监听器 const physics = PhysicsManager.getInstance()?.getSystem(); if (physics) { physics.off(Contact2DType.BEGIN_CONTACT, this.onBeginContact, this); } // 清理防围困状态数据 this.ballHitHistory.clear(); this.ballPhaseThrough.clear(); this.ballDeflectionAttempts.clear(); } private updateBallSpeed() { const skillManager = PersistentSkillManager.getInstance(); if (skillManager) { this.currentSpeed = skillManager.applyBallSpeedBonus(this.baseSpeed); } else { this.currentSpeed = this.baseSpeed; } } // ==================== 小球位置检查机制 ==================== /** * 获取所有活跃的小球 * @returns 返回所有活跃小球的数组 */ private getAllActiveBalls(): Node[] { const balls: Node[] = []; // 添加主小球 if (this.activeBall && this.activeBall.isValid) { balls.push(this.activeBall); } // 查找所有额外小球 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (gameArea) { // 遍历GameArea的所有子节点，查找小球 gameArea.children.forEach(child => { if (child.name === 'AdditionalBall' && child.isValid) { balls.push(child); } }); } return balls; } /** * 检查单个小球是否在游戏区域内 * @param ball 要检查的小球节点 * @returns 如果小球在游戏区域内返回true，否则返回false */ private checkBallPosition(ball: Node): boolean { if (!ball || !ball.isValid) { return false; } // 获取小球的世界坐标 const worldPos = ball.getWorldPosition(); // 计算扩展后的边界（比游戏区域稍大，避免误判） const extension = this.positionCheckBoundaryExtension; const extendedBounds = { left: this.gameBounds.left - extension, right: this.gameBounds.right + extension, top: this.gameBounds.top + extension, bottom: this.gameBounds.bottom - extension }; // 检查小球是否在扩展边界内 const isInBounds = worldPos.x >= extendedBounds.left && worldPos.x <= extendedBounds.right && worldPos.y >= extendedBounds.bottom && worldPos.y <= extendedBounds.top; if (!isInBounds) { console.warn(`[BallController] 小球 ${ball.name} 超出游戏区域:`, { position: { x: worldPos.x, y: worldPos.y }, bounds: extendedBounds }); } return isInBounds; } /** * 将小球重置回游戏区域 * @param ball 要重置的小球节点 */ private rescueBallToGameArea(ball: Node): void { if (!ball || !ball.isValid) { return; } console.log(`[BallController] 正在找回小球 ${ball.name}`); // 使用与小球生成相同的安全位置设置逻辑 this.positionBallSafely(ball); // 重新设置小球的运动方向和速度 const rigidBody = ball.getComponent(RigidBody2D); if (rigidBody) { // 随机新的运动方向 const angle = Math.random() * Math.PI * 2; const direction = new Vec2(Math.cos(angle), Math.sin(angle)).normalize(); // 设置新的速度 rigidBody.linearVelocity = new Vec2( direction.x * this.currentSpeed, direction.y * this.currentSpeed ); } console.log(`[BallController] 小球 ${ball.name} 已重置到安全位置`); } /** * 为小球设置安全位置（复用生成位置逻辑） * @param ball 要设置位置的小球节点 */ private positionBallSafely(ball: Node): void { if (!ball) return; const transform = ball.getComponent(UITransform); const ballRadius = transform ? transform.width / 2 : this.ballRadius; // 计算可生成的范围（考虑小球半径，避免生成在边缘） const minX = this.gameBounds.left + ballRadius + this.edgeOffset; const maxX = this.gameBounds.right - ballRadius - this.edgeOffset; const minY = this.gameBounds.bottom + ballRadius + this.edgeOffset; const maxY = this.gameBounds.top - ballRadius - this.edgeOffset; // 获取GameArea节点 const gameArea = find('Canvas/GameLevelUI/GameArea'); if (!gameArea) { return; } // 查找PlacedBlocks节点，它包含所有放置的方块 if (!this.placedBlocksContainer) { this.setRandomPositionDefault(ball, minX, maxX, minY, maxY); return; } if (!this.placedBlocksContainer.isValid) { this.setRandomPositionDefault(ball, minX, maxX, minY, maxY); return; } // 获取所有已放置的方块 const placedBlocks = []; for (let i = 0; i < this.placedBlocksContainer.children.length; i++) { const block = this.placedBlocksContainer.children[i]; // 检查是否是方块节点（通常以Block命名或有特定标识） if (block.name.includes('Block') || block.getChildByName('B1')) { placedBlocks.push(block); } } // 如果没有方块，使用默认随机位置 if (placedBlocks.length === 0) { this.setRandomPositionDefault(ball, minX, maxX, minY, maxY); return; } // 尝试找到一个不与任何方块重叠的位置 let validPosition = false; let attempts = 0; const maxAttempts = this.maxAttempts; let randomX, randomY; while (!validPosition && attempts < maxAttempts) { // 随机生成位置 randomX = Math.random() * (maxX - minX) + minX; randomY = Math.random() * (maxY - minY) + minY; // 检查是否与任何方块重叠 let overlapping = false; for (const block of placedBlocks) { // 获取方块的世界坐标 const blockWorldPos = block.worldPosition; // 计算小球与方块的距离 const distance = Math.sqrt( Math.pow(randomX - blockWorldPos.x, 2) + Math.pow(randomY - blockWorldPos.y, 2) ); // 获取方块的尺寸 const blockTransform = block.getComponent(UITransform); const blockSize = blockTransform ? Math.max(blockTransform.width, blockTransform.height) / 2 : this.safeDistance; // 如果距离小于小球半径+方块尺寸的一半+安全距离，认为重叠 if (distance < ballRadius + blockSize + this.safeDistance) { overlapping = true; break; } } // 如果没有重叠，找到了有效位置 if (!overlapping) { validPosition = true; } attempts++; } // 如果找不到有效位置，使用默认位置（游戏区域底部中心） if (!validPosition) { randomX = (this.gameBounds.left + this.gameBounds.right) / 2; randomY = this.gameBounds.bottom + ballRadius + this.safeDistance; } // 将世界坐标转换为相对于GameArea的本地坐标 const localPos = gameArea.getComponent(UITransform).convertToNodeSpaceAR(new Vec3(randomX, randomY, 0)); ball.position = localPos; } /** * 设置小球默认位置 * @param ball 小球节点 * @param minX 最小X坐标 * @param maxX 最大X坐标 * @param minY 最小Y坐标 * @param maxY 最大Y坐标 */ private setRandomPositionDefault(ball: Node, minX: number, maxX: number, minY: number, maxY: number): void { const gameArea = find('Canvas/GameLevelUI/GameArea'); if (!gameArea) return; // 随机生成位置 const randomX = Math.random() * (maxX - minX) + minX; const randomY = Math.random() * (maxY - minY) + minY; // 将世界坐标转换为相对于GameArea的本地坐标 const localPos = gameArea.getComponent(UITransform).convertToNodeSpaceAR(new Vec3(randomX, randomY, 0)); ball.position = localPos; } /** * 检查并找回所有超出游戏区域的小球 */ private checkAndRescueAllBalls(): void { if (!this.enableBallPositionCheck) { return; } const balls = this.getAllActiveBalls(); let rescuedCount = 0; balls.forEach(ball => { if (!this.checkBallPosition(ball)) { this.rescueBallToGameArea(ball); rescuedCount++; } }); if (rescuedCount > 0) { console.log(`[BallController] 本次检查找回了 ${rescuedCount} 个小球`); } } }