All content in this course uses:

 Write your own spawner class

Write the class to make your code more efficient

Add and review a special function for your class

When you’ve finished, you’ll have created your own potion spawning class for the Creator Kit: Beginner Code game.

Now that you’ve seen how classes work, you can write a class in your SpawnerSampler script. You can use classes to write more efficient code and group together similar functions. This is a key part of writing code for games: finding and using patterns to create the functionality and player experience that you want.

Let’s start by using what you already know to write a class to calculate the angle required for each health potion.

Using classes to make your code more efficient

. Place this after the closing curly brace of the SpawnerSample class in the SpawnerSample script file:

 keyword and its function in the next tutorial.

Write a class declaration

Now you need to identify the type of data necessary to handle the work you want this function to control. To help you do this, think about the

 of the class you want to create.

This class needs to compute angles for potion spawning, in a regular sequence. To do this, it will need to be able to store:

The number of degrees that need to be added to the position each time a new potion is spawned (

This will enable it to calculate the following equation:

 Identify the data type

 to store the necessary data for the equation:

  The angle of the current potion (call this 

  The number of degrees to add for the next potion (call this 

Declare variables for the necessary data

class should now match the following code:

Remember, each instruction should end with a semicolon, so the compiler knows it is an individual instruction.

 Check your variable declarations

Finally, you need to add a function which computes the next angle to use. 

Add a function

As you’ve done throughout this project, use what you already know to identify the key information in this function and try to work out what each part will do in your script. 

. This is because the function is not only going to do something, it’s also going to return a result (the angle for the new potion). 

Here, your code tells the compiler that the function NextAngle will return an integer (int) value. Previously you were using void (meaning “nothing”), because your functions were computing things but not returning any results.

This instruction stores the current angle in a new variable called currentAngle.

The next instruction computes the angle for the next potion and stores it back in the variable 

. The WrapAngle function is a function that we’ve written for you, which enables you to store an angle between 0° and 360°.

This instruction returns the original angle (before it was advanced in the sequence) to the caller. The value to the right of the return keyword is what will be returned by the function.

Review the function

Let’s take a moment to check that the function completes your required equation:

This function should compute the position of each new potion, by adding your selected increment (step) to your current angle. Let’s start with 


It will complete the same process every time it is called.

Review the function’s computation

You’re nearly done! Now the only missing thing is initializing the 

 class should reserve space for those two values in memory, but you didn’t assign a value to them. By default, the value will be set to 

You could write a function called Init to initialize those values to parameters you give them. But classes have a very useful feature called the 

 In the SpawnerSample script, create a new line at the top of the Start function (above the first call to SpawnPotion).

 Add the following instruction to the line:

Remember when you learned how to create a new variable of a particular class type? The typename was followed by two parenthesis like a function. That’s because it actually 

Initialize the angle and step variables

 is a special function that has exactly the same name as your class and no type (for example, void) written before it. The compiler will create a “hidden” constructor by default which does nothing. If you create your own, you can give it specific parameters.

Beneath the instructions initializing the variables angle and step, add the following code:

  Check your class against the following completed version:

Now the constructor takes one parameter: the increase each time the NextAngle function is called. This is stored in the 

 in your SpawnerSample script and revise the LootAngle variable creation instruction to the following:

That’s it — you’ve written your first class and created a variable with it!

Create parameters for the constructor

Now that you’ve written your own class, you need to update the script to use it.

Adjust your script to use the LootAngle spawner class:

 In the SpawnerSample script, find the Start function.

  Replace the instructions inside the Start function with the following:

Update the Start function

As always, it’s important to test changes in the Editor:

 Return to Unity Editor and look at the Console window.



  You should see five instances of error CS0122 displayed:

This error means that a function is inaccessible due to its protection level.  

LootAngle.NextAngle() is the function you wrote. LootAngle.LootAngle is a function called LootAngle in the class LootAngle — it’s your constructor.

But why are they inaccessible? In the next tutorial, you’ll learn about the 

 keyword and how to make these functions accessible.

Test your changes

Written a custom class for your SpawnerSample script

Used the constructor to initialize parameters 

Tested your changes in Unity Editor and identified a protection level error


In the next tutorial, you’ll fix the protection level error and learn about the public keyword. You’ll also begin to explore the concept of inheritance, and how this can be used to write more efficient code.

Unity Version 2022.3