// 1. 检查敌人生成逻辑
enemyGenerate() {
  if (frame % 30 === 0) {
    const enemyLimit = levelEnemyLimits[level - 1];
    const currentCount = databus.enemys.length;

    // 问题：这里检查发现数量已达上限
    if (currentCount >= enemyLimit) {
      return; // 不再生成新敌机
    }

    // 生成敌机...
  }
}

// 2. 检查无敌技能逻辑
collisionDetection() {
  if (player.invincibleActive) {
    enemy.forceDestroy();  // 调用强制销毁
  }
}

// 3. 检查 forceDestroy 方法
forceDestroy() {
  playAnimation();  // 播放爆炸动画
  // ❌ 问题：没有立即移除敌机！
}

// 4. 检查 removeEnemy 方法
removeEnemy(enemy) {
  const index = enemys.indexOf(enemy);
  if (index !== -1) {
    enemys.splice(index, 1);  // 从数组移除
    pool.recover('enemy', enemy);  // 回收到对象池
  }
}

无敌状态撞飞机
    ↓
调用 enemy.forceDestroy()
    ↓
播放爆炸动画 ✅
    ↓
❌ 没有立即从数组移除
    ↓
敌机仍然在 GameGlobal.databus.enemys 数组中
    ↓
敌人生成逻辑检查：enemys.length >= enemyLimit
    ↓
❌ 认为敌人数量已达上限
    ↓
不再生成新敌人 ❌

// ❌ 方案 1：立即移除
forceDestroy() {
  playAnimation();

  // 立即标记并移除
  this.isActive = false;
  this.visible = false;
  GameGlobal.databus.removeEnemy(this);  // ❌ 立即移除
}

// 问题：动画来不及播放就被移除了

// ✅ 方案 2：延迟移除
forceDestroy() {
  // 播放爆炸动画
  this.playAnimation();
  GameGlobal.musicManager.playExplosion();

  // 标记为非激活（停止移动和攻击）
  this.isActive = false;
  // ❌ 不立即移除，让动画播放完毕
}

// 在 update() 方法中处理移除
update() {
  if (GameGlobal.databus.isGameOver) {
    return;
  }

  // 如果处于爆炸动画播放中，不更新位置
  if (this.isPlaying) {
    return; // 保持位置不变，等待动画结束
  }

  // 非激活状态（已爆炸但动画已结束），直接移除
  if (!this.isActive) {
    this.remove();
    return;
  }

  // 正常更新移动和攻击
  this.updateMove();
  this.updateBullets();
  // ...
}

无敌状态撞飞机
    ↓
调用 enemy.forceDestroy()
    ↓
播放爆炸动画 ✅
    ↓
标记 isActive = false ✅
    ↓
update() 检测到 isPlaying = true
    ↓
保持位置不变，等待动画播放 ✅
    ↓
动画播放完毕（19 帧）
    ↓
stopAnimation() 设置 isPlaying = false
    ↓
update() 检测到 !isActive
    ↓
调用 remove() 从数组移除 ✅
    ↓
敌人数组长度减少 ✅
    ↓
新敌人生成正常 ✅

// destroy() 方法
destroy() {
  this.hp--;
  if (this.hp <= 0) {
    const isVictory = GameGlobal.databus.addLevel10Kill();

    if (Math.random() < 0.3) {
      this.dropCoin();
    }

    // 播放爆炸动画
    this.playAnimation();
    GameGlobal.musicManager.playExplosion();

    // ✅ 标记为非激活（停止移动和攻击）
    this.isActive = false;

    // 第 10 关胜利时立即移除
    if (isVictory) {
      this.remove();
    }
    // 其他情况：等待动画播放完毕后由 update() 移除
  }
}

// Animation.playAnimation()
playAnimation(index = 0, loop = false) {
  this.visible = false;  // ❌ 隐藏精灵图
  this.isPlaying = true;
  this.index = index;

  if (this.interval > 0 && this.count) {
    this[__.timer] = setInterval(this.frameLoop.bind(this), this.interval);
  }
}

// Sprite.render()
render(ctx) {
  if (!this.visible) return;  // ❌ visible = false 时不绘制

  if (this.img && this.img.width > 0) {
    ctx.drawImage(this.img, this.x, this.y, this.width, this.height);
  }
}

// Animation.aniRender() - 动画帧渲染
aniRender(ctx) {
  if (this.index >= 0 && this.index < this.count) {
    ctx.drawImage(
      this.imgList[this.index],  // 绘制当前帧
      this.x, this.y,
      this.width * 1.2, this.height * 1.2
    );
  }
}

render() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);

  this.bg.render(ctx);
  this.player.render(ctx);

  // 绘制敌机（visible = false 时不绘制）
  GameGlobal.databus.enemys.forEach(item => item.render(ctx));

  // ✅ 绘制动画（不依赖 visible，只依赖 isPlaying）
  GameGlobal.databus.animations.forEach(ani => {
    if (ani.isPlaying) {
      ani.aniRender(ctx);  // 爆炸动画在这里绘制
    }
  });
}

// forceDestroy() - 播放动画但不立即移除
forceDestroy() {
  this.playAnimation();
  GameGlobal.musicManager.playExplosion();
  this.isActive = false;  // 标记为非激活
  // 不立即移除，让动画播放完毕
}

// update() - 动画播放完毕后移除
update() {
  if (this.isPlaying) {
    return; // 动画播放中，保持位置
  }

  if (!this.isActive) {
    this.remove();  // 动画结束且非激活，移除
    return;
  }

  // 正常更新...
}

敌机被摧毁
    ↓
调用 destroy() 或 forceDestroy()
    ↓
播放爆炸动画（19 帧）✅
    ↓
设置 visible = false（隐藏精灵图）
    ↓
设置 isActive = false（停止更新）
    ↓
主渲染循环：
  - enemy.render() 不绘制（visible = false）
  - ani.aniRender() 绘制爆炸帧（isPlaying = true）✅
    ↓
动画播放 19 帧
    ↓
frameLoop() 检测到 index >= count
    ↓
stopAnimation()
  - isPlaying = false
  - index = -1
  - 从 animations 数组移除
    ↓
update() 检测到 !isActive && !isPlaying
    ↓
调用 remove()
  - 从 enemys 数组移除
  - 回收到对象池

// 调整前
L10_T1: { hp: 10, speed: 2, ... },
L10_T2: { hp: 15, speed: 2.5, ... },
L10_T3: { hp: 20, speed: 1.5, ... },
L10_T4: { hp: 25, speed: 1, ... },
L10_T5: { hp: 30, speed: 0.8, ... },

// 调整后（增加血量）
L10_T1: { hp: 15, speed: 2, ... },
L10_T2: { hp: 20, speed: 2.5, ... },
L10_T3: { hp: 25, speed: 1.5, ... },
L10_T4: { hp: 30, speed: 1, ... },
L10_T5: { hp: 40, speed: 0.8, ... },

// destroy() 方法中
if (Math.random() < 0.3) {  // 30% 概率
  this.dropCoin();
}

// 调整为动态概率
const dropRate = Math.min(0.5, 0.2 + GameGlobal.databus.level * 0.03);
if (Math.random() < dropRate) {
  this.dropCoin();
}

// 第 1 关：23%
// 第 5 关：35%
// 第 10 关：50%

useInvincible() {
  if (GameGlobal.databus.invincibleUses > 0) {
    this.invincibleActive = true;
    this.invincibleTimer = 600;  // 10 秒
    return true;
  }
  return false;
}

useInvincible() {
  if (GameGlobal.databus.invincibleUses > 0 && !this.invincibleActive) {
    GameGlobal.databus.invincibleUses--;
    this.invincibleActive = true;
    this.invincibleTimer = 600;  // 10 秒
    return true;
  }
  return false;
}

// 添加无敌状态检查
update() {
  if (this.invincibleActive && this.invincibleTimer > 0) {
    this.invincibleTimer--;
    if (this.invincibleTimer <= 0) {
      this.invincibleActive = false;
    }
  }
}

// 每关粒子数量过多
L1: 30 个风环
L2: 80 个岩石
L3: 50 个闪电
L4: 60 个草叶
L5: 80 个水泡
L6: 100 个火焰
L7: 70 个雪花
L8: 60 个雾气
L9: 50 个代码
L10: 100 个光环

总计：~630 个粒子

// 根据关卡特色调整数量
L1: 10 个风线 ✅
L2: 40 个岩石 ✅
L3: 0 个闪电（动态生成）✅
L4: 30 个草丛 ✅
L5: 30 个水泡 ✅
L6: 80 个火焰 ✅
L7: 60 个雪花 ✅
L8: 40 个雾气 ✅
L9: 50 个代码 ✅
L10: 60 个光环 ✅

总计：~400 个粒子（减少 36%）

// 每个粒子都使用 save/restore
renderParticles(ctx) {
  this.particles.forEach(p => {
    ctx.save();  // 性能开销大
    ctx.translate(p.x, p.y);
    ctx.rotate(p.rotation);
    // ... 绘制
    ctx.restore();  // 性能开销大
  });
}

// 简化渲染，减少 save/restore
renderParticles(ctx) {
  this.particles.forEach(p => {
    // 直接使用绝对坐标
    ctx.globalAlpha = p.alpha;
    ctx.fillStyle = p.color;
    ctx.beginPath();
    ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
    ctx.fill();
  });
}

// 游戏初始化时预分配对象池
initPool() {
  // 预分配 50 个敌机
  for (let i = 0; i < 50; i++) {
    this.pool.enemys.push(new Enemy());
  }

  // 预分配 100 个子弹
  for (let i = 0; i < 100; i++) {
    this.pool.bullets.push(new Bullet());
  }

  // 预分配 20 个道具
  for (let i = 0; i < 20; i++) {
    this.pool.powerUps.push(new PowerUp());
  }
}