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.

d6c0194d-644a-5568-9a3a-bf498319eadc:zx7pohSEomVRos4yXEovSf

Understand the difference between public and private

 Review a private variable example

Make your LootAngle variable public

Access a public variable in Unity Editor

Create a new spawning object

Using exposed variables to adjust gameplay

Review your progress

Look up “MonoBehaviour”

Introduction to derivation and inheritance

Review an inheritance example

What does the MonoBehaviour class contain?

Tutorial summary

Unity HOC 1.5 Keywords.mp4

Explore the public keyword, and the role this plays in code

Make a variable public and access it in Unity Editor

Explore the concept of inheritance and derived classes

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

Games

Hour of Code - Creator Kit: Beginner Coding

In the previous tutorial, you explored the role of the class keyword in organizing your code. You’ve also previously encountered another keyword: public. 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 public 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.

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

class Vector3
{
    float x;
    float y;
    float z;

    Vector3 otherVector;
}


You would not be able to access the float variable x in a different script using a dot operator. 

This is because x is private by default — it doesn’t have the public keyword. Only functions inside the class Vector3 can access it.

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


1.  In the SpawnerSample script, find the function LootAngle inside the class LootAngle:

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

2.  Add the keyword public to the function declaration:


3.  Below the function LootAngle, find the function NextAngle:

    int NextAngle()
    {
        int currentAngle = angle;
        angle = Helpers.WrapAngle(angle + step);

        return currentAngle;
    }

4.  Add the keyword public to the function declaration:

5.  Press Ctrl + S (Windows) or Cmd + S (macOS) to save your changes.



6.  Return to Unity Editor, and check that the error has cleared in the Console window.


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

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 ObjectToSpawn is public. Let’s find it in the Unity Editor:


2.  In the Hierarchy, select the PotionSpawner GameObject.


3.  In the Inspector, find the Spawner Sample (Script) component:

The public ObjectToSpawn variable has a field in the Inspector!


When you tell the computer that a variable needs to be accessible from other places using the public keyword, Unity exposes it so that you (or someone else) can change its value in the Inspector.

You can use the ObjectToSpawn public variable to assign a Prefab GameObject as the object to spawn. 

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


1.  In the Hierarchy, right-click and select 3D Object > Sphere from the contextual menu. Rename your new GameObject MoneySpawner.


2.  In the Scene view, use the Move Tool (shortcut: W) to move the MoneySpawner GameObject next to the PotionSpawner GameObject. 


3. Make sure that MoneySpawner is still selected in the Hierarchy. In the Inspector, select the Add Component button. Search for Spawner Sample, and add the script to your MoneySpawner GameObject.



4. In the Project window, go to Assets/Creator Kit - Beginner Code/Prefabs/Tutorial and find the MoneyLoot Prefab.

5.  Make sure that the MoneySpawner GameObject is still selected in the Hierarchy. Drag the MoneyLoot Prefab from the Project window to the Object To Spawn field in the Inspector.



6.  Press Ctrl + S (Windows) or Cmd + S (macOS) to save your changes.


TIP: If you need a little more support completing these steps, you can return to the first tutorial and review the Unity Editor refresher.

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.

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

public class SpawnerSample : MonoBehaviour

You now know what most of this information means:

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


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




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

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

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 SpawnerSample 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#?

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.

However, sometimes you will need 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:

An Enemy class to perform all common operations


Two other classes (FlyingEnemy and WalkingEnemy) that derive from it


The derived classes FlyingEnemy and WalkingEnemy will automatically inherit (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.

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

public class Enemy
{
    public void Attack()
    {
        …
    }
}

public class FlyingEnemy : Enemy
{

}

The colon identifies FlyingEnemy as derived from Enemy. 

You could then write code which accesses the function Attack inside the Enemy class without redeclaring the function: 

void HandleEnemy()
{
  FlyingEnemy myEnemy;
  myEnemy.Attack();
}

Your scripts in Unity derive from the base class MonoBehaviour. 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:

The variable transform, which contains the Transform component


The function GetComponent, 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.

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


Explored the concepts of inheritance and derived classes.


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

Introduction to the public keyword and inheritance

1. Understand the difference between public and private

2. Review a private variable example

3. Make your LootAngle variable public

4. Access a public variable in Unity Editor

5. Create a new spawning object

6. Using exposed variables to adjust gameplay

7. Review your progress

8. Look up “MonoBehaviour”

9. Introduction to derivation and inheritance

10. Review an inheritance example

11. What does the MonoBehaviour class contain?

12. Tutorial summary

Complete this tutorial