import random

def initialize_boards(rows, cols):
    """
    Creates two empty boards: one for game logic and one for display.

    Args:
        rows (int): The number of rows in the board.
        cols (int): The number of columns in the board.

    Returns:
        tuple: A tuple containing (board, display_board).
               'board' holds '0' for empty cells initially.
               'display_board' holds '-' for hidden cells.
    """
    board = [['0' for _ in range(cols)] for _ in range(rows)]
    display_board = [['-' for _ in range(cols)] for _ in range(rows)]
    return board, display_board

def place_mines(board, num_mines):
    """
    Randomly places mines ('M') on the game board.

    Args:
        board (list of lists): The game board where mines will be placed.
        num_mines (int): The total number of mines to place.
    """
    rows = len(board)
    cols = len(board[0])
    mines_placed = 0

    while mines_placed < num_mines:
        r = random.randint(0, rows - 1) # Pick a random row
        c = random.randint(0, cols - 1) # Pick a random column

        if board[r][c] != 'M': # If there isn't already a mine here
            board[r][c] = 'M'
            mines_placed += 1

def calculate_numbers(board):
    """
    Calculates the number of adjacent mines for each non-mine cell.

    Args:
        board (list of lists): The game board with mines placed.
    """
    rows = len(board)
    cols = len(board[0])

    for r in range(rows):
        for c in range(cols):
            if board[r][c] == 'M':
                continue # Skip if it's a mine

            mine_count = 0
            # Check all 8 adjacent cells
            for dr in [-1, 0, 1]: # Delta row: -1 (up), 0 (same row), 1 (down)
                for dc in [-1, 0, 1]: # Delta col: -1 (left), 0 (same col), 1 (right)
                    if dr == 0 and dc == 0: # Skip the current cell itself
                        continue

                    nr, nc = r + dr, c + dc # Neighbor row, neighbor col

                    # Check if the neighbor is within the board boundaries
                    if 0 <= nr < rows and 0 <= nc < cols:
                        if board[nr][nc] == 'M':
                            mine_count += 1
            board[r][c] = str(mine_count) # Store the count as a string

def print_display_board(display_board):
    """
    Prints the current state of the display board to the console.
    """
    rows = len(display_board)
    cols = len(display_board[0])

    # Print column numbers
    print("  ", end="")
    for c in range(cols):
        print(f" {c}", end="")
    print()

    # Print a separator line
    print("  " + "---" * cols)

    # Print row numbers and board content
    for r in range(rows):
        print(f"{r} |", end="")
        for c in range(cols):
            print(f" {display_board[r][c]}", end="")
        print(" |")
    print("  " + "---" * cols)

def get_player_move(rows, cols):
    """
    Prompts the player to enter their move (row and column).

    Args:
        rows (int): Total number of rows on the board.
        cols (int): Total number of columns on the board.

    Returns:
        tuple: (row, col) if input is valid, otherwise asks again.
    """
    while True:
        try:
            move_input = input(f"Enter your move (row column, e.g., 0 0): ").split()
            r, c = int(move_input[0]), int(move_input[1])

            if 0 <= r < rows and 0 <= c < cols:
                return r, c
            else:
                print("Invalid input. Row and column must be within board limits.")
        except (ValueError, IndexError):
            print("Invalid input format. Please enter two numbers separated by a space.")

def play_game():
    """
    Main function to run the Minesweeper game.
    """
    print("Welcome to Simple Minesweeper!")

    # You can change these values to make the board bigger or smaller
    board_rows = 5
    board_cols = 5
    number_of_mines = 4 

    # Initialize the board and display board
    game_board, current_display = initialize_boards(board_rows, board_cols)
    place_mines(game_board, number_of_mines)
    calculate_numbers(game_board)

    game_over = False
    mines_hit = False
    safe_cells_revealed = 0
    total_safe_cells = (board_rows * board_cols) - number_of_mines

    while not game_over:
        print_display_board(current_display)

        # Get player move
        row, col = get_player_move(board_rows, board_cols)

        # Check if the cell is already revealed
        if current_display[row][col] != '-':
            print("This cell is already revealed. Choose another one.")
            continue

        # Reveal the cell
        cell_content = game_board[row][col]
        current_display[row][col] = cell_content # Update what the player sees

        if cell_content == 'M':
            mines_hit = True
            game_over = True
            print("\nBOOM! You hit a mine. Game Over!")
        else:
            safe_cells_revealed += 1
            if safe_cells_revealed == total_safe_cells:
                game_over = True
                print("\nCongratulations! You've cleared all the safe cells. You Win!")

    # After game over, reveal the full board for review
    print("\n--- Game Board Revealed ---")
    # Temporarily copy game_board content to display to show all mines
    final_display = [['0' for _ in range(board_cols)] for _ in range(board_rows)]
    for r in range(board_rows):
        for c in range(board_cols):
            final_display[r][c] = game_board[r][c]
    print_display_board(final_display)

if __name__ == "__main__":
    play_game()

import random

def initialize_boards(rows, cols):
    """
    Creates two empty boards: one for game logic and one for display.

    Args:
        rows (int): The number of rows in the board.
        cols (int): The number of columns in the board.

    Returns:
        tuple: A tuple containing (board, display_board).
               'board' holds '0' for empty cells initially.
               'display_board' holds '-' for hidden cells.
    """
    board = [['0' for _ in range(cols)] for _ in range(rows)]
    display_board = [['-' for _ in range(cols)] for _ in range(rows)]
    return board, display_board

def place_mines(board, num_mines):
    """
    Randomly places mines ('M') on the game board.

    Args:
        board (list of lists): The game board where mines will be placed.
        num_mines (int): The total number of mines to place.
    """
    rows = len(board)
    cols = len(board[0])
    mines_placed = 0

    while mines_placed < num_mines:
        r = random.randint(0, rows - 1) # Pick a random row
        c = random.randint(0, cols - 1) # Pick a random column

        if board[r][c] != 'M': # If there isn't already a mine here
            board[r][c] = 'M'
            mines_placed += 1

def calculate_numbers(board):
    """
    Calculates the number of adjacent mines for each non-mine cell.

    Args:
        board (list of lists): The game board with mines placed.
    """
    rows = len(board)
    cols = len(board[0])

    for r in range(rows):
        for c in range(cols):
            if board[r][c] == 'M':
                continue # Skip if it's a mine

            mine_count = 0
            # Check all 8 adjacent cells
            for dr in [-1, 0, 1]: # Delta row: -1 (up), 0 (same row), 1 (down)
                for dc in [-1, 0, 1]: # Delta col: -1 (left), 0 (same col), 1 (right)
                    if dr == 0 and dc == 0: # Skip the current cell itself
                        continue

                    nr, nc = r + dr, c + dc # Neighbor row, neighbor col

                    # Check if the neighbor is within the board boundaries
                    if 0 <= nr < rows and 0 <= nc < cols:
                        if board[nr][nc] == 'M':
                            mine_count += 1
            board[r][c] = str(mine_count) # Store the count as a string

def print_display_board(display_board):
    """
    Prints the current state of the display board to the console.
    """
    rows = len(display_board)
    cols = len(display_board[0])

    # Print column numbers
    print("  ", end="")
    for c in range(cols):
        print(f" {c}", end="")
    print()

    # Print a separator line
    print("  " + "---" * cols)

    # Print row numbers and board content
    for r in range(rows):
        print(f"{r} |", end="")
        for c in range(cols):
            print(f" {display_board[r][c]}", end="")
        print(" |")
    print("  " + "---" * cols)

def get_player_move(rows, cols):
    """
    Prompts the player to enter their move (row and column).

    Args:
        rows (int): Total number of rows on the board.
        cols (int): Total number of columns on the board.

    Returns:
        tuple: (row, col) if input is valid, otherwise asks again.
    """
    while True:
        try:
            move_input = input(f"Enter your move (row column, e.g., 0 0): ").split()
            r, c = int(move_input[0]), int(move_input[1])

            if 0 <= r < rows and 0 <= c < cols:
                return r, c
            else:
                print("Invalid input. Row and column must be within board limits.")
        except (ValueError, IndexError):
            print("Invalid input format. Please enter two numbers separated by a space.")

def play_game():
    """
    Main function to run the Minesweeper game.
    """
    print("Welcome to Simple Minesweeper!")

    # You can change these values to make the board bigger or smaller
    board_rows = 5
    board_cols = 5
    number_of_mines = 4 

    # Initialize the board and display board
    game_board, current_display = initialize_boards(board_rows, board_cols)
    place_mines(game_board, number_of_mines)
    calculate_numbers(game_board)

    game_over = False
    safe_cells_revealed = 0
    total_safe_cells = (board_rows * board_cols) - number_of_mines

    while not game_over:
        print_display_board(current_display)

        # Get player move
        row, col = get_player_move(board_rows, board_cols)

        # Check if the cell is already revealed
        if current_display[row][col] != '-':
            print("This cell is already revealed. Choose another one.")
            continue

        # Reveal the cell
        cell_content = game_board[row][col]
        current_display[row][col] = cell_content # Update what the player sees

        if cell_content == 'M':
            game_over = True
            print("\nBOOM! You hit a mine. Game Over!")
        else:
            safe_cells_revealed += 1
            if safe_cells_revealed == total_safe_cells:
                game_over = True
                print("\nCongratulations! You've cleared all the safe cells. You Win!")

    # After game over, reveal the full board for review
    print("\n--- Game Board Revealed ---")
    # Temporarily copy game_board content to display to show all mines
    final_display = [['0' for _ in range(board_cols)] for _ in range(board_rows)]
    for r in range(board_rows):
        for c in range(board_cols):
            final_display[r][c] = game_board[r][c]
    print_display_board(final_display)

if __name__ == "__main__":
    play_game()

import turtle
import math # We'll use this later for distance calculations

wn = turtle.Screen() # This creates our game window
wn.setup(width=600, height=600) # Sets the size of the window
wn.bgcolor("black") # Sets the background color to black
wn.title("Simple Pac-Man") # Gives our window a title
wn.tracer(0) # This turns off screen updates, we'll update manually for smoother animation

player = turtle.Turtle() # Creates a new turtle object for our player
player.shape("circle") # Makes the player look like a circle
player.color("yellow") # Sets Pac-Man's color
player.penup() # Lifts the "pen" so it doesn't draw lines when moving
player.goto(0, 0) # Sets Pac-Man's starting position at the center of the screen
player.direction = "stop" # A variable to keep track of Pac-Man's current movement direction

foods = []

food_positions = [
    (-200, 200), (-150, 200), (-100, 200), (-50, 200), (0, 200), (50, 200), (100, 200), (150, 200), (200, 200),
    (-200, 150), (-100, 150), (0, 150), (100, 150), (200, 150),
    (-200, 100), (-150, 100), (-50, 100), (50, 100), (150, 100), (200, 100),
    (-200, 0), (-100, 0), (0, 0), (100, 0), (200, 0), # Note: (0,0) is player start, we'll remove it later
    (-200, -100), (-150, -100), (-50, -100), (50, -100), (150, -100), (200, -100),
    (-200, -150), (-100, -150), (0, -150), (100, -150), (200, -150),
    (-200, -200), (-150, -200), (-100, -200), (-50, -200), (0, -200), (50, -200), (100, -200), (150, -200), (200, -200)
]

for pos in food_positions:
    food = turtle.Turtle()
    food.shape("circle")
    food.color("white")
    food.shapesize(0.5) # Makes the food circles smaller
    food.penup()
    food.goto(pos)
    foods.append(food) # Add each food pellet to our 'foods' list

for food in foods:
    if food.distance(player) < 1: # If food is very close to the player
        food.hideturtle() # Make it invisible
        foods.remove(food) # Remove it from our list
        break # Exit the loop once found and removed

def go_up():
    player.direction = "up"

def go_down():
    player.direction = "down"

def go_left():
    player.direction = "left"

def go_right():
    player.direction = "right"

wn.listen() # Tells the window to listen for keyboard input
wn.onkeypress(go_up, "w") # When 'w' is pressed, call go_up()
wn.onkeypress(go_down, "s") # When 's' is pressed, call go_down()
wn.onkeypress(go_left, "a") # When 'a' is pressed, call go_left()
wn.onkeypress(go_right, "d") # When 'd' is pressed, call go_right()

wn.onkeypress(go_up, "Up")
wn.onkeypress(go_down, "Down")
wn.onkeypress(go_left, "Left")
wn.onkeypress(go_right, "Right")

score = 0

score_display = turtle.Turtle()
score_display.speed(0) # Fastest animation speed
score_display.color("white")
score_display.penup()
score_display.hideturtle() # We don't want to see the turtle itself, just its writing
score_display.goto(0, 260) # Position it near the top of the screen
score_display.write("Score: 0", align="center", font=("Courier", 24, "normal")) # Display initial score

while True: # This loop will run forever until the program is closed
    wn.update() # Manually update the screen (because we used wn.tracer(0))

    # Move the player
    if player.direction == "up":
        y = player.ycor() # Get current Y coordinate
        player.sety(y + 2) # Move up by 2 pixels
    if player.direction == "down":
        y = player.ycor()
        player.sety(y - 2)
    if player.direction == "left":
        x = player.xcor() # Get current X coordinate
        player.setx(x - 2) # Move left by 2 pixels
    if player.direction == "right":
        x = player.xcor()
        player.setx(x + 2)

    # Wrap around the edges (simple boundary)
    if player.xcor() > 290: # If Pac-Man goes too far right
        player.setx(-290) # Warp to the left side
    if player.xcor() < -290: # If Pac-Man goes too far left
        player.setx(290) # Warp to the right side
    if player.ycor() > 290: # If Pac-Man goes too far up
        player.sety(-290) # Warp to the bottom side
    if player.ycor() < -290: # If Pac-Man goes too far down
        player.sety(290) # Warp to the top side

    # Check for collision with food
    # We iterate backwards through the list to safely remove items
    for i in range(len(foods) - 1, -1, -1):
        food = foods[i]
        if player.distance(food) < 15: # If Pac-Man is close enough to the food (adjust 15 as needed)
            food.hideturtle() # Make the food disappear
            foods.pop(i) # Remove the food from the list
            score += 10 # Increase the score
            score_display.clear() # Clear the old score text
            score_display.write(f"Score: {score}", align="center", font=("Courier", 24, "normal")) # Write the new score

    # Check for game over (all food eaten)
    if not foods: # If the 'foods' list is empty
        score_display.clear()
        score_display.goto(0, 0) # Move score display to center
        score_display.write(f"GAME OVER! Your Score: {score}", align="center", font=("Courier", 30, "bold"))
        player.hideturtle() # Hide Pac-Man
        wn.update() # Update one last time
        break # Exit the game loop

import turtle
import math

wn = turtle.Screen()
wn.setup(width=600, height=600)
wn.bgcolor("black")
wn.title("Simple Pac-Man")
wn.tracer(0) # Turn off screen updates for smoother animation

player = turtle.Turtle()
player.shape("circle")
player.color("yellow")
player.penup()
player.goto(0, 0)
player.direction = "stop" # Initial direction

foods = []
food_positions = [
    (-200, 200), (-150, 200), (-100, 200), (-50, 200), (0, 200), (50, 200), (100, 200), (150, 200), (200, 200),
    (-200, 150), (-100, 150), (0, 150), (100, 150), (200, 150),
    (-200, 100), (-150, 100), (-50, 100), (50, 100), (150, 100), (200, 100),
    (-200, 0), (-100, 0), (100, 0), (200, 0), # (0,0) excluded here to avoid overlap with player start
    (-200, -100), (-150, -100), (-50, -100), (50, -100), (150, -100), (200, -100),
    (-200, -150), (-100, -150), (0, -150), (100, -150), (200, -150),
    (-200, -200), (-150, -200), (-100, -200), (-50, -200), (0, -200), (50, -200), (100, -200), (150, -200), (200, -200)
]

for pos in food_positions:
    food = turtle.Turtle()
    food.shape("circle")
    food.color("white")
    food.shapesize(0.5)
    food.penup()
    food.goto(pos)
    foods.append(food)

def go_up():
    player.direction = "up"
def go_down():
    player.direction = "down"
def go_left():
    player.direction = "left"
def go_right():
    player.direction = "right"

wn.listen()
wn.onkeypress(go_up, "w")
wn.onkeypress(go_down, "s")
wn.onkeypress(go_left, "a")
wn.onkeypress(go_right, "d")
wn.onkeypress(go_up, "Up")
wn.onkeypress(go_down, "Down")
wn.onkeypress(go_left, "Left")
wn.onkeypress(go_right, "Right")

score = 0
score_display = turtle.Turtle()
score_display.speed(0)
score_display.color("white")
score_display.penup()
score_display.hideturtle()
score_display.goto(0, 260)
score_display.write("Score: 0", align="center", font=("Courier", 24, "normal"))

while True:
    wn.update() # Manually update the screen

    # Move the player
    if player.direction == "up":
        y = player.ycor()
        player.sety(y + 2)
    elif player.direction == "down": # Use elif to ensure only one direction is processed
        y = player.ycor()
        player.sety(y - 2)
    elif player.direction == "left":
        x = player.xcor()
        player.setx(x - 2)
    elif player.direction == "right":
        x = player.xcor()
        player.setx(x + 2)

    # Wrap around the edges
    if player.xcor() > 290:
        player.setx(-290)
    elif player.xcor() < -290:
        player.setx(290)
    elif player.ycor() > 290:
        player.sety(-290)
    elif player.ycor() < -290:
        player.sety(290)

    # Check for collision with food
    for i in range(len(foods) - 1, -1, -1): # Loop backwards
        food = foods[i]
        if player.distance(food) < 15: # Collision distance
            food.hideturtle()
            foods.pop(i)
            score += 10
            score_display.clear()
            score_display.write(f"Score: {score}", align="center", font=("Courier", 24, "normal"))

    # Check for game over (all food eaten)
    if not foods:
        score_display.clear()
        score_display.goto(0, 0)
        score_display.write(f"GAME OVER! Your Score: {score}", align="center", font=("Courier", 30, "bold"))
        player.hideturtle()
        wn.update()
        break # Exit the game loop

pip install pygame

import pygame
import sys

pygame.init()

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.display.set_caption("My Simple Platformer")

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

running = True
while running:
    # 1. Event Handling: Check for user input (keyboard, mouse, closing window)
    for event in pygame.event.get():
        if event.type == pygame.QUIT: # If the user clicks the 'X' to close the window
            running = False # Stop the game loop
    # Technical Term: Event Handling - This is how our game listens for and responds to anything that happens, like a key press or mouse click.
    # Technical Term: pygame.QUIT - This is a specific event that occurs when the user tries to close the game window.

    # 2. Update game state (we'll add player movement here later)

    # 3. Drawing: Clear the screen and draw game objects
    SCREEN.fill(BLUE) # Fill the background with blue (our sky)

    # (We'll draw our player and ground here soon!)

    # 4. Update the display to show what we've drawn
    pygame.display.flip()
    # Technical Term: pygame.display.flip() - This updates the entire screen to show everything that has been drawn since the last update.

pygame.quit()
sys.exit()

player_width = 30
player_height = 50
player_x = SCREEN_WIDTH // 2 - player_width // 2 # Start in the middle
player_y = SCREEN_HEIGHT - player_height - 50 # Start a bit above the bottom
player_velocity_x = 0 # Horizontal speed
player_velocity_y = 0 # Vertical speed (for jumping and gravity)
player_speed = 5
jump_power = -15 # Negative because y-axis increases downwards
gravity = 0.8
is_grounded = False # To check if the player is on a surface

player_rect = pygame.Rect(player_x, player_y, player_width, player_height)
pygame.draw.rect(SCREEN, RED, player_rect)

player_velocity_y += gravity
player_y += player_velocity_y

ground_height = 20
ground_x = 0
ground_y = SCREEN_HEIGHT - ground_height
ground_width = SCREEN_WIDTH

ground_rect = pygame.Rect(ground_x, ground_y, ground_width, ground_height)

pygame.draw.rect(SCREEN, GREEN, ground_rect)

if player_rect.colliderect(ground_rect):
    player_y = ground_y - player_height # Place player on top of ground
    player_velocity_y = 0 # Stop vertical movement
    is_grounded = True # Player is now on the ground
else:
    is_grounded = False # Player is in the air

if event.type == pygame.KEYDOWN: # If a key is pressed down
    if event.key == pygame.K_SPACE and is_grounded: # If it's the spacebar and player is on ground
        player_velocity_y = jump_power # Apply upward velocity for jump
        is_grounded = False # Player is no longer grounded

keys = pygame.key.get_pressed()

player_velocity_x = 0 # Reset horizontal velocity each frame
if keys[pygame.K_LEFT]:
    player_velocity_x = -player_speed
if keys[pygame.K_RIGHT]:
    player_velocity_x = player_speed

player_x += player_velocity_x

import pygame
import sys

pygame.init()

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
SCREEN = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.display.set_caption("My Simple Platformer")

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

player_width = 30
player_height = 50
player_x = SCREEN_WIDTH // 2 - player_width // 2 # Start in the middle horizontally
player_y = SCREEN_HEIGHT - player_height - 50    # Start a bit above the bottom
player_velocity_x = 0
player_velocity_y = 0
player_speed = 5
jump_power = -15
gravity = 0.8
is_grounded = False

ground_height = 20
ground_x = 0
ground_y = SCREEN_HEIGHT - ground_height
ground_width = SCREEN_WIDTH
ground_rect = pygame.Rect(ground_x, ground_y, ground_width, ground_height)

running = True
clock = pygame.time.Clock() # For controlling frame rate

while running:
    # 8. 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_SPACE and is_grounded:
                player_velocity_y = jump_power
                is_grounded = False

    # 9. Handle horizontal movement with continuous key presses
    keys = pygame.key.get_pressed()
    player_velocity_x = 0 # Reset horizontal velocity each frame
    if keys[pygame.K_LEFT]:
        player_velocity_x = -player_speed
    if keys[pygame.K_RIGHT]:
        player_velocity_x = player_speed

    # 10. Update player's horizontal position
    player_x += player_velocity_x

    # 11. Apply gravity
    player_velocity_y += gravity
    player_y += player_velocity_y

    # 12. Create player rectangle for collision detection and drawing
    player_rect = pygame.Rect(player_x, player_y, player_width, player_height)

    # 13. Collision detection with ground
    if player_rect.colliderect(ground_rect):
        player_y = ground_y - player_height # Place player on top of ground
        player_velocity_y = 0               # Stop vertical movement
        is_grounded = True                  # Player is now on the ground
    else:
        is_grounded = False                 # Player is in the air

    # 14. Keep player within screen bounds horizontally
    if player_x < 0:
        player_x = 0
    if player_x > SCREEN_WIDTH - player_width:
        player_x = SCREEN_WIDTH - player_width

    # 15. Drawing
    SCREEN.fill(BLUE) # Fill background with blue

    pygame.draw.rect(SCREEN, GREEN, ground_rect) # Draw the ground
    pygame.draw.rect(SCREEN, RED, player_rect)   # Draw the player

    # 16. Update the display
    pygame.display.flip()

    # 17. Cap the frame rate (e.g., to 60 FPS)
    clock.tick(60) # This makes sure our game doesn't run too fast
    # Technical Term: FPS (Frames Per Second) - How many times the game updates and draws everything in one second. 60 FPS is generally a smooth experience.

pygame.quit()
sys.exit()

maze = [
    "#######E#####",
    "#P...........#",
    "#.###########",
    "#.#.........#",
    "#.#.#######.#",
    "#.#.........#",
    "#.###########",
    "#.............#",
    "###############"
]

for i in range(len(maze)):
    maze[i] = list(maze[i])

def display_maze(maze):
    """
    Prints the current state of the maze to the console.
    Each character is joined back into a string for display.
    """
    for row in maze:
        print("".join(row)) # Join the list of characters back into a string for printing
    print("-" * len(maze[0])) # Print a separator line for clarity

player_row = 0
player_col = 0

for r in range(len(maze)):
    for c in range(len(maze[r])):
        if maze[r][c] == 'P':
            player_row = r
            player_col = c
            break # Found the player, no need to search further in this row
    if 'P' in maze[r]: # If 'P' was found in the current row, break outer loop too
        break

def move_player(maze, player_row, player_col, move):
    """
    Calculates the new player position based on the move.
    Checks for walls and boundaries.
    Returns the new row and column, or the old ones if the move is invalid.
    """
    new_row, new_col = player_row, player_col

    # Determine the target coordinates based on the input move
    if move == 'w': # Up
        new_row -= 1
    elif move == 's': # Down
        new_row += 1
    elif move == 'a': # Left
        new_col -= 1
    elif move == 'd': # Right
        new_col += 1
    else:
        print("Invalid move. Use 'w', 'a', 's', 'd'.")
        return player_row, player_col # No valid move, return current position

    # Check if the new position is within the maze boundaries
    # len(maze) gives us the number of rows
    # len(maze[0]) gives us the number of columns (assuming all rows are same length)
    if 0 <= new_row < len(maze) and 0 <= new_col < len(maze[0]):
        # Check if the new position is a wall
        if maze[new_row][new_col] == '#':
            print("Ouch! You hit a wall!")
            return player_row, player_col # Can't move, return current position
        else:
            # Valid move! Update the maze:
            # 1. Clear the old player position (replace 'P' with '.')
            maze[player_row][player_col] = '.'
            # 2. Place 'P' at the new position
            maze[new_row][new_col] = 'P'
            return new_row, new_col # Return the new position
    else:
        print("You can't go off the map!")
        return player_row, player_col # Can't move, return current position

game_over = False

while not game_over:
    display_maze(maze)

    # Get player input
    # input() waits for the user to type something and press Enter
    player_move = input("Enter your move (w/a/s/d): ").lower() # .lower() converts input to lowercase

    # Update player position
    # The move_player function returns the new coordinates
    old_player_row, old_player_col = player_row, player_col
    player_row, player_col = move_player(maze, player_row, player_col, player_move)

    # Check for win condition: Did the player move onto the 'E' cell?
    # Note: We check if the *old* 'P' position was replaced by 'E' after moving
    # This logic is a bit tricky if 'E' is *just* walked onto.
    # A cleaner way is to check the cell *before* moving 'P' to it.
    # Let's adjust move_player slightly or check the target cell directly.

    # Revised win condition check within the loop:
    # We need to know if the *target* cell was 'E' *before* the player moved there.
    # Let's refine the move_player to return a status, or check after the fact.

    # Simpler win condition check: Check if the current player_row/col is where E was.
    # This requires us to know the E's original position. Let's find E's position too.
    exit_row, exit_col = -1, -1
    for r in range(len(maze)):
        for c in range(len(maze[r])):
            if maze[r][c] == 'E': # Find the original 'E'
                exit_row, exit_col = r, c
                # Important: If 'E' is overwritten by 'P', the original 'E' is gone.
                # So we need to check if the new 'P' position *matches* E's initial position.
                break
        if exit_row != -1:
            break

    # If the player is now at the exit's original position (which is now 'P' after the move)
    if player_row == exit_row and player_col == exit_col:
        display_maze(maze) # Show the final maze with 'P' at 'E'
        print("Congratulations! You found the exit!")
        game_over = True

maze_blueprint = [
    "#######E#####",
    "#P...........#",
    "#.###########",
    "#.#.........#",
    "#.#.#######.#",
    "#.#.........#",
    "#.###########",
    "#.............#",
    "###############"
]

maze = []
for row_str in maze_blueprint:
    maze.append(list(row_str))

player_row = 0
player_col = 0
for r in range(len(maze)):
    for c in range(len(maze[r])):
        if maze[r][c] == 'P':
            player_row = r
            player_col = c
            break
    if 'P' in maze_blueprint[r]: # Check blueprint to see if 'P' was found in row
        break

exit_row = 0
exit_col = 0
for r in range(len(maze)):
    for c in range(len(maze[r])):
        if maze[r][c] == 'E':
            exit_row = r
            exit_col = c
            break
    if 'E' in maze_blueprint[r]: # Check blueprint to see if 'E' was found in row
        break

def display_maze(current_maze):
    """
    Prints the current state of the maze to the console.
    """
    for row in current_maze:
        print("".join(row))
    print("-" * len(current_maze[0])) # Separator

def move_player(current_maze, p_row, p_col, move):
    """
    Calculates the new player position based on the move.
    Checks for walls and boundaries.
    Returns the new row and column, or the old ones if the move is invalid.
    """
    new_row, new_col = p_row, p_col

    if move == 'w': # Up
        new_row -= 1
    elif move == 's': # Down
        new_row += 1
    elif move == 'a': # Left
        new_col -= 1
    elif move == 'd': # Right
        new_col += 1
    else:
        print("Invalid move. Use 'w', 'a', 's', 'd'.")
        return p_row, p_col

    # Check boundaries
    if not (0 <= new_row < len(current_maze) and 0 <= new_col < len(current_maze[0])):
        print("You can't go off the map!")
        return p_row, p_col

    # Check for walls
    if current_maze[new_row][new_col] == '#':
        print("Ouch! You hit a wall!")
        return p_row, p_col

    # Valid move: Update maze
    current_maze[p_row][p_col] = '.' # Clear old position
    current_maze[new_row][new_col] = 'P' # Set new position
    return new_row, new_col

game_over = False
print("Welcome to the Maze Game!")
print("Navigate 'P' to 'E' using w (up), a (left), s (down), d (right).")

while not game_over:
    display_maze(maze)

    player_move = input("Enter your move (w/a/s/d): ").lower()

    # Store old position for comparison, then update
    player_row, player_col = move_player(maze, player_row, player_col, player_move)

    # Check for win condition
    if player_row == exit_row and player_col == exit_col:
        display_maze(maze) # Show final state
        print("Congratulations! You found the exit!")
        game_over = True

pip install pygame

import pygame
import random # We'll use this later for random pipe positions

pygame.init()

SCREEN_WIDTH = 400
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.display.set_caption("My Simple Flappy Bird")

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GREEN = (0, 255, 0) # For our pipes
BLUE = (0, 0, 255)  # For our bird
SKY_BLUE = (135, 206, 235) # A nice background color

clock = pygame.time.Clock()
FPS = 60 # Frames Per Second. Our game will try to update 60 times every second.

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Drawing the background
    screen.fill(SKY_BLUE) # Fills the entire screen with sky blue

    # Update the display
    pygame.display.flip() # Shows what we've drawn on the screen

    # Control frame rate
    clock.tick(FPS)

pygame.quit() # Uninitializes Pygame, like turning off the engine. Always do this at the end.

bird_x = 50 # X-coordinate of the bird's top-left corner
bird_y = SCREEN_HEIGHT // 2 # Y-coordinate, starting in the middle vertically
bird_width = 30
bird_height = 30
bird_velocity = 0 # How fast the bird is currently moving up or down
GRAVITY = 0.5 # How much the bird accelerates downwards each frame
JUMP_STRENGTH = -8 # How much the bird jumps upwards when flapped (negative for up)


    # 1. Handle Bird movement
    bird_velocity += GRAVITY # Apply gravity
    bird_y += bird_velocity # Update bird's vertical position

    # Keep bird on screen (simple boundaries)
    if bird_y > SCREEN_HEIGHT - bird_height:
        bird_y = SCREEN_HEIGHT - bird_height
        bird_velocity = 0 # Stop falling if on ground
    if bird_y < 0:
        bird_y = 0
        bird_velocity = 0 # Stop going above the top

    # 2. Draw the bird
    pygame.draw.rect(screen, BLUE, (bird_x, bird_y, bird_width, bird_height))

        if event.type == pygame.KEYDOWN: # Checks if any key was pressed down
            if event.key == pygame.K_SPACE: # Checks if the pressed key was the spacebar
                bird_velocity = JUMP_STRENGTH # Make the bird jump!

pipe_width = 50
pipe_gap = 150 # The vertical space between the top and bottom pipes
pipe_speed = 3 # How fast the pipes move left
pipes = [] # A list to hold all our active pipes

pipe_spawn_timer = 0
PIPE_SPAWN_INTERVAL = 90 # How many frames before a new pipe spawns (roughly 1.5 seconds at 60 FPS)


    # 3. Handle Pipes
    # Generate new pipes
    pipe_spawn_timer += 1
    if pipe_spawn_timer >= PIPE_SPAWN_INTERVAL:
        # Random height for the top pipe
        top_pipe_height = random.randint(50, SCREEN_HEIGHT - pipe_gap - 50)
        # The bottom pipe starts after the gap
        bottom_pipe_height = SCREEN_HEIGHT - top_pipe_height - pipe_gap
        # Add new pipe (x-position, top_height, bottom_height)
        pipes.append([SCREEN_WIDTH, top_pipe_height, bottom_pipe_height])
        pipe_spawn_timer = 0

    # Move pipes and remove if off-screen
    pipes_to_remove = []
    for pipe in pipes:
        pipe[0] -= pipe_speed # Move pipe left

        # Check if pipe is off-screen
        if pipe[0] + pipe_width < 0:
            pipes_to_remove.append(pipe)

        # Draw pipes
        # Top pipe
        pygame.draw.rect(screen, GREEN, (pipe[0], 0, pipe_width, pipe[1]))
        # Bottom pipe
        pygame.draw.rect(screen, GREEN, (pipe[0], pipe[1] + pipe_gap, pipe_width, pipe[2]))

    # Clean up old pipes
    for pipe_to_remove in pipes_to_remove:
        pipes.remove(pipe_to_remove)

    # 4. Collision Detection
    game_over = False

    # Check collision with ground/ceiling (already handled this with bird_y boundaries)
    # Re-check explicitly for game over state
    if bird_y >= SCREEN_HEIGHT - bird_height or bird_y <= 0:
        game_over = True

    # Check collision with pipes
    bird_rect = pygame.Rect(bird_x, bird_y, bird_width, bird_height) # Create a rectangle object for the bird for easier collision checking

    for pipe in pipes:
        top_pipe_rect = pygame.Rect(pipe[0], 0, pipe_width, pipe[1])
        bottom_pipe_rect = pygame.Rect(pipe[0], pipe[1] + pipe_gap, pipe_width, pipe[2])

        # `colliderect` is a Pygame function that checks if two rectangles overlap
        if bird_rect.colliderect(top_pipe_rect) or bird_rect.colliderect(bottom_pipe_rect):
            game_over = True
            break # No need to check other pipes if we've already collided

    # Handle Game Over state
    if game_over:
        # Display "Game Over!" message (basic for now)
        font = pygame.font.Font(None, 74) # None uses default font, 74 is font size
        text = font.render("Game Over!", True, BLACK) # Render text: "text", antialias, color
        text_rect = text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)) # Center the text
        screen.blit(text, text_rect) # Draw the text on the screen

        pygame.display.flip() # Make sure the "Game Over" message is shown
        pygame.time.wait(2000) # Wait for 2 seconds before quitting
        running = False # Exit the game loop

score = 0
font = pygame.font.Font(None, 36) # Smaller font for the score


    # 5. Update Score
    for pipe in pipes:
        # If the pipe has passed the bird's x-position AND the score hasn't been added for this pipe yet
        if pipe[0] + pipe_width < bird_x and len(pipe) == 3: # 'len(pipe) == 3' means it's a new pipe without score info
            score += 1
            pipe.append(True) # Mark this pipe as 'scored' so we don't count it again

    # 6. Display Score
    score_text = font.render(f"Score: {score}", True, BLACK)
    screen.blit(score_text, (10, 10)) # Draw score at top-left corner

import pygame
import random

pygame.init()

SCREEN_WIDTH = 400
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("My Simple Flappy Bird")

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
SKY_BLUE = (135, 206, 235)

clock = pygame.time.Clock()
FPS = 60

bird_x = 50
bird_y = SCREEN_HEIGHT // 2
bird_width = 30
bird_height = 30
bird_velocity = 0
GRAVITY = 0.5
JUMP_STRENGTH = -8

pipe_width = 50
pipe_gap = 150
pipe_speed = 3
pipes = [] # Format: [x, top_height, bottom_height, scored_status]

pipe_spawn_timer = 0
PIPE_SPAWN_INTERVAL = 90

score = 0
font = pygame.font.Font(None, 36)
game_over_font = pygame.font.Font(None, 74)

running = True
game_over = False

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE and not game_over: # Only jump if not game over
                bird_velocity = JUMP_STRENGTH

    if not game_over: # Only update game elements if game is not over
        # 1. Handle Bird movement
        bird_velocity += GRAVITY
        bird_y += bird_velocity

        # Keep bird on screen boundaries
        if bird_y > SCREEN_HEIGHT - bird_height:
            bird_y = SCREEN_HEIGHT - bird_height
            bird_velocity = 0
            game_over = True # Game over if bird hits the ground
        if bird_y < 0:
            bird_y = 0
            bird_velocity = 0
            game_over = True # Game over if bird hits the top

        # 2. Handle Pipes
        pipe_spawn_timer += 1
        if pipe_spawn_timer >= PIPE_SPAWN_INTERVAL:
            top_pipe_height = random.randint(50, SCREEN_HEIGHT - pipe_gap - 50)
            bottom_pipe_height = SCREEN_HEIGHT - top_pipe_height - pipe_gap
            pipes.append([SCREEN_WIDTH, top_pipe_height, bottom_pipe_height, False]) # False means not yet scored
            pipe_spawn_timer = 0

        pipes_to_remove = []
        for pipe in pipes:
            pipe[0] -= pipe_speed

            if pipe[0] + pipe_width < 0:
                pipes_to_remove.append(pipe)

        for pipe_to_remove in pipes_to_remove:
            pipes.remove(pipe_to_remove)

        # 3. Update Score
        for pipe in pipes:
            if pipe[0] + pipe_width < bird_x and not pipe[3]: # Check if passed AND not yet scored
                score += 1
                pipe[3] = True # Mark as scored

        # 4. Collision Detection (Bird with Pipes)
        bird_rect = pygame.Rect(bird_x, bird_y, bird_width, bird_height)

        for pipe in pipes:
            top_pipe_rect = pygame.Rect(pipe[0], 0, pipe_width, pipe[1])
            bottom_pipe_rect = pygame.Rect(pipe[0], pipe[1] + pipe_gap, pipe_width, pipe[2])

            if bird_rect.colliderect(top_pipe_rect) or bird_rect.colliderect(bottom_pipe_rect):
                game_over = True
                break

    # --- Drawing ---
    screen.fill(SKY_BLUE) # Clear screen

    # Draw Pipes
    for pipe in pipes:
        pygame.draw.rect(screen, GREEN, (pipe[0], 0, pipe_width, pipe[1]))
        pygame.draw.rect(screen, GREEN, (pipe[0], pipe[1] + pipe_gap, pipe_width, pipe[2]))

    # Draw Bird
    pygame.draw.rect(screen, BLUE, (bird_x, bird_y, bird_width, bird_height))

    # Display Score
    score_text = font.render(f"Score: {score}", True, BLACK)
    screen.blit(score_text, (10, 10))

    # Display Game Over message if needed
    if game_over:
        game_over_text = game_over_font.render("Game Over!", True, BLACK)
        game_over_text_rect = game_over_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
        screen.blit(game_over_text, game_over_text_rect)

    pygame.display.flip()
    clock.tick(FPS)

if game_over:
    pygame.time.wait(2000) # Give a moment to see the Game Over screen

pygame.quit()

import random

word_list = ["python", "hangman", "programming", "computer", "challenge", "developer", "keyboard", "algorithm", "variable", "function"]

chosen_word = random.choice(word_list)


display = ["_"] * len(chosen_word)

lives = 6

game_over = False

guessed_letters = []

print("Welcome to Hangman!")
print("Try to guess the secret word letter by letter.")
print(f"You have {lives} lives. Good luck!\n") # The '\n' creates a new line for better readability
print(" ".join(display)) # '.join()' combines the items in our 'display' list into a single string with spaces

while not game_over: # This loop continues as long as 'game_over' is False
    guess = input("\nGuess a letter: ").lower() # Get player's guess and convert to lowercase

    # --- Check for repeated guesses ---
    if guess in guessed_letters: # Check if the letter is already in our list of 'guessed_letters'
        print(f"You've already guessed '{guess}'. Try a different letter.")
        continue # 'continue' immediately jumps to the next round of the 'while' loop, skipping the rest of the code below

    # Add the current guess to the list of letters we've already tried
    guessed_letters.append(guess)

    # --- Check if the guessed letter is in the word ---
    found_letter_in_word = False # A flag to know if the guess was correct in this round
    # We loop through each position (index) of the chosen word
    for position in range(len(chosen_word)):
        letter = chosen_word[position] # Get the letter at the current position
        if letter == guess: # If the letter from the word matches the player's guess
            display[position] = guess # Update our 'display' list with the correctly guessed letter
            found_letter_in_word = True # Set our flag to True

    # ... (rest of the logic for lives and winning/losing will go here in Step 3)

    # --- If the letter was NOT found ---
    if not found_letter_in_word: # If our flag is still False, it means the guess was wrong
        lives -= 1 # Decrease a life (same as lives = lives - 1)
        print(f"Sorry, '{guess}' is not in the word.")
        print(f"You lose a life! Lives remaining: {lives}")
    else:
        print(f"Good guess! '{guess}' is in the word.")

    print(" ".join(display)) # Display the current state of the word after updating

    # --- Check for winning condition ---
    if "_" not in display: # If there are no more underscores in the 'display' list
        game_over = True # Set 'game_over' to True to stop the loop
        print("\n🎉 Congratulations! You've guessed the word!")
        print(f"The word was: {chosen_word}")

    # --- Check for losing condition ---
    if lives == 0: # If lives run out
        game_over = True # Set 'game_over' to True to stop the loop
        print("\n💀 Game Over! You ran out of lives.")
        print(f"The secret word was: {chosen_word}")

print("\nThanks for playing!") # This message prints after the 'while' loop ends

import random

word_list = ["python", "hangman", "programming", "computer", "challenge", "developer", "keyboard", "algorithm", "variable", "function", "module", "string", "integer", "boolean"]

chosen_word = random.choice(word_list)


display = ["_"] * len(chosen_word) # Creates a list of underscores, e.g., ['_', '_', '_', '_', '_', '_'] for 'python'
lives = 6 # Number of incorrect guesses allowed
game_over = False # Flag to control the game loop
guessed_letters = [] # To keep track of letters the player has already tried

print("Welcome to Hangman!")
print("Try to guess the secret word letter by letter.")
print(f"You have {lives} lives. Good luck!\n") # The '\n' creates a new line for better readability
print(" ".join(display)) # Show the initial blank word

while not game_over:
    guess = input("\nGuess a letter: ").lower() # Get player's guess and convert to lowercase

    # --- Check for repeated guesses ---
    if guess in guessed_letters:
        print(f"You've already guessed '{guess}'. Try a different letter.")
        continue # Skip the rest of this loop iteration and ask for a new guess

    # Add the current guess to the list of guessed letters
    guessed_letters.append(guess)

    # --- Check if the guessed letter is in the word ---
    found_letter_in_word = False # A flag to know if the guess was correct
    for position in range(len(chosen_word)):
        letter = chosen_word[position]
        if letter == guess:
            display[position] = guess # Update the display with the correctly guessed letter
            found_letter_in_word = True # Mark that the letter was found

    # --- If the letter was NOT found ---
    if not found_letter_in_word:
        lives -= 1 # Decrease a life
        print(f"Sorry, '{guess}' is not in the word.")
        print(f"You lose a life! Lives remaining: {lives}")
    else:
        print(f"Good guess! '{guess}' is in the word.")


    print(" ".join(display)) # Display the current state of the word

    # --- Check for winning condition ---
    if "_" not in display: # If there are no more underscores, the word has been guessed
        game_over = True
        print("\n🎉 Congratulations! You've guessed the word!")
        print(f"The word was: {chosen_word}")

    # --- Check for losing condition ---
    if lives == 0: # If lives run out
        game_over = True
        print("\n💀 Game Over! You ran out of lives.")
        print(f"The secret word was: {chosen_word}")

print("\nThanks for playing!")

import turtle
import time
import random

wn = turtle.Screen() # This creates our game window
wn.setup(width=600, height=600) # Sets the size of the window to 600x600 pixels
wn.bgcolor("black") # Sets the background color of the window to black
wn.title("Simple Snake Game by YourName") # Gives our window a title
wn.tracer(0) # Turns off screen updates. We will manually update the screen later.
             # Supplementary Explanation: wn.tracer(0) makes the animation smoother.
             # Without it, you'd see the snake drawing itself pixel by pixel, which looks choppy.
             # wn.update() will be used to show everything we've drawn at once.

head = turtle.Turtle() # Creates a new turtle object for the snake's head
head.speed(0) # Sets the animation speed to the fastest possible (0 means no animation delay)
head.shape("square") # Makes the turtle look like a square
head.color("green") # Sets the color of the square to green
head.penup() # Lifts the pen, so it doesn't draw lines when moving
             # Supplementary Explanation: penup() and pendown() are like lifting and putting down a pen.
             # When the pen is up, the turtle moves without drawing.
head.goto(0, 0) # Puts the snake head in the center of the screen (x=0, y=0)
head.direction = "stop" # A variable to store the snake's current direction

food = turtle.Turtle()
food.speed(0)
food.shape("circle") # The food will be a circle
food.color("red") # Red color for food
food.penup()
food.goto(0, 100) # Place the food at an initial position

score = 0
high_score = 0

pen = turtle.Turtle()
pen.speed(0)
pen.shape("square") # Shape doesn't matter much as it won't be visible
pen.color("white") # Text color
pen.penup()
pen.hideturtle() # Hides the turtle icon itself
pen.goto(0, 260) # Position for the score text (top of the screen)
pen.write(f"Score: {score} High Score: {high_score}", align="center", font=("Courier", 24, "normal"))
             # Supplementary Explanation: pen.write() displays text on the screen.
             # 'align' centers the text, and 'font' sets the style, size, and weight.

def go_up():
    if head.direction != "down": # Prevent the snake from reversing into itself
        head.direction = "up"

def go_down():
    if head.direction != "up":
        head.direction = "down"

def go_left():
    if head.direction != "right":
        head.direction = "left"

def go_right():
    if head.direction != "left":
        head.direction = "right"

def move():
    if head.direction == "up":
        y = head.ycor() # Get current y-coordinate
        head.sety(y + 20) # Move 20 pixels up

    if head.direction == "down":
        y = head.ycor()
        head.sety(y - 20) # Move 20 pixels down

    if head.direction == "left":
        x = head.xcor() # Get current x-coordinate
        head.setx(x - 20) # Move 20 pixels left

    if head.direction == "right":
        x = head.xcor()
        head.setx(x + 20) # Move 20 pixels right

wn.listen() # Tells the window to listen for keyboard input
wn.onkeypress(go_up, "w") # When 'w' is pressed, call go_up()
wn.onkeypress(go_down, "s") # When 's' is pressed, call go_down()
wn.onkeypress(go_left, "a") # When 'a' is pressed, call go_left()
wn.onkeypress(go_right, "d") # When 'd' is pressed, call go_right()

segments = [] # An empty list to hold all the body segments of the snake

while True:
    wn.update() # Manually updates the screen. Shows all changes made since wn.tracer(0).

    # Check for collision with border
    if head.xcor() > 290 or head.xcor() < -290 or head.ycor() > 290 or head.ycor() < -290:
        time.sleep(1) # Pause for a second
        head.goto(0, 0) # Reset snake head to center
        head.direction = "stop"

        # Hide the segments
        for segment in segments:
            segment.goto(1000, 1000) # Move segments off-screen

        # Clear the segments list
        segments.clear() # Supplementary Explanation: segments.clear() removes all items from the list.

        # Reset the score
        score = 0
        pen.clear() # Clears the previous score text
        pen.write(f"Score: {score} High Score: {high_score}", align="center", font=("Courier", 24, "normal"))

    # Check for collision with food
    if head.distance(food) < 20: # Supplementary Explanation: .distance() calculates the distance between two turtles.
                                 # Our turtles are 20x20 pixels, so < 20 means they are overlapping.
        # Move the food to a random spot
        x = random.randint(-280, 280) # Random x-coordinate
        y = random.randint(-280, 280) # Random y-coordinate
        food.goto(x, y)

        # Add a new segment to the snake
        new_segment = turtle.Turtle()
        new_segment.speed(0)
        new_segment.shape("square")
        new_segment.color("grey") # Body segments are grey
        new_segment.penup()
        segments.append(new_segment) # Add the new segment to our list

        # Increase the score
        score += 10 # Add 10 points
        if score > high_score:
            high_score = score

        pen.clear() # Clear old score
        pen.write(f"Score: {score} High Score: {high_score}", align="center", font=("Courier", 24, "normal"))

    # Move the end segments first in reverse order
    # This logic makes the segments follow the head properly
    for index in range(len(segments) - 1, 0, -1):
        x = segments[index - 1].xcor()
        y = segments[index - 1].ycor()
        segments[index].goto(x, y)

    # Move segment 0 to where the head is
    if len(segments) > 0:
        x = head.xcor()
        y = head.ycor()
        segments[0].goto(x, y)

    move() # Call the move function to move the head

    # Check for head collision with the body segments
    for segment in segments:
        if segment.distance(head) < 20: # If head touches any body segment
            time.sleep(1)
            head.goto(0, 0)
            head.direction = "stop"

            # Hide the segments
            for seg in segments:
                seg.goto(1000, 1000)

            segments.clear()

            # Reset the score
            score = 0
            pen.clear()
            pen.write(f"Score: {score} High Score: {high_score}", align="center", font=("Courier", 24, "normal"))

    time.sleep(0.1) # Pause for a short time to control game speed
                    # Supplementary Explanation: time.sleep(0.1) makes the game run at a reasonable speed.
                    # A smaller number would make it faster, a larger number slower.

python snake_game.py