main.py

import pygame
import random
import json
import os
from enum import Enum

pygame.init()

# Colors
white = (255, 255, 255)
red = (255, 0, 0)
black = (0, 0, 0)
green = (0, 255, 0)
yellow = (255, 255, 0)
blue = (0, 0, 255)
dark_green = (0, 155, 0)
gray = (128, 128, 128)

# Game States
class GameState(Enum):
    MENU = 1
    DIFFICULTY = 2
    PLAYING = 3
    PAUSED = 4
    GAME_OVER = 5

# Difficulty Levels
class Difficulty(Enum):
    EASY = 1
    MEDIUM = 2
    HARD = 3
    EXTREME = 4

DIFFICULTY_SETTINGS = {
    Difficulty.EASY: {"speed": 4, "color": green},
    Difficulty.MEDIUM: {"speed": 8, "color": yellow},
    Difficulty.HARD: {"speed": 12, "color": red},
    Difficulty.EXTREME: {"speed": 16, "color": (255, 0, 255)}
}

# Creating window
screen_width = 800
screen_height = 600
gameWindow = pygame.display.set_mode((screen_width, screen_height))

# Game Title
pygame.display.set_caption("🐍 Advanced Snake Game")
pygame.display.update()
clock = pygame.time.Clock()
font_small = pygame.font.SysFont(None, 20)
font_medium = pygame.font.SysFont(None, 40)
font_large = pygame.font.SysFont(None, 60)

# High Score File
HIGH_SCORE_FILE = "highscore.json"



def text_screen(text, color, x, y, font=None):
    if font is None:
        font = font_small
    screen_text = font.render(text, True, color)
    gameWindow.blit(screen_text, [x, y])


def plot_snake(gameWindow, color, snk_list, snake_size):
    for x, y in snk_list:
        pygame.draw.rect(gameWindow, color, [x, y, snake_size, snake_size])
        pygame.draw.rect(gameWindow, black, [x, y, snake_size, snake_size], 2)


class HighScoreManager:
    """Manages high scores persistence"""
    @staticmethod
    def load_high_score():
        if os.path.exists(HIGH_SCORE_FILE):
            try:
                with open(HIGH_SCORE_FILE, 'r') as f:
                    data = json.load(f)
                    return data.get("high_score", 0)
            except:
                return 0
        return 0

    @staticmethod
    def save_high_score(score):
        with open(HIGH_SCORE_FILE, 'w') as f:
            json.dump({"high_score": score}, f)


def draw_menu():
    """Draw main menu screen"""
    gameWindow.fill(white)
    text_screen("🐍 SNAKE GAME 🐍", black, screen_width // 2 - 150, 50, font_large)
    text_screen("Press S to Start", black, screen_width // 2 - 100, 180, font_medium)
    text_screen("Press Q to Quit", black, screen_width // 2 - 100, 250, font_medium)
    
    high_score = HighScoreManager.load_high_score()
    text_screen(f"High Score: {high_score * 10}", red, screen_width // 2 - 100, 380, font_small)
    
    pygame.display.update()


def draw_difficulty_menu():
    """Draw difficulty selection screen"""
    gameWindow.fill(white)
    text_screen("SELECT DIFFICULTY", black, screen_width // 2 - 150, 50, font_large)
    text_screen("1 - EASY", green, screen_width // 2 - 100, 150, font_medium)
    text_screen("2 - MEDIUM", yellow, screen_width // 2 - 100, 220, font_medium)
    text_screen("3 - HARD", red, screen_width // 2 - 100, 290, font_medium)
    text_screen("4 - EXTREME", (255, 0, 255), screen_width // 2 - 100, 360, font_medium)
    text_screen("Q - Back to Menu", gray, screen_width // 2 - 100, 450, font_small)
    
    pygame.display.update()


def draw_paused_screen():
    """Draw pause menu"""
    gameWindow.fill(black)
    gameWindow.set_alpha(128)
    overlay = pygame.Surface((screen_width, screen_height))
    overlay.set_alpha(128)
    overlay.fill(black)
    gameWindow.blit(overlay, (0, 0))
    
    text_screen("PAUSED", white, screen_width // 2 - 80, screen_height // 2 - 50, font_large)
    text_screen("Press P to Resume", white, screen_width // 2 - 120, screen_height // 2 + 50, font_small)
    
    pygame.display.update()


def draw_game_over_screen(score, high_score):
    """Draw game over screen with score"""
    gameWindow.fill(white)
    text_screen("GAME OVER!", red, screen_width // 2 - 100, 100, font_large)
    text_screen(f"Final Score: {score * 10}", black, screen_width // 2 - 150, 200, font_medium)
    
    if score * 10 > high_score * 10:
        text_screen("NEW HIGH SCORE!", red, screen_width // 2 - 150, 280, font_medium)
    else:
        text_screen(f"High Score: {high_score * 10}", black, screen_width // 2 - 150, 280, font_small)
    
    text_screen("Press ENTER to Replay", black, screen_width // 2 - 140, 380, font_small)
    text_screen("Press M for Menu", black, screen_width // 2 - 140, 420, font_small)
    text_screen("Press Q to Quit", black, screen_width // 2 - 140, 460, font_small)
    
    pygame.display.update()


def gameloop():
    """Main game loop with state management"""
    # Game specific variables
    game_state = GameState.MENU
    exit_game = False
    snake_x = 45
    snake_y = 55
    velocity_x = 0
    velocity_y = 0
    snk_list = []
    snk_length = 1
    score = 0
    snake_size = 20

    food_x = random.randint(50, screen_width - 50)
    food_y = random.randint(50, screen_height - 50)
    
    difficulty = Difficulty.MEDIUM
    fps = DIFFICULTY_SETTINGS[difficulty]["speed"]
    snake_color = DIFFICULTY_SETTINGS[difficulty]["color"]
    
    high_score = HighScoreManager.load_high_score()
    
    while not exit_game:
        if game_state == GameState.MENU:
            draw_menu()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exit_game = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_s:
                        game_state = GameState.DIFFICULTY
                    if event.key == pygame.K_q:
                        exit_game = True
        
        elif game_state == GameState.DIFFICULTY:
            draw_difficulty_menu()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exit_game = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_1:
                        difficulty = Difficulty.EASY
                        game_state = GameState.PLAYING
                        snake_x, snake_y = 45, 55
                        velocity_x, velocity_y = 0, 0
                        snk_list, snk_length = [], 1
                        score = 0
                        food_x = random.randint(50, screen_width - 50)
                        food_y = random.randint(50, screen_height - 50)
                        fps = DIFFICULTY_SETTINGS[difficulty]["speed"]
                        snake_color = DIFFICULTY_SETTINGS[difficulty]["color"]
                    elif event.key == pygame.K_2:
                        difficulty = Difficulty.MEDIUM
                        game_state = GameState.PLAYING
                        snake_x, snake_y = 45, 55
                        velocity_x, velocity_y = 0, 0
                        snk_list, snk_length = [], 1
                        score = 0
                        food_x = random.randint(50, screen_width - 50)
                        food_y = random.randint(50, screen_height - 50)
                        fps = DIFFICULTY_SETTINGS[difficulty]["speed"]
                        snake_color = DIFFICULTY_SETTINGS[difficulty]["color"]
                    elif event.key == pygame.K_3:
                        difficulty = Difficulty.HARD
                        game_state = GameState.PLAYING
                        snake_x, snake_y = 45, 55
                        velocity_x, velocity_y = 0, 0
                        snk_list, snk_length = [], 1
                        score = 0
                        food_x = random.randint(50, screen_width - 50)
                        food_y = random.randint(50, screen_height - 50)
                        fps = DIFFICULTY_SETTINGS[difficulty]["speed"]
                        snake_color = DIFFICULTY_SETTINGS[difficulty]["color"]
                    elif event.key == pygame.K_4:
                        difficulty = Difficulty.EXTREME
                        game_state = GameState.PLAYING
                        snake_x, snake_y = 45, 55
                        velocity_x, velocity_y = 0, 0
                        snk_list, snk_length = [], 1
                        score = 0
                        food_x = random.randint(50, screen_width - 50)
                        food_y = random.randint(50, screen_height - 50)
                        fps = DIFFICULTY_SETTINGS[difficulty]["speed"]
                        snake_color = DIFFICULTY_SETTINGS[difficulty]["color"]
                    elif event.key == pygame.K_q:
                        game_state = GameState.MENU
        
        elif game_state == GameState.PAUSED:
            draw_paused_screen()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exit_game = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_p:
                        game_state = GameState.PLAYING
        
        elif game_state == GameState.PLAYING:
            # KEY MAPPINGS
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exit_game = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_p:
                        game_state = GameState.PAUSED
                    elif event.key == pygame.K_RIGHT:
                        if velocity_x == 0:
                            velocity_x = 1
                            velocity_y = 0
                    elif event.key == pygame.K_LEFT:
                        if velocity_x == 0:
                            velocity_x = -1
                            velocity_y = 0
                    elif event.key == pygame.K_UP:
                        if velocity_y == 0:
                            velocity_y = -1
                            velocity_x = 0
                    elif event.key == pygame.K_DOWN:
                        if velocity_y == 0:
                            velocity_y = 1
                            velocity_x = 0

            snake_x = snake_x + velocity_x * snake_size
            snake_y = snake_y + velocity_y * snake_size

            # Check food collision
            if abs(snake_x - food_x) < snake_size and abs(snake_y - food_y) < snake_size:
                score += 1
                food_x = random.randint(50, screen_width - 50)
                food_y = random.randint(50, screen_height - 50)
                snk_length += 1
                # Increase difficulty as score increases
                if score % 5 == 0:
                    fps = min(fps + 1, 20)

            gameWindow.fill(white)
            
            # Draw border
            pygame.draw.rect(gameWindow, black, [0, 0, screen_width, screen_height], 3)
            
            # Draw score and difficulty
            text_screen(f"Score: {score * 10}", red, 10, 10, font_small)
            text_screen(f"High Score: {high_score * 10}", blue, 10, 40, font_small)
            difficulty_text = difficulty.name
            text_screen(f"Difficulty: {difficulty_text}", snake_color, screen_width - 200, 10, font_small)
            text_screen("P - Pause | Q - Quit", gray, screen_width - 200, 40, font_small)
            
            # Draw food
            pygame.draw.rect(gameWindow, red, [food_x, food_y, snake_size, snake_size])
            pygame.draw.rect(gameWindow, dark_green, [food_x, food_y, snake_size, snake_size], 2)

            # Update snake
            head = [snake_x, snake_y]
            snk_list.append(head)

            if len(snk_list) > snk_length:
                del snk_list[0]

            # Check collision with self
            if head in snk_list[:-1]:
                if score * 10 > high_score * 10:
                    high_score = score
                    HighScoreManager.save_high_score(high_score)
                game_state = GameState.GAME_OVER

            # Check boundary collision
            if snake_x < 0 or snake_x > screen_width - snake_size or snake_y < 0 or snake_y > screen_height - snake_size:
                if score * 10 > high_score * 10:
                    high_score = score
                    HighScoreManager.save_high_score(high_score)
                game_state = GameState.GAME_OVER
            
            plot_snake(gameWindow, snake_color, snk_list, snake_size)
            pygame.display.update()
            clock.tick(fps)
            continue

        elif game_state == GameState.GAME_OVER:
            draw_game_over_screen(score, high_score)
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exit_game = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_RETURN:
                        game_state = GameState.DIFFICULTY
                    elif event.key == pygame.K_m:
                        game_state = GameState.MENU
                    elif event.key == pygame.K_q:
                        exit_game = True
        
        clock.tick(60)

    pygame.quit()
    quit()


if __name__ == "__main__":
    gameloop()