Be a Game Developer Chapter Notes | Year 3 Computing IGCSE (Cambridge) - Class 3 PDF Download

Creating games

• In this unit, students will use  to create interactive games, focusing on breaking down tasks, learning from errors, and debugging programs.
• Students will learn:
  • That tasks can be broken down into smaller tasks: Dividing complex tasks into manageable sub-tasks for easier development.
  • That programmers learn from their mistakes: Recognizing errors as opportunities to improve coding practices.
  • How to test and debug programs: Identifying and fixing errors to ensure programs function as intended.
• Scratch is a block-based programming environment used to create games with sprites, sounds, and animations.

Algorithm to code

Dividing tasks

• Complex tasks can be divided into smaller, manageable sections called sub-tasks, making them easier to understand, follow, and edit.
• Keyword:
  • Sub-task: A smaller task that forms part of a larger, more complex task.
• Example: The task of “getting ready for school” can be broken into sub-tasks:
  • Brush teeth
  • Bathe
  • Change clothes
• Example: Creating a computer game.
  • Game requirements:
    • When the Green flag is clicked, a character says “Hello” and makes a meow sound.
    • When the character is clicked, it moves 10 steps, changes its costume, glides to a random position, and thinks “Hmm …” for 2 seconds.
  • Dividing into sub-tasks:
    • Sub-task 1: When the game starts

      Step	Instruction
      1	When the Green flag is clicked
      2	Say ‘Hello’ for 2 seconds
      3	Start Meow sound

    • Sub-task 2: When the character is clicked

      Step	Instruction
      1	When this sprite is clicked
      2	Move 10 steps
      3	Switch to next costume
      4	Glide 1 second to a random position
      5	Think ‘Hmm …’ for 2 seconds

  • Benefits of dividing tasks:
    • Each sub-task can be edited independently without affecting others.
    • Makes the algorithm easier to understand and modify.
    • Simplifies the process of coding by focusing on smaller sections.
• Programs, like algorithms, can be divided into smaller sections to enhance clarity and editability.

Making mistakes

• Testing programs is essential to identify mistakes or errors, which are opportunities for learning.
• Keyword:
  • Error: A mistake in a program that prevents it from functioning as intended.
• Learning from errors helps programmers avoid repeating mistakes in future coding projects.
• Example: A program with an error.
  • Game requirement: A letter changes color when clicked.
  • Algorithm:

    Step	Instruction
    1	When this sprite is clicked
    2	Change colour effect by 25

  • Implementation:
    • Create a new project and select the Block-A sprite.
    • Add the “when this sprite clicked” and “change color effect by” blocks.
    • Test the program by clicking the sprite.
  • Error identified:
    • The “change color effect by” block lacks a number (e.g., 25), causing the color not to change.
    • Lesson learned: Always specify a value in the “change color effect by” block to achieve the desired effect.

Debugging programs

• Debugging: The process of finding and fixing errors in a program to ensure it matches the intended algorithm.
• Steps to debug a program:
  • Test the code to determine if it produces the expected results.
  • Identify the part of the code that is causing incorrect behavior.
  • Modify the code to align with the algorithm.
  • Retest the program to confirm the fix resolves the issue.
• Example: Debugging a program with two sprites (Block-D and Block-E).
  • Desired outcomes:
    • Block-D: Gets smaller when clicked.
    • Block-E: Moves 10 steps and plays a meow sound when clicked.
  • Algorithms:
    • Block-D Sprite:

      Step	Instruction
      1	When this sprite is clicked
      2	Change size by −10

    • Block-E Sprite:

      Step	Instruction
      1	When this sprite is clicked
      2	Move 10 steps
      3	Play meow sound until done

  • Error in implementation:
    • The code for Block-D incorrectly uses “change size by 10” (increasing size) instead of “change size by −10” (decreasing size).
  • Debugging process:
    • Test the program and notice Block-D grows instead of shrinking.
    • Identify the error in the “change size by” block.
    • Change the value from 10 to −10 to match the algorithm.
    • Retest to confirm Block-D now shrinks when clicked.

Did you know?

• Software bugs come in various types, one of which is a Collision Detection Problem.
• Collision Detection Problem:
  • Occurs when a sprite passes through an object (e.g., a wall) it was not supposed to.
  • A common issue in video games, requiring debugging to ensure proper interaction between sprites and objects.

What can you do?

• Divide complex tasks into smaller sub-tasks to simplify algorithm design and coding.
• Learn from mistakes in programs by identifying errors and applying lessons to future coding efforts.
• Test and debug programs to ensure they produce the desired outcomes, correcting errors to match the intended algorithms.