如何在C#中不使用大量数组精简重复的技能冷却代码？

核心思路 #

将每个技能的冷却状态（isCooldown、cooldownTimer、冷却时长等）单独封装，用一个统一容器管理所有技能的状态，避免多数组同步的冗余和冲突，同时复用通用的冷却更新/检查函数。

方法1：用对象/字典封装单技能状态（适合脚本语言） #

以JavaScript为例，用对象存储单个技能的冷却属性，再通过字典映射所有技能：

// 初始化所有技能的冷却状态，key为技能标识
const skillCooldowns = {
  fireBall: { isCooldown: false, cooldownTimer: 0, duration: 5 },
  frostNova: { isCooldown: false, cooldownTimer: 0, duration: 8 },
  thunderStrike: { isCooldown: false, cooldownTimer: 0, duration: 10 },
  heal: { isCooldown: false, cooldownTimer: 0, duration: 15 }
};

// 通用冷却更新函数
function updateCooldown(skillName, deltaTime) {
  const skill = skillCooldowns[skillName];
  if (skill.isCooldown) {
    skill.cooldownTimer -= deltaTime;
    if (skill.cooldownTimer <= 0) {
      skill.isCooldown = false;
      skill.cooldownTimer = 0;
    }
  }
}

// 通用技能释放检查函数
function canCastSkill(skillName) {
  const skill = skillCooldowns[skillName];
  if (!skill.isCooldown) {
    skill.isCooldown = true;
    skill.cooldownTimer = skill.duration;
    return true;
  }
  return false;
}

• 优势：每个技能状态独立封装，不会出现逻辑冲突；仅用一个容器管理，空间占用远低于多数组；新增技能只需在字典中添加新对象，无需修改核心函数。

方法2：用自定义类封装冷却逻辑（适合面向对象语言） #

以Python为例，通过类封装冷却属性与行为，实例化每个技能的冷却对象：

class SkillCooldown:
    def __init__(self, duration):
        self.is_cooldown = False
        self.cooldown_timer = 0
        self.duration = duration

    # 内置冷却更新方法
    def update(self, delta_time):
        if self.is_cooldown:
            self.cooldown_timer -= delta_time
            if self.cooldown_timer <= 0:
                self.is_cooldown = False
                self.cooldown_timer = 0

    # 内置释放检查方法
    def can_cast(self):
        if not self.is_cooldown:
            self.is_cooldown = True
            self.cooldown_timer = self.duration
            return True
        return False

# 初始化技能冷却实例
skill_cooldowns = {
    "fire_ball": SkillCooldown(5),
    "frost_nova": SkillCooldown(8),
    "thunder_strike": SkillCooldown(10),
    "heal": SkillCooldown(15)
}

# 调用示例
skill_cooldowns["fire_ball"].update(1)
if skill_cooldowns["fire_ball"].can_cast():
    print("释放火球术")

• 优势：逻辑内聚性更强，后续扩展冷却相关功能（比如冷却缩减）时，只需修改类的实现；代码可读性更高，技能状态与行为绑定。

方法3：用Map存储动态技能（适合技能数量不固定的场景） #

以C#为例，用Dictionary存储技能ID与冷却对象的映射，支持动态添加/删除技能：

public class SkillCooldown
{
    public bool IsCooldown { get; set; }
    public float CooldownTimer { get; set; }
    public float Duration { get; set; }

    public SkillCooldown(float duration)
    {
        Duration = duration;
        IsCooldown = false;
        CooldownTimer = 0;
    }
}

// 初始化技能冷却字典
Dictionary<int, SkillCooldown> skillCooldowns = new Dictionary<int, SkillCooldown>
{
    { 1, new SkillCooldown(5f) },
    { 2, new SkillCooldown(8f) },
    { 3, new SkillCooldown(10f) },
    { 4, new SkillCooldown(15f) }
};

// 通用更新方法
public void UpdateCooldown(int skillId, float deltaTime)
{
    if (skillCooldowns.TryGetValue(skillId, out var skill))
    {
        if (skill.IsCooldown)
        {
            skill.CooldownTimer -= deltaTime;
            if (skill.CooldownTimer <= 0)
            {
                skill.IsCooldown = false;
                skill.CooldownTimer = 0;
            }
        }
    }
}

// 通用释放检查方法
public bool CanCastSkill(int skillId)
{
    if (skillCooldowns.TryGetValue(skillId, out var skill))
    {
        if (!skill.IsCooldown)
        {
            skill.IsCooldown = true;
            skill.CooldownTimer = skill.Duration;
            return true;
        }
    }
    return false;
}

• 优势：支持动态增减技能，无需提前定义所有技能的结构；键值对映射避免了数组索引同步的问题，逻辑更安全。

内容的提问来源于stack exchange，提问作者polelord