Sucssessfully implemented A* algorithm on the ghosts

2 files changed, 51 insertions, 103 deletions

diff --git a/src/Game.py b/src/Game.py
index a69ad84..19901a6 100644
--- a/src/Game.py
+++ b/src/Game.py
@@ -25,7 +25,10 @@ class Game():
             '../assets/pacman_left_sprite.png').convert_alpha()
 
         player = Player.Player(sprite_sheet)
-        ghost = Ghost.Ghost()
+        inky = Ghost.Ghost("green", 75, 75)
+        pinky = Ghost.Ghost("cyan", 27 * 30, 30 * 30 + 15)
+        clyde = Ghost.Ghost("red", 27 * 30 + 15, 75)
+        winky = Ghost.Ghost("purple", 75, 30 * 30 + 15)
 
         # Set the pacman velocity
         dx = 0
@@ -149,10 +152,16 @@ class Game():
                 player.y += dy
 
 
-            ghost.move(maze.maze, (player.x, player.y))
+            inky.move(maze.maze, (player.x, player.y))
+            pinky.move(maze.maze, (player.x, player.y))
+            winky.move(maze.maze, (player.x, player.y))
+            clyde.move(maze.maze, (player.x, player.y))
             maze.draw_map(screen)
             player.draw(screen, counter)
-            ghost.draw(screen)
+            inky.draw(screen)
+            pinky.draw(screen)
+            winky.draw(screen)
+            clyde.draw(screen)
 
             # Update the screen
             pygame.display.flip()
diff --git a/src/Ghost.py b/src/Ghost.py
index 2477bfa..11c195b 100644
--- a/src/Ghost.py
+++ b/src/Ghost.py
@@ -6,11 +6,11 @@ import map as Map
 import random
 
 class Ghost():
-    def __init__(self):
-        self.x = 75
-        self.y = 75
-        self.tx = 0
-        self.ty = 0
+    def __init__(self, color, x, y):
+        self.x = x
+        self.y = y
+        self.color = color
+        self.last_move = 3
         self.speed = 3
 
     def heuristic(self, pacman_pos, next_pos):
@@ -32,84 +32,53 @@ class Ghost():
         direct_x = [1, 0, -1, 0, 1, 1, -1, -1]
         direct_y = [0, 1, 0, -1, -1, 1, -1, 1]
 
-        # print(f"nx: {nx}, ny: {ny}")
-        # print()
-
-        # print(maze[3][13], self.is_valid(maze, 13, 3))
-        print()
-        if nx == 391 and ny == 79:
-            print("----------------------")
 
         for i in range(len(direct_x)):
             px = nx + direct_x[i] * 14
             py = ny + direct_y[i] * 14
-            print(px, py)
             x = px // gx
             y = py // gy
-            # print(f"x: {x}, y: {y} is_valid({x}, {y}) = {self.is_valid(maze, x, y)}")
             if not self.is_valid(maze, x, y):
                 return False
 
         return True
 
-    def get_possible_moves(self, maze):
-        possible_directions = {}
-
-        up    = (0, -self.speed)
-        down  = (0, self.speed)
-        right = (self.speed, 0)
-        left  = (-self.speed, 0)
-
-        if self.check_collision(up[0], up[1], 30, 30, maze):
-            possible_directions[up] = DIRECTION.UP
-        if self.check_collision(down[0], down[1], 30, 30, maze):
-            possible_directions[down] = DIRECTION.DOWN
-        if self.check_collision(right[0], right[1], 30, 30, maze):
-            possible_directions[right] = DIRECTION.RIGHT
-        if self.check_collision(left[0], left[1], 30, 30, maze):
-            possible_directions[left] = DIRECTION.LEFT
-
-        return possible_directions
-        
-
-    # def get_next_move(self, pacman_pos, maze):
-    #     possible_directions = self.get_possible_moves(maze)
-    #
-    #     next_move = DIRECTION.RIGHT
-    #     mn = 1000000 # really big number
-    #
-    #     for pos, dir in possible_directions.items():
-    #         h = self.heuristic(pacman_pos, pos)
-    #         if h < mn:
-    #             mn = h
-    #             print("dir: ", dir)
-    #             next_move = dir
-    #
-    #     print("Min h:", mn)
-    #     # print("Left: ", self.heuristic(pacman_pos))
-    #     print("Best: next_move", next_move)
-    #     return next_move
-
 
     def get_next_move(self, pacman_pos, maze):
         dx = [1, 0, -1, 0]
         dy = [0, 1, 0, -1]
 
-
         ret = len(dx) * [math.inf]
+
+        forbidden = 0
+
+        if self.last_move == 0:
+            forbidden = 2
+        if self.last_move == 1:
+            forbidden = 3
+        if self.last_move == 2:
+            forbidden = 0
+        if self.last_move == 3:
+            forbidden = 1
+
         
         for i in range(len(dx)):
-            nx = self.x + dx[i] * self.speed
-            ny = self.y + dy[i] * self.speed
-            if self.check_collision(nx, ny, 30, 30, maze):
-                ret[i] = self.heuristic((nx, ny), pacman_pos)
+            if i != forbidden:
+                nx = self.x + dx[i] * self.speed
+                ny = self.y + dy[i] * self.speed
+                if self.check_collision(nx, ny, 30, 30, maze):
+                    ret[i] = self.heuristic((nx, ny), pacman_pos)
 
+        print("--------------------")
 
         min_idx = ret.index(min(ret))
-        # if min_idx == 1:
-        #     print(f"({self.x}, {self.y})")
-        #     print(self.check_collision(391, 79, 30, 30, maze))
-        return (dx[min_idx] * self.speed, dy[min_idx] * self.speed)
+        print(f"last_move: {self.last_move}, current_move: {min_idx}")
+        x1 = self.x + dx[2] * self.speed
+        y1 = self.y + dy[2] * self.speed
+        x2 = self.x + dx[0] * self.speed
+        y2 = self.y + dy[0] * self.speed
+        print(f"hl = {self.heuristic((x1, y1), pacman_pos)}, h2 = {self.heuristic((x2, y2), pacman_pos)}")
+        return min_idx
 
 
 
@@ -118,48 +87,18 @@ class Ghost():
 
 
     def move(self, maze, player_pos):
-        next_move = self.get_next_move(player_pos, maze)
-
-        dx = 0
-        dy = 0
-
-        self.x += next_move[0]
-        self.y += next_move[1]
-
-        # if next_move == DIRECTION.UP:
-        #     self.ty = -self.speed
-        #     self.tx = 0
-        # elif next_move == DIRECTION.DOWN:
-        #     self.ty = self.speed
-        #     self.tx = 0
-        # elif next_move == DIRECTION.RIGHT:
-        #     self.tx = self.speed
-        #     self.ty = 0
-        # elif next_move == DIRECTION.LEFT:
-        #     self.tx = -self.speed
-        #     self.ty = 0
-        #
-        #
-        # if self.check_collision(self.tx, self.ty, 30, 30, maze):
-        #     dx = self.tx
-        #     dy = self.ty
-        #
-        # if dx < 0:
-        #     self.direction = DIRECTION.LEFT
-        # elif dx > 0:
-        #     self.direction = DIRECTION.RIGHT
-        # elif dy < 0:
-        #     self.direction = DIRECTION.UP
-        # elif dy > 0:
-        #     self.direction = DIRECTION.DOWN
-        #
-        # if self.check_collision(dx, dy, 30, 30, maze):
-        #     self.x += dx
-        #     self.y += dy
+        min_idx = self.get_next_move(player_pos, maze)
+        dx = [1, 0, -1, 0]
+        dy = [0, 1, 0, -1]
+        new_dx = dx[min_idx] * self.speed
+        new_dy = dy[min_idx] * self.speed
+        self.x += new_dx
+        self.y += new_dy
+        self.last_move = min_idx
 
     def draw(self, screen):
         radius = 30 // 2
         pos = (self.x , self.y)
-        pygame.draw.circle(screen, 'green', pos, radius)
+        pygame.draw.circle(screen, self.color, pos, radius)