import pygame # Screen dimensions SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 GRID_SIZE = 20 GRID_WIDTH = SCREEN_WIDTH // GRID_SIZE GRID_HEIGHT = SCREEN_HEIGHT // GRID_SIZE # Colors (RGB) WHITE = (255, 255, 255) BLACK = (0, 0, 0) RED = (220, 20, 60) # Crimson Red DARK_RED = (139, 0, 0) GREEN = (50, 205, 50) # Lime Green DARK_GREEN = (0, 100, 0) BLUE = (30, 144, 255) # Dodger Blue LIGHT_BLUE = (173, 216, 230) YELLOW = (255, 215, 0) # Gold ORANGE = (255, 140, 0) # Dark Orange PURPLE = (148, 0, 211) # Dark Violet GRAY = (105, 105, 105) # Dim Gray LIGHT_GRAY = (211, 211, 211) # Theme Colors BACKGROUND_COLOR = (20, 20, 30) # Dark bluish background GRID_COLOR = (40, 40, 55) # Darker grid lines SNAKE_HEAD_COLOR = GREEN SNAKE_BODY_COLOR_1 = DARK_GREEN SNAKE_BODY_COLOR_2 = (0, 120, 0) # Slightly lighter dark green SNAKE_EYE_COLOR = BLACK SNAKE_PUPIL_COLOR = WHITE FOOD_COLOR = RED FOOD_SHINE_COLOR = (255, 100, 100) FOOD_STEM_COLOR = (139, 69, 19) # Brown FOOD_PARTICLE_COLOR = ORANGE PARTICLE_COLOR_FOOD = FOOD_PARTICLE_COLOR PARTICLE_COLOR_GAMEOVER = RED SCORE_COLOR = WHITE MENU_TITLE_COLOR = GREEN MENU_OPTION_COLOR = WHITE MENU_SELECTED_COLOR = YELLOW MENU_INFO_COLOR = GRAY GAME_OVER_COLOR = RED HIGH_SCORE_COLOR = YELLOW # Snake settings SNAKE_START_POS = (GRID_WIDTH // 2, GRID_HEIGHT // 2) SNAKE_START_LENGTH = 3 SNAKE_SPEED = 10 # Moves per second (approx) SNAKE_MOVE_INTERVAL = 1000 / SNAKE_SPEED # Milliseconds per move SNAKE_BODY_RADIUS_FACTOR = 0.4 # For rounded segments (percentage of GRID_SIZE) SNAKE_HEAD_RADIUS_FACTOR = 0.5 # Food settings FOOD_RADIUS_FACTOR = 0.45 # Percentage of GRID_SIZE FOOD_STEM_HEIGHT_FACTOR = 0.2 FOOD_STEM_WIDTH_FACTOR = 0.1 FOOD_SHINE_OFFSET_FACTOR = 0.15 # Particle settings PARTICLE_COUNT_FOOD = 25 PARTICLE_COUNT_GAMEOVER = 40 PARTICLE_LIFESPAN = 30 # Frames PARTICLE_SPEED_MAX = 4 PARTICLE_RADIUS_START = 6 PARTICLE_RADIUS_END = 0 PARTICLE_GRAVITY = 0.1 # Simple gravity effect # UI settings FONT_NAME = None # Use default pygame font FONT_SIZE_XLARGE = 72 FONT_SIZE_LARGE = 48 FONT_SIZE_MEDIUM = 32 FONT_SIZE_SMALL = 20 UI_PADDING = 10 HIGH_SCORE_FILE = "highscore.txt" # Game states MENU = "MENU" PLAYING = "PLAYING" GAME_OVER = "GAME_OVER" # Directions (using Vector2 for easier calculations) UP = pygame.Vector2(0, -1) DOWN = pygame.Vector2(0, 1) LEFT = pygame.Vector2(-1, 0) RIGHT = pygame.Vector2(1, 0) # Sound Settings (Optional: uncomment and provide files) # SOUND_EAT_FILE = "assets/eat.wav" # SOUND_GAMEOVER_FILE = "assets/gameover.wav" # SOUND_MENU_SELECT_FILE = "assets/select.wav" # SOUND_MENU_NAVIGATE_FILE = "assets/navigate.wav" SOUND_ENABLED = False # Set to True if you add sound files and init mixer import pygame import random from settings import * class Particle: def __init__(self, x, y, color, gravity=PARTICLE_GRAVITY): self.x = x self.y = y self.start_color = color self.lifespan = PARTICLE_LIFESPAN self.max_lifespan = PARTICLE_LIFESPAN # Store max for alpha calculation angle = random.uniform(0, 2 * 3.14159) speed = random.uniform(1, PARTICLE_SPEED_MAX) self.vx = speed * pygame.math.Vector2(1, 0).rotate(random.uniform(0, 360)).x self.vy = speed * pygame.math.Vector2(0, 1).rotate(random.uniform(0, 360)).y - random.uniform(0, speed * 0.5) # Slight upward bias initially self.radius = PARTICLE_RADIUS_START self.gravity = gravity def update(self): self.vy += self.gravity # Apply gravity self.x += self.vx self.y += self.vy self.lifespan -= 1 # Interpolate radius based on lifespan t = max(0, self.lifespan / self.max_lifespan) # Ensure t is not negative self.radius = PARTICLE_RADIUS_START * t + PARTICLE_RADIUS_END * (1 - t) if self.radius < 0: self.radius = 0 def draw(self, surface): if self.lifespan > 0 and self.radius > 0: # Fade color based on lifespan using alpha alpha = int(255 * (self.lifespan / self.max_lifespan)) # Create a temporary surface for alpha blending if main surface doesn't support it well # Or, if the main surface supports alpha (pygame.SRCALPHA flag), draw directly # For simplicity, we'll just change the color brightness slightly t = self.lifespan / self.max_lifespan current_color = tuple(max(0, min(255, int(c * (0.5 + t * 0.5)))) for c in self.start_color) # Fade towards half brightness try: # Use pygame.SRCALPHA for proper alpha blending if possible temp_surf = pygame.Surface((self.radius * 2, self.radius * 2), pygame.SRCALPHA) pygame.draw.circle(temp_surf, (*self.start_color, alpha), (self.radius, self.radius), int(self.radius)) surface.blit(temp_surf, (int(self.x - self.radius), int(self.y - self.radius))) except: # Fallback if SRALPHA fails or is not desired pygame.draw.circle(surface, current_color, (int(self.x), int(self.y)), int(self.radius)) class ParticleSystem: def __init__(self): self.particles = [] def add_particles(self, x, y, count, color, gravity=PARTICLE_GRAVITY): for _ in range(count): self.particles.append(Particle(x, y, color, gravity)) def update(self): # Update and remove dead particles self.particles = [p for p in self.particles if p.lifespan > 0] for particle in self.particles: particle.update() def draw(self, surface): for particle in self.particles: particle.draw(surface) def clear(self): self.particles = [] import pygame from settings import * class Snake: def __init__(self): self.reset() self.move_timer = 0 self.move_interval = SNAKE_MOVE_INTERVAL def reset(self): self.body = [pygame.Vector2(SNAKE_START_POS[0] - i, SNAKE_START_POS[1]) for i in range(SNAKE_START_LENGTH)] self.direction = RIGHT self.new_direction = RIGHT self.grow = False self.head_color = SNAKE_HEAD_COLOR self.body_color_1 = SNAKE_BODY_COLOR_1 self.body_color_2 = SNAKE_BODY_COLOR_2 self.eye_color = SNAKE_EYE_COLOR self.pupil_color = SNAKE_PUPIL_COLOR self.move_timer = 0 # Reset move timer def change_direction(self, direction): # Prevent reversing direction directly if direction + self.direction != pygame.Vector2(0, 0): self.new_direction = direction def move(self): self.direction = self.new_direction new_head = self.body[0] + self.direction # Wrap around screen edges new_head.x %= GRID_WIDTH new_head.y %= GRID_HEIGHT if self.grow: self.body.insert(0, new_head) self.grow = False else: self.body.insert(0, new_head) self.body.pop() # Remove the tail segment def grow_snake(self): self.grow = True def check_collision_self(self): return self.body[0] in self.body[1:] def update(self, dt): # Timer based movement for consistent speed regardless of frame rate self.move_timer += dt moved = False if self.move_timer >= self.move_interval: self.move() # Reset timer, subtracting the interval to keep overshoot self.move_timer -= self.move_interval # Ensure timer doesn't accumulate large negative values if dt is huge if self.move_timer < -self.move_interval: self.move_timer = 0 moved = True return moved def draw(self, surface): # Draw body segments (rounded rectangles) radius = int(GRID_SIZE * SNAKE_BODY_RADIUS_FACTOR) for i, segment in enumerate(reversed(self.body[1:])): # Draw tail first segment_rect = pygame.Rect( segment.x * GRID_SIZE, segment.y * GRID_SIZE, GRID_SIZE, GRID_SIZE ) # Alternate colors for segments color = self.body_color_1 if (len(self.body) - 1 - i) % 2 == 0 else self.body_color_2 pygame.draw.rect(surface, color, segment_rect, border_radius=radius) # Draw head (also rounded, slightly larger radius) head_radius = int(GRID_SIZE * SNAKE_HEAD_RADIUS_FACTOR) head_rect = pygame.Rect( self.body[0].x * GRID_SIZE, self.body[0].y * GRID_SIZE, GRID_SIZE, GRID_SIZE ) pygame.draw.rect(surface, self.head_color, head_rect, border_radius=head_radius) # Draw eyes based on direction eye_size = GRID_SIZE // 6 pupil_size = eye_size // 2 center_x = head_rect.centerx center_y = head_rect.centery offset_x = GRID_SIZE // 4 offset_y = GRID_SIZE // 4 if self.direction == UP: eye1_pos = (center_x - offset_x, center_y - offset_y) eye2_pos = (center_x + offset_x, center_y - offset_y) pupil_offset = (0, -pupil_size // 2) elif self.direction == DOWN: eye1_pos = (center_x - offset_x, center_y + offset_y) eye2_pos = (center_x + offset_x, center_y + offset_y) pupil_offset = (0, pupil_size // 2) elif self.direction == LEFT: eye1_pos = (center_x - offset_x, center_y - offset_y) eye2_pos = (center_x - offset_x, center_y + offset_y) pupil_offset = (-pupil_size // 2, 0) else: # RIGHT eye1_pos = (center_x + offset_x, center_y - offset_y) eye2_pos = (center_x + offset_x, center_y + offset_y) pupil_offset = (pupil_size // 2, 0) pygame.draw.circle(surface, self.eye_color, eye1_pos, eye_size) pygame.draw.circle(surface, self.eye_color, eye2_pos, eye_size) # Draw pupils pupil1_pos = (eye1_pos[0] + pupil_offset[0], eye1_pos[1] + pupil_offset[1]) pupil2_pos = (eye2_pos[0] + pupil_offset[0], eye2_pos[1] + pupil_offset[1]) pygame.draw.circle(surface, self.pupil_color, pupil1_pos, pupil_size) pygame.draw.circle(surface, self.pupil_color, pupil2_pos, pupil_size) def get_head_center_pixel(self): return ( (self.body[0].x * GRID_SIZE) + GRID_SIZE // 2, (self.body[0].y * GRID_SIZE) + GRID_SIZE // 2 ) import pygame import random from settings import * import math class Food: def __init__(self, snake_body): self.color = FOOD_COLOR self.shine_color = FOOD_SHINE_COLOR self.stem_color = FOOD_STEM_COLOR self.particle_color = PARTICLE_COLOR_FOOD self.randomize_position(snake_body) # Animation properties self.pulse_timer = random.uniform(0, 500) # Random start offset self.pulse_speed = 750 # Milliseconds per pulse cycle self.min_scale = 0.9 self.max_scale = 1.0 self.current_scale = 1.0 def randomize_position(self, snake_body): available_positions = [] for x in range(GRID_WIDTH): for y in range(GRID_HEIGHT): pos = pygame.Vector2(x, y) if pos not in snake_body: available_positions.append(pos) if not available_positions: # Handle the case where there's no space left (shouldn't happen in normal snake) # For now, just place it randomly, potentially overlapping the snake briefly self.position = pygame.Vector2(random.randint(0, GRID_WIDTH - 1), random.randint(0, GRID_HEIGHT - 1)) else: self.position = random.choice(available_positions) def update(self, dt): # Pulsing animation self.pulse_timer = (self.pulse_timer + dt) % self.pulse_speed # Use a sine wave for smooth pulsing (0 to 1 range) scale_factor = (math.sin(2 * math.pi * self.pulse_timer / self.pulse_speed) + 1) / 2 self.current_scale = self.min_scale + (self.max_scale - self.min_scale) * scale_factor def draw(self, surface): # Calculate dynamic size and position center_x = (self.position.x + 0.5) * GRID_SIZE center_y = (self.position.y + 0.5) * GRID_SIZE radius = int(GRID_SIZE * FOOD_RADIUS_FACTOR * self.current_scale) # Draw main body (apple shape - circle) pygame.draw.circle(surface, self.color, (center_x, center_y), radius) # Draw shine effect shine_radius = radius // 3 shine_offset_x = int(radius * FOOD_SHINE_OFFSET_FACTOR) shine_offset_y = -int(radius * FOOD_SHINE_OFFSET_FACTOR) # Offset towards top-left shine_pos = (center_x + shine_offset_x, center_y + shine_offset_y) pygame.draw.circle(surface, self.shine_color, shine_pos, shine_radius) # Draw stem stem_width = int(GRID_SIZE * FOOD_STEM_WIDTH_FACTOR * self.current_scale) stem_height = int(GRID_SIZE * FOOD_STEM_HEIGHT_FACTOR * self.current_scale) stem_rect = pygame.Rect( center_x - stem_width // 2, center_y - radius - stem_height + (radius // 5), # Position above the apple slightly embedded stem_width, stem_height ) pygame.draw.rect(surface, self.stem_color, stem_rect, border_radius=stem_width // 2) def get_center_pixel(self): return ( (self.position.x * GRID_SIZE) + GRID_SIZE // 2, (self.position.y * GRID_SIZE) + GRID_SIZE // 2 ) import pygame from settings import * class UI: def __init__(self): try: self.font_xlarge = pygame.font.Font(FONT_NAME, FONT_SIZE_XLARGE) self.font_large = pygame.font.Font(FONT_NAME, FONT_SIZE_LARGE) self.font_medium = pygame.font.Font(FONT_NAME, FONT_SIZE_MEDIUM) self.font_small = pygame.font.Font(FONT_NAME, FONT_SIZE_SMALL) except Exception as e: print(f"Error loading font: {e}. Using default pygame font.") self.font_xlarge = pygame.font.SysFont(None, FONT_SIZE_XLARGE) self.font_large = pygame.font.SysFont(None, FONT_SIZE_LARGE) self.font_medium = pygame.font.SysFont(None, FONT_SIZE_MEDIUM) self.font_small = pygame.font.SysFont(None, FONT_SIZE_SMALL) def draw_text(self, surface, text, font, color, center_x=None, center_y=None, top_left_x=None, top_left_y=None, top_right_x=None, top_right_y=None): text_surface = font.render(text, True, color) text_rect = text_surface.get_rect() if center_x is not None and center_y is not None: text_rect.center = (center_x, center_y) elif top_left_x is not None and top_left_y is not None: text_rect.topleft = (top_left_x, top_left_y) elif top_right_x is not None and top_right_y is not None: text_rect.topright = (top_right_x, top_right_y) else: # Default to center if no position specified text_rect.center = (surface.get_width() // 2, surface.get_height() // 2) surface.blit(text_surface, text_rect) def draw_score(self, surface, score): score_text = f"Score: {score}" self.draw_text(surface, score_text, self.font_medium, SCORE_COLOR, top_left_x=UI_PADDING, top_left_y=UI_PADDING) def draw_high_score(self, surface, high_score, position='top_right'): high_score_text = f"High Score: {high_score}" if position == 'top_right': self.draw_text(surface, high_score_text, self.font_medium, HIGH_SCORE_COLOR, top_right_x=SCREEN_WIDTH - UI_PADDING, top_right_y=UI_PADDING) elif position == 'center': self.draw_text(surface, high_score_text, self.font_medium, HIGH_SCORE_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT // 2 + 50) def draw_menu(self, surface, selected_option, high_score): # Title self.draw_text(surface, "PYTHON SNAKE", self.font_xlarge, MENU_TITLE_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT // 4) # High Score self.draw_high_score(surface, high_score, position='center') # Show high score below title # Options start_color = MENU_SELECTED_COLOR if selected_option == 0 else MENU_OPTION_COLOR quit_color = MENU_SELECTED_COLOR if selected_option == 1 else MENU_OPTION_COLOR self.draw_text(surface, "Start Game", self.font_large, start_color, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT * 0.6) self.draw_text(surface, "Quit", self.font_large, quit_color, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT * 0.6 + 60) # Instructions self.draw_text(surface, "Use Arrow Keys or WASD to move", self.font_small, MENU_INFO_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT * 0.85) self.draw_text(surface, "Enter/Space to select", self.font_small, MENU_INFO_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT * 0.85 + 30) def draw_game_over(self, surface, score, high_score): # Dim background slightly using an overlay surface with alpha overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA) overlay.fill((0, 0, 0, 180)) # Black overlay with alpha surface.blit(overlay, (0, 0)) self.draw_text(surface, "GAME OVER", self.font_xlarge, GAME_OVER_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT // 3) self.draw_text(surface, f"Final Score: {score}", self.font_large, SCORE_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT // 2) if score >= high_score and score > 0: self.draw_text(surface, "New High Score!", self.font_medium, HIGH_SCORE_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT // 2 + 50) else: self.draw_text(surface, f"High Score: {high_score}", self.font_medium, HIGH_SCORE_COLOR, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT // 2 + 50) self.draw_text(surface, "Press Enter to return to Menu", self.font_medium, GRAY, center_x=SCREEN_WIDTH // 2, center_y=SCREEN_HEIGHT * 0.75) def draw_grid(self, surface): # Draw slightly thicker grid lines for x in range(0, SCREEN_WIDTH, GRID_SIZE): pygame.draw.line(surface, GRID_COLOR, (x, 0), (x, SCREEN_HEIGHT), 1) for y in range(0, SCREEN_HEIGHT, GRID_SIZE): pygame.draw.line(surface, GRID_COLOR, (0, y), (SCREEN_WIDTH, y), 1) def draw_background(self, surface): # Simple gradient background (optional, can be slow) # for y in range(SCREEN_HEIGHT): # color_ratio = y / SCREEN_HEIGHT # color = ( # int(BACKGROUND_COLOR[0] * (1 - color_ratio) + GRID_COLOR[0] * color_ratio), # int(BACKGROUND_COLOR[1] * (1 - color_ratio) + GRID_COLOR[1] * color_ratio), # int(BACKGROUND_COLOR[2] * (1 - color_ratio) + GRID_COLOR[2] * color_ratio) # ) # pygame.draw.line(surface, color, (0, y), (SCREEN_WIDTH, y)) # Or just fill with solid color surface.fill(BACKGROUND_COLOR) import pygame import sys import os from settings import * from snake import Snake from food import Food from particle import ParticleSystem from ui import UI class Game: def __init__(self, screen): self.screen = screen self.clock = pygame.time.Clock() self.game_state = MENU self.score = 0 self.high_score = self.load_high_score() self.snake = Snake() self.food = Food(self.snake.body) self.particle_system = ParticleSystem() self.ui = UI() self.menu_selection = 0 # 0: Start, 1: Quit # Sound Loading (Optional) self.sound_eat = None self.sound_gameover = None self.sound_navigate = None self.sound_select = None if SOUND_ENABLED: self.load_sounds() def load_high_score(self): if os.path.exists(HIGH_SCORE_FILE): try: with open(HIGH_SCORE_FILE, 'r') as f: return int(f.read().strip()) except ValueError: print(f"Warning: High score file '{HIGH_SCORE_FILE}' contains invalid data. Resetting to 0.") return 0 except Exception as e: print(f"Warning: Could not read high score file '{HIGH_SCORE_FILE}': {e}. Resetting to 0.") return 0 return 0 def save_high_score(self): try: with open(HIGH_SCORE_FILE, 'w') as f: f.write(str(self.high_score)) except Exception as e: print(f"Error: Could not save high score to '{HIGH_SCORE_FILE}': {e}") def load_sounds(self): # Helper function to load sound safely def _load_sound(filename): if not filename or not os.path.exists(filename): print(f"Warning: Sound file not found: {filename}") return None try: return pygame.mixer.Sound(filename) except pygame.error as e: print(f"Warning: Could not load sound '{filename}': {e}") return None # pygame.mixer.init() # Ensure mixer is initialized (usually done in main.py) # self.sound_eat = _load_sound(SOUND_EAT_FILE) # self.sound_gameover = _load_sound(SOUND_GAMEOVER_FILE) # self.sound_navigate = _load_sound(SOUND_MENU_NAVIGATE_FILE) # self.sound_select = _load_sound(SOUND_MENU_SELECT_FILE) pass # Implement actual loading if SOUND_ENABLED and files exist def play_sound(self, sound): if SOUND_ENABLED and sound: try: sound.play() except Exception as e: print(f"Error playing sound: {e}") def run(self): running = True while running: # Delta time for frame-independent movement/animations # Limit dt to avoid large jumps if debugging/stalling dt = min(self.clock.tick(60), 100) # Milliseconds, max 100ms step # Event Handling events = pygame.event.get() for event in events: if event.type == pygame.QUIT: running = False self.handle_input(event) # Update game state self.update(dt) # Draw everything self.draw() # Update the display pygame.display.flip() self.save_high_score() # Save high score when quitting pygame.quit() sys.exit() # Ensure clean exit def handle_input(self, event): if self.game_state == MENU: if event.type == pygame.KEYDOWN: new_selection = self.menu_selection if event.key == pygame.K_UP or event.key == pygame.K_w: new_selection = (self.menu_selection - 1) % 2 elif event.key == pygame.K_DOWN or event.key == pygame.K_s: new_selection = (self.menu_selection + 1) % 2 elif event.key == pygame.K_RETURN or event.key == pygame.K_SPACE: self.play_sound(self.sound_select) if self.menu_selection == 0: # Start Game self.start_game() elif self.menu_selection == 1: # Quit pygame.event.post(pygame.event.Event(pygame.QUIT)) # Post quit event elif event.key == pygame.K_ESCAPE: pygame.event.post(pygame.event.Event(pygame.QUIT)) if new_selection != self.menu_selection: self.menu_selection = new_selection self.play_sound(self.sound_navigate) elif self.game_state == PLAYING: if event.type == pygame.KEYDOWN: direction = None if event.key == pygame.K_UP or event.key == pygame.K_w: direction = UP elif event.key == pygame.K_DOWN or event.key == pygame.K_s: direction = DOWN elif event.key == pygame.K_LEFT or event.key == pygame.K_a: direction = LEFT elif event.key == pygame.K_RIGHT or event.key == pygame.K_d: direction = RIGHT elif event.key == pygame.K_ESCAPE: # Allow escape to go back to menu self.game_state = MENU # Maybe save high score here too? Or only on game over/quit. if direction: self.snake.change_direction(direction) elif self.game_state == GAME_OVER: if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN or event.key == pygame.K_SPACE: self.play_sound(self.sound_select) self.game_state = MENU # Return to menu elif event.key == pygame.K_ESCAPE: self.game_state = MENU def start_game(self): self.score = 0 self.snake.reset() self.food.randomize_position(self.snake.body) self.particle_system.clear() # Clear particles from previous game/game over self.game_state = PLAYING def update(self, dt): self.particle_system.update() # Update particles regardless of state (for menu/game over effects) if self.game_state == PLAYING: moved = self.snake.update(dt) self.food.update(dt) # Update food animation if moved: # Only check collisions after the snake has moved a grid step # Check food collision if self.snake.body[0] == self.food.position: self.score += 1 self.snake.grow_snake() self.play_sound(self.sound_eat) food_center_x, food_center_y = self.food.get_center_pixel() self.particle_system.add_particles(food_center_x, food_center_y, PARTICLE_COUNT_FOOD, self.food.particle_color) self.food.randomize_position(self.snake.body) # Optional: Increase speed slightly # self.snake.move_interval = max(50, self.snake.move_interval * 0.98) # Check game over conditions (self collision) if self.snake.check_collision_self(): self.game_over() elif self.game_state == MENU: # Could add menu-specific animations here pass elif self.game_state == GAME_OVER: # Game over state updates (e.g., particle system already handled) pass def game_over(self): self.game_state = GAME_OVER self.play_sound(self.sound_gameover) if self.score > self.high_score: self.high_score = self.score self.save_high_score() # Save immediately on new high score # Add game over particle effect from snake head head_center_x, head_center_y = self.snake.get_head_center_pixel() self.particle_system.add_particles(head_center_x, head_center_y, PARTICLE_COUNT_GAMEOVER, PARTICLE_COLOR_GAMEOVER, gravity=0.05) # Less gravity for explosion def draw(self): # Draw background first self.ui.draw_background(self.screen) if self.game_state == MENU: self.ui.draw_menu(self.screen, self.menu_selection, self.high_score) self.particle_system.draw(self.screen) # Draw particles if any linger elif self.game_state == PLAYING: self.ui.draw_grid(self.screen) # Draw grid behind game elements self.food.draw(self.screen) # Draw food before snake self.snake.draw(self.screen) self.particle_system.draw(self.screen) # Draw particles on top self.ui.draw_score(self.screen, self.score) self.ui.draw_high_score(self.screen, self.high_score) # Show high score during play elif self.game_state == GAME_OVER: # Draw final game state behind game over screen (optional, can be visually noisy) # self.ui.draw_grid(self.screen) # self.food.draw(self.screen) # Draw food in its last position # self.snake.draw(self.screen) # Draw particles from the game over explosion self.particle_system.draw(self.screen) # Draw game over overlay text (draws its own dark overlay) self.ui.draw_game_over(self.screen, self.score, self.high_score) import pygame import sys from settings import * from game import Game def main(): pygame.init() # Initialize mixer only if sound is enabled if SOUND_ENABLED: try: pygame.mixer.init() print("Pygame mixer initialized.") except pygame.error as e: print(f"Warning: Failed to initialize pygame mixer: {e}. Sound disabled.") # Optionally disable sound globally here if init fails # global SOUND_ENABLED # SOUND_ENABLED = False # Set display mode with flags if needed (e.g., DOUBLEBUF for smoother rendering) screen_flags = 0 # pygame.DOUBLEBUF | pygame.HWSURFACE (can experiment) screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), screen_flags) pygame.display.set_caption("Enhanced Python Snake") # Optional: Set Icon (Create a 32x32 assets/snake_icon.png) try: # Make sure you have an 'assets' folder with 'snake_icon.png' # icon_path = os.path.join('assets', 'snake_icon.png') # if os.path.exists(icon_path): # icon = pygame.image.load(icon_path) # pygame.display.set_icon(icon) # else: # print("Warning: Icon file 'assets/snake_icon.png' not found.") pass # Icon loading commented out for simplicity except Exception as e: print(f"Warning: Could not load icon - {e}") game = Game(screen) game.run() # run() now handles the main loop and exit if __name__ == '__main__': main() 0