All content in this course uses:

Introduction to the public keyword and inheritance

 keyword, and the role this plays in code

Make a variable public and access it in Unity Editor

When you’ve finished, you’ll be ready to create a custom effect for the health potions used in your SpawnerSample script.

 you explored the role of the class keyword in organizing your code. You’ve also previously encountered another keyword: 

. In your SampleSpawner script, the ObjectToSpawn variable written within the Spawner Sample class starts with the public keyword.

By default, everything within a class is private. This means that it can only be accessed by the class itself. However, if you add the 

 keyword in front of a class, function or variable, this allows other classes to access it too.

You could consider public things to be in an open wagon where the contents can be easily accessed, and private things to be in a closed one.

Understand the difference between public and private

Let’s look at an example which illustrates the difference between public and private variables. 

You would not be able to access the float variable 

 in a different script using a dot operator. 

This is because 

 is private by default — it doesn’t have the 

 keyword. Only functions inside the class Vector3 can access it.

 Review a private variable example

Let's make your LootAngle constructor and NextAngle function public to fix the Unity Editor error:

In the SpawnerSample script, find the function 

  Return to Unity Editor, and check that the error has cleared in the

Great — you’ve fixed the error by making the constructor and function accessible!

Make your LootAngle variable public

When you make a class variable public, this has an interesting secondary effect of enabling you to access it from the Inspector. 

In the SpawnerSample script, the variable 

is public. Let’s find it in the Unity Editor:

When you tell the computer that a variable needs to be accessible from other places using the 

 keyword, Unity exposes it so that you (or someone else) can change its value in the Inspector.

Access a public variable in Unity Editor

 public variable to assign a Prefab GameObject as the object to spawn. 

Let’s create a different GameObject which spawns money at game start:

  In the Hierarchy, right-click and select 

 from the contextual menu. Rename your new GameObject 

In the Scene view, use the Move Tool (shortcut: 

) to move the MoneySpawner GameObject next to the PotionSpawner GameObject. 

 Make sure that MoneySpawner is still selected in the Hierarchy. In the Inspector, select the 

, and add the script to your MoneySpawner GameObject.

Assets/Creator Kit - Beginner Code/Prefabs/Tutorial

 GameObject is still selected in the Hierarchy. Drag the MoneyLoot Prefab from the Project window to the 

If you need a little more support completing these steps, you can return to the first tutorial and review the 

Create a new spawning object

Exposed variables can be very useful, because they enable people to adjust gameplay without editing scripts. Values which can be easily adjusted in this way include:

The amount of health points an object gives when equipped

The points of contact on an enemy character - such as various colliders


Exposed values are very useful because they can be changed by a non-coder. They can also be adjusted during live play in Unity Editor to test and refine the player experience.

Using exposed variables to adjust gameplay

You’ve learned a lot in these tutorials, but there’s one more thing to explore. Let’s review the 

You now know what most of this information means:

 is a keyword which means the class can be accessed by other scripts

 is a type, which enables you to group related functions and variables


However, there’s still a little more information to work out:

Review your progress

First, take the standard approach when you encounter an unfamiliar type or keyword — search in the 

The first result provides the following definition: 

“MonoBehaviour is the base class from which every Unity script derives.”

That tells you that MonoBehaviour is a class, something you’ve already encountered, and all scripts derive from it.  Since 

is a script, you could deduce that the colon sign means “the class before the colon derives from the class after the colon” — but what does it actually mean for something to be “derived” in C#?

Look up “MonoBehaviour”

Class allows you to group together the variables and functions needed to complete a specific task — for example, an Enemy class could group together everything needed to control enemies in your game.

variations or specializations of that class

. For example, you might want a flying enemy and walking enemy, which have the same data and most functions, but a different movement function. 

To write this code efficiently, you could write:

 classes FlyingEnemy and WalkingEnemy will automatically 

 (be able to access) all the functions and variables of the Enemy class. 

One way to think of derived classes is as different members of the same family.

Introduction to derivation and inheritance

Let’s use the example from the previous step to explore what inheritance looks like in practice:

You could then write code which accesses the function 

 class without redeclaring the function, for example: 

Review an inheritance example

Your scripts in Unity derive from the base class 

. This means that the script can access a range of variables and functions created within the base class that every Unity user can use, including:

, which enables you to access a component on a GameObject


These default variables and functions mean that you have to spend less time writing scripts to do commonly needed things, and can focus more on writing code that will help you make your specific game.

What does the MonoBehaviour class contain?

 keyword, and used it to fix the protection level error in your SpawnerSample script.


In the next tutorial, you’ll apply what you’ve learnt and write a custom effect for the health potions in the game.

Unity Version 2022.3