📌 Course purpose: This course teaches you how to create video games using Unity — one of the most popular game engines in the world. You will learn the basics of game design, coding (C#), and how to build your own playable games. No prior experience needed — just creativity and curiosity.
| Aspect | Details |
|---|---|
| Target audience | Beginners interested in game development — no coding or design experience needed |
| Prerequisites | None — just a computer and an open mind |
| Delivery mode | Self-paced with practical projects and examples |
| Total duration | ~4–6 hours (over 1–2 weeks) |
| Certification | Certificate of Completion |
By the end of this course, you will be able to:
| Module | Title & focus | Key activities & takeaways |
|---|---|---|
| 1 | Welcome to Unity Getting started with game development |
Install Unity, learn the interface, understand scenes and game objects. 🔹 Task: Create your first project and navigate the editor. |
| 2 | Game Objects and Components Building your game world |
Learn about game objects, components, transforms, and prefabs. 🔹 Task: Build a simple scene with objects. |
| 3 | Introduction to C# Scripting Make your game interactive |
Learn the basics of C# — variables, functions, and events. Attach scripts to objects. 🔹 Task: Write a script to move a player. |
| 4 | Physics and Collisions Make things move and interact |
Understand rigidbodies, colliders, and triggers. Detect collisions and respond. 🔹 Task: Add collectibles and obstacles. |
| 5 | User Interface and Sound Make your game look and sound great |
Create UI elements (score, health, menus). Add sound effects and background music. 🔹 Task: Add a score counter and sound. |
| 6 | Building and Publishing Share your game with the world |
Build your game for Windows, Mac, or web. Learn about testing and publishing. 🔹 Task: Build and share your completed game. |
| Component | Description |
|---|---|
| Practical exercises | After each module, complete a hands-on task (e.g., build a scene, write a script). |
| Game journal | Document your progress and ideas. |
| Final project | Create a complete playable game (e.g., a platformer or 2D shooter). |
| Peer playtesting | Share your game and get feedback. |
| Week | Modules to cover | Estimated time |
|---|---|---|
| Week 1 | Modules 1, 2, 3 | 2–3 hours |
| Week 2 | Modules 4, 5, 6 | 2–3 hours |
| Question | Answer |
|---|---|
| Do I need to know coding? | No, this course is for beginners. We start from the very basics. |
| Can I use Unity for free? | Yes, Unity has a free version that is perfect for beginners. |
| What kind of games will I build? | You will build simple 2D and 3D games — like platformers or puzzle games. |
| How long does it take? | About 4–6 hours total. You can go at your own pace. |
| Is there a certificate? | Yes, you will receive a Certificate of Completion. |
After finishing all modules and the final project, you will receive a Certificate of Completion. You can use your new skills to create your own games, join game jams, or even start a career in game development.
After this course, you can explore advanced topics like 3D modelling, multiplayer games, or mobile game development — or just start making your own games!
Hello, future game developer! Welcome to the very first module of "Game Development with Unity". This is a very special course because it will teach you how to create your own video games using Unity — one of the most popular game engines in the world.
In this module, we will start from the very beginning. We will learn what Unity is, how to install it, and how to use its interface. You don't need to know anything about game development. We will go slowly and use lots of examples. By the end of this module, you will have Unity installed and understand the basics of the editor.
Chidi is a teenager in Lagos. He loves playing video games. One day, he thought: "What if I could make my own game?" He heard about Unity and decided to try it.
He downloaded Unity and opened it for the first time. It looked complicated. There were many panels and buttons. But he followed a tutorial step by step. He learned about the Scene view, the Hierarchy, and the Inspector. He created a simple scene with a cube and a sphere.
He pressed the Play button and saw his objects on the screen. He was amazed. He had created something! From that day, Chidi was hooked. He continued learning and eventually made his own game. This story shows that anyone can start with Unity and learn step by step.
Definition: Unity is a game engine — a software tool that helps you create video games.
Why important: Unity is used by millions of developers around the world to make games for phones, computers, and consoles.
Simple explanation: Unity is like a workshop where you build games.
Real-life example: Many popular games like "Among Us" and "Pokémon Go" were made with Unity.
School example: A teacher uses Unity to teach students game development.
Home example: A teenager uses Unity to create their own game.
Nigerian example: A Nigerian developer uses Unity to create a local game.
Illustration:
+----------------------+
| Unity = Game Engine |
| → Build games |
| → For phones, PC |
| → Used worldwide |
+----------------------+
Mini summary: Unity is a tool for making video games.
Definition: Unity is popular because it is powerful, flexible, and has a free version for beginners.
Why important: It is one of the best tools to start learning game development.
Simple explanation: Unity helps you turn your game ideas into reality.
Real-life example: Indie game developers use Unity to create and sell games.
School example: Students use Unity for game design projects.
Home example: A hobbyist uses Unity to make games for fun.
Nigerian example: Nigerian game studios use Unity to develop mobile games.
Illustration:
Why Unity?
✅ Free to start
✅ Easy to learn
✅ Many tutorials
✅ Used by pros
Mini summary: Unity is great for beginners and professionals.
Definition: Installing Unity means downloading and setting up the software on your computer.
Why important: You need Unity installed to start making games.
Simple explanation: Like installing a game on your computer.
Real-life example: You download Unity Hub and install the latest version.
School example: A teacher helps students install Unity.
Home example: You install Unity on your personal computer.
Nigerian example: A developer installs Unity on their laptop.
Illustration:
Install Steps:
1. Download Unity Hub
2. Install Unity Hub
3. Install a Unity version
4. Create a project
5. Start learning!
Mini summary: Install Unity to start making games.
Definition: Unity Hub is a launcher that helps you manage your Unity projects and versions.
Why important: It makes it easy to organise your work and switch between projects.
Simple explanation: It's like a control panel for your Unity projects.
Real-life example: A developer uses Unity Hub to open different projects.
School example: A student uses Unity Hub to access their class projects.
Home example: A hobbyist uses Unity Hub to manage their games.
Nigerian example: A Nigerian developer uses Unity Hub to keep projects organised.
Illustration:
Unity Hub:
📁 Projects list
📦 Installs
🚀 Open projects
➕ Create new project
Mini summary: Unity Hub helps you manage your projects.
Definition: The Unity interface is the layout of panels and windows you see when you open Unity.
Why important: You need to know where things are to work efficiently.
Simple explanation: It's like the dashboard of a car — you need to know what each part does.
Real-life example: A designer uses the interface to build game levels.
School example: A student learns where the Scene and Game views are.
Home example: A hobbyist explores the interface.
Nigerian example: A developer navigates the interface to build games.
Illustration:
Main Panels:
🖼️ Scene View
🎮 Game View
📋 Hierarchy
📁 Project
🔧 Inspector
Mini summary: The Unity interface has several key panels.
Definition: The Scene View is where you build and arrange your game world.
Why important: This is where you place objects, move them, and design your game.
Simple explanation: It's like a 3D canvas where you create your game.
Real-life example: A level designer places buildings and trees in the Scene View.
School example: A student drags objects into the Scene View.
Home example: A hobbyist arranges objects in the Scene View.
Nigerian example: A developer builds a game world in the Scene View.
Illustration:
Scene View:
🖱️ Click to select
🔄 Rotate view
🚀 Move objects
📐 Scale objects
Mini summary: The Scene View is where you build your game world.
Definition: The Game View shows what the player will see when they play your game.
Why important: It helps you preview your game as you build it.
Simple explanation: It's like a window into your game.
Real-life example: A developer tests how the game looks in Game View.
School example: A student plays their game in Game View.
Home example: A hobbyist sees their game come to life.
Nigerian example: A developer previews their game in Game View.
Illustration:
Game View:
🎮 Shows game screen
▶️ Play button
⏸️ Pause
🎥 Camera view
Mini summary: The Game View shows what the player sees.
Definition: The Hierarchy panel lists all the objects in your scene.
Why important: It helps you organise and select objects.
Simple explanation: It's like a list of everything in your game.
Real-life example: A developer selects an object from the Hierarchy.
School example: A student sees all objects in the scene.
Home example: A hobbyist finds objects in the Hierarchy.
Nigerian example: A developer organises objects in the Hierarchy.
Illustration:
Hierarchy:
📋 List of objects
🖱️ Click to select
🔗 Parent-child relationships
Mini summary: The Hierarchy lists all objects in your scene.
Definition: The Project panel shows all the files in your project — like scripts, images, and sounds.
Why important: It helps you find and organise your assets.
Simple explanation: It's like a file explorer for your game.
Real-life example: A developer drags an image from the Project panel into the scene.
School example: A student finds scripts in the Project panel.
Home example: A hobbyist organises their assets.
Nigerian example: A developer manages game assets in the Project panel.
Illustration:
Project Panel:
📁 Folders
📄 Files
🖼️ Assets
🔍 Search
Mini summary: The Project panel holds all your game files.
Definition: The Inspector shows details about the object you have selected — like its position, scale, and components.
Why important: It helps you change properties of objects.
Simple explanation: It's like a control panel for each object.
Real-life example: A developer changes the colour of an object in the Inspector.
School example: A student adjusts the size of a cube.
Home example: A hobbyist tweaks object properties.
Nigerian example: A developer modifies objects in the Inspector.
Illustration:
Inspector:
🔧 Properties
📐 Transform
🎨 Components
⚙️ Settings
Mini summary: The Inspector shows and changes object properties.
Definition: You have learned the basics of Unity and its interface.
Why important: You are now ready to start creating your own games.
Simple explanation: You know your way around Unity.
Real-life example: You can now build a simple scene.
School example: You can start your first game project.
Home example: You can begin making games for fun.
Nigerian example: You can start developing games in Nigeria.
Illustration:
+----------------------+
| You are ready to |
| start making games! 🎉 |
| → Unity installed |
| → Interface known |
| → Projects ready |
+----------------------+
Mini summary: You are ready to start creating games!
Step 1: Open Unity Hub.
Step 2: Click "New Project" and choose 3D.
Step 3: Name it "MyFirstGame".
Step 4: Save it in "Documents".
Step 5: Click "Create".
+----------------------+
| Scene View | Game View |
+----------------------+
| Hierarchy |
+----------------------+
| Project |
+----------------------+
| Inspector |
+----------------------+
| Panel | Purpose |
|---|---|
| Scene View | Build game world |
| Game View | Test game |
| Hierarchy | List objects |
| Project | Manage assets |
| Inspector | Change properties |
+----------------------+
| Projects | Installs |
| (list) | (versions) |
+----------------------+
In this module, we learned the basics of Unity. We discovered that Unity is a game engine used to create video games. We installed Unity and learned about the key interface panels: Scene View, Game View, Hierarchy, Project, and Inspector. With this foundation, you are now ready to start creating your own games. Great job!
Match the word with its meaning:
| Word | Meaning |
|---|---|
| 1. Unity | A) What the player sees |
| 2. Scene View | B) List of objects |
| 3. Game View | C) Game engine |
| 4. Hierarchy | D) Where you build |
| 5. Inspector | E) Object properties |
(Answers: 1-C, 2-D, 3-A, 4-B, 5-E)
Scenario 1: You have just installed Unity. What is the first thing you should do?
Scenario 2: You are in Unity and cannot find the Hierarchy panel. What would you do?
In groups of 3, explore the Unity interface together. Identify each panel and share what you think it does.
Create a new Unity project. Spend 5 minutes exploring the interface. Write down what you found.
Create a new Unity project. Add a cube, sphere, and cylinder to the scene. Save the scene. Show it to the class.
Open Unity and create a new project. Take a screenshot of the interface and label the five main panels.
Explore the Unity interface and find the "Game" tab. Press the Play button and describe what happens.
Fill-in-the-blank: 1-game engine, 2-Scene, 3-Game, 4-Hierarchy, 5-Inspector
True/False: 1-T, 2-F, 3-F, 4-T, 5-T
Matching: 1-C, 2-D, 3-A, 4-B, 5-E
In Module Two, we will learn about Game Objects and Components. We will learn how to add and control objects in your game. Before the next session, think about what objects you would like in your game.
See you in Module Two! 🎉
End of Module One · Welcome to Unity!
Hello, future game developer! In Module One, we learned the basics of Unity — what it is, how to install it, and how to use the interface. We learned about the Scene, Game, Hierarchy, Project, and Inspector panels. Now it is time to start building.
In this module, we will learn about Game Objects and Components. Game Objects are the things you see in your game — like characters, trees, and coins. Components are the features that make them work — like movement, colour, and behaviour. By the end of this module, you will be able to create and control objects in your game world.
Tunde is a young game developer in Abuja. He wanted to create a character for his game. He opened Unity and created a Game Object — a simple cube. He was excited to see it in the Scene.
But the cube was just a shape. It didn't do anything. He learned about Components. He added a Rigidbody component to make it fall with gravity. He added a script to make it move. The cube came to life.
Tunde then turned his cube into a Prefab so he could use it again in other levels. He was proud of his first character. He learned that Game Objects and Components are the building blocks of every game.
Definition: A Game Object is any object in your game — a character, a coin, a tree, or a light.
Why important: Everything in your game is a Game Object.
Simple explanation: A Game Object is like a toy that you place in your game world.
Real-life example: A character in a game is a Game Object.
School example: A student places objects in a scene.
Home example: A toy on a shelf.
Nigerian example: A player character in a Nigerian game.
Illustration:
+----------------------+
| Game Object = |
| Anything in your |
| game |
| → Cube |
| → Player |
| → Coin |
+----------------------+
Mini summary: A Game Object is any object in your game.
Definition: You create a Game Object by right-clicking in the Hierarchy or using the GameObject menu.
Why important: This is how you add things to your game.
Simple explanation: Like adding a toy to a playroom.
Real-life example: A developer creates a cube in Unity.
School example: A student adds a sphere to the scene.
Home example: A hobbyist adds a cylinder.
Nigerian example: A developer creates a character.
Illustration:
Create Object:
1. Right-click in Hierarchy
2. Choose 3D Object → Cube
3. The cube appears in the scene
Mini summary: Create Game Objects to build your game.
Definition: A Component is a feature that you add to a Game Object to give it functionality.
Why important: Components make Game Objects do things.
Simple explanation: Components are like superpowers for your objects.
Real-life example: A Rigidbody makes an object fall with gravity.
School example: A Light component makes the scene brighter.
Home example: A sound component plays music.
Nigerian example: A script component makes a character move.
Illustration:
+----------------------+
| Component = |
| Feature added to |
| a Game Object |
| → Transform |
| → Rigidbody |
| → Collider |
+----------------------+
Mini summary: Components add features to Game Objects.
Definition: Transform is a component that controls an object's position, rotation, and scale.
Why important: Every object needs a Transform to be placed in the world.
Simple explanation: It tells the object where to be, how to face, and how big to be.
Real-life example: A chair has a position, rotation, and size.
School example: A desk in a classroom has a location and orientation.
Home example: A TV is placed in a certain spot and angle.
Nigerian example: A character's position in a game level.
Illustration:
Transform:
📍 Position (x, y, z)
🔄 Rotation (x, y, z)
📏 Scale (x, y, z)
Mini summary: Transform controls position, rotation, and scale.
Definition: Position is where the object is located in the world. It has X, Y, and Z coordinates.
Why important: You need to place objects in the right spot.
Simple explanation: It's like an address for your object.
Real-life example: A house has a street address.
School example: A student sits in a specific seat.
Home example: A bed is placed in a corner.
Nigerian example: A character starts at a specific point.
Illustration:
Position:
X = left/right
Y = up/down
Z = forward/backward
Mini summary: Position places an object in the world.
Definition: Rotation controls which direction the object is facing.
Why important: You need objects to face the right way.
Simple explanation: It's like turning your head.
Real-life example: A person turns to look at something.
School example: A chair faces the teacher.
Home example: A TV is turned toward the sofa.
Nigerian example: A character faces the enemy.
Illustration:
Rotation:
X = tilt up/down
Y = turn left/right
Z = roll
Mini summary: Rotation controls the direction an object faces.
Definition: Scale controls the size of the object.
Why important: You need objects to be the right size.
Simple explanation: It's like making something bigger or smaller.
Real-life example: A poster can be small or large.
School example: A globe can be scaled up or down.
Home example: A photo can be enlarged or reduced.
Nigerian example: A character can be scaled to fit.
Illustration:
Scale:
X = width
Y = height
Z = depth
Mini summary: Scale controls the size of the object.
Definition: A Prefab is a reusable Game Object. You can save it and use it many times.
Why important: Prefabs save time and keep things consistent.
Simple explanation: Like a stamp — you use it to make many copies.
Real-life example: A coin prefab can be placed many times.
School example: A student uses a template for posters.
Home example: A cookie cutter makes many cookies.
Nigerian example: A character prefab is used in many levels.
Illustration:
Prefab:
🔁 Reusable
📦 Save once, use many times
✅ Consistent
Mini summary: Prefabs are reusable Game Objects.
Definition: You have learned the basics of Game Objects and Components.
Why important: You can now start building your game world.
Simple explanation: You know how to add and control objects.
Real-life example: You can create a simple scene.
School example: You can build a level for your game.
Home example: You can create a small game environment.
Nigerian example: You can build a Nigerian-themed game.
Illustration:
+----------------------+
| You can build with |
| Game Objects! 🎉 |
| → Create objects |
| → Add components |
| → Use prefabs |
+----------------------+
Mini summary: You are now ready to build with Game Objects!
Create Object:
Step 1: Right-click Hierarchy → Cube.
Step 2: Click the cube.
Step 3: Set Position to (2, 1, 0).
Step 4: Set Rotation to (0, 45, 0).
Step 5: Set Scale to (2, 2, 2).
Create Prefab:
Step 1: Create a sphere.
Step 2: Add a Rigidbody.
Step 3: Drag to Project panel.
Step 4: Drag the Prefab into the scene.
+----------------------+
| Game Object (Cube) |
| → Transform |
| → Mesh Filter |
| → Mesh Renderer |
| → Box Collider |
+----------------------+
| Property | Description |
|---|---|
| Position | Location in world |
| Rotation | Direction facing |
| Scale | Size |
Prefab: Coin
→ Use in many places
→ Consistent size and behaviour
→ Easy to update
In this module, we learned about Game Objects and Components. We discovered that Game Objects are the building blocks of any game, and Components add functionality to them. We learned about Transform — position, rotation, and scale — and how to use Prefabs to reuse objects. With this knowledge, you can now start building your own game world. Great job!
Match the word with its meaning:
| Word | Meaning |
|---|---|
| 1. Game Object | A) The size of an object |
| 2. Component | B) Any object in your game |
| 3. Transform | C) A reusable Game Object |
| 4. Scale | D) A feature added to an object |
| 5. Prefab | E) Controls position, rotation, scale |
(Answers: 1-B, 2-D, 3-E, 4-A, 5-C)
Scenario 1: You want to place a tree in your game. What would you create?
Scenario 2: You need to place 100 coins in your game. What would you use to save time?
In groups of 3, create a simple scene with at least 5 Game Objects. Use different sizes, positions, and rotations. Share your scene with the class.
Create a simple scene with a cube, sphere, and cylinder. Change their position, rotation, and scale. Save the scene.
Create a scene with 10 Game Objects. Use at least 3 different shapes. Create a Prefab and use it at least 3 times. Save and share your scene.
Create a Prefab of a coin. Place 5 coins in your scene. Change their positions and rotations. Save the scene.
Create a scene with a character (cube), obstacles (spheres), and collectibles (prefab coins). Arrange them in an interesting way. Save the scene.
Fill-in-the-blank: 1-Game Object, 2-Component, 3-Transform, 4-Position, 5-Prefab
True/False: 1-F, 2-T, 3-F, 4-T, 5-F
Matching: 1-B, 2-D, 3-E, 4-A, 5-C
In Module Three, we will learn about C# scripting. We will write code to make our Game Objects move and interact. Before the next session, think about how you would like your character to move.
See you in Module Three! 🎉
End of Module Two · Game Objects and Components
Hello, future game developer! In Module Two, we learned about Game Objects and Components. We learned how to create and control objects in the scene. Now it is time to bring them to life with code.
In this module, we will learn the basics of C# (pronounced "C sharp"), the programming language used in Unity. We will write simple scripts to make our Game Objects move, jump, and interact. By the end of this module, you will be able to write your own scripts and make your game interactive.
Chioma is a young game developer in Enugu. She had built a scene with a player character. But her player just sat there. It didn't move. It didn't do anything. She knew she needed to write code.
She opened Visual Studio and wrote her first C# script. She used a function called Update() to move the player forward. She attached the script to her player. When she pressed Play, the player moved! She was amazed.
Chioma learned that C# is the magic behind every game. It makes things move, jump, and react. She continued learning and soon could create complex behaviours.
Definition: C# is a programming language used to write code for Unity games.
Why important: C# is what makes your game interactive.
Simple explanation: C# is like a set of instructions you give to your game.
Real-life example: A recipe is a set of instructions for cooking.
School example: A student writes instructions for a robot.
Home example: A parent writes a to-do list.
Nigerian example: A developer writes code for a Nigerian game.
Illustration:
+----------------------+
| C# = Instructions |
| for your game |
| → Move |
| → Jump |
| → Collect |
+----------------------+
Mini summary: C# is the language used to control your game.
Definition: A script is a file that contains C# code. You attach it to a Game Object.
Why important: Scripts give behaviour to objects.
Simple explanation: A script is like a set of rules for an object.
Real-life example: A script for a character tells it how to move.
School example: A student writes a script for a robot.
Home example: A parent creates a chore list.
Nigerian example: A developer writes a script for a player.
Illustration:
Create a Script:
1. Right-click in Project panel
2. Choose Create → C# Script
3. Name it "PlayerMovement"
4. Double-click to open
Mini summary: A script is a file of code that controls an object.
Definition: A C# script has a basic structure: using statements, a class, and methods.
Why important: This structure is the same for every script.
Simple explanation: It's like a template that you fill in.
Real-life example: A letter has a structure: greeting, body, closing.
School example: An essay has an introduction, body, and conclusion.
Home example: A recipe has ingredients and steps.
Nigerian example: A developer follows the same script structure.
Illustration:
Script Structure:
using UnityEngine;
public class PlayerMovement : MonoBehaviour
{
// Variables go here
void Start() { }
void Update() { }
}
Mini summary: All scripts have a similar structure.
Definition: A variable is a container that stores a value — like a number or a word.
Why important: Variables store information that your script uses.
Simple explanation: Like a box that holds something.
Real-life example: A score variable stores the player's score.
School example: A grade variable stores a student's grade.
Home example: A grocery list variable stores items.
Nigerian example: A speed variable stores how fast a player moves.
Illustration:
Variables:
int score = 0;
float speed = 5f;
string name = "Player";
Mini summary: Variables store information.
Definition: A function is a block of code that performs a specific task.
Why important: Functions organise your code and make it reusable.
Simple explanation: Like a recipe step that does one thing.
Real-life example: A function to move a player.
School example: A function to calculate the average of grades.
Home example: A function to clean a room.
Nigerian example: A function to jump when the player presses a button.
Illustration:
Functions:
void Start() { }
void Update() { }
void Jump() { }
Mini summary: Functions perform specific tasks.
Definition: The Start() function runs once when the game begins.
Why important: It is used for setup, like initialising variables.
Simple explanation: It's what happens at the beginning.
Real-life example: Turning on a game console.
School example: Setting up a classroom before class.
Home example: Setting the table before dinner.
Nigerian example: Initialising a player's health at the start.
Illustration:
void Start()
{
// Runs once at start
Debug.Log("Game Started!");
}
Mini summary: Start runs once when the game begins.
Definition: The Update() function runs every frame of the game.
Why important: It is used for continuous actions like movement.
Simple explanation: It's what happens constantly.
Real-life example: Breathing is continuous.
School example: A teacher checks attendance every day.
Home example: Checking the time constantly.
Nigerian example: Moving a player every frame.
Illustration:
void Update()
{
// Runs every frame
transform.Translate(0, 0, speed * Time.deltaTime);
}
Mini summary: Update runs continuously.
Definition: You can move a Game Object by changing its position in the Update() function.
Why important: This is how you make characters move.
Simple explanation: You tell the object to move forward every frame.
Real-life example: A car moving forward.
School example: A student walking to class.
Home example: A fan spinning.
Nigerian example: A player moving in a game.
Illustration:
// Move forward
transform.Translate(Vector3.forward * speed * Time.deltaTime);
Mini summary: Move objects by changing their position.
Definition: You attach a script to a Game Object by dragging it onto the object or adding it as a component.
Why important: This is how you give behaviour to objects.
Simple explanation: You put the script on the object you want to control.
Real-life example: Putting a remote control on a toy.
School example: Attaching a note to a project.
Home example: Adding a label to a box.
Nigerian example: Attaching a movement script to a player.
Illustration:
Attach Script:
1. Select the Game Object
2. In Inspector, click "Add Component"
3. Type the script name
4. Click it to add
Mini summary: Attach scripts to Game Objects to control them.
Definition: You have learned the basics of C# scripting in Unity.
Why important: You can now write simple scripts to control your game.
Simple explanation: You know how to make objects move and interact.
Real-life example: You can write a script to move a player.
School example: You can create a simple game project.
Home example: You can build a fun game.
Nigerian example: You can develop a local game.
Illustration:
+----------------------+
| You can code! 🎉 |
| → Write scripts |
| → Move objects |
| → Control games |
+----------------------+
Mini summary: You are now ready to write code in Unity!
public float speed = 5f; at the top.
using UnityEngine;
public class PlayerMovement : MonoBehaviour
{
public float speed = 5f;
void Update()
{
transform.Translate(0, 0, speed * Time.deltaTime);
}
}
using UnityEngine;
public class MyScript : MonoBehaviour
{
// Variables
public float speed = 5f;
// Start is called once
void Start()
{
// Setup code
}
// Update is called every frame
void Update()
{
// Continuous code
}
}
| Type | Description |
|---|---|
| int | Whole numbers |
| float | Decimal numbers |
| string | Text |
| bool | True/False |
transform.Translate(0, 0, speed * Time.deltaTime);
In this module, we learned about C# scripting in Unity. We discovered that C# is the language used to control Game Objects. We learned about the structure of a script, variables, functions, and the Start and Update methods. We also wrote a simple movement script and attached it to a Game Object. With this knowledge, you can now make your games interactive. Great job!
Match the word with its meaning:
| Word | Meaning |
|---|---|
| 1. C# | A) Runs every frame |
| 2. Script | B) A container for data |
| 3. Variable | C) A programming language |
| 4. Start | D) A file of code |
| 5. Update | E) Runs once |
(Answers: 1-C, 2-D, 3-B, 4-E, 5-A)
Scenario 1: You want to make a player move forward. What script would you write?
Scenario 2: You want to print a message when the game starts. What function would you use?
In groups of 3, write a simple movement script. Attach it to a cube. Test it and share your results.
Write a script that moves a sphere forward. Attach it to a sphere in your scene. Test it.
Create a simple scene with a player (cube). Write a script to move the player forward. Add a script to print a message when the game starts.
Write a script to move a Game Object in the forward direction. Attach it to a cube. Test it and save the scene.
Write a script that moves a player forward when the "W" key is pressed. Use Input.GetKey().
Fill-in-the-blank: 1-Unity, 2-script, 3-variable, 4-function, 5-Update
True/False: 1-T, 2-F, 3-T, 4-F, 5-F
Matching: 1-C, 2-D, 3-B, 4-E, 5-A
In Module Four, we will learn about physics and collisions. We will make objects interact with each other. Before the next session, think about how you would like your objects to collide.
See you in Module Four! 🎉
End of Module Three · Introduction to C# Scripting
Hello, future game developer! In Module Three, we learned about C# scripting. We learned how to write code to move and control Game Objects. Now it is time to make our game feel more real with physics and collisions.
Physics makes objects fall, bounce, and move like they do in the real world. Collisions happen when objects touch each other. In this module, we will learn how to add physics to our objects and detect when they collide. By the end of this module, you will be able to make objects interact with gravity, walls, and each other.
Kofi is a game developer in Accra. He wanted to create a game where a ball falls and bounces. He placed a ball in the scene, but it just floated in the air. It didn't fall. He knew he needed physics.
He added a Rigidbody component to the ball. Now it fell with gravity. He added a Collider to the ball and to the ground. When the ball hit the ground, it bounced. Kofi was thrilled. He then added a script to collect coins when the ball touched them. He learned that physics and collisions make games feel real.
Definition: Physics in Unity simulates real-world forces like gravity, friction, and bouncing.
Why important: Physics makes games feel realistic and fun.
Simple explanation: It's like making your game follow the laws of nature.
Real-life example: A ball falling to the ground.
School example: A pendulum swinging.
Home example: A cup falling off a table.
Nigerian example: A player jumping and falling in a game.
Illustration:
+----------------------+
| Physics = |
| Gravity, bounce, |
| friction |
| → Makes games real |
+----------------------+
Mini summary: Physics makes your game behave like the real world.
Definition: Rigidbody is a component that adds physics to a Game Object. It makes the object respond to gravity and forces.
Why important: Without Rigidbody, objects don't fall or react to physics.
Simple explanation: It's like giving an object weight and gravity.
Real-life example: A ball with Rigidbody falls down.
School example: A book on a table has weight.
Home example: A cup falls if pushed.
Nigerian example: A player with Rigidbody jumps and falls.
Illustration:
+----------------------+
| Rigidbody = |
| Adds gravity |
| Adds physics |
| → Makes objects fall |
+----------------------+
Mini summary: Rigidbody adds physics to an object.
Definition: You add a Rigidbody by clicking "Add Component" and selecting Rigidbody.
Why important: This is how you enable physics for an object.
Simple explanation: Like putting a weight on an object.
Real-life example: A ball with Rigidbody falls.
School example: A student adds weight to a paper to keep it from blowing away.
Home example: A paperweight on a desk.
Nigerian example: A character with Rigidbody.
Illustration:
Add Rigidbody:
1. Select the object
2. Click "Add Component"
3. Type "Rigidbody"
4. Click it
Mini summary: Add Rigidbody to enable physics.
Definition: A Collider is a component that defines the shape of an object for collision detection.
Why important: Colliders allow objects to detect when they touch each other.
Simple explanation: Like an invisible shell around an object.
Real-life example: A ball has a round Collider.
School example: A box has a box Collider.
Home example: A chair has a Collider around it.
Nigerian example: A player has a Collider to detect hits.
Illustration:
+----------------------+
| Collider = |
| Invisible shape |
| → Detects touch |
| → Triggers events |
+----------------------+
Mini summary: Colliders detect when objects touch.
Definition: Unity has different Collider shapes: Box Collider, Sphere Collider, Capsule Collider, and Mesh Collider.
Why important: You choose the shape that best fits your object.
Simple explanation: Different shapes for different objects.
Real-life example: A sphere Collider for a ball.
School example: A box Collider for a crate.
Home example: A capsule Collider for a person.
Nigerian example: A mesh Collider for a complex object.
Illustration:
Collider Types:
📦 Box Collider
⚪ Sphere Collider
💊 Capsule Collider
🧊 Mesh Collider
Mini summary: Choose the Collider that fits your object.
Definition: Collision detection is when Unity detects that two objects have touched.
Why important: It allows you to respond to collisions — like taking damage or collecting items.
Simple explanation: Unity tells you when objects hit each other.
Real-life example: A player touches a coin and collects it.
School example: Two students bump into each other.
Home example: A glass hits a table.
Nigerian example: A character hits an enemy.
Illustration:
Collision Detection:
Object A → touches → Object B → event triggers
Mini summary: Collision detection tells you when objects touch.
Definition: OnCollisionEnter() is a function that runs when two objects with Colliders collide.
Why important: It lets you respond to collisions.
Simple explanation: It's like a doorbell that rings when someone touches the door.
Real-life example: A script that plays a sound when a ball hits a wall.
School example: A bell rings when a student enters the room.
Home example: A light turns on when a door opens.
Nigerian example: A game where a player collects coins when they touch them.
Illustration:
void OnCollisionEnter(Collision collision)
{
Debug.Log("Collision detected!");
}
Mini summary: OnCollisionEnter responds to collisions.
Definition: A Trigger is a Collider that detects when an object enters its space without physical collision.
Why important: Triggers are used for areas that cause effects — like collecting items or entering a zone.
Simple explanation: Like a sensor that detects when something passes through.
Real-life example: A sensor that opens a door when someone walks near.
School example: A motion sensor in a hallway.
Home example: A light that turns on when you walk into a room.
Nigerian example: A coin that is collected when the player walks over it.
Illustration:
Trigger:
🚪 Area detects entry
→ No physical collision
→ Events can be triggered
Mini summary: Triggers detect when objects enter an area.
Definition: OnTriggerEnter() is a function that runs when an object enters a Trigger.
Why important: It lets you respond to triggers.
Simple explanation: It's like a sensor that activates when something passes through.
Real-life example: A player enters a zone and gets a power-up.
School example: A student enters a room and a bell rings.
Home example: A light turns on when you walk into a room.
Nigerian example: A player collects coins by walking over them.
Illustration:
void OnTriggerEnter(Collider other)
{
Debug.Log("Trigger entered!");
}
Mini summary: OnTriggerEnter responds to triggers.
Definition: You have learned the basics of physics, Rigidbody, Colliders, and Triggers.
Why important: You can now make your game feel realistic and interactive.
Simple explanation: You know how to make objects fall, bounce, and interact.
Real-life example: You can create a game with coins and obstacles.
School example: You can build a physics-based game.
Home example: You can make a fun interactive game.
Nigerian example: You can develop a Nigerian-themed game with physics.
Illustration:
+----------------------+
| You understand |
| Physics and |
| Collisions! 🎉 |
| → Rigidbody |
| → Colliders |
| → Triggers |
+----------------------+
Mini summary: You are now ready to use physics and collisions in your games!
using UnityEngine;
public class CollectCoin : MonoBehaviour
{
void OnTriggerEnter(Collider other)
{
if (other.tag == "Player")
{
Destroy(gameObject);
Debug.Log("Coin collected!");
}
}
}
+----------------------+
| Game Object |
| → Rigidbody |
| → Collider |
| → Script (optional)|
+----------------------+
| Type | Best For |
|---|---|
| Box | Boxes, crates |
| Sphere | Balls, round objects |
| Capsule | Characters |
| Mesh | Complex shapes |
Collision: Objects bounce, physical contact
Trigger: Objects pass through, detect entry
In this module, we learned about physics and collisions in Unity. We discovered that Rigidbody adds physics to objects, Colliders detect collisions, and Triggers detect entry. We also learned how to use OnCollisionEnter and OnTriggerEnter to respond to interactions. With this knowledge, you can now make your games more realistic and interactive. Great job!
Match the word with its meaning:
| Word | Meaning |
|---|---|
| 1. Rigidbody | A) Defines shape for collisions |
| 2. Collider | B) Adds physics |
| 3. Trigger | C) Runs on collision |
| 4. OnCollisionEnter | D) Detects entry without physics |
| 5. OnTriggerEnter | E) Runs on trigger entry |
(Answers: 1-B, 2-A, 3-D, 4-C, 5-E)
Scenario 1: You want a ball to fall and bounce off the ground. What components would you add?
Scenario 2: You want to collect coins when the player walks over them. What would you use?
In groups of 3, create a simple scene with a player and collectibles. Use physics and triggers. Test it and share your results.
Create a scene with a ball and a ground. Add Rigidbody and Collider. Write a script to detect when the ball hits the ground.
Create a simple collection game. Use a player (sphere) with Rigidbody. Add collectibles (coins) with triggers. Write a script to destroy coins when collected.
Write a script that destroys an object when it collides with the player. Attach it to a collectible object. Test it.
Create a game where the player collects coins and avoids obstacles. Use physics, collisions, and triggers. Make the coins rotate.
Fill-in-the-blank: 1-Rigidbody, 2-Collider, 3-Trigger, 4-OnCollisionEnter, 5-OnTriggerEnter
True/False: 1-T, 2-F, 3-F, 4-T, 5-T
Matching: 1-B, 2-A, 3-D, 4-C, 5-E
In Module Five, we will learn about user interface and sound. We will add score, health, and music to our game. Before the next session, think about what UI elements you would like in your game.
See you in Module Five! 🎉
End of Module Four · Physics and Collisions
Hello, future game developer! In Module Four, we learned about physics and collisions. We learned how to make objects fall, bounce, and interact. Now we will learn how to make our game look and sound even better with User Interface (UI) and Sound.
UI is what players see on the screen — like scores, health bars, and menus. Sound adds music, sound effects, and atmosphere. In this module, we will learn how to add a score counter, health bar, and sound effects to our game. By the end of this module, you will be able to create a more polished and engaging game.
Amara is a young game developer in Abuja. She had built a game with a player, coins, and obstacles. But something was missing. The game felt empty. There was no score, no sound, no feedback.
She added a score counter to show how many coins the player collected. She added a health bar to show the player's health. She added sound effects for collecting coins and background music. Suddenly, the game felt alive. Players loved it. Amara learned that UI and sound make a game complete.
Definition: UI (User Interface) is everything the player sees on the screen — text, buttons, health bars, and menus.
Why important: UI gives players information and helps them interact with the game.
Simple explanation: It's like the dashboard of a car.
Real-life example: A score counter in a game.
School example: A whiteboard with information.
Home example: A thermostat display.
Nigerian example: A game score in a Nigerian game.
Illustration:
+----------------------+
| UI = |
| Score, health, |
| menus, buttons |
| → Player information |
+----------------------+
Mini summary: UI shows information to the player.
Definition: You create UI elements by right-clicking in the Hierarchy and choosing UI → Text, Image, Button, etc.
Why important: This is how you add text, images, and buttons to your game.
Simple explanation: Like adding labels and pictures to a poster.
Real-life example: A score text on the screen.
School example: A label on a project.
Home example: A sticky note on the fridge.
Nigerian example: A health bar in a game.
Illustration:
Create UI:
1. Right-click in Hierarchy
2. Choose UI → Text
3. Type your text
Mini summary: Create UI elements to display information.
Definition: Text is a UI element that displays words on the screen — like scores or instructions.
Why important: Text is the most common way to give information.
Simple explanation: Words on the screen.
Real-life example: Score: 100.
School example: A class schedule.
Home example: A to-do list.
Nigerian example: A game title.
Illustration:
Text Example:
"Score: 0"
Mini summary: Text displays words on the screen.
Definition: Image is a UI element that displays a picture — like a health bar or icon.
Why important: Images make the UI more visual and interesting.
Simple explanation: Pictures on the screen.
Real-life example: A health bar with a heart icon.
School example: A diagram on a poster.
Home example: A family photo.
Nigerian example: A coin icon in a game.
Illustration:
Image Example:
🧡 Health bar
Mini summary: Images make UI more visual.
Definition: You can update UI elements from scripts to show changing values — like scores and health.
Why important: This makes the UI dynamic and responsive.
Simple explanation: The UI changes as the game changes.
Real-life example: Score increases when you collect a coin.
School example: A timer counting down.
Home example: A weather app updating.
Nigerian example: Health decreases when hit.
Illustration:
public Text scoreText;
int score = 0;
void UpdateScore()
{
score++;
scoreText.text = "Score: " + score;
}
Mini summary: Scripts can update UI elements dynamically.
Definition: Sound includes music, sound effects, and voice. It makes games more immersive.
Why important: Sound adds emotion and feedback.
Simple explanation: Sound makes games feel alive.
Real-life example: A coin collection sound.
School example: A bell ringing.
Home example: A doorbell.
Nigerian example: Music in a Nigerian game.
Illustration:
+----------------------+
| Sound = |
| Music, effects, |
| voice |
| → Immersive games |
+----------------------+
Mini summary: Sound makes games more immersive.
Definition: Audio Source is a component that plays sound in Unity.
Why important: You need an Audio Source to play sound.
Simple explanation: It's like a speaker.
Real-life example: A speaker playing music.
School example: A classroom speaker.
Home example: A Bluetooth speaker.
Nigerian example: A game sound effect.
Illustration:
Audio Source:
🔊 Plays sound
🎵 Music
🎮 Effects
Mini summary: Audio Source plays sound in Unity.
Definition: You add sound effects by attaching an Audio Source to a Game Object and assigning a clip.
Why important: Sound effects give feedback to players.
Simple explanation: Like adding a sound to a button.
Real-life example: A coin collection sound.
School example: A buzzer sound.
Home example: A microwave beep.
Nigerian example: A game jump sound.
Illustration:
Add Sound:
1. Select object
2. Add Component → Audio Source
3. Assign Audio Clip
4. Play in script
Mini summary: Add sound effects to give feedback.
Definition: You can play sound from a script using AudioSource.Play().
Why important: This allows you to play sounds at the right time.
Simple explanation: You trigger sound when something happens.
Real-life example: Play a coin sound when collected.
School example: Play a bell when class ends.
Home example: Play a doorbell sound.
Nigerian example: Play a jump sound when the player jumps.
Illustration:
public AudioSource audioSource;
void PlaySound()
{
audioSource.Play();
}
Mini summary: Scripts can play sound effects.
Definition: You have learned how to add UI and sound to your game.
Why important: You can now create a more polished and engaging game.
Simple explanation: You know how to add score, health, and sound.
Real-life example: You can create a complete game experience.
School example: You can build a game with UI and sound.
Home example: You can make a fun interactive game.
Nigerian example: You can develop a Nigerian game with UI and sound.
Illustration:
+----------------------+
| You can add UI and |
| Sound! 🎉 |
| → Score |
| → Health |
| → Sound effects |
+----------------------+
Mini summary: You are now ready to add UI and sound to your games!
audioSource.Play() when needed.
using UnityEngine;
using UnityEngine.UI;
public class ScoreManager : MonoBehaviour
{
public Text scoreText;
int score = 0;
void Start()
{
UpdateScore();
}
void UpdateScore()
{
scoreText.text = "Score: " + score;
}
public void AddScore()
{
score++;
UpdateScore();
}
}
+----------------------+
| Score: 0 |
| ❤️ Health: 100 |
| 🪙 Coins: 0 |
+----------------------+
| Property | Description |
|---|---|
| Audio Clip | The sound file |
| Play On Awake | Play when game starts |
| Loop | Repeat sound |
| Volume | Loudness |
public Text scoreText;
int score = 0;
void UpdateScore()
{
scoreText.text = "Score: " + score;
}
In this module, we learned about User Interface and Sound. We discovered that UI shows information to players, and Sound makes games immersive. We learned how to create UI elements like Text and Image, how to update them from scripts, and how to add sound effects and background music. With this knowledge, you can now create a polished and engaging game. Great job!
Match the word with its meaning:
| Word | Meaning |
|---|---|
| 1. UI | A) Displays words |
| 2. Text | B) Plays sound |
| 3. Image | C) What the player sees |
| 4. Audio Source | D) Displays pictures |
| 5. Score | E) Tracks points |
(Answers: 1-C, 2-A, 3-D, 4-B, 5-E)
Scenario 1: You want to show the player's score on the screen. What would you create?
Scenario 2: You want to play a sound when the player collects a coin. What would you do?
In groups of 3, add UI and sound to a simple game. Each person focuses on a different element: score, health, or sound. Share your results.
Add a score counter to your game. When the player collects a coin, the score increases. Update the UI text.
Add a score counter, health bar, and sound effects to your game. Make sure the score updates when coins are collected and health changes.
Add a sound effect to your game when the player collects a coin. Use Audio Source and a script to play the sound.
Create a complete game with UI (score, health) and sound (coin collection, background music). Make it polished and fun.
Fill-in-the-blank: 1-User Interface, 2-Text, 3-Image, 4-Audio Source, 5-Background
True/False: 1-F, 2-T, 3-T, 4-F, 5-T
Matching: 1-C, 2-A, 3-D, 4-B, 5-E
In Module Six, we will learn about building and publishing your game. We will learn how to export your game and share it with others. Before the next session, think about how you would like to share your game.
See you in Module Six! 🎉
End of Module Five · User Interface and Sound
Hello, future game developer! In Module Five, we learned about User Interface and Sound. We learned how to add scores, health bars, and sound effects to our games. Now it is time for the final step: building and publishing your game.
Building means exporting your game into a format that others can play — like an executable file for Windows or an app for mobile. Publishing means sharing it with the world. In this module, we will learn how to build your game for different platforms and how to share it with others. By the end of this module, you will be able to share your game with friends, family, and the world.
Kemi is a young game developer in Lagos. She had built a fun game with a player, coins, obstacles, score, and sound. But her game was only in Unity. Her friends couldn't play it. She wanted to share it with them.
She learned how to build her game for Windows. She clicked File → Build Settings, selected Windows, and clicked Build. She got an executable file. She sent it to her friends. They could play it on their computers. Kemi was thrilled. She had published her first game.
She also built a Web version and shared it online. People from all over could play it. Kemi learned that building and publishing is the final step to becoming a game developer.
Definition: Building a game means exporting it into a format that can be played outside of Unity.
Why important: This is how you share your game with others.
Simple explanation: Like packaging a gift to give to someone.
Real-life example: Creating an .exe file for Windows.
School example: A student saves a project to share.
Home example: A family member prints a photo to share.
Nigerian example: A developer builds a game for Nigerian players.
Illustration:
+----------------------+
| Building = Export |
| → Playable format |
| → Share with others |
+----------------------+
Mini summary: Building is exporting your game to a playable format.
Definition: Build Settings is a window in Unity where you choose the platform and settings for your build.
Why important: It controls how your game will be exported.
Simple explanation: Like choosing the format for a document.
Real-life example: Choosing PC, Mac, or Web.
School example: Choosing a file format for a project.
Home example: Choosing a printer setting.
Nigerian example: Building for Windows or Android.
Illustration:
Build Settings:
File → Build Settings
Platform: Windows, Mac, Web
Scene: Add scenes
Build
Mini summary: Build Settings let you choose how to export your game.
Definition: Building for Windows creates an executable (.exe) file that runs on Windows computers.
Why important: Windows is the most common platform for PC games.
Simple explanation: Like creating a program that opens on a PC.
Real-life example: A game that runs on Windows.
School example: A program for a school computer.
Home example: A game for the family PC.
Nigerian example: A game for Nigerian players on Windows.
Illustration:
Build for Windows:
1. File → Build Settings
2. Select Windows
3. Click Build
4. Name the file
5. Wait for build
Mini summary: Build for Windows to create a .exe file.
Definition: Building for Web creates a game that runs in a browser.
Why important: Web games are easy to share — anyone with a browser can play.
Simple explanation: Like a game that runs on a website.
Real-life example: A game on a website.
School example: A game for the school website.
Home example: A game shared with family online.
Nigerian example: A game hosted on a Nigerian website.
Illustration:
Build for Web:
1. File → Build Settings
2. Select WebGL
3. Click Build
4. Create a folder
5. Open the index.html file
Mini summary: Build for Web to create a browser game.
Definition: You need to add all the scenes you want in your build.
Why important: Only the scenes you add will be included.
Simple explanation: Like selecting which pages to print.
Real-life example: Adding the main menu, game, and game over scenes.
School example: Adding all pages of a project.
Home example: Selecting photos for an album.
Nigerian example: Adding all levels of a Nigerian game.
Illustration:
Add Scenes:
1. Open Build Settings
2. Click "Add Open Scenes"
3. All scenes appear
4. They will be included in the build
Mini summary: Add all scenes you want in your build.
Definition: Player Settings let you customise your game's name, icon, and other details.
Why important: It makes your game look professional.
Simple explanation: Like adding a title and logo.
Real-life example: Setting the game name and icon.
School example: Adding a title to a project.
Home example: Labelling a box.
Nigerian example: Customising a Nigerian game's name.
Illustration:
Player Settings:
Company Name
Product Name
Icon
Resolution
Mini summary: Player Settings customise your game's appearance.
Definition: After building, you should test your game to make sure it works.
Why important: You want to catch any bugs before sharing.
Simple explanation: Like checking your work before submitting it.
Real-life example: Playing the game after building.
School example: Testing a project before presenting.
Home example: Trying a recipe before serving.
Nigerian example: Testing a game before publishing.
Illustration:
Test Your Build:
1. Run the .exe file
2. Play the game
3. Check for errors
4. Fix and rebuild if needed
Mini summary: Always test your build before sharing.
Definition: Sharing means making your game available to others.
Why important: This is the final step — you get to share your creation.
Simple explanation: Like giving a gift to friends.
Real-life example: Sending the .exe file to a friend.
School example: Sharing a project with classmates.
Home example: Sharing a game with family.
Nigerian example: Posting a game on a Nigerian platform.
Illustration:
Share Your Game:
1. Build the game
2. Send the file
3. Upload to a website
4. Share the link
Mini summary: Share your game with others and enjoy their feedback.
Definition: You have learned all the steps to create, build, and share a game.
Why important: You are now a game developer!
Simple explanation: You can create and share games.
Real-life example: You can build and publish your own games.
School example: You can create games for school projects.
Home example: You can make games for your family.
Nigerian example: You can develop games for the Nigerian market.
Illustration:
+----------------------+
| You are a Game |
| Developer! 🎉 |
| → Create |
| → Build |
| → Share |
+----------------------+
Mini summary: You are now a game developer!
Build for Windows:
Step 1: File → Build Settings
Step 2: Platform = Windows
Step 3: Add Open Scenes
Step 4: Set name to "MyGame"
Step 5: Build to "MyGame.exe"
Step 6: Test the game
Open Unity → Build Settings → Choose Platform → Add Scenes → Build → Test → Share
| Platform | Description |
|---|---|
| Windows | PC executable |
| WebGL | Browser game |
| Mac | Mac executable |
| Android | Mobile app |
☐ Add all scenes
☐ Set Player Settings
☐ Choose platform
☐ Build the game
☐ Test the game
☐ Share the game
In this final module, we learned about building and publishing your game. We discovered that building is the process of exporting your game into a playable format. We learned how to build for Windows and Web, how to add scenes, and how to test and share our games. With this knowledge, you can now share your creations with the world. Congratulations on completing this course! You are now a game developer.
Match the word with its meaning:
| Word | Meaning |
|---|---|
| 1. Build | A) The system your game runs on |
| 2. Platform | B) Export a game |
| 3. Scene | C) Customisation options |
| 4. Player Settings | D) A level or screen |
| 5. Test | E) Check for bugs |
(Answers: 1-B, 2-A, 3-D, 4-C, 5-E)
Scenario 1: You have finished your game. You want to share it with friends. What would you do?
Scenario 2: You built your game, but it doesn't work. What would you do?
In groups of 3, build your games and share them with each other. Test each other's games and give feedback.
Build your game for Windows or Web. Test it and share it with a friend or family member. Write about their feedback.
Build your complete game for Windows and Web. Test both versions. Share them with your class.
Build your game and share it with at least 3 people. Collect their feedback and write a short report.
Build your game for two different platforms (e.g., Windows and Web). Compare the build sizes and performance.
Fill-in-the-blank: 1-playable, 2-Build, 3-platform, 4-.exe, 5-Player
True/False: 1-T, 2-F, 3-T, 4-F, 5-F
Matching: 1-B, 2-A, 3-D, 4-C, 5-E
Congratulations! You have completed all 6 modules of the "Game Development with Unity" course. You now have the skills to create, build, and share your own games.
Here are some ideas for your next steps:
Thank you for being part of this course. You are now a game developer! 🎉
End of Module Six · Building and Publishing Your Game
End of Course · Game Development with Unity