📘 Module 2: Lists – Advanced Data Management

“Managing collections of data like a pro.”

🌟 Module Introduction

In Module 1, we reviewed the basics of Scratch – motion, looks, events, loops, conditions, and variables. Now it's time to learn something new and powerful: lists.

Think of a variable as a single box that holds one thing – like a score or a name. A list is like a shelf with many boxes, each holding a different item. You can store many things in a list – high scores, inventory items, card decks, and more.

Lists are one of the most important tools in programming. They let you manage collections of data easily.

In this module, we will learn what lists are, how to create them, and how to use them in your games and projects. Let's get started!

🎯 Learning Objectives

• Define what a list is and why it is useful.
• Create and use lists in Scratch.
• Add, remove, and change items in a list.
• Search a list for specific values.
• Use lists to manage game data (high scores, inventory, cards).
• Understand when to use lists vs multiple variables.

📖 Warm-up Story: The Shopping List

Imagine you are going to the market in Lagos. Your mother gives you a shopping list: rice, beans, tomatoes, onions, and pepper. You take the list and buy each item one by one.

That list is like a Scratch list! It holds many items, and you can add, remove, or change them. If you forget to buy something, you can add it later.

In this module, we will learn how to create lists in Scratch – just like your shopping list, but for games!

📚 Main Lessons

Lesson 1: What is a List?

Definition: A list is a collection of items stored together.

Why important: Lists let you manage many pieces of data easily.

Simple explanation: A variable is one box; a list is a shelf with many boxes.

Real-life example: A shopping list – you can add, remove, and check items.

School example: A class list – all the students' names.

Home example: A to-do list – tasks you need to complete.

Nigerian example: A market vendor's inventory – items they have in stock.

    List vs Variable:
    ┌─────────────────────────────────────────────┐
    │  Variable: score = 5                       │
    │  List: [rice, beans, tomatoes, onions]     │
    └─────────────────────────────────────────────┘
    

Lesson 2: Creating a List in Scratch

Why important: You need to create a list before you can use it.

How to create:

• Click the "Variables" category.
• Click "Make a List".
• Give your list a name (e.g., "shoppingList").
• Choose "For all sprites" or "For this sprite only".
• Click "OK".

Nigerian example: A student creates a list called "gameScores".

Lesson 3: Adding Items to a List

Why important: You need to add items to your list.

How to add:

• Use the "add item to list" block.
• Specify what to add (e.g., "rice").
• You can also type items directly in the list view.

Nigerian example: A game adds the player's score to a high scores list.

Lesson 4: Removing Items from a List

Why important: You may need to remove items – like when an item is used.

How to remove:

• Use "delete 1 of list" to remove an item by position.
• Use "delete all of list" to clear the list.

Nigerian example: A card game removes a card from the player's hand when played.

Lesson 5: Changing Items in a List

Why important: Sometimes you need to update an item.

How to change:

• Use "replace item 1 of list with" to change a specific item.
• You can also edit directly in the list view.

Nigerian example: A game updates the player's score in a high scores list.

Lesson 6: Getting Items from a List

Why important: You need to read items from your list.

How to get:

• Use "item 1 of list" to get a specific item.
• Use "length of list" to find out how many items are in the list.
• Use "list contains" to check if an item is in the list.

Nigerian example: A game checks if a player's name is in the high scores list.

Lesson 7: Searching a List

Definition: Searching means checking if an item is in the list.

Why important: You might want to see if a player's name is already in a list.

How to search:

• Use "list contains item" block.
• Loop through the list to find items.

Nigerian example: A game checks if a player's name is already in the high scores list.

Lesson 8: Looping Through a List

Definition: Looping through a list means checking every item one by one.

Why important: You can process all items in a list.

How to loop:

• Use a "repeat" or "repeat until" loop.
• Use a counter variable to track positions.
• Use "item counter of list" to get each item.

Nigerian example: A game displays all high scores in a list.

Lesson 9: Lists vs Multiple Variables

Why important: Knowing when to use lists vs variables saves time.

Nigerian example: A game uses a list for high scores and variables for score and lives.

Lesson 10: Using Lists for High Scores

Why important: High scores are a common use for lists.

Steps:

1. Create a list called "highScores".
2. When a game ends, add the player's score to the list.
3. Sort the list (if needed).
4. Display the top scores.

Nigerian example: A game shows the top 5 scores on a leaderboard.

Lesson 11: Using Lists for Inventory

Why important: Games often have inventories.

Steps:

1. Create a list called "inventory".
2. When a player collects an item, add it to the list.
3. When a player uses an item, remove it.
4. Display the inventory on screen.

Nigerian example: A game where a player collects different fruits.

Lesson 12: Using Lists for Card Games

Why important: Card games need decks and hands.

Steps:

1. Create a list called "deck" with all cards.
2. Shuffle the deck.
3. Deal cards to a "hand" list.
4. Play cards by removing them.

Nigerian example: A simple card game like "Whot" or "Poker".

📌 Key Vocabulary

🧠 Important Concepts

• Collections: Lists store collections of data.
• Dynamic: Lists can grow and shrink.
• Efficiency: Lists make managing data easier.

🔢 Steps to Perform Key Tasks

Task 1: Create a List

1. Click Variables.
2. Click "Make a List".
3. Name it "myList".
4. Click "OK".

Task 2: Add Items to a List

1. Use "add item to list".
2. Add "apple", "banana", "orange".
3. See your list grow.

Task 3: Remove an Item

1. Use "delete 1 of list".
2. Remove "apple".
3. Check your list.

Task 4: Get the Length of a List

1. Use "length of list".
2. Show it in a say block.

🔢 Step-by-step: Creating a High Scores List

1. Create a list – call it "highScores".
2. Add a "when green flag clicked" – clear the list.
3. Add a "when game ends" – add the score to the list.
4. Add a "say" block – show the top scores.

🧸 Fun Examples for Children

• Pet list: Create a list of pets you want to adopt.
• Game items: Create a list of items in a game.

🏠 Everyday Examples

• Shopping list: Items to buy.
• To-do list: Tasks to complete.

👪 Parent Tips

• Show your child how lists are like shopping lists.
• Encourage them to create lists for their projects.
• Help them understand the difference between variables and lists.

💡 Interesting Facts

• Lists are used in almost every programming language.
• Lists are also called "arrays" in other languages.
• Scratch lists are very powerful and easy to use.

❓ Did You Know?

• You can add any type of item to a list – numbers, text, even pictures.
• You can have lists inside lists!

🔔 Remember This

• A list is a collection of items.
• Create a list using "Make a List".
• Add, remove, and change items.
• Use loops to process all items.
• Lists are great for high scores, inventory, and cards.

⚠️ Common Mistakes

• Forgetting to create a list. – Always create your list first.
• Using the wrong item number. – Check your positions.
• Not clearing lists at the start. – Use "delete all".
• Trying to use a list as a variable. – Lists are collections.

✅ Best Practices

• Give your lists clear names.
• Clear lists at the start of a game.
• Use loops to process lists.
• Use lists for collections of data.
• Test your list operations.

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is a list?
  A collection of items.
• Q2: How do I create a list?
  Click "Make a List" in Variables.
• Q3: How do I add an item?
  Use "add item to list".
• Q4: How do I remove an item?
  Use "delete 1 of list".
• Q5: How do I change an item?
  Use "replace item".
• Q6: How do I get the length of a list?
  Use "length of list".
• Q7: How do I search a list?
  Use "list contains".
• Q8: What are lists used for?
  High scores, inventory, cards.
• Q9: Can I have a list of lists?
  Yes – advanced, but possible!
• Q10: When should I use a list vs variables?
  Lists for collections; variables for single values.

🔗 Matching Exercise

Match the term with its description.

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

🎭 Scenario-based Exercise

Scenario: A student wants to create a game with a high scores leaderboard. When a game ends, the player's score is added to the list, and the top 5 scores are displayed.

Question: How would you use a list to implement this?

👥 Group Activity

In groups of 4, each person creates a list for a different purpose – one for high scores, one for inventory, one for a shopping list, and one for a to-do list.

✍️ Individual Activity

Create a list called "fruits" with 5 fruits. Add, remove, and change items. Display the length of the list.

🛠️ Mini Project

Create a simple game that uses a list for high scores. When a game ends, add the score to the list and display the top scores.

📋 Practical Assignment

Create a project that uses a list for inventory. Let the player collect items and display the inventory.

🔑 Key Takeaways

• Lists store collections of data.
• Create lists with "Make a List".
• Add, remove, and change items.
• Use loops to process lists.
• Lists are perfect for high scores, inventory, and cards.

💬 Classroom Discussion Questions

• What is the difference between a variable and a list?
• How can you use a list in a game?
• What are some everyday examples of lists?
• Why are lists important in programming?

🔜 Preparation for Module 3

In Module 3, we will explore Custom Blocks – Reusable Code. You will learn how to create your own blocks to make your code cleaner and more reusable.

Think about a task you repeat often in your code – we will learn how to turn it into a custom block!

You have completed Module 2 – you are now a list master! 🎉

📘 Module 3: Custom Blocks – Reusable Code

“Creating your own building blocks.”

🌟 Module Introduction

In Modules 1 and 2, we reviewed the basics and learned about lists. Now it's time to learn one of the most powerful features of Scratch: custom blocks.

Custom blocks are blocks you create yourself. They let you reuse code, make your projects cleaner, and save you time. Think of them like your own special tools – once you make them, you can use them again and again.

Imagine you are building a house. Instead of making each nail from scratch, you have a hammer and nails ready. Custom blocks are like that – they are your coding tools.

In this module, we will learn how to create custom blocks, add inputs to them, and use them to simplify our projects. Let's start building!

🎯 Learning Objectives

• Define what custom blocks are and why they are useful.
• Create custom blocks using the "My Blocks" category.
• Add inputs (parameters) to custom blocks.
• Use custom blocks to simplify complex scripts.
• Create reusable systems with custom blocks.
• Understand how custom blocks make code cleaner and more organized.

📖 Warm-up Story: The Toolbox

Imagine you are a carpenter. You have a toolbox with many tools – a hammer, a saw, a screwdriver. Each tool is used for a specific job. When you need to build something, you use the right tool.

Custom blocks are like your toolbox. You create blocks for specific tasks – like a "jump" block or a "shoot" block. Then, whenever you need that action, you just use your block instead of writing the same code again.

This is the power of custom blocks – they make you a more efficient coder!

📚 Main Lessons

Lesson 1: What Are Custom Blocks?

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

Why important: They save time, reduce errors, and make code cleaner.

Simple explanation: It's like creating your own tool – you can use it whenever you need.

Real-life example: A recipe – you use it many times to cook the same dish.

School example: A math formula – you use it for different problems.

Home example: A cleaning routine – you follow the same steps each week.

Nigerian example: A traditional dance move – you repeat it in different dances.

    Custom Blocks:
    ┌─────────────────────────────────────────────┐
    │  Define jump                               │
    │    repeat 10                               │
    │      change y by 5                        │
    │    end                                     │
    │  Use it like any other block!              │
    └─────────────────────────────────────────────┘
    

Lesson 2: Why Use Custom Blocks?

• Reuse: Write once, use many times.
• Organization: Keep your code clean and tidy.
• Debugging: Fix errors in one place.
• Readability: Your code is easier to understand.
• Speed: Code faster by reusing blocks.

Nigerian example: A game uses a "jump" block for the player, and it works perfectly every time.

Lesson 3: Creating a Custom Block

Why important: You need to know how to create your own blocks.

How to create:

1. Click the "My Blocks" category.
2. Click "Make a Block".
3. Enter a name for your block (e.g., "jump").
4. Click "OK".
5. Add the code that defines what the block does.

Nigerian example: A student creates a block called "dance".

Lesson 4: Adding Inputs to Custom Blocks

Definition: Inputs are values you can pass to a custom block.

Why important: Inputs make your blocks flexible and powerful.

How to add inputs:

• When creating a block, click "Add an input".
• Name the input (e.g., "distance").
• Use the input in your block's code.

Nigerian example: A "move distance" block takes a distance input.

Lesson 5: Using Custom Blocks in Your Code

Why important: You need to know how to use the blocks you created.

How to use:

• Find your custom block in the "My Blocks" category.
• Drag it into your script like any other block.
• If it has inputs, fill them in.

Nigerian example: A game uses the "jump" block whenever the player presses space.

Lesson 6: Example – Jump Block

Steps:

1. Create a block called "jump".
2. Add code: change y by 10, wait 0.1 seconds, change y by -10.
3. Use "jump" whenever the player presses space.

Nigerian example: A platformer game uses a "jump" block.

Lesson 7: Example – Shoot Block

Steps:

1. Create a block called "shoot".
2. Add code: create a clone of a bullet, set its direction, move it.
3. Use "shoot" whenever the player clicks.

Nigerian example: A space shooter uses a "shoot" block.

Lesson 8: Example – Score Update Block

Steps:

1. Create a block called "updateScore".
2. Add an input called "points".
3. Add code: change score by points, say score.
4. Use "updateScore 5" when the player scores.

Nigerian example: A game uses "updateScore" to change the score.

Lesson 9: Custom Blocks with Multiple Inputs

Why important: Some actions need more than one input.

How to create:

• Add multiple inputs when creating the block.
• Use all inputs in the block's code.

Nigerian example: A "move to" block takes x and y inputs.

Lesson 10: Custom Blocks and Lists

Why important: Combining custom blocks with lists is powerful.

How to use:

• Create a block that adds an item to a list.
• Create a block that removes an item.
• Create a block that displays the list.

Nigerian example: A game uses custom blocks to manage a high scores list.

Lesson 11: Organizing Code with Custom Blocks

Why important: Organized code is easier to understand and fix.

Tips:

• Group related actions into custom blocks.
• Use clear block names.
• Keep blocks short and focused.

Nigerian example: A game has blocks like "initGame", "playerMove", "checkCollision".

Lesson 12: Reusing Custom Blocks Across Projects

Why important: You can reuse blocks in multiple projects.

How to reuse:

• Save your project with custom blocks.
• Open it and copy the blocks to a new project.
• Use the "backpack" feature to save blocks.

Nigerian example: A student reuses a "dance" block in different animations.

📌 Key Vocabulary

🧠 Important Concepts

• Reusability: Write once, use many times.
• Modularity: Break code into small, manageable parts.
• Efficiency: Work smarter, not harder.

🔢 Steps to Perform Key Tasks

Task 1: Create a Custom Block

1. Click "My Blocks".
2. Click "Make a Block".
3. Name it "sayHello".
4. Add code: say "Hello!".
5. Use it in your script.

Task 2: Add an Input to a Block

1. Create a block called "sayWord".
2. Add an input called "word".
3. Add code: say word.
4. Use it: sayWord "Hello!".

Task 3: Create a Block with Multiple Inputs

1. Create a block called "moveTo".
2. Add inputs: "x" and "y".
3. Add code: go to x: x y: y.
4. Use it: moveTo 50 50.

🔢 Step-by-step: Creating a Jump Block

1. Click "My Blocks" – open the category.
2. Click "Make a Block" – give it a name: "jump".
3. Add code – change y by 10, wait 0.1 seconds, change y by -10.
4. Use the block – in your game, use "jump".
5. Test – make sure it works.

🧸 Fun Examples for Children

• Pet game: Create a "feed" block for feeding your pet.
• Dance game: Create a "spin" block for dancing.

🏠 Everyday Examples

• Family game: Create a "rollDice" block for a board game.
• School project: Create a "calculateAverage" block.

👪 Parent Tips

• Show your child how custom blocks are like tools in a toolbox.
• Encourage them to think about actions they repeat often.
• Help them create their own custom blocks.

💡 Interesting Facts

• Custom blocks are also called "procedures" or "functions".
• Professional programmers use functions all the time.
• Scratch's custom blocks make coding fun and easy.

❓ Did You Know?

• You can use the "backpack" to save custom blocks for other projects.
• Custom blocks can be shared with other Scratch users.

🔔 Remember This

• Custom blocks save time.
• They make your code cleaner.
• They can have inputs.
• They can be reused across projects.
• They are powerful tools.

⚠️ Common Mistakes

• Not using custom blocks. – Use them to save time.
• Giving blocks unclear names. – Use clear names.
• Not using inputs. – Inputs make blocks flexible.
• Making blocks too long. – Keep blocks short and focused.

✅ Best Practices

• Give blocks clear, descriptive names.
• Use inputs for flexibility.
• Keep blocks short and focused.
• Organize your code with custom blocks.
• Reuse blocks across projects.
• Test your blocks after creating them.

📊 Comparison: Without vs With Custom Blocks

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is a custom block?
  A block you create yourself.
• Q2: Why use custom blocks?
  To save time and organize code.
• Q3: How do I create a custom block?
  Click "Make a Block" in My Blocks.
• Q4: What is an input?
  A value passed to a block.
• Q5: Can I have multiple inputs?
  Yes – add as many as you need.
• Q6: How do I use a custom block?
  Drag it from My Blocks like any other block.
• Q7: Can I reuse custom blocks?
  Yes – use the backpack or copy them.
• Q8: What is the backpack?
  Scratch's storage for blocks and sprites.
• Q9: Are custom blocks like functions?
  Yes – they are the Scratch version of functions.
• Q10: How can I organize my code?
  Use custom blocks to group related actions.

🔗 Matching Exercise

Match the term with its description.

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

🎭 Scenario-based Exercise

Scenario: A student is creating a game with many actions – jumping, shooting, and collecting items. The code is becoming messy and hard to fix.

Question: How can custom blocks help organize this game?

👥 Group Activity

In groups of 4, each person creates a different custom block – one for movement, one for scoring, one for jumping, and one for shooting. Combine them into one project.

✍️ Individual Activity

Create a custom block called "greet" that takes a name as input and says "Hello, name!".

🛠️ Mini Project

Create a simple game with at least 3 custom blocks – one for movement, one for scoring, and one for jumping. Share your project.

📋 Practical Assignment

Create a project that uses custom blocks to organize code. Write a short reflection on how custom blocks helped.

🔑 Key Takeaways

• Custom blocks save time.
• They make code cleaner.
• Inputs make blocks flexible.
• Blocks can be reused across projects.
• Organization makes coding easier.

💬 Classroom Discussion Questions

• What custom block would you create first?
• How can custom blocks help you code faster?
• Why is organization important in coding?
• What is the most useful custom block you have used?

🔜 Preparation for Module 4

In Module 4, we will explore Game States and Structured Game Flow. You will learn how to control the flow of your game using states like start, play, win, and game over.

Think about a game you like – it probably has a start screen, a play state, and a game over screen. We will learn how to build that in Scratch!

You have completed Module 3 – you can now create your own blocks! 🎉

📘 Module 4: Game States and Structured Game Flow

“Controlling your game like a director.”

🌟 Module Introduction

In Modules 1-3, we reviewed the basics, learned about lists, and created custom blocks. Now it's time to think about the flow of your game.

Every good game has a structure – a start screen, a play state, and a win or game over screen. This is called game states. Game states control what happens at each stage of your game.

Think of a movie – it has an opening, a middle, and an ending. A game is the same. Game states let you organize your game into clear stages.

In this module, we will learn how to create and manage game states in Scratch. Let's become game directors!

🎯 Learning Objectives

• Understand the concept of game states.
• Identify common game states: start, play, win, game over.
• Use variables to track the current game state.
• Create start screens and instructions.
• Implement win and game over screens.
• Manage transitions between states.
• Design structured game flow.

📖 Warm-up Story: The Movie Director

Imagine you are a movie director. Your movie has three parts – the beginning, the middle, and the end. Each part has different scenes, characters, and actions.

In a game, you are the director. You decide what happens at the start, during the game, and when the game ends. Game states are like the chapters of your movie.

By using game states, you can create a smooth, professional game that players will love.

📚 Main Lessons

Lesson 1: What Are Game States?

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

Why important: Game states organize the flow of your game.

Simple explanation: It's like the chapters of a book – each chapter is a state.

Real-life example: A sports match has states – before, during, after.

School example: A lesson has states – introduction, teaching, practice.

Home example: A meal has states – preparing, eating, cleaning.

Nigerian example: A wedding has states – ceremony, reception, after-party.

    Game States:
    ┌─────────────────────────────────────────────┐
    │  Start → Play → Win / Game Over            │
    └─────────────────────────────────────────────┘
    

Lesson 2: Why Use Game States?

• Organization: Keep your code clean and logical.
• Control: Decide what happens at each stage.
• Player experience: Create a smooth, professional experience.
• Easy updates: Change one state without affecting others.

Nigerian example: A game with a start screen, levels, and a win screen feels professional.

Lesson 3: Common Game States

• Start: Title screen, instructions, play button.
• Play: The main game – player controls, scoring.
• Win: When the player achieves the goal.
• Game Over: When the player loses.
• Pause: Optional – when the player pauses.
• Level Complete: Between levels.

Lesson 4: Tracking the Game State

Why important: You need to know which state the game is in.

How to track:

• Create a variable called "gameState".
• Assign a number or name to each state (e.g., 0=start, 1=play, 2=win, 3=game over).
• Check the variable to decide what to do.

Nigerian example: A game uses "gameState" to show the right screen.

Lesson 5: Creating a Start Screen

Why important: The start screen is the first thing players see.

Steps:

1. Set gameState to "start".
2. Add a backdrop with a title.
3. Add a sprite that says "Click to start".
4. When clicked, change gameState to "play".

Nigerian example: A game starts with "Welcome to Lagos Adventure".

Lesson 6: Adding Instructions

Why important: Players need to know how to play.

How to add:

• Add a "How to Play" button on the start screen.
• Show instructions when clicked.
• Use a separate backdrop or sprite for instructions.

Nigerian example: A game shows instructions in English and Pidgin.

Lesson 7: The Play State

Why important: This is where the action happens.

Steps:

1. When gameState = "play", show the game backdrop.
2. Activate player controls.
3. Start scoring, lives, and enemies.
4. Check for win or lose conditions.

Nigerian example: In "play" state, the player controls a character and collects items.

Lesson 8: The Win State

Why important: Winning feels rewarding.

Steps:

1. When the player achieves the goal, set gameState to "win".
2. Show a win message (e.g., "You Win!").
3. Add a "Play Again" button.

Nigerian example: A game says "Congratulations! You collected all the flags!"

Lesson 9: The Game Over State

Why important: Losing is part of the game.

Steps:

1. When the player loses (e.g., lives = 0), set gameState to "game over".
2. Show a game over message (e.g., "Game Over").
3. Add a "Try Again" button.

Nigerian example: A game says "Try again! You can do it!"

Lesson 10: Transitions Between States

Definition: Transitions are how you move from one state to another.

Why important: Smooth transitions make your game feel professional.

How to transition:

• Change the gameState variable.
• Hide/show sprites based on the state.
• Use broadcasts to trigger state changes.

Nigerian example: A game fades from the start screen to the play state.

Lesson 11: Using Broadcasts for States

Why important: Broadcasts make state management cleaner.

How to use:

• Broadcast "startGame" when the player clicks start.
• Broadcast "winGame" when the player wins.
• Use "when I receive" to trigger state changes.

Nigerian example: A game broadcasts "levelComplete" to move to the next level.

Lesson 12: Structured Game Flow – Putting It All Together

Why important: A structured game is easier to build and play.

Steps:

1. Plan your game states.
2. Create a variable to track the state.
3. Use "when green flag clicked" to set the start state.
4. Use "if" blocks to handle each state.
5. Use broadcasts to transition between states.
6. Test your game flow.

Nigerian example: A complete game with start, play, win, and game over states.

📌 Key Vocabulary

🧠 Important Concepts

• Organization: Game states keep your code organized.
• Control: You control the flow of the game.
• Experience: A well-structured game is more enjoyable.

🔢 Steps to Perform Key Tasks

Task 1: Create a Game State Variable

1. Create a variable called "gameState".
2. Set it to "start" at the beginning.

Task 2: Create a Start Screen

1. Add a backdrop with a title.
2. Add a sprite that says "Click to Start".
3. When clicked, set gameState to "play".

Task 3: Create a Win Screen

1. When the player wins, set gameState to "win".
2. Show a win message.
3. Add a "Play Again" button.

🔢 Step-by-step: Creating a Game with States

1. Create a gameState variable – set to "start".
2. Create a start screen – title and instructions.
3. When "start" is clicked – change state to "play".
4. In play state – run the game.
5. When the player wins – change state to "win".
6. In win state – show win message and "Play Again".
7. When "Play Again" is clicked – reset the game.

🧸 Fun Examples for Children

• Pet game: Start screen, play state (feed the pet), and a win state.
• Space game: Start, play, win, and game over states.

🏠 Everyday Examples

• Family game: A board game with start, play, and end states.
• School quiz: Start, questions, and results states.

👪 Parent Tips

• Show your child how games have start, play, and end screens.
• Help them plan their game states before coding.
• Encourage them to add clear instructions.

💡 Interesting Facts

• Professional games always use game states.
• Game states are also called "game modes".
• Well-designed game states improve player experience.

❓ Did You Know?

• Some games have dozens of states (e.g., menus, options, levels).
• You can use game states to create a "pause" feature.

🔔 Remember This

• Game states organize your game.
• Common states: start, play, win, game over.
• Use a variable to track the state.
• Use broadcasts for smooth transitions.
• A structured game is more professional.

⚠️ Common Mistakes

• Not using game states. – Use them to organize your code.
• Forgetting to change the state. – Always update the state.
• Not resetting the game. – Reset all variables when playing again.
• Messy transitions. – Use broadcasts for clean transitions.

✅ Best Practices

• Plan your game states before coding.
• Use a variable to track the state.
• Use broadcasts for transitions.
• Reset variables when restarting.
• Add clear instructions on the start screen.
• Test all state transitions.

📊 Comparison: With vs Without Game States

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is a game state?
  A phase of a game.
• Q2: What are common game states?
  Start, play, win, game over.
• Q3: How do I track the game state?
  Use a variable called "gameState".
• Q4: What is a transition?
  Moving from one state to another.
• Q5: How do I create a start screen?
  Set gameState to "start" and show the title.
• Q6: How do I show a win screen?
  Set gameState to "win" and show a message.
• Q7: How do I reset the game?
  Reset variables and go back to "start".
• Q8: What is a broadcast?
  A message that triggers state changes.
• Q9: Why are game states important?
  They organize your game.
• Q10: Can I have more than 4 states?
  Yes – you can have as many as you need.

🔗 Matching Exercise

Match the term with its description.

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

🎭 Scenario-based Exercise

Scenario: A student is creating a game with a start screen, gameplay, and a win screen. They want to add a "Game Over" screen when the player loses.

Question: How would you implement these game states?

👥 Group Activity

In groups of 4, each person designs a different game state for the same game – one does start, one does play, one does win, and one does game over. Combine them.

✍️ Individual Activity

Create a game with at least 3 states: start, play, and win or game over. Save your project.

🛠️ Mini Project

Create a complete game with start, play, win, and game over states. Add instructions and a "Play Again" button.

📋 Practical Assignment

Create a game with structured game states. Write a reflection on how states helped organize your code.

🔑 Key Takeaways

• Game states organize your game.
• Common states: start, play, win, game over.
• Use a variable to track the state.
• Use broadcasts for transitions.
• A structured game is professional.

💬 Classroom Discussion Questions

• What are the benefits of using game states?
• How can you make transitions smooth?
• Why is it important to reset the game?
• What other states could you add to a game?

🔜 Preparation for Module 5

In Module 5, we will explore Enemy Behaviors and Simple AI. You will learn how to create enemies that chase, patrol, and react to the player.

Think about a game with enemies – how do they move and behave? We will learn how to make them smart!

You have completed Module 4 – your games are now structured! 🎉

📘 Module 5: Enemy Behaviors and Simple AI

“Making your enemies smart and challenging.”

🌟 Module Introduction

In Modules 1-4, we learned the foundations of Level 2 – lists, custom blocks, and game states. Now it's time to make your games more exciting with enemies!

Enemies make games challenging and fun. But enemies that just move in a straight line are boring. In this module, we will learn how to create smart enemies that chase, patrol, and react to the player.

This is called Artificial Intelligence (AI) – making enemies behave like they are thinking. We will learn how to create different enemy behaviors and make your games more engaging.

Let's make your enemies smart!

🎯 Learning Objectives

• Understand what Artificial Intelligence (AI) is in games.
• Create different enemy movement patterns (patrol, chase, random).
• Use sensing blocks for enemy awareness (touching player, distance).
• Implement chase behavior – enemies follow the player.
• Implement patrol behavior – enemies move back and forth.
• Create simple AI state machines (idle, chase, attack).

📖 Warm-up Story: The Smart Enemies

Imagine you are playing a game. You are a hero, and there are enemies that want to catch you. Some enemies move back and forth (patrol). Some enemies chase you (chase). Some enemies wait and then attack when you get close.

These enemies feel alive because they have AI. They are not just moving randomly – they are responding to you.

In this module, we will learn how to create enemies like these. Let's make your game more challenging!

📚 Main Lessons

Lesson 1: What is AI in Games?

Definition: AI (Artificial Intelligence) in games is code that makes characters behave in smart ways.

Why important: AI makes games challenging and fun.

Simple explanation: It's like giving enemies a brain – they can think and react.

Real-life example: A robot that follows you.

School example: A classmate who reacts to what you say.

Home example: A pet that comes when you call it.

Nigerian example: A market vendor who approaches you when you look at their goods.

    AI in Games:
    ┌─────────────────────────────────────────────┐
    │  Patrol → moves back and forth             │
    │  Chase → follows the player                │
    │  Attack → attacks when close               │
    │  Idle → waits and watches                  │
    └─────────────────────────────────────────────┘
    

Lesson 2: Enemy Movement – Patrol

Definition: Patrol means moving back and forth between two points.

Why important: Patrol is the simplest and most common enemy behavior.

How to create:

• Move the enemy in one direction.
• When it reaches the edge, turn around.
• Use "if on edge, bounce" or custom code.

Nigerian example: A guard walking back and forth.

Lesson 3: Enemy Movement – Chase

Definition: Chase means following the player.

Why important: Chase is more challenging and exciting.

How to create:

• Get the player's position.
• Move the enemy towards the player.
• Use "point towards player" and "move 2 steps".

Nigerian example: A lion chasing a gazelle.

Lesson 4: Enemy Movement – Random

Definition: Random means moving in random directions.

Why important: Random movement is unpredictable.

How to create:

• Use "pick random" to choose a direction.
• Move in that direction for a short time.
• Repeat.

Nigerian example: A fly moving randomly.

Lesson 5: Sensing the Player

Definition: Sensing means detecting the player.

Why important: Enemies need to know where the player is.

How to sense:

• Use "touching player" to detect contact.
• Use "distance to player" to measure how far.
• Use "point towards player" to face them.

Nigerian example: A guard who sees you and starts chasing.

Lesson 6: Chase Behavior – Step by Step

Steps:

1. Add a sprite for the enemy.
2. Add a "when green flag clicked" block.
3. Add a "forever" loop.
4. Add "point towards player".
5. Add "move 2 steps".
6. Add a wait block (0.1 seconds).

Nigerian example: An enemy chases the player.

Lesson 7: Patrol Behavior – Step by Step

Steps:

1. Add a sprite for the enemy.
2. Add a "when green flag clicked" block.
3. Add a "forever" loop.
4. Add "move 2 steps".
5. Add "if on edge, bounce".
6. Add a wait block (0.1 seconds).

Nigerian example: An enemy patrols back and forth.

Lesson 8: AI State Machines – Idle, Chase, Attack

Definition: A state machine is a way for an enemy to switch between different behaviors.

Why important: State machines make enemies more realistic.

States:

• Idle: Enemy waits.
• Chase: Enemy follows the player.
• Attack: Enemy attacks when close.

Nigerian example: A guard who waits, then chases, then attacks.

Lesson 9: Creating an AI State Machine

Steps:

1. Create a variable called "enemyState" for each enemy.
2. Set it to "idle" at the start.
3. If the player is far, stay "idle".
4. If the player is close, switch to "chase".
5. If touching the player, switch to "attack".

Nigerian example: An enemy with idle, chase, and attack states.

Lesson 10: Attack Behavior

Definition: Attack means doing damage to the player.

Why important: Attack is the climax of enemy behavior.

How to create:

• When the enemy touches the player, broadcast "hurt".
• Reduce the player's lives.
• Add a cooldown to prevent constant damage.

Nigerian example: An enemy bites the player.

Lesson 11: Using Clones for Multiple Enemies

Why important: Clones let you have many enemies.

How to use:

• Create a single enemy sprite.
• Use "create clone of myself" to make copies.
• Each clone can have its own behavior.
• Use "when I start as a clone" to set up each enemy.

Nigerian example: A game with 5 enemies chasing the player.

Lesson 12: Combining AI with Other Concepts

Why important: AI works with lists, custom blocks, and game states.

Example:

• Use a list to store enemy positions.
• Use custom blocks for enemy behaviors.
• Use game states to control when enemies are active.

Nigerian example: A complete game with smart enemies.

📌 Key Vocabulary

🧠 Important Concepts

• Variety: Different enemy behaviors make games interesting.
• Challenge: Smart enemies make games harder and more fun.
• Balance: Enemies should be challenging but not impossible.

🔢 Steps to Perform Key Tasks

Task 1: Create a Patrol Enemy

1. Add an enemy sprite.
2. Add "when green flag clicked".
3. Add "forever" loop.
4. Add "move 2 steps".
5. Add "if on edge, bounce".
6. Test it.

Task 2: Create a Chase Enemy

1. Add an enemy sprite.
2. Add "when green flag clicked".
3. Add "forever" loop.
4. Add "point towards player".
5. Add "move 2 steps".
6. Test it.

Task 3: Create an AI State Machine

1. Create a variable "enemyState".
2. Set it to "idle".
3. If distance to player > 100, stay idle.
4. If distance < 100, switch to chase.
5. If touching player, switch to attack.
6. Test it.

🔢 Step-by-step: Creating a Chase Enemy

1. Add a sprite – choose an enemy.
2. Add "when green flag clicked" – start the script.
3. Add a "forever" loop – keep the behavior running.
4. Add "point towards player" – face the player.
5. Add "move 2 steps" – move towards the player.
6. Add a "wait 0.1 seconds" – control speed.
7. Test your enemy – it should chase the player.

🧸 Fun Examples for Children

• Pet game: An enemy pet that chases you.
• Space game: Enemies that patrol and chase.

🏠 Everyday Examples

• Family game: Enemies in a board game.
• School project: A game with smart enemies.

👪 Parent Tips

• Show your child how enemies in games have different behaviors.
• Help them create simple enemy behaviors.
• Encourage them to experiment with different AI states.

💡 Interesting Facts

• AI in games is called "game AI".
• Some game AI is very advanced.
• Simple AI can be created with just a few blocks.

❓ Did You Know?

• AI in games can use "pathfinding" to find the best route.
• Some enemies use "stealth" to avoid the player.

🔔 Remember This

• AI makes enemies smart.
• Common behaviors: patrol, chase, attack, idle.
• Use sensing to detect the player.
• State machines switch between behaviors.
• Clones create multiple enemies.

⚠️ Common Mistakes

• Enemies too fast or too slow. – Adjust speed.
• Enemies not detecting player. – Check sensing blocks.
• No cooldown on attacks. – Add a wait or cooldown.
• Too many clones. – Limit the number of clones.

✅ Best Practices

• Start with simple behaviors (patrol).
• Add chase behavior gradually.
• Use cooldowns for attacks.
• Limit the number of clones.
• Test enemy behaviors thoroughly.
• Balance difficulty for fun gameplay.

📊 Comparison: Enemy Behaviors

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is AI in games?
  Smart behavior for enemies.
• Q2: What is patrol?
  Moving back and forth.
• Q3: What is chase?
  Following the player.
• Q4: What is a state machine?
  Switching between behaviors.
• Q5: How do I detect the player?
  Use sensing blocks.
• Q6: How do I create multiple enemies?
  Use clones.
• Q7: What is a cooldown?
  A pause between attacks.
• Q8: How do I balance enemy difficulty?
  Adjust speed and damage.
• Q9: Can enemies use pathfinding?
  Yes – but that's advanced.
• Q10: What is the most common enemy behavior?
  Patrol and chase.

🔗 Matching Exercise

Match the term with its description.

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

🎭 Scenario-based Exercise

Scenario: A student wants to create a game where enemies patrol and chase the player when they get close.

Question: How would you implement this with a state machine?

👥 Group Activity

In groups of 4, each person creates a different enemy behavior – one patrols, one chases, one attacks, and one is idle. Combine them into one game.

✍️ Individual Activity

Create a simple game with one enemy that chases the player. Save your project.

🛠️ Mini Project

Create a game with at least two different enemy behaviors (e.g., patrol and chase). Use a state machine for one enemy.

📋 Practical Assignment

Create a game with enemies that use AI. Write a reflection on how you created the enemy behaviors.

🔑 Key Takeaways

• AI makes enemies smart.
• Behaviors: patrol, chase, attack, idle.
• Sensing detects the player.
• State machines switch behaviors.
• Clones create multiple enemies.

💬 Classroom Discussion Questions

• What is your favorite enemy behavior?
• How can you make enemies more challenging?
• What other enemy behaviors could you create?
• How does AI improve a game?

🔜 Preparation for Module 6

In Module 6, we will explore Spawning Systems and Object Management. You will learn how to create and manage multiple objects dynamically.

Think about a game where objects appear and disappear – like falling stars or enemies. We will learn how to manage them!

You have completed Module 5 – your enemies are now smart! 🎉

📘 Module 6: Spawning Systems and Object Management

“Creating and managing objects dynamically.”

🌟 Module Introduction

In Modules 1-5, we learned about lists, custom blocks, game states, and enemy AI. Now it's time to learn how to create and manage objects dynamically – spawning them when needed and deleting them when they are no longer needed.

Think of a game where enemies appear (spawn) at random times, or where objects fall from the sky. These objects need to be created, managed, and removed efficiently.

In this module, we will learn how to use cloning and timing to create spawning systems. We will also learn how to manage object lifetimes and use object pooling for performance.

Let's learn how to spawn and manage objects like a pro!

🎯 Learning Objectives

• Understand what spawning systems are and why they are important.
• Use cloning to spawn objects dynamically.
• Control spawn timing and rates.
• Create random spawning systems.
• Manage object lifetimes and deletion.
• Understand object pooling concepts.

📖 Warm-up Story: The Falling Stars

Imagine a game where stars fall from the sky, and the player has to catch them. The stars appear (spawn) at random times and positions, and they disappear when they reach the bottom or are caught.

This is a spawning system. The stars are created dynamically, and they are managed automatically. Without a spawning system, you would have to add every star manually – which would be impossible!

In this module, we will learn how to create systems like this in Scratch.

📚 Main Lessons

Lesson 1: What is a Spawning System?

Definition: A spawning system creates objects (like enemies or items) during the game.

Why important: Spawning systems make games dynamic and interesting.

Simple explanation: It's like a factory that produces objects on demand.

Real-life example: A vending machine that dispenses items when you press a button.

School example: A teacher handing out worksheets to students.

Home example: A parent giving snacks to children.

Nigerian example: A market vendor restocking items as they sell.

    Spawning System:
    ┌─────────────────────────────────────────────┐
    │  Factory → creates objects on demand       │
    │  Objects → enemies, items, power-ups       │
    │  Timing → when and how often to spawn      │
    └─────────────────────────────────────────────┘
    

Lesson 2: Why Use Spawning Systems?

• Dynamic: Objects appear as needed.
• Efficient: No need to add all objects manually.
• Unlimited: Can create endless objects.
• Variety: Random spawning creates variety.

Nigerian example: A game where enemies keep appearing until the player wins.

Lesson 3: Using Clones for Spawning

Definition: Cloning is creating copies of a sprite.

Why important: Cloning is the easiest way to spawn objects in Scratch.

How to use:

• Use "create clone of myself".
• Use "when I start as a clone" to set up each clone.
• Use "delete this clone" to remove it.

Nigerian example: A game spawns enemies using clones.

Lesson 4: Controlling Spawn Timing

Why important: Timing controls how often objects appear.

How to control:

• Use "wait" blocks to control timing.
• Use "repeat" loops to spawn multiple objects.
• Use "forever" loops to keep spawning.

Nigerian example: Enemies spawn every 2 seconds.

Lesson 5: Random Spawning

Definition: Random spawning means creating objects at random positions and times.

Why important: Random spawning makes games unpredictable and exciting.

How to create:

• Use "pick random" for position.
• Use "pick random" for timing.

Nigerian example: Stars fall at random positions and times.

Lesson 6: Object Lifetimes – When to Delete

Definition: Lifetime is how long an object exists before being deleted.

Why important: Deleting objects keeps your game running smoothly.

When to delete:

• When the object reaches the edge.
• When the object is collected by the player.
• After a certain amount of time.

Nigerian example: A falling star is deleted when it reaches the bottom.

Lesson 7: Deleting Clones

Why important: Too many clones slow down your game.

How to delete:

• Use "delete this clone".
• Add conditions to trigger deletion.

Nigerian example: Enemies are deleted when they touch the player.

Lesson 8: Object Pooling – Advanced Management

Definition: Object pooling means reusing objects instead of creating new ones.

Why important: Object pooling improves performance.

How to use:

• Create a pool of objects at the start.
• When you need an object, take one from the pool.
• When done, return it to the pool.

Nigerian example: A game reuses bullets instead of creating new ones.

Lesson 9: Spawning in Waves

Definition: Wave spawning means creating groups of objects at once.

Why important: Waves create patterns and challenges.

How to create:

• Use a "repeat" loop to spawn multiple objects.
• Use a "wait" block between waves.
• Increase difficulty in later waves.

Nigerian example: A game spawns 5 enemies at a time in waves.

Lesson 10: Spawning with Custom Blocks

Why important: Custom blocks make spawning code cleaner.

How to use:

• Create a custom block called "spawnEnemy".
• Add code to create a clone and set its position.
• Use the block whenever you need to spawn.

Nigerian example: A game uses "spawnEnemy" to create enemies.

Lesson 11: Combining Spawning with AI

Why important: Spawning and AI work together.

How to combine:

• Spawn enemies with different AI behaviors.
• Use random spawning for variety.
• Use wave spawning for difficulty.

Nigerian example: A game spawns enemies that chase the player.

Lesson 12: Performance Tips

• Limit clones: Delete clones that are not needed.
• Use object pooling: Reuse objects when possible.
• Avoid too many clones: Keep the number of clones manageable.
• Test performance: Make sure your game runs smoothly.

📌 Key Vocabulary

🧠 Important Concepts

• Efficiency: Delete objects when they are no longer needed.
• Variety: Random spawning creates interesting games.
• Performance: Too many clones can slow down your game.

🔢 Steps to Perform Key Tasks

Task 1: Spawn Enemies Every 2 Seconds

1. Add an enemy sprite.
2. Add "when green flag clicked".
3. Add "forever" loop.
4. Add "create clone of myself".
5. Add "wait 2 seconds".
6. Add "when I start as a clone" – set position and move.

Task 2: Random Spawning

1. Add "go to x: pick random -200 to 200 y: 180".
2. Add "show".
3. Add movement code.

Task 3: Delete Clones

1. Add "if y position < -180, delete this clone".
2. Add "if touching player, delete this clone".

🔢 Step-by-step: Creating a Falling Star System

1. Create a star sprite – choose a star from the library.
2. Add "when green flag clicked" – hide the original.
3. Add a "forever" loop – spawn stars.
4. Add "create clone of myself" – create a new star.
5. Add "wait pick random 1 to 3" – random timing.
6. Add "when I start as a clone" – set random x position.
7. Add "repeat until y < -180" – move down.
8. Add "change y by -5" – fall speed.
9. Add "delete this clone" – delete when off-screen.
10. Test your game – stars should fall from the sky.

🧸 Fun Examples for Children

• Pet game: Spawn food for your pet.
• Space game: Spawn enemies and power-ups.

🏠 Everyday Examples

• Family game: Spawn obstacles in a racing game.
• School project: Spawn questions in a quiz game.

👪 Parent Tips

• Show your child how objects appear in games.
• Help them understand the importance of deleting objects.
• Encourage them to create their own spawning systems.

💡 Interesting Facts

• Spawning systems are used in almost every game.
• Object pooling is used in professional game development.
• Too many objects can slow down a game.

❓ Did You Know?

• Some games spawn hundreds of objects at once.
• Object pooling is a common optimization technique.

🔔 Remember This

• Spawn objects dynamically.
• Use clones for spawning.
• Control timing with "wait".
• Use random positions and timing.
• Delete clones when they are no longer needed.
• Use object pooling for performance.

⚠️ Common Mistakes

• Not deleting clones. – Delete them to keep performance.
• Spawning too many objects. – Limit the number of clones.
• No random variation. – Use random for variety.
• Objects spawning at the same position. – Randomize positions.

✅ Best Practices

• Delete clones when they are off-screen.
• Limit the number of clones.
• Use random positions and timing.
• Use object pooling for performance.
• Test your spawning system thoroughly.

📊 Comparison: Spawning Methods

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is a spawning system?
  Creates objects during the game.
• Q2: Why use clones?
  Clones are easy to create and manage.
• Q3: How do I control timing?
  Use "wait" blocks.
• Q4: What is random spawning?
  Objects at random positions and times.
• Q5: How do I delete clones?
  Use "delete this clone".
• Q6: What is object pooling?
  Reusing objects instead of creating new ones.
• Q7: Why delete clones?
  To keep your game fast.
• Q8: What is wave spawning?
  Spawning groups of objects.
• Q9: Can I combine spawning with AI?
  Yes – spawn enemies with AI.
• Q10: What is the best spawning method?
  Cloning is the easiest for beginners.

🔗 Matching Exercise

Match the term with its description.

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

🎭 Scenario-based Exercise

Scenario: A student wants to create a game where enemies appear (spawn) at random positions and chase the player. When the enemies are caught, they disappear and new ones spawn.

Question: How would you implement this spawning system?

👥 Group Activity

In groups of 4, each person creates a different spawning system – one with random timing, one with random positions, one with waves, and one with object pooling.

✍️ Individual Activity

Create a simple spawning system that spawns objects every 3 seconds. Save your project.

🛠️ Mini Project

Create a game with a spawning system – falling stars, enemies, or items. Use random positions and timing, and delete objects when needed.

📋 Practical Assignment

Create a game with a spawning system. Write a reflection on how you managed the objects.

🔑 Key Takeaways

• Spawning systems create objects dynamically.
• Cloning is the easiest way to spawn.
• Timing controls how often objects appear.
• Random creates variety.
• Delete clones to keep performance.
• Object pooling reuses objects.

💬 Classroom Discussion Questions

• What is the most important part of a spawning system?
• How can you make spawning more interesting?
• Why is deleting objects important?
• What other games use spawning systems?

🔜 Preparation for Module 7

In Module 7, we will explore Physics and Motion Systems. You will learn how to add gravity, velocity, and collision physics to your games.

Think about a game where characters jump or objects fall – we will learn how to make them move realistically!

You have completed Module 6 – you can now spawn and manage objects! 🎉

📘 Module 7: Physics and Motion Systems

“Making your games move like the real world.”

🌟 Module Introduction

In Modules 1-6, we learned about lists, custom blocks, game states, enemy AI, and spawning systems. Now it's time to learn about physics – how objects move and interact in the real world.

Physics makes games feel realistic. When a character jumps, it goes up and then comes down. When a ball is thrown, it follows an arc. These are all physics.

In this module, we will learn how to add gravity, velocity, acceleration, collision detection, and bounce physics to your games.

Let's make your games move like the real world!

🎯 Learning Objectives

• Understand basic physics concepts: gravity, velocity, acceleration.
• Implement gravity in your games.
• Use velocity and acceleration for smooth motion.
• Implement collision detection and response.
• Create arc trajectories for projectiles.
• Add bounce physics.

📖 Warm-up Story: The Jumping Hero

Imagine a game where a hero jumps from platform to platform. When the hero jumps, they go up and then come back down. This is gravity at work.

When the hero throws a ball, it follows an arc – up and then down. This is projectile motion.

In this module, we will learn how to create these realistic movements in Scratch. Let's make your games feel real!

📚 Main Lessons

Lesson 1: What is Physics in Games?

Definition: Physics in games is the simulation of real-world motion – gravity, velocity, and collisions.

Why important: Physics makes games realistic and fun.

Simple explanation: It's like making your game obey the laws of physics – things fall, bounce, and move realistically.

Real-life example: A ball falling to the ground.

School example: A pendulum swinging.

Home example: A toy car rolling down a ramp.

Nigerian example: A mango falling from a tree.

    Physics in Games:
    ┌─────────────────────────────────────────────┐
    │  Gravity → pulls objects down              │
    │  Velocity → speed and direction            │
    │  Acceleration → changing speed             │
    │  Collision → objects hitting each other    │
    │  Bounce → objects bouncing back            │
    └─────────────────────────────────────────────┘
    

Lesson 2: Gravity – Pulling Objects Down

Definition: Gravity is a force that pulls objects down.

Why important: Gravity makes games feel realistic.

How to implement:

• Use a variable called "gravity" (e.g., -0.5).
• Use a variable called "yVelocity".
• In a loop, change yVelocity by gravity.
• Change y position by yVelocity.

Nigerian example: A character falls when they jump.

Lesson 3: Velocity – Speed and Direction

Definition: Velocity is speed in a specific direction.

Why important: Velocity controls how fast and where an object moves.

How to implement:

• Use variables "xVelocity" and "yVelocity".
• Change x position by xVelocity.
• Change y position by yVelocity.

Nigerian example: A character moves left and right with velocity.

Lesson 4: Acceleration – Changing Speed

Definition: Acceleration is the rate of change of velocity.

Why important: Acceleration creates smooth motion.

How to implement:

• Add acceleration to velocity each frame.
• Use "change xVelocity by xAcceleration".
• Use "change yVelocity by yAcceleration".

Nigerian example: A car speeding up and slowing down.

Lesson 5: Jumping with Gravity

Why important: Jumping is a core game mechanic.

Steps:

1. Set yVelocity to a positive value (e.g., 10) when jumping.
2. Apply gravity each frame.
3. When y reaches the ground, stop falling.

Nigerian example: A character jumps and falls back down.

Lesson 6: Collision Detection

Definition: Collision detection is checking if two objects are touching.

Why important: Collisions trigger events – like damage or collecting items.

How to detect:

• Use "touching sprite" block.
• Use "touching color" block.
• Check distance between objects.

Nigerian example: A player collects a coin when touching it.

Lesson 7: Collision Response

Definition: Collision response is what happens when objects collide.

Why important: Response makes collisions meaningful.

How to respond:

• Bounce back.
• Stop movement.
• Destroy an object.
• Change score.

Nigerian example: An enemy disappears when hit.

Lesson 8: Platformer Physics

Definition: Platformer physics is used in platform games – jumping, falling, and landing on platforms.

Why important: Platformers are one of the most popular game genres.

How to implement:

• Apply gravity to the player.
• Check if the player is on a platform.
• Allow jumping when on the ground.

Nigerian example: A game where a character jumps between platforms.

Lesson 9: Projectile Motion – Arcs

Definition: Projectile motion is the path of an object thrown into the air.

Why important: Arcs are used for throwing, shooting, and jumping.

How to implement:

• Set an initial velocity.
• Apply gravity each frame.
• The object follows a parabolic arc.

Nigerian example: A ball thrown in a game follows an arc.

Lesson 10: Bounce Physics

Definition: Bounce physics makes objects bounce when they hit the ground.

Why important: Bouncing is common in games – balls, enemies, and players.

How to implement:

• Reverse velocity when hitting the ground.
• Reduce velocity slightly for realism (damping).

Nigerian example: A ball bounces on the ground.

Lesson 11: Friction and Damping

Definition: Friction slows objects down. Damping reduces bounce height.

Why important: Friction and damping make motion more realistic.

How to implement:

• Multiply velocity by a friction factor (e.g., 0.9).
• Multiply bounce velocity by a damping factor (e.g., 0.8).

Nigerian example: A ball stops rolling due to friction.

Lesson 12: Combining Physics with Other Concepts

Why important: Physics works with AI, spawning, and game states.

Example:

• Enemies use physics to chase the player.
• Objects spawn and fall with gravity.
• Game states control when physics is active.

Nigerian example: A complete game with realistic physics.

📌 Key Vocabulary

🧠 Important Concepts

• Realism: Physics makes games feel real.
• Smoothness: Velocity and acceleration create smooth motion.
• Interactivity: Collisions make games interactive.

🔢 Steps to Perform Key Tasks

Task 1: Add Gravity to a Sprite

1. Create variables: "yVelocity" and "gravity".
2. Set gravity to -0.5.
3. In a loop, change yVelocity by gravity.
4. Change y position by yVelocity.
5. Test it.

Task 2: Make a Sprite Jump

1. When space is pressed, set yVelocity to 10.
2. Apply gravity each frame.
3. When y < -180, set yVelocity to 0.
4. Test it.

Task 3: Create a Bouncing Ball

1. Create variables: "xVelocity" and "yVelocity".
2. Set initial velocities.
3. Move with velocity.
4. When hitting the edge, reverse velocity.
5. Test it.

🔢 Step-by-step: Creating a Jumping Character

1. Add a player sprite – choose a character.
2. Create variables – "yVelocity", "gravity" (-0.5).
3. Add "when green flag clicked" – start the game.
4. Add "forever" loop – update physics.
5. Add "change yVelocity by gravity" – apply gravity.
6. Add "change y by yVelocity" – move the character.
7. Add "when space pressed" – set yVelocity to 10.
8. Add ground collision – if y < -180, set yVelocity to 0.
9. Test your game – press space to jump.

🧸 Fun Examples for Children

• Pet game: Make a pet jump and bounce.
• Space game: Add gravity to spaceships.

🏠 Everyday Examples

• Family game: A platformer game for family.
• School project: A physics simulation.

👪 Parent Tips

• Show your child how gravity works in games.
• Help them understand velocity and acceleration.
• Encourage them to experiment with different physics values.

💡 Interesting Facts

• Physics engines are used in almost every game.
• Scratch does not have a built-in physics engine.
• You can create simple physics with just a few blocks.

❓ Did You Know?

• Some games have complex physics engines.
• Physics can be used for particles, cloth, and water.

🔔 Remember This

• Gravity pulls objects down.
• Velocity controls speed and direction.
• Acceleration changes speed.
• Collisions trigger events.
• Physics makes games realistic.

⚠️ Common Mistakes

• Gravity too strong. – Adjust values.
• Forgetting to reset velocity. – Reset when on the ground.
• No collision response. – Add response to collisions.
• Objects moving through each other. – Use better collision detection.

✅ Best Practices

• Start with simple gravity.
• Use variables for velocity and gravity.
• Test physics values carefully.
• Add collision detection.
• Add damping for realism.
• Combine physics with other concepts.

📊 Comparison: With vs Without Physics

📝 End-of-Module Summary

❓ Frequently Asked Questions

• Q1: What is gravity?
  Pulls objects down.
• Q2: What is velocity?
  Speed and direction.
• Q3: What is acceleration?
  Changing speed.
• Q4: How do I detect collisions?
  Use "touching" blocks.
• Q5: What is a projectile?
  An object thrown in an arc.
• Q6: How do I make objects bounce?
  Reverse velocity on collision.
• Q7: What is damping?
  Reduces bounce height.
• Q8: What is friction?
  Slows objects down.
• Q9: How do I implement jumping?
  Set velocity, apply gravity.
• Q10: Why is physics important?
  It makes games realistic.

🔗 Matching Exercise

Match the term with its description.

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

🎭 Scenario-based Exercise

Scenario: A student wants to create a platformer game with jumping, gravity, and bouncing enemies.

Question: How would you implement the physics for this game?

👥 Group Activity

In groups of 4, each person creates a different physics system – one for gravity, one for bouncing, one for projectiles, and one for platformer physics.

✍️ Individual Activity

Create a simple game with gravity and jumping. Save your project.

🛠️ Mini Project

Create a platformer game with jumping, gravity, and collision detection. Add at least one platform.

📋 Practical Assignment

Create a game that uses physics (gravity, velocity, collision). Write a reflection on how you implemented the physics.

🔑 Key Takeaways

• Gravity pulls objects down.
• Velocity controls speed and direction.
• Acceleration changes speed.
• Collisions trigger events.
• Physics makes games realistic.
• Implement physics with variables and loops.

💬 Classroom Discussion Questions

• What is the most important physics concept?
• How can you make jumping feel more realistic?
• What other games use physics?
• How can you combine physics with AI?

🔜 Preparation for Module 8

In Module 8, we will explore Scratch Extensions. You will learn how to use pen, music, video sensing, and text-to-speech extensions.

Think about a project that could use pen or video sensing – we will learn how to use them!

You have completed Module 7 – your games now have realistic physics! 🎉

📘 Module 8: Scratch Extensions

“Expanding your creative toolbox.”

🌟 Module Introduction

In Modules 1-7, we learned a lot about Scratch – lists, custom blocks, game states, AI, spawning, and physics. But did you know that Scratch has extensions that add new features?

Extensions are like extra tools for your toolbox. They let you do things that are not possible with the standard blocks – like drawing with a pen, making music, controlling a robot, or using your camera.

In this module, we will explore some of the most useful Scratch extensions: the Pen, Music, Video Sensing, and Text-to-Speech extensions.

Let's expand your creative toolbox!

🎯 Learning Objectives

• Understand what Scratch extensions are and how to use them.
• Use the Pen extension to draw and create graphics.
• Use the Music extension to create melodies and beats.
• Use the Video Sensing extension for motion detection and camera interaction.
• Use the Text-to-Speech extension to add spoken words.
• Explore other extensions like Micro:bit and LEGO (if available).

📖 Warm-up Story: The Creative Coder

Imagine you are a creative coder in Lagos. You want to create a project that draws beautiful patterns, plays music, and responds to your hand movements. But you don't know how to do it in Scratch.

Then you discover Scratch Extensions! You add the Pen extension to draw patterns, the Music extension to play melodies, and the Video Sensing extension to control the project with your hand.

Your project becomes interactive and magical. This is the power of extensions!

📚 Main Lessons

Lesson 1: What Are Scratch Extensions?

Definition: Extensions are add-ons that give Scratch new features.

Why important: Extensions let you do things that are not possible with standard blocks.

Simple explanation: It's like adding new tools to your toolbox.

Real-life example: A carpenter adding a new saw to their toolbox.

School example: A student using a calculator for math.

Home example: A chef using a new kitchen gadget.

Nigerian example: A tailor using a new sewing machine attachment.

    Scratch Extensions:
    ┌─────────────────────────────────────────────┐
    │  Pen → draw and create graphics            │
    │  Music → play melodies and beats           │
    │  Video Sensing → camera interaction        │
    │  Text-to-Speech → spoken words             │
    │  Micro:bit → control robots                │
    └─────────────────────────────────────────────┘
    

Lesson 2: How to Add an Extension

Why important: You need to know how to add extensions.

How to add:

• Click the "Add Extension" button at the bottom left.
• Choose the extension you want.
• It will appear in the blocks palette.

Nigerian example: A student adds the Pen extension to draw patterns.

Lesson 3: The Pen Extension – Drawing with Code

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

Why important: You can create graphics, patterns, and art.

Key blocks:

• pen down: Start drawing.
• pen up: Stop drawing.
• set pen "summary-box">✅ Mini summary: The Pen extension lets you draw on the stage.