CHAPTER 25

CLASSES

1
 Topics
 Understanding Classes
– The Anatomy of a Class
 Class Inheritance
– Superclasses and Subclasses
– Virtual and Override

2
 Understanding Classes
 Classes are the key concept in Object-Oriented
Programming
 A class is a definition of a type of object
 There can be many instances of a single class
– Each person in this classroom could be thought of as an
instance of the Human class
 C# classes combine data and functionality
– Classes have variables, which are called fields
– Classes have functions, which are called methods
 You're already using classes!
– Each C# script you've written is a class
 Classes represent objects in your game

3
 Understanding Classes
 Example: A character in a standard RPG
– Fields you would want for each character
string name; // The character's name
float health; // The amount of health she
has
float healthMax; // Her maximum amount of
health
List<Item> inventory; // List of Items in her inventory
List<Item> equipped; // A List of Items she has equipped

– Methods you would want

void Move(Vector3 newLoc) {…} // Moves her to newLoc
void Attack(Character target) {…} // Attacks target with the
current weapon or spell
void TakeDamage(float dmgAmt) {…} // Reduces health
void Equip(Item newItem) {…} // Adds an Item to the
equipped List

4
The Anatomy of a Class

Includes
The Class Declaration
Fields

Methods

Properties

p.s. Line numbers are handled automatically by MonoDevelop

5
 The Anatomy of a Class
 We'll explore each part of a class named Enemy
– The Enemy class is for a simple top-down space shooter game
– An Enemy instance moves down the screen at a speed of 10
 Includes
– Include code libraries in your project
– Enables standard Unity libraries and objects
• e.g., GameObject, MonoBehaviour, Transform, Renderer, etc.
1 using UnityEngine; // Required for
Unity
2 using System.Collections; // Included by
Unity's default
3 using System.Collections.Generic; // Required to use a List

 The Class Declaration

– Declares the name of the class and its superclass
– Enemy is a class that extends its superclass MonoBehaviour
5 public class Enemy : MonoBehaviour {
6
 The Anatomy of a Class
 Fields
– Fields are variables that are part of the class
– Fields marked public are able to be seen by other classes and by
other instances of this class
– Fields marked private are only able to be seen by this one
instance of a class
• Private fields are secrets
• They are also a safer way to program than always using public fields
• Public fields are used throughout the book so that the field values appear
and are editable in the Unity Inspector

7 public float speed = 10f; // The speed in

m/s
8 public float fireRate = 0.3f; // Shots per
second (Unused)

• Declares two public fields for all instances of the Enemy class
• Each instance has its own value for speed and fireRate
7
 The Anatomy of a Class
 Methods
– Functions that are part of the class
– Can also be marked public or private

11 void Update() {
12 Move();
13 }
14
15 public virtual void Move() { // Move down the screen
at speed
16 Vector3 tempPos = pos;
17 tempPos.y -= speed * Time.deltaTime; // Makes it
Time-Based!
18 pos = tempPos;
19 }

– Note that Move is a virtual function

• Virtual functions can be overridden by functions of the same name in a
subclass (we'll cover this shortly)
8
 The Anatomy of a Class
 Properties
– Properties are methods masquerading as fields
– Properties can only exist within classes

35 public Vector3 pos {

36 get {
37 return( this.transform.position );
38 }
39 set {
40 this.transform.position = value;
41 }
42 }

– This property simplifies setting the transform.position of

this Enemy

9
 Class Instances as Components
 In Unity, all class instances are treated as GameObject
Components
– The class instance can be accessed using GetComponent<>()

Enemy thisEnemy =
this.gameObject.GetComponent<Enemy>();

– From there, any public variable can be accessed

thisEnemy.speed = 20f; // Increase speed of this Enemy

to 20

– Many C# scripts can be attached to a single GameObject

10
 Class Inheritance
 Most classes inherit from another class
5 public class Enemy : MonoBehaviour {…}

 Enemy inherits from MonoBehaviour

– Enemy is the subclass of MonoBehavior
– MonoBehavior is called the superclass, base class, or parent
class of Enemy
– This means that Enemy inherits all of MonoBehaviour's fields
and methods
• Example inherited fields:
– gameObject, transform, renderer, etc.
• Example inherited methods:
– GetComponent<>(), Invoke(), StartCoroutine(), etc.
• Inheriting from MonoBehaviour is what makes Enemy able to act like a
GameObject component

11
 Class Inheritance
 We can create a class that inherits from Enemy!
1 using UnityEngine;
2 using System.Collections;
3
4 public class EnemyZig : Enemy {
5 // EnemyZig inherits ALL its behavior from Enemy
6 }

 If this class is attached to a different GameObject, that

GameObject will act exactly like an Enemy
– It will also move down the screen at a rate of 10m/second
 Move() can be overridden because it is a virtual function
– This means that EnemyZig can have its own version of Move()!

12
 Class Inheritance
 EnemyZig.Move() overrides Enemy.Move()
4 public class EnemyZig : Enemy {
5 public override void Move () {
6 Vector3 tempPos = pos;
7 tempPos.x = Mathf.Sin(Time.time * Mathf.PI*2) *
4;
8 pos = tempPos; // Uses the pos property of
the superclass
9 base.Move(); // Calls Move() on the
superclass
10 }
11 }

– Now, when the Update() method in Enemy calls Move(),

EnemyZig instances will use EnemyZig.Move() instead
• This moves the EnemyZig instance back and forth horizontally
– On line 9, base.Move() calls the Move() function on
EnemyZig's base class, Enemy
• This causes EnemyZig instances to continue to move downward as well
13
 Chapter 25 – Summary
 Classes combine data (fields) and functionality
(methods)
 Classes can inherit from each other
 Classes are used in Unity as GameObject Components
 Understanding classes is the key to object-oriented
programming (OOP)
– Before OOP, games were often a single, very large function
– With OOP, each object in the game is a class, and each class
can think for itself

 Next Chapter: Object-Oriented Thinking

– The next chapter talks more about the OOP mentality
– Also has a section where you make procedural art!

14