GameMaker Lesson Plan

Project Name

Your GameMaker project must be named:

PX_lastname_SimplePlatformer

Replace lastname with your own last name.

Example:

PX_Smith_SimplePlatformer

Learning Objectives

By the end of this lesson, you should be able to:

1. Create a GameMaker project.
2. Create player and platform sprites.
3. Create objects and a game room.
4. Program horizontal player movement.
5. Implement gravity and jumping.
6. Detect collisions with platforms.
7. Prevent the player from falling through platforms.
8. Prevent repeated jumping while airborne.
9. Create a playable platform course.
10. Create a goal and level completion condition.
11. Test and debug your program.
12. Capture a screenshot and gameplay video.

Required Submission Files

Part 1 – Create the Project

1. Open GameMaker.
2. Create a new project.
3. Select a GML Code project.
4. Save the project using the required filename.

PX_lastname_SimplePlatformer

Part 2 – Create the Sprites

Create the following sprites:

You may draw your own graphics or use simple colored rectangles.

Sprite Origins

Set the origin of the player and platform sprites to Top Left (0, 0).

Use rectangular collision masks for the player and platforms.

Part 3 – Create the Objects

Assign the appropriate sprite to each object.

Leave the objects' Solid property unchecked. You will handle collisions using GML code.

Part 4 – Create the Room

Create a room called:

rm_game

Suggested room dimensions:

• Width: 1024 pixels
• Height: 768 pixels

Place one player near the bottom-left corner.

Create a starting ground platform and several elevated platforms.

Place the goal on the final platform.

Example Level Design

This illustration is an example of how to arrange your platforms. Your actual room must be created inside GameMaker.

Part 5 – Create Player Movement Variables

Select:

obj_player

Add a Create Event.

Enter:

// Player movement settings
move_speed = 4;

// Vertical movement settings
vsp = 0;

// Gravity acceleration
gravity_force = 0.5;

// Initial upward jumping velocity
jump_speed = -10;

// Maximum falling velocity
max_fall_speed = 12;

Understanding the Variables

Part 6 – Program Horizontal Movement

Add a Step Event to obj_player.

Enter the following code:

// Check keyboard input
var move_right = keyboard_check(vk_right)
              || keyboard_check(ord("D"));

var move_left = keyboard_check(vk_left)
             || keyboard_check(ord("A"));

// Determine horizontal movement
var hsp = (move_right - move_left) * move_speed;

// Move without passing through platforms
var remaining_x = abs(hsp);
var step_x = sign(hsp);

while (remaining_x > 0)
{
    var amount = min(1, remaining_x);

    if (!place_meeting(
        x + step_x * amount,
        y,
        obj_platform))
    {
        x += step_x * amount;
    }
    else
    {
        break;
    }

    remaining_x -= amount;
}

// Keep the player inside the room
x = clamp(
    x,
    0,
    room_width - sprite_width
);

Understanding the Code

keyboard_check() detects whether the player is pressing a movement key.

hsp stores the player's horizontal movement for the current step.

place_meeting() checks whether moving the player would cause a collision with a platform.

clamp() prevents the player from leaving the room horizontally.

Part 7 – Add Gravity and Jumping

Understanding Gravity

Gravity pulls the player downward.

In GameMaker, positive vertical velocity moves the player downward.

Negative vertical velocity moves the player upward.

// Upward movement
vsp = -10;

// Downward movement
vsp = 10;

Add the Jumping Code

Add the following code underneath the horizontal movement code in the obj_player Step Event.

// Check whether the player is on a platform
var on_ground = place_meeting(
    x,
    y + 1,
    obj_platform
);

// Allow jumping only while standing
// on a platform
if (on_ground && (
    keyboard_check_pressed(vk_space)
    || keyboard_check_pressed(vk_up)
    || keyboard_check_pressed(ord("W"))
))
{
    vsp = jump_speed;
}

// Apply gravity
vsp += gravity_force;

// Limit falling speed
vsp = min(vsp, max_fall_speed);

How Jumping Works

1. The player presses Space, W, or Up.
2. The game checks whether the player is on a platform.
3. The player's vertical velocity becomes negative.
4. The player moves upward.
5. Gravity gradually reduces upward velocity.
6. The player stops rising and begins falling.
7. The player lands on a platform.

Part 8 – Add Vertical Collision Detection

The player must land on platforms instead of falling through them.

Add the following code underneath your gravity and jumping code in the obj_player Step Event.

// Move vertically without passing
// through platforms

var remaining_y = abs(vsp);
var step_y = sign(vsp);

while (remaining_y > 0)
{
    var amount = min(1, remaining_y);

    if (!place_meeting(
        x,
        y + step_y * amount,
        obj_platform))
    {
        y += step_y * amount;
    }
    else
    {
        // Stop vertical movement
        // when a platform is reached
        vsp = 0;
        break;
    }

    remaining_y -= amount;
}

Understanding Collision Detection

The code checks whether the player's next movement would cause a collision.

If the path is clear, the player moves.

If a platform blocks the movement, the player stops.

This prevents the player from falling through platforms or jumping through platforms from below.

Part 9 – Create a Playable Platform Course

Your game must contain at least five platforms, including the starting ground.

Arrange platforms at different heights.

The player must move horizontally and jump to reach the final platform.

Required Features

• Starting ground platform.
• At least four additional platforms.
• Platforms at different heights.
• Platforms separated by gaps.
• A playable path from start to finish.

Test every jump to make sure the player can complete the course.

If a jump is too difficult, adjust the platform positions or jumping variables.

Part 10 – Create a Goal

Create a sprite called:

spr_goal

Create an object called:

obj_goal

Assign spr_goal to obj_goal.

Place the goal on the final platform.

Goal Collision

Select obj_player.

Add a Collision Event with obj_goal.

// Complete the level
show_message(
    "Congratulations! You completed the level!"
);

// Restart the room
room_restart();

When the player reaches the goal, a completion message appears and the room restarts.

Part 11 – Test Your Game

Run the game and check each requirement.

Part 12 – Required Screenshot

PX_lastname_SimplePlatformer_Screenshot.png

You must submit a screenshot of your completed project inside the GameMaker engine.

Instructions

1. Open your completed project in GameMaker.
2. Display the Room Editor showing your completed platformer level.
3. Make sure the player, platforms, and goal are visible.
4. Press Windows + Shift + S to open the Windows Snipping Tool.
5. Capture the GameMaker window.
6. Save the screenshot as a PNG file.

Your screenshot should show the GameMaker interface and your completed project.

Part 13 – Required Gameplay Video

PX_lastname_SimplePlatformer_Demo.mp4

You must record a video demonstrating your actual GameMaker program running.

Recording Instructions

1. Open your completed project in GameMaker.
2. Run the game.
3. Open Windows Snipping Tool and select its video recording option, or use another screen recorder.
4. Select the area containing the running game.
5. Begin recording.
6. Demonstrate the required gameplay.
7. Stop the recording after at least 7 seconds.
8. Save the recording as an MP4 file.

What Your Video Must Show

• Player movement to the left and right.
• The player jumping.
• The player landing on a platform.
• The player jumping between platforms.
• The game running without error messages.

Reaching the final goal during your recording is encouraged.

Part 14 – Debugging Checklist

Player Does Not Move

Check the player's Step Event.

Make sure the movement code is inside obj_player.

Player Does Not Jump

Check that jump_speed is a negative value.

Make sure the player is standing on a platform before pressing Jump.

Player Falls Through Platforms

Check the collision masks and vertical collision code.

Verify that the platform object is named obj_platform.

Player Can Jump Repeatedly in Midair

Make sure the jump code checks whether the player is standing on a platform.

Player Cannot Reach a Platform

Adjust platform positions or the jumping variables.

Goal Does Not Work

Check the Collision Event between obj_player and obj_goal.

Part 15 – Optional Challenge Activities

Vocabulary

Review Questions

1. What is gravity, and how does it affect the player?
2. Why does jumping velocity begin with a negative value?
3. What happens to vertical velocity while the player is falling?
4. How does place_meeting() prevent the player from moving through platforms?
5. Why should jumping be allowed only when the player is standing on a platform?
6. What is the difference between horizontal and vertical velocity?
7. How could you make the player jump higher?
8. What happens if the gravity value is increased?
9. Why is collision detection important in a platform game?
10. What must your gameplay video demonstrate to show that your program works?

100-Point Grading Rubric

Final Submission

Submit all three required items to Google Classroom according to your teacher's instructions.

Verify that all files use your correct last name before submitting.