多个委托分配和调用在一个c#纸牌游戏的动作结构

本文关键字：纸牌游戏 一个 结构 分配 调用 | 更新日期: 2023-09-27 17:54:28

我正在用c#开发一款纸牌游戏，我不知道如何做以下事情:

我有我的Card类，它有一个动作列表，这些动作是该卡可以执行的攻击。

这些攻击是一个名为Act的自定义类(在这个例子中我称之为Rules)。

当我加载卡片时，我调用我创建的initialize方法来初始化卡片列表，以及每张卡片的攻击列表。

我希望能够将我的攻击表达为带有参数的多个方法调用，这些参数只有在我调用该攻击执行时才会被调用。

例如，像这样的

ActionList = new List<CardRule>();
        ActionList.Add(new CardRule()
        {
            Description = "Cause 20 damage, then causes burn status.",
            Rules = Damage(20).CauseStatus(Status.Burn);
        });

我想定义这个动作(我称之为Rules)作为一个多方法调用，传递参数，

调用Rules.Execute()来执行所有的方法调用，等等。

我知道这与委托有关，但我不知道如何调用多个带有预定义参数的方法。

提前谢谢你，很抱歉我的英语不好，我也是Stack Overflow的新手。

认为,

多个委托分配和调用在一个c#纸牌游戏的动作结构

你要找的实际上不是一个委托，而是一个跟踪需要做什么的类。这是流畅api经常使用的模式，但是为您的示例创建一些东西相对简单。

对于您的示例，您可能有一个IActionConfiguration接口，例如:

public interface IActionConfiguration
{
    void PerformAction(MyTarget target);
}

现在，您需要几个不同的实现。例如，表示损坏的一个:

class DamageActionConfiguration : IActionConfiguration
{
    private int m_damageStrength;
    public DamageActionConfiguration(int strength)
    {
        m_damageStrength = strength;
    }
    public void PerformAction(MyTarget target)
    {
        target.Health -= strength;
    }
}

另一个表示状态效果:

class CauseStatusActionConfiguration : IActionConfiguration
{
    private Status m_status;
    public CauseStatusActionConfiguration(Status status)
    {
        m_status = status;
    }
    public void PerformAction(MyTarget target)
    {
        target.StatusEffects.Add(m_status);
    }
}

现在，您还将创建一个表示多个操作的实现。

class CompositeActionConfiguration : IActionConfiguration
{
    private IActionConfiguration m_firstWrappedConfiguration;
    private IActionConfiguration m_secondWrappedConfiguration;
    public CompositeActionConfiguration(IActionConfiguration first, IActionConfiguration second)
    {
        m_firstWrappedConfiguration = first;
        m_secondWrappedConfiguration = second;
    }
    public void PerformAction(MyTarget target)
    {
        m_firstWrappedConfiguration.PerformAction();
        m_secondWrappedConfiguration.PerformAction();
    }
}

这是令人难以置信的简化，但对于我们的例子来说已经足够好了。现在，您有了一个类(CompositeActionConfiguration)，它可以表示多个动作——您所需要的只是让您可以轻松地将它们链接在一起的魔力。

public static class ActionRules
{
    //First, you want a few static methods which can start a chain:
    public static IActionConfiguration Damage(int strength)
    {
        return new DamageActionConfiguration(strength);
    }
    public static IActionConfiguration Status(Status status)
    {
        return new CauseStatusActionConfiguration(status);
    }
    // Next, some extension methods which allow you to chain things together
    // This is really the glue that makes this whole solution easy to use
    public static IActionConfiguration WithDamage(this IActionConfiguration source, int strength)
    {
        return new CompositeActionConfiguration(source, Damage(strength));
    }
    public static IActionConfiguration WithStatus(this IActionConfiguration source, Status status)
    {
        return new CompositeActionConfiguration(source, Status(status));
    }
}

就是这样。这给了你一个或多或少你想要的解决方案。你可以将你的Rules属性定义为IActionConfiguration，然后你可以像这样使用它:

var card = new CardRule()
{
    Description = "Cause 20 damage, then causes burn status.",
    Rules = ActionRules.Damage(20).WithStatus(Status.Burn);
};
card.PerformAction(target);
相关文章：