伤害计算是游戏中的重要概念。玩家需要快速计算不同武器的伤害，了解需要多少发子弹才能击杀对手。在实际开发中，我们遇到过玩家反馈说不知道用什么武器更高效，所以决定做一个伤害计算器来解决这个问题。

伤害计算模型

首先定义武器数据和防具系数。这些数据是从游戏官方数据整理出来的：

static const Map<String, int> weaponDamage = {
  'M416': 41,
  'AK47': 49,
  'M16A4': 48,
  'SCAR-L': 45,
  'AWM': 120,
  'M24': 79,
  'SKS': 53,
};

为什么这样设计：使用 Map 存储武器名称和伤害值，方便后续查询和扩展。每个武器的伤害值都是游戏内的真实数据，确保计算准确性。

防具防护系数决定了玩家能减少多少伤害：

static const Map<String, double> armorProtection = {
  '无防具': 1.0,
  '一级防具': 0.9,
  '二级防具': 0.75,
  '三级防具': 0.55,
};

防具系数说明：三级防具能减少 45% 的伤害（系数 0.55），这是游戏中最强的防护。系数越低，防护效果越好。

不同部位的伤害倍数也很关键：

static const double headMultiplier = 2.1;
static const double bodyMultiplier = 1.0;
static const double legMultiplier = 0.9;

部位倍数含义：头部是致命位置，伤害翻倍（2.1倍）；躯干是标准伤害（1.0倍）；腿部伤害最低（0.9倍）。这反映了真实的游戏机制。

核心计算方法，将所有因素组合起来：

static int calculateDamage(
  String weapon,
  String hitLocation,
  String armorLevel,
) {
  int baseDamage = weaponDamage[weapon] ?? 0;
  double locationMultiplier = _getLocationMultiplier(hitLocation);
  double armorFactor = armorProtection[armorLevel] ?? 1.0;
  
  double finalDamage = baseDamage * locationMultiplier * armorFactor;
  return finalDamage.toInt();
}

计算流程：

• 获取武器基础伤害
• 根据击中部位获取倍数
• 根据防具等级获取防护系数
• 三者相乘得到最终伤害，转换为整数

部位倍数的获取逻辑：

static double _getLocationMultiplier(String location) {
  switch (location) {
    case '头部':
      return headMultiplier;
    case '躯干':
      return bodyMultiplier;
    case '腿部':
      return legMultiplier;
    default:
      return 1.0;
  }
}

为什么用 switch：相比 if-else，switch 语句更清晰，易于维护。如果后续要添加新的部位（比如手臂），只需添加新的 case 分支。

计算需要多少发子弹才能击杀对手：

static int calculateShotsToKill(
  String weapon,
  String hitLocation,
  String armorLevel,
  int playerHealth,
) {
  int damage = calculateDamage(weapon, hitLocation, armorLevel);
  if (damage == 0) return 0;
  return (playerHealth / damage).ceil();
}

向上取整的重要性：使用 .ceil() 而不是 .toInt() 是因为即使只剩 1 点伤害，也需要再开一枪。比如 100 血量、33 伤害的武器，需要 4 枪而不是 3 枪。

伤害计算器页面

页面的状态管理需要跟踪用户选择的武器、部位、防具和对手血量：

class _DamageCalculatorPageState extends State<DamageCalculatorPage> {
  String _selectedWeapon = 'M416';
  String _selectedLocation = '躯干';
  String _selectedArmor = '二级防具';
  int _playerHealth = 100;

初始值选择：默认选择 M416（最常用的步枪）、躯干（最常见的击中部位）、二级防具（中等防护）和 100 血量（满血状态）。这样用户打开应用就能看到一个合理的计算结果。

在 build 方法中实时计算伤害数据：

int damage = DamageCalculator.calculateDamage(
  _selectedWeapon,
  _selectedLocation,
  _selectedArmor,
);
int shotsToKill = DamageCalculator.calculateShotsToKill(
  _selectedWeapon,
  _selectedLocation,
  _selectedArmor,
  _playerHealth,
);

实时计算的好处：每当用户改变任何参数，build 方法都会重新执行，自动计算新的伤害值。这样用户能立即看到参数变化的影响，提升交互体验。

武器选择器使用 Wrap 布局，让按钮自动换行：

Wrap(
  spacing: 8.w,
  runSpacing: 8.h,
  children: DamageCalculator.weaponDamage.keys.map((weapon) {
    return GestureDetector(
      onTap: () => setState(() => _selectedWeapon = weapon),
      child: Container(
        padding: EdgeInsets.symmetric(horizontal: 12.w, vertical: 8.h),
        decoration: BoxDecoration(
          color: _selectedWeapon == weapon
              ? const Color(0xFFFF6B35)
              : Colors.white10,
          borderRadius: BorderRadius.circular(6.r),
        ),
        child: Text(weapon, style: TextStyle(color: Colors.white, fontSize: 12.sp)),
      ),
    );
  }).toList(),
)

Wrap 的优势：相比 Row 或 Column，Wrap 能自动处理溢出，按钮会自动换到下一行。这样在不同屏幕尺寸上都能正常显示。

部位选择器使用 Row 平均分配空间：

Row(
  children: ['头部', '躯干', '腿部'].map((location) {
    return Expanded(
      child: GestureDetector(
        onTap: () => setState(() => _selectedLocation = location),
        child: Container(
          padding: EdgeInsets.symmetric(vertical: 10.h),
          decoration: BoxDecoration(
            color: _selectedLocation == location
                ? const Color(0xFF4CAF50)
                : Colors.white10,
            borderRadius: BorderRadius.circular(6.r),
          ),
          child: Text(location, textAlign: TextAlign.center, style: TextStyle(color: Colors.white)),
        ),
      ),
    );
  }).toList(),
)

Expanded 的作用：三个按钮平均分配宽度，每个占 1/3。这样看起来更对称，用户也更容易点击。

血量滑块让用户快速调整对手的血量：

Slider(
  value: _playerHealth.toDouble(),
  min: 1,
  max: 100,
  divisions: 99,
  activeColor: const Color(0xFFE91E63),
  inactiveColor: Colors.white24,
  label: _playerHealth.toString(),
  onChanged: (value) => setState(() => _playerHealth = value.toInt()),
)

divisions 参数：设置为 99 表示有 99 个分段，这样滑块每次移动都是 1 点血量的变化。如果不设置 divisions，滑块会是连续的，不够精确。

结果卡片使用渐变背景突出显示：

Container(
  width: double.infinity,
  padding: EdgeInsets.all(20.w),
  decoration: BoxDecoration(
    borderRadius: BorderRadius.circular(12.r),
    gradient: const LinearGradient(
      colors: [Color(0xFFFF6B35), Color(0xFFFF8E53)],
      begin: Alignment.topLeft,
      end: Alignment.bottomRight,
    ),
  ),
  child: Column(
    children: [
      Text('计算结果', style: TextStyle(color: Colors.white, fontSize: 18.sp, fontWeight: FontWeight.bold)),
      SizedBox(height: 20.h),
      Row(
        mainAxisAlignment: MainAxisAlignment.spaceAround,
        children: [
          Column(children: [Text('单发伤害'), Text('$damage', style: TextStyle(fontSize: 28.sp))]),
          Column(children: [Text('需要射击'), Text('$shotsToKill 枪', style: TextStyle(fontSize: 28.sp))]),
        ],
      ),
    ],
  ),
)

渐变背景的视觉效果：从左上到右下的橙色渐变，让结果卡片更突出。大字体显示伤害和枪数，用户一眼就能看到关键信息。

高级功能扩展

武器对比功能

有时玩家想知道两把武器哪个更强。我们可以添加对比功能：

class WeaponComparison {
  final String weapon1;
  final String weapon2;
  final int damage1;
  final int damage2;
  
  WeaponComparison({
    required this.weapon1,
    required this.weapon2,
    required this.damage1,
    required this.damage2,
  });
  
  String getWinner() {
    if (damage1 > damage2) return weapon1;
    if (damage2 > damage1) return weapon2;
    return '平手';
  }
}

对比逻辑：通过计算两把武器的伤害，直接比较大小。这样玩家能快速判断哪把武器更适合当前情况。

伤害历史记录

记录用户最近的计算结果，方便查看：

class DamageRecord {
  final String weapon;
  final String location;
  final String armor;
  final int damage;
  final DateTime timestamp;
  
  DamageRecord({
    required this.weapon,
    required this.location,
    required this.armor,
    required this.damage,
    required this.timestamp,
  });
}

为什么需要历史记录：玩家在战斗中可能会快速切换武器，记录能帮助他们回顾之前的计算结果，做出更好的决策。

在页面中添加历史记录列表：

List<DamageRecord> _history = [];

void _addToHistory(String weapon, String location, String armor, int damage) {
  _history.insert(0, DamageRecord(
    weapon: weapon,
    location: location,
    armor: armor,
    damage: damage,
    timestamp: DateTime.now(),
  ));
  
  if (_history.length > 10) {
    _history.removeLast();
  }
}

限制历史记录数量：只保留最近 10 条记录，避免占用过多内存。每次新增记录时，如果超过 10 条就删除最旧的。

暴击伤害计算

游戏中有暴击机制，我们需要支持这个功能：

static int calculateCriticalDamage(
  int baseDamage,
  double criticalRate,
  double criticalMultiplier,
) {
  double expectedDamage = baseDamage * (1 + (criticalRate * (criticalMultiplier - 1)));
  return expectedDamage.toInt();
}

期望伤害计算：暴击期望伤害 = 基础伤害 × (1 + 暴击率 × (暴击倍数 - 1))。比如 50% 暴击率、2.0 倍暴击伤害，期望伤害就是基础伤害的 1.5 倍。

性能优化

缓存计算结果

频繁计算相同的伤害值会浪费 CPU，我们可以缓存结果：

class DamageCache {
  static final Map<String, int> _cache = {};
  
  static String _generateKey(String weapon, String location, String armor) {
    return '$weapon-$location-$armor';
  }
  
  static int? get(String weapon, String location, String armor) {
    return _cache[_generateKey(weapon, location, armor)];
  }
  
  static void set(String weapon, String location, String armor, int damage) {
    _cache[_generateKey(weapon, location, armor)] = damage;
  }
  
  static void clear() {
    _cache.clear();
  }
}

缓存策略：用武器、部位、防具组合作为 key，存储计算结果。下次遇到相同组合时直接返回缓存值，避免重复计算。

在计算方法中使用缓存：

static int calculateDamageWithCache(
  String weapon,
  String hitLocation,
  String armorLevel,
) {
  int? cached = DamageCache.get(weapon, hitLocation, armorLevel);
  if (cached != null) return cached;
  
  int damage = calculateDamage(weapon, hitLocation, armorLevel);
  DamageCache.set(weapon, hitLocation, armorLevel, damage);
  return damage;
}

缓存命中：大多数情况下，用户会重复选择相同的武器和部位组合，缓存能显著提升响应速度。

测试与验证

单元测试

验证伤害计算的正确性：

void main() {
  test('M416 躯干 无防具 应该是 41 伤害', () {
    int damage = DamageCalculator.calculateDamage('M416', '躯干', '无防具');
    expect(damage, 41);
  });
  
  test('AWM 头部 三级防具 应该是 252 伤害', () {
    int damage = DamageCalculator.calculateDamage('AWM', '头部', '三级防具');
    expect(damage, (120 * 2.1 * 0.55).toInt());
  });
  
  test('100 血量 41 伤害 需要 3 枪', () {
    int shots = DamageCalculator.calculateShotsToKill('M416', '躯干', '无防具', 100);
    expect(shots, 3);
  });
}

测试覆盖：测试几个关键场景，确保计算逻辑正确。特别是边界情况（比如伤害不能整除血量）需要重点验证。

小结

伤害计算器从简单的数学运算发展到完整的游戏工具。关键要点包括：

• 准确的数据模型：武器伤害、防具系数、部位倍数都要符合游戏规则
• 流畅的交互体验：实时计算、清晰的视觉反馈、便捷的参数选择
• 性能考虑：缓存机制、合理的数据结构、避免不必要的重复计算
• 可维护性：模块化设计、清晰的代码结构、充分的测试覆盖

这个项目展示了如何将游戏机制转化为实用工具，帮助玩家做出更好的战术决策。

---

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net