7.7. Unity scripting with C# - Basics: Understanding inheritance and polymorphism

When diving into Unity scripting with C#, understanding the concepts of inheritance and polymorphism is crucial for creating flexible and maintainable code. These object-oriented programming principles allow you to create systems that are easy to extend and modify, which is particularly beneficial in game development where requirements can frequently change.

Inheritance in C# is a mechanism that allows one class to inherit fields and methods from another class. The class that inherits is called the derived class, and the class from which it inherits is the base class. This relationship allows you to create a hierarchy of classes that share a common structure and behavior, reducing redundancy and promoting code reuse.

Consider a simple example where you have a base class called Character which has properties like health and name, and methods like TakeDamage() and Attack(). You can then create derived classes such as Warrior and Mage that inherit from Character. These derived classes can have additional properties and methods specific to their roles, like Mana for Mage or Strength for Warrior.

public class Character
{
    public string Name { get; set; }
    public int Health { get; set; }

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

    public void TakeDamage(int damage)
    {
        Health -= damage;
        Debug.Log(Name + " takes " + damage + " damage.");
    }

    public virtual void Attack()
    {
        Debug.Log(Name + " attacks!");
    }
}

public class Warrior : Character
{
    public int Strength { get; set; }

    public Warrior(string name, int health, int strength) : base(name, health)
    {
        Strength = strength;
    }

    public override void Attack()
    {
        Debug.Log(Name + " swings a sword with strength " + Strength + "!");
    }
}

public class Mage : Character
{
    public int Mana { get; set; }

    public Mage(string name, int health, int mana) : base(name, health)
    {
        Mana = mana;
    }

    public override void Attack()
    {
        Debug.Log(Name + " casts a spell using " + Mana + " mana!");
    }
}

In the above example, both Warrior and Mage override the Attack() method to provide specific implementations. This is where polymorphism comes into play. Polymorphism allows you to treat objects of different derived classes through a common interface, typically provided by the base class.

With polymorphism, you can write code that works with objects of the base class type, but at runtime, the correct derived class method is called. This is achieved through method overriding, where a derived class provides a specific implementation of a method that is already defined in its base class. The virtual keyword in the base class method and the override keyword in the derived class method play a crucial role in this mechanism.

Let’s see how polymorphism works in practice:

public class Game
{
    public void Start()
    {
        Character[] characters = new Character[]
        {
            new Warrior("Aragorn", 100, 20),
            new Mage("Gandalf", 80, 50)
        };

        foreach (Character character in characters)
        {
            character.Attack();
        }
    }
}

In the Game class, we have an array of Character objects. However, the actual objects are of type Warrior and Mage. When the Attack() method is called in the loop, the runtime determines which version of the method to execute based on the actual object type. This is a demonstration of polymorphism, where the same method call results in different behavior depending on the object's type.

Inheritance and polymorphism are powerful tools, but they should be used judiciously. Overusing inheritance can lead to complex hierarchies that are difficult to maintain. It’s often beneficial to use composition over inheritance when possible, where you build classes by combining simple, reusable components.

In Unity, these concepts are particularly useful when dealing with game objects and their behaviors. By creating a base class for a common set of behaviors and then deriving specific behaviors for different game objects, you can create a flexible system that is easy to extend. For example, you might have a base class Enemy with methods for movement and attack, and then derive specific enemy types like Zombie or Dragon that have unique behaviors.

While inheritance allows you to share code among classes, polymorphism enables you to use those classes interchangeably, which is particularly beneficial in scenarios like event handling, where different types of events might be processed through a common interface. This flexibility is a cornerstone of creating robust systems that can adapt to changing requirements, a common scenario in game development.

In conclusion, mastering inheritance and polymorphism in C# is essential for any Unity developer. It not only helps in reducing code duplication but also enhances the scalability and maintainability of the game code. As you continue to develop your skills in Unity, keep these principles in mind to create efficient and dynamic game systems.