Category: Fun & Experiments

pip install pygame

import pygame
import random # We'll need this for the food placement later

pygame.init() 

screen_width = 600
screen_height = 400
screen = pygame.display.set_mode((screen_width, screen_height))

pygame.display.set_caption("My Simple Snake Game!")

WHITE = (255, 255, 255) # Max red, green, blue = white
BLACK = (0, 0, 0)       # No red, green, blue = black
GREEN = (0, 255, 0)     # Max green
RED = (255, 0, 0)       # Max red

clock = pygame.time.Clock()

snake_block = 10 # Size of one snake segment (10 pixels by 10 pixels)
snake_speed = 15 # How fast the snake moves (frames per second)

x1 = screen_width / 2 # Starting x-coordinate, in the middle of the screen
y1 = screen_height / 2 # Starting y-coordinate, in the middle of the screen

snake_list = [] # This list will store the (x, y) coordinates of each segment of our snake
length_of_snake = 1 # The initial length of the snake

x1_change = 0
y1_change = 0

food_x = round(random.randrange(0, screen_width - snake_block) / 10.0) * 10.0
food_y = round(random.randrange(0, screen_height - snake_block) / 10.0) * 10.0

game_over = False # Becomes True when the player decides to quit the entire application
game_close = False # Becomes True when the snake crashes, prompting a "Game Over" screen

score = 0 # Player's score

def draw_snake(snake_block, snake_list):
    for x in snake_list:
        pygame.draw.rect(screen, GREEN, [x[0], x[1], snake_block, snake_block])
        # pygame.draw.rect(): Draws a rectangle on the screen.
        # Arguments: (surface, color, [x_pos, y_pos, width, height])

def display_score(score):
    font = pygame.font.SysFont("comicsansms", 25) # Choose a font (comicsansms) and size (25)
    value = font.render("Your Score: " + str(score), True, WHITE)
    # font.render(): Creates a new Surface (an image) with the rendered text.
    # Arguments: (text, antialias, color). Antialias makes the text smoother.
    screen.blit(value, [0, 0]) # Draw the text on the screen at position (0,0) (top-left corner)
    # screen.blit(): Draws one image (our text surface) onto another (our game screen).

def message(msg, color):
    font = pygame.font.SysFont("comicsansms", 50) # Larger font for the main message
    mesg = font.render(msg, True, color)
    # Calculate position to center the message on the screen
    mesg_rect = mesg.get_rect(center=(screen_width / 2, screen_height / 2))
    screen.blit(mesg, mesg_rect)

while not game_over:

    # Loop for the "Game Over" screen
    while game_close:
        screen.fill(BLACK) # Clear the screen with black
        message("You Lost! Press Q-Quit or C-Play Again", RED)
        display_score(score) # Show final score
        pygame.display.update() # Update the display to show the game over message

        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_q: # If 'Q' is pressed
                    game_over = True # End the main game loop
                    game_close = False # Exit the game over loop
                if event.key == pygame.K_c: # If 'C' is pressed
                    # Reset game variables to play again
                    x1 = screen_width / 2
                    y1 = screen_height / 2
                    x1_change = 0
                    y1_change = 0
                    snake_list = []
                    length_of_snake = 1
                    food_x = round(random.randrange(0, screen_width - snake_block) / 10.0) * 10.0
                    food_y = round(random.randrange(0, screen_height - snake_block) / 10.0) * 10.0
                    score = 0
                    game_close = False # Exit the game over loop and start new game
            if event.type == pygame.QUIT: # If the user clicks the window close button
                game_over = True
                game_close = False

    # Loop for active gameplay
    for event in pygame.event.get():
        if event.type == pygame.QUIT: # If user closes the window
            game_over = True
        if event.type == pygame.KEYDOWN:
            # pygame.KEYDOWN: An event type that occurs when a key is pressed down.
            # event.key: A constant representing which key was pressed (e.g., pygame.K_LEFT for the left arrow key).
            if event.key == pygame.K_LEFT:
                x1_change = -snake_block # Move left by one snake block
                y1_change = 0 # No vertical movement
            elif event.key == pygame.K_RIGHT:
                x1_change = snake_block # Move right
                y1_change = 0
            elif event.key == pygame.K_UP:
                y1_change = -snake_block # Move up
                x1_change = 0
            elif event.key == pygame.K_DOWN:
                y1_change = snake_block # Move down
                x1_change = 0

    # Collision with boundaries (game over if snake hits the wall)
    if x1 >= screen_width or x1 < 0 or y1 >= screen_height or y1 < 0:
        game_close = True

    # Update snake's position based on its current direction
    x1 += x1_change
    y1 += y1_change

    # Clear the screen for the new frame
    screen.fill(BLACK)

    # Draw the food
    pygame.draw.rect(screen, RED, [food_x, food_y, snake_block, snake_block])

    # Add the current head position to the snake's body list
    snake_head = []
    snake_head.append(x1)
    snake_head.append(y1)
    snake_list.append(snake_head)

    # Remove the oldest segment if the snake is longer than its current length
    if len(snake_list) > length_of_snake:
        del snake_list[0]

    # Collision with self (game over if snake hits its own body)
    for x in snake_list[:-1]: # Check all segments except the current head
        if x == snake_head:
            game_close = True

    # Draw the entire snake and the score
    draw_snake(snake_block, snake_list)
    display_score(score)

    # Update the full display surface to the screen to show all changes
    pygame.display.update()
    # pygame.display.update(): This updates the entire screen to show what we've drawn since the last update.
    # Without this, you wouldn't see anything!

    # Check if the snake has eaten the food
    if x1 == food_x and y1 == food_y:
        # Generate new food position
        food_x = round(random.randrange(0, screen_width - snake_block) / 10.0) * 10.0
        food_y = round(random.randrange(0, screen_height - snake_block) / 10.0) * 10.0
        length_of_snake += 1 # Make the snake grow
        score += 10 # Increase score

    # Control game speed
    clock.tick(snake_speed)
    # clock.tick(): This pauses the game for a short time to ensure it doesn't run faster than our desired `snake_speed` frames per second.

pygame.quit()
quit() # Exit the Python script

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

def create_deck():
    """
    Creates a standard deck of 52 cards, represented by numbers.
    Ace = 1, Jack = 11, Queen = 12, King = 13.
    """
    deck = [] # This is our empty list that will become the deck.
    card_values = list(range(1, 14)) # Creates a list: [1, 2, ..., 13]

    for _ in range(4): # We do this 4 times for the 4 suits.
        deck.extend(card_values) # Adds all card_values to the deck.
                                # extend adds all items from one list to another.
    return deck # The function gives us back the completed deck.

def shuffle_deck(deck):
    """
    Shuffles the given deck of cards randomly.
    """
    random.shuffle(deck) # This function from the 'random' module shuffles the list in place.
    print("Deck has been shuffled!")

def deal_card(deck):
    """
    Deals one card from the top of the deck.
    """
    if not deck: # Checks if the deck is empty. 'not deck' is true if the list is empty.
        print("No cards left in the deck!")
        return None # Return nothing if the deck is empty.
    return deck.pop() # 'pop()' removes and returns the last item from a list.
                      # We'll treat the "last" item as the "top" of the deck after shuffling.

def play_round(deck):
    """
    Plays a single round of the 'Higher Card Wins' game.
    """
    print("\n--- New Round! ---")

    # Deal cards to Player 1 and Player 2
    player1_card = deal_card(deck)
    player2_card = deal_card(deck)

    if player1_card is None or player2_card is None: # Check if cards were actually dealt
        print("Cannot play round, not enough cards!")
        return # Stop the function if no cards.

    # Display what cards were drawn
    # We can make cards like 11, 12, 13 look like Jack, Queen, King for fun!
    card_names = {1: "Ace", 11: "Jack", 12: "Queen", 13: "King"}
    p1_display_card = card_names.get(player1_card, str(player1_card))
    p2_display_card = card_names.get(player2_card, str(player2_card))

    print(f"Player 1 draws: {p1_display_card}")
    print(f"Player 2 draws: {p2_display_card}")

    # Determine the winner
    if player1_card > player2_card:
        print("Player 1 wins the round!")
    elif player2_card > player1_card:
        print("Player 2 wins the round!")
    else:
        print("It's a tie!") # In a real game, this might lead to 'War'!

print("Welcome to Higher Card Wins!")

my_deck = create_deck()

shuffle_deck(my_deck)

play_round(my_deck)

print("\nThanks for playing!")

import turtle

wn = turtle.Screen()
wn.title("Simple Pong by YourName") # Set the title of the window
wn.bgcolor("black") # Set the background color to black
wn.setup(width=800, height=600) # Set the dimensions of the window (800 pixels wide, 600 pixels high)
wn.tracer(0) # Turns off screen updates automatically, allowing us to update manually for smoother animation

paddle_a = turtle.Turtle() # Create a turtle object for Paddle A
paddle_a.speed(0) # Set the animation speed to the fastest possible (0 means no animation delay)
paddle_a.shape("square") # Give it a square shape
paddle_a.color("white") # Make it white
paddle_a.shapesize(stretch_wid=5, stretch_len=1) # Stretch the square to be a rectangle (5 times wider than default, 1 time longer)
paddle_a.penup() # Lift the pen so it doesn't draw lines when moving
paddle_a.goto(-350, 0) # Position Paddle A on the left side (x=-350, y=0)

paddle_b = turtle.Turtle() # Create a turtle object for Paddle B
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 Paddle B on the right side (x=350, y=0)

ball = turtle.Turtle()
ball.speed(0)
ball.shape("circle") # A circular shape
ball.color("white")
ball.penup()
ball.goto(0, 0) # Start the ball in the center of the screen

ball.dx = 2 # Change in X-coordinate (how many pixels the ball moves horizontally per update)
ball.dy = 2 # Change in Y-coordinate (how many pixels the ball moves vertically per update)

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

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)

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

while True:
    wn.update() # Manually update the screen (because we set wn.tracer(0))

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

    # Border checking (top and bottom)
    if ball.ycor() > 290: # If ball hits the top border (screen height is 600, so half is 300, allowing for ball size)
        ball.sety(290)
        ball.dy *= -1 # Reverse the vertical direction

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

    # Border checking (left and right)
    if ball.xcor() > 390: # If ball goes off the right side
        ball.goto(0, 0) # Reset ball to center
        ball.dx *= -1 # Reverse direction
        # Here we'd add score for player A

    if ball.xcor() < -390: # If ball goes off the left side
        ball.goto(0, 0) # Reset ball to center
        ball.dx *= -1 # Reverse direction
        # Here we'd add score for player B

    # Paddle and ball collisions
    # Collision with Paddle B
    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)
        ball.dx *= -1 # Reverse horizontal direction

    # Collision with 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)
        ball.dx *= -1 # Reverse horizontal direction

score_a = 0
score_b = 0

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

    # Border checking (left and right)
    if ball.xcor() > 390:
        ball.goto(0, 0)
        ball.dx *= -1
        score_a += 1 # Player A scores!
        pen.clear() # Clear the previous score
        pen.write("Player A: {}  Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

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

import turtle

wn = turtle.Screen()
wn.title("Simple Pong by YourName")
wn.bgcolor("black")
wn.setup(width=800, height=600)
wn.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("Player A: 0  Player B: 0", align="center", font=("Courier", 24, "normal"))

def paddle_a_up():
    y = paddle_a.ycor()
    y += 20
    if y < 250: # Prevent paddle from going off-screen (top)
        paddle_a.sety(y)

def paddle_a_down():
    y = paddle_a.ycor()
    y -= 20
    if y > -250: # Prevent paddle from going off-screen (bottom)
        paddle_a.sety(y)

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

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

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

while True:
    wn.update()

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

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

    if ball.ycor() < -290:
        ball.sety(-290)
        ball.dy *= -1

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

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

    # Paddle and ball collisions
    # Collision with Paddle B
    # Check if ball is horizontally near paddle B AND vertically aligned with it
    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) # Push ball back slightly to prevent it from getting stuck
        ball.dx *= -1 # Reverse direction

    # Collision with Paddle A
    # Check if ball is horizontally near paddle A AND vertically aligned with it
    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) # Push ball back slightly
        ball.dx *= -1 # Reverse direction

pip install pygame

import pygame
import sys

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

WIDTH, HEIGHT = 600, 600
LINE_WIDTH = 10
BOARD_ROWS, BOARD_COLS = 3, 3
SQUARE_SIZE = WIDTH // BOARD_COLS # Each square will be 200x200 pixels
CIRCLE_RADIUS = SQUARE_SIZE // 3
CIRCLE_WIDTH = 15
CROSS_WIDTH = 25
SPACE = SQUARE_SIZE // 4 # Space for X and O not to touch edges

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Tic-Tac-Toe!")
screen.fill(WHITE)

board = [[0, 0, 0],
         [0, 0, 0],
         [0, 0, 0]]
player = 1 # Player 1 is 'X', Player 2 is 'O'
game_over = False
winner = None

def draw_board():
    # Horizontal lines
    pygame.draw.line(screen, BLACK, (0, SQUARE_SIZE), (WIDTH, SQUARE_SIZE), LINE_WIDTH)
    pygame.draw.line(screen, BLACK, (0, 2 * SQUARE_SIZE), (WIDTH, 2 * SQUARE_SIZE), LINE_WIDTH)
    # Vertical lines
    pygame.draw.line(screen, BLACK, (SQUARE_SIZE, 0), (SQUARE_SIZE, HEIGHT), LINE_WIDTH)
    pygame.draw.line(screen, BLACK, (2 * SQUARE_SIZE, 0), (2 * SQUARE_SIZE, HEIGHT), LINE_WIDTH)

def draw_figures():
    for row in range(BOARD_ROWS):
        for col in range(BOARD_COLS):
            if board[row][col] == 1: # Player 1 (X)
                # Draw an 'X'
                pygame.draw.line(screen, BLUE, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SPACE),
                                (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH)
                pygame.draw.line(screen, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SPACE),
                                (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH)
            elif board[row][col] == 2: # Player 2 (O)
                # Draw an 'O'
                pygame.draw.circle(screen, RED, (int(col * SQUARE_SIZE + SQUARE_SIZE // 2),
                                                int(row * SQUARE_SIZE + SQUARE_SIZE // 2)), CIRCLE_RADIUS, CIRCLE_WIDTH)

def check_win(player_val):
    global game_over, winner

    # Check horizontal win
    for row in range(BOARD_ROWS):
        if board[row][0] == player_val and board[row][1] == player_val and board[row][2] == player_val:
            game_over = True
            winner = player_val
            pygame.draw.line(screen, GREEN, (0, row * SQUARE_SIZE + SQUARE_SIZE // 2),
                            (WIDTH, row * SQUARE_SIZE + SQUARE_SIZE // 2), LINE_WIDTH)
            return True

    # Check vertical win
    for col in range(BOARD_COLS):
        if board[0][col] == player_val and board[1][col] == player_val and board[2][col] == player_val:
            game_over = True
            winner = player_val
            pygame.draw.line(screen, GREEN, (col * SQUARE_SIZE + SQUARE_SIZE // 2, 0),
                            (col * SQUARE_SIZE + SQUARE_SIZE // 2, HEIGHT), LINE_WIDTH)
            return True

    # Check ascending diagonal win
    if board[2][0] == player_val and board[1][1] == player_val and board[0][2] == player_val:
        game_over = True
        winner = player_val
        pygame.draw.line(screen, GREEN, (SPACE, HEIGHT - SPACE), (WIDTH - SPACE, SPACE), LINE_WIDTH)
        return True

    # Check descending diagonal win
    if board[0][0] == player_val and board[1][1] == player_val and board[2][2] == player_val:
        game_over = True
        winner = player_val
        pygame.draw.line(screen, GREEN, (SPACE, SPACE), (WIDTH - SPACE, HEIGHT - SPACE), LINE_WIDTH)
        return True

    return False

def check_draw():
    for row in range(BOARD_ROWS):
        for col in range(BOARD_COLS):
            if board[row][col] == 0: # If any square is empty, it's not a draw yet
                return False
    return True # If no square is empty and no winner, it's a draw

def display_message(message):
    font = pygame.font.Font(None, 80) # None for default font, 80 for font size
    text = font.render(message, True, BLACK) # Render the text: (text, antialias, color)
    text_rect = text.get_rect(center=(WIDTH // 2, HEIGHT // 2)) # Get rectangle for centering
    screen.blit(text, text_rect) # Draw the text onto the screen

    # Add a smaller message for restarting
    small_font = pygame.font.Font(None, 40)
    restart_text = small_font.render("Press 'R' to Restart", True, GRAY)
    restart_text_rect = restart_text.get_rect(center=(WIDTH // 2, HEIGHT // 2 + 50))
    screen.blit(restart_text, restart_text_rect)

def restart_game():
    global board, player, game_over, winner
    board = [[0, 0, 0],
             [0, 0, 0],
             [0, 0, 0]]
    player = 1
    game_over = False
    winner = None
    screen.fill(WHITE) # Clear the screen
    draw_board() # Redraw the empty board

running = True
draw_board()

while running:
    for event in pygame.event.get(): # Check for all events (user actions)
        if event.type == pygame.QUIT: # If the user clicks the 'X' to close the window
            running = False
            sys.exit() # Exit the program

        if event.type == pygame.MOUSEBUTTONDOWN and not game_over:
            mouseX = event.pos[0] # x-coordinate of mouse click
            mouseY = event.pos[1] # y-coordinate of mouse click

            # Determine which square was clicked
            clicked_col = mouseX // SQUARE_SIZE
            clicked_row = mouseY // SQUARE_SIZE

            # Make sure click is within board bounds and the cell is empty
            if 0 <= clicked_row < BOARD_ROWS and 0 <= clicked_col < BOARD_COLS and board[clicked_row][clicked_col] == 0:
                board[clicked_row][clicked_col] = player # Place current player's mark

                if check_win(player):
                    message = f"Player {winner} Wins!"
                elif check_draw():
                    game_over = True
                    message = "It's a Draw!"
                else:
                    # Switch player for the next turn
                    player = 1 if player == 2 else 2 # If player was 2, switch to 1; otherwise, switch to 2

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r: # Check if 'R' key is pressed
                restart_game()

    # Always redraw everything in the loop
    screen.fill(WHITE) # Clear the screen each frame
    draw_board() # Draw the grid lines
    draw_figures() # Draw X's and O's

    if game_over:
        if winner:
            display_message(f"Player {winner} Wins!")
        else:
            display_message("It's a Draw!")

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

import pygame
import sys

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

WIDTH, HEIGHT = 600, 600
LINE_WIDTH = 10
BOARD_ROWS, BOARD_COLS = 3, 3
SQUARE_SIZE = WIDTH // BOARD_COLS # Each square will be 200x200 pixels
CIRCLE_RADIUS = SQUARE_SIZE // 3
CIRCLE_WIDTH = 15
CROSS_WIDTH = 25
SPACE = SQUARE_SIZE // 4 # Space for X and O not to touch edges

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Tic-Tac-Toe!")
screen.fill(WHITE)

board = [[0, 0, 0],
         [0, 0, 0],
         [0, 0, 0]]
player = 1 # Player 1 is 'X', Player 2 is 'O'
game_over = False
winner = None

def draw_board():
    # Horizontal lines
    pygame.draw.line(screen, BLACK, (0, SQUARE_SIZE), (WIDTH, SQUARE_SIZE), LINE_WIDTH)
    pygame.draw.line(screen, BLACK, (0, 2 * SQUARE_SIZE), (WIDTH, 2 * SQUARE_SIZE), LINE_WIDTH)
    # Vertical lines
    pygame.draw.line(screen, BLACK, (SQUARE_SIZE, 0), (SQUARE_SIZE, HEIGHT), LINE_WIDTH)
    pygame.draw.line(screen, BLACK, (2 * SQUARE_SIZE, 0), (2 * SQUARE_SIZE, HEIGHT), LINE_WIDTH)

def draw_figures():
    for row in range(BOARD_ROWS):
        for col in range(BOARD_COLS):
            if board[row][col] == 1: # Player 1 (X)
                # Draw an 'X'
                pygame.draw.line(screen, BLUE, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SPACE),
                                (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH)
                pygame.draw.line(screen, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SPACE),
                                (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH)
            elif board[row][col] == 2: # Player 2 (O)
                # Draw an 'O'
                pygame.draw.circle(screen, RED, (int(col * SQUARE_SIZE + SQUARE_SIZE // 2),
                                                int(row * SQUARE_SIZE + SQUARE_SIZE // 2)), CIRCLE_RADIUS, CIRCLE_WIDTH)

def check_win(player_val):
    global game_over, winner

    # Check horizontal win
    for row in range(BOARD_ROWS):
        if board[row][0] == player_val and board[row][1] == player_val and board[row][2] == player_val:
            game_over = True
            winner = player_val
            pygame.draw.line(screen, GREEN, (0, row * SQUARE_SIZE + SQUARE_SIZE // 2),
                            (WIDTH, row * SQUARE_SIZE + SQUARE_SIZE // 2), LINE_WIDTH)
            return True

    # Check vertical win
    for col in range(BOARD_COLS):
        if board[0][col] == player_val and board[1][col] == player_val and board[2][col] == player_val:
            game_over = True
            winner = player_val
            pygame.draw.line(screen, GREEN, (col * SQUARE_SIZE + SQUARE_SIZE // 2, 0),
                            (col * SQUARE_SIZE + SQUARE_SIZE // 2, HEIGHT), LINE_WIDTH)
            return True

    # Check ascending diagonal win (bottom-left to top-right)
    if board[2][0] == player_val and board[1][1] == player_val and board[0][2] == player_val:
        game_over = True
        winner = player_val
        pygame.draw.line(screen, GREEN, (SPACE, HEIGHT - SPACE), (WIDTH - SPACE, SPACE), LINE_WIDTH)
        return True

    # Check descending diagonal win (top-left to bottom-right)
    if board[0][0] == player_val and board[1][1] == player_val and board[2][2] == player_val:
        game_over = True
        winner = player_val
        pygame.draw.line(screen, GREEN, (SPACE, SPACE), (WIDTH - SPACE, HEIGHT - SPACE), LINE_WIDTH)
        return True

    return False

def check_draw():
    for row in range(BOARD_ROWS):
        for col in range(BOARD_COLS):
            if board[row][col] == 0: # If any square is empty, it's not a draw yet
                return False
    # If no winner and no empty squares, it's a draw
    return True

def display_message(message):
    font = pygame.font.Font(None, 80) # None for default font, 80 for font size
    text = font.render(message, True, BLACK) # Render the text: (text, antialias, color)
    text_rect = text.get_rect(center=(WIDTH // 2, HEIGHT // 2)) # Get rectangle for centering
    screen.blit(text, text_rect) # Draw the text onto the screen

    # Add a smaller message for restarting
    small_font = pygame.font.Font(None, 40)
    restart_text = small_font.render("Press 'R' to Restart", True, GRAY)
    restart_text_rect = restart_text.get_rect(center=(WIDTH // 2, HEIGHT // 2 + 50))
    screen.blit(restart_text, restart_text_rect)

def restart_game():
    global board, player, game_over, winner
    board = [[0, 0, 0],
             [0, 0, 0],
             [0, 0, 0]]
    player = 1
    game_over = False
    winner = None
    screen.fill(WHITE) # Clear the screen
    draw_board() # Redraw the empty board

running = True
draw_board()

while running:
    for event in pygame.event.get(): # Check for all events (user actions)
        if event.type == pygame.QUIT: # If the user clicks the 'X' to close the window
            running = False
            sys.exit() # Exit the program gracefully

        if event.type == pygame.MOUSEBUTTONDOWN and not game_over:
            mouseX = event.pos[0] # x-coordinate of mouse click
            mouseY = event.pos[1] # y-coordinate of mouse click

            # Determine which square was clicked
            clicked_col = mouseX // SQUARE_SIZE
            clicked_row = mouseY // SQUARE_SIZE

            # Make sure click is within board bounds and the cell is empty
            if 0 <= clicked_row < BOARD_ROWS and 0 <= clicked_col < BOARD_COLS and board[clicked_row][clicked_col] == 0:
                board[clicked_row][clicked_col] = player # Place current player's mark

                if check_win(player):
                    # Winner determined, message set inside check_win
                    pass
                elif check_draw():
                    game_over = True
                    winner = None # No specific winner in a draw
                else:
                    # Switch player for the next turn
                    player = 1 if player == 2 else 2 # If player was 2, switch to 1; otherwise, switch to 2

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r: # Check if 'R' key is pressed
                restart_game()

    # Always redraw everything in the loop
    screen.fill(WHITE) # Clear the screen each frame before drawing
    draw_board() # Draw the grid lines
    draw_figures() # Draw X's and O's

    if game_over:
        if winner:
            display_message(f"Player {winner} Wins!")
        else:
            display_message("It's a Draw!")

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

print("Welcome to the Whispering Woods Adventure!")
print("You find yourself at the edge of a dark forest. A narrow path lies ahead, and a faint glow twinkles deep within.")
print("The air is thick with mystery, and the rustling leaves seem to whisper secrets.")

print("\nWhat do you do?") # The \n creates a new line, making the text easier to read.
print("1. Follow the path into the forest.")
print("2. Look for another way around.")

choice1 = input("> ") # The player's choice will be stored in the 'choice1' variable.

if choice1 == "1":
    print("\nYou bravely step onto the path, the trees closing in around you.")
    print("After a few minutes, you come to a fork in the road.")
    print("To the left, you hear the faint sound of rushing water. To the right, the path seems darker and quieter.")

    # Now we present another choice based on the first one!
    print("\nWhat do you do?")
    print("1. Go left towards the sound of water.")
    print("2. Go right into the darker path.")

    choice2 = input("> ")

    if choice2 == "1":
        print("\nYou follow the sound of water and soon find a beautiful, clear stream.")
        print("You're thirsty, but also notice something shiny at the bottom of the stream.")
        print("\nWhat do you do?")
        print("1. Drink from the stream.")
        print("2. Try to reach the shiny object.")
        choice3 = input("> ")
        if choice3 == "1":
            print("\nThe water is refreshing, and you feel invigorated! You continue your journey feeling ready for anything.")
            print("Congratulations! You found a safe path through the woods!")
        elif choice3 == "2":
            print("\nYou reach into the stream and pull out a rusty old key. Suddenly, a grumpy forest spirit appears!")
            print("The spirit demands to know why you took their key. You try to explain, but it's too late.")
            print("Game Over. The spirit turns you into a toad!")
        else:
            print("\nConfused by your choice, you hesitate too long. A wolf howls nearby, and you quickly retreat.")
            print("Game Over. You got scared and ran away!")

    elif choice2 == "2":
        print("\nYou venture into the darker path. The air grows cold, and you feel a sense of dread.")
        print("Suddenly, you stumble upon an old, abandoned cabin. The door creaks open slightly.")
        print("\nWhat do you do?")
        print("1. Enter the cabin.")
        print("2. Try to sneak past the cabin.")
        choice3_dark_path = input("> ")
        if choice3_dark_path == "1":
            print("\nYou push open the door and step inside. It's dusty and silent. In the center of the room, a chest sits.")
            print("\nWhat do you do?")
            print("1. Open the chest.")
            print("2. Look around the room first.")
            choice4_cabin = input("> ")
            if choice4_cabin == "1":
                print("\nYou open the chest and find a treasure map! You've found your way out!")
                print("Congratulations! You found the treasure map and escaped the forest!")
            elif choice4_cabin == "2":
                print("\nAs you look around, a trap door opens beneath you!")
                print("Game Over. You fell into a pit!")
            else:
                print("\nUnsure, you linger too long. Something in the shadows grabs you!")
                print("Game Over. You were caught by an unknown creature!")
        elif choice3_dark_path == "2":
            print("\nYou try to sneak past, but trip over a root and alert whatever is inside the cabin.")
            print("Game Over. You were noticed and dragged into the cabin by unseen forces!")
        else:
            print("\nYour hesitation costs you. The cabin door slams shut, trapping you outside with unseen dangers!")
            print("Game Over. You are trapped outside the spooky cabin.")

    else:
        print("\nNot understanding your choice, you stand frozen. The forest grows eerier.")
        print("Game Over. You couldn't make a decision and were lost.")

elif choice1 == "2":
    print("\nYou decide the forest is too dangerous and look for another way. After hours of searching, you find nothing but thorns.")
    print("Exhausted and defeated, you realize you should have taken the path.")
    print("Game Over. You gave up too easily and got nowhere.")

else:
    print("\nInvalid choice. The forest watches as you stand confused.")
    print("Game Over. You couldn't make a decision and were lost.")

print("\nThanks for playing!")

print("Welcome to the Whispering Woods Adventure!")
print("You find yourself at the edge of a dark forest. A narrow path lies ahead, and a faint glow twinkles deep within.")
print("The air is thick with mystery, and the rustling leaves seem to whisper secrets.")

print("\nWhat do you do?")
print("1. Follow the path into the forest.")
print("2. Look for another way around.")

choice1 = input("> ") # Get player's choice

if choice1 == "1":
    print("\nYou bravely step onto the path, the trees closing in around you.")
    print("After a few minutes, you come to a fork in the road.")
    print("To the left, you hear the faint sound of rushing water. To the right, the path seems darker and quieter.")

    # Second Choice Point (Path split)
    print("\nWhat do you do?")
    print("1. Go left towards the sound of water.")
    print("2. Go right into the darker path.")

    choice2 = input("> ")

    if choice2 == "1":
        print("\nYou follow the sound of water and soon find a beautiful, clear stream.")
        print("You're thirsty, but also notice something shiny at the bottom of the stream.")

        # Third Choice Point (Stream)
        print("\nWhat do you do?")
        print("1. Drink from the stream.")
        print("2. Try to reach the shiny object.")

        choice3 = input("> ")

        if choice3 == "1":
            print("\nThe water is refreshing, and you feel invigorated! You continue your journey feeling ready for anything.")
            print("Congratulations! You found a safe path through the woods!")
        elif choice3 == "2":
            print("\nYou reach into the stream and pull out a rusty old key. Suddenly, a grumpy forest spirit appears!")
            print("The spirit demands to know why you took their key. You try to explain, but it's too late.")
            print("Game Over. The spirit turns you into a toad!")
        else:
            print("\nConfused by your choice, you hesitate too long. A wolf howls nearby, and you quickly retreat.")
            print("Game Over. You got scared and ran away!")

    elif choice2 == "2":
        print("\nYou venture into the darker path. The air grows cold, and you feel a sense of dread.")
        print("Suddenly, you stumble upon an old, abandoned cabin. The door creaks open slightly.")

        # Third Choice Point (Cabin)
        print("\nWhat do you do?")
        print("1. Enter the cabin.")
        print("2. Try to sneak past the cabin.")

        choice3_dark_path = input("> ")

        if choice3_dark_path == "1":
            print("\nYou push open the door and step inside. It's dusty and silent. In the center of the room, a chest sits.")
            print("\nWhat do you do?")
            print("1. Open the chest.")
            print("2. Look around the room first.")

            choice4_cabin = input("> ")

            if choice4_cabin == "1":
                print("\nYou open the chest and find a treasure map! You've found your way out!")
                print("Congratulations! You found the treasure map and escaped the forest!")
            elif choice4_cabin == "2":
                print("\nAs you look around, a trap door opens beneath you!")
                print("Game Over. You fell into a pit!")
            else:
                print("\nUnsure, you linger too long. Something in the shadows grabs you!")
                print("Game Over. You were caught by an unknown creature!")

        elif choice3_dark_path == "2":
            print("\nYou try to sneak past, but trip over a root and alert whatever is inside the cabin.")
            print("Game Over. You were noticed and dragged into the cabin by unseen forces!")
        else:
            print("\nYour hesitation costs you. The cabin door slams shut, trapping you outside with unseen dangers!")
            print("Game Over. You are trapped outside the spooky cabin.")

    else:
        print("\nNot understanding your choice, you stand frozen. The forest grows eerier.")
        print("Game Over. You couldn't make a decision and were lost.")

elif choice1 == "2":
    print("\nYou decide the forest is too dangerous and look for another way. After hours of searching, you find nothing but thorns.")
    print("Exhausted and defeated, you realize you should have taken the path.")
    print("Game Over. You gave up too easily and got nowhere.")

else:
    print("\nInvalid choice. The forest watches as you stand confused.")
    print("Game Over. You couldn't make a decision and were lost.")

print("\nThanks for playing!")