Update 'board'

board

@@ -1,78 +1,226 @@
 import sys
+from queue import PriorityQueue
+
 import pygame
 
 screen = []
 objectArray = []
+collisionsMap = []
 
-class Agent:
+
-    def __init__(self, name, xPos, yPos):
+class Position:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def get_moved(self, delta_x, delta_y):
+        return Position(self.x + delta_x, self.y + delta_y)
+
+
+class Object:
+    def __init__(self, name, pos):
         self.name = name
-        self.xPos = xPos
+        self.pos = pos
-        self.yPos = yPos
+
+    def draw(self, square):
+        leftTopX, leftTopY = 50 + self.pos.x * square, 10 + self.pos.y * square
+        pygame.draw.rect(screen, (0, 0, 0), (leftTopX, leftTopY, square, square))
+
+
+def detect_collision(newPos):
+    return collisionsMap[newPos.x][newPos.y]
+
+
+def position_in_grid(pos, gridLength):
+    return 0 <= pos.x < gridLength and 0 <= pos.y < gridLength
+
+
+def movement_allowed(newPos, gridLength):
+    return position_in_grid(newPos, gridLength) and not detect_collision(newPos)
+
+
+class Agent(Object):
+    def __init__(self, name, pos):
+        super().__init__(name, pos)
+
+    def draw(self, square):
+        ## RYSUJEMY AGENTA
+        circleX = 52 + self.pos.x * square
+        circleY = 12 + self.pos.y * square
+
+        truck = pygame.image.load("car.png").convert_alpha()  # tu ścieżka do zdjęcia w tle
+        truck = pygame.transform.scale(truck, (square, square))
+        screen.blit(truck, (circleX, circleY))
+
+    def move(self, event, gridLength):
+        if event.key == pygame.K_LEFT:
+            newPos = self.pos.get_moved(-1, 0)
+            self.move_if_possible(newPos, gridLength)
+        if event.key == pygame.K_RIGHT:
+            newPos = self.pos.get_moved(1, 0)
+            self.move_if_possible(newPos, gridLength)
+        if event.key == pygame.K_UP:
+            newPos = self.pos.get_moved(0, -1)
+            self.move_if_possible(newPos, gridLength)
+        if event.key == pygame.K_DOWN:
+            newPos = self.pos.get_moved(0, 1)
+            self.move_if_possible(newPos, gridLength)
+
+    def move_if_possible(self, newPos, gridLength):
+        if movement_allowed(newPos, gridLength):
+            self.pos = newPos
+
+
+class House(Object):
+    def __init__(self, name, pos):
+        super().__init__(name, pos)
+        self.trash_cans = {
+            "paper": False,
+            "glass": False,
+            "plastic": False,
+            "bio": False
+        }
+
+    def draw(self, square):
+        x = 52 + self.pos.x * square
+        y = 12 + self.pos.y * square
+
+        house = pygame.image.load("house.png").convert_alpha()  # tu ścieżka do zdjęcia w tle
+        house = pygame.transform.scale(house, (square, square))
+        screen.blit(house, (x, y))
+
+
+class Junkyard(Object):
+    def __init__(self, name, pos):
+        super().__init__(name, pos)
+        self.heaps = {
+            "paper": True,
+            "glass": True,
+            "plastic": True,
+            "bio": True
+        }
+
+    def draw(self, square):
+        x = 52 + self.pos.x * square
+        y = 12 + self.pos.y * square
+
+        junkyard = pygame.image.load("junkyard.png").convert_alpha()  # tu ścieżka do zdjęcia w tle
+        junkyard = pygame.transform.scale(junkyard, (square, square))
+        screen.blit(junkyard, (x, y))
+
+
+class Hole(Object):
+    def __init__(self, name, pos):
+        super().__init__(name, pos)
+
+    def draw(self, square):
+        x = 52 + self.pos.x * square
+        y = 12 + self.pos.y * square
+
+        hole = pygame.image.load("hole.png").convert_alpha()  # tu ścieżka do zdjęcia w tle
+        hole = pygame.transform.scale(hole, (square, square))
+        screen.blit(hole, (x, y))
+
 
 def draw(square_num, objectArr):
-    #następne dwie linijki do odkomentowania, jak będzie wgrane zdjęcie do tła
+    # następne dwie linijki do odkomentowania, jak będzie wgrane zdjęcie do tła
-    #background = pygame.image.load("ścieżka do pliku").convert() #tu ścieżka do zdjęcia w tle
+    # background = pygame.image.load("ścieżka do pliku").convert() #tu ścieżka do zdjęcia w tle
-    #screen.blit(background, (0, 0))
+    # screen.blit(background, (0, 0))
-    grid_color = (0, 0, 0) #kolor czarny
+    grid_color = (0, 0, 0)  # kolor czarny
 
-    grid_size = 500  #rozmiar kraty
+    grid_size = 510  # rozmiar kraty
-    square = grid_size/square_num #rozmiar pojedyńczego kwadracika
+    square = grid_size // square_num  # rozmiar pojedyńczego kwadracika
 
     a = 50
-    b = 10  #odległości kraty od krawędzi okna
+    b = 10  # odległości kraty od krawędzi okna
+
+    for o in objectArr:
+        o.draw(square)
 
     for i in range(square_num):
-        pygame.draw.line(screen, grid_color, (a + i*square, b), (a + i*square, b + grid_size), 2)
+        pygame.draw.line(screen, grid_color, (a + i * square, b), (a + i * square, b + grid_size), 2)
 
-        pygame.draw.line(screen, grid_color, (a, b + i*square), (a + grid_size, b + i*square), 2)
+        pygame.draw.line(screen, grid_color, (a, b + i * square), (a + grid_size, b + i * square), 2)
 
     pygame.draw.line(screen, grid_color, (a, b + grid_size), (a + grid_size,
-                     b + grid_size), 2)
+                                                              b + grid_size), 2)
     pygame.draw.line(screen, grid_color, (a + grid_size, b),
                      (a + grid_size, b + grid_size), 2)
 
-    ## tutaj rysujemy agenta i inne obiekty juz na gotowej mapie
-
-    ## RYSUJEMY AGENTA
-    #agent_color = (255, 0, 0)
-    circleX = objectArr[0].xPos * square + square + square/ 2 #dodane jedno +square, by śmieciara nie wychodziła poza kratę
-    circleY = objectArr[0].yPos * square - square / 2
-    #radius = 10
-    #pygame.draw.circle(screen, agent_color, (a + circleX, b + circleY), radius)
-    truck = pygame.image.load("car.png").convert_alpha() #tu ścieżka do zdjęcia w tle
-    truck = pygame.transform.scale(truck, (square, square))
-    screen.blit(truck, (circleX, circleY))
 
 def kb_listen(objectArray, gridLength):
+    agent = objectArray[0]
     for event in pygame.event.get():
         if event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_LEFT and objectArray[0].xPos > 0:
+            agent.move(event, gridLength)
-                objectArray[0].xPos = objectArray[0].xPos - 1
-            if event.key == pygame.K_RIGHT and objectArray[0].xPos < gridLength - 1:
-                objectArray[0].xPos = objectArray[0].xPos + 1
-            if event.key == pygame.K_UP and objectArray[0].yPos > 1:
-                objectArray[0].yPos = objectArray[0].yPos - 1
-            if event.key == pygame.K_DOWN and objectArray[0].yPos < gridLength:
-                objectArray[0].yPos = objectArray[0].yPos + 1
         if event.type == pygame.QUIT:
             sys.exit()
 
 
+#moje
+def manhattan(field1, field2):#nasze punktyNOWE
+    tuple1 = zip(field1, field2)#łączymy xpos1 z xpos2 i ypos1 z ypos2
+    for i, j in tuple1:
+        distance = sum(abs(i - j))#dodajemy wartości bezwzględne różnic x i y
+    return distance
+
+
+class Node:  #prawie jak Field w bfs
+    def __init__(self, state, parent, action):
+        self.state = state  #position - (x, y, direction)
+        self.parent = parent
+        self.action = action
+
+
+def algorithm():
+    opened = PriorityQueue()#może być też lista
+    closed = []#już odwiedzone, odrzucone wierzchołki
+    first_state = (0, 0, "Right")#x, y, kierunek
+    final_state = (14, 14, "Right")
+    starting_point = Node(first_state, False, False)
+    ending_point = Node(final_state, False, False)
+
+    pos1 = (starting_point.state[0], starting_point.state[1])
+    pos2 = (ending_point.state[0], ending_point.state[1])
+
+    opened.put((1, starting_point))
+
+    a = final_state[0]
+    b = final_state[1]
+    hole = Hole("astar", Position(a, b))#narysowana dziura w miejscu mety(celu), by sprawdzić, czy działa
+    objectArray.append(hole)
+
+
 if __name__ == '__main__':
-    pygame.init()  #inicjalizacja modułów, na razie niepotrzebna
+    pygame.init()  # inicjalizacja modułów, na razie niepotrzebna
+    gridSize = 15
+    astar()
 
-    #Tworzymy nowego playera, czy tam agenta
+    # Tworzymy nowego playera, czy tam agenta
-    agent = Agent("smieciarka", 5, 7)
+    agent = Agent("smieciarka", Position(0, 0))
+    junkyard = Junkyard("wysypisko", Position(10, 10))
+    houses = [House(f'dom-{i}', pos) for i, pos in enumerate([Position(x, y) for x, y in [
+        (7, 4), (3, 10), (8, 10), (4, 5), (1, 2), (10, 4), (13, 14), (6, 9)
+    ]])]
+    holes = [Hole(f'dziura-{i}', pos) for i, pos in enumerate([Position(x, y) for x, y in [
+        (4, 9), (5, 11), (11, 7), (13, 8)
+    ]])]
     objectArray.append(agent)
+    objectArray.append(junkyard)
+    objectArray += houses
+    objectArray += holes
 
-    width = 600
+    collisionsMap = [[False] * gridSize for _ in range(gridSize)]
+    for object in objectArray[1:]:
+        collisionsMap[object.pos.x][object.pos.y] = True
+
+    width = 610
     height = 530
-    screen = pygame.display.set_mode((width, height))  #ustalanie rozmiarów okna
+    screen = pygame.display.set_mode((width, height))  # ustalanie rozmiarów okna
 
     while 1:
-        c = (255, 255, 255)  #tymczasowy kolor tła - do usunięcia, jak już będzie zdjęcie
+        c = (255, 255, 255)  # tymczasowy kolor tła - do usunięcia, jak już będzie zdjęcie
         screen.fill(c)
-        draw(15, objectArray)
+        draw(gridSize, objectArray)
-        kb_listen(objectArray, 15)
+        kb_listen(objectArray, gridSize)
-        pygame.display.update()  #by krata pojawiła się w okienku - update powierzchni
+        pygame.display.update()  # by krata pojawiła się w okienku - update powierzc