poprawienie bfs, start A*

.idea/misc.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (pythonProject)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" project-jdk-name="Python 3.9" project-jdk-type="Python SDK" />
 </project>

astar.py

@@ -0,0 +1,201 @@
+from operator import itemgetter
+import cart
+import copy
+from classes import Field
+
+
+class Istate:
+    def __init__(self, direction, x, y):
+        self.direction = direction
+        self.x = x
+        self.y = y
+
+    def get_direction(self):
+        return self.direction
+
+    def set_direction(self, direction):
+        self.direction = direction
+
+    def get_x(self):
+        return self.x
+
+    def set_x(self, x):
+        self.x = x
+
+    def get_y(self):
+        return self.y
+
+    def set_y(self, y):
+        self.y = y
+
+
+class Node:
+    def __init__(self, action, direction, parent, x, y):
+        self.action = action
+        self.direction = direction
+        self.parent = parent
+        self.x = x
+        self.y = y
+
+    def get_action(self):
+        return self.action
+
+    def set_action(self, action):
+        self.action = action
+
+    def get_direction(self):
+        return self.direction
+
+    def set_direction(self, direction):
+        self.direction = direction
+
+    def get_parent(self):
+        return self.parent
+
+    def set_parent(self, parent):
+        self.parent = parent
+
+    def get_x(self):
+        return self.x
+
+    def set_x(self, x):
+        self.x = x
+
+    def get_y(self):
+        return self.y
+
+    def set_y(self, y):
+        self.y = y
+
+
+def fieldCost(T,node):
+    c = 0
+    if T[node.x-1][node.y-1].plantType == 1:
+        c =2
+    elif T[node.x-1][node.y-1].plantType == 2:
+        c =5
+    elif T[node.x-1][node.y-1].plantType == 3:
+        c =13
+    elif T[node.x-1][node.y-1].plantType == 4:
+        c =100000
+    else:
+        c=0
+
+    if T[node.x-1][node.y-1].isWet == 1:
+        c = c + 4
+    else:
+        c=c+1
+
+    return c
+
+
+def cost(T, node):
+    cost = 0
+
+    while (node.get_parent() != None):
+        cost = cost + fieldCost(T, node)
+        node = node.get_parent()
+
+    return cost
+
+
+def f(goaltest, map, node):
+    return cost(map, node) + heuristic(goaltest, node)
+
+
+def goal_test(elem,goaltest):
+    if elem.get_x() == goaltest[0] and elem.get_y() == goaltest[1]:
+        return True
+    else:
+        return False
+
+
+def graphsearch(explored, f, fringe, goaltest, istate, map, succ):  # przeszukiwanie grafu wszerz
+    node = Node(None, istate.get_direction(), None, istate.get_x(), istate.get_y())
+    fringe.append((node, 0))  # wierzchołki do odwiedzenia z priorytetem
+    while True:
+        if not fringe:
+            return False
+        elem = fringe.pop(0)  # zdejmujemy wierzchołek z kolejki fringe i rozpatrujemy go
+        temp = copy.copy(elem[0])
+        if goal_test(elem[0], goaltest) is True:  # jeżeli osiągniemy cel w trakcie przeszukiwania grafu wszerz (wjedziemy na pole docelowe) : zwracamy listę ruchów, po których wykonaniu dotrzemy na miejsce
+            return print_moves(elem[0])
+        explored.append(elem)  # dodajemy wierzchołek do listy wierzchołków odwiedzonych
+        for (action, state) in succ(temp):  # iterujemy po wszystkich możliwych akcjach i stanach otrzymanych dla danego wierzchołka grafu
+            fringe_tuple = []
+            fringe_tuple_prio = []
+            explored_tuple = []
+            for (x, y) in fringe:
+                fringe_tuple.append((x.get_direction(), x.get_x(), x.get_y()))
+                fringe_tuple_prio.append(((x.get_direction(), x.get_x(), x.get_y()), y))
+            for (x, y) in explored:
+                explored_tuple.append((x.get_direction(), x.get_x(), x.get_y()))
+            x = Node(action, state[0], elem[0], state[1], state[2])  # stworzenie nowego wierzchołka, którego rodzicem jest elem
+            p = f(goaltest, map, x)  # liczy priorytet
+            #print('Koszt =', p)
+            if state not in fringe_tuple and state not in explored_tuple:  # jeżeli stan nie znajduje się na fringe oraz nie znajduje się w liście wierzchołków odwiedzonych
+                fringe.append((x, p))  # dodanie wierzchołka na fringe
+                fringe = sorted(fringe, key=itemgetter(1))  # sortowanie fringe'a według priorytetu
+            elif state in fringe_tuple:
+                i = 0
+                for (state_prio, r) in fringe_tuple_prio:
+                    if str(state_prio) == str(state):
+                        if r > p:
+                            fringe.insert(i, (x,p))  # zamiana state, który należy do fringe z priorytetem r na state z priorytetem p (niższym)
+                            fringe.pop(i + 1)
+                            fringe = sorted(fringe, key=itemgetter(1))  # sortowanie fringe'a według priorytetu
+                            break
+                    i = i + 1
+
+
+def heuristic(goaltest, node):
+    return abs(node.get_x() - goaltest[0]) + abs(node.get_y() - goaltest[1])
+
+
+def print_moves(elem):
+    moves_list = []
+    while (elem.get_parent() != None):
+        moves_list.append(elem.get_action())
+        elem = elem.get_parent()
+    moves_list.reverse()
+    return moves_list
+
+
+def succ(elem):
+    actions_list = []
+    temp = copy.copy(elem.get_direction())
+
+    if temp == 1:
+        temp = 4
+    else:
+        temp = temp - 1
+
+    actions_list.append(("rotate_right", (temp, elem.get_x(), elem.get_y())))
+    temp = copy.copy(elem.get_direction())
+
+    if temp == 4:
+        temp = 1
+    else:
+        temp = temp + 1
+
+    actions_list.append(("rotate_left", (temp, elem.get_x(), elem.get_y())))
+    temp_move_south = elem.get_y() - 1
+    temp_move_west = elem.get_x() - 1
+    temp_move_east = elem.get_x() + 1
+    temp_move_north = elem.get_y() + 1
+
+
+    if cart.Cart.is_move_allowed_succ(elem) == "x + 1":
+        actions_list.append(("move", (elem.get_direction(), temp_move_east, elem.get_y())))
+    elif cart.Cart.is_move_allowed_succ(elem) == "y + 1":
+        actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_north)))
+    elif cart.Cart.is_move_allowed_succ(elem) == "y - 1":
+        actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_south)))
+    elif cart.Cart.is_move_allowed_succ(elem) == "x - 1":
+        actions_list.append(("move", (elem.get_direction(), temp_move_west, elem.get_y())))
+
+
+
+
+
+    return actions_list

bfs.py

@@ -0,0 +1,156 @@
+import sys
+import cart
+import copy
+
+
+class Istate:
+    def __init__(self, direction, x, y):
+        self.direction = direction
+        self.x = x
+        self.y = y
+
+    def get_direction(self):
+        return self.direction
+
+    def set_direction(self, direction):
+        self.direction = direction
+
+    def get_x(self):
+        return self.x
+
+    def set_x(self, x):
+        self.x = x
+
+    def get_y(self):
+        return self.y
+
+    def set_y(self, y):
+        self.y = y
+
+
+class Node:
+    def __init__(self, action, direction, parent, x, y):
+        self.action = action
+        self.direction = direction
+        self.parent = parent
+        self.x = x
+        self.y = y
+
+    def get_action(self):
+        return self.action
+
+    def set_action(self, action):
+        self.action = action
+
+    def get_direction(self):
+        return self.direction
+
+    def set_direction(self, direction):
+        self.direction = direction
+
+    def get_parent(self):
+        return self.parent
+
+    def set_parent(self, parent):
+        self.parent = parent
+
+    def get_x(self):
+        return self.x
+
+    def set_x(self, x):
+        self.x = x
+
+    def get_y(self):
+        return self.y
+
+    def set_y(self, y):
+        self.y = y
+
+
+def goal_test(goaltest,elem):
+    if elem.get_x() == goaltest[0] and elem.get_y() == goaltest[1]:
+        return True
+    else:
+        return False
+
+
+# def graphsearch(explored, fringe, goaltest, istate, succ):  # przeszukiwanie grafu wszerz
+def graphsearch(explored, fringe, goaltest, istate):  # przeszukiwanie grafu wszerz
+    node = Node(None, istate.get_direction(), None, istate.get_x(), istate.get_y())
+
+    fringe = []
+    #elem = []
+    explored = []
+    #action = []
+    fringe.append(node)  # wierzchołki do odwiedzenia
+    # fringe = [node]
+    while True:
+        if not fringe:
+            return False
+        elem = fringe.pop(0)  # zdejmujemy wierzchołek z kolejki fringe i rozpatrujemy go
+        temp = copy.copy(elem)
+        if goal_test(goaltest,
+                     elem) is True:  # jeżeli osiągniemy cel w trakcie przeszukiwania grafu wsszerz, zwracamy listę ruchów, po których wykonaniu dotrzemy na miejsce
+            return print_moves(elem)
+        explored.append(elem)  # dodajemy wierzchołek do listy wierzchołków odwiedzonych
+
+        for action, state in succ(temp):  # iterujemy po wszystkich możliwych akcjach i stanach otrzymanych dla danego wierzchołka grafu
+
+            fringe_tuple = []
+            explored_tuple = []
+            for x in fringe:
+                fringe_tuple.append((x.get_direction(), x.get_x(), x.get_y()))
+            for x in explored:
+                explored_tuple.append((x.get_direction(), x.get_x(), x.get_y()))
+            if state not in fringe_tuple and state not in explored_tuple:  # jeżeli stan nie znajduje się na fringe oraz nie znajduje się w liście wierzchołków odwiedzonych
+                x = Node(action, state[0], elem, state[1], state[2])  # stworzenie nowego wierzchołka, którego rodzicem jest elem
+                fringe.append(x)  # dodanie wierzchołka na fringe
+
+
+def print_moves(elem):
+    moves_list = []
+    while (elem.get_parent() != None):
+        moves_list.append(elem.get_action())
+        elem = elem.get_parent()
+    moves_list.reverse()
+    return moves_list
+
+
+def succ(elem):
+    actions_list = []
+    temp = copy.copy(elem.get_direction())
+
+    if temp == 1:
+        temp = 4
+    else:
+        temp = temp - 1
+
+    actions_list.append(("rotate_right", (temp, elem.get_x(), elem.get_y())))
+    temp = copy.copy(elem.get_direction())
+
+    if temp == 4:
+        temp = 1
+    else:
+        temp = temp + 1
+
+    actions_list.append(("rotate_left", (temp, elem.get_x(), elem.get_y())))
+    temp_move_south = elem.get_y() - 1
+    temp_move_west = elem.get_x() - 1
+    temp_move_east = elem.get_x() + 1
+    temp_move_north = elem.get_y() + 1
+
+
+    if cart.Cart.is_move_allowed_succ(elem) == "x + 1":
+        actions_list.append(("move", (elem.get_direction(), temp_move_east, elem.get_y())))
+    elif cart.Cart.is_move_allowed_succ(elem) == "y + 1":
+        actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_north)))
+    elif cart.Cart.is_move_allowed_succ(elem) == "y - 1":
+        actions_list.append(("move", (elem.get_direction(), elem.get_x(), temp_move_south)))
+    elif cart.Cart.is_move_allowed_succ(elem) == "x - 1":
+        actions_list.append(("move", (elem.get_direction(), temp_move_west, elem.get_y())))
+
+
+
+
+
+    return actions_list

board.py

@@ -0,0 +1,71 @@
+import pygame
+from screen import SCREEN
+global BLACK
+
+# global SCREEN
+global BLACK
+global gridObjects
+global imgTree
+global imgTree
+imgTree = pygame.image.load('img/tree.png')
+
+gridObjects = {}  # Store grid-box objects from Grid Class
+
+class Grid(object):
+    #  ta klasa rysuje kratę na ekranie
+    def __init__(self, x, y, sx, sy):
+        self.x = x
+        self.y = y
+        self.sx = sx
+        self.sy = sy
+        self.width = 1
+
+    def draw(self):
+        # global SCREEN
+        global BLACK
+        # SCREEN = pygame.display.set_mode([600,650])
+        BLACK = (0, 0, 0)
+        pygame.draw.rect(SCREEN, BLACK, (self.x, self.y, self.sx, self.sy), self.width)
+
+class Box(object):
+    # global SCREEN
+
+    def __init__(self, x, y, sx, sy, color):
+        self.x = x
+        self.y = y
+        self.sx = sx
+        self.sy = sy
+        self.color = color
+
+    def draw(self):
+        # global SCREEN
+        # SCREEN = pygame.display.set_mode([600,650])
+        # global BLACK
+        pygame.draw.rect(SCREEN, self.color, pygame.Rect(self.x, self.y, self.sx, self.sy))
+
+class Obstacle(object):
+    def __init__(self, mouseObj):
+        self.mseX = mouseObj[0]
+        self.mseY = mouseObj[1]
+
+        for grid in gridObjects:
+            g = getGridBoxes(grid)
+            self.x = g.x
+            self.y = g.y
+            self.sx = g.sx
+            self.sy = g.sy
+            if self.mseX > self.x and self.mseX < self.x + self.sx:
+                if self.mseY > self.y and self.mseY < self.y + self.sy:
+                    self.posX = self.x
+                    self.posY = self.y
+                    self.gridBox = grid
+
+    def draw(self):
+        # pygame.draw.rect(SCREEN, GREY, pygame.Rect(self.posX, self.posY, self.sx, self.sy))
+        global imgTree
+        SCREEN.blit(imgTree, (self.posX, self.posY))
+        # pygame.display.update()
+
+def getGridBoxes(grid_box):
+       global gridObjects
+       return gridObjects[grid_box]

cart.py

@@ -0,0 +1,77 @@
+import definitions
+
+
+class Cart:
+    def __init__(self, direction, x, y):
+        self.direction = direction  # w którą stronę patrzy, zgodnie ze wskazówkami zegara (1 -: godzina 12, 2 : godzina 3, 3 : godzina 6, 4 : godzina 9)
+        self.x = x
+        self.y = y
+
+    def get_direction(self):
+        return self.direction
+
+    def set_direction(self, direction):
+        self.direction = direction
+
+    def get_x(self):
+        return self.x
+
+    def set_x(self, x):
+        self.x = x
+
+    def get_y(self):
+        return self.y
+
+    def set_y(self, y):
+        self.y = y
+
+
+    def is_move_allowed(self,
+                        cart_rect):  # sprawdza czy dany ruch, który chce wykonać wózek jest możliwy, zwraca prawdę lub fałsz
+        if self.direction == definitions.CART_DIRECTION_EAST and cart_rect.x + definitions.BLOCK_SIZE < definitions.WIDTH_MAP:
+            return True
+        elif self.direction == definitions.CART_DIRECTION_SOUTH and cart_rect.y - definitions.BLOCK_SIZE >= 0:
+            return True
+        elif self.direction == definitions.CART_DIRECTION_NORTH and cart_rect.y + definitions.BLOCK_SIZE < definitions.HEIGHT_MAP:
+            return True
+        elif self.direction == definitions.CART_DIRECTION_WEST and cart_rect.x - definitions.BLOCK_SIZE >= 0:
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def is_move_allowed_succ(
+            node):  # sprawdza czy dany ruch, który chce wykonać wózek jest możliwy, zwraca pozycje po wykonaniu ruchu, wersja node
+        if node.get_direction() == definitions.CART_DIRECTION_EAST and node.get_x() * definitions.BLOCK_SIZE + definitions.BLOCK_SIZE < definitions.WIDTH_MAP:
+            return "x + 1"
+        elif node.get_direction() == definitions.CART_DIRECTION_NORTH and node.get_y() * definitions.BLOCK_SIZE - definitions.BLOCK_SIZE >= 0:
+            return "y - 1"
+        elif node.get_direction() == definitions.CART_DIRECTION_SOUTH and node.get_y() * definitions.BLOCK_SIZE + definitions.BLOCK_SIZE < definitions.HEIGHT_MAP:
+            return "y + 1"
+        elif node.get_direction() == definitions.CART_DIRECTION_WEST and node.get_x() * definitions.BLOCK_SIZE - definitions.BLOCK_SIZE >= 0:
+            return "x - 1"
+        else:
+            return False
+
+    def move(self):
+        if self.direction == definitions.CART_DIRECTION_EAST:
+            self.x = self.x + definitions.BLOCK_SIZE
+        elif self.direction == definitions.CART_DIRECTION_NORTH:
+            self.y = self.y + definitions.BLOCK_SIZE
+        elif self.direction == definitions.CART_DIRECTION_SOUTH:
+            self.y = self.y - definitions.BLOCK_SIZE
+        elif self.direction == definitions.CART_DIRECTION_WEST:
+            self.x = self.x - definitions.BLOCK_SIZE
+
+    def rotate_right(self):
+        if self.direction == 1:
+            self.direction = 4
+        else:
+            self.direction = self.direction - 1
+
+    def rotate_left(self):
+        if self.direction == 4:
+            self.direction = 1
+        else:
+            self.direction = self.direction + 1
+

classes.py

@@ -0,0 +1,24 @@
+class Field:
+    def __init__(self, fieldType, plantType, isWet, wetTime, isFertilized, fertilizedTime):
+        self.fieldType =fieldType              #  good/bad
+        self.plantType =plantType              #  wheat/carrot/cabbage
+        self.isWet =isWet                      #  yes/no
+        self.wetTime =wetTime                  #  number
+        self.isFertilized =isFertilized        #  yes/no
+        self.fertilizedTime =fertilizedTime    #  number
+
+class Plant:
+    def __init__(self, plantType, growthState):
+        self.plantType = plantType              # wheat/carrot/cabbage
+        self.growthState = growthState          # growing/grown
+
+
+class Fertilizer:
+    def __init__(self, fertilizerType):
+        self.fertilizerType = fertilizerType    # wheat/carrot/cabbage
+
+
+class Player:
+    x = 0
+    y = 0
+    rotation = 0

definitions.py

@@ -0,0 +1,24 @@
+# definicje
+import os
+import pygame
+
+pygame.init()
+BLOCK_SIZE = 50
+
+WHEAT_COST = 2
+CARROT_COST = 5
+CABBAGE_COST = 13
+TREE_COST = 100000
+DIRT_COST = 1
+WET_DIRT_COST = 4
+
+CART_DIRECTION_EAST = 1
+CART_DIRECTION_NORTH = 2
+CART_DIRECTION_SOUTH = 4
+CART_DIRECTION_WEST = 3
+
+HEIGHT_AMOUNT, WIDTH_AMOUNT = 11, 11
+HEIGHT_MAP, WIDTH_MAP = BLOCK_SIZE * HEIGHT_AMOUNT, BLOCK_SIZE * WIDTH_AMOUNT
+HEIGHT, WIDTH = HEIGHT_MAP + BLOCK_SIZE, WIDTH_MAP
+IMAGE_SIZE_NEURAL_NETWORK = 16
+WINDOW = pygame.display.set_mode((WIDTH, HEIGHT))

main.py

@@ -1,105 +1,699 @@
 import pygame
 
+import astar
+from classes import Field, Plant, Fertilizer, Player
+from bfs import Node
+from bfs import Istate, print_moves, succ
+from bfs import graphsearch
+from board import Grid, Box, Obstacle, getGridBoxes, gridObjects
+from screen import SCREEN
 
-class Field:
+# pygame.init()
-    def __init__(self, fieldType, plantType, isWet, wetTime, isFertilized, fertilizedTime):
+
-        self.fieldType = fieldType              # good/bad
+# Game Constants
-        self.plantType = plantType              # wheat/carrot/cabbage
+Ucelu = False
-        self.isWet = isWet                      # yes/no
+SCREENX = 500
-        self.wetTime = wetTime                  # number
+SCREENY = 500
-        self.isFertilized = isFertilized        # yes/no
+
-        self.fertilizedTime = fertilizedTime    # number
+pygame.display.set_caption('Inteligentny Traktor')
+
+# COLORS
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+RED = (255, 0, 0)
+GREEN = (0, 255, 0, 0)
+BLUE = (0, 0, 255, 0)
+GREY = (128, 128, 128)
+
+CLOCK = pygame.time.Clock()
+FPS = 30
+DELAY = 300
+
+#  np. 10 pól x 10 pól = 100 pól
+GRIDX = 10
+GRIDY = 10
+
+obstacleObjects = {}  # Store the obstacle objects (Blocks on the path) from Obstacle class
+# global gridObjects
+# gridObjects = {}  # Store grid-box objects from Grid Class
+gridObstacle = {}  # Store the grid:obstacle pair stuck together
+boxObjects = {}
+boxes = 1
+obstacles = 1
+
+# BFS Variables
 
 
-class Plant:
+
-    def __init__(self, plantType, growthState):
+startNode = Istate( 1,1,1)
-        self.plantType = plantType              # wheat/carrot/cabbage
+goalNode = [1,1]
-        self.growthState = growthState          # growing/grown
+
+graph = dict()
+pathFound = []  # Store the path in a list  box index to draw on later
+
+def drawGrid(sizex,sizey):
+    spaceX = SCREENX // sizex
+    spaceY = SCREENY // sizey
+    width = 2
+
+    counter = 1
+    for i in range(sizex):
+        for j in range(sizey):
+            # g = Grid(i*spaceX, j*spaceY, spaceX, spaceY)
+            g = Grid(50 + i*50, 50 + j*50, spaceX, spaceY)
+            gridObjects[counter] = g
+            counter += 1
+def generateGraph(row,col):
+    # This function generates a graph based on the gridObjects instantiated!
+    sample_graph = {'A':['B','C','E'],
+                    'B':['A','D','E'],
+                    'C':['A','F','G'],
+                    'D':['B'],
+                    'E':['A','B','D'],
+                    'F':['C'],
+                    'G':['C']
+                    }
+
+    miniG = {}
+    for grid in range(len(gridObjects)):
+        grid += 1  # Synchronize index
+        mod = grid % col  # Used to check the Top and Bottom Grid Boxes!
+        gN = grid - 1
+        gS = grid + 1
+        gE = grid + col
+        gW = grid - col
+
+        # CHECK THE NEIGHBORS TO THE GRID-BOXES, ACCOUNTING FOR THE EXTREME GRID-BOXES(BORDERS)
+        if mod == 0:  # 5,10,15,20,25 - You can't go south from here (Bottom Boxes)
+            if grid > col:  # Away from the Left Border of the Screen
+                if grid > (col*row)-col:  # You are on the Right Border of the screen - You can't go East
+                    miniG[grid] = [gN, gW]
+                else:  # Away from the Right Border of the Screen - You can go East
+                    miniG[grid] = [gN, gE, gW]
+            else:  # You are on the Left Edge of the screen - You can't go West
+                miniG[grid] = [gN, gE]
+
+        elif mod == 1:  # 6,11,16,21 :> You can't go North from here (Top Boxes)
+            if grid > col:  # Away from the Left Border of the Screen
+                if grid > (col*row)-col:  # You are on the Right Border of the screen - You can't go East
+                    miniG[grid] = [gS, gW]
+                else:  # Away from the Right Border of the Screen - You can go east
+                    miniG[grid] = [gS, gE, gW]
+            else:  # You are on the Left Edge of the screen - You can't go West
+                miniG[grid] = [gS, gE]
+
+        else:  # All the rest (Not Top or Bottom Boxes) - You can go North or South
+            if grid > col:  # Away from the Left Border of the Screen
+                if grid > (col*row)-col:  # You are on the Right Border of the screen - You can't go East
+                    miniG[grid] = [gN, gS, gW]
+                else: # Away from the Right Border of the Screen - You can go East
+                    miniG[grid] = [gN, gS, gE, gW]
+            else: # You are on the Left Edge of the screen - You can't go West
+                miniG[grid] = [gN, gS, gE]
+
+    # FILTER OUT OBSTACLES FROM THE GRAPH
+    miniG2 = {}
+    for grid in range(len(gridObjects)):
+        grid += 1
+        if grid not in gridObstacle:
+            # gridObjects.remove(grid) # Dict object has no attribute : 'remove'
+            # HACK
+            miniG2[grid] = miniG[grid] # Created a new dictionary that stored the values required
+            # IN-DEPTH FILTER - Filter out obstacles from the neighbors-list
+            for neigbor in miniG2[grid]:
+                if neigbor in gridObstacle:
+                    miniG2[grid].remove(neigbor)
+
+    # Filtering again as the first Filter block didn't clear out everything
+    # Filtering through the neighbors
+    for grid in miniG2:
+        for item in miniG2[grid]:
+            if item in gridObstacle:
+                miniG2[grid].remove(item)
+
+    return miniG2
+
+def drawGraph(pathF):
+    #Draws the path given the path-list
+    global Ucelu
+    #print(pathF)
+
+    if (Ucelu == False):
+        for grid in pathF:
+            # g = gridObjects[grid]  # Get the grid-box object mentioned in the path
+            # x = g.x
+            # y = g.y
+            # sx = g.sx
+            # sy = g.sy
+            # a = 0
+            # pygame.draw.rect(SCREEN, GREEN, pygame.Rect(x, y, sx, sy))
+
+            if grid == 'rotate_right':
+                player.rotation = (player.rotation - 90) % 360
+            if grid == 'rotate_left':
+                player.rotation = (player.rotation + 90) %360
+
+            #( player.rotation)
+
+            if grid == 'move':
+                if player.rotation == 0:
+                    if player.x < 9:
+                        player.x = player.x + 1
+                if player.rotation == 180:
+                    if player.x > 0:
+                        player.x = player.x - 1
+                if player.rotation == 270:
+                    if player.y < 9:
+                        player.y = player.y + 1
+                if player.rotation == 90:
+                    if player.y > 0:
+                        player.y = player.y - 1
 
 
-class Fertilizer:
+            # if player.x < (x/50 - 1):
-    def __init__(self, fertilizerType):
+            #     a = 1
-        self.fertilizerType = fertilizerType    # wheat/carrot/cabbage
+            # if player.x > (x/50 - 1):
+            #     a =2
+            # if player.y < (y/50 - 1):
+            #     a =3
+            # if player.y > (y/50 - 1):
+            #     a =4
+            #
+            # if a==1:
+            #     # player.x = x/50 - 1
+            #     player.rotation = 0
+            # if a==2:
+            #     # player.x = x/50 - 1
+            #     player.rotation = 180
+            # if a==3:
+            #     # player.y = y/50 - 1
+            #     player.rotation = 270
+            # if a==4:
+            #     # player.y = y/50 - 1
+            #     player.rotation = 90
 
 
-class Player:
+        # tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
-    x = 0
+        # if player.rotation == 180:
-    y = 0
+        #     tmpImg = pygame.transform.flip(tmpImg, True, True)
-    rotation = 0
+        #     tmpImg = pygame.transform.flip(tmpImg, True, False)
+        #
+        # #player is seen on the way
+        #     SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
+        #     pygame.display.update()
+        #     # pygame.time.wait(300)
+
+            # player.y = y/50 - 1
+            # player.x = x/50 - 1
+
+            # -----------------------------
+            i = 0
+            while i < len(T):
+                j = 0
+                while j < len(T[i]):
+                    #color = (255, 255, 255, 0)
+                    if T[i][j].isWet == 0:
+                        # a = 1
+                        color = (160, 80, 40, 0)
+                    else:
+                        # a = 1
+                        color = (50, 25, 0, 0)
+
+                    #Covers 'player' on the way
+                    pygame.draw.rect(SCREEN, color, pygame.Rect(50 + 50 * i, 50 + 50 * j, 50, 50))
+                    if T[i][j].plantType == 1:
+                        SCREEN.blit(imgWheat, (50 + 50 * i, 50 + 50 * j))
+                    if T[i][j].plantType == 2:
+                        SCREEN.blit(imgCarrot, (50 + 50 * i, 50 + 50 * j))
+                    if T[i][j].plantType == 3:
+                        SCREEN.blit(imgCabbage, (50 + 50 * i, 50 + 50 * j))
+                    if T[i][j].plantType == 4:
+                        SCREEN.blit(imgTree, (50 + 50 * i, 50 + 50 * j))
+
+                    j = j + 1
+                i = i + 1
+
+            # Render the trees
+            for obs in obstacleObjects:
+                obstacleObjects[obs].draw()
 
 
-T = [[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+            for bx in boxObjects:
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+                boxObjects[bx].draw()
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+            i = 0
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+            while i < len(T)+1:
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+                pygame.draw.line(SCREEN, (0, 0, 0), (50 + i * 50, 50), (50 + i * 50, 50 + len(T) * 50), 1)
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+                pygame.draw.line(SCREEN, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 1)
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+                i = i + 1
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+
-     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)]]
+            tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
+            if player.rotation == 180:
+                tmpImg = pygame.transform.flip(tmpImg, True, True)
+                tmpImg = pygame.transform.flip(tmpImg, True, False)
+
+            #player is seen on the way
+            SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
+
+            # --------------------------------------
+
+            # tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
+            # # if flip:
+            # # if flip == True:
+            # if player.rotation == 180:
+            #     tmpImg = pygame.transform.flip(tmpImg, True, True)
+            #     tmpImg = pygame.transform.flip(tmpImg, True, False)
+            #
+            # SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
+
+            pygame.display.update()
+            pygame.time.wait(300)
+            SCREEN.fill((WHITE))
+            # pygame.time.wait(50)
+            # pygame.draw.rect(SCREEN, WHITE, pygame.Rect(x, y, sx, sy))
+            Ucelu = True
+def UIHandler(mouseObj):
+    # drawGrid(GRIDX, GRIDY)
+    global Ucelu
+    drawGrid(10,10)
+
+    for grid in gridObjects:
+        gridObjects[grid].draw()
+
+    for bx in boxObjects:
+        boxObjects[bx].draw()
+
+    for obs in obstacleObjects:
+        obstacleObjects[obs].draw()
+
+    if pathFound:
+            drawGraph(pathFound)
+            # Ucelu = False
+
+def eventHandler(kbdObj,mouseObj):
+    global boxes
+    global obstacles
+    global startNode
+    global goalNode
+    global pathFound
+    global Ucelu
+
+    if event.type == pygame.QUIT:
+        running = False
+
+    if event.type == pygame.KEYDOWN:
+        pygame.time.wait(DELAY)
+        if event.key == pygame.K_LEFT:
+            if player.x > 0:
+                player.x = player.x - 1
+                player.rotation = 180
+
+        if event.key == pygame.K_UP:
+            if player.y > 0:
+                player.y = player.y - 1
+                player.rotation = 90
+
+        if event.key == pygame.K_RIGHT:
+            if player.x < 9:
+                player.x = player.x + 1
+                player.rotation = 0
+
+        if event.key == pygame.K_DOWN:
+            if player.y < 9:
+                player.y = player.y + 1
+                player.rotation = 270
+
+        # Aga start lewo prawo, naprzód
+        if event.key == pygame.K_a:
+            player.rotation = (player.rotation + 90) % 360
+        if event.key == pygame.K_d:
+            player.rotation = (player.rotation - 90) % 360
+        if event.key == pygame.K_w:
+            if player.rotation == 0:
+                if player.x < 9:
+                    player.x = player.x + 1
+            if player.rotation == 180:
+                if player.x > 0:
+                    player.x = player.x - 1
+            if player.rotation == 270:
+                if player.y < 9:
+                    player.y = player.y + 1
+            if player.rotation == 90:
+                if player.y > 0:
+                    player.y = player.y - 1
+
+# If Key_f is pressed, set goal node
+        if kbdObj[pygame.K_f]:
+            gBox = getGridBoxes(int(len(gridObjects)))
+            # gBox = getGridBoxes()
+
+            #x = mouseObj[0]
+            #y = mouseObj[1]
+            # x = gBox.x
+            # y = gBox.y
+            sx = gBox.sx
+            sy = gBox.sy
+            # ----------------------------------------
+            mseX = mouseObj[0]
+            mseY = mouseObj[1]
+
+            for grid in gridObjects:
+                g = getGridBoxes(grid)
+                x = g.x
+                y = g.y
+                sx = g.sx
+                sy = g.sy
+                if mseX > x and mseX < x + sx:
+                    if mseY > y and mseY < y + sy:
+                        posX = x
+                        posY = y
+                        gridBox = grid
+
+            # SCREEN.blit(imgTree, (posX, posY))
+
+            # ---------------------------------------
+            bo = Box(posX, posY, sx, sy, BLUE)
+            boxObjects[boxes] = bo
+            # boxes += 1
+            boxes = 1
+            # goalNode = GRIDX*GRIDX
+            # goalNode = (10 * (x + 1) + (y + 1) - 10)
+
+            # goalNode.state = int(10 * (posX/50 ) + (posY/50) - 10)
+
+            # goalNode[0] = int((posX/50)
+            # goalNode[1] = int(posY/50) - 10
+
+            goalNode = [int(posX/50), int(posY/50)]
+            # goalNode = [10,10]
+
+            print(' goalNode x=', goalNode[0], 'goalNode y=', goalNode[1])
+
+
+
+
+            # pygame.display.update()
+
+            # goalNode = (x/sx) * (y/sy)
+            # Delay to avoid multiple spawning of objects
+            pygame.time.wait(DELAY)
+
+            # If Key_x is pressed, spawn tree
+        if kbdObj[pygame.K_x]:
+            obs = Obstacle(mouseObj)
+            obstacleObjects[obstacles] = obs
+            # print(obs.gridBox)
+            obstacles += 1
+            # print(obstacleObjects)
+            gridObstacle[obs.gridBox] = obstacles
+            # Delay to avoid multiple spawning of objects
+
+            mseX = mouseObj[0]
+            mseY = mouseObj[1]
+
+            for grid in gridObjects:
+                g = getGridBoxes(grid)
+                x = g.x
+                y = g.y
+                sx = g.sx
+                sy = g.sy
+                if mseX > x and mseX < x + sx:
+                    if mseY > y and mseY < y + sy:
+                        posX = x
+                        posY = y
+
+            T[int((posX/50)-1)][int((posY/50)-1)].plantType=4
+
+
+            pygame.display.update()
+            pygame.time.wait(DELAY)
+
+
+        # if Key_SPACE is pressed, start the magic
+        if kbdObj[pygame.K_SPACE]:
+            Ucelu = False
+            gBox = getGridBoxes(1)
+
+            x = gBox.x
+            y = gBox.y
+            sx = gBox.sx
+            sy = gBox.sy
+
+            x = (player.x +1) * 50
+            y = (player.y +1) * 50
+
+            # tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
+            # SCREEN.blit(tmpImg, (50 + 50 * player.x, 50 + 50 * player.y))
+            # pygame.display.update()
+
+            #when on it keeps flashing - among others
+            #bo = Box(x, y, sx, sy, RED)
+            #boxObjects[boxes] = bo
+
+            # boxes += 1
+            boxes = 1
+
+            # startNode.state = (10 * (player.x + 1) + (player.y + 1) - 10)
+
+            startNode.x = player.x + 1
+            startNode.y = player.y + 1
+
+            if player.rotation == 0:
+                startNode.direction = 1
+            elif player.rotation == 90:
+                startNode.direction = 2
+            elif player.rotation == 180:
+                startNode.direction = 3
+            elif player.rotation == 270:
+                startNode.direction = 4
+
+            print(' startNode x=', startNode.x, 'startNode y= ', startNode.y, 'startNode direction =', startNode.direction)
+
+            graph = generateGraph(GRIDY,GRIDX)
+            print(graph)
+
+            # if startNode != goalNode:
+            if startNode.x != goalNode[0] or startNode.y != goalNode[1]:
+                elem = []
+
+
+                move_list = (graphsearch([], [], goalNode, startNode))  # przeszukiwanie grafu wszerz
+
+                pathFound = move_list
+
+                # pathFound = bfs.graphsearch()
+                print('akcje które wykonuję by znalezc sie u celu')
+                print(move_list)
+                print('\n')
+            # Delay to avoid multiple spawning of objects
+            pygame.time.wait(DELAY)
+            # startNode = goalNode
+
+
+        if kbdObj[pygame.K_b]:
+            Ucelu = False
+            gBox = getGridBoxes(1)
+
+            x = gBox.x
+            y = gBox.y
+            sx = gBox.sx
+            sy = gBox.sy
+
+            x = (player.x +1) * 50
+            y = (player.y +1) * 50
+
+            # tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
+            # SCREEN.blit(tmpImg, (50 + 50 * player.x, 50 + 50 * player.y))
+            # pygame.display.update()
+
+            #when on it keeps flashing - among others
+            #bo = Box(x, y, sx, sy, RED)
+            #boxObjects[boxes] = bo
+
+            # boxes += 1
+            boxes = 1
+
+            # startNode.state = (10 * (player.x + 1) + (player.y + 1) - 10)
+
+            startNode.x = player.x + 1
+            startNode.y = player.y + 1
+
+            if player.rotation == 0:
+                startNode.direction = 1
+            elif player.rotation == 90:
+                startNode.direction = 2
+            elif player.rotation == 180:
+                startNode.direction = 3
+            elif player.rotation == 270:
+                startNode.direction = 4
+
+            print(' startNode x=', startNode.x, 'startNode y= ', startNode.y, 'startNode direction =', startNode.direction)
+
+            # startNode = (((player.x + 1)*10 - 9) * (player.y + 1) )
+            # startNode = 2
+
+            # tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
+            # SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
+            # pygame.display.update()
+
+            # Delay to avoid multiple spawning of objects
+            #pygame.time.wait(DELAY)
+
+            graph = generateGraph(GRIDY,GRIDX)
+            print(graph)
+
+            # if startNode != goalNode:
+            if startNode.x != goalNode[0] or startNode.y != goalNode[1]:
+                elem = []
+
+                move_list = (astar.graphsearch([], astar.f, [], goalNode, startNode, T, succ))  # przeszukiwanie grafu wszerz
+
+                pathFound = move_list
+
+                # pathFound = bfs.graphsearch()
+                print('akcje które wykonuję by znalezc sie u celu')
+                print(move_list)
+                print('\n')
+
+
+            # else:
+            #     startNode = (10 * (player.x + 1) + (player.y + 1) - 10)
+            # Ucelu = True
+
+            # Delay to avoid multiple spawning of objects
+            pygame.time.wait(DELAY)
+
+        #With it it keeps going, if without it turns off
+
+        # Ucelu = False
+
+T = [[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,2,1,0,0,0),Field(1,3,0,0,0,0),Field(0,3,0,0,0,0),Field(0,0,1,0,0,0),Field(0,0,0,0,0,0),Field(1,3,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,0,1,0,0,0),Field(1,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,3,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(0,2,1,0,0,0),Field(0,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,0,0,0,0),Field(0,2,1,0,0,0),Field(0,1,1,0,0,0),Field(0,0,0,0,0,0),Field(1,3,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,1,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,1,0,0,0,0),Field(0,0,0,0,0,0),Field(1,3,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,3,0,0,0,0),Field(0,3,1,0,0,0),Field(1,2,1,0,0,0),Field(1,1,1,0,0,0),Field(0,1,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,3,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,1,0,0,0,0),Field(0,2,0,0,0,0),Field(0,1,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,0,1,0,0,0),Field(0,0,1,0,0,0),Field(0,1,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,3,1,0,0,0),Field(1,2,1,0,0,0),Field(0,0,1,0,0,0),Field(0,0,0,0,0,0),Field(0,1,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,0,0,0,0),Field(0,2,0,0,0,0),Field(1,1,0,0,0,0),Field(1,0,1,0,0,0),Field(0,2,1,0,0,0),Field(0,3,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
+     [Field(1,0,1,0,0,0),Field(0,0,0,0,0,0),Field(1,1,1,0,0,0),Field(1,0,0,0,0,0),Field(0,1,1,0,0,0),Field(0,0,1,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)]]
+
+
+#T = [[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,2,1,0,0,0),Field(1,3,0,0,0,0),Field(0,3,0,0,0,0),Field(0,0,1,0,0,0),Field(0,3,0,0,0,0),Field(1,0,1,0,0,0),Field(1,3,0,0,0,0),Field(1,2,1,0,0,0)],
+#     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,0,1,0,0,0),Field(1,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(0,2,0,0,0,0),Field(1,1,0,0,0,0),Field(1,0,1,0,0,0),Field(1,1,0,0,0,0)],
+#     [Field(0,2,1,0,0,0),Field(0,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,0,0,0,0),Field(0,2,1,0,0,0),Field(0,1,1,0,0,0),Field(0,2,0,0,0,0),Field(1,0,0,0,0,0),Field(1,0,0,0,0,0),Field(1,1,0,0,0,0)],
+#     [Field(1,0,1,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,1,0,0,0,0),Field(0,0,0,0,0,0),Field(1,2,0,0,0,0),Field(1,0,0,0,0,0),Field(1,0,0,0,0,0)],
+#     [Field(1,3,0,0,0,0),Field(0,3,1,0,0,0),Field(1,2,1,0,0,0),Field(1,1,1,0,0,0),Field(0,1,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,0,1,0,0,0),Field(1,3,0,0,0,0),Field(1,0,1,0,0,0)],
+#     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,1,0,0,0,0),Field(0,2,0,0,0,0),Field(0,1,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,1,1,0,0,0)],
+#     [Field(1,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,0,1,0,0,0),Field(0,0,1,0,0,0),Field(0,1,0,0,0,0),Field(1,2,1,0,0,0),Field(1,2,1,0,0,0),Field(1,0,0,0,0,0)],
+#     [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,3,1,0,0,0),Field(1,2,1,0,0,0),Field(0,0,1,0,0,0),Field(0,0,0,0,0,0),Field(0,1,1,0,0,0),Field(1,0,0,0,0,0),Field(1,1,1,0,0,0),Field(1,1,1,0,0,0)],
+#     [Field(1,0,0,0,0,0),Field(0,2,0,0,0,0),Field(1,1,0,0,0,0),Field(1,0,1,0,0,0),Field(0,2,1,0,0,0),Field(0,3,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,0,0,0,0),Field(1,2,1,0,0,0),Field(1,2,1,0,0,0)],
+#     [Field(1,0,1,0,0,0),Field(0,0,0,0,0,0),Field(1,1,1,0,0,0),Field(1,0,0,0,0,0),Field(0,1,1,0,0,0),Field(0,0,1,0,0,0),Field(0,1,0,0,0,0),Field(1,1,1,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0)]]
+
+
+
+# =========================================================================================
+# no i tutaj mamy główna pętlę programu
 
 pygame.init()
 
 player = Player()
-
-screen = pygame.display.set_mode([600, 600])
-
 running = True
-clock = pygame.time.Clock()
+# clock = pygame.time.Clock()
-while running:
-    for event in pygame.event.get():
-        if event.type == pygame.QUIT:
-            running = False
-        if event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_LEFT:
-                if player.x > 0:
-                    player.x = player.x - 1
-            if event.key == pygame.K_UP:
-                if player.y > 0:
-                    player.y = player.y - 1
-            if event.key == pygame.K_RIGHT:
-                if player.x < 9:
-                    player.x = player.x + 1
-            if event.key == pygame.K_DOWN:
-                if player.y < 9:
-                    player.y = player.y + 1
 
-    screen.fill((175, 255, 50))
+SCREEN.fill(WHITE)
+
+while running:
+
+    for event in pygame.event.get():
+        kbd = pygame.key.get_pressed()
+        mse = pygame.mouse.get_pos()
+        UIHandler(mse)
+        eventHandler(kbd, mse)
+    pygame.display.update()
+    # CLOCK.tick(FPS)
+
+    #screen.fill((175, 255, 50, 0))
+
+    # SCREEN.fill((WHITE))
     imgWheat = pygame.image.load('img/wheat.png')
     imgCarrot = pygame.image.load('img/carrot.png')
     imgCabbage = pygame.image.load('img/cabbage.png')
     imgPlayer = pygame.image.load('img/player.png')
+    global imgTree
+    imgTree = pygame.image.load('img/tree.png')
+    # pygame.display.update()
 
     i = 0
     while i < len(T):
         j = 0
         while j < len(T[i]):
-            color = (0, 0, 0)
+            # color = (255, 255, 255, 0)
             if T[i][j].isWet == 0:
-                color = (160, 80, 40)
+                # a = 1
+                color = (160, 80, 40, 0)
             else:
-                color = (50, 25, 0)
+                # a = 1
-            pygame.draw.rect(screen, color, pygame.Rect(50 + 50 * i, 50 + 50 * j, 50, 50))
+                color = (50, 25, 0, 0)
+            #colour from the beginning
+            pygame.draw.rect(SCREEN, color, pygame.Rect(50 + 50 * i, 50 + 50 * j, 50, 50))
             if T[i][j].plantType == 1:
-                screen.blit(imgWheat, (50 + 50 * i, 50 + 50 * j))
+                SCREEN.blit(imgWheat, (50 + 50 * i, 50 + 50 * j))
             if T[i][j].plantType == 2:
-                screen.blit(imgCarrot, (50 + 50 * i, 50 + 50 * j))
+                SCREEN.blit(imgCarrot, (50 + 50 * i, 50 + 50 * j))
             if T[i][j].plantType == 3:
-                screen.blit(imgCabbage, (50 + 50 * i, 50 + 50 * j))
+                SCREEN.blit(imgCabbage, (50 + 50 * i, 50 + 50 * j))
+            if T[i][j].plantType == 4:
+                SCREEN.blit(imgTree, (50 + 50 * i, 50 + 50 * j))
+
+
             j = j + 1
         i = i + 1
 
     i = 0
     while i < len(T)+1:
-        pygame.draw.line(screen, (0, 0, 0), (50 + i * 50, 50), (50 + i * 50, 50 + len(T) * 50), 5)
+        pygame.draw.line(SCREEN, (0, 0, 0), (50 + i * 50, 50), (50 + i * 50, 50 + len(T) * 50), 1)
-        pygame.draw.line(screen, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 5)
+        pygame.draw.line(SCREEN, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 1)
         i = i + 1
 
+    for obs in obstacleObjects:
+        obstacleObjects[obs].draw()
+
+    # if startNode.state != goalNode.state:
+    if startNode.x != goalNode[0] or startNode.y != goalNode[1] :
+        for bx in boxObjects:
+            boxObjects[bx].draw()
+
+
     tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
-    screen.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
+    if player.rotation == 180:
-    pygame.display.flip()
+        tmpImg = pygame.transform.flip(tmpImg, True, True)
-# clock.tick(30)
+        tmpImg = pygame.transform.flip(tmpImg, True, False)
+
+    #player seen at the beginning
+    SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
+
+
+
+    # if Ucelu == False:
+    #     for bx in boxObjects:
+    #         boxObjects[bx].draw()
+
+
+    font = pygame.font.SysFont('comicsans', 18)
+    label = font.render('f- punkt końcowy, x- drzewa, spacja- uruchomienie', 1, (0, 0, 0))
+    label1 = font.render('strzałki-ręczne poruszanie traktorem,', 1, (0, 0, 0))
+    label2 = font.render('a- obrót w lewo, d- w prawo, w-ruch naprzód', 1, (0, 0, 0))
+    label3 = font.render('b - uruchom A*', 1, (0, 0, 0))
+    SCREEN.blit(label, (10, 570))
+    SCREEN.blit(label1, (10, 590))
+    SCREEN.blit(label2, (10, 610))
+    SCREEN.blit(label3, (10, 630))
+
+    # pygame.display.flip()
+
+    pygame.display.update()
+    CLOCK.tick(FPS)
 
 # Done! Time to quit.
 

screen.py

@@ -0,0 +1,2 @@
+import pygame
+SCREEN = pygame.display.set_mode([600,665])