Get started with Creator Kit: Beginner Code

Get started with code in Unity

Introduction to variables

Write your own instruction

Introduction to functions

Write your own spawn function 

Introduction to classes

 Write your own spawner class

Introduction to the public keyword and inheritance

Customize the health potions

Customize your game

Homework Submissions

WebGL Submissions - Create your first Action-RPG with C#

Live Session - Create your first Action-RPG Game with C#

Creator Kit: Beginner Code

In this activity, students customize their own 3D role-play video games using Unity technology and C# computer coding. All activity assets and step-by-step tutorials are included, helping learners to get started quickly. By the end of the project, students will have customized their own playable 3D games and have gained a better understanding of scripting, variables, functions, and classes. 

Participating in the global Hour of Code? Visit our Hour of Code Edition of this Creator Kit.

No coding experience? No problem! In this beginner project, you’ll explore the basics of C# code for Unity in the context of an action RPG. 

To get the most out of this project, you’ll have completed one of the three introductory Creator Kits (Puzzle, FPS, RPG), so you can apply your knowledge of the Unity Editor and focus on customizing the game with scripts.

Important: This learning content requires at least Unity 2019.2, and will not work correctly on older versions.

02439728-8951-533a-981d-a7d52852537c:KNyBhALw6RpujrBA0XtIVQ

Using classes to make your code more efficient

Write a class declaration

 Identify the data type

Declare variables for the necessary data

 Check your variable declarations

Add a function

Review the function

Review the function’s computation

Initialize the angle and step variables

Create parameters for the constructor

Update the Start function

Test your changes

Tutorial summary

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.

Games

Hour of Code - Creator Kit: Beginner Coding

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.

First, add a class declaration. Place this after the closing curly brace of the SpawnerSample class in the SpawnerSample script file: 

You’ll find out more about the public keyword and its function in the next tutorial.

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 purpose 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 (x°)

This will enable it to calculate the following equation: 

In your new class LootAngle, declare two integer variables to store the necessary data for the equation:


1.  The angle of the current potion (call this angle)


2.  The number of degrees to add for the next potion (call this step)

Your new LootAngle class should now match the following code:

public class LootAngle
{
    int angle;
    int step;
}

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

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

Add the following function to your LootAngle class:

public class LootAngle
{
    int angle;
    int step;
    
    int NextAngle()
    {
        int currentAngle = angle;
        angle = Helpers.WrapAngle(angle + step);
        
        return currentAngle;
    }
}


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. 

The function type here is int and not void. 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.


        angle = Helpers.WrapAngle(angle + step);

The next instruction computes the angle for the next potion and stores it back in the variable angle. 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.

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 angle = 0 and step = 45.


The first time you call the function, it will:

3.  Return 0



The second time the function is called, it will:



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

You’re nearly done! Now the only missing thing is initializing the angle and step variables. 

You just told the computer that the LootAngle 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 0.

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 constructor.

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

2.  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 is a function: the constructor.

The constructor 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.


1.  In the SpawnerSample script, find the LootAngle class.


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

LootAngle(int increment)
{
    step = increment;
    angle = 0;
}



3.  Check your class against the following completed version:

public class LootAngle
{
    int angle;
    int step;

    LootAngle(int increment)
    {
        step = increment;
        angle = 0;
    }
    
    int NextAngle()
    {
        int currentAngle = angle;
        angle = Helpers.WrapAngle(angle + step);
        
        return currentAngle;
    }
}


Now the constructor takes one parameter: the increase each time the NextAngle function is called. This is stored in the step variable, and the angle variable is initialized to 0.


4.  Return to the Start function in your SpawnerSample script and revise the LootAngle variable creation instruction to the following:

LootAngle myLootAngle = new LootAngle(45);



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

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:


1.  In the SpawnerSample script, find the Start function.


2.  Replace the instructions inside the Start function with the following:

LootAngle myLootAngle = new LootAngle(45);

//every call will advance the angle!
SpawnPotion(myLootAngle.NextAngle());
SpawnPotion(myLootAngle.NextAngle());
SpawnPotion(myLootAngle.NextAngle());
SpawnPotion(myLootAngle.NextAngle());


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

1.  Return to Unity Editor and look at the Console window.


2.  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 public keyword and how to make these functions accessible.

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.

Write your own spawner class

1. Using classes to make your code more efficient

2. Write a class declaration

3. Identify the data type

4. Declare variables for the necessary data

5. Check your variable declarations

6. Add a function

7. Review the function

8. Review the function’s computation

9. Initialize the angle and step variables

10. Create parameters for the constructor

11. Update the Start function

12. Test your changes

13. Tutorial summary

Complete this tutorial