Edit pathfinding to improve success rate

main.py

@@ -0,0 +1,79 @@
+import pygame
+from snake import Apple, Snake
+from pathfinding import set_path, is_position_safe
+from settings import *
+
+def drawGrid():
+    for x in range(0, WIDTH, BLOCK_SIZE):
+        for y in range(0, HEIGHT, BLOCK_SIZE):
+            rect = pygame.Rect(x, y, BLOCK_SIZE, BLOCK_SIZE)
+            pygame.draw.rect(SCREEN, GRID_CLR, rect, 1)
+
+def handle_events():
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            return False
+    return True
+
+def update(snake, apple):
+    apple.drawApple()
+    path = set_path(snake, apple)
+    if path:
+        snake.go_to(path[0])
+    snake.move()
+
+    pygame.draw.rect(SCREEN, SNAKE_CLR, snake.head)
+
+    for square in snake.body[1:]:
+        if snake.head.x == square.x and snake.head.y == square.y:
+            snake.dead = True
+        if snake.head.x <= -1 or snake.head.x >= WIDTH or snake.head.y <= -1 or snake.head.y >= HEIGHT:
+            snake.dead = True
+    if snake.dead:
+        #main()
+        pygame.time.wait(30000)
+
+    if len(snake.body) < 1:
+        # If snake's body is empty, add a new block after the head
+        new_block = pygame.Rect(snake.head.x, snake.head.y, BLOCK_SIZE, BLOCK_SIZE)
+        snake.body.append(new_block)
+    else:
+        # Draw and update all body segments
+        for square in snake.body:
+            pygame.draw.rect(SCREEN, SNAKE_CLR, square)
+
+    apple_pos = (apple.apple.x, apple.apple.y)
+    if snake.head.x == apple_pos[0] and snake.head.y == apple_pos[1]:
+        apple.spawn()  # Respawn apple
+        while not is_position_safe(snake.body, (apple.apple.x, apple.apple.y)):
+            apple.spawn()
+        # Add a new block after the current head position
+        snake.grow()
+        
+def main():
+    pygame.init()
+    clock = pygame.time.Clock()
+    font = pygame.font.SysFont('timesnewroman', BLOCK_SIZE * 2)
+    score = font.render("1", True, "white")
+    score_rect = score.get_rect(center = (WIDTH / 2, HEIGHT / 20)) # Position score at the top center
+
+    drawGrid()
+
+    snake = Snake()
+    apple = Apple()
+
+    running = True
+    while running:
+        running = handle_events()
+        SCREEN.fill(SURFACE_CLR)
+        drawGrid()
+
+        update(snake, apple)
+                
+        clock.tick(FPS)
+        pygame.display.update()
+
+    pygame.quit()
+
+if __name__ == "__main__":
+    main()

pathfinding.py

@@ -0,0 +1,173 @@
+from settings import *
+from queue import Queue
+from snake import create_duplicate_snake, deepcopy
+from random import randrange
+
+def get_neighbours(position):
+    '''
+    Get neighbouring positions from the current position
+    
+    Args:
+        - position: Tuple representing the current position (x, y)
+    Returns:
+        - List of neighbouring positions
+    '''
+
+    neighbours = [[position[0] + BLOCK_SIZE, position[1]],
+                      [position[0] - BLOCK_SIZE, position[1]],
+                      [position[0], position[1] + BLOCK_SIZE],
+                      [position[0], position[1] - BLOCK_SIZE]]
+    
+    neighbours_within_grid = []
+    for pos in neighbours:
+        if pos in GRID:
+            neighbours_within_grid.append(pos)
+
+    return neighbours_within_grid
+
+def get_available_neighbours(snake, position, apple_pos):
+    valid_neighbours = []
+    neighbours = get_neighbours(position)
+    for neighbour in neighbours:
+        if is_position_available(snake, neighbour) and apple_pos != neighbour:
+            valid_neighbours.append(neighbour)
+    return valid_neighbours
+
+def is_position_available(snake, position):
+    if (0 <= position[0] <= ROWS or 0 <= position[1] <= ROWS) and position not in snake.body:
+        return True
+    return False
+
+def distance(position1, position2):
+    x1, x2 = position1[0], position2[0]
+    y1, y2 = position1[1], position2[1]
+    return abs(x2 - x1) + abs(y2 - y1)
+    
+
+def longest_path_to_tail(snake, apple_pos):
+    neighbours = get_available_neighbours(snake, (snake.head.x, snake.head.y), apple_pos)
+    path = []
+    if neighbours:
+        d = -9999
+        for neighbour in neighbours:
+            tail_pos = (snake.tail.x, snake.tail.y)
+            if distance(neighbour, tail_pos) > d:
+                dup_snake = create_duplicate_snake(snake)
+                dup_snake.go_to(neighbour)
+                dup_snake.move()
+            if dup_snake.head.x == apple_pos[0] and dup_snake.head.y == apple_pos[1]:
+                dup_snake.grow()
+            if path_to_tail(dup_snake):
+                path.append(neighbour)
+                d = distance(neighbour, tail_pos)
+        if path:
+            return [path[-1]]
+        
+def find_safe_move(snake, apple_pos):
+    neighbours = get_available_neighbours(snake, (snake.head.x, snake.head.y), apple_pos)
+    path = []
+    if neighbours:
+        path.append(neighbours[randrange(len(neighbours))])
+        dup_snake = create_duplicate_snake(snake)
+        for move in path:
+            dup_snake.go_to(move)
+            dup_snake.move()
+        if path_to_tail(dup_snake):
+            return path
+        else:
+            return path_to_tail(snake)
+        
+def BFS(start_pos, target_pos, snake_body):
+    '''
+    Perform Breadth-First Search (BFS) to find the shortest path from the snake's head to the apple
+    
+    Args:
+        - start_pos: Tuple representing the starting position (snake's head)
+        - target_pos: Tuple representing the target position (apple)
+        - snake_body: List representing the coordinates of the snake's body
+    Returns:
+        - List representing the sequence of moves to the apple as a list of tuples (coordinates)
+    '''
+    
+    queue = Queue()
+    queue.put((start_pos, [])) # Initialize queue with snake's head position and empty path
+
+    visited = set()
+    visited.add(start_pos)
+
+    while not queue.empty():
+        current_pos, path = queue.get()
+
+        # Return path if apple is found
+        if current_pos == target_pos:
+            return path # Sequence of moves towards the apple
+        
+        # Explore neighbours
+        neighbours = get_neighbours(current_pos)
+        for neighbour in neighbours:
+            if is_position_safe(snake_body, tuple(neighbour)) and tuple(neighbour) not in visited:
+            #if tuple(neighbour) not in snake_body and tuple(neighbour) not in visited:
+                direction = [neighbour[0] - current_pos[0], neighbour[1] - current_pos[1]]
+                visited.add(tuple(neighbour))
+                new_path = path + [tuple(direction)]
+                queue.put((tuple(neighbour), new_path))
+                
+    return [] # If no path is found
+
+def is_position_safe(snake_body, position):
+    if position[0] < 0 or position[0] >= WIDTH or position[1] < 0 or position[1] >= HEIGHT:
+        return False
+    for square in snake_body:
+        if position == (square.x, square.y):
+            return False
+    return True
+
+def set_path(snake, apple):
+    apple_pos = (apple.apple.x, apple.apple.y)
+    snake_head_pos = (snake.head.x, snake.head.y)
+    if snake.score == SNAKE_MAX_LEN - 1 and apple_pos in get_neighbours(snake_head_pos):
+        winning_path = [apple_pos]
+        return winning_path
+    
+    duplicate_snake = create_duplicate_snake(snake)
+    dup_head_pos = (duplicate_snake.head.x, duplicate_snake.head.y)
+
+    initial_path = BFS(dup_head_pos, apple_pos, duplicate_snake.body)
+    secondary_path = []
+    #print(f"Score: {snake.score}")
+    if initial_path:
+        for position in initial_path:
+            duplicate_snake.go_to(position)
+            duplicate_snake.move()
+        duplicate_snake.grow()
+        secondary_path = path_to_tail(duplicate_snake)
+    if secondary_path:
+        #print(f"Initial path: {initial_path}")
+        return initial_path
+    if longest_path_to_tail(snake, apple_pos) and snake.score % 2 == 0:
+        #print(f"Longest Path to Tail: {longest_path_to_tail(snake, apple_pos)}")
+        return longest_path_to_tail(snake, apple_pos)
+    if find_safe_move(snake, apple_pos):
+        #print(f"Find safe move: {find_safe_move(snake, apple_pos)}")
+        return find_safe_move(snake, apple_pos)
+    if path_to_tail(snake):
+        #print(f"Path to tail: {path_to_tail(snake)}")
+        return path_to_tail(snake)
+    print("snake is in danger")
+
+def path_to_tail(snake):
+    body_len = len(snake.body)
+    tail_pos = deepcopy(snake.tail)
+    #print(f"Tail Position: {tail_pos}")
+    if len(snake.body) > 1:
+        snake.tail = snake.body.pop(-1)
+    #print(tail_pos)
+    head_pos = (snake.head.x, snake.head.y)
+    snake_tail_pos = (tail_pos.x, tail_pos.y)
+    path = BFS(head_pos, (snake_tail_pos), snake.body)
+
+    if len(snake.body) < body_len:
+        snake.body.append(snake.tail)
+        snake.tail = snake.body[-1]
+
+    return path

settings.py

@@ -0,0 +1,22 @@
+import pygame
+
+WIDTH = 612
+HEIGHT = 612
+BLOCK_SIZE = 36
+ROWS = WIDTH // BLOCK_SIZE
+GAP_SIZE = 2
+
+# Set up display
+SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Snake")
+
+SURFACE_CLR = (0, 0, 0)
+GRID_CLR = (255, 255, 255)
+SNAKE_CLR = (0, 255, 0)
+APPLE_CLR = (255, 0, 0)
+
+FPS = 5
+INITIAL_SNAKE_LEN = 1
+SNAKE_MAX_LEN = ROWS * ROWS - INITIAL_SNAKE_LEN
+
+GRID = [[x,y] for x in range(0, WIDTH, BLOCK_SIZE) for y in range(0, HEIGHT, BLOCK_SIZE)]

snake.py

@@ -0,0 +1,81 @@
+import random
+from settings import *
+from copy import deepcopy
+
+def create_duplicate_snake(snake):
+    dup_snake = Snake()
+    dup_snake.pos = deepcopy(snake.pos)
+    dup_snake.head = deepcopy(snake.head)
+    dup_snake.body = deepcopy(snake.body)
+    dup_snake.dead = deepcopy(snake.dead)
+    dup_snake.tail = deepcopy(snake.tail)
+    return dup_snake
+
+class Snake:
+    def __init__(self):
+        # Initialize the snake at the center of the screen
+        self.x, self.y = 0, 0
+        self.pos = [1, 0] # [x, y] direction, initially set to right
+        self.head = pygame.Rect(self.x, self.y, BLOCK_SIZE, BLOCK_SIZE)
+        self.body = [] # List to keep track of snake's body segments
+        self.dead = False
+        if self.body:
+            self.tail = self.body[-1]
+        else:
+            self.tail = self.head
+        self.score = 0
+
+    def drawSnake(self):
+        pygame.draw.rect(SCREEN, SNAKE_CLR, self.head)
+        for segment in self.body:
+            pygame.draw.rect(SCREEN, SNAKE_CLR, segment)
+
+    def go_to(self, position):
+        if position[0] > 0 and self.pos != [-1, 0]:
+            self.pos = [1, 0]
+        elif position[0] < 0 and self.pos != [1, 0]:
+            self.pos = [-1, 0]
+        elif position[1] > 0 and self.pos != [0, 1]:
+            self.pos = [0, 1]
+        elif position[1] < 0 and self.pos != [0, -1]:
+            self.pos = [0, -1]
+    
+    def move(self):
+        new_head = self.head.copy()
+        new_head.x += self.pos[0] * BLOCK_SIZE
+        new_head.y += self.pos[1] * BLOCK_SIZE
+
+        if self.body:
+            self.body.insert(0, new_head)
+            self.head = self.body[0]
+        else:
+            self.head = new_head
+
+        if not self.dead and self.body:
+            self.body.pop()
+
+    def grow(self):
+        self.score += 1
+        new_block = pygame.Rect(self.head.x, self.head.y, BLOCK_SIZE, BLOCK_SIZE)
+        self.body.insert(0, new_block)
+
+class Apple:
+    def __init__(self):
+        self.spawn()
+
+    def spawn(self):
+        ''' Spawn a new apple on the screen at a random position '''
+        # Randomly spawn apple
+        self.x = random.randrange(0, WIDTH, BLOCK_SIZE)
+        self.y = random.randrange(0, HEIGHT, BLOCK_SIZE)
+        self.apple = pygame.Rect(self.x, self.y, BLOCK_SIZE, BLOCK_SIZE)
+    
+    def drawApple(self):
+        pygame.draw.rect(SCREEN, APPLE_CLR, self.apple)
+
+    def checkSpawn(self, snake):
+        ''' Check if the apple collides with the snake. If so, respawn the apple. '''
+        for square in snake.body:
+            if self.apple.colliderect(square):
+                self.spawn() # Respawn apple if it collides with snake
+                #snake.grow()

test_snake.py

@@ -0,0 +1,95 @@
+import unittest
+import pygame
+from snake import Snake, Apple  # Make sure the Snake and Apple classes are imported correctly
+from settings import *
+
+class TestSnakeGame(unittest.TestCase):
+    
+    def setUp(self):
+        pygame.init()
+        self.snake = Snake()
+        self.apple = Apple()
+
+    def tearDown(self):
+        pygame.quit()
+
+    def test_initial_state(self):
+        # Test initial snake position
+        self.assertEqual(self.snake.head.x, 0)
+        self.assertEqual(self.snake.head.y, 0)
+        # Test initial snake length
+        self.assertEqual(len(self.snake.body), 0)
+
+    def test_movement(self):
+        # Test snake movement to the right
+        self.snake.pos = [1, 0]
+        self.snake.drawSnake()
+        self.assertEqual(self.snake.head.x, BLOCK_SIZE)
+        self.assertEqual(self.snake.head.y, 0)
+
+        # Test snake movement left
+        self.snake.pos = [-1, 0]
+        self.snake.drawSnake()
+        self.assertEqual(self.snake.head.x, 0)
+        self.assertEqual(self.snake.head.y, 0)
+
+        # Test snake movement downwards
+        self.snake.pos = [0, -1]
+        self.snake.drawSnake()
+        self.assertEqual(self.snake.head.x, 0)
+        self.assertEqual(self.snake.head.y, -50)
+
+        # Test snake movement upwards
+        self.snake.pos = [0, 1]
+        self.snake.drawSnake()
+        self.assertEqual(self.snake.head.x, 0)
+        self.assertEqual(self.snake.head.y, 0)
+
+    def test_apple_spawn(self):
+        # Test apple spawning within the grid
+        self.apple.spawn()
+        self.assertTrue(0 <= self.apple.apple.x < WIDTH)
+        self.assertTrue(0 <= self.apple.apple.y < HEIGHT)
+        self.assertEqual(self.apple.apple.width, BLOCK_SIZE)
+        self.assertEqual(self.apple.apple.height, BLOCK_SIZE)
+
+    def test_eating_apple(self):
+        # Place apple directly in front of the snake
+        self.apple.apple.x = self.snake.head.x + BLOCK_SIZE
+        self.apple.apple.y = self.snake.head.y
+        self.snake.pos = [1, 0]
+        self.snake.drawSnake()
+
+        # Simulate snake eating the apple
+        if self.snake.head.colliderect(self.apple.apple):
+            self.snake.body.append(pygame.Rect(self.snake.head.x, self.snake.head.y, BLOCK_SIZE, BLOCK_SIZE))
+            self.apple.spawn()
+
+        self.assertEqual(len(self.snake.body), 1)
+        self.assertNotEqual((self.apple.apple.x, self.apple.apple.y), (self.snake.head.x, self.snake.head.y))
+
+    def test_collision_with_wall(self):
+        # Move snake to the right until it hits the wall
+        self.snake.pos = [-1, 0]
+        self.snake.drawSnake()
+        self.snake.pos = [-1, 0]
+        self.snake.drawSnake()
+        self.assertTrue(self.snake.dead)
+
+    def test_collision_with_self(self):
+        # Create a situation where the snake will collide with itself
+        self.snake.body = [
+            pygame.Rect(WIDTH / 2, HEIGHT / 2, BLOCK_SIZE, BLOCK_SIZE),
+            pygame.Rect(WIDTH / 2 - BLOCK_SIZE, HEIGHT / 2, BLOCK_SIZE, BLOCK_SIZE),
+            pygame.Rect(WIDTH / 2 - 2 * BLOCK_SIZE, HEIGHT / 2, BLOCK_SIZE, BLOCK_SIZE)
+        ]
+        self.snake.pos = [1, 0]
+        self.snake.drawSnake()  # Move right
+        self.snake.pos = [0, -1]
+        self.snake.drawSnake()  # Move up
+        self.snake.pos = [-1, 0]
+        self.snake.drawSnake()  # Move left (collide with body)
+        self.assertTrue(self.snake.dead)
+
+if __name__ == '__main__':
+    unittest.main()