Merge pull request 'small fix + pygad install' (#3) from fix into master

Reviewed-on: #3

NN/Generator.py

@@ -15,7 +15,6 @@ b = [Image.open("b1.png").convert('RGBA'), Image.open("b2.png").convert('RGBA'),
 
 
 def generate(water, fertilizer, plantf):
-    new_im = None
     if water == 1:
         new_im = Image.new('RGB', (100, 100),
                            (160 + random.randint(-10, 10), 80 + random.randint(-10, 10), 40 + random.randint(-10, 10)))
@@ -81,4 +80,3 @@ for x in range(0, 1000):
     generate(0, 1, random.randint(0, 2)).save('datasets/01/' + str(x) + '.png')
 for x in range(0, 1000):
     generate(1, 1, random.randint(0, 2)).save('datasets/11/' + str(x) + '.png')
-

NN/trainer.py

@@ -2,13 +2,14 @@ import pathlib
 import random
 
 import torch
-from PIL.Image import Image
 from torch import nn
 from torch.utils.data import DataLoader
 from torchvision import datasets, transforms
 from torchvision.transforms import Lambda
 
-device = torch.device('cuda')
+
+device = torch.device('cpu')
+
 
 def train(model, dataset, n_iter=100, batch_size=2560000):
     optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
@@ -40,7 +41,7 @@ train_data = datasets.ImageFolder(root="./datasets",
                                   transform=data_transform,
                                   target_transform=None)
 
-model1=nn.Sequential(nn.Linear(30000, 10000),nn.ReLU(),nn.Linear(10000,10000),nn.ReLU(),nn.Linear(10000,10000),nn.Linear(10000,4),nn.LogSoftmax(dim=-1)).to(device)
+model1 = nn.Sequential(nn.Linear(30000, 10000), nn.ReLU(), nn.Linear(10000, 10000), nn.ReLU(), nn.Linear(10000, 0000), nn.Linear(10000, 4), nn.LogSoftmax(dim=-1)).to(device)
 model1.load_state_dict(torch.load("./trained"))
 train(model1, train_data)
 

astar.py

@@ -1,7 +1,6 @@
 from operator import itemgetter
 import cart
 import copy
-from classes import Field
 
 
 class Istate:
@@ -92,7 +91,7 @@ def fieldCost(T,node):
 def cost(T, node):
     cost = 0
 
-    while (node.get_parent() != None):
+    while node.get_parent() is not None:
         cost = cost + fieldCost(T, node)
         node = node.get_parent()
 
@@ -154,7 +153,7 @@ def heuristic(goaltest, node):
 
 def print_moves(elem):
     moves_list = []
-    while (elem.get_parent() != None):
+    while elem.get_parent() is not None:
         moves_list.append(elem.get_action())
         elem = elem.get_parent()
     moves_list.reverse()
@@ -184,7 +183,6 @@ def succ(elem):
     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":
@@ -194,8 +192,4 @@ def succ(elem):
     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

@@ -1,4 +1,3 @@
-import sys
 import cart
 import copy
 
@@ -74,16 +73,12 @@ def goal_test(goaltest,elem):
         return False
 
 
-# def graphsearch(explored, fringe, goaltest, istate, succ):  # przeszukiwanie grafu wszerz
+def graphsearch(goaltest, istate):  # 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
@@ -109,7 +104,7 @@ def graphsearch(explored, fringe, goaltest, istate):  # przeszukiwanie grafu wsz
 
 def print_moves(elem):
     moves_list = []
-    while (elem.get_parent() != None):
+    while elem.get_parent() is not None:
         moves_list.append(elem.get_action())
         elem = elem.get_parent()
     moves_list.reverse()
@@ -139,7 +134,6 @@ def succ(elem):
     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":
@@ -149,8 +143,4 @@ def succ(elem):
     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

@@ -1,6 +1,5 @@
 import pygame
 from screen import SCREEN
-global BLACK
 
 # global SCREEN
 global BLACK
@@ -8,9 +7,9 @@ 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):
@@ -27,6 +26,7 @@ class Grid(object):
         BLACK = (0, 0, 0)
         pygame.draw.rect(SCREEN, BLACK, (self.x, self.y, self.sx, self.sy), self.width)
 
+
 class Box(object):
     # global SCREEN
 
@@ -43,6 +43,7 @@ class Box(object):
         # 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]
@@ -66,6 +67,7 @@ class Obstacle(object):
         SCREEN.blit(imgTree, (self.posX, self.posY))
         # pygame.display.update()
 
+
 def getGridBoxes(grid_box):
     global gridObjects
     return gridObjects[grid_box]

cart.py

@@ -25,7 +25,6 @@ class Cart:
     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:
@@ -74,4 +73,3 @@ class Cart:
             self.direction = 1
         else:
             self.direction = self.direction + 1
-

classes.py

@@ -7,6 +7,7 @@ class Field:
         self.isFertilized = isFertilized        # yes/no
         self.fertilizedTime = fertilizedTime    # number
 
+
 class Plant:
     def __init__(self, plantType, growthState):
         self.plantType = plantType              # wheat/carrot/cabbage

decisionTree/generator.py

@@ -1,5 +1,6 @@
 import random
 
+
 # Generowanie unikalnej losowej linii tekstu
 def generate_unique_line(existing_lines):
     while True:
@@ -9,6 +10,7 @@ def generate_unique_line(existing_lines):
         if line not in existing_lines:
             return line
 
+
 # Generowanie 200 unikalnych linii tekstu
 lines = []
 while len(lines) < 200:

decisionTree/treemaker.py

@@ -1,5 +1,3 @@
-
-
 # from sklearn.datasets import load_iris
 from sklearn.tree import export_text
 

definitions.py

@@ -1,5 +1,3 @@
-# definicje
-import os
 import pygame
 
 pygame.init()

main.py

@@ -1,18 +1,15 @@
 import pygame
-import pathlib
 import random
 
 import torch
 from torch import nn
-from torch.utils.data import DataLoader
 from torchvision import datasets, transforms
 from torchvision.transforms import Lambda
 from PIL import Image
 
 import astar
-from classes import Field, Plant, Fertilizer, Player
+from classes import Field, Player
-from bfs import Node
+from bfs import Istate, succ
-from bfs import Istate, print_moves, succ
 from bfs import graphsearch
 from board import Grid, Box, Obstacle, getGridBoxes, gridObjects
 from screen import SCREEN
@@ -40,8 +37,8 @@ plants[2].append(Image.open("NN/ca2.png"))
 plants[2].append(Image.open("NN/ca3.png"))
 b = [Image.open("NN/b1.png").convert('RGBA'), Image.open("NN/b2.png").convert('RGBA'), Image.open("NN/b3.png").convert('RGBA')]
 
+
 def generate(water, fertilizer, plantf):
-    new_im = None
     if water == 1:
         new_im = Image.new('RGB', (100, 100),
                            (160 + random.randint(-10, 10), 80 + random.randint(-10, 10), 40 + random.randint(-10, 10)))
@@ -98,6 +95,7 @@ def generate(water, fertilizer, plantf):
 
     return new_im
 
+
 # COLORS
 WHITE = (255, 255, 255)
 BLACK = (0, 0, 0)
@@ -124,18 +122,16 @@ obstacles = 1
 
 # BFS Variables
 
-
-
 startNode = Istate(1, 1, 1)
 goalNode = [1, 1]
 
 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):
@@ -144,16 +140,18 @@ def drawGrid(sizex,sizey):
             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'],
+    # sample_graph = {'A': ['B', 'C', 'E'],
-                    'B':['A','D','E'],
+    #                'B': ['A', 'D', 'E'],
-                    'C':['A','F','G'],
+    #                'C': ['A', 'F', 'G'],
-                    'D':['B'],
+    #                'D': ['B'],
-                    'E':['A','B','D'],
+    #                'E': ['A', 'B', 'D'],
-                    'F':['C'],
+    #                'F': ['C'],
-                    'G':['C']
+    #                'G': ['C']
-                    }
+    #                }
 
     miniG = {}
     for grid in range(len(gridObjects)):
@@ -214,12 +212,13 @@ def generateGraph(row,col):
 
     return miniG2
 
+
 def drawGraph(pathF):
     # Draws the path given the path-list
     global Ucelu
     # print(pathF)
 
-    if (Ucelu == False):
+    if not Ucelu:
         for grid in pathF:
             # g = gridObjects[grid]  # Get the grid-box object mentioned in the path
             # x = g.x
@@ -250,44 +249,6 @@ def drawGraph(pathF):
                     if player.y > 0:
                         player.y = player.y - 1
 
-
-            # if player.x < (x/50 - 1):
-            #     a = 1
-            # 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
-
-
-        # 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))
-        #     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
@@ -318,7 +279,6 @@ def drawGraph(pathF):
             for obs in obstacleObjects:
                 obstacleObjects[obs].draw()
 
-
             for bx in boxObjects:
                 boxObjects[bx].draw()
 
@@ -336,24 +296,15 @@ def drawGraph(pathF):
             # 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))
+            SCREEN.fill(WHITE)
             # pygame.time.wait(50)
             # pygame.draw.rect(SCREEN, WHITE, pygame.Rect(x, y, sx, sy))
             Ucelu = True
-def UIHandler(mouseObj):
+
+
+def UIHandler():
     # drawGrid(GRIDX, GRIDY)
     global Ucelu
     drawGrid(10, 10)
@@ -369,7 +320,7 @@ def UIHandler(mouseObj):
 
     if pathFound:
         drawGraph(pathFound)
-            # Ucelu = False
+
 
 def eventHandler(kbdObj, mouseObj):
     global boxes
@@ -380,7 +331,7 @@ def eventHandler(kbdObj,mouseObj):
     global Ucelu
 
     if event.type == pygame.QUIT:
-        running = False
+        pygame.quit()
 
     if event.type == pygame.KEYDOWN:
         pygame.time.wait(DELAY)
@@ -426,15 +377,10 @@ def eventHandler(kbdObj,mouseObj):
 # 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]
 
@@ -444,15 +390,11 @@ def eventHandler(kbdObj,mouseObj):
                 y = g.y
                 sx = g.sx
                 sy = g.sy
-                if mseX > x and mseX < x + sx:
+                if x < mseX < x + sx:
-                    if mseY > y and mseY < y + sy:
+                    if y < 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
@@ -470,9 +412,6 @@ def eventHandler(kbdObj,mouseObj):
 
             print(' goalNode x=', goalNode[0], 'goalNode y=', goalNode[1])
 
-
-
-
             # pygame.display.update()
 
             # goalNode = (x/sx) * (y/sy)
@@ -527,44 +466,22 @@ def eventHandler(kbdObj,mouseObj):
                 y = g.y
                 sx = g.sx
                 sy = g.sy
-                if mseX > x and mseX < x + sx:
+                if x < mseX < x + sx:
-                    if mseY > y and mseY < y + sy:
+                    if y < 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
 
@@ -582,12 +499,9 @@ def eventHandler(kbdObj,mouseObj):
             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
-                move_list = (graphsearch([], [], goalNode, startNode))  # przeszukiwanie grafu wszerz
 
                 pathFound = move_list
 
@@ -599,32 +513,11 @@ def eventHandler(kbdObj,mouseObj):
             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
 
@@ -639,22 +532,11 @@ def eventHandler(kbdObj,mouseObj):
 
             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
 
@@ -665,17 +547,11 @@ def eventHandler(kbdObj,mouseObj):
                 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)],
@@ -688,20 +564,6 @@ 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(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
 
@@ -718,7 +580,7 @@ while running:
     for event in pygame.event.get():
         kbd = pygame.key.get_pressed()
         mse = pygame.mouse.get_pos()
-        UIHandler(mse)
+        UIHandler()
         eventHandler(kbd, mse)
     pygame.display.update()
     # CLOCK.tick(FPS)
@@ -756,7 +618,6 @@ while running:
             if T[i][j].plantType == 4:
                 SCREEN.blit(imgTree, (50 + 50 * i, 50 + 50 * j))
 
-
             j = j + 1
         i = i + 1
 
@@ -774,7 +635,6 @@ while running:
         for bx in boxObjects:
             boxObjects[bx].draw()
 
-
     tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
     if player.rotation == 180:
         tmpImg = pygame.transform.flip(tmpImg, True, True)
@@ -783,21 +643,14 @@ while running:
     # player seen at the beginning
     SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
 
-
+    font = pygame.font.SysFont('comicsans', 22)
-
+    label = font.render('F - cel | X - drzewo', True, (0, 0, 0))
-    # if Ucelu == False:
+    label1 = font.render('ARROWS - ręczne poruszanie', True, (0, 0, 0))
-    #     for bx in boxObjects:
+    label2 = font.render('A - lewo | D - prawo | W - ruch', True, (0, 0, 0))
-    #         boxObjects[bx].draw()
+    label3 = font.render('SPACE - start BFS | B - start A*', True, (0, 0, 0))
-
+    SCREEN.blit(label, (10, 555))
-
+    SCREEN.blit(label1, (10, 580))
-    font = pygame.font.SysFont('comicsans', 18)
+    SCREEN.blit(label2, (10, 605))
-    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()