OOP 中的表达类型组合

Question

假设我们要编写一个具有 3 种基本角色类型的 RPG 游戏：战士、法师和弓箭手。 我们还结合了骑士、圣骑士和游侠等角色类型。在 TypeScript 中，我们可以像这样描述字符的接口：

    // fighter can fight
    // mage can cast
    // archer can shoot
    // paradin can cast and fight
    // knight can fight and shoot
    // ranger can cast and shoot

    type Fighter = {fight: () => string}
    type Mage = {cast: () => string}
    type Archer = {shoot: () => string}
    type Knight = Fighter & Archer
    type Paladin = Fighter & Mage
    type Ranger = Archer & Mage

问题是如何仅使用 OOP 技术来实现这些接口（假设我们正在使用 C# 等主流 OOP 语言）？

我没有成功地用没有重复行为的继承来表达这一点。目前我看到的唯一方法是：

class Paladin {
  constructor(private fighter: Fighter, private mage: Mage) {}

  fight() {this.fighter.fight()}
  cast() {this.mage.cast()}
}

但我不喜欢这种方法，因为任何时候我想创造一个圣骑士，我也必须创造一个法师和一个战士，基本上是同一个人

Answer 1

也许尝试进一步推动你的作文。你只需要一种具有不同能力的类型，例如：

public class Hero
{
    private readonly string name;
    private readonly IEnumerable<IHeroAbility> abilities;

    public Hero(string name, [Optional] IEnumerable<IHeroAbility> abilities)
    {
        this.name = name;
        this.abilities = abilities ?? new List<IHeroAbility> { new OhCrap() };
    }

    public void Attack()
    {
        Console.WriteLine(name);

        foreach (var ability in abilities) ability.Execute();

        Console.WriteLine();
    }
}

现在准备可用的能力：

public interface IHeroAbility
{
    void Execute();
}

public class SwingSwordAbility : IHeroAbility
{
    public void Execute()
    {
        Console.WriteLine("And with all his might the hero swung his sword down onto his opponent...");
    }
}

public class ShootArrowAbility : IHeroAbility
{
    public void Execute()
    {
        Console.WriteLine("The hero loads an arrow into his bow without blinking and launches it with fierce speed towards his opponant...");
    }
}

public class CastFireBallAbility : IHeroAbility
{
    public void Execute()
    {
        Console.WriteLine("The hero reaches deep into the underverse and hurls a ball of fire towards his opponant...");
    }
}

public class OhCrap : IHeroAbility
{
    public void Execute()
    {
        Console.WriteLine("The hero pats his pockets as if he forgot something at home...");
    }
}

然后组成你的英雄类型：

class Program
{
    static void Main(string[] args)
    {
        IHeroAbility swingSwordAbility = new SwingSwordAbility();
        IHeroAbility shootArrowAbility = new ShootArrowAbility();
        IHeroAbility castFireBallAbility = new CastFireBallAbility();

        var fighter = new Hero("The Fighter", new[] { swingSwordAbility });
        fighter.Attack();

        var mage = new Hero("The Mage", abilities: new[] { castFireBallAbility });
        mage.Attack();

        var archer = new Hero("The Archer", abilities: new[] { shootArrowAbility });
        archer.Attack();

        var knight = new Hero("The Knight", abilities: new[] { swingSwordAbility, shootArrowAbility });
        knight.Attack();

        var paladin = new Hero("The Paladin", abilities: new[] { swingSwordAbility, castFireBallAbility });
        paladin.Attack();

        var ranger = new Hero("The Ranger",abilities: new[] { shootArrowAbility, castFireBallAbility });
        ranger.Attack();

    }
}

如果您想要更明确的操作组，您可以将 Hero 类修改为如下内容：

public class Hero
{
    private readonly string name;
    private readonly IEnumerable<IHeroAbility> meleeAbilities;
    private readonly IEnumerable<IHeroAbility> magicAbilities;
    private readonly IEnumerable<IHeroAbility> rangedAbilities;

    public Hero(
        string name,
        [Optional] IEnumerable<IHeroAbility> meleeAbilities,
        [Optional] IEnumerable<IHeroAbility> magicAbilities,
        [Optional] IEnumerable<IHeroAbility> rangedAbilities)
    {
        this.name = name;

        var defaultAbilities = new List<IHeroAbility> { new OhCrap() };
        this.meleeAbilities = meleeAbilities ?? defaultAbilities;
        this.magicAbilities = magicAbilities ?? defaultAbilities;
        this.rangedAbilities = rangedAbilities ?? defaultAbilities;
    }

    public void MeleeAttack()
    {
        var ability = meleeAbilities.First();
        Console.WriteLine(name);
        ability.Execute();
    }

    public void MagicAttack()
    {
        var ability = magicAbilities.First();
        Console.WriteLine(name);
        ability.Execute();
    }

    public void RangedAttack()
    {
        var ability = rangedAbilities.First();
        Console.WriteLine(name);
        ability.Execute();
    }

}

然后您可以开始构建它以包含更复杂的逻辑，例如与技能、冷却时间、技能选择等相关的成本等。

希望这会有所帮助！

Answer 2

您的Paladin 类对Composite design pattern 是封闭的，并且可以按原样转换为C#，也许在这里和那里有一些readonly 来改进它。

使用 Composition（此处为 Forwarding）被认为是一种比使用继承更强大的设计（请参阅 Composition over inheritance），但它可能感觉不那么自然，这就是为什么 IMO 你说：

但我不喜欢这种方法，因为任何时候我想创造一个圣骑士，我还必须创造一个法师和一个战士，这基本上是同一个人。

“同一个人”在语义上与继承的相关性高于组合，但会导致设计更加脆弱。从角色或能力的角度思考 (*) 更加灵活：Healer，Druid 不是一个人，而是一个人/玩家/角色可以拥有的能力。

(*) 术语取自Albert's answer，但我仍然更喜欢您的解决方案更简单和明确。为了更进一步，我们需要一个参考场景列表和/或一个正在运行的原型（或任何现有程序）来评估设计和代码......

Answer 3

为此，我建议使用“装饰器设计模式”。

之后你可以让你的主角添加一些带有装饰器的特定行为。例如：

var  Fighter = new Charactermaker();
var  Mage  = new Charactermaker();
var  Archer = new Charactermaker();

KnifeDecorator addKnight = new KnifeDecorator(Fighter);
Paladin Decorator addPaladin= new PaladinDecorator(addKnight);

我有一些建议给你。您还可以使用“轻量级设计模式”来简化您的应用程序。它允许您通过在多个对象之间共享状态的公共部分而不是将所有数据保留在每个对象中，从而将更多对象放入可用的 RAM 量。

有关更多信息，您可以查看流动链接：

Decorator Design Pattern