Introduction: Your First Fun Python Game!

Have you ever played Tic-Tac-Toe? It’s a classic paper-and-pencil game for two players, ‘X’ and ‘O’, who take turns marking the spaces in a 3×3 grid. The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row wins.

Today, we’re going to bring this simple yet engaging game to life using Python! Don’t worry if you’re new to coding; we’ll go step-by-step, explaining everything in simple terms. By the end of this guide, you’ll have a fully functional Tic-Tac-Toe game running on your computer, and you’ll have learned some fundamental programming concepts along the way.

Ready to dive into the world of game development? Let’s start coding!

Understanding the Basics: How We’ll Build It

Before we jump into writing code, let’s break down the different parts we’ll need for our game:

The Game Board

First, we need a way to represent the 3×3 Tic-Tac-Toe board in our Python program. We’ll use a list for this.
* List: Think of a list as a container that can hold multiple items in a specific order. Each item in the list has an index (a number starting from 0) that tells us its position. For our Tic-Tac-Toe board, a list with 9 spots (0 to 8) will be perfect, with each spot initially empty.

Showing the Board

Players need to see the board after each move. We’ll create a function to print the current state of our list in a nice 3×3 grid format.
* Function: A function is like a mini-program or a recipe for a specific task. You give it some information (ingredients), it does its job, and sometimes it gives you back a result (the cooked meal). We’ll use functions to organize our code and make it reusable.

Player Moves

We need a way for players to choose where they want to place their ‘X’ or ‘O’. This involves getting input from the player, checking if their chosen spot is valid (is it an empty spot, and is it a number between 1 and 9?), and then updating our board.
* Input: This refers to any data that your program receives, typically from the user typing something on the keyboard.
* Integer: A whole number (like 1, 5, 100) without any decimal points. Our game board spots will be chosen using integers.
* Boolean: A data type that can only have one of two values: True or False. We’ll use these to check conditions, like whether a game is still active or if a spot is empty.

Checking for a Winner

After each move, we need to check if the current player has won the game. This means looking at all possible winning lines: three rows, three columns, and two diagonals.

Checking for a Tie

If all 9 spots on the board are filled, and no player has won, the game is a tie. We’ll need a way to detect this.

The Game Flow

Finally, we’ll put all these pieces together. The game will run in a loop until someone wins or it’s a tie. Inside this loop, players will take turns, make moves, and the board will be updated and displayed.
* Loop: A loop is a way to repeat a block of code multiple times. This is perfect for our game, which needs to keep going until a winning or tying condition is met.

Step-by-Step Construction

Let’s start building our game!

1. Setting Up Our Game Board

First, let’s create our board. We’ll use a list of 9 empty strings (' ') to represent the 9 spots.

board = [' ' for _ in range(9)]

2. Displaying the Board

Now, let’s write a function to show our board to the players in a friendly format.

def display_board(board):
    """
    Prints the Tic-Tac-Toe board in a 3x3 grid format.
    """
    print(f"{board[0]}|{board[1]}|{board[2]}") # Top row
    print("-+-+-") # Separator line
    print(f"{board[3]}|{board[4]}|{board[5]}") # Middle row
    print("-+-+-") # Separator line
    print(f"{board[6]}|{board[7]}|{board[8]}") # Bottom row

3. Handling Player Input

Next, we need a function that asks the current player for their move, checks if it’s valid, and returns the chosen spot.

def get_player_move(player, board):
    """
    Asks the current player for their move (1-9), validates it,
    and returns the 0-indexed position on the board.
    """
    while True: # Keep looping until a valid move is entered
        try: # Try to do this code
            # Get input from the player and convert it to an integer.
            # We subtract 1 because players think 1-9, but our list indices are 0-8.
            move = int(input(f"Player {player}, choose your spot (1-9): ")) - 1

            # Check if the chosen spot is within the valid range (0-8)
            # AND if that spot on the board is currently empty (' ').
            if 0 <= move <= 8 and board[move] == ' ':
                return move # If valid, return the move and exit the loop
            else:
                print("This spot is taken or out of range. Try again.")
        except ValueError: # If something goes wrong (e.g., player types text instead of number)
            print("Invalid input. Please enter a number between 1 and 9.")

4. Checking for a Win

This is where we define what constitutes a win. We’ll check all rows, columns, and diagonals.

def check_win(board, player):
    """
    Checks if the given player has won the game.
    Returns True if the player has won, False otherwise.
    """
    # Define all possible winning combinations (indices of the board list)
    win_conditions = [
        # Rows
        [0, 1, 2], [3, 4, 5], [6, 7, 8],
        # Columns
        [0, 3, 6], [1, 4, 7], [2, 5, 8],
        # Diagonals
        [0, 4, 8], [2, 4, 6]
    ]

    for condition in win_conditions:
        # For each winning combination, check if all three spots
        # are occupied by the current player.
        if board[condition[0]] == board[condition[1]] == board[condition[2]] == player:
            return True # If a win is found, return True immediately
    return False # If no win condition is met after checking all, return False

5. Checking for a Tie

A tie occurs if all spots on the board are filled, and check_win is False for both players.

def check_tie(board):
    """
    Checks if the game is a tie (all spots filled, no winner).
    Returns True if it's a tie, False otherwise.
    """
    # The game is a tie if there are no empty spots (' ') left on the board.
    return ' ' not in board

6. The Main Game Loop

Now, let’s put everything together to create the actual game!

def play_game():
    """
    This function contains the main logic to play the Tic-Tac-Toe game.
    """
    board = [' ' for _ in range(9)] # Initialize a fresh board
    current_player = 'X' # Player X starts
    game_active = True # A boolean variable to control the game loop

    print("Welcome to Tic-Tac-Toe!")
    display_board(board) # Show the initial empty board

    while game_active: # Keep playing as long as game_active is True
        # 1. Get the current player's move
        move = get_player_move(current_player, board)

        # 2. Update the board with the player's move
        board[move] = current_player

        # 3. Display the updated board
        display_board(board)

        # 4. Check for a win
        if check_win(board, current_player):
            print(f"Player {current_player} wins! Congratulations!")
            game_active = False # End the game
        # 5. If no win, check for a tie
        elif check_tie(board):
            print("It's a tie!")
            game_active = False # End the game
        # 6. If no win and no tie, switch to the other player
        else:
            # If current_player is 'X', change to 'O'. Otherwise, change to 'X'.
            current_player = 'O' if current_player == 'X' else 'X'

if __name__ == "__main__":
    play_game()

Conclusion: What You’ve Achieved!

Congratulations! You’ve just built a fully functional Tic-Tac-Toe game using Python! You started with an empty board and, step by step, added logic for displaying the board, handling player input, checking for wins, and managing ties.

You’ve learned fundamental programming concepts like:
* Lists for data storage.
* Functions for organizing your code.
* Loops for repeating actions.
* Conditional statements (if, elif, else) for making decisions.
* Error handling (try-except) for robust programs.

This project is a fantastic foundation. Feel free to experiment further:
* Can you add a way to play multiple rounds?
* How about letting players enter their names instead of just ‘X’ and ‘O’?
* Could you make a simple AI opponent?

Keep exploring, keep coding, and have fun with Python!

Hey everyone! Ever spent hours trying to clear lines in Tetris, that iconic puzzle game where colorful blocks fall from the sky? It’s a classic for a reason – simple to understand, yet endlessly engaging! What if I told you that you could build a basic version of this game yourself using Python?

In this post, we’re going to dive into creating a simple Tetris-like game. Don’t worry if you’re new to game development; we’ll break down the core ideas using easy-to-understand language and provide code snippets to guide you. By the end, you’ll have a better grasp of how games like Tetris are put together and a foundation to build even more amazing things!

What is Tetris, Anyway?

For those who might not know, Tetris is a tile-matching puzzle video game. It features seven different shapes, known as Tetrominoes (we’ll just call them ‘blocks’ for simplicity), each made up of four square blocks. These blocks fall one by one from the top of the screen. Your goal is to rotate and move these falling blocks to create complete horizontal lines without any gaps. When a line is complete, it disappears, and the blocks above it fall down, earning you points. The game ends when the stack of blocks reaches the top of the screen.

Tools We’ll Need

To bring our Tetris game to life, we’ll use Python, a popular and beginner-friendly programming language. For the graphics and game window, we’ll rely on a fantastic library called Pygame.

• Python: Make sure you have Python installed on your computer (version 3.x is recommended). You can download it from python.org.
• Pygame: This is a set of Python modules designed for writing video games. It handles things like creating windows, drawing shapes, managing user input (keyboard/mouse), and playing sounds. It makes game development much easier!

How to Install Pygame

Installing Pygame is straightforward. Open your terminal or command prompt and type the following command:

pip install pygame

• pip: This is Python’s package installer. Think of it like an app store for Python libraries. It helps you download and install additional tools that other people have created for Python.

Once pip finishes, you’re all set to start coding!

Core Concepts for Our Tetris Game

Before we jump into code, let’s think about the main components of a Tetris game:

• The Game Board (Grid): Tetris is played on a grid of cells. We’ll need a way to represent this grid in our program.
• The Blocks (Tetrominoes): We need to define the shapes and colors of the seven different Tetris blocks.
• Falling and Movement: Blocks need to fall downwards, and players need to move them left, right, and rotate them.
• Collision Detection: How do we know if a block hits the bottom of the screen, another block, or the side walls? This is crucial for stopping blocks and preventing them from overlapping.
• Line Clearing: When a row is completely filled with blocks, it should disappear, and the rows above it should shift down.
• Game Loop: Every game has a “game loop” – a continuous cycle that handles events, updates the game state, and redraws everything on the screen.

Let’s Start Coding!

We’ll begin by setting up our Pygame window and defining our game board.

Setting Up the Pygame Window

First, we need to import pygame and initialize it. Then, we can set up our screen dimensions and create the game window.

import pygame

SCREEN_WIDTH = 400
SCREEN_HEIGHT = 600
BLOCK_SIZE = 30 # Each 'cell' in our grid will be 30x30 pixels

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (50, 50, 50)
BLUE = (0, 0, 255)
CYAN = (0, 255, 255)
GREEN = (0, 255, 0)
ORANGE = (255, 165, 0)
PURPLE = (128, 0, 128)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)

pygame.init()

screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("My Simple Tetris")

• import pygame: This line brings all the Pygame tools into our program.
• SCREEN_WIDTH, SCREEN_HEIGHT: These variables define how wide and tall our game window will be in pixels.
• BLOCK_SIZE: Since Tetris blocks are made of smaller squares, this defines the size of one of those squares.
• Colors: We define common colors using RGB (Red, Green, Blue) values. Each value ranges from 0 to 255, determining the intensity of that color component.
• pygame.init(): This function needs to be called at the very beginning of any Pygame program to prepare all the modules for use.
• pygame.display.set_mode(...): This creates the actual window where our game will be displayed.
• pygame.display.set_caption(...): This sets the text that appears in the title bar of our game window.

Defining the Game Board

Our Tetris board will be a grid, like a spreadsheet. We can represent this using a 2D list (also known as a list of lists or a 2D array) in Python. Each element in this list will represent a cell on the board. A 0 might mean an empty cell, and a number representing a color could mean a filled cell.

GRID_WIDTH = SCREEN_WIDTH // BLOCK_SIZE # Number of blocks horizontally
GRID_HEIGHT = SCREEN_HEIGHT // BLOCK_SIZE # Number of blocks vertically

game_board = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]

• GRID_WIDTH, GRID_HEIGHT: We calculate the number of blocks that can fit across and down the screen based on our BLOCK_SIZE.
• game_board = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]: This is a powerful Python trick called a list comprehension. It creates a list of lists.
  • [0 for _ in range(GRID_WIDTH)] creates a single row of GRID_WIDTH zeros (e.g., [0, 0, 0, ..., 0]).
  • The outer loop for _ in range(GRID_HEIGHT) repeats this process GRID_HEIGHT times, stacking these rows to form our 2D grid. Initially, all cells are 0 (empty).

Defining Tetrominoes (The Blocks)

Each Tetris block shape (Tetromino) is unique. We can define them using a list of coordinates relative to a central point. We’ll also assign them a color.

TETROMINOES = {
    'I': {'shape': [[0,0], [1,0], [2,0], [3,0]], 'color': CYAN}, # Cyan I-block
    'J': {'shape': [[0,0], [0,1], [1,1], [2,1]], 'color': BLUE}, # Blue J-block
    'L': {'shape': [[1,0], [0,1], [1,1], [2,1]], 'color': ORANGE}, # Orange L-block (oops, this is T-block)
    # Let's fix L-block and add more common ones correctly.
    # For simplicity, we'll only define one for now, the 'Square' block, and a 'T' block
    'O': {'shape': [[0,0], [1,0], [0,1], [1,1]], 'color': YELLOW}, # Yellow O-block (Square)
    'T': {'shape': [[1,0], [0,1], [1,1], [2,1]], 'color': PURPLE}, # Purple T-block
    # ... you would add S, Z, L, J, I blocks here
}

current_block_shape_data = TETROMINOES['T']
current_block_color = current_block_shape_data['color']
current_block_coords = current_block_shape_data['shape']

block_x_offset = GRID_WIDTH // 2 - 1 # Center horizontally
block_y_offset = 0 # Top of the screen

• TETROMINOES: This is a dictionary where each key is the name of a block type (like ‘O’ for the square block, ‘T’ for the T-shaped block), and its value is another dictionary containing its shape and color.
• shape: This list of [row, column] pairs defines which cells are filled for that specific block, relative to an origin point (usually the top-leftmost cell of the block’s bounding box).
• block_x_offset, block_y_offset: These variables will keep track of where our falling block is currently located on the game grid.

Drawing Everything

Now that we have our game board and a block defined, we need functions to draw them on the screen.

def draw_grid():
    # Draw vertical lines
    for x in range(0, SCREEN_WIDTH, BLOCK_SIZE):
        pygame.draw.line(screen, GRAY, (x, 0), (x, SCREEN_HEIGHT))
    # Draw horizontal lines
    for y in range(0, SCREEN_HEIGHT, BLOCK_SIZE):
        pygame.draw.line(screen, GRAY, (0, y), (SCREEN_WIDTH, y))

def draw_board_blocks():
    for row_index, row in enumerate(game_board):
        for col_index, cell_value in enumerate(row):
            if cell_value != 0: # If cell is not empty (0)
                # Draw the filled block
                pygame.draw.rect(screen, cell_value, (col_index * BLOCK_SIZE,
                                                      row_index * BLOCK_SIZE,
                                                      BLOCK_SIZE, BLOCK_SIZE))

def draw_current_block(block_coords, block_color, x_offset, y_offset):
    for x, y in block_coords:
        # Calculate screen position for each sub-block
        draw_x = (x_offset + x) * BLOCK_SIZE
        draw_y = (y_offset + y) * BLOCK_SIZE
        pygame.draw.rect(screen, block_color, (draw_x, draw_y, BLOCK_SIZE, BLOCK_SIZE))
        # Optional: draw a border for better visibility
        pygame.draw.rect(screen, WHITE, (draw_x, draw_y, BLOCK_SIZE, BLOCK_SIZE), 1) # 1-pixel border

• draw_grid(): This function draws gray lines to visualize our grid cells.
• draw_board_blocks(): This iterates through our game_board 2D list. If a cell has a color value (not 0), it means there’s a settled block there, so we draw a rectangle of that color at the correct position.
• draw_current_block(...): This function takes the coordinates, color, and current position of our falling block and draws each of its four sub-blocks on the screen.
  • pygame.draw.rect(...): This Pygame function draws a rectangle. It takes the screen, color, a tuple (x, y, width, height) for its position and size, and an optional thickness for the border.

The Game Loop: Bringing It All Together

The game loop is the heart of our game. It runs continuously, handling user input, updating the game state, and redrawing the screen.

clock = pygame.time.Clock() # Helps control the game's speed
running = True
fall_time = 0 # Tracks how long it's been since the block last fell
fall_speed = 0.5 # How many seconds before the block moves down 1 unit

while running:
    # --- Event Handling ---
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                block_x_offset -= 1 # Move block left
            if event.key == pygame.K_RIGHT:
                block_x_offset += 1 # Move block right
            if event.key == pygame.K_DOWN:
                block_y_offset += 1 # Move block down faster

    # --- Update Game State (e.g., block falling automatically) ---
    fall_time += clock.get_rawtime() # Add time since last frame
    clock.tick() # Update clock and control frame rate

    if fall_time / 1000 >= fall_speed: # Check if enough time has passed (milliseconds to seconds)
        block_y_offset += 1 # Move the block down
        fall_time = 0 # Reset fall timer

    # --- Drawing ---
    screen.fill(BLACK) # Clear the screen with black each frame
    draw_grid() # Draw the background grid
    draw_board_blocks() # Draw any blocks that have settled on the board
    draw_current_block(current_block_coords, current_block_color, block_x_offset, block_y_offset)

    pygame.display.flip() # Update the full display Surface to the screen

pygame.quit()
print("Game Over!")

• clock = pygame.time.Clock(): This object helps us manage the game’s frame rate and calculate time intervals.
• running = True: This boolean variable controls whether our game loop continues to run. When it becomes False, the loop stops, and the game ends.
• while running:: This is our main game loop.
• for event in pygame.event.get():: This loop checks for any events that have occurred (like a key press, mouse click, or closing the window).
  • pygame.QUIT: This event occurs when the user clicks the ‘X’ button to close the window.
  • pygame.KEYDOWN: This event occurs when a key is pressed down. We check event.key to see which key was pressed (pygame.K_LEFT, pygame.K_RIGHT, pygame.K_DOWN).
• fall_time += clock.get_rawtime(): clock.get_rawtime() gives us the number of milliseconds since the last call to clock.tick(). We add this to fall_time to keep track of how much time has passed for our automatic block fall.
• clock.tick(): This function should be called once per frame. It tells Pygame how many milliseconds have passed since the last call and helps limit the frame rate to ensure the game runs at a consistent speed on different computers.
• screen.fill(BLACK): Before drawing anything new, it’s good practice to clear the screen by filling it with a background color (in our case, black).
• pygame.display.flip(): This command updates the entire screen to show everything we’ve drawn since the last flip().

What’s Next? (Beyond the Basics)

You now have a basic Pygame window with a grid and a single block that automatically falls and can be moved left, right, and down by the player. This is a great start! To make it a full Tetris game, you’d need to add these crucial features:

• Collision Detection:
  • Check if the current_block hits the bottom of the screen or another block on the game_board.
  • If a collision occurs, the block should “lock” into place on the game_board (update game_board cells with the block’s color).
  • Then, a new random block should appear at the top.
• Rotation: Implement logic to rotate the current_block‘s shape data when a rotation key (e.g., K_UP) is pressed, ensuring it doesn’t collide with walls or other blocks during rotation.
• Line Clearing:
  • After a block locks, check if any rows on the game_board are completely filled.
  • If a row is full, remove it and shift all rows above it down by one.
• Game Over Condition: If a new block appears and immediately collides with existing blocks (meaning it can’t even start falling), the game should end.
• Scoring and Levels: Keep track of the player’s score and increase the fall_speed as the score goes up to make the game harder.
• Sound Effects and Music: Add audio elements to make the game more immersive.

Conclusion

Phew! You’ve taken a significant step into game development by creating the foundational elements of a Tetris-like game in Python using Pygame. We’ve covered setting up the game window, representing the game board, defining block shapes, drawing everything on screen, and creating an interactive game loop.

This project, even in its simplified form, touches upon many core concepts in game programming: event handling, game state updates, and rendering graphics. I encourage you to experiment with the code, add more features, and personalize your game. Happy coding, and may your blocks always fit perfectly!

Welcome, aspiring game developers! Have you ever wanted to create your own game but felt intimidated by complex coding? Well, you’re in luck! Today, we’re going to dive into Pygame, a fantastic library that makes building simple 2D games in Python incredibly fun and straightforward. No prior game development experience needed – just a willingness to learn and a little bit of Python knowledge.

By the end of this guide, you’ll have created a small, interactive game where you control a square and guide it to a target. It’s a great stepping stone to more complex game ideas!

What is Pygame?

Before we jump into coding, let’s understand what Pygame is.

• Pygame: Think of Pygame as a set of tools (a “library” or “module”) for the Python programming language that makes it easier to create games. It handles a lot of the tricky parts for you, like drawing graphics, playing sounds, and processing input from your keyboard or mouse. This means you can focus more on the fun parts of game design!

Getting Started: Setting Up Your Environment

First things first, we need to make sure you have Python installed. If you don’t, head over to the official Python website (python.org) and download the latest version.

Once Python is ready, we need to install Pygame. This is usually done using a tool called pip.

• pip: This is Python’s package installer. It’s like an app store for Python libraries, allowing you to easily download and install packages like Pygame.

Open your terminal or command prompt and type the following command:

pip install pygame

If everything goes well, you’ll see messages indicating that Pygame has been successfully installed.

Pygame Fundamentals: The Building Blocks of Our Game

Every Pygame project typically follows a similar structure. Let’s look at the core components we’ll use:

1. Initializing Pygame

Before we can use any Pygame features, we need to tell Pygame to get ready. This is done with pygame.init().

2. Setting Up the Game Window

Our game needs a window to display everything. We’ll set its size (width and height) and give it a title.

• Screen/Surface: In Pygame, a “surface” is basically a blank canvas (like a piece of paper) where you draw everything. The main window of your game is the primary surface.

3. Colors!

Games use colors, of course! In Pygame, colors are represented using RGB values.

• RGB (Red, Green, Blue): This is a way to describe colors by mixing different amounts of red, green, and blue light. Each color component is given a value from 0 to 255.
  • (0, 0, 0) is Black
  • (255, 255, 255) is White
  • (255, 0, 0) is Red
  • (0, 255, 0) is Green
  • (0, 0, 255) is Blue

4. The Game Loop: The Heartbeat of Your Game

This is the most important concept in game development. A game isn’t just a single program that runs once; it’s a constant cycle of doing several things over and over again, many times per second.

• Game Loop: Imagine a constant cycle that runs incredibly fast (e.g., 60 times per second). In each cycle (or “frame”), the game does these three things:
  • a. Handle Events: Check for any user input (keyboard presses, mouse clicks) or system events (like closing the window).
  • b. Update Game State: Move characters, check for collisions, update scores – basically, change anything that needs to be different in the next moment.
  • c. Draw Everything: Clear the screen, then draw all the characters, backgrounds, and text in their new positions.
  • d. Update Display: Show the newly drawn frame on your screen. Without this, you wouldn’t see anything!
  • e. Control Frame Rate: Make sure the game doesn’t run too fast or too slow on different computers.

5. Quitting Pygame

When the game loop finishes (e.g., when the user closes the window), we need to properly shut down Pygame using pygame.quit().

Our Simple Game: “Square Journey”

Let’s put these concepts into practice and build our “Square Journey” game! Our goal is simple: control a blue square to reach a green target square.

Step 1: Basic Setup and Window

First, we’ll get the basic Pygame window up and running.

import pygame

pygame.init()

WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
BLACK = (0, 0, 0)

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Square Journey")

clock = pygame.time.Clock()

game_over = False

Step 2: Creating Our Player and Target

We’ll use pygame.Rect to define our squares.

• Rect (Rectangle): In Pygame, a Rect is a very useful object that stores the coordinates (x, y) of the top-left corner, and the width and height of a rectangular area. It’s perfect for representing game objects or their boundaries for things like collision detection.

player_size = 50
player_x = 50
player_y = SCREEN_HEIGHT // 2 - player_size // 2 # Center vertically
player_speed = 5
player_rect = pygame.Rect(player_x, player_y, player_size, player_size)

target_size = 50
target_x = SCREEN_WIDTH - 100
target_y = SCREEN_HEIGHT // 2 - target_size // 2 # Center vertically
target_rect = pygame.Rect(target_x, target_y, target_size, target_size)

Step 3: The Game Loop and Event Handling

Now, let’s create the main game loop. This is where the magic happens! We’ll start by just handling the event of closing the window.

running = True
while running:
    # 1. Event handling
    for event in pygame.event.get():
        if event.type == pygame.QUIT: # If the user clicked the close button
            running = False # Exit the game loop

    # If the game is not over, process movement and collision
    if not game_over:
        # 2. Update Game State (Player Movement)
        keys = pygame.key.get_pressed() # Get all currently pressed keys
        if keys[pygame.K_LEFT]:
            player_rect.x -= player_speed
        if keys[pygame.K_RIGHT]:
            player_rect.x += player_speed
        if keys[pygame.K_UP]:
            player_rect.y -= player_speed
        if keys[pygame.K_DOWN]:
            player_rect.y += player_speed

        # Keep player within screen bounds
        player_rect.left = max(0, player_rect.left)
        player_rect.right = min(SCREEN_WIDTH, player_rect.right)
        player_rect.top = max(0, player_rect.top)
        player_rect.bottom = min(SCREEN_HEIGHT, player_rect.bottom)

        # Check for collision with target
        if player_rect.colliderect(target_rect):
            game_over = True # Set game_over to True

    # 3. Drawing everything
    screen.fill(BLACK) # Fill the screen with black to clear the previous frame

    pygame.draw.rect(screen, BLUE, player_rect) # Draw the player
    pygame.draw.rect(screen, GREEN, target_rect) # Draw the target

    if game_over:
        font = pygame.font.Font(None, 74) # Choose font, None means default, size 74
        text = font.render("You Reached the Target!", True, WHITE) # Render text, True for anti-aliasing
        text_rect = text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)) # Center the text
        screen.blit(text, text_rect) # Draw the text onto the screen

    # 4. Update the display
    pygame.display.flip() # Show everything we've drawn

    # 5. Control frame rate
    clock.tick(60) # Limit the game to 60 frames per second

pygame.quit()

Understanding the Code

Let’s break down the important parts of the code:

• import pygame: Brings all the Pygame tools into our program.
• pygame.init(): Gets Pygame ready.
• SCREEN_WIDTH, SCREEN_HEIGHT: Variables to store our window’s dimensions.
• screen = pygame.display.set_mode(...): Creates the actual window.
• pygame.display.set_caption(...): Sets the title displayed at the top of the window.
• player_rect = pygame.Rect(...): Creates a rectangle for our player. This Rect object will hold its position and size.
• running = True: A variable that keeps our game loop going. When running becomes False, the loop stops and the game ends.
• while running:: This is our main game loop. Everything inside this while loop runs repeatedly.
• for event in pygame.event.get():: This checks for all user inputs and system events that have happened since the last frame.
• if event.type == pygame.QUIT:: If the user clicks the ‘X’ button to close the window, this event is triggered, and we set running = False to stop the game.
• keys = pygame.key.get_pressed(): This gets the state of all keyboard keys. We can then check specific keys.
• if keys[pygame.K_LEFT]:: Checks if the left arrow key is currently being held down. If it is, we decrease player_rect.x to move the player left. K_RIGHT, K_UP, K_DOWN work similarly.
• player_rect.left = max(0, player_rect.left): This line, and others like it, prevent the player from moving off-screen. max(0, ...) ensures the left edge is never less than 0.
• screen.fill(BLACK): This fills the entire screen with black. It’s crucial because it clears whatever was drawn in the previous frame, preventing a “smearing” effect.
• pygame.draw.rect(screen, BLUE, player_rect): This draws a rectangle on our screen surface. It’s blue (BLUE) and uses the dimensions stored in player_rect.
• player_rect.colliderect(target_rect): This is a very handy Pygame function that checks if two Rect objects are overlapping. If they are, it returns True.
• font = pygame.font.Font(None, 74): This creates a font object we can use to display text. None uses the default font.
• text = font.render("...", True, WHITE): This actually creates an image (another surface) of our text in white (WHITE). True enables anti-aliasing for smoother edges.
• text_rect = text.get_rect(center=(...)): This gets a Rect for our text image and centers it on the screen.
• screen.blit(text, text_rect): This draws (or “blits”) our text image onto the main screen surface at the specified text_rect position.
• pygame.display.flip(): This command updates the entire screen to show everything we’ve drawn since the last flip(). It’s how you see your game visually change.
• clock.tick(60): This tells Pygame to pause briefly if necessary to ensure the game doesn’t run faster than 60 frames per second. This makes the game run at a consistent speed on different computers.
• pygame.quit(): Cleans up all the Pygame modules when the game is over.

Running Your Game

Save the code above as a Python file (e.g., square_journey.py). Then, open your terminal or command prompt, navigate to where you saved the file, and run it using:

python square_journey.py

You should see a window pop up with a blue square and a green square. Use your arrow keys to move the blue square! When it touches the green square, a “You Reached the Target!” message will appear.

What’s Next? Ideas for Your Game!

Congratulations! You’ve just created your first game with Pygame. This is just the beginning. Here are some ideas to expand your “Square Journey” game:

• Add More Levels: Create different target positions or add obstacles.
• Scoring: Keep track of how many targets you hit.
• Different Shapes/Images: Instead of squares, try drawing circles or loading actual image files for your player and target.
• Sounds and Music: Add sound effects when you hit the target or background music.
• Timer: Add a timer to see how fast you can reach the target.
• Enemies: Introduce another square that moves around, and if it touches you, it’s “Game Over!”.

Pygame is a powerful and fun tool for learning game development. Don’t be afraid to experiment, read the official Pygame documentation, and try out new ideas. Happy coding!