モンスターハンターで学ぶオブジェクト指向

// 基底クラス
public class Monster
{
    public string Name;
    public int MaxHP;
    public int CurrentHP;

    public Monster(string name, int maxHP)
    {
        Name      = name;
        MaxHP     = maxHP;
        CurrentHP = maxHP;
    }

    public virtual void TakeTurn()
    {
        Console.WriteLine($"{Name} は様子をうかがっている…");
    }
}

// 大型モンスター
public class LargeMonster : Monster
{
    public bool CanFly;

    public LargeMonster(string name, int maxHP, bool canFly)
        : base(name, maxHP)
    {
        CanFly = canFly;
    }

    public override void TakeTurn()
    {
        Roar();                 // 大型だけが持つ行動
    }

    public void Roar()
    {
        Console.WriteLine($"{Name} が咆哮！　ハンターは耳をふさぐ");
    }
}

// 小型モンスター
public class SmallMonster : Monster
{
    public SmallMonster(string name, int maxHP)
        : base(name, maxHP) { }

    public override void TakeTurn()
    {
        Console.WriteLine($"{Name} が小突いてきた！");
    }
}

// ---------------- 使う側 ----------------
var mizutsune = new LargeMonster("タマミツネ", 3200, canFly:false);
var jagras    = new SmallMonster("ジャグラス", 240);

Monster[] field = { mizutsune, jagras };

foreach (Monster m in field)
{
    m.TakeTurn();      // 基底型でまとめて扱える！
}

// 型固有のメンバーにアクセスしたい場合はキャスト or 'is' パターン
if (mizutsune is LargeMonster lm && lm.CanFly)
{
    Console.WriteLine($"{lm.Name} は空中へ舞い上がった！");
}

何がポイントか

1. ポリモーフィズム
   Monster[] に派生クラスを混在させ、TakeTurn() を呼ぶだけで大型・小型それぞれの挙動に自動で切り替わります。
2. 共通化と差分最小化
   HP など共通プロパティは基底 Monster に集約し、派生クラスでは“差分”だけを書くので重複が減ります。
3. 型固有機能の呼び出し
   フィールドやメソッドが派生にしか無い場合は、is パターンマッチやキャストで呼び分ければ OK。（Unity の GetComponent<LargeMonster>() も同じ発想です）

この使い方を実演すると、「同じ配列で扱えるのに、動きはモンスターごとに違う」という“継承＋ポリモーフィズム”の威力が直感的に伝わります。

// ---------------- インターフェースと実装 ----------------
public interface IAttackable
{
    void Attack(Monster target);
}

// ハンター
public class Hunter : IAttackable
{
    public string Name;
    public Weapon Equipped;

    public Hunter(string name, Weapon weapon)
    {
        Name = name;
        Equipped = weapon;
    }

    public void Attack(Monster target)
    {
        int dmg = Equipped.CalcDamage();
        target.TakeDamage(dmg);
        Console.WriteLine($"{Name} が {Equipped.Type} で {dmg} ダメージ！");
    }
}

// オトモアイルー
public class Palico : IAttackable
{
    public string Nickname;

    public Palico(string nickname) => Nickname = nickname;

    public void Attack(Monster target)
    {
        int dmg = 30;
        target.TakeDamage(dmg);
        Console.WriteLine($"アイルー {Nickname} がサポート攻撃！（{dmg} ダメージ）");
    }
}

// 置き型爆弾
public class BarrelBomb : IAttackable
{
    public int Power;

    public BarrelBomb(int power) => Power = power;

    public void Attack(Monster target)
    {
        target.TakeDamage(Power);
        Console.WriteLine($"大タル爆弾が爆発！ {Power} ダメージ！");
    }
}

// （参照用）簡易モンスター
public class Monster
{
    public string Name;
    public int CurrentHP;

    public Monster(string name, int hp)
    {
        Name = name;
        CurrentHP = hp;
    }

    public void TakeDamage(int amount)
    {
        CurrentHP = Math.Max(CurrentHP - amount, 0);
        Console.WriteLine($"{Name} の残り HP: {CurrentHP}");
    }
}

// ---------------- 使う側 ----------------
Weapon gs = new Weapon { Type = "大剣", BasePower = 180 };
IAttackable[] attackers =
{
    new Hunter("コニシ", gs),
    new Palico("モモ"),
    new BarrelBomb(300)
};

Monster rathalos = new Monster("リオレウス", 1000);

// まとめて攻撃！
foreach (IAttackable atk in attackers)
{
    atk.Attack(rathalos);
}

ここで押さえておきたいポイント

実演アイデア

• 配列に “爆弾だけ” 追加して再実行 → コード修正ゼロ で新しい攻撃が機能する様子を見せる
• IAttackable を実装していないオブジェクトを配列に入れようとすると コンパイルエラー になることを確認し、型安全性を体感させる

このように インターフェース＝「できること」の約束 を軸に設計すると、ゲームでも業務アプリでも “将来の拡張” がラクになることが直感的に理解できます。