Have a question?
Message sent Close

GAM-202-B: GAMES DEVELOPMENT (age 11-14)

Get course

Recent Comments

    General Information

    1. Each class is 60 minutes.
    2. Class days: On Saturday or Sunday
    3. Course schedule and timing will be decided once the class is complete.
    4. Minimum 5 participants to run one class.
    5. Maximum 10 participants in each class.


    1. Fair knowledge of English Speaking Course Description.
    2. Course: GAM-201-A : Game Development (11-14)

    Course Description This is level2 of the course “Game Development (11-13)”. In the world of animations and games, there are many concepts and coding experience that candidates need to acquire. In this course, we will start with simple, primitive shapes and building up to more sophisticated sprite. Students become familiar with the programming concepts and the design process, then learn how these simpler constructs can be combined to create more complex programs. Students will develop their own projects where they can practice design, testing, and debugging the code. Course Aim In this course, students learn about images and animations. This include dealing with variables, sprite, sprite movement, conditions, and keyboard input. Moreover, they will learn about functions, collision detection, velocity, and complex sprite movement. During the lessons, they will learn how to design and make their own game. Course Objective The student will:

    • Learn about graphic animation concepts such as primitive, sprites, collision detection, etc…
    • Learn about programming concepts such as variables, conditions, and functions.
    • Learn how to define the main parts of his planned game.

    Images and Animations

    The Draw Loop
    This lesson introduces the draw loop, one of the core programming paradigms in Game Lab. Students learn how to combine the draw loop with random numbers to manipulate some simple animations first with dots and then with sprites.
    Sprite Movement
    In this lesson, the class learns how to control sprite movement using a construct called the counter pattern, which incrementally changes a sprite's properties. After brainstorming different ways that they could animate sprites by controlling their properties, students explore the counter pattern in Code Studio, using the counter pattern to create various types of sprite movements.
    Mini-Project - Animation
    In this lesson, the class is asked to combine different methods from previous lessons to create an animated scene. Students first review the types of movement and animation that they have learned, and brainstorm what types of scenes might need that movement. They then begin to plan out their own animated scenes, which they create in Game Lab.
    This lesson introduces students to booleans and conditionals, which allow a program to run differently depending on whether a condition is true. The class starts by playing a short game in which they respond according to whether particular conditions are met. They then move to Code Studio, where they learn how the computer evaluates boolean expressions, and how they can be used to structure a program.
    Keyboard Input
    Following the introduction to booleans and if statements in the previous lesson, students are introduced to a new block called keyDown(), which returns a boolean and can be used in conditionals statements to move sprites around the screen. By the end of this lesson they will have written programs that take keyboard input from the user to control sprites on the screen.
    Mouse Input
    The class continues to explore ways to use conditional statements to take user input. In addition to the keyboard commands learned yesterday, they learn about several ways to take mouse input. They also expand their understanding of conditionals to include else, which allows for the computer to run a certain section of code when a condition is true, and a different section of code when it is not.
    Project - Interactive Card
    In this culminating project for Chapter 1, students plan for and develop an interactive greeting card using all of the programming techniques they've learned to this point.

    Building Games

    After a brief review of how the counter pattern is used to move sprites, the class is introduced to the idea of hiding those patterns in a single block, in order to help manage the complexity of programs. They then head to Code Studio to try out new blocks that set a sprite's velocity directly, and look at the various ways that they are able to code more complex behaviors in their sprites.

    Be the first to add a review.

    Layer 1
    Login Categories