SI-projekt-smieciarka/board

from asyncio.windows_events import NULL
from collections import deque
from lib2to3.pgen2.token import CIRCUMFLEX
from queue import Queue
import sys
from unicodedata import name
import pygame
import random
import time

screen = []
objectArray = []
pathToPrint = []


class Object:
    def __init__(self, name, xPos, yPos):
        self.name = name
        self.xPos = xPos
        self.yPos = yPos

class Field:
    def __init__(self, xPos, yPos, isObject):
        self.xPos = xPos
        self.yPos = yPos
        self.visited = False
        self.parent = None
        number = random.randint(0, 9)
        if number > 7 and not isObject:
            self.isBlock = True
        else:
            self.isBlock = False

    def printXandY(self):
        print("X: " + str(self.xPos) + ". Y: " + str(self.yPos))


def draw(square_num, objectArr, pathToTarget, num):
    grid_color = (0, 0, 0)
    grid_size = 500 
    square = grid_size/square_num
    a = 50
    b = 10 

    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, 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)
    pygame.draw.line(screen, grid_color, (a + grid_size, b),
                     (a + grid_size, b + grid_size), 2)

    circleX = objectArr[0].xPos * square + square + square / 2
    circleY = objectArr[0].yPos * square + square / 2
  
    a = (10 + circleX, 5 + circleY)
    b = (20 + circleX, 5 + circleY)
    c = (15 + circleX, 20 + circleY)


    polygon = pygame.draw.polygon(screen, (0, 0, 255), (b, a, c))
    print(polygon)

    


    circleX = objectArray[1].xPos * square + square * 2
    circleY = objectArr[1].yPos * square + square
    radius = 8
    grid_color = (255, 0, 0)
    pygame.draw.circle(screen, grid_color, (circleX, circleY), radius)


def kb_listen(objectArray, gridLength):
    for event in pygame.event.get():
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT and objectArray[0].xPos > 0:
                objectArray[0].xPos = objectArray[0].xPos - 1
                print(objectArray[0].xPos)
            if event.key == pygame.K_RIGHT and objectArray[0].xPos < gridLength - 1:
                objectArray[0].xPos = objectArray[0].xPos + 1
                print(objectArray[0].xPos)
            if event.key == pygame.K_UP and objectArray[0].yPos > 0:
                objectArray[0].yPos = objectArray[0].yPos - 1
                print(objectArray[0].yPos)
            if event.key == pygame.K_DOWN and objectArray[0].yPos < gridLength - 1:
                objectArray[0].yPos = objectArray[0].yPos + 1
                print(objectArray[0].yPos)
        if event.type == pygame.QUIT:
            sys.exit()


fieldQueue = []
isGoalAchieved = False

def startQueue(agentX, agentY, fieldList, gridNum):
    currentX = agentX
    currentY = agentY
    currentIndex = currentY * gridNum + currentX

    fieldQueue.append(fieldList[currentIndex])

    checkFlag = False

    while not checkFlag:
        result = checkGoal(fieldList, gridNum)
        if result:
            checkFlag = True
        # print("NEXT CHECK GOAL")
    return result


def checkGoal(fieldList, gridNum):
    currentField = fieldQueue.pop(0)

    currentY = currentField.yPos
    currentX = currentField.xPos
    currentIndex = currentY * gridNum + currentX
    # print("POPPED!!!")
    # currentField.printXandY()
    ##print(str(currentField.xPos) + " " + str(objectArray[1].xPos) + " " + str(currentField.yPos) + " " + str(objectArray[1].yPos))

    # SPRAWDZAMY CZY DANE POLE JEST POLEM W KTORYM ZNAJDUJE SIE NASZ CEL
    if currentField.xPos == objectArray[1].xPos and currentField.yPos == objectArray[1].yPos:
        return currentField

    # SPRAWDZAMY CZY DANE POLE ZOSTALO JUZ WCZESNIEJ ODWIEDZONE - JEZELI NIE TO USTAWIAMY STATUS
    if not currentField.visited:
        currentField.visited = True

        # JEZELI DANE POLE NIE ZOSTALO ODWIEDZONE, TO DODAJEMY DO KOLEJKI WSZYSTKIE POLA OBOK I LECIMY DALEJ
        if currentIndex + 15 <= 224 and fieldList[currentIndex + 15].visited == False and fieldList[currentIndex + 15].isBlock == False:
            fieldQueue.append(fieldList[currentIndex + 15])
            fieldList[currentIndex + 15].parent = fieldList[currentIndex]
            # print("APPENDED DOWN!!!")
            # fieldList[currentIndex + 15].printXandY()
        if currentIndex - 15 > -1 and fieldList[currentIndex - 15].visited == False and fieldList[currentIndex - 15].isBlock == False:
            fieldQueue.append(fieldList[currentIndex - 15])
            fieldList[currentIndex - 15].parent = fieldList[currentIndex]
            # print("APPENDED UP!!!")
            # fieldList[currentIndex - 15].printXandY()
        if (currentIndex + 1) % 15 != 0 and fieldList[currentIndex + 1].visited == False and fieldList[currentIndex + 1].isBlock == False:
            fieldQueue.append(fieldList[currentIndex + 1])
            fieldList[currentIndex + 1].parent = fieldList[currentIndex]
            # print("APPENDED RIGHT!!!")
            # fieldList[currentIndex + 1].printXandY()
        if (currentIndex - 1) % 15 != 14 and not currentIndex - 1 < 0 and fieldList[currentIndex - 1].visited == False and fieldList[currentIndex - 1].isBlock == False:
            fieldQueue.append(fieldList[currentIndex - 1])
            fieldList[currentIndex - 1].parent = fieldList[currentIndex]
            # print("APPENDED LEFT!!!")
            # fieldList[currentIndex - 1].printXandY()

def generateStartEndPos():
    startX = random.randint(0, 14)
    startY = random.randint(0, 14)
    print(startX)
    targetX = None
    targetY = None

    while targetX == None and targetY == None or targetX == startX and targetY == startY:
        targetX = random.randint(0, 14)
        targetY = random.randint(0, 14)

    return [startX, startY, targetX, targetY]

if __name__ == '__main__':
    pygame.init()  # inicjalizacja modułów, na razie niepotrzebna

    width = 600
    height = 530
    screen = pygame.display.set_mode(
        (width, height))  # ustalanie rozmiarów okna

    # OBLICZANIE RANDOMOWYCH POL START I END
    [sX, sY, eX, eY] = generateStartEndPos()

    print(sX)
    print(sY)
    print(sX)
    print(eY)

    # GENEROWANIE WSZYSTKICH POL - FIELDS
    fields = []
    for y in range(15):
        for x in range(15):
            if x == sX and y == sY or x == eX and y == eY:
                newField = Field(x, y, True)
            else:
                newField = Field(x, y, False)
            # newField.printXandY()
            fields.append(newField)

    agent = Object("AGENT", sX, sY)
    target = Object("TARGET", eX, eY)

    # if fields[agent.getX - 1 * 

    objectArray.append(agent)
    objectArray.append(target)

    result = startQueue(objectArray[0].xPos,
                        objectArray[0].yPos, fields, 15)


    print("RED DOT X AND Y POSITION ============================")
    print("X: " + str(objectArray[1].xPos) + " Y: " + str(objectArray[1].yPos))
    print("TRUCK X AND Y POSITION ============================")
    print("X: " + str(objectArray[0].xPos) + " Y: " + str(objectArray[0].yPos))

    result_parent = result.parent

    currentIndex = (objectArray[0].yPos) * 15 + objectArray[0].xPos
    pathToTarget = deque()
    pathToTarget.appendleft(result)

    while result_parent.parent != None:
        pathToTarget.appendleft(result_parent)
        result_parent = result_parent.parent
    pathToTarget.appendleft(fields[currentIndex])

    print("PRINTING PATH TO TARGET ============================")
    for node in pathToTarget:
        node.printXandY()

    while 1:
        # tymczasowy kolor tła - do usunięcia, jak już będzie zdjęcie
        c = (255, 255, 255)
        screen.fill(c)
        draw(15, objectArray, pathToTarget, 1)

        # TUTAJ RYSUJEMY SCIEZKE
        for node in pathToTarget:
            if node == pathToTarget[0] or node == pathToTarget[-1]:
                continue
            green = (0, 255, 0)
            pygame.draw.circle(screen, green, ((node.xPos + 1)
                               * 500 / 15 + 30, (node.yPos + 1) * 500 / 15), 5)

        for node in fields:
            ## DRAWING BLOCKS
            if node.isBlock == True:
                black = (0, 0, 0)
                pygame.draw.rect(screen, black, pygame.Rect((node.xPos + 1) * 500 / 15 + 30, (node.yPos + 1) * 500 / 15 - 10, 10, 10))

        kb_listen(objectArray, 15)
        pygame.display.update()  # by krata pojawiła się w okienku - update powierzchni