movement done

Signed-off-by: Neerka <kuba.markil0220@gmail.com>

classes/Garbagetruck.py

@@ -1,5 +1,10 @@
+import math
+import random
+
 import pygame
 from classes.Household import *
+from classes.Node import *
+from classes.Trashcan import Trashcan
 
 
 class Garbagetruck:
@@ -27,6 +32,24 @@ class Garbagetruck:
         self.orientation = 3  # Niech numery będą tak: N - 0, W - 1, S - 2, E - 3  -- po prostu odwrotnie do zegara
         self.runningtime = 0
         self.movesequence = []
+        self.target = None
+
+    def getState(self):
+        return self.state
+
+    def setMovesequence(self, movesequence):
+        self.movesequence = movesequence
+        return self
+
+    def setTarget(self):
+        for place in self.houses:
+            if place.getFinal():
+                self.target = place
+                return
+        for place in self.trashcans:
+            if place.getFinal():
+                self.target = place
+                return
 
     def getOrientation(self):
         return self.orientation
@@ -100,7 +123,8 @@ class Garbagetruck:
     def modPosiotion(self, modX, modY):
         x = self.getPosition()[0] + modX
         y = self.getPosition()[1] + modY
-        self.setPosition([x, y])
+        position = [x, y]
+        self.setPosition(position)
 
     def getRoute(self):
         return self.route
@@ -133,21 +157,25 @@ class Garbagetruck:
         dist = abs(lok1[0] - lok2[0]) + abs(lok1[1] - lok2[1])
         return dist
 
-    def selfdistance(self, target) -> int:
+    def selfdistance(self, target):
-        lok = target.getPosition()
+        if isinstance(target, (Trashcan, Household)):
-        own = self.getPosition()
+            lok = target.getPosition()
+            own = self.getPosition()
 
-        dist = abs(lok[0] - own[0]) + abs(lok[1] - own[1])
+            dist = abs(lok[0] - own[0]) + abs(lok[1] - own[1])
-        return dist
+            return dist
+        return math.inf
 
     def scanTile(self):
         self.state = None
         temp = self.houses[:]
-        temp.append(self.trashcans[:])
+        temp.extend(self.trashcans[:])
         for loc in temp:
             if tuple(self.position) == loc.getPosition():
                 self.state = loc
                 return
+            else:
+                self.state = False
 
     def printme(self):
         x, y = self.getPosition()
@@ -184,27 +212,101 @@ class Garbagetruck:
             stepX = 1
         self.modPosiotion(stepX, stepY)
 
-    def graphsearch(self, target):
+    def graphsearch(self):
+        def succ(elem):
+            def virtRotateLeft(state):
+                ort = (state[-1] + 1) % 4
+                result = state[:]
+                result[-1] = ort
+                return result
+
+            def virtRotateRight(state):
+                ort = (state[-1] - 1) % 4
+                result = state[:]
+                result[-1] = ort
+                return result
+
+            def virtMoveForward(state):
+                ort = state[-1]
+                x, y = state[0], state[1]
+                stepX, stepY = 0, 0
+                if ort == 0 and y != 0:
+                    stepY = -1
+                elif ort == 1 and x != 0:
+                    stepX = -1
+                elif ort == 2 and y != 20:
+                    stepY = 1
+                elif ort == 3 and x != 30:
+                    stepX = 1
+                x += stepX
+                y += stepY
+                result = [x, y, ort]
+                return result
+
+            op = elem.getState()
+            forward = {"result": virtMoveForward(op), "action": "F"}
+            left = {"result": virtRotateLeft(op), "action": "L"}
+            right = {"result": virtRotateRight(op), "action": "R"}
+            # print("got children")
+            return [forward, left, right]
+
         fringe = []
         explored = []
-        result = []
+        target = self.target.getPosition()
-        initial = self.getPosition()
+        temp = self.getPosition()[:]
-        initial.append(self.getOrientation())
+        temp.append(self.getOrientation())
-        fringe.append(tuple(initial))
+        initial = Node(temp)
+        fringe.append(initial)
 
         while True:
+            fringPos = [item.getState() for item in fringe]
+            explPos = [item.getState() for item in explored]
             if not fringe:
                 return False
 
             elem = fringe.pop(0)
-            if self.selfdistance(target) == 0:
+            virtPos = elem.getState()[:-1]
+            dist = abs(virtPos[0]-target[0]) + abs(virtPos[1]-target[1])
+            if dist == 0:
+                def findWay(node):
+                    temp = node
+                    movelist = []
+                    while temp:
+                        movelist.append(temp.getAction())
+                        temp = temp.getParent()
+                    return movelist
+
+                lista = findWay(elem)
+                result = lista[::-1]
+                result.pop(0)
                 return result
 
             explored.append(elem)
+            suc = succ(elem)
+            for wynik in suc:
+                if wynik['result'] not in fringPos and wynik['result'] not in explPos:
+                    x = Node(wynik["result"])
+                    x.setParent(elem)
+                    x.setAction(wynik["action"])
+                    fringe.append(x)
 
-    #     KONIECZNIE SKOŃCZYĆ!!!
+    def executeMovement(self):
-
+        element = self.movesequence.pop(0) if self.movesequence else ""
+        if element == "L":
+            self.rotateLeft()
+        elif element == "R":
+            self.rotateRight()
+        elif element == "F":
+            self.moveForward()
 
+    def randomTarget(self):
+        wybor1 = random.choice([1,2])
+        if wybor1 == 1:
+            wybor2 = random.choice(self.houses)
+        else:
+            wybor2 = random.choice(self.trashcans)
+        wybor2.switchFinal()
+        # print(wybor2)
 
     def classifyTrash(self):
         pass

classes/Node.py

@@ -0,0 +1,22 @@
+class Node:
+    def __init__(self, state):
+        self.state = state
+        self.action = ""
+        self.parent: Node = None
+
+    def getState(self):
+        return self.state
+
+    def getAction(self):
+        return self.action
+
+    def setAction(self, action):
+        self.action = action
+        return self
+
+    def getParent(self):
+        return self.parent if self.parent else False
+
+    def setParent(self, parent):
+        self.parent = parent
+        return self

classes/Trashcan.py

@@ -5,6 +5,14 @@ class Trashcan:
         self.image: object = None
         self.position: tuple = None
         self.trashtype: str = None
+        self.final = False
+
+    def getFinal(self):
+        return self.final
+
+    def switchFinal(self):
+        self.final = False if self.final else True
+        return self
 
     def setPosition(self, position: tuple):
         self.position = position

generators.py

@@ -42,6 +42,8 @@ def householdGenerator(mult):
         house_image = pygame.image.load(f'sprites/domek.png')
         house_image = pygame.transform.scale(house_image, new_house_size)
         house = generateHousehold(mult, i, house_image, house_positions[i])
+        if i == 1:
+            house.switchFinal()
         houses.append(house)
 
     return houses

main.py

@@ -1,12 +1,17 @@
+import pygame.transform
+
 from generators import *
+import time
 
 W = 30
 H = 20
-MULT = 48
+MULT = 50
 SIZE = (MULT*W, MULT*H)
 pygame.init()
 screen = pygame.display.set_mode(SIZE)
 tilemap = Tilemap(Tileset("sprites/Tiles/1 Tiles/FieldsTile_38.png", mult=MULT), mult=MULT, size=(W, H))
+targimage = pygame.image.load("sprites/X.png").convert_alpha()
+targimage = pygame.transform.scale(targimage, (MULT, MULT))
 
 trashcans = trashcanGenerator(MULT)
 houses = householdGenerator(MULT)
@@ -18,14 +23,33 @@ while running:
         if event.type == pygame.QUIT:
             running = False
 
+    print(garbagetruck.movesequence)
+    garbagetruck.setTarget()
+    garbagetruck.executeMovement()
     screen.fill((0, 0, 0))
     tilemap.render(MULT)
     screen.blit(tilemap.image, tilemap.rect)
-    screen.blit(garbagetruck.getImage(), garbagetruck.printme())
     for i in trashcans:
         screen.blit(i.getImage(), i.printme())
     for h in houses:
         screen.blit(h.getImage(), h.printme())
+    print(garbagetruck.getPosition())
+    bruh = garbagetruck.target.getPosition()
+    bruhlist = [i*MULT for i in bruh]
+    screen.blit(targimage, bruhlist)
+    screen.blit(garbagetruck.getImage(), garbagetruck.printme())
     pygame.display.update()
+    garbagetruck.scanTile()
+    state = garbagetruck.getState()
+    if not garbagetruck.movesequence:
+        moves = garbagetruck.graphsearch()
+        garbagetruck.setMovesequence(moves)
+    if state:
+        if state.getFinal():
+            garbagetruck.getState().switchFinal()
+        elif not garbagetruck.movesequence:
+            garbagetruck.randomTarget()
+    time.sleep(0.5)
+
 
 pygame.quit()