Tag: Games

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

python connect4.py

import numpy as np # We'll use numpy later for easy board manipulation

ROW_COUNT = 6
COLUMN_COUNT = 7

def create_board():
    # np.zeros creates an array (similar to a list) filled with zeros
    # (ROW_COUNT, COLUMN_COUNT) specifies the size
    board = np.zeros((ROW_COUNT, COLUMN_COUNT))
    return board

board = create_board()

def print_board(board):
    # np.flipud flips the board "up-down"
    # This makes row 0 appear at the bottom, which is more intuitive for Connect Four
    print(np.flipud(board)) 

def is_valid_location(board, col):
    # The top row (ROW_COUNT - 1) in that column must be empty (0)
    return board[ROW_COUNT - 1][col] == 0

def get_next_open_row(board, col):
    for r in range(ROW_COUNT):
        if board[r][col] == 0: # If the spot is empty (0)
            return r # Return the row number

def drop_piece(board, row, col, piece):
    board[row][col] = piece # Assign the player's piece number to that spot

def winning_move(board, piece):
    # 1. Check horizontal locations for win
    # We iterate through each row
    for c in range(COLUMN_COUNT - 3): # -3 because we need 4 spots, so we stop 3 spots from the end
        for r in range(ROW_COUNT):
            if board[r][c] == piece and board[r][c+1] == piece and board[r][c+2] == piece and board[r][c+3] == piece:
                return True

    # 2. Check vertical locations for win
    # We iterate through each column
    for c in range(COLUMN_COUNT):
        for r in range(ROW_COUNT - 3): # -3 because we need 4 spots, so we stop 3 spots from the end
            if board[r][c] == piece and board[r+1][c] == piece and board[r+2][c] == piece and board[r+3][c] == piece:
                return True

    # 3. Check positively sloped diagonals (\)
    # Start from bottom-left
    for c in range(COLUMN_COUNT - 3):
        for r in range(ROW_COUNT - 3):
            if board[r][c] == piece and board[r+1][c+1] == piece and board[r+2][c+2] == piece and board[r+3][c+3] == piece:
                return True

    # 4. Check negatively sloped diagonals (/)
    # Start from top-left, moving down and right
    for c in range(COLUMN_COUNT - 3):
        for r in range(3, ROW_COUNT): # Start checking from row 3 (index 3) up to the top
            if board[r][c] == piece and board[r-1][c+1] == piece and board[r-2][c+2] == piece and board[r-3][c+3] == piece:
                return True

    return False # If no winning pattern is found, return False

game_over = False
turn = 0 # Player 0 (or 1 in game, but usually 0 and 1 in code) starts first

print_board(board)

while not game_over:
    # Player 1 turn
    if turn == 0:
        try:
            # Get column input from Player 1
            # input() function gets text input from the user
            # int() converts that text into a whole number
            col = int(input("Player 1 Make your Selection (0-6):"))
        except ValueError: # Handle cases where user doesn't enter a number
            print("Invalid input. Please enter a number between 0 and 6.")
            continue # Skip to the next iteration of the loop

        # Check if the chosen column is valid
        if 0 <= col <= COLUMN_COUNT - 1 and is_valid_location(board, col):
            row = get_next_open_row(board, col)
            drop_piece(board, row, col, 1) # Player 1 uses piece '1'

            if winning_move(board, 1):
                print("PLAYER 1 WINS!!! Congratulations!")
                game_over = True
        else:
            print("Column is full or out of bounds. Try again!")
            continue # Skip player turn, allow them to re-enter input

    # Player 2 turn
    else: # turn == 1
        try:
            col = int(input("Player 2 Make your Selection (0-6):"))
        except ValueError:
            print("Invalid input. Please enter a number between 0 and 6.")
            continue

        if 0 <= col <= COLUMN_COUNT - 1 and is_valid_location(board, col):
            row = get_next_open_row(board, col)
            drop_piece(board, row, col, 2) # Player 2 uses piece '2'

            if winning_move(board, 2):
                print("PLAYER 2 WINS!!! Congratulations!")
                game_over = True
        else:
            print("Column is full or out of bounds. Try again!")
            continue # Skip player turn, allow them to re-enter input

    print_board(board) # Print the board after each move

    # Check for a draw (board is full)
    # np.all(board[ROW_COUNT-1] != 0) checks if all spots in the top row are taken
    if not game_over and np.all(board[ROW_COUNT-1] != 0):
        print("It's a DRAW! The board is full.")
        game_over = True

    turn += 1 # Increment turn
    turn = turn % 2 # This makes turn alternate between 0 and 1 (0 -> 1 -> 0 -> 1...)

import turtle # Import the turtle module

screen = turtle.Screen() # Create a screen object, which is our game window
screen.title("My Pong Game") # Give the window a title
screen.bgcolor("black") # Set the background color to black
screen.setup(width=800, height=600) # Set the dimensions of the window
screen.tracer(0) # Turns off screen updates. This makes animations smoother.
                 # We'll manually update the screen later.

paddle_a = turtle.Turtle() # Create a turtle object
paddle_a.speed(0) # Set animation speed to fastest
paddle_a.shape("square") # Set shape to square
paddle_a.color("white") # Set color to white
paddle_a.shapesize(stretch_wid=5, stretch_len=1) # Stretch the square to be a rectangle
                                                 # 5 times wider vertically, 1 time wider horizontally (default)
paddle_a.penup() # Lift the pen so it doesn't draw lines
paddle_a.goto(-350, 0) # Position the paddle on the left side

paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5, stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0) # Position the paddle on the right side

ball = turtle.Turtle()
ball.speed(0)
ball.shape("circle") # Ball will be a circle
ball.color("white")
ball.penup()
ball.goto(0, 0) # Start the ball in the center
ball.dx = 2 # delta x: How much the ball moves in the x-direction each frame
ball.dy = 2 # delta y: How much the ball moves in the y-direction each frame
            # These values determine the ball's speed and direction

def paddle_a_up():
    y = paddle_a.ycor() # Get the current y-coordinate of paddle A
    y += 20 # Add 20 pixels to the y-coordinate
    paddle_a.sety(y) # Set the new y-coordinate for paddle A

def paddle_a_down():
    y = paddle_a.ycor()
    y -= 20 # Subtract 20 pixels from the y-coordinate
    paddle_a.sety(y)

def paddle_b_up():
    y = paddle_b.ycor()
    y += 20
    paddle_b.sety(y)

def paddle_b_down():
    y = paddle_b.ycor()
    y -= 20
    paddle_b.sety(y)

screen.listen() # Tell the screen to listen for keyboard input
screen.onkeypress(paddle_a_up, "w") # When 'w' is pressed, call paddle_a_up
screen.onkeypress(paddle_a_down, "s") # When 's' is pressed, call paddle_a_down
screen.onkeypress(paddle_b_up, "Up") # When 'Up arrow' is pressed, call paddle_b_up
screen.onkeypress(paddle_b_down, "Down") # When 'Down arrow' is pressed, call paddle_b_down

score_a = 0
score_b = 0

pen = turtle.Turtle() # Create a new turtle for writing the score
pen.speed(0)
pen.color("white")
pen.penup()
pen.hideturtle() # Hide the turtle icon itself
pen.goto(0, 260) # Position the scoreboard at the top of the screen
pen.write("Player A: 0  Player B: 0", align="center", font=("Courier", 24, "normal"))

while True:
    screen.update() # Manually update the screen to show all changes

    # Move the ball
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)

    # Border checking
    # Top and bottom borders
    if ball.ycor() > 290: # If ball hits the top border (screen height is 600, so top is +300)
        ball.sety(290) # Snap it back to the border
        ball.dy *= -1 # Reverse the y-direction (bounce down)

    if ball.ycor() < -290: # If ball hits the bottom border
        ball.sety(-290)
        ball.dy *= -1 # Reverse the y-direction (bounce up)

    # Left and right borders (scoring)
    if ball.xcor() > 390: # If ball goes past the right border (screen width is 800, so right is +400)
        ball.goto(0, 0) # Reset ball to center
        ball.dx *= -1 # Reverse x-direction to serve the other way
        score_a += 1 # Player A scores
        pen.clear() # Clear previous score
        pen.write(f"Player A: {score_a}  Player B: {score_b}", align="center", font=("Courier", 24, "normal"))


    if ball.xcor() < -390: # If ball goes past the left border
        ball.goto(0, 0) # Reset ball to center
        ball.dx *= -1 # Reverse x-direction
        score_b += 1 # Player B scores
        pen.clear() # Clear previous score
        pen.write(f"Player A: {score_a}  Player B: {score_b}", align="center", font=("Courier", 24, "normal"))

    # Paddle and ball collisions
    # Paddle B collision
    if (ball.xcor() > 340 and ball.xcor() < 350) and \
       (ball.ycor() < paddle_b.ycor() + 50 and ball.ycor() > paddle_b.ycor() - 50):
        ball.setx(340) # Snap ball back to avoid getting stuck
        ball.dx *= -1 # Reverse x-direction

    # Paddle A collision
    if (ball.xcor() < -340 and ball.xcor() > -350) and \
       (ball.ycor() < paddle_a.ycor() + 50 and ball.ycor() > paddle_a.ycor() - 50):
        ball.setx(-340) # Snap ball back
        ball.dx *= -1 # Reverse x-direction

import turtle

screen = turtle.Screen()
screen.title("My Pong Game")
screen.bgcolor("black")
screen.setup(width=800, height=600)
screen.tracer(0)

paddle_a = turtle.Turtle()
paddle_a.speed(0)
paddle_a.shape("square")
paddle_a.color("white")
paddle_a.shapesize(stretch_wid=5, stretch_len=1)
paddle_a.penup()
paddle_a.goto(-350, 0)

paddle_b = turtle.Turtle()
paddle_b.speed(0)
paddle_b.shape("square")
paddle_b.color("white")
paddle_b.shapesize(stretch_wid=5, stretch_len=1)
paddle_b.penup()
paddle_b.goto(350, 0)

ball = turtle.Turtle()
ball.speed(0)
ball.shape("circle")
ball.color("white")
ball.penup()
ball.goto(0, 0)
ball.dx = 2
ball.dy = 2

score_a = 0
score_b = 0

pen = turtle.Turtle()
pen.speed(0)
pen.color("white")
pen.penup()
pen.hideturtle()
pen.goto(0, 260)
pen.write(f"Player A: {score_a}  Player B: {score_b}", align="center", font=("Courier", 24, "normal"))

def paddle_a_up():
    y = paddle_a.ycor()
    # Prevent paddle from going off-screen
    if y < 240: # Max Y-coordinate for paddle top (290 - 50 paddle height / 2)
        y += 20
        paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    # Prevent paddle from going off-screen
    if y > -240: # Min Y-coordinate for paddle bottom (-290 + 50 paddle height / 2)
        y -= 20
        paddle_a.sety(y)

def paddle_b_up():
    y = paddle_b.ycor()
    if y < 240:
        y += 20
        paddle_b.sety(y)

def paddle_b_down():
    y = paddle_b.ycor()
    if y > -240:
        y -= 20
        paddle_b.sety(y)

screen.listen()
screen.onkeypress(paddle_a_up, "w")
screen.onkeypress(paddle_a_down, "s")
screen.onkeypress(paddle_b_up, "Up")
screen.onkeypress(paddle_b_down, "Down")

while True:
    screen.update()

    # Move the ball
    ball.setx(ball.xcor() + ball.dx)
    ball.sety(ball.ycor() + ball.dy)

    # Border checking
    # Top and bottom walls
    if ball.ycor() > 290:
        ball.sety(290)
        ball.dy *= -1
    if ball.ycor() < -290:
        ball.sety(-290)
        ball.dy *= -1

    # Right and left walls (scoring)
    if ball.xcor() > 390: # Ball goes off right side
        ball.goto(0, 0)
        ball.dx *= -1
        score_a += 1
        pen.clear()
        pen.write(f"Player A: {score_a}  Player B: {score_b}", align="center", font=("Courier", 24, "normal"))

    if ball.xcor() < -390: # Ball goes off left side
        ball.goto(0, 0)
        ball.dx *= -1
        score_b += 1
        pen.clear()
        pen.write(f"Player A: {score_a}  Player B: {score_b}", align="center", font=("Courier", 24, "normal"))

    # Paddle and ball collisions
    # Paddle B
    # Check if ball is between paddle's x-range AND paddle's y-range
    if (ball.xcor() > 340 and ball.xcor() < 350) and \
       (ball.ycor() < paddle_b.ycor() + 50 and ball.ycor() > paddle_b.ycor() - 50):
        ball.setx(340) # Snap ball to the paddle's edge
        ball.dx *= -1 # Reverse direction

    # Paddle A
    if (ball.xcor() < -340 and ball.xcor() > -350) and \
       (ball.ycor() < paddle_a.ycor() + 50 and ball.ycor() > paddle_a.ycor() - 50):
        ball.setx(-340) # Snap ball to the paddle's edge
        ball.dx *= -1 # Reverse direction

import random # We'll need this later for shuffling!

def create_deck():
    """
    Creates a standard deck of 52 cards, represented by numerical values.
    2-10 are face value, Jack=11, Queen=12, King=13, Ace=14.
    """
    suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades'] # Even though we won't use suits for comparison, it's good to represent a full deck
    ranks = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] # 11=Jack, 12=Queen, 13=King, 14=Ace

    deck = [] # An empty list to hold our cards
    for suit in suits:
        for rank in ranks:
            # For simplicity, we'll just store the rank (numerical value) of the card.
            # In a real game, you might store (rank, suit) tuples.
            deck.append(rank)
    return deck

import random # Make sure this is at the top of your file!


def shuffle_deck(deck):
    """
    Shuffles the given deck of cards in place.
    """
    random.shuffle(deck)
    print("Deck has been shuffled!")
    # We don't need to return the deck because random.shuffle modifies the list directly (in place).

import random


def deal_card(deck):
    """
    Deals one card from the top of the deck.
    """
    if not deck: # Check if the deck is empty
        print("No more cards in the deck!")
        return None # Return None if the deck is empty
    card = deck.pop(0) # Remove and return the first card (top of the deck)
    return card

import random


def get_card_name(card_value):
    """
    Converts a numerical card value to its common name (e.g., 14 -> Ace).
    """
    if card_value == 11:
        return "Jack"
    elif card_value == 12:
        return "Queen"
    elif card_value == 13:
        return "King"
    elif card_value == 14:
        return "Ace"
    else:
        return str(card_value) # For numbers 2-10, just return the number as a string


def play_high_card():
    """
    Plays a single round of the High Card game.
    """
    print("Welcome to High Card Showdown!")
    print("------------------------------")

    deck = create_deck()
    shuffle_deck(deck)

    print("\nDealing cards...")
    player_card = deal_card(deck)
    computer_card = deal_card(deck)

    if player_card is None or computer_card is None:
        print("Not enough cards to play!")
        return

    player_card_name = get_card_name(player_card)
    computer_card_name = get_card_name(computer_card)

    print(f"You drew a: {player_card_name}")
    print(f"The computer drew a: {computer_card_name}")

    print("\n--- Determining the winner ---")
    if player_card > computer_card:
        print("Congratulations! You win this round!")
    elif computer_card > player_card:
        print("Bummer! The computer wins this round.")
    else:
        print("It's a tie! Nobody wins this round.")

    print("\nThanks for playing!")

import random

def create_deck():
    """
    Creates a standard deck of 52 cards, represented by numerical values.
    2-10 are face value, Jack=11, Queen=12, King=13, Ace=14.
    """
    # We still use suits and ranks for clarity in creating a full deck,
    # but for this game, only the numerical rank matters.
    suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
    ranks = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] # 11=Jack, 12=Queen, 13=King, 14=Ace

    deck = []
    for suit in suits:
        for rank in ranks:
            deck.append(rank)
    return deck

def shuffle_deck(deck):
    """
    Shuffles the given deck of cards in place.
    """
    random.shuffle(deck)
    print("Deck has been shuffled!")

def deal_card(deck):
    """
    Deals one card from the top of the deck (removes and returns the first card).
    """
    if not deck:
        # If the deck is empty, we can't deal a card.
        # This is a good safety check for more complex games.
        print("No more cards in the deck!")
        return None
    card = deck.pop(0) # pop(0) removes and returns the first item
    return card

def get_card_name(card_value):
    """
    Converts a numerical card value to its common name (e.g., 14 -> Ace).
    """
    if card_value == 11:
        return "Jack"
    elif card_value == 12:
        return "Queen"
    elif card_value == 13:
        return "King"
    elif card_value == 14:
        return "Ace"
    else:
        return str(card_value) # For numbers 2-10, just return the number as a string

def play_high_card():
    """
    Plays a single round of the High Card game between a player and a computer.
    """
    print("--- Welcome to High Card Showdown! ---")
    print("Let's see who gets the highest card!")

    # 1. Create and shuffle the deck
    deck = create_deck()
    shuffle_deck(deck)

    print("\n--- Dealing cards... ---")

    # 2. Deal one card to the player and one to the computer
    player_card = deal_card(deck)
    computer_card = deal_card(deck)

    # Basic error handling in case the deck somehow runs out (unlikely in a 1-round game)
    if player_card is None or computer_card is None:
        print("Error: Could not deal cards. Game over.")
        return

    # 3. Get user-friendly names for the cards
    player_card_name = get_card_name(player_card)
    computer_card_name = get_card_name(computer_card)

    print(f"You drew a: {player_card_name}")
    print(f"The computer drew a: {computer_card_name}")

    print("\n--- And the winner is... ---")

    # 4. Compare cards and determine the winner
    if player_card > computer_card:
        print("🎉 Congratulations! You win this round!")
    elif computer_card > player_card:
        print("😔 Bummer! The computer wins this round.")
    else:
        print("🤝 It's a tie! No winner this round.")

    print("\n--- Thanks for playing High Card Showdown! ---")

if __name__ == "__main__":
    play_high_card()