Merge branch 'setube:main' into main

2026-05-12 07:55:11 +08:00 · 2025-12-17 23:07:53 +08:00
parent 97db1324b6 6813456d12
commit d700216cfc
12 changed files with 325 additions and 121 deletions
--- a/src/App.vue
+++ b/src/App.vue
@@ -200,41 +200,49 @@
                <SidebarTrigger class="lg:hidden" data-tutorial="mobile-menu" />
              </div>

-              <!-- 资源显示 - PC端居中，移动端可折叠 -->
-              <div
-                class="resource-bar flex items-center gap-3 sm:gap-6 justify-center"
-                :class="resourceBarExpanded ? 'hidden' : 'overflow-x-auto'"
-              >
-                <div v-for="resourceType in resourceTypes" :key="resourceType.key" class="flex items-center gap-1.5 sm:gap-2 flex-shrink-0">
-                  <ResourceIcon :type="resourceType.key" size="md" />
-                  <div class="min-w-0">
-                    <!-- 电力显示净产量和效率 -->
-                    <template v-if="resourceType.key === 'energy'">
-                      <p
-                        class="text-xs sm:text-sm font-medium truncate"
-                        :class="netEnergy >= 0 ? 'text-green-600 dark:text-green-400' : 'text-red-600 dark:text-red-400'"
-                      >
-                        {{ netEnergy >= 0 ? '+' : '' }}{{ formatNumber(netEnergy) }}
-                      </p>
-                      <p class="text-[10px] sm:text-xs text-muted-foreground truncate">
-                        {{ formatNumber(production?.energy || 0) }} / {{ formatNumber(energyConsumption) }}
-                      </p>
-                    </template>
-                    <!-- 其他资源统一显示：当前值/容量 -->
-                    <template v-else>
-                      <p
-                        class="text-xs sm:text-sm font-medium truncate"
-                        :class="getResourceColor(planet.resources[resourceType.key], capacity?.[resourceType.key] || Infinity)"
-                      >
-                        {{ formatNumber(planet.resources[resourceType.key]) }} / {{ formatNumber(capacity?.[resourceType.key] || 0) }}
-                      </p>
-                      <p class="text-[10px] sm:text-xs text-muted-foreground truncate">
-                        +{{ formatNumber(Math.round((production?.[resourceType.key] || 0) / 60)) }}/{{ t('resources.perMinute') }}
-                      </p>
-                    </template>
-                  </div>
-                </div>
-              </div>
+	              <!-- 资源显示 - PC端居中，移动端可折叠 -->
+	              <!-- 关键：min-w-0 + overflow-hidden，避免横向滚动内容溢出覆盖左侧菜单按钮 -->
+	              <div class="min-w-0 overflow-hidden">
+	                <div
+	                  class="resource-bar flex items-center gap-3 sm:gap-6 justify-start sm:justify-center"
+	                  :class="resourceBarExpanded ? 'hidden' : 'overflow-x-auto'"
+	                >
+	                  <div
+	                    v-for="resourceType in resourceTypes"
+	                    :key="resourceType.key"
+	                    class="flex items-center gap-1.5 sm:gap-2 flex-shrink-0"
+	                  >
+	                    <ResourceIcon :type="resourceType.key" size="md" />
+	                    <div class="min-w-0">
+	                      <!-- 电力显示净产量和效率 -->
+	                      <template v-if="resourceType.key === 'energy'">
+	                        <p
+	                          class="text-xs sm:text-sm font-medium truncate"
+	                          :class="netEnergy >= 0 ? 'text-green-600 dark:text-green-400' : 'text-red-600 dark:text-red-400'"
+	                        >
+	                          {{ netEnergy >= 0 ? '+' : '' }}{{ formatNumber(netEnergy) }}
+	                        </p>
+	                        <p class="text-[10px] sm:text-xs text-muted-foreground truncate">
+	                          {{ formatNumber(production?.energy || 0) }} / {{ formatNumber(energyConsumption) }}
+	                        </p>
+	                      </template>
+	                      <!-- 其他资源统一显示：当前值/容量 -->
+	                      <template v-else>
+	                        <p
+	                          class="text-xs sm:text-sm font-medium truncate"
+	                          :class="getResourceColor(planet.resources[resourceType.key], capacity?.[resourceType.key] || Infinity)"
+	                        >
+	                          {{ formatNumber(planet.resources[resourceType.key]) }} /
+	                          {{ formatNumber(capacity?.[resourceType.key] || 0) }}
+	                        </p>
+	                        <p class="text-[10px] sm:text-xs text-muted-foreground truncate">
+	                          +{{ formatNumber(Math.round((production?.[resourceType.key] || 0) / 60)) }}/{{ t('resources.perMinute') }}
+	                        </p>
+	                      </template>
+	                    </div>
+	                  </div>
+	                </div>
+	              </div>

              <!-- 右侧：展开按钮（仅移动端） + 状态 -->
              <div class="flex items-center gap-2 sm:gap-3 flex-shrink-0 justify-end">
@@ -428,6 +436,7 @@
  import { DIPLOMATIC_CONFIG } from '@/config/gameConfig'
  import type { VersionInfo } from '@/utils/versionCheck'
  import { formatNumber, getResourceColor } from '@/utils/format'
+  import { getGameLoopIntervalMs, scaleNumber, scaleResources } from '@/utils/speed'
  import {
    Moon,
    Sun,
@@ -1232,7 +1241,7 @@
      clearInterval(gameLoop)
    }
    // 根据游戏速度计算间隔时间
-    const interval = 1000 / (gameStore.gameSpeed || 1)
+    const interval = getGameLoopIntervalMs(gameStore.gameSpeed)
    // 启动新的游戏循环
    gameLoop = setInterval(() => {
      updateGame()
@@ -1433,11 +1442,12 @@
    if (!planet.value) return null
    const now = Date.now()
    const bonuses = officerLogic.calculateActiveBonuses(gameStore.player.officers, now)
-    return resourceLogic.calculateResourceProduction(planet.value, {
+    const base = resourceLogic.calculateResourceProduction(planet.value, {
      resourceProductionBonus: bonuses.resourceProductionBonus,
      darkMatterProductionBonus: bonuses.darkMatterProductionBonus,
      energyProductionBonus: bonuses.energyProductionBonus
    })
+    return scaleResources(base, gameStore.gameSpeed)
  })

  const capacity = computed(() => {
@@ -1450,7 +1460,7 @@
  // 电力消耗
  const energyConsumption = computed(() => {
    if (!planet.value) return 0
-    return resourceLogic.calculateEnergyConsumption(planet.value)
+    return scaleNumber(resourceLogic.calculateEnergyConsumption(planet.value), gameStore.gameSpeed)
  })

  // 净电力（产量 - 消耗）
--- a/src/logic/diplomaticLogic.ts
+++ b/src/logic/diplomaticLogic.ts
@@ -6,6 +6,8 @@

 import { DIPLOMATIC_CONFIG } from '@/config/gameConfig'
 import { locales, type Locale } from '@/locales'
+import * as resourceLogic from './resourceLogic'
+import * as officerLogic from './officerLogic'
 import type {
  DiplomaticRelation,
  RelationStatus,
@@ -783,14 +785,14 @@ export const handleNPCGiftToPlayer = (npc: NPC, player: Player, giftResources: R
 * @param locale 语言代码
 */
 export const acceptNPCGift = (player: Player, npc: NPC, giftNotification: GiftNotification, locale: Locale): void => {
-  // 将资源添加到玩家主星球
+  // 将资源添加到玩家主星球（使用安全添加函数防止溢出）
  if (player.planets && player.planets.length > 0) {
    const mainPlanet = player.planets[0]
    if (mainPlanet) {
-      mainPlanet.resources.metal += giftNotification.resources.metal
-      mainPlanet.resources.crystal += giftNotification.resources.crystal
-      mainPlanet.resources.deuterium += giftNotification.resources.deuterium
-      mainPlanet.resources.darkMatter += giftNotification.resources.darkMatter
+      // 计算军官加成
+      const bonuses = officerLogic.calculateActiveBonuses(player.officers, Date.now())
+      // 使用安全添加函数，超出容量的资源会丢失
+      resourceLogic.addResourcesSafely(mainPlanet, giftNotification.resources, bonuses.storageCapacityBonus)
    }
  }

--- a/src/logic/fleetLogic.ts
+++ b/src/logic/fleetLogic.ts
@@ -6,6 +6,9 @@ import * as battleLogic from './battleLogic'
 import * as moonLogic from './moonLogic'
 import * as moonValidation from './moonValidation'
 import * as diplomaticLogic from './diplomaticLogic'
+import * as resourceLogic from './resourceLogic'
+import * as fleetStorageLogic from './fleetStorageLogic'
+import * as officerLogic from './officerLogic'

 /**
 * 计算两个星球之间的距离
@@ -78,8 +81,9 @@ export const processTransportArrival = (
  targetPlanet: Planet | undefined,
  player?: Player,
  allNpcs?: NPC[],
-  locale: Locale = 'zh-CN'
-): { success: boolean; reputationGain?: number } => {
+  locale: Locale = 'zh-CN',
+  storageCapacityBonus: number = 0
+): { success: boolean; reputationGain?: number; overflow?: Resources } => {
  // 检查是否是赠送任务
  if (mission.isGift && mission.giftTargetNpcId && player && allNpcs) {
    const targetNpc = allNpcs.find(n => n.id === mission.giftTargetNpcId)
@@ -101,13 +105,15 @@ export const processTransportArrival = (

  // 正常运输任务
  if (targetPlanet) {
-    targetPlanet.resources.metal += mission.cargo.metal
-    targetPlanet.resources.crystal += mission.cargo.crystal
-    targetPlanet.resources.deuterium += mission.cargo.deuterium
-    targetPlanet.resources.darkMatter += mission.cargo.darkMatter
+    // 使用安全添加函数，防止资源溢出
+    const result = resourceLogic.addResourcesSafely(targetPlanet, mission.cargo, storageCapacityBonus)
    mission.status = 'returning'
-    mission.cargo = { metal: 0, crystal: 0, deuterium: 0, darkMatter: 0, energy: 0 }
-    return { success: true }
+
+    // 如果有溢出的资源，保留在cargo中返回给发送者
+    if (result.overflow.metal > 0 || result.overflow.crystal > 0 || result.overflow.deuterium > 0 || result.overflow.darkMatter > 0) {
+      mission.cargo = result.overflow
+      return { success: true, overflow: result.overflow }
+    }
  }
  mission.status = 'returning'
  mission.cargo = { metal: 0, crystal: 0, deuterium: 0, darkMatter: 0, energy: 0 }
@@ -178,10 +184,10 @@ export const processAttackArrival = async (
  })
  targetPlanet.defense = battleLogic.repairDefense(defenseBeforeBattle, targetPlanet.defense) as Record<DefenseType, number>

-  // 扣除掠夺的资源
-  targetPlanet.resources.metal -= battleResult.plunder.metal
-  targetPlanet.resources.crystal -= battleResult.plunder.crystal
-  targetPlanet.resources.deuterium -= battleResult.plunder.deuterium
+  // 扣除掠夺的资源（防止下溢到负数）
+  targetPlanet.resources.metal = Math.max(0, targetPlanet.resources.metal - battleResult.plunder.metal)
+  targetPlanet.resources.crystal = Math.max(0, targetPlanet.resources.crystal - battleResult.plunder.crystal)
+  targetPlanet.resources.deuterium = Math.max(0, targetPlanet.resources.deuterium - battleResult.plunder.deuterium)

  mission.status = 'returning'

@@ -519,18 +525,28 @@ export const processSpyArrival = (
 /**
 * 处理部署任务到达
 */
-export const processDeployArrival = (mission: FleetMission, targetPlanet: Planet | undefined, playerId: string): boolean => {
+export const processDeployArrival = (
+  mission: FleetMission,
+  targetPlanet: Planet | undefined,
+  playerId: string,
+  technologies: Record<TechnologyType, number>
+): { success: boolean; overflow?: Partial<Record<ShipType, number>> } => {
  if (!targetPlanet || targetPlanet.ownerId !== playerId) {
    mission.status = 'returning'
-    return false
+    return { success: false }
  }

-  for (const [shipType, count] of Object.entries(mission.fleet)) {
-    targetPlanet.fleet[shipType as ShipType] += count
+  // 使用安全添加函数，防止舰队仓储溢出
+  const result = fleetStorageLogic.addFleetSafely(targetPlanet, mission.fleet, technologies)
+  // 如果有溢出的舰船，保留在mission.fleet中返回给发送者
+  const hasOverflow = Object.keys(result.overflow).length > 0
+  if (hasOverflow) {
+    mission.fleet = result.overflow as Fleet
+    mission.status = 'returning'
+    return { success: true, overflow: result.overflow }
  }
-
  // 部署任务直接完成，不返回
-  return true
+  return { success: true }
 }

 /**
@@ -693,19 +709,19 @@ export const processDestroyArrival = (
 /**
 * 处理舰队任务返回
 */
-export const processFleetReturn = (mission: FleetMission, originPlanet: Planet): void => {
-  // 舰船返回
-  Object.entries(mission.fleet).forEach(([shipType, count]) => {
-    if (count > 0) {
-      originPlanet.fleet[shipType as ShipType] += count
-    }
-  })
+export const processFleetReturn = (
+  mission: FleetMission,
+  originPlanet: Planet,
+  technologies: Record<TechnologyType, number>,
+  storageCapacityBonus: number
+): void => {
+  // 舰船返回 - 使用安全添加函数
+  fleetStorageLogic.addFleetSafely(originPlanet, mission.fleet, technologies)
+  // 注意：如果舰队仓储溢出，超出部分会丢失（这是合理的惩罚）

-  // 资源返回（掠夺物或运输货物）
-  originPlanet.resources.metal += mission.cargo.metal
-  originPlanet.resources.crystal += mission.cargo.crystal
-  originPlanet.resources.deuterium += mission.cargo.deuterium
-  originPlanet.resources.darkMatter += mission.cargo.darkMatter
+  // 资源返回（掠夺物或运输货物）- 使用安全添加函数
+  resourceLogic.addResourcesSafely(originPlanet, mission.cargo, storageCapacityBonus)
+  // 注意：如果资源仓储溢出，超出部分会丢失（这是合理的惩罚）
 }

 /**
@@ -743,6 +759,9 @@ export const updateFleetMissions = async (

  // 获取所有星球列表（用于月球生成检查）
  const allPlanets = Array.from(planets.values())
+  // 计算军官加成（用于资源容量计算）
+  const bonuses = officerLogic.calculateActiveBonuses(attacker.officers, now)
+  const storageCapacityBonus = bonuses.storageCapacityBonus

  // 使用 for...of 以支持 await
  for (const mission of missions) {
@@ -755,7 +774,7 @@ export const updateFleetMissions = async (

      switch (mission.missionType) {
        case MissionType.Transport:
-          processTransportArrival(mission, targetPlanet, attacker, allNpcs)
+          processTransportArrival(mission, targetPlanet, attacker, allNpcs, locale, storageCapacityBonus)
          break

        case MissionType.Attack: {
@@ -808,8 +827,8 @@ export const updateFleetMissions = async (
          break

        case MissionType.Deploy:
-          const deployed = processDeployArrival(mission, targetPlanet, attacker.id)
-          if (deployed) {
+          const deployed = processDeployArrival(mission, targetPlanet, attacker.id, attacker.technologies)
+          if (deployed.success && !deployed.overflow) {
            completedMissions.push(mission.id)
          }
          break
@@ -858,7 +877,7 @@ export const updateFleetMissions = async (
    if (mission.status === 'returning' && mission.returnTime && now >= mission.returnTime) {
      // 舰队返回
      if (originPlanet) {
-        processFleetReturn(mission, originPlanet)
+        processFleetReturn(mission, originPlanet, attacker.technologies, storageCapacityBonus)
      }
      completedMissions.push(mission.id)
    }
--- a/src/logic/fleetStorageLogic.ts
+++ b/src/logic/fleetStorageLogic.ts
@@ -52,6 +52,26 @@ export const calculateMaxFleetStorage = (planet: Planet, technologies: Record<Te
  return maxStorage
 }

+/**
+ * 计算建造队列中的舰船仓储使用量
+ * @param buildQueue 建造队列
+ * @returns 队列中舰船的仓储使用量
+ */
+export const calculateQueueFleetStorageUsage = (buildQueue: Array<{ type: string; itemType: string; quantity?: number }>): number => {
+  let queueUsage = 0
+
+  for (const item of buildQueue) {
+    if (item.type === 'ship') {
+      const shipType = item.itemType as ShipType
+      const quantity = item.quantity || 0
+      const shipConfig = SHIPS[shipType]
+      queueUsage += quantity * shipConfig.storageUsage
+    }
+  }
+
+  return queueUsage
+}
+
 /**
 * 检查是否有足够的舰队仓储空间建造新舰船
 * @param planet 星球对象
@@ -67,10 +87,11 @@ export const hasEnoughFleetStorage = (
  technologies: Record<TechnologyType, number>
 ): boolean => {
  const currentUsage = calculateFleetStorageUsage(planet.fleet)
+  const queueUsage = calculateQueueFleetStorageUsage(planet.buildQueue)
  const maxStorage = calculateMaxFleetStorage(planet, technologies)
  const newShipUsage = SHIPS[shipType].storageUsage * quantity

-  return currentUsage + newShipUsage <= maxStorage
+  return currentUsage + queueUsage + newShipUsage <= maxStorage
 }

 /**
@@ -93,3 +114,46 @@ export const getMaxBuildableShips = (planet: Planet, shipType: ShipType, technol

  return Math.floor(availableStorage / shipStorageUsage)
 }
+
+/**
+ * 安全地添加舰船到星球（会检查舰队仓储容量上限）
+ * @param planet 星球对象
+ * @param fleet 要添加的舰船
+ * @param technologies 玩家的科技等级
+ * @returns 实际添加的舰船数量和溢出的舰船数量
+ */
+export const addFleetSafely = (
+  planet: Planet,
+  fleet: Partial<Record<ShipType, number>>,
+  technologies: Record<TechnologyType, number>
+): { added: Partial<Record<ShipType, number>>; overflow: Partial<Record<ShipType, number>> } => {
+  const maxStorage = calculateMaxFleetStorage(planet, technologies)
+  let currentUsage = calculateFleetStorageUsage(planet.fleet)
+
+  const added: Partial<Record<ShipType, number>> = {}
+  const overflow: Partial<Record<ShipType, number>> = {}
+
+  for (const [shipType, count] of Object.entries(fleet)) {
+    if (count <= 0) continue
+
+    const ship = shipType as ShipType
+    const shipStorageUsage = SHIPS[ship].storageUsage
+
+    // 计算可以添加多少艘（不超过容量上限）
+    const spaceAvailable = Math.max(0, maxStorage - currentUsage)
+    const maxCanAdd = shipStorageUsage > 0 ? Math.floor(spaceAvailable / shipStorageUsage) : count
+    const actuallyAdded = Math.min(count, maxCanAdd)
+    const overflowed = count - actuallyAdded
+    if (actuallyAdded > 0) {
+      planet.fleet[ship] = (planet.fleet[ship] || 0) + actuallyAdded
+      added[ship] = actuallyAdded
+      currentUsage += actuallyAdded * shipStorageUsage
+    }
+
+    if (overflowed > 0) {
+      overflow[ship] = overflowed
+    }
+  }
+
+  return { added, overflow }
+}
--- a/src/logic/npcGrowthLogic.ts
+++ b/src/logic/npcGrowthLogic.ts
@@ -384,15 +384,16 @@ export const autoBuildNPCFleet = (npc: NPC): void => {

    if (!canBuild) continue

-    // 根据难度和当前资源决定建造数量
-    const maxAffordable = Math.floor(
-      Math.min(
-        planet.resources.metal / shipConfig.cost.metal,
-        planet.resources.crystal / shipConfig.cost.crystal,
-        planet.resources.deuterium / shipConfig.cost.deuterium,
-        shipConfig.cost.darkMatter > 0 ? planet.resources.darkMatter / shipConfig.cost.darkMatter : Infinity
-      )
-    )
+    // 根据难度和当前资源决定建造数量（防止除零）
+    const metalAffordable = shipConfig.cost.metal > 0 ? planet.resources.metal / shipConfig.cost.metal : Infinity
+    const crystalAffordable = shipConfig.cost.crystal > 0 ? planet.resources.crystal / shipConfig.cost.crystal : Infinity
+    const deuteriumAffordable = shipConfig.cost.deuterium > 0 ? planet.resources.deuterium / shipConfig.cost.deuterium : Infinity
+    const darkMatterAffordable = shipConfig.cost.darkMatter > 0 ? planet.resources.darkMatter / shipConfig.cost.darkMatter : Infinity
+
+    const maxAffordable = Math.floor(Math.min(metalAffordable, crystalAffordable, deuteriumAffordable, darkMatterAffordable))
+
+    // 防止NaN或Infinity（如果所有成本都为0的极端情况）
+    if (!Number.isFinite(maxAffordable) || maxAffordable <= 0) continue

    // 建造数量：简单1-5艘，中等5-10艘，困难10-20艘
    const buildCount = Math.min(maxAffordable, npc.difficulty === 'easy' ? 5 : npc.difficulty === 'medium' ? 10 : 20)
--- a/src/logic/publicLogic.ts
+++ b/src/logic/publicLogic.ts
@@ -8,6 +8,7 @@ import type { Planet, Resources, Officer, BuildingConfig, TechnologyConfig } fro
 import { OfficerType } from '@/types/game'
 import * as officerLogic from '@/logic/officerLogic'
 import * as resourceLogic from '@/logic/resourceLogic'
+import { scaleResources } from '@/utils/speed'

 /**
 * 获取特定等级的升级条件
@@ -93,11 +94,12 @@ export const checkRequirements = (
 * @param officers 玩家的军官对象
 * @returns 每小时各类资源的产量
 */
-export const getResourceProduction = (planet: Planet, officers: Record<OfficerType, Officer>): Resources => {
+export const getResourceProduction = (planet: Planet, officers: Record<OfficerType, Officer>, resourceSpeed: number = 1): Resources => {
  // 计算当前激活的军官加成
  const bonuses = officerLogic.calculateActiveBonuses(officers, Date.now())
  // 根据建筑等级和军官加成计算资源产量
-  return resourceLogic.calculateResourceProduction(planet, bonuses)
+  const base = resourceLogic.calculateResourceProduction(planet, bonuses)
+  return scaleResources(base, resourceSpeed)
 }

 /**
--- a/src/logic/resourceLogic.ts
+++ b/src/logic/resourceLogic.ts
@@ -194,6 +194,44 @@ export const addResources = (currentResources: Resources, amount: Resources): vo
  currentResources.darkMatter += amount.darkMatter
 }

+/**
+ * 安全地添加资源（会检查仓储容量上限）
+ * @param planet 星球对象
+ * @param amount 要添加的资源
+ * @param storageCapacityBonus 仓储容量加成
+ * @returns 实际添加的资源数量和溢出的资源数量
+ */
+export const addResourcesSafely = (
+  planet: Planet,
+  amount: Resources,
+  storageCapacityBonus: number
+): { added: Resources; overflow: Resources } => {
+  const capacity = calculateResourceCapacity(planet, storageCapacityBonus)
+
+  const added: Resources = { metal: 0, crystal: 0, deuterium: 0, darkMatter: 0, energy: 0 }
+  const overflow: Resources = { metal: 0, crystal: 0, deuterium: 0, darkMatter: 0, energy: 0 }
+
+  // 处理每种资源
+  const resources: Array<keyof Resources> = ['metal', 'crystal', 'deuterium', 'darkMatter']
+
+  for (const resourceType of resources) {
+    const currentAmount = planet.resources[resourceType]
+    const amountToAdd = amount[resourceType]
+    const maxCapacity = capacity[resourceType]
+
+    // 计算可以添加的量（不超过容量上限）
+    const spaceAvailable = Math.max(0, maxCapacity - currentAmount)
+    const actuallyAdded = Math.min(amountToAdd, spaceAvailable)
+    const overflowed = amountToAdd - actuallyAdded
+
+    planet.resources[resourceType] += actuallyAdded
+    added[resourceType] = actuallyAdded
+    overflow[resourceType] = overflowed
+  }
+
+  return { added, overflow }
+}
+
 /**
 * 资源产量详细信息（用于UI展示）
 */
@@ -249,7 +287,8 @@ export interface ConsumptionDetail {
 export const calculateProductionBreakdown = (
  planet: Planet,
  officers: Record<OfficerType, Officer>,
-  currentTime: number
+  currentTime: number,
+  resourceSpeed: number = 1
 ): ProductionBreakdown => {
  const metalMineLevel = planet.buildings[BuildingType.MetalMine] || 0
  const crystalMineLevel = planet.buildings[BuildingType.CrystalMine] || 0
@@ -435,42 +474,56 @@ export const calculateProductionBreakdown = (

  const energyFinal = energyBase * (1 + totalEnergyBonus / 100)

+  const speed = resourceSpeed
+
+  const scaleBonuses = (bonuses: ProductionBonus[]) =>
+    bonuses.map(bonus => ({
+      ...bonus,
+      value: bonus.value * speed
+    }))
+
+  const scaleSources = (sources?: ProductionSource[]) =>
+    sources?.map(source => ({
+      ...source,
+      production: source.production * speed
+    }))
+
  return {
    metal: {
-      baseProduction: metalBase,
+      baseProduction: metalBase * speed,
      buildingLevel: metalMineLevel,
      buildingName: 'buildings.metalMine',
-      bonuses: metalBonuses,
-      finalProduction: metalFinal
+      bonuses: scaleBonuses(metalBonuses),
+      finalProduction: metalFinal * speed
    },
    crystal: {
-      baseProduction: crystalBase,
+      baseProduction: crystalBase * speed,
      buildingLevel: crystalMineLevel,
      buildingName: 'buildings.crystalMine',
-      bonuses: crystalBonuses,
-      finalProduction: crystalFinal
+      bonuses: scaleBonuses(crystalBonuses),
+      finalProduction: crystalFinal * speed
    },
    deuterium: {
-      baseProduction: deuteriumBase,
+      baseProduction: deuteriumBase * speed,
      buildingLevel: deuteriumSynthesizerLevel,
      buildingName: 'buildings.deuteriumSynthesizer',
-      bonuses: deuteriumBonuses,
-      finalProduction: deuteriumFinal
+      bonuses: scaleBonuses(deuteriumBonuses),
+      finalProduction: deuteriumFinal * speed
    },
    darkMatter: {
-      baseProduction: darkMatterBase,
+      baseProduction: darkMatterBase * speed,
      buildingLevel: darkMatterCollectorLevel,
      buildingName: 'buildings.darkMatterCollector',
-      bonuses: darkMatterBonuses,
-      finalProduction: darkMatterFinal
+      bonuses: scaleBonuses(darkMatterBonuses),
+      finalProduction: darkMatterFinal * speed
    },
    energy: {
-      baseProduction: energyBase,
+      baseProduction: energyBase * speed,
      buildingLevel: solarPlantLevel,
      buildingName: 'buildings.solarPlant',
-      bonuses: energyBonuses,
-      finalProduction: energyFinal,
-      sources: energySources
+      bonuses: scaleBonuses(energyBonuses),
+      finalProduction: energyFinal * speed,
+      sources: scaleSources(energySources)
    }
  }
 }
@@ -478,7 +531,7 @@ export const calculateProductionBreakdown = (
 /**
 * 计算能量消耗详细breakdown
 */
-export const calculateConsumptionBreakdown = (planet: Planet): ConsumptionBreakdown => {
+export const calculateConsumptionBreakdown = (planet: Planet, resourceSpeed: number = 1): ConsumptionBreakdown => {
  const metalMineLevel = planet.buildings[BuildingType.MetalMine] || 0
  const crystalMineLevel = planet.buildings[BuildingType.CrystalMine] || 0
  const deuteriumSynthesizerLevel = planet.buildings[BuildingType.DeuteriumSynthesizer] || 0
@@ -487,22 +540,24 @@ export const calculateConsumptionBreakdown = (planet: Planet): ConsumptionBreakd
  const crystalConsumption = crystalMineLevel * 10 * Math.pow(1.1, crystalMineLevel)
  const deuteriumConsumption = deuteriumSynthesizerLevel * 15 * Math.pow(1.1, deuteriumSynthesizerLevel)

+  const speed = resourceSpeed
+
  return {
    metalMine: {
      buildingLevel: metalMineLevel,
      buildingName: 'buildings.metalMine',
-      consumption: metalConsumption
+      consumption: metalConsumption * speed
    },
    crystalMine: {
      buildingLevel: crystalMineLevel,
      buildingName: 'buildings.crystalMine',
-      consumption: crystalConsumption
+      consumption: crystalConsumption * speed
    },
    deuteriumSynthesizer: {
      buildingLevel: deuteriumSynthesizerLevel,
      buildingName: 'buildings.deuteriumSynthesizer',
-      consumption: deuteriumConsumption
+      consumption: deuteriumConsumption * speed
    },
-    total: metalConsumption + crystalConsumption + deuteriumConsumption
+    total: (metalConsumption + crystalConsumption + deuteriumConsumption) * speed
  }
 }
--- a/src/logic/shipLogic.ts
+++ b/src/logic/shipLogic.ts
@@ -173,6 +173,24 @@ export const calculateCurrentMissileCount = (defense: Partial<Record<DefenseType
  return interplanetaryMissiles + antiBallisticMissiles
 }

+/**
+ * 计算建造队列中的导弹总数
+ */
+export const calculateQueueMissileCount = (buildQueue: Array<{ type: string; itemType: string; quantity?: number }>): number => {
+  let queueMissileCount = 0
+
+  for (const item of buildQueue) {
+    if (item.type === 'defense') {
+      const defenseType = item.itemType as DefenseType
+      if (defenseType === DefenseType.InterplanetaryMissile || defenseType === DefenseType.AntiBallisticMissile) {
+        queueMissileCount += item.quantity || 0
+      }
+    }
+  }
+
+  return queueMissileCount
+}
+
 /**
 * 检查导弹容量限制
 */
@@ -180,7 +198,8 @@ export const checkMissileSiloLimit = (
  defenseType: DefenseType,
  currentDefense: Partial<Record<DefenseType, number>>,
  buildings: Partial<Record<BuildingType, number>>,
-  quantity: number
+  quantity: number,
+  buildQueue?: Array<{ type: string; itemType: string; quantity?: number }>
 ): boolean => {
  // 只对导弹类型进行检查
  if (defenseType !== DefenseType.InterplanetaryMissile && defenseType !== DefenseType.AntiBallisticMissile) {
@@ -189,7 +208,8 @@ export const checkMissileSiloLimit = (

  const maxCapacity = calculateMissileSiloCapacity(buildings)
  const currentCount = calculateCurrentMissileCount(currentDefense)
-  const newCount = currentCount + quantity
+  const queueCount = buildQueue ? calculateQueueMissileCount(buildQueue) : 0
+  const newCount = currentCount + queueCount + quantity

  return newCount <= maxCapacity
 }
--- a/src/logic/shipValidation.ts
+++ b/src/logic/shipValidation.ts
@@ -101,7 +101,7 @@ export const validateDefenseBuild = (
  }

  // 导弹发射井容量限制
-  if (!shipLogic.checkMissileSiloLimit(defenseType, planet.defense, planet.buildings, quantity)) {
+  if (!shipLogic.checkMissileSiloLimit(defenseType, planet.defense, planet.buildings, quantity, planet.buildQueue)) {
    return { valid: false, reason: 'errors.missileSiloLimit' }
  }

--- a/src/utils/speed.ts
+++ b/src/utils/speed.ts
@@ -0,0 +1,28 @@
+import type { Resources } from '@/types/game'
+
+/**
+ * 按倍率缩放一个数值
+ * - 支持合法的 0（例如用于“暂停”）
+ */
+export const scaleNumber = (value: number, multiplier: number): number => value * multiplier
+
+/**
+ * 按倍率缩放 Resources（常用于“每小时产量/消耗”等展示）
+ * - 支持合法的 0（例如用于“暂停”）
+ */
+export const scaleResources = (resources: Resources, multiplier: number): Resources => ({
+  metal: resources.metal * multiplier,
+  crystal: resources.crystal * multiplier,
+  deuterium: resources.deuterium * multiplier,
+  darkMatter: resources.darkMatter * multiplier,
+  energy: resources.energy * multiplier
+})
+
+/**
+ * 计算游戏循环的间隔（毫秒）
+ * - multiplier <= 0 或非有限值时，回退到 baseMs，避免除 0
+ */
+export const getGameLoopIntervalMs = (multiplier: number, baseMs: number = 1000): number => {
+  if (!Number.isFinite(multiplier) || multiplier <= 0) return baseMs
+  return baseMs / multiplier
+}
--- a/src/views/OverviewView.vue
+++ b/src/views/OverviewView.vue
@@ -201,6 +201,7 @@
  import { Badge } from '@/components/ui/badge'
  import ResourceIcon from '@/components/ResourceIcon.vue'
  import { formatNumber, getResourceColor } from '@/utils/format'
+  import { scaleNumber } from '@/utils/speed'
  import type { Planet } from '@/types/game'
  import * as publicLogic from '@/logic/publicLogic'
  import * as resourceLogic from '@/logic/resourceLogic'
@@ -209,25 +210,27 @@
  const { t } = useI18n()
  const { SHIPS } = useGameConfig()
  const planet = computed(() => gameStore.currentPlanet)
-  const production = computed(() => (planet.value ? publicLogic.getResourceProduction(planet.value, gameStore.player.officers) : null))
+  const production = computed(() =>
+    planet.value ? publicLogic.getResourceProduction(planet.value, gameStore.player.officers, gameStore.gameSpeed) : null
+  )
  const capacity = computed(() => (planet.value ? publicLogic.getResourceCapacity(planet.value, gameStore.player.officers) : null))

  // 能量消耗
  const energyConsumption = computed(() => {
    if (!planet.value) return 0
-    return resourceLogic.calculateEnergyConsumption(planet.value)
+    return scaleNumber(resourceLogic.calculateEnergyConsumption(planet.value), gameStore.gameSpeed)
  })

  // 资源产量详细breakdown
  const productionBreakdown = computed(() => {
    if (!planet.value) return null
-    return resourceLogic.calculateProductionBreakdown(planet.value, gameStore.player.officers, Date.now())
+    return resourceLogic.calculateProductionBreakdown(planet.value, gameStore.player.officers, Date.now(), gameStore.gameSpeed)
  })

  // 资源消耗详细breakdown
  const consumptionBreakdown = computed(() => {
    if (!planet.value) return null
-    return resourceLogic.calculateConsumptionBreakdown(planet.value)
+    return resourceLogic.calculateConsumptionBreakdown(planet.value, gameStore.gameSpeed)
  })

  // 资源类型配置
--- a/src/views/SettingsView.vue
+++ b/src/views/SettingsView.vue
@@ -65,10 +65,10 @@
            <h3 class="font-medium">{{ t('settings.gameSpeed') }}</h3>
            <p class="text-sm text-muted-foreground">{{ t('settings.gameSpeedDesc') }}</p>
          </div>
-          <div class="flex items-center gap-2 sm:gap-4 w-full sm:w-auto">
-            <div class="flex items-center gap-2 flex-1 sm:flex-initial">
+	          <div class="flex items-center gap-2 sm:gap-4 w-full sm:w-auto">
+	            <div class="flex items-center gap-2 flex-1 sm:flex-initial">
              <Button @click="decreaseSpeed" variant="outline" size="sm" :disabled="gameStore.gameSpeed <= 0.5">-</Button>
-              <span class="min-w-[60px] text-center font-medium">{{ gameStore.gameSpeed || 1 }}x</span>
+              <span class="min-w-[60px] text-center font-medium">{{ gameStore.gameSpeed }}x</span>
              <Button @click="increaseSpeed" variant="outline" size="sm" :disabled="gameStore.gameSpeed >= 10">+</Button>
            </div>
            <Button @click="resetSpeed" variant="ghost" size="sm">{{ t('settings.reset') }}</Button>