The user wants Python code for a Snake game. Let me write a complete, working Snake game using pygame, which is the most common library for this. I should: 1. Create a complete, functional Snake game 2. Include proper game mechanics (snake movement, food eating, collision detection, growing) 3. Add a score system 4. Include game over conditions 5. Add restart functionality 6. Make the code well-commented and organized Let me write a clean pygame implementation: Key features to include: - Snake movement with arrow keys - Food spawning at random locations - Score tracking - Collision detection (walls and self) - Game over screen - Restart option - Nice visuals (grid, colors) Let me write the code: ```python import pygame import random import sys # Initialize pygame pygame.init() # Constants WIDTH = 600 HEIGHT = 400 CELL_SIZE = 20 GRID_WIDTH = WIDTH // CELL_SIZE GRID_HEIGHT = HEIGHT // CELL_SIZE # Colors BLACK = (0, 0, 0) GREEN = (0, 255, 0) DARK_GREEN = (0, 200, 0) RED = (255, 0, 0) WHITE = (255, 255, 255) GRAY = (40, 40, 40) # Directions UP = (0, -1) DOWN = (0, 1) LEFT = (-1, 0) RIGHT = (1, 0) # Set up display screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Snake Game") clock = pygame.time.Clock() font = pygame.font.SysFont("arial", 25) big_font = pygame.font.SysFont("arial", 40) class Snake: def __init__(self): self.body = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)] self.direction = RIGHT self.grow = False def change_direction(self, new_dir): # Prevent reversing into itself if (new_dir[0] * -1, new_dir[1] * -1) != self.direction: self.direction = new_dir def move(self): head = self.body[0] new_head = (head[0] + self.direction[0], head[1] + self.direction[1]) self.body.insert(0, new_head) if self.grow: self.grow = False else: self.body.pop() def check_collision(self): head = self.body[0] # Wall collision if head[0] < 0 or head[0] >= GRID_WIDTH or head[1] < 0 or head[1] >= GRID_HEIGHT: return True # Self collision if head in self.body[1:]: return True return False def draw(self, surface): for i, segment in enumerate(self.body): x = segment[0] * CELL_SIZE y = segment[1] * CELL_SIZE color = GREEN if i == 0 else DARK_GREEN rect = pygame.Rect(x, y, CELL_SIZE, CELL_SIZE) pygame.draw.rect(surface, color, rect) pygame.draw.rect(surface, BLACK, rect, 1) class Food: def __init__(self, snake): self.spawn(snake) def spawn(self, snake): while True: pos = (random.randint(0, GRID_WIDTH - 1), random.randint(0, GRID_HEIGHT - 1)) if pos not in snake.body: self.pos = pos break def draw(self, surface): x = self.pos[0] * CELL_SIZE y = self.pos[1] * CELL_SIZE rect = pygame.Rect(x, y, CELL_SIZE, CELL_SIZE) pygame.draw.rect(surface, RED, rect) def draw_grid(surface): for x in range(0, WIDTH, CELL_SIZE): pygame.draw.line(surface, GRAY, (x, 0), (x, HEIGHT)) for y in range(0, HEIGHT, CELL_SIZE): pygame.draw.line(surface, GRAY, (0, y), (WIDTH, y)) def show_text(surface, text, font, color, center): text_surface = font.render(text, True, color) rect = text_surface.get_rect(center=center) surface.blit(text_surface, rect) def game_loop(): snake = Snake() food = Food(snake) score = 0 while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_UP: snake.change_direction(UP) elif event.key == pygame.K_DOWN: snake.change_direction(DOWN) elif event.key == pygame.K_LEFT: snake.change_direction(LEFT) elif event.key == pygame.K_RIGHT: snake.change_direction(RIGHT) snake.move() # Check if food eaten if snake.body[0] == food.pos: snake.grow = True score += 1 food.spawn(snake) # Check collision if snake.check_collision(): return score # Draw screen.fill(BLACK) draw_grid(screen) food.draw(screen) snake.draw(screen) # Draw score score_text = font.render(f"Score: {score}", True, WHITE) screen.blit(score_text, (10, 10)) pygame.display.flip() clock.tick(10) # Game speed def main(): while True: score = game_loop() # Game over screen game_over = True while game_over: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE or event.key == pygame.K_RETURN: game_over = False if event.key == pygame.K_ESCAPE: pygame.quit() sys.exit() screen.fill(BLACK) show_text(screen, "GAME OVER", big_font, RED, (WIDTH // 2, HEIGHT // 2 - 30)) show_text(screen, f"Score: {score}", font, WHITE, (WIDTH // 2, HEIGHT // 2 + 20)) show_text(screen, "Press SPACE to restart, ESC to quit", font, WHITE, (WIDTH // 2, HEIGHT // 2 + 60)) pygame.display.flip() if __name__ == "__main__": main() ``` This looks good. Let me review it for bugs: 1. Snake starts at center, moves right 2. Direction change prevents 180-degree turns 3. Food spawns at random location not on snake 4. Score increments when food eaten 5. Game over on wall or self collision 6. Game over screen with restart One issue: in `change_direction`, if the snake has only one segment, reversing is fine, but the check `(new_dir[0] * -1, new_dir[1] * -1) != self.direction` correctly prevents reversal. Actually for a 1-segment snake it's still safer to prevent it. Another edge case: if the snake body is length 1 and you press the opposite direction quickly, could cause issues but the check handles it. Wait, there's a subtle bug: if the player presses two keys quickly in one frame (e.g., moving right, press UP then LEFT in the same frame), the snake could reverse. But with a snake of length > 1, the direction check handles it since each check is against the current direction. Actually no — if moving RIGHT and pressing UP then LEFT, after UP the direction becomes UP, then LEFT is allowed (LEFT is not opposite of UP), so snake moves up then left in successive frames — that's fine actually. The bug would be pressing DOWN then... no, actually the classic bug: moving RIGHT, press UP, then LEFT in same frame. After UP is processed, direction is UP. Then LEFT is checked against UP — LEFT is not opposite of UP, so direction becomes LEFT. Snake moves LEFT... but snake was moving RIGHT! That would cause self-collision. To handle this properly, I should track the direction at the time of movement. One common fix is to queue directions or check against the actual last movement direction. A simple fix: only allow one direction change per frame, or check against the previous direction before the last input. Actually the simplest robust approach: maintain the direction used in the last move, and check new directions against that, applying at most... hmm, actually the issue is that multiple key presses in one frame can accumulate. A simple fix is to process only the direction changes but validate against the direction the snake actually moved last. Let me restructure: keep `self.direction` as the last applied direction, and when changing, compare against the direction that will be used this frame. The problem is events happen between frames. Actually a cleaner fix: store pending direction changes and validate them sequentially, or just limit to one change per event loop iteration... Actually the standard simple fix is to check the new direction against the snake's actual movement direction at move time, and reject reversal at move time. But then the visual behavior might be odd. For a simple game, the double-press-in-one-frame bug is rare and mostly an edge case. But let me handle it properly anyway with a small tweak — process key events but validate against `self.direction` which only updates after movement... Hmm. Simplest robust approach: use a queue of directions. On keydown, append to queue if valid against the last queued direction (or current direction if queue empty). In move(), pop from the queue. Let me implement that: ```python class Snake: def __init__(self): self.body = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)] self.direction = RIGHT self.next_directions = [] self.grow = False def change_direction(self, new_dir): last = self.next_directions[-1] if self.next_directions else self.direction if (new_dir[0] * -1, new_dir[1] * -1) != last and new_dir != last: if len(self.next_directions) < 2: self.next_directions.append(new_dir) def move(self): if self.next_directions: self.direction = self.next_directions.pop(0) head = self.body[0] new_head = (head[0] + self.direction[0], head[1] + self.direction[1]) self.body.insert(0, new_head) if self.grow: self.grow = False else: self.body.pop() ``` This handles the input queue properly. This is a nicer implementation. Also, I could add wrap-around option or increasing speed as score increases. Let me add speed increase for fun: ```python speed = 10 + min(score, 15) # increases with score clock.tick(speed) ``` That's a nice touch. Or keep it simple. I'll add mild speed scaling. Also I should mention installation: `pip install pygame`. Let me also make sure the food drawing looks nice — maybe draw a circle instead of a square for food. And maybe eyes on the snake head? Keep it reasonably simple but polished. Format considerations: The user asked for Python code for a snake game. I should provide: 1. A brief intro mentioning pygame requirement 2. The complete code in a code block 3. Brief instructions on how to run and controls 4. Maybe a short list of features The code should be the bulk of the response. I shouldn't over-explain. Use markdown code blocks since this is likely rendered. Keep surrounding text concise. Let me finalize the code: ```python import pygame import random import sys # ---------- Setup ---------- pygame.init() CELL_SIZE = 20 GRID_WIDTH = 30 GRID_HEIGHT = 20 WIDTH = GRID_WIDTH * CELL_SIZE HEIGHT = GRID_HEIGHT * CELL_SIZE # Colors BLACK = (15, 15, 15) GRAY = (35, 35, 35) GREEN = (0, 220, 80) DARK_GREEN = (0, 160, 60) RED = (230, 60, 60) WHITE = (240, 240, 240) # Directions (dx, dy) UP = (0, -1) DOWN = (0, 1) LEFT = (-1, 0) RIGHT = (1, 0) screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Snake") clock = pygame.time.Clock() font = pygame.font.SysFont("consolas", 24) big_font = pygame.font.SysFont("consolas", 48, bold=True) class Snake: def __init__(self): start = (GRID_WIDTH // 2, GRID_HEIGHT // 2) self.body = [start] self.direction = RIGHT self.pending = [] # queued direction changes self.grow = False def queue_direction(self, new_dir): last = self.pending[-1] if self.pending else self.direction opposite = (new_dir[0] * -1, new_dir[1] * -1) if opposite != last and new_dir != last and len(self.pending) < 2: self.pending.append(new_dir) def move(self): if self.pending: self.direction = self.pending.pop(0) head = self.body[0] new_head = (head[0] + self.direction[0], head[1] + self.direction[1]) self.body.insert(0, new_head) if self.grow: self.grow = False else: self.body.pop() def hit_wall(self): head = self.body[0] return (head[0] < 0 or head[0] >= GRID_WIDTH or head[1] < 0 or head[1] >= GRID_HEIGHT) def hit_self(self): return self.body[0] in self.body[1:] def draw(self, surface): for i, (gx, gy) in enumerate(self.body): rect = pygame.Rect(gx * CELL_SIZE, gy * CELL_SIZE, CELL_SIZE, CELL_SIZE) color = GREEN if i == 0 else DARK_GREEN pygame.draw.rect(surface, color, rect.inflate(-2, -2), border_radius=4) class Food: def __init__(self, snake): self.respawn(snake) def respawn(self, snake): occupied = set(snake.body) while True: pos = (random.randrange(GRID_WIDTH), random.randrange(GRID_HEIGHT)) if pos not in occupied: self.pos = pos return def draw(self, surface): center = (self.pos[0] * CELL_SIZE + CELL_SIZE // 2, self.pos[1] * CELL_SIZE + CELL_SIZE // 2) pygame.draw.circle(surface, RED, center, CELL_SIZE // 2 - 2) def draw_grid(surface): for x in range(0, WIDTH, CELL_SIZE): pygame.draw.line(surface, GRAY, (x, 0), (x, HEIGHT)) for y in range(0, HEIGHT, CELL_SIZE): pygame.draw.line(surface, GRAY, (0, y), (WIDTH, y)) def centered_text(surface, text, fnt, color, y_offset=0): rendered = fnt.render(text, True, color) rect = rendered.get_rect(center=(WIDTH // 2, HEIGHT // 2 + y_offset)) surface.blit(rendered, rect) def play(): """Runs one game; returns the final score.""" snake = Snake() food = Food(snake) score = 0 while True: # --- Events --- for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: if event.key in (pygame.K_UP, pygame.K_w): snake.queue_direction(UP) elif event.key in (pygame.K_DOWN, pygame.K_s): snake.queue_direction(DOWN) elif event.key in (pygame.K_LEFT, pygame.K_a): snake.queue_direction(LEFT) elif event.key in (pygame.K_RIGHT, pygame.K_d): snake.queue_direction(RIGHT) # --- Update --- snake.move() if snake.body[0] == food.pos: snake.grow = True score += 1 food.respawn(snake) if snake.hit_wall() or snake.hit_self(): return score # --- Draw --- screen.fill(BLACK) draw_grid(screen) food.draw(screen) snake.draw(screen) screen.blit(font.render(f"Score: {score}", True, WHITE), (10, 10)) pygame.display.flip() # Speed up slightly as score grows clock.tick(8 + min(score, 12)) def game_over_screen(score): while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: if event.key in (pygame.K_SPACE, pygame.K_RETURN): return if event.key == pygame.K_ESCAPE: pygame.quit() sys.exit() screen.fill(BLACK) centered_text(screen, "GAME OVER", big_font, RED, -40) centered_text(screen, f"Score: {score}", font, WHITE, 10) centered_text(screen, "SPACE = play again | ESC = quit", font, WHITE, 50) pygame.display.flip() clock.tick(30) def main(): while True: score = play() game_over_screen(score) if __name__ == "__main__": main() ``` Wait, in `hit_self` when the snake grows, the tail doesn't pop, so the new head could equal... let me think. If snake grows: body.insert(0, new_head), no pop. Then body[0] in body[1:] — new_head would only be in body[1:] if the snake moved into itself. With growth, moving into the tail cell that was just "kept" — e.g., snake body [(5,5),(5,6)], moving down to (5,6) would be a collision. That's correct behavior — the head can't occupy the same cell as any body segment. Standard. One edge: when the snake is length 1... snake = [(x,y)], moves to new cell, pops tail, so body has 1 segment, hit_self checks body[0] in body[1:] = [] → False. Good. Also note the food could spawn... it avoids snake body. Good. The grid: 30x20 grid with 20px cells = 600x400 window. Good. Speed: starts at 8 fps... that's a bit slow. Maybe 10 base. clock.tick(10) means 10 frames per second → snake moves 10 cells/sec. That's reasonable for a starting snake. Let me use `clock.tick(10 + min(score, 10))`. WASD support is a nice addition. Let me also double check `queue_direction`: prevents 180 turns and duplicates. Good. Font: "consolas" should exist on Windows; on other systems SysFont falls back to default if not found. Fine. I should mention: `pip install pygame` before running. Format: Brief intro line, code block, then short "How to run" and controls, features list maybe. Keep it tight. The response is mostly code which is appropriate. I'll add a features/controls section briefly. No need for extensive explanation of every function. Here's a complete Snake game using pygame: ```python import pygame import random import sys # ---------- Setup ---------- pygame.init() CELL_SIZE = 20 GRID_WIDTH = 30 GRID_HEIGHT = 20 WIDTH = GRID_WIDTH * CELL_SIZE HEIGHT = GRID_HEIGHT * CELL_SIZE # Colors BLACK = (15, 15, 15) GRAY = (35, 35, 35) GREEN = (0, 220, 80) DARK_GREEN = (0, 160, 60) RED = (230, 60, 60) WHITE = (240, 240, 240) # Directions (dx, dy) UP, DOWN, LEFT, RIGHT = (0, -1), (0, 1), (-1, 0), (1, 0) screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Snake") clock = pygame.time.Clock() font = pygame.font.SysFont("consolas", 24) big_font = pygame.font.SysFont("consolas", 48, bold=True) class Snake: def __init__(self): self.body = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)] self.direction = RIGHT self.pending = [] # queued direction changes (prevents instant reversal) self.grow = False def queue_direction(self, new_dir): last = self.pending[-1] if self.pending else self.direction opposite = (new_dir[0] * -1, new_dir[1] * -1) if opposite != last and new_dir != last and len(self.pending) < 2: self.pending.append(new_dir) def move(self): if self.pending: self.direction = self.pending.pop(0) head = self.body[0] new_head = (head[0] + self.direction[0], head[1] + self.direction[1]) self.body.insert(0, new_head) if self.grow: self.grow = False else: self.body.pop() def hit_wall(self): head = self.body[0] return (head[0] < 0 or head[0] >= GRID_WIDTH or head[1] < 0 or head[1] >= GRID_HEIGHT) def hit_self(self): return self.body[0] in self.body[1:] def draw(self, surface): for i, (gx, gy) in enumerate(self.body): rect = pygame.Rect(gx * CELL_SIZE, gy * CELL_SIZE, CELL_SIZE, CELL_SIZE) color = GREEN if i == 0 else DARK_GREEN pygame.draw.rect(surface, color, rect.inflate(-2, -2), border_radius=4) class Food: def __init__(self, snake): self.respawn(snake) def respawn(self, snake): occupied = set(snake.body) while True: pos = (random.randrange(GRID_WIDTH), random.randrange(GRID_HEIGHT)) if pos not in occupied: self.pos = pos return def draw(self, surface): center = (self.pos[0] * CELL_SIZE + CELL_SIZE // 2, self.pos[1] * CELL_SIZE + CELL_SIZE // 2) pygame.draw.circle(surface, RED, center, CELL_SIZE // 2 - 2) def draw_grid(surface): for x in range(0, WIDTH, CELL_SIZE): pygame.draw.line(surface, GRAY, (x, 0), (x, HEIGHT)) for y in range(0, HEIGHT, CELL_SIZE): pygame.draw.line(surface, GRAY, (0, y), (WIDTH, y)) def centered_text(surface, text, fnt, color, y_offset=0): rendered = fnt.render(text, True, color) rect = rendered.get_rect(center=(WIDTH // 2, HEIGHT // 2 + y_offset)) surface.blit(rendered, rect) def play(): """Runs one full game and returns the final score.""" snake = Snake() food = Food(snake) score = 0 while True: # --- Events --- for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: if event.key in (pygame.K_UP, pygame.K_w): snake.queue_direction(UP) elif event.key in (pygame.K_DOWN, pygame.K_s): snake.queue_direction(DOWN) elif event.key in (pygame.K_LEFT, pygame.K_a): snake.queue_direction(LEFT) elif event.key in (pygame.K_RIGHT, pygame.K_d): snake.queue_direction(RIGHT) # --- Update --- snake.move() if snake.body[0] == food.pos: snake.grow = True score += 1 food.respawn(snake) if snake.hit_wall() or snake.hit_self(): return score # --- Draw --- screen.fill(BLACK) draw_grid(screen) food.draw(screen) snake.draw(screen) screen.blit(font.render(f"Score: {score}", True, WHITE), (10, 10)) pygame.display.flip() # Speed up slightly as score grows clock.tick(10 + min(score, 10)) def game_over_screen(score): while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: if event.key in (pygame.K_SPACE, pygame.K_RETURN): return if event.key == pygame.K_ESCAPE: pygame.quit() sys.exit() screen.fill(BLACK) centered_text(screen, "GAME OVER", big_font, RED, -40) centered_text(screen, f"Score: {score}", font, WHITE, 10) centered_text(screen, "SPACE = play again | ESC = quit", font, WHITE, 50) pygame.display.flip() clock.tick(30) def main(): while True: score = play() game_over_screen(score) if __name__ == "__main__": main() ``` **How to run:** 1. Install pygame: `pip install pygame` 2. Save the code as `snake.py` and run: `python snake.py` **Controls:** - Arrow keys or WASD to move - SPACE/ENTER to restart after game over - ESC to quit **Features:** - Snake grows and score increases when eating food - Game over on wall or self collision - Speed gradually increases with your score - Input buffering so quick key presses don't cause instant self-collision Want me to add anything, like a high-score tracker, sound effects, or wrap-around walls (snake passes through edges)?

write python code to make snake game