📘 Module 1: Advanced Review and Systems Thinking – Level 3

“Thinking like an expert game developer.”

🌟 Module Introduction

Welcome to Level 3 of the Certified Scratch Expert course!

You have come a long way. In Level 1, you learned the basics. In Level 2, you mastered lists, custom blocks, game states, AI, spawning, physics, extensions, and polish. Now, in Level 3, you will become a true expert.

In this module, we will review what you learned in Level 2 and introduce the expert mindset – systems thinking. Systems thinking means looking at your project as a whole, understanding how different parts work together, and planning your code carefully.

Think of it like building a house. A carpenter doesn't just hammer nails randomly – they follow a plan, they understand how each part fits together, and they think about the whole project. That's systems thinking.

Let's begin your journey to becoming a Scratch Expert Level 3!

🎯 Learning Objectives

• Review and apply all Level 2 concepts: lists, custom blocks, game states, AI, spawning, physics, extensions, and polish.
• Understand and apply systems thinking to complex projects.
• Write a detailed Game Design Document (GDD) for a complex game.
• Use systematic approaches to debug and fix code.
• Think like an expert game developer.

📖 Warm-up Story: The Expert Builder

Imagine you are building a big, complex Lego castle. You don't just dump all the bricks on the floor and start sticking them together randomly. You look at the picture, plan which parts go where, and build it section by section.

This is how expert game developers work. They think about the whole project first. They break it down into smaller parts. They plan, organize, and then code.

In this module, we will learn how to think like that – like an expert builder, an expert game developer.

📚 Main Lessons

Lesson 1: What is Systems Thinking?

Definition: Systems thinking is looking at a project as a whole and understanding how its parts work together.

Why important: It helps you plan, organize, and build complex projects successfully.

Simple explanation: It's like looking at a car – you don't just see the wheels; you see how the engine, wheels, steering, and brakes all work together.

Real-life example: An architect designs a building by thinking about how all the rooms connect.

School example: A teacher plans a lesson by thinking about the introduction, main activity, and conclusion.

Home example: Planning a party – you think about food, music, games, and guests.

Nigerian example: A market planner organizes stalls by product type – food, clothes, electronics.

    Systems Thinking:
    ┌─────────────────────────────────────────────┐
    │  Whole Project                             │
    │  ├── System 1: Player Controls             │
    │  ├── System 2: Enemy AI                    │
    │  ├── System 3: Scoring                     │
    │  └── System 4: User Interface              │
    └─────────────────────────────────────────────┘
    

Lesson 2: Review – Lists in Level 2

Definition: Lists store collections of data – like high scores or inventory items.

Why important: Lists help you manage many pieces of data.

Simple explanation: A list is like a shelf with many boxes – each box holds one item.

Nigerian example: A list of items in a market stall.

    Lists Review:
    ┌─────────────────────────────────────────────┐
    │  highScores = [100, 80, 60, 40, 20]        │
    │  inventory = ["apple", "sword", "shield"]   │
    └─────────────────────────────────────────────┘
    

Lesson 3: Review – Custom Blocks

Definition: Custom blocks are blocks you create yourself to reuse code.

Why important: They save time and keep code organized.

Nigerian example: A "jump" block used many times in a platformer.

Lesson 4: Review – Game States

Definition: Game states are the phases of a game – start, play, win, game over.

Why important: They organize the flow of your game.

Nigerian example: A game with a start screen, play state, and game over screen.

Lesson 5: Review – Enemy AI

Definition: AI makes enemies behave in smart ways – patrol, chase, attack.

Why important: AI makes games challenging and fun.

Nigerian example: Enemies that chase the player.

Lesson 6: Review – Spawning Systems

Definition: Spawning creates objects dynamically – like enemies or items.

Why important: Spawning makes games dynamic.

Nigerian example: Enemies that appear at random times.

Lesson 7: Review – Physics

Definition: Physics simulates real-world motion – gravity, velocity, collisions.

Why important: Physics makes games realistic.

Nigerian example: A character jumping and falling.

Lesson 8: Review – Extensions

Definition: Extensions add new features – Pen, Music, Video Sensing.

Why important: Extensions unlock new creative possibilities.

Nigerian example: Using the Pen extension to draw Nigerian flags.

Lesson 9: Review – Polish

Definition: Polish is the small details that make a game look professional.

Why important: Polish makes games feel complete.

Nigerian example: Adding sound effects and a title screen.

Lesson 10: Writing a Game Design Document (GDD)

Definition: A GDD is a written plan for your game.

Why important: A GDD keeps you organized and focused.

What to include:

• Title: What is your game called?
• Goal: What is the player trying to do?
• Characters: What sprites will you use?
• Setting: What backdrop will you use?
• Controls: How does the player control the game?
• Scoring: How does the player score?
• Lives: How many lives?
• Levels: How many levels?
• Enemies: What enemies?
• Power-ups: What special items?
• End condition: When does the game end?

Nigerian example: A GDD for a game about Lagos.

Lesson 11: Systematic Debugging

Definition: Debugging is finding and fixing mistakes in code.

Why important: Debugging is a key skill for experts.

Steps:

1. Identify the problem.
2. Check the code.
3. Test with different values.
4. Use "wait" and "say" blocks to check values.
5. Fix the issue.

Nigerian example: A student systematically finds and fixes a bug in their game.

Lesson 12: Thinking Like an Expert

Why important: Experts think differently – they plan, organize, and break down problems.

How to think like an expert:

• Plan before you code.
• Break big problems into smaller ones.
• Test your code often.
• Learn from mistakes.
• Keep learning.

📌 Key Vocabulary

🧠 Important Concepts

• Plan: Always plan before coding.
• Organize: Keep your code organized.
• Systems: Think about how parts connect.

🔢 Steps to Perform Key Tasks

Task 1: Write a GDD

1. Choose a game idea.
2. Write the title, goal, characters, controls, scoring, and end condition.
3. Review and refine.

Task 2: Debug a Game

1. Play your game and find a problem.
2. Identify the likely cause.
3. Test with "say" blocks.
4. Fix the problem.
5. Test again.

Task 3: Think Like an Expert

1. Choose a complex project.
2. Break it down into smaller parts.
3. Plan each part.
4. Build and test.

🔢 Step-by-step: Writing a Game Design Document

1. Title – give your game a name.
2. Goal – what does the player need to do?
3. Characters – list all sprites.
4. Setting – what backdrop?
5. Controls – keyboard, mouse, or touch?
6. Scoring – how does the player score?
7. Lives – how many lives?
8. Levels – how many levels?
9. Enemies – what enemies?
10. Power-ups – what special items?
11. End condition – when does the game end?

🧸 Fun Examples for Children

• Lego building: Planning a Lego castle.
• Party planning: Planning a birthday party.

🏠 Everyday Examples

• Family trip: Planning a family vacation.
• School project: Planning a science fair project.

👪 Parent Tips

• Help your child think about the whole project.
• Encourage them to plan before coding.
• Show them how experts break down big problems.

💡 Interesting Facts

• Professional game developers spend weeks planning.
• Systems thinking is used in many fields – engineering, business, and more.
• Scratch was designed to teach systems thinking.

❓ Did You Know?

• Many professional games start with a Game Design Document.
• Scratch has over 100 million projects.

🔔 Remember This

• Think about the whole project.
• Plan before you code.
• Break big problems into smaller parts.
• Test and debug systematically.
• Keep learning and improving.

⚠️ Common Mistakes

• "I'll just start coding." – Always plan first.
• "I don't need a GDD." – A GDD helps you stay organized.
• "I'll fix bugs later." – Debug as you go.
• "I can't break it down." – Break it into smaller pieces.

✅ Best Practices

• Write a GDD before coding.
• Break your project into systems.
• Test your code often.
• Debug systematically.
• Keep learning and improving.

📊 Comparison: Beginner vs Expert Mindset

Beginner	Expert
Starts coding without planning	Plans before coding
Sees the project as one big thing	Breaks it down into systems
Fixes bugs randomly	Debugs systematically
Stops learning	Keeps learning

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is systems thinking?
  Seeing the whole project and how parts connect.
• Q2: What is a GDD?
  A Game Design Document – a written plan.
• Q3: Why plan before coding?
  Planning saves time and keeps you organized.
• Q4: What is systematic debugging?
  A structured way to find and fix bugs.
• Q5: What is the expert mindset?
  Plan, organize, and keep learning.
• Q6: Why break down projects?
  It makes them easier to build.
• Q7: What are systems?
  Connected parts of a project.
• Q8: What is Level 3 about?
  Advanced game development and expert skills.
• Q9: How do I become an expert?
  Practice, plan, and keep learning.
• Q10: What's next after this module?
  Advanced data structures and game mechanics!

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. GDD	A. A written plan for your game
2. Systems thinking	B. Seeing the whole project
3. Debug	C. Finding and fixing mistakes
4. Expert	D. Someone who is very skilled

(Answers: 1-A, 2-B, 3-C, 4-D)

🎭 Scenario-based Exercise

Scenario: A student wants to create a complex game with multiple levels, enemies, and power-ups. They don't know where to start.

Question: How would you help them using systems thinking and a GDD?

👥 Group Activity

In groups of 4, brainstorm a game idea and write a GDD. Each person focuses on a different system – player controls, enemies, scoring, and UI.

✍️ Individual Activity

Write a Game Design Document for a game of your choice. Include title, goal, characters, controls, scoring, and end condition.

🛠️ Mini Project

Create a simple game that demonstrates systems thinking – break it into at least 3 systems (player, enemies, scoring).

📋 Practical Assignment

Find a bug in a game you have created. Use systematic debugging to fix it. Write a reflection on the process.

🔑 Key Takeaways

• Systems thinking is essential for complex projects.
• Plan with a Game Design Document.
• Debug systematically.
• Think like an expert – plan, organize, and keep learning.

💬 Classroom Discussion Questions

• What is the most important part of planning a game?
• How can systems thinking help you code better?
• What is the difference between a beginner and an expert?
• What is the most important thing you learned in Level 2?

🔜 Preparation for Module 2

In Module 2, we will explore Advanced Data Structures. You will learn how to use multi-dimensional lists, clone-specific variables, and cloud data.

Think about a game that needs to store complex data – like a tile map or an inventory system. We will learn how to build them!

---

You have completed Module 1 – you are thinking like an expert! 🎉

📘 Module 2: Advanced Data Structures – Level 3

“Managing complex data like an expert.”

🌟 Module Introduction

In Module 1, we reviewed Level 2 concepts and learned about systems thinking. Now it's time to dive into advanced data structures.

In Level 2, you learned about lists – simple collections of items. In Level 3, we will go much further. We will learn how to use multi-dimensional lists (lists of lists), how to give each clone its own variables, and how to store data using cloud variables.

Think of it like moving from a small notebook to a powerful database. With advanced data structures, you can create more complex and interesting games – like tile maps, advanced inventory systems, and online high scores.

Let's explore the power of advanced data!

🎯 Learning Objectives

• Understand advanced data structures and why they are important.
• Use multi-dimensional lists (lists of lists) to simulate 2D arrays.
• Give individual clones their own properties using clone-specific variables.
• Use cloud variables for high scores and save states.
• Apply these concepts to create complex game systems.

📖 Warm-up Story: The Map Maker

Imagine you are creating a game with a big world – like a treasure map. You need to store information about each tile – is it grass, water, or a wall? A simple list won't work because you need a grid.

You use a multi-dimensional list – a list of lists. Each row is a list, and each item in the row stores the tile type.

This is the power of advanced data structures – they help you organize complex data in your games.

📚 Main Lessons

Lesson 1: What Are Advanced Data Structures?

Definition: Advanced data structures are ways to organize and store complex data.

Why important: They help you manage complex game data – like maps, inventories, and player stats.

Simple explanation: If a simple list is a shelf, a multi-dimensional list is a bookshelf with many rows.

Real-life example: A spreadsheet – rows and columns of data.

School example: A seating chart – rows and columns of seats.

Home example: A wardrobe – shelves with different types of clothes.

Nigerian example: A market with rows of stalls – each row has different products.

    Advanced Data Structures:
    ┌─────────────────────────────────────────────┐
    │  Multi-dimensional lists (lists of lists)  │
    │  Clone-specific variables                  │
    │  Cloud variables                           │
    └─────────────────────────────────────────────┘
    

Lesson 2: Review – Simple Lists

Definition: A simple list is a collection of items.

Why important: Lists are the foundation of advanced data structures.

Example: highScores = [100, 80, 60, 40, 20]

Lesson 3: Multi-Dimensional Lists – Lists of Lists

Definition: A multi-dimensional list is a list that contains other lists.

Why important: It's used for grids, maps, and complex data.

How to create:

• Create a list called "map".
• Add items to the list – but each item is also a list.
• Use nested loops to access items.

Nigerian example: A map of a city – each row is a street, each column is a building.

    Multi-Dimensional List:
    ┌─────────────────────────────────────────────┐
    │  map = [                                    │
    │  [1, 1, 1, 1, 1],  ← row 1                 │
    │  [1, 0, 0, 0, 1],  ← row 2                 │
    │  [1, 0, 2, 0, 1],  ← row 3                 │
    │  [1, 0, 0, 0, 1],  ← row 4                 │
    │  [1, 1, 1, 1, 1]   ← row 5                 │
    │  ]                                          │
    │  1 = wall, 0 = floor, 2 = treasure         │
    └─────────────────────────────────────────────┘
    

Lesson 4: Creating a 2D Grid with Lists

Why important: Grids are used in many games – maps, mazes, and board games.

Steps:

1. Create a list called "grid".
2. Use a "repeat" loop to add rows.
3. Each row is a list of values.
4. Access items using "item row of grid" and "item column of row".

Nigerian example: A chessboard – 8 rows and 8 columns.

Lesson 5: Accessing Items in a Multi-Dimensional List

Why important: You need to read and write data in your grid.

How to access:

• Use "item row of grid" to get a row.
• Then use "item column of row" to get a specific item.
• Use loops to iterate through all items.

Nigerian example: Checking if a tile is a wall or a floor.

Lesson 6: Using Multi-Dimensional Lists for Tile Maps

Definition: A tile map is a grid that defines the layout of a game world.

Why important: Tile maps are used in platformers, RPGs, and strategy games.

Steps:

1. Define a grid with numbers (0 = floor, 1 = wall, etc.).
2. Draw the tiles on the stage using the grid data.
3. Use the grid for collision detection.

Nigerian example: A game map of Lagos with streets, buildings, and landmarks.

Lesson 7: Clone-Specific Variables

Definition: Clone-specific variables are variables that belong to a specific clone, not the original sprite.

Why important: They allow each clone to have its own properties – like health, speed, or position.

How to create:

• Create a variable "for this sprite only".
• Each clone has its own copy of the variable.

Nigerian example: Each enemy clone has its own health and speed.

    Clone-Specific Variables:
    ┌─────────────────────────────────────────────┐
    │  Original Sprite                           │
    │  Clone 1: health = 10, speed = 2           │
    │  Clone 2: health = 5, speed = 3            │
    │  Clone 3: health = 8, speed = 1            │
    └─────────────────────────────────────────────┘
    

Lesson 8: Creating Clone-Specific Variables

Steps:

1. Create a variable called "health".
2. In the variable settings, choose "For this sprite only".
3. In "when I start as a clone", set health to a random value.
4. Each clone will have its own health.

Nigerian example: Each enemy has its own health.

Lesson 9: Using Clone-Specific Variables for Enemies

Why important: Enemies with different health and speed are more interesting.

Steps:

• Create a clone for each enemy.
• Assign random health and speed to each.
• Use the values in the game logic.

Nigerian example: Enemies with different health levels.

Lesson 10: Cloud Variables – Storing Data Online

Definition: Cloud variables store data on the Scratch cloud – they persist across sessions.

Why important: Cloud variables allow high scores and save states.

How to use:

• Create a variable and check "Cloud variable".
• The value is stored on Scratch's servers.
• It can be accessed by anyone who plays your project.

Nigerian example: A game with a global high score leaderboard.

Lesson 11: Using Cloud Variables for High Scores

Why important: High scores motivate players to play again.

Steps:

1. Create a cloud variable called "highScore".
2. When a game ends, check if the score is higher.
3. If so, update the cloud variable.

Nigerian example: A game where players compete for the highest score.

Lesson 12: Combining Data Structures for Complex Systems

Why important: Combining lists, clone variables, and cloud variables creates powerful systems.

Example:

• Use a list for a tile map.
• Use clone variables for enemy health.
• Use cloud variables for high scores.

Nigerian example: A complete game with a map, enemies, and a leaderboard.

📌 Key Vocabulary

🧠 Important Concepts

• Complexity: Advanced data structures handle complex data.
• Flexibility: They adapt to different needs.
• Power: They enable more sophisticated games.

🔢 Steps to Perform Key Tasks

Task 1: Create a Multi-Dimensional List

1. Create a list called "grid".
2. Add rows as lists.
3. Access items with row and column indices.

Task 2: Use Clone-Specific Variables

1. Create a variable "for this sprite only".
2. In "when I start as a clone", set the variable.
3. Use it in your game.

Task 3: Use a Cloud Variable

1. Create a variable and check "Cloud variable".
2. Update it when the player scores.
3. Display it on screen.

🔢 Step-by-step: Creating a Tile Map

1. Create a list – called "map".
2. Add rows – each row is a list of numbers.
3. Create sprites for tiles – for walls, floors, etc.
4. Use a loop – to draw the tiles on the stage.
5. Use the map – for collision detection.
6. Test your map – make sure it works.

🧸 Fun Examples for Children

• Treasure map: A grid map with treasure locations.
• Maze game: A grid that defines a maze.

🏠 Everyday Examples

• Seating chart: A grid of seats.
• Calendar: A grid of days.

👪 Parent Tips

• Help your child understand grids – like a chessboard.
• Explain how cloud variables work – like saving a game online.
• Encourage them to use advanced data structures in their games.

💡 Interesting Facts

• Multi-dimensional lists are called "arrays" in other languages.
• Cloud variables are limited to 10 per project.
• Clone variables are a unique feature of Scratch.

❓ Did You Know?

• You can have lists of lists of lists – 3D arrays!
• Cloud variables can be used for multiplayer games.

🔔 Remember This

• Multi-dimensional lists are lists of lists.
• They are used for grids and tile maps.
• Clone-specific variables give each clone its own properties.
• Cloud variables store data online.
• Combine them for powerful games.

⚠️ Common Mistakes

• Using the wrong index. – Check row and column numbers.
• Not setting clone variables. – Set them in "when I start as a clone".
• Cloud variables not updating. – Make sure you change the value.
• Too many cloud variables. – Only 10 per project.

✅ Best Practices

• Use meaningful names for lists and variables.
• Check indices carefully.
• Initialize clone variables in "when I start as a clone".
• Update cloud variables only when needed.
• Combine data structures for complex systems.

📊 Comparison: Simple List vs Multi-Dimensional List

Simple List	Multi-Dimensional List
One-dimensional	Two-dimensional
Stores one row	Stores a grid
Example: high scores	Example: tile map
Easy to use	More complex but powerful

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is a multi-dimensional list?
  A list that contains other lists.
• Q2: What is a tile map?
  A grid that defines a game world.
• Q3: What is a clone-specific variable?
  A variable for a specific clone.
• Q4: What is a cloud variable?
  A variable stored online.
• Q5: How do I create a multi-dimensional list?
  Create a list and add other lists as items.
• Q6: How do I access items in a grid?
  Use row and column indices.
• Q7: How do I create a clone-specific variable?
  Create a variable "for this sprite only".
• Q8: How do I use a cloud variable?
  Create a variable and check "Cloud variable".
• Q9: How many cloud variables can I have?
  Up to 10 per project.
• Q10: Why are advanced data structures important?
  They enable more complex games.

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. Multi-dimensional list	A. A variable stored online
2. Clone-specific variable	B. A list of lists
3. Cloud variable	C. A variable for a specific clone
4. Tile map	D. A grid defining a game world

(Answers: 1-B, 2-C, 3-A, 4-D)

🎭 Scenario-based Exercise

Scenario: A student wants to create a game with a world map, enemies with different health, and a global high score.

Question: What data structures would you use?

👥 Group Activity

In groups of 4, each person designs a different data structure – one for a map, one for enemies, one for high scores, and one for inventory. Combine them into one project.

✍️ Individual Activity

Create a multi-dimensional list for a 5x5 grid. Add values and access them.

🛠️ Mini Project

Create a simple tile map game – a grid with walls and floors, and a character that can move around.

📋 Practical Assignment

Create a game that uses at least two advanced data structures – a multi-dimensional list and clone-specific variables. Write a reflection on your process.

🔑 Key Takeaways

• Multi-dimensional lists are lists of lists.
• They are used for grids and tile maps.
• Clone-specific variables give each clone its own properties.
• Cloud variables store data online.
• Combine data structures for powerful games.

💬 Classroom Discussion Questions

• What is the most useful advanced data structure?
• How can you use a tile map in a game?
• Why are clone variables useful?
• What would you use cloud variables for?

🔜 Preparation for Module 3

In Module 3, we will explore Advanced Game Mechanics. You will learn how to create scrolling worlds, portal systems, dynamic terrain, and complex AI.

Think about a game with a big world – we will learn how to build it!

---

You have completed Module 2 – you can now manage complex data! 🎉

📘 Module 3: Advanced Game Mechanics – Level 3

“Building professional-quality game features.”

🌟 Module Introduction

In Modules 1 and 2, we reviewed Level 2 concepts and learned advanced data structures. Now it's time to explore advanced game mechanics.

Game mechanics are the rules and systems that make a game work. In Level 2, you learned basic mechanics – movement, jumping, scoring, and simple AI. In Level 3, we will take it much further.

You will learn how to create scrolling worlds, portal systems, dynamic terrain, complex AI, and advanced physics. These are the features that make games feel professional and polished.

Let's build some amazing game mechanics!

🎯 Learning Objectives

• Create scrolling worlds (side-scrolling and top-down).
• Build portal systems for teleportation.
• Implement dynamic terrain that changes during gameplay.
• Create advanced AI – pathfinding, group tactics, and state machines.
• Apply advanced physics – gravity, friction, and momentum.

📖 Warm-up Story: The Epic Game

Imagine you are creating an epic adventure game. The world is huge – it scrolls as the player moves. There are portals that teleport the player to new areas. The terrain changes dynamically – bridges appear and disappear. The enemies are smart – they work together to catch the player.

These are advanced game mechanics. They make games feel professional and immersive. In this module, we will learn how to build them.

📚 Main Lessons

Lesson 1: What Are Advanced Game Mechanics?

Definition: Advanced game mechanics are complex rules and systems that make games more engaging.

Why important: They add depth, challenge, and fun to games.

Simple explanation: It's like adding special moves to a fighting game – they make the game more exciting.

Real-life example: A car with advanced features – power steering, anti-lock brakes.

School example: Advanced math concepts – algebra, calculus.

Home example: A smart home – lights that turn on automatically.

Nigerian example: A market with modern payment systems – mobile money.

    Advanced Game Mechanics:
    ┌─────────────────────────────────────────────┐
    │  Scrolling worlds                          │
    │  Portal systems                            │
    │  Dynamic terrain                           │
    │  Complex AI                                │
    │  Advanced physics                          │
    └─────────────────────────────────────────────┘
    

Lesson 2: Scrolling Worlds – Side-Scrolling

Definition: A side-scrolling world moves as the player moves – like a 2D platformer.

Why important: It allows large, continuous levels.

How to create:

• Move the background and sprites opposite to the player.
• Use a camera system – track the player's position.
• Scroll the world when the player moves.

Nigerian example: A game where you run through the streets of Lagos.

    Side-Scrolling:
    ┌─────────────────────────────────────────────┐
    │  Player moves right → world moves left     │
    │  Background scrolls slowly                 │
    │  Platforms appear and disappear            │
    └─────────────────────────────────────────────┘
    

Lesson 3: Top-Down Scrolling

Definition: In top-down scrolling, the view moves from above – like a map.

Why important: It's used in RPGs, adventure games, and strategy games.

How to create:

• Move the background and sprites in all directions.
• Use a camera that follows the player.
• Scroll both horizontally and vertically.

Nigerian example: A game where you explore a city map.

Lesson 4: Portal Systems – Teleportation

Definition: Portals allow the player to teleport from one place to another.

Why important: Portals add mystery and convenience to games.

How to create:

• Create two portal sprites.
• When the player touches one, move to the other.
• Add visual effects for teleportation.

Nigerian example: A game where you teleport between different markets.

Lesson 5: Dynamic Terrain – Changing the World

Definition: Dynamic terrain changes during gameplay – bridges, lava, or walls.

Why important: It adds challenge and variety.

How to create:

• Use clones or sprite switching.
• Change terrain based on time, score, or events.
• Use lists to store terrain states.

Nigerian example: A game where the river floods and changes the path.

Lesson 6: Advanced Physics – Gravity, Friction, Momentum

Definition: Advanced physics adds more realistic motion.

Why important: It makes games feel more realistic and responsive.

How to implement:

• Gravity: Pulls objects down.
• Friction: Slows objects down.
• Momentum: Objects keep moving.

Nigerian example: A car game with realistic acceleration and braking.

Lesson 7: Complex AI – Pathfinding

Definition: Pathfinding is when enemies find the best route to the player.

Why important: Pathfinding makes enemies smarter.

How to implement:

• Use grid-based movement.
• Calculate the shortest path.
• Move step by step.

Nigerian example: Enemies that follow you through a maze.

Lesson 8: Complex AI – Group Tactics

Definition: Group tactics are when enemies work together.

Why important: Group tactics make games more challenging.

How to implement:

• One enemy leads, others follow.
• Enemies surround the player.
• Enemies coordinate attacks.

Nigerian example: A group of enemies that surround the player.

Lesson 9: Complex AI – State Machines (Advanced)

Definition: A state machine controls an enemy's behavior – idle, patrol, chase, attack.

Why important: State machines make enemies more realistic.

How to implement:

• Use a variable for the state.
• Switch between states based on conditions.
• Each state has different behavior.

Nigerian example: An enemy that waits, chases, and attacks.

Lesson 10: Combining Mechanics – Creating a Complete System

Why important: Combining mechanics creates a complete game.

Example:

• Scrolling world + portals + dynamic terrain + advanced AI.
• All mechanics work together for an immersive experience.

Nigerian example: A complete adventure game set in Nigeria.

Lesson 11: Testing and Balancing Advanced Mechanics

Why important: Advanced mechanics need testing and balancing.

How to test:

• Playtest thoroughly.
• Adjust values for balance.
• Get feedback from others.

Nigerian example: A game balanced for fun and challenge.

📌 Key Vocabulary

🧠 Important Concepts

• Integration: Mechanics should work together.
• Balance: Games should be challenging but fair.
• Testing: Test mechanics thoroughly.

🔢 Steps to Perform Key Tasks

Task 1: Create a Side-Scrolling World

1. Create a player sprite.
2. Add background sprites.
3. Move the background opposite to the player.
4. Test the scrolling.

Task 2: Create a Portal System

1. Create two portal sprites.
2. When the player touches one, move to the other.
3. Add visual effects.

Task 3: Implement Pathfinding

1. Create a grid map.
2. Calculate the shortest path.
3. Move the enemy step by step.

🔢 Step-by-step: Creating a Scrolling World

1. Create a player – control with arrow keys.
2. Add background sprites – multiple backdrops.
3. Create a camera variable – track the player's position.
4. Scroll the background – move opposite to the player.
5. Add platforms – they should also scroll.
6. Test your world – move left and right.

🧸 Fun Examples for Children

• Scrolling game: A runner game like Temple Run.
• Portal game: A puzzle game with teleportation.

🏠 Everyday Examples

• Video game: Mario – side-scrolling.
• Board game: Monopoly – dynamic board.

👪 Parent Tips

• Show your child how scrolling works in games.
• Help them understand portals – like in video games.
• Encourage them to test and balance their games.

💡 Interesting Facts

• Scrolling was a breakthrough in game design.
• Portals are used in many puzzle games.
• AI in games is a growing field.

❓ Did You Know?

• The first scrolling game was released in 1981.
• Portal was named "Game of the Year".

🔔 Remember This

• Scrolling creates large worlds.
• Portals let players teleport.
• Dynamic terrain changes the game.
• Advanced AI makes enemies smarter.
• Physics adds realism.
• Combine mechanics for a complete game.

⚠️ Common Mistakes

• Scrolling too fast. – Adjust speed.
• Portals not working. – Check coordinates.
• AI too hard. – Balance difficulty.
• Physics not realistic. – Adjust values.

✅ Best Practices

• Test scrolling speeds.
• Use clear portal markers.
• Balance AI difficulty.
• Adjust physics values.
• Combine mechanics for a complete game.

📊 Comparison: Basic vs Advanced Mechanics

Basic Mechanics	Advanced Mechanics
Simple movement	Scrolling worlds
Simple AI	Pathfinding, group tactics
No portals	Portal systems
Static terrain	Dynamic terrain
Simple physics	Advanced physics

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is scrolling?
  Moving world.
• Q2: What are portals?
  Teleportation devices.
• Q3: What is dynamic terrain?
  Changing world.
• Q4: What is pathfinding?
  Finding the best route.
• Q5: What are group tactics?
  Enemies working together.
• Q6: What is a state machine?
  Controls behavior.
• Q7: What is gravity?
  Pulls objects down.
• Q8: What is friction?
  Slows objects.
• Q9: What is momentum?
  Keeps objects moving.
• Q10: Why combine mechanics?
  For a complete game.

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. Scrolling	A. Teleportation
2. Portal	B. Moving world
3. Pathfinding	C. Finding the best route
4. Dynamic terrain	D. Changing world

(Answers: 1-B, 2-A, 3-C, 4-D)

🎭 Scenario-based Exercise

Scenario: A student wants to create a game with a large world, portals, and smart enemies.

Question: What mechanics would you use? How would you combine them?

👥 Group Activity

In groups of 4, each person creates a different advanced mechanic – one does scrolling, one does portals, one does AI, and one does dynamic terrain. Combine them into one game.

✍️ Individual Activity

Create a simple scrolling game. Save your project.

🛠️ Mini Project

Create a game that uses at least two advanced mechanics – scrolling, portals, dynamic terrain, or advanced AI.

📋 Practical Assignment

Create a game with advanced mechanics. Write a reflection on how you implemented them.

🔑 Key Takeaways

• Scrolling creates large worlds.
• Portals allow teleportation.
• Dynamic terrain changes the game.
• Advanced AI makes enemies smarter.
• Physics adds realism.
• Combine mechanics for a complete game.

💬 Classroom Discussion Questions

• What is the most interesting advanced mechanic?
• How can you use portals creatively?
• What makes AI "smart"?
• How can you balance advanced mechanics?

🔜 Preparation for Module 4

In Module 4, we will explore Advanced Game Development Projects. You will build complete games using all the skills you have learned.

Think about a game you want to build – we will create it in the next module!

---

You have completed Module 3 – your games now have advanced mechanics! 🎉

📘 Module 4: Advanced Game Development Projects – Level 3

“Building complete, polished games like a pro.”

🌟 Module Introduction

In Modules 1-3, we learned systems thinking, advanced data structures, and advanced game mechanics. Now it's time to build complete games using all these skills.

In this module, we will create several complete game projects. Each project will use the skills you have learned – from data structures to advanced mechanics. By the end, you will have a portfolio of advanced games.

Think of this as your "game development studio". You will build games step by step, learning how to organize, code, and polish each one.

Let's build some amazing games!

🎯 Learning Objectives

• Build a complete Pacman-style game with AI ghosts.
• Create a Space Shooter with enemy spawning and difficulty progression.
• Develop a Breakout game with power-ups and levels.
• Construct a Platformer with scrolling and multiple levels.
• Design a Point-and-Click Adventure with inventory and puzzles.

📖 Warm-up Story: The Game Developer's Portfolio

Imagine you are a game developer. You want to show your skills to the world. You need a portfolio of complete, polished games.

You build a Pacman game, a Space Shooter, a Breakout game, a Platformer, and an Adventure game. Each game is complete, polished, and fun to play.

You share your portfolio online. People are impressed. You get invited to join a game development team.

This is what we will do in this module – build a portfolio of advanced games.

📚 Main Lessons

Lesson 1: Project Overview – What We Will Build

Definition: We will build five complete games in this module.

Why important: Each game teaches different skills and techniques.

The games:

• Pacman: Movement, AI ghosts, collisions.
• Space Shooter: Enemy spawning, shooting, difficulty.
• Breakout: Movement, collisions, power-ups.
• Platformer: Scrolling, jumping, levels.
• Point-and-Click: Inventory, puzzles, storytelling.

Nigerian example: A collection of games inspired by Nigerian culture.

    Projects:
    ┌─────────────────────────────────────────────┐
    │  1. Pacman                                 │
    │  2. Space Shooter                          │
    │  3. Breakout                               │
    │  4. Platformer                             │
    │  5. Point-and-Click Adventure              │
    └─────────────────────────────────────────────┘
    

Lesson 2: Pacman – Movement and Maze

Definition: Pacman is a classic maze game.

Why important: It teaches movement, collision, and grid-based design.

Steps:

1. Create a maze using a grid (multi-dimensional list).
2. Create the Pacman sprite.
3. Use arrow keys to control movement.
4. Add collision detection with walls.
5. Add pellets to collect.

Nigerian example: A Pacman game set in a Nigerian market.

Lesson 3: Pacman – AI Ghosts

Definition: Ghosts are enemies that chase the player.

Why important: It teaches AI and pathfinding.

Steps:

1. Create ghost sprites.
2. Use clones to create multiple ghosts.
3. Make ghosts chase Pacman.
4. Add different ghost behaviors (chase, scatter, frightened).

Nigerian example: Ghosts wearing Nigerian patterns.

Lesson 4: Pacman – Scoring and Win Condition

Why important: Scoring makes the game competitive.

Steps:

1. Add a score variable.
2. Increase score when pellets are collected.
3. Win when all pellets are collected.
4. Add a game over when Pacman touches a ghost.

Lesson 5: Space Shooter – Player and Movement

Definition: A space shooter is a game where you shoot enemies.

Why important: It teaches shooting mechanics, spawning, and difficulty.

Steps:

1. Create a player sprite.
2. Control with arrow keys or mouse.
3. Add shooting with the space bar or click.

Nigerian example: A space shooter set in Nigerian space.

Lesson 6: Space Shooter – Enemy Spawning

Why important: Spawning creates the challenge.

Steps:

1. Create an enemy sprite.
2. Use cloning to spawn enemies.
3. Add random spawning at the top.
4. Enemies move down.

Lesson 7: Space Shooter – Difficulty Progression

Why important: Difficulty keeps players engaged.

Steps:

1. Increase enemy speed over time.
2. Spawn enemies faster.
3. Add boss enemies.

Lesson 8: Breakout – Movement and Collisions

Definition: Breakout is a classic ball-and-paddle game.

Why important: It teaches physics and collision detection.

Steps:

1. Create a paddle and a ball.
2. Use mouse movement for the paddle.
3. Add ball physics – bouncing off walls and paddle.

Nigerian example: A Breakout game with Nigerian colors.

Lesson 9: Breakout – Power-ups and Levels

Why important: Power-ups and levels add variety.

Steps:

1. Add power-ups – longer paddle, extra ball, etc.
2. Create multiple levels with different brick layouts.
3. Win when all bricks are destroyed.

Lesson 10: Platformer – Scrolling World

Definition: A platformer with scrolling and multiple levels.

Why important: It teaches scrolling, platform mechanics, and level design.

Steps:

1. Create a player with jumping and gravity.
2. Add scrolling – move the world as the player moves.
3. Design multiple levels with platforms.

Nigerian example: A platformer set in Nigerian landscapes.

Lesson 11: Point-and-Click Adventure – Inventory and Puzzles

Definition: An adventure game with inventory and puzzles.

Why important: It teaches storytelling, inventory management, and puzzle design.

Steps:

1. Create scenes and characters.
2. Add clickable objects.
3. Create an inventory list.
4. Design puzzles that require using items.

Nigerian example: An adventure game about Nigerian folklore.

Lesson 12: Portfolio and Sharing

Why important: Sharing your games is how you get recognized.

Steps:

1. Share your games on Scratch.
2. Create a portfolio page.
3. Add descriptions and screenshots.
4. Share with friends and online communities.

📌 Key Vocabulary

🧠 Important Concepts

• Variety: Different games teach different skills.
• Integration: Combine all skills in each game.
• Portfolio: A portfolio shows your skills.

🔢 Steps to Perform Key Tasks

Task 1: Build a Pacman Game

1. Create a maze grid.
2. Add Pacman and ghosts.
3. Add scoring and win condition.
4. Test your game.

Task 2: Build a Space Shooter

1. Create player and shooting.
2. Add enemy spawning.
3. Add difficulty progression.
4. Test your game.

Task 3: Build a Point-and-Click Adventure

1. Create scenes and characters.
2. Add clickable objects.
3. Create an inventory.
4. Design puzzles.

🔢 Step-by-step: Building a Pacman Game

1. Create a maze – use a grid (multi-dimensional list).
2. Add Pacman – control with arrow keys.
3. Add pellets – place them in the maze.
4. Add ghosts – create AI that chases Pacman.
5. Add scoring – increase score when pellets are collected.
6. Add win condition – win when all pellets are collected.
7. Add game over – when Pacman touches a ghost.
8. Test and polish – add sound and visuals.

🧸 Fun Examples for Children

• Pacman: A maze game with funny ghosts.
• Space Shooter: A game where you shoot aliens.

🏠 Everyday Examples

• Video games: Pacman, Space Invaders, Breakout.
• Adventure games: Point-and-click games.

👪 Parent Tips

• Show your child examples of each game type.
• Encourage them to complete each project.
• Help them share their games online.

💡 Interesting Facts

• Pacman is one of the most famous games.
• Space Invaders was a breakthrough.
• Breakout was created by Steve Jobs and Steve Wozniak.

❓ Did You Know?

• Pacman was originally called "Puck-Man".
• Breakout was made by Atari.

🔔 Remember This

• Build complete games.
• Use all your skills.
• Test and polish your games.
• Share your games.
• Build a portfolio.

⚠️ Common Mistakes

• Not testing. – Test your games thoroughly.
• No polish. – Add sound and visual effects.
• Not sharing. – Share your games to get feedback.
• Not completing projects. – Finish each game.

✅ Best Practices

• Plan each project before coding.
• Test your games after each change.
• Add polish – sound, visuals, UI.
• Share your games.
• Build a portfolio.
• Keep learning.

📊 Comparison: Game Projects

Game	Skills	Difficulty
Pacman	Maze, AI, scoring	Medium
Space Shooter	Spawning, shooting	Easy
Breakout	Physics, collisions	Easy
Platformer	Scrolling, levels	Hard
Adventure	Inventory, puzzles	Hard

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is Pacman?
  A classic maze game.
• Q2: What is a Space Shooter?
  A shooting game.
• Q3: What is Breakout?
  A ball-and-paddle game.
• Q4: What is a Platformer?
  A jumping game.
• Q5: What is a Point-and-Click?
  An adventure game.
• Q6: Why build multiple games?
  Different games teach different skills.
• Q7: How do I share my games?
  Share on Scratch.
• Q8: What is a portfolio?
  A collection of your work.
• Q9: How do I test my games?
  Play them and get feedback.
• Q10: What is the most important skill?
  Combining all skills.

🔗 Matching Exercise

Match the game with its description.

Game	Description
1. Pacman	A. Shooting game
2. Space Shooter	B. Maze game with ghosts
3. Breakout	C. Ball-and-paddle game
4. Platformer	D. Jumping and scrolling game

(Answers: 1-B, 2-A, 3-C, 4-D)

🎭 Scenario-based Exercise

Scenario: A student wants to build a portfolio of games to show to a college.

Question: What games would you recommend they build?

👥 Group Activity

In groups of 4, each person builds a different game. Share your games and give feedback.

✍️ Individual Activity

Choose one game project to build. Complete it and share it.

🛠️ Mini Project

Build a complete game of your choice. Use all the skills you have learned. Share your game with the class.

📋 Practical Assignment

Build a complete game. Write a reflection on the process – what you learned, what was challenging, and what you are proud of.

🔑 Key Takeaways

• Build complete games.
• Use all your skills.
• Test and polish.
• Share your games.
• Build a portfolio.

💬 Classroom Discussion Questions

• What is your favorite game to build?
• Which game was the most challenging?
• What would you add to improve your games?
• What will you build next?

🔜 Preparation for Module 5

In Module 5, we will explore Advanced Scratch Features. You will learn about the Pen extension, advanced cloning, broadcasting, and cloud variables.

Think about a project that could use advanced Scratch features – we will learn how to use them!

---

You have completed Module 4 – you have a portfolio of advanced games! 🎉

📘 Module 5: Advanced Scratch Features – Level 3

“Unlocking the full power of Scratch.”

🌟 Module Introduction

In Modules 1-4, we learned systems thinking, advanced data structures, advanced mechanics, and built complete games. Now it's time to explore the advanced features of Scratch itself.

Scratch has many powerful features that go beyond the basic blocks. In this module, we will explore the Pen extension in depth, advanced cloning techniques, complex broadcasting for structured game flow, and cloud variables for online data.

These features will allow you to create projects that are more visual, interactive, and connected.

Let's unlock the full power of Scratch!

🎯 Learning Objectives

• Use the Pen extension to create complex patterns, graphs, and bar charts.
• Implement advanced cloning for particle systems and complex effects.
• Use complex broadcasting for structured game flow.
• Use cloud variables to store and retrieve data across sessions.
• Combine advanced features to create innovative projects.

📖 Warm-up Story: The Creative Coder

Imagine you are a creative coder. You want to create a project that draws beautiful patterns, creates particle effects, and saves high scores online.

You use the Pen extension to draw intricate designs. You use advanced cloning to create particle explosions. You use cloud variables to save high scores.

Your project is creative, interactive, and professional. This is the power of advanced Scratch features.

📚 Main Lessons

Lesson 1: Pen Extension – Advanced Drawing

Definition: The Pen extension lets you draw on the stage.

Why important: It allows you to create graphics, patterns, and visualizations.

Advanced uses:

• Complex geometric patterns.
• Graphs and bar charts.
• Art and animations.
• Interactive drawing tools.

Nigerian example: Drawing Nigerian patterns with the Pen.

    Pen Extension:
    ┌─────────────────────────────────────────────┐
    │  pen down → start drawing                  │
    │  pen up → stop drawing                     │
    │  set pen color → change color              │
    │  set pen size → change thickness           │
    └─────────────────────────────────────────────┘
    

Lesson 2: Creating Complex Patterns with the Pen

Why important: Patterns are visually stunning.

How to create:

• Use loops to repeat movements.
• Change pen color and size each iteration.
• Use mathematical formulas for patterns.

Nigerian example: A Nigerian flag pattern.

Lesson 3: Drawing Graphs and Charts

Why important: Graphs visualize data.

How to create:

• Store data in a list.
• Loop through the list to draw bars.
• Add labels and axes.

Nigerian example: A bar chart of population in Nigerian states.

Lesson 4: Advanced Cloning – Particle Systems

Definition: Particle systems create many small objects for effects.

Why important: Particles create explosions, fire, rain, and more.

How to create:

• Create a sprite for a particle.
• Use cloning to create many particles.
• Give each particle random speed and direction.
• Delete particles when done.

Nigerian example: A fireworks display over Lagos.

Lesson 5: Creating Particle Effects – Explosions

Why important: Explosions are dramatic.

Steps:

1. When an event happens, create multiple clones.
2. Give each clone a random direction and speed.
3. Change color and size.
4. Delete clones after a short time.

Lesson 6: Advanced Broadcasting – Structured Game Flow

Definition: Broadcasting sends messages between sprites.

Why important: It coordinates complex game logic.

Advanced uses:

• Game state transitions (start, play, win, game over).
• Events (power-ups, level changes).
• Communication between systems.

Nigerian example: Broadcasting events in a game.

Lesson 7: Broadcast with Data – Sending Information

Why important: You can send data with broadcasts.

How to use:

• Use broadcast "message" with a variable.
• Store data in a variable before broadcasting.
• Use the data in the receiving script.

Lesson 8: Cloud Variables – Storing Data Online

Definition: Cloud variables store data on Scratch's servers.

Why important: They persist across sessions and are shared.

How to use:

• Create a variable and check "Cloud variable".
• Update the variable as needed.
• All players see the same value.

Nigerian example: A global high score for a game.

Lesson 9: Using Cloud Variables for High Scores

Why important: High scores motivate players.

Steps:

1. Create a cloud variable called "highScore".
2. When a game ends, check if the score is higher.
3. Update the cloud variable if needed.
4. Display the high score.

Lesson 10: Combining Advanced Features

Why important: Combining features creates powerful projects.

Example:

• Pen + Cloning: Draw with particle effects.
• Broadcasting + Cloud: Share events across players.
• Pen + Cloud: Visualize data from cloud variables.

Nigerian example: A project that draws a graph of cloud high scores.

Lesson 11: Performance Tips for Advanced Features

• Limit clones: Too many clones slow down the project.
• Use wait blocks: Avoid infinite loops.
• Optimize drawing: Use "pen up" when not drawing.
• Use cloud variables sparingly: Only update when needed.

Lesson 12: Creative Project Ideas

• Art generator: Uses Pen to create random art.
• Particle game: Explosions and effects.
• Global leaderboard: Uses cloud variables.
• Interactive dashboard: Graphs and data visualization.

📌 Key Vocabulary

🧠 Important Concepts

• Creativity: Advanced features unlock creative projects.
• Efficiency: Use features wisely for performance.
• Integration: Combine features for powerful results.

🔢 Steps to Perform Key Tasks

Task 1: Draw a Pattern

1. Add the Pen extension.
2. Use a loop to repeat movements.
3. Change color and size each time.
4. Test your pattern.

Task 2: Create a Particle Explosion

1. Create a particle sprite.
2. Use "create clone of myself" in a loop.
3. Give each clone random direction and speed.
4. Delete clones after a short time.
5. Test the effect.

Task 3: Save a High Score

1. Create a cloud variable called "highScore".
2. When a game ends, check if the score is higher.
3. Update the cloud variable.
4. Display the high score.

🔢 Step-by-step: Creating a Particle Explosion

1. Create a particle sprite – a small circle or dot.
2. Add "when green flag clicked" – hide the original sprite.
3. Add "when I receive explode" – create multiple clones.
4. Add "create clone of myself" – repeat 50 times.
5. Add "when I start as a clone" – set random direction and speed.
6. Add "change x by speed" and "change y by speed" – move the particle.
7. Add "delete this clone" – after a short time.
8. Test your explosion – broadcast "explode".

🧸 Fun Examples for Children

• Art project: Draw a rainbow.
• Fireworks: Create a fireworks show.

🏠 Everyday Examples

• Graphs: Bar charts in newspapers.
• Particles: Fireworks, rain, snow.

👪 Parent Tips

• Show your child how Pen creates art.
• Explain how cloud variables work – like a shared scoreboard.
• Encourage them to experiment with advanced features.

💡 Interesting Facts

• The Pen extension is inspired by Logo's turtle graphics.
• Particle systems are used in many video games.
• Cloud variables are limited to 10 per project.

❓ Did You Know?

• You can use the Pen to create animations.
• Cloud variables can be used for multiplayer games.

🔔 Remember This

• Pen draws on the stage.
• Particles create effects.
• Broadcasting coordinates logic.
• Cloud variables store data online.
• Combine features for powerful projects.

⚠️ Common Mistakes

• Too many clones. – Limit clones for performance.
• Not using "pen up". – Use "pen up" when not drawing.
• Cloud variables not updating. – Make sure you change the value.
• Broadcasts not received. – Make sure all sprites have receivers.

✅ Best Practices

• Limit clones to 50 for performance.
• Use "pen up" when not drawing.
• Update cloud variables only when needed.
• Use meaningful broadcast names.
• Combine features for creative projects.

📊 Comparison: Basic vs Advanced Features

Basic Features	Advanced Features
Simple drawing	Complex patterns
No particle effects	Particle systems
Simple broadcasts	Complex structured flow
No cloud data	Cloud variables

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is the Pen extension?
  Draws on the stage.
• Q2: What are particles?
  Small visual elements.
• Q3: What is broadcasting?
  Sending messages between sprites.
• Q4: What are cloud variables?
  Online data storage.
• Q5: How many cloud variables can I have?
  Up to 10.
• Q6: How do I create a particle system?
  Use cloning and random movement.
• Q7: How do I use broadcasting?
  Use "broadcast" and "when I receive".
• Q8: How do I save a high score?
  Use a cloud variable.
• Q9: Can I combine advanced features?
  Yes – for powerful projects.
• Q10: What is the most useful advanced feature?
  It depends on your project.

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. Pen	A. Online data storage
2. Particle	B. Drawing on the stage
3. Broadcast	C. Send a message
4. Cloud variable	D. Small visual element

(Answers: 1-B, 2-D, 3-C, 4-A)

🎭 Scenario-based Exercise

Scenario: A student wants to create a project that draws a graph of high scores saved in a cloud variable.

Question: What features would you use? How would you combine them?

👥 Group Activity

In groups of 4, each person explores a different advanced feature – one does Pen, one does particles, one does broadcasting, and one does cloud variables. Share your discoveries.

✍️ Individual Activity

Create a project that uses the Pen extension to draw a pattern. Save your project.

🛠️ Mini Project

Create a project that uses at least two advanced features – Pen, particles, broadcasting, or cloud variables.

📋 Practical Assignment

Create a project that uses advanced Scratch features. Write a reflection on how you used them.

🔑 Key Takeaways

• Pen draws on the stage.
• Particles create effects.
• Broadcasting coordinates logic.
• Cloud variables store data online.
• Combine features for powerful projects.

💬 Classroom Discussion Questions

• What is your favorite advanced feature?
• How can you use Pen creatively?
• What would you use cloud variables for?
• How can broadcasting improve your projects?

🔜 Preparation for Module 6

In Module 6, we will explore Game Polish and User Experience. You will learn how to make your games look and feel professional.

Think about a game you have created – how can you make it look better and be more fun to play?

---

You have completed Module 5 – you can now use advanced Scratch features! 🎉

📘 Module 6: Game Polish and User Experience – Level 3

“Making your games look and feel professional.”

🌟 Module Introduction

In Modules 1-5, we learned advanced concepts – systems thinking, data structures, advanced mechanics, complete game projects, and advanced Scratch features. Now it's time to focus on polish and user experience.

Polish is what makes a game feel complete and professional. It's the difference between a game that looks homemade and one that looks like it was made by a pro.

In this module, we will learn how to add polish to your games – advanced UI design, sound design, visual effects, playtesting, and user experience. Let's make your games shine!

🎯 Learning Objectives

• Design advanced user interfaces – custom menus, health bars, HUDs.
• Use the Music extension for custom soundtracks.
• Create visual effects – particle systems, screen shake, transitions.
• Apply polishing techniques that make games feel complete.
• Conduct structured playtests and iterate based on feedback.

📖 Warm-up Story: The Polished Game

Imagine two games. Game A is fun but has no sound, no visual effects, and a confusing interface. Game B has exciting sounds, cool effects, and a clear interface. Which game would you rather play?

Game B is polished. It feels professional and complete. In this module, we will learn how to make your games like Game B.

📚 Main Lessons

Lesson 1: What Is Polish?

Definition: Polish is the small details that make a game feel complete and professional.

Why important: Polish makes games more enjoyable and memorable.

Simple explanation: It's like adding icing to a cake – it makes it look and taste better.

Real-life example: A car with a shiny paint job and comfortable interior.

School example: A well-presented project with neat handwriting and illustrations.

Home example: A clean, organized room.

Nigerian example: A well-decorated shop with colorful displays.

    Polish Elements:
    ┌─────────────────────────────────────────────┐
    │  UI design                                 │
    │  Sound design                              │
    │  Visual effects                            │
    │  Playtesting                               │
    │  User experience                           │
    └─────────────────────────────────────────────┘
    

Lesson 2: Advanced UI Design – Custom Menus

Definition: UI is the user interface – menus, buttons, and displays.

Why important: Good UI helps players understand the game.

How to design:

• Use sprites for buttons.
• Add hover and click effects.
• Show clear labels.
• Use consistent colors and fonts.

Nigerian example: A game menu with Nigerian colors and patterns.

Lesson 3: Health Bars and HUDs

Definition: A health bar shows player health. HUD shows game information.

Why important: They help players understand their status.

How to create:

• Use a sprite that changes size based on health.
• Change color from green to red.
• Add a border for style.
• Display score, lives, and time.

Nigerian example: A health bar with Nigerian flag colors.

Lesson 4: Sound Design – Custom Soundtracks

Definition: Sound design is creating and using audio in games.

Why important: Sound enhances the gaming experience.

How to create:

• Use the Music extension to compose melodies.
• Record your own sounds.
• Use background music for atmosphere.
• Add sound effects for actions.

Nigerian example: A game with Afrobeats background music.

Lesson 5: Visual Effects – Particle Systems

Definition: Particle systems create effects like explosions, rain, and fire.

Why important: Particles add excitement and visual appeal.

How to create:

• Use cloning to create particles.
• Give each particle random speed and direction.
• Add color and size variation.
• Delete particles after a short time.

Nigerian example: Fireworks over Lagos.

Lesson 6: Screen Shake – Adding Impact

Definition: Screen shake is a camera effect that adds impact.

Why important: Screen shake makes actions feel powerful.

How to create:

• Change the position of all sprites randomly.
• Use a variable to control shake intensity.
• Fade the shake out over time.

Nigerian example: A game where explosions shake the screen.

Lesson 7: Transitions – Smooth Scene Changes

Definition: Transitions are effects between scenes or states.

Why important: Transitions make games feel smooth.

How to create:

• Use a fade effect – gradually change brightness.
• Use a slide effect – move sprites in and out.
• Use a zoom effect – scale sprites.

Nigerian example: A fade transition between levels.

Lesson 8: Polishing Techniques – Small Details

• Animations: Make sprites animate smoothly.
• Feedback: Show visual feedback for actions.
• Instructions: Add clear instructions.
• Title screen: Create a professional title screen.
• Credits: Add a credits screen.

Nigerian example: A game with a title screen showing Nigerian landmarks.

Lesson 9: Playtesting – Getting Feedback

Definition: Playtesting is having others play your game and give feedback.

Why important: Playtesting helps you see what you missed.

How to conduct:

• Ask friends or family to play.
• Watch them play and note problems.
• Ask for honest feedback.
• Use feedback to improve.

Nigerian example: A student tests their game with classmates.

Lesson 10: Iterating Based on Feedback

Definition: Iteration is making changes based on feedback.

Why important: Iteration makes games better.

Steps:

1. Collect feedback.
2. Identify areas to improve.
3. Make changes.
4. Test again.
5. Repeat.

Nigerian example: A student improves their game based on feedback.

Lesson 11: User Experience – Putting the Player First

Definition: UX is how the player feels when playing the game.

Why important: Good UX keeps players engaged.

How to improve UX:

• Make controls intuitive.
• Provide clear feedback.
• Make the game easy to learn.
• Add visual and audio feedback.

Lesson 12: Final Polish – Releasing Your Game

Why important: A polished game is more enjoyable and shareable.

Final steps:

• Add a title screen.
• Add instructions.
• Add a high score board.
• Add sound and visual effects.
• Share your game.

Nigerian example: A student shares their polished game on Scratch.

📌 Key Vocabulary

🧠 Important Concepts

• Professionalism: Polish makes games professional.
• Experience: UX focuses on the player.
• Iteration: Keep improving based on feedback.

🔢 Steps to Perform Key Tasks

Task 1: Create a Health Bar

1. Create a sprite for the health bar.
2. Use "set size to health * 10".
3. Change color based on health.
4. Add a border.

Task 2: Add a Screen Shake

1. Create a variable for shake intensity.
2. When an event happens, set shake to 10.
3. In a loop, change all sprite positions randomly.
4. Reduce shake over time.

Task 3: Conduct a Playtest

1. Ask a friend to play your game.
2. Watch and take notes.
3. Ask for feedback.
4. Make improvements.

🔢 Step-by-step: Creating a Health Bar

1. Create a sprite – draw a rectangle.
2. Add a variable – called "health".
3. Set health to 100 – at the start.
4. In a loop – set the sprite's size to health.
5. Change color – green for high health, red for low.
6. Test your health bar – change health to see it work.

🧸 Fun Examples for Children

• Pet game: Add a health bar for your pet.
• Space game: Add screen shake for explosions.

🏠 Everyday Examples

• Video games: Health bars in games.
• Movies: Sound effects and transitions.

👪 Parent Tips

• Show your child how polish makes games better.
• Encourage them to add sound and visual effects.
• Help them conduct playtesting with friends.

💡 Interesting Facts

• Polish can make a game 10x more enjoyable.
• Professional games spend months on polish.
• Players notice small details.

❓ Did You Know?

• Sound effects can be created with Scratch's built-in sounds.
• You can use the "pen" extension to create health bars.

🔔 Remember This

• Polish makes games professional.
• Sound and visual feedback are important.
• UI helps players understand the game.
• Playtesting helps you improve.
• Iteration makes games better.

⚠️ Common Mistakes

• No sound. – Add sound effects.
• No visual feedback. – Show what's happening.
• Confusing UI. – Make it clear and simple.
• No playtesting. – Get feedback.

✅ Best Practices

• Add sound effects for feedback.
• Add visual feedback for actions.
• Design clear and simple UI.
• Conduct playtesting.
• Iterate and improve.

📊 Comparison: Unpolished vs Polished Game

Unpolished	Polished
No sound	Sound effects and music
No visual feedback	Visual effects
Confusing UI	Clear and simple UI
No playtesting	Playtested and improved
No polish	Polished and complete

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is polish?
  Small details that make a game professional.
• Q2: What is UI?
  User interface.
• Q3: What is a health bar?
  Shows player health.
• Q4: What is screen shake?
  A camera effect.
• Q5: What is playtesting?
  Testing with players.
• Q6: Why is playtesting important?
  It helps you find problems.
• Q7: What is iteration?
  Making improvements.
• Q8: What is UX?
  User experience.
• Q9: How can I improve UX?
  Make controls intuitive and give clear feedback.
• Q10: How can I make my game look professional?
  Add polish – sound, visuals, and clear UI.

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. Polish	A. Testing with players
2. Playtesting	B. Small details that make a game professional
3. UI	C. User interface
4. Screen shake	D. Camera effect

(Answers: 1-B, 2-A, 3-C, 4-D)

🎭 Scenario-based Exercise

Scenario: A student has created a game but it feels unfinished. There is no sound, no visual feedback, and the UI is confusing.

Question: How would you polish this game?

👥 Group Activity

In groups of 4, each person takes a different aspect of polish – one does sound, one does visual effects, one does UI, and one does playtesting.

✍️ Individual Activity

Identify three things you can polish in a game you have created. Make the improvements and save your project.

🛠️ Mini Project

Take a game you have created and polish it. Add sound effects, visual feedback, a UI, and a title screen. Share your polished game.

📋 Practical Assignment

Conduct a playtest of your game with at least 2 people. Write a reflection on the feedback and what you improved.

🔑 Key Takeaways

• Polish makes games professional.
• Sound and visual feedback are important.
• UI helps players understand the game.
• Playtesting helps you improve.
• Iteration makes games better.

💬 Classroom Discussion Questions

• What is the most important part of polish?
• How can sound improve a game?
• Why is playtesting important?
• What would you add to a game to make it more fun?

🔜 Preparation for Module 7

In Module 7, we will explore Project Management and Collaboration. You will learn how to manage large projects and work with others.

Think about a big project you want to create – we will learn how to manage it!

---

You have completed Module 6 – your games are now polished! 🎉

📘 Module 7: Project Management and Collaboration – Level 3

“Managing complex projects and working with others.”

🌟 Module Introduction

In Modules 1-6, we learned advanced concepts, built games, and polished them. Now it's time to learn how to manage large projects and collaborate with others.

As you build more complex games, you need good project management skills. You need to plan, track progress, and stay organized. When working with others, you need to communicate and coordinate.

Think of this as learning how to be a project leader. You will learn how to plan, organize, and lead a team to create amazing projects.

Let's become great project managers!

🎯 Learning Objectives

• Understand the principles of project management.
• Plan and track large projects.
• Use Scratch's backup and remix features for version control.
• Collaborate effectively with others.
• Write clear documentation and comments for your code.

📖 Warm-up Story: The Game Studio

Imagine you are part of a small game studio – a team of four people. You want to create a big adventure game. Each person has a different role: one does the coding, one does the art, one does the sound, and one manages the project.

The project manager keeps everyone organized. They use a checklist, track progress, and make sure everyone is working together. They also save backups of the project.

Because of good project management, the game is completed on time and looks amazing.

In this module, we will learn how to be that project manager.

📚 Main Lessons

Lesson 1: What is Project Management?

Definition: Project management is the process of planning, organizing, and completing a project.

Why important: Good project management leads to successful projects.

Simple explanation: It's like planning a party – you decide what to do, who does what, and when it should be done.

Real-life example: A construction project – planning, building, and finishing a building.

School example: A group project – dividing tasks and meeting deadlines.

Home example: Planning a family holiday – deciding where to go, what to do, and when to travel.

Nigerian example: Organizing a festival – planning events, logistics, and coordination.

    Project Management:
    ┌─────────────────────────────────────────────┐
    │  Plan → Organize → Execute → Review        │
    └─────────────────────────────────────────────┘
    

Lesson 2: Planning Your Project

Why important: A good plan saves time and reduces stress.

What to plan:

• Goal: What do you want to achieve?
• Tasks: What needs to be done?
• Timeline: When will each task be done?
• Roles: Who will do what?
• Resources: What tools and materials do you need?

Nigerian example: Planning a game about Nigerian wildlife.

Lesson 3: Breaking Down a Project

Definition: Breaking down means dividing a big project into smaller tasks.

Why important: Smaller tasks are easier to complete.

How to break down:

• List all the features.
• Divide each feature into smaller tasks.
• Prioritize tasks.

Nigerian example: Breaking a game into systems – player, enemies, scoring, UI.

Lesson 4: Tracking Progress

Why important: Tracking helps you stay on schedule.

How to track:

• Use a checklist.
• Use a Kanban board (To Do, Doing, Done).
• Set deadlines.
• Review progress regularly.

Nigerian example: A game development team uses a checklist to track tasks.

Lesson 5: Version Control – Saving Your Work

Definition: Version control is managing different versions of your project.

Why important: It helps you recover from mistakes.

How to use:

• Save your project with version numbers (e.g., "Game_v1", "Game_v2").
• Use Scratch's "Save as" feature.
• Use Scratch's "Backup" feature.
• Use "Remix" to create branches.

Nigerian example: A student saves versions of their game as they work.

Lesson 6: Collaboration – Working with Others

Definition: Collaboration is working together on a project.

Why important: Many projects are team efforts.

How to collaborate:

• Communicate clearly.
• Divide tasks.
• Share work regularly.
• Give and receive feedback.

Nigerian example: A team of students creates a game together.

Lesson 7: Tools for Collaboration

Why important: Tools make collaboration easier.

Tools:

• Scratch Cloud: Share projects online.
• Google Docs: Share documents.
• Communication apps: WhatsApp, Slack, Discord.
• Project management tools: Trello, Asana.

Nigerian example: A team uses WhatsApp to communicate.

Lesson 8: Writing Documentation

Definition: Documentation is written information about your project.

Why important: Documentation helps others understand your code.

How to write:

• Add comments to your code.
• Write a README file.
• Explain how the game works.
• List the controls.

Nigerian example: A student adds comments to their code.

Lesson 9: Adding Comments to Your Code

Definition: Comments are notes you add to your code.

Why important: Comments explain what your code does.

How to add:

• Right-click on a block and add a comment.
• Explain what the script does.
• Use comments for complex sections.

Nigerian example: A student adds comments to explain their game logic.

Lesson 10: Code Reviews

Definition: A code review is when someone else looks at your code.

Why important: Code reviews find mistakes and improve quality.

How to conduct:

• Share your code with a teammate.
• Ask them to check for bugs.
• Suggest improvements.
• Learn from feedback.

Nigerian example: Two students review each other's code.

Lesson 11: Communication and Teamwork

Why important: Good communication is essential for teamwork.

How to communicate:

• Be clear and concise.
• Listen to others.
• Give constructive feedback.
• Be respectful.

Nigerian example: A team communicates effectively to complete a project.

Lesson 12: Presenting Your Project

Why important: Presenting shows your work to others.

How to present:

• Explain the goal of the project.
• Show how it works.
• Highlight key features.
• Share what you learned.

Nigerian example: A student presents their game to the class.

📌 Key Vocabulary

🧠 Important Concepts

• Planning: Plan before you start.
• Organization: Keep track of your work.
• Collaboration: Work effectively with others.

🔢 Steps to Perform Key Tasks

Task 1: Plan a Project

1. Write down the goal.
2. List all tasks.
3. Set a timeline.
4. Assign roles.

Task 2: Use Version Control

1. Save your project with a version number.
2. Make changes.
3. Save a new version.

Task 3: Write Documentation

1. Add comments to your code.
2. Write a README file.
3. Explain the game controls.

🔢 Step-by-step: Managing a Group Project

1. Plan – meet with the team and decide on the goal.
2. Break down – divide the project into tasks.
3. Assign roles – decide who does what.
4. Set deadlines – decide when each task should be done.
5. Track progress – use a checklist.
6. Communicate – talk regularly.
7. Review – check each other's work.
8. Present – share the finished project.

🧸 Fun Examples for Children

• Group project: A group of friends builds a game together.
• School project: A team creates a presentation.

🏠 Everyday Examples

• Family holiday: Planning a trip.
• Community event: Organizing a party.

👪 Parent Tips

• Help your child plan their projects.
• Encourage them to work with others.
• Show them how to use version control.

💡 Interesting Facts

• Project management is a real career.
• Version control is used by all professional developers.
• Collaboration is essential in the tech industry.

❓ Did You Know?

• Scratch has built-in version control with "Save as".
• Many companies use project management tools.

🔔 Remember This

• Plan before you start.
• Break down big projects.
• Track your progress.
• Use version control.
• Communicate with your team.
• Write documentation.

⚠️ Common Mistakes

• Not planning. – Always plan first.
• Not communicating. – Talk to your team.
• Not using version control. – Save different versions.
• Not writing comments. – Explain your code.

✅ Best Practices

• Plan your project.
• Break it down.
• Track your progress.
• Use version control.
• Write comments.
• Communicate with your team.
• Review each other's code.
• Present your work.

📊 Comparison: Solo vs Team Project

Solo Project	Team Project
You do everything	Tasks are divided
No communication needed	Communication is essential
Easier to manage	More complex to manage
Less feedback	More feedback

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is project management?
  Planning and completing projects.
• Q2: Why plan a project?
  Planning saves time.
• Q3: What is version control?
  Managing different versions.
• Q4: Why use version control?
  It helps you recover from mistakes.
• Q5: What is collaboration?
  Working with others.
• Q6: Why collaborate?
  Many projects are team efforts.
• Q7: What is documentation?
  Written information about your project.
• Q8: Why write comments?
  Comments explain your code.
• Q9: What is a code review?
  Checking someone's code.
• Q10: What is the most important skill?
  Planning and communication.

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. Project management	A. Working with others
2. Version control	B. Planning and completing projects
3. Collaboration	C. Managing different versions
4. Documentation	D. Written information

(Answers: 1-B, 2-C, 3-A, 4-D)

🎭 Scenario-based Exercise

Scenario: A group of students wants to create a big adventure game together. They need to plan, divide tasks, and communicate effectively.

Question: How would you manage this project?

👥 Group Activity

In groups of 4, plan a project together. Create a checklist, assign roles, and set deadlines.

✍️ Individual Activity

Write a plan for a project you want to create. Include the goal, tasks, timeline, and roles.

🛠️ Mini Project

Create a project plan for a game. Use version control by saving different versions.

📋 Practical Assignment

Create a project and use version control. Write documentation and add comments to your code.

🔑 Key Takeaways

• Plan your project.
• Break it down.
• Track your progress.
• Use version control.
• Write comments.
• Communicate with your team.
• Review each other's code.
• Present your work.

💬 Classroom Discussion Questions

• What is the most important part of project management?
• How can you work effectively with others?
• Why is version control important?
• What would you include in your project plan?

🔜 Preparation for Module 8

In Module 8, we will explore Exam Preparation and Capstone Project. You will review all the concepts and complete your final project.

Think about a game you want to build for your final project – we will create it in the next module!

---

You have completed Module 7 – you can now manage projects and collaborate! 🎉

📘 Module 8: Exam Preparation and Capstone Project – Level 3

“Putting everything together and earning your certification.”

🌟 Module Introduction

Congratulations! You have reached the final module of the Certified Scratch Expert Level 3 course. You have learned so much – systems thinking, advanced data structures, advanced mechanics, complete games, advanced features, polish, and project management.

Now it's time to put it all together. In this capstone module, you will plan, create, and finalize a complete, polished game that showcases everything you have learned.

You will also prepare for the Level 3 certification exam by reviewing key concepts and taking practice questions.

You will be a Certified Scratch Expert Level 3!

Let's finish strong!

🎯 Learning Objectives

• Plan a complete capstone game using all the skills you have learned.
• Build a polished, original game from start to finish.
• Create a portfolio of advanced Scratch projects.
• Review key concepts for the Level 3 certification exam.
• Practice exam-style questions.
• Explore career paths from Scratch to professional programming.

📖 Warm-up Story: The Certified Expert

Imagine you have completed all the modules. You have built amazing games, learned advanced concepts, and worked with others. Now you are ready to take the Level 3 certification exam.

You review everything you have learned. You take practice exams. You feel confident. You pass the exam with flying colors.

You are now a Certified Scratch Expert Level 3. You can add this to your portfolio, your resume, and your future career.

This is what we will achieve in this module.

📚 Main Lessons

Lesson 1: Capstone Project – Overview

Definition: A capstone project is a final project that shows everything you have learned.

Why important: It demonstrates your skills and gives you a portfolio piece.

Simple explanation: It's like a final exam – but instead of a test, you create a game.

Real-life example: A student creates a game for a coding competition.

School example: A final project for a computer class.

Home example: A game you share with your family.

Nigerian example: A young coder creates a game about Nigerian culture.

    Capstone Project:
    ┌─────────────────────────────────────────────┐
    │  Plan → Create → Polish → Share → Reflect  │
    └─────────────────────────────────────────────┘
    

Lesson 2: Choosing Your Capstone Game Idea

Why important: The right idea motivates you and shows your skills.

Ideas:

• A platformer with scrolling and multiple levels.
• A Pacman-style game with AI ghosts.
• A space shooter with difficulty progression.
• A breakout game with power-ups.
• A point-and-click adventure with inventory.
• An original game of your own design.

Nigerian example: A game about Nigerian folklore.

Lesson 3: Planning Your Capstone Project

Why important: A good plan leads to a good game.

What to plan:

• Write a Game Design Document (GDD).
• List all features and mechanics.
• Break the project into tasks.
• Set a timeline.

Nigerian example: A student writes a GDD for their game.

Lesson 4: Building Your Capstone Game

Why important: This is where you apply all your skills.

Steps:

1. Set up your project in Scratch.
2. Build the core mechanics.
3. Add advanced features (AI, spawning, physics, etc.).
4. Add polish (sound, visuals, UI).
5. Test and debug.

Nigerian example: A student builds a game with all the features.

Lesson 5: Testing and Polishing

Why important: Testing and polishing make your game professional.

Steps:

• Playtest with friends.
• Get feedback.
• Fix bugs.
• Add final polish.

Nigerian example: A student tests their game and makes improvements.

Lesson 6: Sharing Your Capstone Project

Why important: Sharing lets others enjoy your work.

How to share:

• Share on Scratch.
• Share the link with friends and family.
• Add to your portfolio.

Nigerian example: A student shares their game on Scratch.

Lesson 7: Review – Key Concepts

Why important: Reviewing helps you prepare for the exam.

Topics to review:

• Systems thinking and GDDs.
• Advanced data structures (multi-dimensional lists, clone variables, cloud variables).
• Advanced mechanics (scrolling, portals, AI, physics).
• Advanced Scratch features (Pen, particles, broadcasting, cloud).
• Polish and UX.
• Project management and collaboration.

Nigerian example: A student reviews all the topics.

Lesson 8: Exam-Style Questions – Part 1

Why important: Practice questions help you prepare.

Sample question 1: What is a multi-dimensional list?

Answer: A list that contains other lists.

Sample question 2: What is a cloud variable?

Answer: A variable stored online.

Lesson 9: Exam-Style Questions – Part 2

Sample question 3: What is a Game Design Document?

Answer: A written plan for your game.

Sample question 4: What is a particle system?

Answer: A system that creates many small visual elements.

Lesson 10: Exam-Style Questions – Part 3

Sample question 5: What is a clone-specific variable?

Answer: A variable for a specific clone.

Sample question 6: What is a state machine?

Answer: A system that controls behavior with states.

Lesson 11: Tips for Exam Success

• Review: Go over all the modules.
• Practice: Take practice exams.
• Relax: Get a good night's sleep.
• Read carefully: Read each question carefully.
• Think: Think about the best answer.

Lesson 12: Career Paths – From Scratch to Professional

Why important: Scratch is a stepping stone to a career in technology.

Career paths:

• Game developer: Make games for a living.
• Software engineer: Build software applications.
• Web developer: Build websites.
• Data scientist: Work with data.
• AI engineer: Work with artificial intelligence.

Nigerian example: A student uses Scratch skills to learn Python.

📌 Key Vocabulary

🧠 Important Concepts

• Preparation: Prepare for the exam.
• Portfolio: Showcase your skills.
• Career: Build a future in technology.

🔢 Steps to Perform Key Tasks

Task 1: Plan Your Capstone Project

1. Choose your game idea.
2. Write a GDD.
3. Break down the tasks.
4. Set a timeline.

Task 2: Build Your Capstone Project

1. Set up your Scratch project.
2. Build the core mechanics.
3. Add advanced features.
4. Add polish.
5. Test and debug.

Task 3: Review for the Exam

1. Review all modules.
2. Take practice exams.
3. Practice exam-style questions.

🔢 Step-by-step: Completing Your Capstone Project

1. Choose your idea – pick a game you want to create.
2. Write a GDD – plan your game.
3. Set up – create a new Scratch project.
4. Build core mechanics – movement, scoring, etc.
5. Add advanced features – AI, spawning, physics, etc.
6. Add polish – sound, visuals, UI.
7. Test and debug – play and fix issues.
8. Share – share your game.
9. Review – review key concepts.
10. Take the exam – earn your certification.

🧸 Fun Examples for Children

• Portfolio game: A game you can show to friends.
• Exam prep: Playing a quiz game to prepare.

🏠 Everyday Examples

• Career planning: Thinking about your future.
• Certification: A certificate you can share.

👪 Parent Tips

• Help your child plan their capstone project.
• Encourage them to review for the exam.
• Celebrate their achievement – they have worked hard!

💡 Interesting Facts

• Scratch is used in many universities.
• Certifications can help you get into college.
• Many professional developers started with Scratch.

❓ Did You Know?

• Scratch has over 100 million projects.
• You can add Scratch to your resume.

🔔 Remember This

• Your capstone project shows your skills.
• Review before the exam.
• Scratch is a stepping stone to a career.
• Be proud of what you have achieved.

⚠️ Common Mistakes

• Not planning. – Plan your project.
• Not reviewing. – Review for the exam.
• Not practicing. – Practice exam questions.
• Not sharing. – Share your work.

✅ Best Practices

• Plan your capstone project.
• Review all modules.
• Practice exam questions.
• Share your work.
• Build your portfolio.
• Explore career paths.
• Keep learning.

📊 Comparison: Level 1, 2, and 3

Level	Skills	Projects
Level 1	Basics, loops, conditions, variables	Simple games, animations
Level 2	Lists, custom blocks, AI, physics	Advanced games
Level 3	Systems thinking, advanced data, advanced mechanics	Professional games

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is a capstone project?
  A final project showing your skills.
• Q2: How do I prepare for the exam?
  Review all modules and practice questions.
• Q3: What is a portfolio?
  A collection of your work.
• Q4: How can I use Scratch skills?
  They are a stepping stone to a career.
• Q5: What career paths are available?
  Game developer, software engineer, web developer, etc.
• Q6: How do I share my project?
  Share on Scratch.
• Q7: What should I include in my portfolio?
  Your best projects.
• Q8: Why is planning important?
  It saves time and keeps you organized.
• Q9: What is the most important skill?
  Combining all the skills you have learned.
• Q10: What's next after this course?
  Keep learning and building!

🔗 Matching Exercise

Match the term with its description.

Term	Description
1. Capstone	A. A collection of your work
2. Portfolio	B. A final project
3. Certification	C. Proof of your skills
4. Career	D. Your professional path

(Answers: 1-B, 2-A, 3-C, 4-D)

🎭 Scenario-based Exercise

Scenario: A student wants to get the Level 3 certification and build a portfolio for college applications.

Question: What steps should they take?

👥 Group Activity

In groups of 4, share your capstone projects. Give each other feedback and discuss career paths.

✍️ Individual Activity

Write a reflection on your learning journey. What did you learn? What are you proud of? What's next?

🛠️ Mini Project

Complete your capstone project. Share it with the class and add it to your portfolio.

📋 Practical Assignment

Take a practice exam. Write a reflection on your performance and what you need to review.

🔑 Key Takeaways

• Your capstone project shows your skills.
• Review before the exam.
• Scratch is a stepping stone to a career.
• Be proud of what you have achieved.

💬 Classroom Discussion Questions

• What is the most important thing you learned in this course?
• What was the most challenging part?
• What project are you most proud of?
• What will you create next?

🏁 Congratulations – You've Completed the Entire Course!

You have completed all eight modules of the Certified Scratch Expert Level 3 course. You have learned:

• Module 1: Advanced Review and Systems Thinking
• Module 2: Advanced Data Structures
• Module 3: Advanced Game Mechanics
• Module 4: Advanced Game Development Projects
• Module 5: Advanced Scratch Features
• Module 6: Game Polish and User Experience
• Module 7: Project Management and Collaboration
• Module 8: Exam Preparation and Capstone Project

You are now a Certified Scratch Expert Level 3 – ready to create amazing games and pursue a career in technology.

🎉 You are a Scratch Master! 🎉

---

Thank you for your dedication – go create something amazing!