Sztuczna_Inteligencja/waiter.py

import pygame
import time
from pygame.math import Vector2

class Waiter(object):

    def __init__(self, game, x, y):
        self.game = game
        self.grid = game.grid
        game.idItem += 1
        self.size= self.game.screen.get_size()
        self.x = x
        self.y = y
        self.positionX = int(x / 50)
        self.positionY = int(y / 50)
        self.image = pygame.image.load("./Images/waiter.png").convert()
        self.image.set_colorkey((255, 255, 255))
        self.type = "waiter"
        self.lastStep = []
        self.tmp = []
        self.allPath = []


    def findWaiter(self, grid):
        for y in range(10):
            for x in range(10):
                if grid[y][x].type =="waiter":
                    #print(x,y)
                    return [x, y]


    def moveLeft(self, grid):

        position = self.findWaiter(grid)
        positionX = position[0]
        positionY = position[1]
        if positionX != 0:
            collisionObject = grid[positionY][positionX - 1]
            if collisionObject.type == "gridElement":
                grid[positionY][positionX - 1].x += 50
                grid[positionY][positionX].x -= 50
                grid[positionY][positionX - 1], \
                grid[positionY][positionX] = \
                grid[positionY][positionX], \
                grid[positionY][positionX - 1]

                #print(self.positionX)
                return grid
            else:
                pass
    def moveRight(self, grid):

        position = self.findWaiter(grid)
        positionX = position[0]
        positionY = position[1]
        if positionX != 9:
            collisionObject = grid[positionY][positionX + 1]
            if collisionObject.type == "gridElement":
                grid[positionY][positionX + 1].x -= 50
                grid[positionY][positionX].x += 50
                grid[positionY][positionX + 1], \
                grid[positionY][positionX] = \
                    grid[positionY][positionX], \
                    grid[positionY][positionX + 1]

                # print(self.positionX)
                return grid
            else:
                pass

    def moveUp(self, grid):
        position = self.findWaiter(grid)
        positionX = position[0]
        positionY = position[1]
        if positionY != 0:
            collisionObject = grid[positionY - 1][positionX]
            if collisionObject.type == "gridElement":
                grid[positionY - 1][positionX].y += 50
                grid[positionY][positionX].y -= 50
                grid[positionY - 1][positionX], \
                grid[positionY][positionX] = \
                grid[positionY][positionX], \
                grid[positionY - 1][positionX]
                return grid
            else:
                pass

    def moveDown(self, grid):
        position = self.findWaiter(grid)
        positionX = position[0]
        positionY = position[1]
        if positionY != 9:
            collisionObject = grid[positionY + 1][positionX]
            if collisionObject.type == "gridElement":
                grid[positionY + 1][positionX].y -= 50
                grid[positionY][positionX].y += 50
                grid[positionY + 1][positionX], \
                grid[positionY][positionX] = \
                    grid[positionY][positionX], \
                    grid[positionY + 1][positionX]
                return grid
            else:
                pass



    def move(self, game):
        keys = pygame.key.get_pressed()

        if keys[pygame.K_LEFT]:
            self.moveLeft(game.grid)
        if keys[pygame.K_RIGHT]:
            self.moveRight(game.grid)
        if keys[pygame.K_UP]:
            self.moveUp(game.grid)
        if keys[pygame.K_DOWN]:
            self.moveDown(game.grid)
        if keys[pygame.K_s]:
            game.showGrid(game.grid)


    def draw(self):
        self.rect1 = pygame.Rect(self.x, self.y, 50, 50)
        pygame.draw.rect(self.game.screen, (0, 150, 255), self.rect1)
        #print(self.lastStep)
        self.game.screen.blit(self.image, (self.x, self.y))


    def isMoveInRange(self, move, position):

        positionX = position[0]
        positionY = position[1]

        if move == "Left":
            if positionX  == 0:
                return False
        if move == "Right":
            if positionX == 9:
                return False
        if move == "Up":
            if positionY == 0:
                return False
        if move == "Down":
            if positionY == 9:
                return False
        return True

    def checkPoss(self, position, lastOperation):

        stackMove = []

        positionX = position[0]
        positionY = position[1]

        if len(lastOperation) == 0:
            if self.isMoveInRange("Up", position):
                collisionObjectUp = self.grid[positionY - 1][positionX]
                if collisionObjectUp.type == "gridElement" or collisionObjectUp.type == "waiter":
                    stackMove.append("Up")
            if self.isMoveInRange("Down", position):
                collisionObjectDown = self.grid[positionY + 1][positionX]
                if collisionObjectDown.type == "gridElement" or collisionObjectDown.type == "waiter":
                    stackMove.append("Down")
            if self.isMoveInRange("Left", position):
                collisionObjectLeft = self.grid[positionY][positionX - 1]
                if collisionObjectLeft.type == "gridElement" or collisionObjectLeft.type == "waiter":
                    stackMove.append("Left")
            if self.isMoveInRange("Right", position):
                collisionObjectRight = self.grid[positionY][positionX + 1]
                if collisionObjectRight.type == "gridElement" or collisionObjectRight.type == "waiter":
                    stackMove.append("Right")
            return stackMove
        else:
            last = lastOperation[-1]
            if last == "Left":
                if self.isMoveInRange("Up", position):
                    collisionObjectUp = self.grid[positionY - 1][positionX]
                    if collisionObjectUp.type == "gridElement":
                        stackMove.append("Up")
                if self.isMoveInRange("Down", position):
                    collisionObjectDown = self.grid[positionY + 1][positionX]
                    if collisionObjectDown.type == "gridElement":
                        stackMove.append("Down")
                if self.isMoveInRange("Left", position):
                    collisionObjectLeft = self.grid[positionY][positionX - 1]
                    if collisionObjectLeft.type == "gridElement":
                        stackMove.append("Left")

                return stackMove

            if last == "Right":
                if self.isMoveInRange("Up", position):
                    collisionObjectUp = self.grid[positionY - 1][positionX]
                    if collisionObjectUp.type == "gridElement":
                        stackMove.append("Up")
                if self.isMoveInRange("Down", position):
                    collisionObjectDown = self.grid[positionY + 1][positionX]
                    if collisionObjectDown.type == "gridElement":
                        stackMove.append("Down")

                if self.isMoveInRange("Right", position):
                    collisionObjectRight = self.grid[positionY][positionX + 1]
                    if collisionObjectRight.type == "gridElement":
                        stackMove.append("Right")
                return stackMove

            if last == "Up":
                if self.isMoveInRange("Up", position):
                    collisionObjectUp = self.grid[positionY - 1][positionX]
                    if collisionObjectUp.type == "gridElement":
                        stackMove.append("Up")

                if self.isMoveInRange("Left", position):
                    collisionObjectLeft = self.grid[positionY][positionX - 1]
                    if collisionObjectLeft.type == "gridElement":
                        stackMove.append("Left")
                if self.isMoveInRange("Right", position):
                    collisionObjectRight = self.grid[positionY][positionX + 1]
                    if collisionObjectRight.type == "gridElement":
                        stackMove.append("Right")
                return stackMove

            if last == "Down":

                if self.isMoveInRange("Down", position):
                    collisionObjectDown = self.grid[positionY + 1][positionX]
                    if collisionObjectDown.type == "gridElement":
                        stackMove.append("Down")
                if self.isMoveInRange("Left", position):
                    collisionObjectLeft = self.grid[positionY][positionX - 1]
                    if collisionObjectLeft.type == "gridElement":
                        stackMove.append("Left")
                if self.isMoveInRange("Right", position):
                    collisionObjectRight = self.grid[positionY][positionX + 1]
                    if collisionObjectRight.type == "gridElement":
                        stackMove.append("Right")
                return stackMove


    def dfsFind(self, position, currentOperation, idTable):

        print("Sprawdzam czy stolik")

        positionX = position[0]
        positionY = position[1]

        if self.isMoveInRange("Up", position):
            if self.grid[positionY - 1][positionX].type == "table":
                    if self.grid[positionY - 1][positionX].id == idTable:
                        self.allPath.append(currentOperation)
                        print("Dodalem do all path sciezke jedna z miliona")
                        return 0
        if self.isMoveInRange("Down", position):
            if self.grid[positionY + 1][positionX].type == "table":
                    if self.grid[positionY + 1][positionX].id == idTable:
                        self.allPath.append(currentOperation)
                        return 0
        if self.isMoveInRange("Left", position):
            if self.grid[positionY][positionX - 1].type == "table":
                    if self.grid[positionY][positionX - 1].id == idTable:
                        self.allPath.append(currentOperation)
                        return 0
        if self.isMoveInRange("Right", position):
            if self.grid[positionY][positionX + 1].type == "table":
                    if self.grid[positionY][positionX + 1].id == idTable:
                        self.allPath.append(currentOperation)
                        return 0
        print("Sprawdzilem nie jest to stolik")
        steps = []
        steps.append(self.checkPoss(position, currentOperation))
        allstep = steps[-1]
        print("Naszymi mozliwosciami sa ", allstep)

        if len(allstep) != 1:
            for i in allstep:
                newCurrentOperation = currentOperation[:]
                newCurrentOperation.append(i)
                newPosition = position[:]
                if i == "Left":
                    newPosition[0] -= 1
                if i == "Right":
                    newPosition[0] += 1
                if i == "Up":
                    newPosition[1] -= 1
                if i == "Down":
                    newPosition[1] += 1

                self.tmp.append([newPosition, newCurrentOperation, idTable])
            while self.tmp:
                move = self.tmp.pop()
                self.dfsFind(move[0], move[1], move[2])

        else:
            step = allstep.pop()

            print("Wybrałem: ", step)
            print("Pozycja tego cwela: ", position)
            if step == "Left":
                position[0] -= 1
                currentOperation.append("Left")
            if step == "Right":
                position[0] += 1
                currentOperation.append("Right")
            if step == "Up":
                position[1] -= 1
                currentOperation.append("Up")
            if step == "Down":
                position[1] += 1
                currentOperation.append("Down")

            self.dfsFind(position, currentOperation, idTable)