Madra_smieciarka/classes/Garbagetruck.py

import pygame
from classes.Household import *


class Garbagetruck:

    def __init__(self, mult):
        self.mult = mult
        self.capacity: int = 20
        self.trash: list = []
        self.trashweight: int = 0
        self.image = pygame.image.load("sprites/smieciara.png").convert_alpha()
        self.image = pygame.transform.scale(self.image, (mult, mult))
        self.position = [3, 3]
        self.houses: list = []
        self.trashcans: list = []
        self.state = None
        self.segregation = {"Papier": "paper",
                            "MetalPlastik": "metals_and_plastics",
                            "Mixed": "mixed",
                            "Bio": "bio_waste",
                            "Szklo": "glass"}
        self.route = None
        self.scanner = None
        self.planner = None
        self.driver = None
        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 = []

    def getOrientation(self):
        return self.orientation

    def setOrientation(self, orientation):
        self.orientation = orientation % 4
        return self

    def getRunningtime(self):
        return self.runningtime

    def setRunningtime(self, runningtime):
        self.runningtime = runningtime
        return self

    def incrRunningtime(self):
        self.runningtime += 1
        return self

    def getTrashcans(self):
        return self.trashcans

    def setTrashcans(self, others):
        self.trashcans = others
        return self

    def setHouses(self, houses):
        self.houses = houses
        return self

    def getHouses(self):
        return self.houses

    def getCapacity(self) -> int:
        return self.capacity

    def getTrash(self) -> list:
        return self.trash

    def setTrash(self, trash: list) -> None:
        self.trash = trash
        for item in trash:
            self.addTrashweight(item.getWaga)

    def addTrash(self, trash: Trash) -> None:
        self.trash.append(trash)
        self.addTrashweight(trash.getWaga())

    def getTrashweight(self) -> int:
        return self.trashweight

    def setTrashweight(self, weight: int) -> None:
        self.trashweight = weight

    def addTrashweight(self, weight: int) -> None:
        self.trashweight += weight

    def getImage(self) -> object:
        return self.image

    def setImage(self, image: object) -> None:
        self.image = image

    def getPosition(self) -> list:
        return self.position

    def setPosition(self, position: list) -> object:
        self.position = position
        return self

    def modPosiotion(self, modX, modY):
        x = self.getPosition()[0] + modX
        y = self.getPosition()[1] + modY
        self.setPosition([x, y])

    def getRoute(self):
        return self.route

    def setRoute(self, route) -> None:
        self.route = route

    def getScanner(self):
        return self.scanner

    def setScanner(self, scanner) -> None:
        self.route = scanner

    def getPlanner(self):
        return self.planner

    def setPlanner(self, planner) -> None:
        self.route = planner

    def getDriver(self):
        return self.driver

    def setDriver(self, driver) -> None:
        self.route = driver

    def distance(self, object1, object2) -> int:
        lok1 = object1.getPosition()
        lok2 = object2.getPosition()

        dist = abs(lok1[0] - lok2[0]) + abs(lok1[1] - lok2[1])
        return dist

    def selfdistance(self, target) -> int:
        lok = target.getPosition()
        own = self.getPosition()

        dist = abs(lok[0] - own[0]) + abs(lok[1] - own[1])
        return dist

    def scanTile(self):
        self.state = None
        temp = self.houses[:]
        temp.append(self.trashcans[:])
        for loc in temp:
            if tuple(self.position) == loc.getPosition():
                self.state = loc
                return

    def printme(self):
        x, y = self.getPosition()
        return self.mult*x, self.mult*y

    def throwGarbage(self, trash):
        if self.segregation[trash.getTtype()] == self.state.getTrashtype():
            self.addTrashweight(trash.getWeight * (-1))
            self.trash.remove(trash)

    def rotateImage(self, arg):
        self.image = pygame.transform.rotate(self.image, 90*arg)

    def rotateLeft(self):
        self.setOrientation(self.getOrientation()+1)
        self.rotateImage(1)

    def rotateRight(self):
        self.setOrientation(self.getOrientation()-1)
        self.rotateImage(-1)

    def moveForward(self):
        ort = self.orientation
        x, y = self.getPosition()
        stepX = 0
        stepY = 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
        self.modPosiotion(stepX, stepY)

    def graphsearch(self, target):
        fringe = []
        explored = []
        result = []
        initial = self.getPosition()
        initial.append(self.getOrientation())
        fringe.append(tuple(initial))

        while True:
            if not fringe:
                return False

            elem = fringe.pop(0)
            if self.selfdistance(target) == 0:
                return result

            explored.append(elem)

    #     KONIECZNIE SKOŃCZYĆ!!!



    def classifyTrash(self):
        pass
#     Tutaj jest plan żeby dopiero napisać funkcję jak już będzie klasyfikator
#     ogólnie to myślałem żeby po prostu zklasyfikować śmieć i zmienić mu trashtype na rozpoznany, żeby śmieciarka go tak posegreowała