Object-Oriented Programming for Games

# CHAPTER 5

Object-Oriented Programming for Games #

1. Introduction #

2. Learning Objectives #

• Define a Class to act as a blueprint for game entities.

• Instantiate new Objects from a Class in memory.

• Understand Encapsulation (Public vs. Private access modifiers).

• Use Inheritance to create subclasses (e.g., Orc inherits from Enemy).

• Understand Polymorphism (Overriding base behaviors).

3. Classes and Objects (The Blueprint and the House) #

// The Blueprint (Class)
public class Player
{
    public string Name;
    public int Health = 100;

    public void TakeDamage(int amount)
    {
        Health -= amount;
    }
}

// Building the Object (Instantiating)
Player player1 = new Player(); // Creates a new Player in memory
player1.Name = "Arthur";       // Accessing its specific variables
player1.TakeDamage(20);        // Calling its specific method

4. Encapsulation (Protecting the Data) #

• public: Any other script can see and change this variable.

• private: Only the script it lives inside can see or change it. (This is the default).

5. Inheritance (Sharing the DNA) #

// Parent Class (Base)
public class Enemy
{
    public int Health = 50;
    public void Walk() { Console.WriteLine("Walking..."); }
}

// Child Class (Derived) uses the colon ':' to inherit
public class Dragon : Enemy 
{
    public void BreatheFire() { Console.WriteLine("FWOOSH!"); }
}

// The Dragon gets 'Walk()' and 'Health' automatically for free!

6. Polymorphism (Overriding Behavior) #

• You mark the parent method as virtual (meaning it *can* be changed).

• You mark the child method as override (meaning "ignore the parent, do it my way").

public class Enemy {
    public virtual void Attack() { Console.WriteLine("Punch!"); }
}

public class Dragon : Enemy {
    public override void Attack() { Console.WriteLine("Fireball!"); }
}

7. Visual Learning: Inheritance Tree #

                  [ Class: Enemy ]
                  - int Health
                  - void TakeDamage()
                         |
           +-------------+-------------+
           |                           |
[ Class: Goblin ]             [ Class: Dragon ]
- void StealGold()            - void BreatheFire()
- override Attack()           - override Attack()

8. Best Practices #

• Composition over Inheritance: While Inheritance is powerful, don't create massive, 10-layer deep family trees (e.g., Entity -> Living -> Enemy -> Boss -> Dragon). It becomes impossible to maintain. Modern game engines (like Unity) heavily favor *Composition*—attaching small, reusable Component scripts (like a HealthComponent and a FireComponent) to an empty GameObject.

9. Common Mistakes #

• Null Reference Exceptions: A beginner writes Player myPlayer; and then immediately tries to write myPlayer.TakeDamage(10);. The game instantly crashes. Why? Because Player myPlayer; only creates an empty label. You MUST use the new keyword (myPlayer = new Player();) to actually build the object in the computer's RAM before you can use it!

10. Mini Project: Build an RPG Battle System #

1. 1. Open your Console App. Replace the code with:

using System;

// 1. The Base Class
public class Character
{
    public string Name;
    public int Health = 100;

    public virtual void Attack(Character target)
    {
        Console.WriteLine(Name + " attacks " + target.Name + " for 10 damage!");
        target.Health -= 10;
    }
}

// 2. The Child Class
public class Boss : Character
{
    public override void Attack(Character target)
    {
        Console.WriteLine(Name + " uses MEGA SMASH on " + target.Name + " for 40 damage!");
        target.Health -= 40;
    }
}

class Program
{
    static void Main()
    {
        // 3. Instantiate Objects
        Character hero = new Character();
        hero.Name = "Arthur";

        Boss evilKing = new Boss();
        evilKing.Name = "Sauron";
        evilKing.Health = 500;

        // 4. Battle!
        hero.Attack(evilKing);
        evilKing.Attack(hero);

        Console.WriteLine(hero.Name + " HP: " + hero.Health);
        Console.WriteLine(evilKing.Name + " HP: " + evilKing.Health);
    }
}

11. Practice Exercises #

1. 1. What keyword is used in C# to create a brand new instance of an object in memory?

1. 2. Explain the difference between public and private access modifiers.

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the four pillars of Object-Oriented Programming (Encapsulation, Inheritance, Polymorphism, Abstraction) and provide a concrete game development example for each.

• Q: A junior developer receives a NullReferenceException when calling player.Attack(). Explain what this error means in the context of Classes and Objects, and how the new keyword prevents it.

• Q: Contrast Inheritance with Composition. Why do modern engines like Unity prefer a Component-based architecture over deep Inheritance trees?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #