GTA East Academy

The Exit Strategy

Objective: The Exit Strategy

Let's begin by reviewing our objective.

Write a script with a game loop that specifically checks for the pygame.QUIT event. If the event is detected, the script must call pygame.quit() and exit the program gracefully. You must use only the pygame library for this task; do not use or reference the turtle module.

Check Spec: See the Failing Tests

Next, we'll run pytest to see the failing tests. This confirms the engineering specification we need to meet.

Test Results:

  • ❌ test_quit_event_triggers_graceful_exit
  • ❌ test_loop_ignores_other_events

Implement: main.py

Now, let's build the solution by following the TODO comments in the skeleton code. Each implementation slide covers all TODOs for a single file, referencing the most relevant documentation sections to review for the task.

Step by step checklist:

  1. Create a loop to go through the list of events that have occurred.
  2. Inside the loop, check if the current event is the QUIT event type.
  3. If it is the QUIT event, change the value of the running variable to stop the main game loop.

The following documentation sections are going to be helpful:

  • Fetching Events
  • Processing Events
  • Checking Specific Event Types

Validate: Run the Tests Again

With the code in place, let's run the tests again to validate our work.

Test Results:

  • ✅ test_quit_event_triggers_graceful_exit
  • ✅ test_loop_ignores_other_events All tests passed!

Documentation

Pygame Basics: Blueprint 1 Reference

This document provides a quick reference for fundamental Pygame concepts covered in the initial setup of a game window and basic event handling.

1. Getting Started

Before using Pygame, the library must be imported and initialized.

Initialization and Shutdown

  • pygame.init(): Prepares all the Pygame modules for use. This function should be called once at the very beginning of a Pygame program.
  • pygame.quit(): Shuts down all the Pygame modules. This function should be called once at the very end, typically after the main game loop has finished.

A simple animation or diagram illustrating the init/quit process.

2. The Game Window

The visual output of a Pygame program appears in a window, referred to as the display surface.

Creating the Display Surface (Screen)

  • screen = pygame.display.set_mode((width, height)): Creates the main window with the specified dimensions (width and height in pixels). The function returns a Surface object representing the window, which is commonly stored in a variable named screen.

Setting the Window Title

  • pygame.display.set_caption("Your Title"): Sets the text that appears in the window's title bar.

An image of a blank Pygame window with a title bar.

3. The Game Loop

A game program typically runs continuously, checking for input, updating game elements, and drawing to the screen many times per second. This is managed by a main loop.

Purpose and Basic Structure

The game loop keeps the program running. A common structure uses a variable to control the loop's execution.

running = True
while running:
    # Code inside the loop runs repeatedly
    pass # Placeholder for game logic

# Code outside the loop runs after the loop finishes

When the condition controlling the while loop becomes False, the loop terminates, and the program can proceed to shut down.

A diagram showing the game loop cycle (Events -> Update -> Draw -> Flip).

4. Handling Events

Events are how Pygame detects user input (like key presses, mouse movement, window closing) and other occurrences.

Fetching Events

  • pygame.event.get(): This function retrieves all events that have occurred since the last time it was called. It returns a list of event objects. This should be called once per frame inside the game loop.

Processing Events

The standard approach is to loop through the list of events obtained from pygame.event.get() and check the type attribute of each event.

for event in pygame.event.get():
    # Check the type of the event
    if event.type == SOME_EVENT_TYPE:
        # Respond to this specific event
        pass

Checking Specific Event Types

Pygame defines constants for different event types:

  • pygame.QUIT: Triggered when the user clicks the window's close button (the 'X').
  • pygame.KEYDOWN: Triggered when a keyboard key is pressed down.
  • pygame.MOUSEMOTION: Triggered when the mouse cursor moves within the window.
for event in pygame.event.get():
    # Check if the user clicked the window's 'X' button
    if event.type == pygame.QUIT:
        # Handle quitting
        pass

    # Check if any key was pressed down
    if event.type == pygame.KEYDOWN:
        # Handle key press
        pass

    # Check if the mouse was moved
    if event.type == pygame.MOUSEMOTION:
        # Handle mouse movement
        pass

Inspecting Event Data

Event objects carry additional information as attributes.

  • Inspecting All Data: To see all data associated with an event, you can print its internal dictionary using the __dict__ attribute. This is useful for exploration and debugging.

    if event.type == pygame.KEYDOWN:
    # Prints all data associated with the key press event
    print(event.__dict__)

  • Accessing Specific Attributes: Specific event types have specific attributes. For example, the MOUSEMOTION event has a pos attribute, which is a tuple (x, y) representing the mouse coordinates.

    if event.type == pygame.MOUSEMOTION:
    # Prints the current (x, y) coordinates of the mouse
    print(event.pos)

A console showing event data being printed, possibly highlighting __dict__ or pos output.

5. Drawing

Drawing in Pygame involves preparing the visual content and then making it visible on the screen.

The Drawing Process

Drawing is typically a two-step process per frame:

  1. Draw onto a hidden surface (the 'back buffer').
  2. Swap the hidden surface with the currently visible surface (the 'front buffer') to show the completed drawing.

Filling the Background

  • surface.fill(COLOR): Fills the entire surface (like the main screen surface) with a single color. This is often used at the beginning of each frame to clear the screen and set the background color. COLOR is usually an RGB tuple like (255, 0, 0) for red.

Updating the Display

  • pygame.display.flip(): Updates the entire screen to show everything that has been drawn since the last update. This function should be called once per frame after all drawing operations are complete.

A diagram showing a hidden "back" surface being drawn on, and then the flip() operation swapping it with the visible "front" surface.