技能系统

于 2024-12-29 01:17:47 发布
阅读量988 收藏 19
点赞数 20
分类专栏： MMORPG游戏技术专栏 文章标签： 技能系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/144797937
版权

设计一个游戏的技能系统可以使用多种设计模式来提高系统的灵活性和可扩展性。以下是一个基于常见设计模式的技能系统的设计示例，包括策略模式、工厂模式和观察者模式。

1. 策略模式

策略模式允许我们定义一系列算法（在这里是技能），并将它们封装在独立的类中，使得它们可以互换。这样可以在运行时选择不同的技能。

C#代码示例
// 技能接口
public interface ISkill
{
    void UseSkill(Character user, Character target);
}

// 具体技能实现
public class FireballSkill : ISkill
{
    public void UseSkill(Character user, Character target)
    {
        Console.WriteLine($"{user.Name} casts Fireball on {target.Name}!");
        target.TakeDamage(30);
    }
}

public class HealSkill : ISkill
{
    public void UseSkill(Character user, Character target)
    {
        Console.WriteLine($"{user.Name} heals {target.Name}!");
        target.Heal(20);
    }
}

// 角色类
public class Character
{
    public string Name { get; private set; }
    public int Health { get; private set; }

    public Character(string name, int health)
    {
        Name = name;
        Health = health;
    }

    public void TakeDamage(int amount)
    {
        Health -= amount;
        Console.WriteLine($"{Name} takes {amount} damage. Remaining health: {Health}");
    }

    public void Heal(int amount)
    {
        Health += amount;
        Console.WriteLine($"{Name} heals for {amount}. Current health: {Health}");
    }
}

2. 工厂模式

工厂模式可以用来创建技能实例，允许我们在不暴露具体实现的情况下创建对象。

C#代码示例
public static class SkillFactory
{
    public static ISkill CreateSkill(string skillType)
    {
        switch (skillType)
        {
            case "Fireball":
                return new FireballSkill();
            case "Heal":
                return new HealSkill();
            default:
                throw new ArgumentException("Invalid skill type");
        }
    }
}

3. 观察者模式

观察者模式可以用来实现技能的效果通知，例如，当技能被使用时，其他系统（如日志系统、UI更新等）可以被通知。

C#代码示例
public interface IObserver
{
    void Update(string message);
}

public class SkillLogger : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine($"Log: {message}");
    }
}

public class Skill
{
    private ISkill _skill;
    private List<IObserver> _observers;

    public Skill(ISkill skill)
    {
        _skill = skill;
        _observers = new List<IObserver>();
    }

    public void Attach(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Use(Character user, Character target)
    {
        _skill.UseSkill(user, target);
        NotifyObservers($"{user.Name} used {_skill.GetType().Name} on {target.Name}");
    }

    private void NotifyObservers(string message)
    {
        foreach (var observer in _observers)
        {
            observer.Update(message);
        }
    }
}

4. 整合示例

下面是一个简单的主程序，展示如何使用这些设计模式来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100);
        Character monster = new Character("Monster", 50);

        // 创建技能
        ISkill fireball = SkillFactory.CreateSkill("Fireball");
        ISkill heal = SkillFactory.CreateSkill("Heal");

        // 创建技能包装器
        Skill fireballSkill = new Skill(fireball);
        Skill healSkill = new Skill(heal);

        // 添加观察者
        SkillLogger logger = new SkillLogger();
        fireballSkill.Attach(logger);
        healSkill.Attach(logger);

        // 使用技能
        fireballSkill.Use(hero, monster);
        healSkill.Use(hero, hero);
    }
}

结论

通过使用策略模式、工厂模式和观察者模式，我们构建了一个灵活且可扩展的技能系统。这个系统允许我们轻松添加新技能、创建技能实例，并在技能使用时通知其他系统。

我们可以进一步扩展这个技能系统，增加更多的功能和复杂性。以下是一些可以考虑的扩展：

5. 技能冷却时间

我们可以为技能添加冷却时间，以限制技能的使用频率。这可以通过在技能类中添加冷却时间属性和逻辑来实现。

C#代码示例
public class SkillWithCooldown : ISkill
{
    public string Name { get; private set; }
    public int Cooldown { get; private set; }
    private int _lastUsedTime;

    public SkillWithCooldown(string name, int cooldown)
    {
        Name = name;
        Cooldown = cooldown;
        _lastUsedTime = -cooldown; // 允许立即使用
    }

    public bool CanUse(int currentTime)
    {
        return currentTime >= _lastUsedTime + Cooldown;
    }

    public void UseSkill(Character user, Character target, int currentTime)
    {
        if (!CanUse(currentTime))
        {
            Console.WriteLine($"{user.Name} cannot use {Name} yet! Cooldown remaining.");
            return;
        }

        _lastUsedTime = currentTime;
        Console.WriteLine($"{user.Name} uses {Name} on {target.Name}!");
        target.TakeDamage(30); // 示例伤害
    }
}

6. 技能效果

我们可以为技能添加不同的效果，例如伤害、治疗、增益或减益效果。可以使用策略模式来实现不同的效果。

C#代码示例
public interface ISkillEffect
{
    void Apply(Character user, Character target);
}

public class DamageEffect : ISkillEffect
{
    private int _damage;

    public DamageEffect(int damage)
    {
        _damage = damage;
    }

    public void Apply(Character user, Character target)
    {
        Console.WriteLine($"{user.Name} deals {_damage} damage to {target.Name}!");
        target.TakeDamage(_damage);
    }
}

public class HealEffect : ISkillEffect
{
    private int _healAmount;

    public HealEffect(int healAmount)
    {
        _healAmount = healAmount;
    }

    public void Apply(Character user, Character target)
    {
        Console.WriteLine($"{user.Name} heals {target.Name} for {_healAmount}!");
        target.Heal(_healAmount);
    }
}

// 修改技能类以支持效果
public class SkillWithEffect : ISkill
{
    private ISkillEffect _effect;

    public SkillWithEffect(ISkillEffect effect)
    {
        _effect = effect;
    }

    public void UseSkill(Character user, Character target)
    {
        _effect.Apply(user, target);
    }
}

7. 技能组合

我们可以允许玩家组合多个技能，形成复合技能。这可以通过创建一个复合技能类来实现。

C#代码示例
public class CompositeSkill : ISkill
{
    private List<ISkill> _skills;

    public CompositeSkill()
    {
        _skills = new List<ISkill>();
    }

    public void AddSkill(ISkill skill)
    {
        _skills.Add(skill);
    }

    public void UseSkill(Character user, Character target)
    {
        foreach (var skill in _skills)
        {
            skill.UseSkill(user, target);
        }
    }
}

8. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100);
        Character monster = new Character("Monster", 50);

        // 创建技能效果
        ISkillEffect fireballDamage = new DamageEffect(30);
        ISkillEffect healEffect = new HealEffect(20);

        // 创建技能
        ISkill fireball = new SkillWithEffect(fireballDamage);
        ISkill heal = new SkillWithEffect(healEffect);

        // 创建技能组合
        CompositeSkill comboSkill = new CompositeSkill();
        comboSkill.AddSkill(fireball);
        comboSkill.AddSkill(heal);

        // 使用技能
        comboSkill.UseSkill(hero, monster); // 使用组合技能
    }
}

9. 技能升级系统

我们可以为技能添加升级系统，使得技能在使用后可以获得经验并提升效果。

C#代码示例
public class UpgradableSkill : ISkill
{
    private ISkillEffect _effect;
    private int _level;
    private int _experience;

    public UpgradableSkill(ISkillEffect effect)
    {
        _effect = effect;
        _level = 1;
        _experience = 0;
    }

    public void UseSkill(Character user, Character target)
    {
        _effect.Apply(user, target);
        GainExperience(10); // 每次使用获得经验
    }

    private void GainExperience(int amount)
    {
        _experience += amount;
        if (_experience >= 100) // 升级条件
        {
            _level++;
            _experience = 0;
            Console.WriteLine($"Skill upgraded to level {_level}!");
            // 可以在这里增强技能效果
        }
    }
}

10. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100);
        Character monster = new Character("Monster", 50);

        // 创建技能效果
        ISkillEffect fireballDamage = new DamageEffect(30);
        ISkillEffect healEffect = new HealEffect(20);

        // 创建可升级技能
        UpgradableSkill fireball = new UpgradableSkill(fireballDamage);
        UpgradableSkill heal = new UpgradableSkill(healEffect);

        // 使用技能
        fireball.UseSkill(hero, monster); // 使用火球技能
        heal.UseSkill(hero, hero); // 使用治疗技能

        // 再次使用技能以获得经验
        fireball.UseSkill(hero, monster);
        fireball.UseSkill(hero, monster);
        fireball.UseSkill(hero, monster); // 可能会升级
    }
}

结论

通过以上的扩展，我们为技能系统增加了冷却时间、技能效果、技能组合和技能升级等功能。这使得技能系统更加丰富和灵活，能够满足更复杂的游戏需求。

我们可以继续扩展技能系统，增加更多的功能和复杂性。以下是一些可以考虑的扩展：

11. 技能目标选择

我们可以为技能添加目标选择机制，使得玩家可以选择单个目标或多个目标。可以通过定义目标选择策略来实现。

C#代码示例
public interface ITargetingStrategy
{
    List<Character> SelectTargets(Character user, List<Character> potentialTargets);
}

public class SingleTargetStrategy : ITargetingStrategy
{
    public List<Character> SelectTargets(Character user, List<Character> potentialTargets)
    {
        // 选择第一个目标
        return potentialTargets.Take(1).ToList();
    }
}

public class AreaOfEffectStrategy : ITargetingStrategy
{
    public List<Character> SelectTargets(Character user, List<Character> potentialTargets)
    {
        // 选择所有目标
        return potentialTargets;
    }
}

// 修改技能类以支持目标选择
public class TargetedSkill : ISkill
{
    private ISkillEffect _effect;
    private ITargetingStrategy _targetingStrategy;

    public TargetedSkill(ISkillEffect effect, ITargetingStrategy targetingStrategy)
    {
        _effect = effect;
        _targetingStrategy = targetingStrategy;
    }

    public void UseSkill(Character user, List<Character> potentialTargets)
    {
        var targets = _targetingStrategy.SelectTargets(user, potentialTargets);
        foreach (var target in targets)
        {
            _effect.Apply(user, target);
        }
    }
}

12. 技能冷却时间与状态效果

我们可以为技能添加状态效果，例如眩晕、减速等。这些状态效果可以在技能使用后施加到目标上。

C#代码示例
public interface IStatusEffect
{
    void Apply(Character target);
}

public class StunEffect : IStatusEffect
{
    public void Apply(Character target)
    {
        Console.WriteLine($"{target.Name} is stunned!");
        // 这里可以添加逻辑来阻止目标在下一回合行动
    }
}

// 修改技能效果以支持状态效果
public class DamageWithStatusEffect : ISkillEffect
{
    private int _damage;
    private IStatusEffect _statusEffect;

    public DamageWithStatusEffect(int damage, IStatusEffect statusEffect)
    {
        _damage = damage;
        _statusEffect = statusEffect;
    }

    public void Apply(Character user, Character target)
    {
        Console.WriteLine($"{user.Name} deals {_damage} damage to {target.Name}!");
        target.TakeDamage(_damage);
        _statusEffect.Apply(target);
    }
}

13. 技能组合与连击系统

我们可以实现一个连击系统，使得玩家可以通过连续使用特定技能来触发更强大的技能效果。

C#代码示例
public class ComboSkill : ISkill
{
    private List<ISkill> _skills;
    private int _comboCount;

    public ComboSkill()
    {
        _skills = new List<ISkill>();
        _comboCount = 0;
    }

    public void AddSkill(ISkill skill)
    {
        _skills.Add(skill);
    }

    public void UseSkill(Character user, Character target)
    {
        if (_comboCount < _skills.Count)
        {
            _skills[_comboCount].UseSkill(user, target);
            _comboCount++;
        }
        else
        {
            Console.WriteLine($"{user.Name} has completed the combo!");
            // 可以在这里触发额外效果
            _comboCount = 0; // 重置连击计数
        }
    }
}

14. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100);
        Character monster1 = new Character("Monster1", 50);
        Character monster2 = new Character("Monster2", 50);
        List<Character> monsters = new List<Character> { monster1, monster2 };

        // 创建技能效果
        ISkillEffect fireballDamage = new DamageWithStatusEffect(30, new StunEffect());
        ISkillEffect healEffect = new HealEffect(20);

        // 创建目标选择策略
        ITargetingStrategy singleTarget = new SingleTargetStrategy();
        ITargetingStrategy areaOfEffect = new AreaOfEffectStrategy();

        // 创建技能
        TargetedSkill fireball = new TargetedSkill(fireballDamage, singleTarget);
        TargetedSkill heal = new TargetedSkill(healEffect, singleTarget);

        // 创建连击技能
        ComboSkill comboSkill = new ComboSkill();
        comboSkill.AddSkill(fireball);
        comboSkill.AddSkill(heal);

        // 使用技能
        fireball.UseSkill(hero, monsters); // 使用火球技能
        heal.UseSkill(hero, hero); // 使用治疗技能
        comboSkill.UseSkill(hero, monster1); // 使用连击技能
        comboSkill.UseSkill(hero, monster1); // 继续连击
        comboSkill.UseSkill(hero, monster1); // 完成连击
    }
}

15. 技能的视觉效果与音效

在实际游戏中，技能的视觉效果和音效是非常重要的。虽然在代码中无法直接实现这些效果，但我们可以为技能添加视觉效果和音效的接口，以便在实际实现时进行扩展。

C#代码示例
public interface IVisualEffect
{
    void PlayEffect(Character user, Character target);
}

public interface ISoundEffect
{
    void PlaySound();
}

// 示例实现
public class FireballEffect : IVisualEffect
{
    public void PlayEffect(Character user, Character target)
    {
        Console.WriteLine($"Fireball effect plays from {user.Name} to {target.Name}!");
    }
}

public class FireballSound : ISoundEffect
{
    public void PlaySound()
    {
        Console.WriteLine("Fireball sound plays!");
    }
}

// 修改技能类以支持视觉效果和音效
public class SkillWithEffects : ISkill
{
    private ISkillEffect _effect;
    private IVisualEffect _visualEffect;
    private ISoundEffect _soundEffect;

    public SkillWithEffects(ISkillEffect effect, IVisualEffect visualEffect, ISoundEffect soundEffect)
    {
        _effect = effect;
        _visualEffect = visualEffect;
        _soundEffect = soundEffect;
    }

    public void UseSkill(Character user, Character target)
    {
        _visualEffect.PlayEffect(user, target);
        _soundEffect.PlaySound();
        _effect.Apply(user, target);
    }
}

16. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100);
        Character monster1 = new Character("Monster1", 50);
        List<Character> monsters = new List<Character> { monster1 };

        // 创建技能效果
        ISkillEffect fireballDamage = new DamageWithStatusEffect(30, new StunEffect());
        ISkillEffect healEffect = new HealEffect(20);

        // 创建视觉效果和音效
        IVisualEffect fireballVisual = new FireballEffect();
        ISoundEffect fireballSound = new FireballSound();

        // 创建技能
        SkillWithEffects fireball = new SkillWithEffects(fireballDamage, fireballVisual, fireballSound);
        SkillWithEffects heal = new SkillWithEffects(healEffect, null, null); // 没有视觉和音效

        // 使用技能
        fireball.UseSkill(hero, monster1); // 使用火球技能
        heal.UseSkill(hero, hero); // 使用治疗技能
    }
}

结论

通过以上的扩展，我们为技能系统增加了目标选择、状态效果、连击系统、视觉效果和音效等功能。这使得技能系统更加丰富和灵活，能够满足更复杂的游戏需求。

我们可以继续扩展技能系统，增加更多的功能和复杂性。以下是一些可以考虑的扩展：

17. 技能的属性依赖

我们可以为技能添加属性依赖，例如技能的伤害可以根据角色的力量、智力等属性进行计算。这可以通过在技能类中添加属性依赖逻辑来实现。

C#代码示例
public class AttributeBasedDamageEffect : ISkillEffect
{
    private int _baseDamage;
    private Func<Character, int> _attributeSelector; // 选择属性的函数

    public AttributeBasedDamageEffect(int baseDamage, Func<Character, int> attributeSelector)
    {
        _baseDamage = baseDamage;
        _attributeSelector = attributeSelector;
    }

    public void Apply(Character user, Character target)
    {
        int attributeValue = _attributeSelector(user);
        int totalDamage = _baseDamage + attributeValue; // 根据属性计算总伤害
        Console.WriteLine($"{user.Name} deals {totalDamage} damage to {target.Name}!");
        target.TakeDamage(totalDamage);
    }
}

18. 技能的元素属性

我们可以为技能添加元素属性，例如火、冰、雷等。不同的元素属性可以对不同的目标产生不同的效果。

C#代码示例
public enum Element
{
    Fire,
    Ice,
    Lightning,
    Earth
}

public class ElementalDamageEffect : ISkillEffect
{
    private int _baseDamage;
    private Element _element;

    public ElementalDamageEffect(int baseDamage, Element element)
    {
        _baseDamage = baseDamage;
        _element = element;
    }

    public void Apply(Character user, Character target)
    {
        int totalDamage = _baseDamage;

        // 根据元素属性调整伤害
        if (_element == Element.Fire && target.HasElementalWeakness(Element.Fire))
        {
            totalDamage *= 2; // 火元素对火弱点的目标造成双倍伤害
        }

        Console.WriteLine($"{user.Name} deals {totalDamage} {_element} damage to {target.Name}!");
        target.TakeDamage(totalDamage);
    }
}

19. 技能的施法范围

我们可以为技能添加施法范围，限制技能的使用距离。可以通过在技能类中添加范围属性和逻辑来实现。

C#代码示例
public class RangeRestrictedSkill : ISkill
{
    private ISkillEffect _effect;
    private int _range;

    public RangeRestrictedSkill(ISkillEffect effect, int range)
    {
        _effect = effect;
        _range = range;
    }

    public void UseSkill(Character user, Character target)
    {
        int distance = CalculateDistance(user, target);
        if (distance > _range)
        {
            Console.WriteLine($"{user.Name} is too far away to use this skill!");
            return;
        }

        _effect.Apply(user, target);
    }

    private int CalculateDistance(Character user, Character target)
    {
        // 这里可以实现实际的距离计算逻辑
        return 1; // 示例返回值
    }
}

20. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100, 10); // 假设角色有力量属性
        Character monster1 = new Character("Monster1", 50);
        monster1.SetElementalWeakness(Element.Fire); // 假设怪物对火元素有弱点

        // 创建技能效果
        ISkillEffect fireballDamage = new ElementalDamageEffect(30, Element.Fire);
        ISkillEffect healEffect = new HealEffect(20);

        // 创建范围限制技能
        RangeRestrictedSkill fireball = new RangeRestrictedSkill(fireballDamage, 5);
        RangeRestrictedSkill heal = new RangeRestrictedSkill(healEffect, 5);

        // 使用技能
        fireball.UseSkill(hero, monster1); // 使用火球技能
        heal.UseSkill(hero, hero); // 使用治疗技能
    }
}

21. 技能的状态管理

我们可以为技能添加状态管理功能，以便在技能使用后跟踪状态效果的持续时间和效果。

C#代码示例
public class StatusEffectWithDuration : IStatusEffect
{
    private int _duration;

    public StatusEffectWithDuration(int duration)
    {
        _duration = duration;
    }

    public void Apply(Character target)
    {
        Console.WriteLine($"{target.Name} is affected by a status effect for {_duration} turns!");
        // 这里可以添加逻辑来处理状态效果的持续时间
    }
}

22. 技能的组合与升级

我们可以实现技能的组合与升级系统，使得玩家可以通过组合技能来解锁更强大的技能。

C#代码示例
public class SkillCombination
{
    private List<ISkill> _skills;

    public SkillCombination()
    {
        _skills = new List<ISkill>();
    }

    public void AddSkill(ISkill skill)
    {
        _skills.Add(skill);
    }

    public void UseCombination(Character user, Character target)
    {
        foreach (var skill in _skills)
        {
            skill.UseSkill(user, target);
        }
        // 可以在这里添加组合技能的额外效果
    }
}

23. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100, 10);
        Character monster1 = new Character("Monster1", 50);
        monster1.SetElementalWeakness(Element.Fire);

        // 创建技能效果
        ISkillEffect fireballDamage = new ElementalDamageEffect(30, Element.Fire);
        ISkillEffect healEffect = new HealEffect(20);
        IStatusEffect stunEffect = new StatusEffectWithDuration(2);

        // 创建技能
        RangeRestrictedSkill fireball = new RangeRestrictedSkill(fireballDamage, 5);
        RangeRestrictedSkill heal = new RangeRestrictedSkill(healEffect, 5);
        ISkill stunSkill = new SkillWithEffect(stunEffect);

        // 创建技能组合
        SkillCombination combo = new SkillCombination();
        combo.AddSkill(fireball);
        combo.AddSkill(stunSkill);

        // 使用技能
        fireball.UseSkill(hero, monster1); // 使用火球技能
        heal.UseSkill(hero, hero); // 使用治疗技能
        combo.UseCombination(hero, monster1); // 使用技能组合
    }
}

24. 技能的冷却时间与状态效果

我们可以为技能添加冷却时间和状态效果的结合，使得技能在使用后需要等待一定时间才能再次使用。

C#代码示例
public class CooldownSkill : ISkill
{
    private ISkillEffect _effect;
    private int _cooldown;
    private int _lastUsedTime;

    public CooldownSkill(ISkillEffect effect, int cooldown)
    {
        _effect = effect;
        _cooldown = cooldown;
        _lastUsedTime = -cooldown; // 允许立即使用
    }

    public void UseSkill(Character user, Character target, int currentTime)
    {
        if (currentTime < _lastUsedTime + _cooldown)
        {
            Console.WriteLine($"{user.Name} cannot use this skill yet! Cooldown remaining.");
            return;
        }

        _lastUsedTime = currentTime;
        _effect.Apply(user, target);
    }
}

25. 整合示例

下面是一个简单的主程序，展示如何使用这些扩展功能来创建和使用技能。

C#代码示例
class Program
{
    static void Main(string[] args)
    {
        // 创建角色
        Character hero = new Character("Hero", 100, 10);
        Character monster1 = new Character("Monster1", 50);
        monster1.SetElementalWeakness(Element.Fire);

        // 创建技能效果
        ISkillEffect fireballDamage = new ElementalDamageEffect(30, Element.Fire);
        ISkillEffect healEffect = new HealEffect(20);
        IStatusEffect stunEffect = new StatusEffectWithDuration(2);

        // 创建技能
        CooldownSkill fireball = new CooldownSkill(fireballDamage, 3);
        CooldownSkill heal = new CooldownSkill(healEffect, 2);
        ISkill stunSkill = new SkillWithEffect(stunEffect);

        // 使用技能
        fireball.UseSkill(hero, monster1, 0); // 使用火球技能
        heal.UseSkill(hero, hero, 0); // 使用治疗技能
        fireball.UseSkill(hero, monster1, 1); // 再次使用火球技能
        fireball.UseSkill(hero, monster1, 4); // 冷却时间结束后再次使用
    }
}

结论

通过以上的扩展，我们为技能系统增加了属性依赖、元素属性、施法范围、状态管理、技能组合与升级、冷却时间等功能。这使得技能系统更加丰富和灵活，能够满足更复杂的游戏需求。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值