From 101136b0b7f3d00a26c84b36b7b8c386e28d9e0b Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Sun, 19 Mar 2023 22:00:10 +0100 Subject: [PATCH 1/7] radius Fix --- Interface/grid_draw.py | 8 ++++---- Interface/vacuum_render.py | 26 +++++++++++++++----------- 2 files changed, 19 insertions(+), 15 deletions(-) diff --git a/Interface/grid_draw.py b/Interface/grid_draw.py index 5335dee..b40a406 100644 --- a/Interface/grid_draw.py +++ b/Interface/grid_draw.py @@ -10,6 +10,7 @@ class Colors: DEFAULT_COLOR = Colors.WHITE +RADIUS_SIZE_COEFFICIENT = 3 def default_color(func): @@ -53,7 +54,6 @@ class GridDraw: self.line(0, tiles_height * i, self.width, tiles_height * i, color=color) @default_color - def circle(self, x, y, radius, color=None): - pygame.draw.circle( - self.screen, color, (x, y), radius - ) # TODO calculate radius (now 20) in terms of window size. + def circle(self, x, y, tile_height, color=None): + radius = tile_height / RADIUS_SIZE_COEFFICIENT + pygame.draw.circle(self.screen, color, (x, y), radius) diff --git a/Interface/vacuum_render.py b/Interface/vacuum_render.py index b5007fe..6d9bc79 100644 --- a/Interface/vacuum_render.py +++ b/Interface/vacuum_render.py @@ -4,31 +4,35 @@ import pygame from Interface.movement import robot_movement -def initial_draw(grid_dimensions, board_size): +# window_dimensions says how many pixels window have +# board_size says how many lines board have +def initial_draw(window_dimensions, board_size): # window name pygame.display.set_caption("AI Vacuum Cleaner") # define array for grid - border_array = [["" for j in range(board_size)] for i in range(board_size)] + board_array = [["" for j in range(board_size)] for i in range(board_size)] + board_render(board_array) # set window dimension - grid_width = grid_dimensions - grid_height = grid_dimensions + window_width = window_dimensions + window_height = window_dimensions # FIXME @countingthedots: please tell me what is going on there and why??? - # - grid = GridDraw(grid_width, grid_height) - tile_width = grid_width / board_size - tile_height = grid_height / board_size + # + grid = GridDraw(window_width, window_height) + tile_width = window_width / board_size + tile_height = window_height / board_size x = tile_width / 2 y = tile_height / 2 - radius = tile_height/3 # rendering loop while True: grid.start_draw() grid.board(board_size, board_size) - (x, y) = robot_movement(grid_width, grid_height, tile_width, tile_height, x, y) - grid.circle(x, y, radius, color=Colors.RED) + (x, y) = robot_movement( + window_width, window_height, tile_width, tile_height, x, y + ) + grid.circle(x, y, tile_height, color=Colors.RED) grid.end_draw() pygame.time.delay(10) From e37a889e1e279300abbd07df460e2eedb1c42cfe Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Mon, 20 Mar 2023 01:14:48 +0100 Subject: [PATCH 2/7] Array Grid --- Interface/grid_draw.py | 4 +- Interface/vacuum_render.py | 106 +++++++++++++++++++++++++++++++++---- 2 files changed, 98 insertions(+), 12 deletions(-) diff --git a/Interface/grid_draw.py b/Interface/grid_draw.py index b40a406..e3900e7 100644 --- a/Interface/grid_draw.py +++ b/Interface/grid_draw.py @@ -10,7 +10,6 @@ class Colors: DEFAULT_COLOR = Colors.WHITE -RADIUS_SIZE_COEFFICIENT = 3 def default_color(func): @@ -54,6 +53,5 @@ class GridDraw: self.line(0, tiles_height * i, self.width, tiles_height * i, color=color) @default_color - def circle(self, x, y, tile_height, color=None): - radius = tile_height / RADIUS_SIZE_COEFFICIENT + def circle(self, x, y, radius, color=None): pygame.draw.circle(self.screen, color, (x, y), radius) diff --git a/Interface/vacuum_render.py b/Interface/vacuum_render.py index 6d9bc79..82ca681 100644 --- a/Interface/vacuum_render.py +++ b/Interface/vacuum_render.py @@ -1,3 +1,5 @@ +from enum import Enum +from typing import List from Interface.grid_draw import GridDraw, Colors import sys import pygame @@ -10,29 +12,115 @@ def initial_draw(window_dimensions, board_size): # window name pygame.display.set_caption("AI Vacuum Cleaner") - # define array for grid - board_array = [["" for j in range(board_size)] for i in range(board_size)] - board_render(board_array) - # set window dimension window_width = window_dimensions window_height = window_dimensions # FIXME @countingthedots: please tell me what is going on there and why??? # - grid = GridDraw(window_width, window_height) + renderer = GridDraw(window_width, window_height) tile_width = window_width / board_size tile_height = window_height / board_size + radius = tile_width / 3 x = tile_width / 2 y = tile_height / 2 + # initialize board array + newGrid = Grid(board_size, tile_width) + # rendering loop while True: - grid.start_draw() - grid.board(board_size, board_size) + renderer.start_draw() + renderer.board(board_size, board_size) (x, y) = robot_movement( window_width, window_height, tile_width, tile_height, x, y ) - grid.circle(x, y, tile_height, color=Colors.RED) - grid.end_draw() + renderer.circle(x, y, radius, color=Colors.RED) + renderer.end_draw() pygame.time.delay(10) + + +# TODO wrap it all to another file that handles array rendering +class acceptedType(Enum): + EMPTY = "empty" + PLAYER = "player" + RUBBISH = "rubbish" + ANIMAL = "animal" + + +class objectOnTile: + def __init__( + self, position_x: int, position_y: int, type: acceptedType = acceptedType.EMPTY + ): + self.position_x = position_x + self.position_y = position_y + self.type = type + + +def _translate_array_to_window_position( + position_in_array, window_dimensions, board_size +) -> int: + # TODO calculate position from array position to window position eg.: array_position = 0 => window_position = 50 (px) + return 0 + + +class Grid: + def __init__(self, size_array, tile_width): + self.array = [ + [objectOnTile(i, j) for j in range(size_array)] for i in range(size_array) + ] + self.list: List[objectOnTile] = [] + + # render the array + def render(self, renderer: GridDraw, window_dimensions, board_size, tile_width): + # render object with respect to type + for item in self.list: + if item.type == acceptedType.PLAYER: + # constants for player + PLAYER_RADIUS_RATIO = 3 + PLAYER_COLOR = Colors.RED + + render_x = _translate_array_to_window_position( + item.position_x, window_dimensions, board_size + ) + render_y = _translate_array_to_window_position( + item.position_y, window_dimensions, board_size + ) + renderer.circle( + render_x, + render_y, + tile_width / PLAYER_RADIUS_RATIO, + color=PLAYER_COLOR, + ) + # TODO act accordingly to other options + + # add new object on grid + def add(self, newObject: objectOnTile): + if ( + self.array[newObject.position_x][newObject.position_y].type + != acceptedType.EMPTY + ): + print( + f"Cannot add object at ({newObject.position_x}, {newObject.position_y}): position already occupied" + ) + return + + self.array[newObject.position_x][newObject.position_y] = newObject + self.list.append(newObject) + + def delete(self, position_x, position_y): + # Find the object with the given position in the list + for obj in self.list: + if obj.position_x == position_x and obj.position_y == position_y: + break + + else: # No object found with the given position + print(f"No object found at ({position_x}, {position_y})") + return + + # Remove the object from both the array and the list + self.array[position_x][position_y] = objectOnTile(position_x, position_y) + self.list.remove(obj) + + # TODO update: update position from (start_x, start_y) to (end_x, end_y) + # TODO change movement to work with arrays From 7757843da81e68c6b804d2ed6da400f0903830f4 Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Wed, 22 Mar 2023 20:46:05 +0100 Subject: [PATCH 3/7] formatting requirements --- requirements.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 231dd17..a5604b1 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1 +1,2 @@ -pygame \ No newline at end of file +pygame +formaFormatting: Provider - black \ No newline at end of file From e55dbcccea8378ff264562411d35d98adb36bad7 Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Wed, 22 Mar 2023 20:47:14 +0100 Subject: [PATCH 4/7] error correction --- Project discription.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Project discription.txt b/Project discription.txt index 29d0404..85b0d69 100644 --- a/Project discription.txt +++ b/Project discription.txt @@ -3,17 +3,17 @@ Dokumentacja projektu "Automatyczny robot sprzątający" Wprowadzenie: -Projekt "Automatyczny robot sprzątający" jest projektem bazującym się na symulacji pracy robota sprzątającego w pomieszczeniu za pomocą sztucznej intelegencji. Robot ma za zadanie wyznaczać miejsca do sprzątania oraz uniknąć przeszkód oraz reagować na zdarzenia randomowe. Projekt jest napisany w języku Python. +Projekt "Automatyczny robot sprzątający" jest projektem bazującym się na symulacji pracy robota sprzątającego w pomieszczeniu za pomocą sztucznej inteligencji. Robot ma za zadanie wyznaczać miejsca do sprzątania oraz uniknąć przeszkód oraz reagować na zdarzenia losowe. Projekt jest napisany w języku Python. Instrukcja obsługi: Uruchomienie projektu: - Aby uruchomić projekt należy uruchomić plik "main.py" za pomocą interpretera Python. Projektu wyświetli się w konsoli.Po uruchomieniu projektu na ekranie wyświetli się plansza o wymiarach 10x10. Robot "Cleaner" (oznaczony jako "R" na planszy) startuje z pozycji (0,0). użytkownik ma za zadanie wprowadzić pozycje do sprzątania, które są oznaczone na planszy jako litery "D". Możliwe pozycje to liczby od 0 do 9. + Aby uruchomić projekt należy uruchomić plik "main.py" za pomocą interpretera Python. Projektu wyświetli się w konsoli.Po uruchomieniu projektu na ekranie wyświetli się plansza o wymiarach NxN (default: 10x10). Robot "Cleaner" (oznaczony jako "R" na planszy) startuje z pozycji (0,0). użytkownik ma za zadanie wprowadzić pozycje do sprzątania, które są oznaczone na planszy jako litery "D". Możliwe pozycje to liczby od 0 do N-1. Użytkownik wprowadza pozycje za pomocą terminala. Wprowadzenie koordynat odbywa się w następujący sposób: Najpierw wprowadzamy numer wiersza, a następnie numer kolumny, oddzielając je spacją. Przykładowo, jeśli chcemy wskazać pozycję (4,5) wpisujemy: "4 5". - Po wskazaniu pozycji do sprzątania, użytkownik musi uniknąć przeszkód, które są oznaczone na planszy jako znak "X". Robot nie może przejść przez przeszkody. Jeśli użytkownik wskazuje pozycję przeszkody, projektu zwróci błąd i będzie wymagała podania nowych koordynatów. + Po wskazaniu pozycji do sprzątania, użytkownik musi uniknąć przeszkód, które są oznaczone na planszy jako znak "X". Robot nie może przejść przez przeszkody. Jeśli użytkownik wskazuje pozycję przeszkody, projektu zwróci błąd i będzie wymagała podania nowych współrzędnych. Przebieg projektu: Robot, zgodnie z zbudowaną mapą, musi obliczyć najkrótszą ścieżkę do sprzątania wszystkich pozycji oraz uniknąć przeszkód. Podczas sprzątania mogą wystąpić przypadkowe zdarzenia, na które robot będzie reagował. W tym celu, z pomocą sieci neuronowych, robot analizuje zdjęcie zdarzenia, aby wybrać najlepsze rozwiązania. @@ -25,7 +25,7 @@ Możliwe modyfikacje: Projekt zostanie napisany z myślą o możliwości łatwej modyfikacji. Można zmienić wymiary planszy, dodać lub usunąć przeszkody oraz ilość przypadkowych zdarzeń i pozycji do sprzątania. Wszystkie te zmiany można wprowadzić w pliku "config.py". Podsumowanie: - Projekt "Automatyczny robot sprzątający" to prosty, ale edukacyjny projekt programistyczny. Użytkownik ma za zadanie wskazanie pozycji, które robot powinien posprzątać, a także koordynat przeszkody. Natomiast zadaniem robota, który został zbudowany przy użyciu sztucznej inteligencji, jest unikanie przeszkód, podejmowanie decyzji w przypadku wystąpienia przypadkowych zdarzeń oraz sprzątanie wyznaczonych punktów. Projekt został napisany w języku Python z wykorzystaniem sztucznej inteligencji.Analiza zdięć jest oparta na sieciach neuronowych. + Projekt "Automatyczny robot sprzątający" to prosty, ale edukacyjny projekt programistyczny. Użytkownik ma za zadanie wskazanie pozycji, które robot powinien posprzątać, a także koordynat przeszkody. Natomiast zadaniem robota, który został zbudowany przy użyciu sztucznej inteligencji, jest unikanie przeszkód, podejmowanie decyzji w przypadku wystąpienia przypadkowych zdarzeń oraz sprzątanie wyznaczonych punktów. Projekt został napisany w języku Python z wykorzystaniem sztucznej inteligencji. Analiza zdjęć jest oparta na sieciach neuronowych. ****** From 4933c04bd8bf939a4ebd621ec75cab7d94572714 Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Wed, 22 Mar 2023 20:48:02 +0100 Subject: [PATCH 5/7] upadte + array_to_window_position --- Interface/vacuum_render.py | 40 ++++++++++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/Interface/vacuum_render.py b/Interface/vacuum_render.py index 82ca681..47b035b 100644 --- a/Interface/vacuum_render.py +++ b/Interface/vacuum_render.py @@ -7,11 +7,17 @@ from Interface.movement import robot_movement # window_dimensions says how many pixels window have -# board_size says how many lines board have +# board_size says how many lines board have in one row def initial_draw(window_dimensions, board_size): # window name pygame.display.set_caption("AI Vacuum Cleaner") + # define additional variables + tile_size = window_width / board_size + + # initialize board array + newGrid = Grid(board_size, tile_size) + # set window dimension window_width = window_dimensions window_height = window_dimensions @@ -25,9 +31,6 @@ def initial_draw(window_dimensions, board_size): x = tile_width / 2 y = tile_height / 2 - # initialize board array - newGrid = Grid(board_size, tile_width) - # rendering loop while True: renderer.start_draw() @@ -57,15 +60,16 @@ class objectOnTile: self.type = type +# calculate position from array position to window position eg.: array_position = 0 => window_position = 50 (px) def _translate_array_to_window_position( - position_in_array, window_dimensions, board_size + array_position, window_dimensions, board_size ) -> int: - # TODO calculate position from array position to window position eg.: array_position = 0 => window_position = 50 (px) - return 0 + tile_size_window = window_dimensions / board_size + return array_position * tile_size_window + tile_size_window / 2 class Grid: - def __init__(self, size_array, tile_width): + def __init__(self, size_array, tile_size): self.array = [ [objectOnTile(i, j) for j in range(size_array)] for i in range(size_array) ] @@ -80,12 +84,15 @@ class Grid: PLAYER_RADIUS_RATIO = 3 PLAYER_COLOR = Colors.RED + # position on screen render_x = _translate_array_to_window_position( item.position_x, window_dimensions, board_size ) render_y = _translate_array_to_window_position( item.position_y, window_dimensions, board_size ) + + # image rendering function renderer.circle( render_x, render_y, @@ -123,4 +130,21 @@ class Grid: self.list.remove(obj) # TODO update: update position from (start_x, start_y) to (end_x, end_y) + def update(self, start_x, start_y, end_x, end_y): + # check if obj exist at starting position + if self.array[start_x][start_y].type == acceptedType.EMPTY: + print( + f"Cannot move object at ({start_x}, {start_y}): no object on position" + ) + return + # check if destination is empty + if self.array[end_x][end_y].type != acceptedType.EMPTY: + print( + f"Cannot move object to ({end_x}, {end_y}): position already occupied" + ) + return + # all OK + self.array[end_x][end_y].type = self.array[start_x][start_y].type + self.array[start_x][start_y].type = acceptedType.EMPTY + # TODO change movement to work with arrays From be307ebab571733a05ea87e2782aac223aa292a9 Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Wed, 22 Mar 2023 23:11:13 +0100 Subject: [PATCH 6/7] bugFixes --- Interface/vacuum_render.py | 36 +++++++++++++++--------------------- 1 file changed, 15 insertions(+), 21 deletions(-) diff --git a/Interface/vacuum_render.py b/Interface/vacuum_render.py index 47b035b..38eaee0 100644 --- a/Interface/vacuum_render.py +++ b/Interface/vacuum_render.py @@ -13,10 +13,11 @@ def initial_draw(window_dimensions, board_size): pygame.display.set_caption("AI Vacuum Cleaner") # define additional variables - tile_size = window_width / board_size + tile_size = window_dimensions / board_size # initialize board array - newGrid = Grid(board_size, tile_size) + newGrid = Grid(board_size) + newGrid.add(objectOnTile(1, 1, acceptedType.PLAYER)) # set window dimension window_width = window_dimensions @@ -25,22 +26,16 @@ def initial_draw(window_dimensions, board_size): # FIXME @countingthedots: please tell me what is going on there and why??? # renderer = GridDraw(window_width, window_height) - tile_width = window_width / board_size - tile_height = window_height / board_size - radius = tile_width / 3 - x = tile_width / 2 - y = tile_height / 2 # rendering loop while True: renderer.start_draw() renderer.board(board_size, board_size) - (x, y) = robot_movement( - window_width, window_height, tile_width, tile_height, x, y - ) - renderer.circle(x, y, radius, color=Colors.RED) + + newGrid.render(renderer, window_dimensions, board_size) + renderer.end_draw() - pygame.time.delay(10) + pygame.time.delay(30) # TODO wrap it all to another file that handles array rendering @@ -61,22 +56,21 @@ class objectOnTile: # calculate position from array position to window position eg.: array_position = 0 => window_position = 50 (px) -def _translate_array_to_window_position( - array_position, window_dimensions, board_size -) -> int: - tile_size_window = window_dimensions / board_size +def _translate_array_to_window_position(array_position, tile_size_window) -> int: return array_position * tile_size_window + tile_size_window / 2 class Grid: - def __init__(self, size_array, tile_size): + def __init__(self, size_array): self.array = [ [objectOnTile(i, j) for j in range(size_array)] for i in range(size_array) ] self.list: List[objectOnTile] = [] # render the array - def render(self, renderer: GridDraw, window_dimensions, board_size, tile_width): + def render(self, renderer: GridDraw, window_dimensions, board_size): + tile_size = window_dimensions / board_size + # render object with respect to type for item in self.list: if item.type == acceptedType.PLAYER: @@ -86,17 +80,17 @@ class Grid: # position on screen render_x = _translate_array_to_window_position( - item.position_x, window_dimensions, board_size + item.position_x, tile_size ) render_y = _translate_array_to_window_position( - item.position_y, window_dimensions, board_size + item.position_y, tile_size ) # image rendering function renderer.circle( render_x, render_y, - tile_width / PLAYER_RADIUS_RATIO, + tile_size / PLAYER_RADIUS_RATIO, color=PLAYER_COLOR, ) # TODO act accordingly to other options From 586a94e0c012e801a45a250c3abac3aae5781c18 Mon Sep 17 00:00:00 2001 From: Mateusz Dokowicz Date: Thu, 23 Mar 2023 00:54:05 +0100 Subject: [PATCH 7/7] working arrays and movement --- Interface/movement.py | 24 ++++++++-------- Interface/vacuum_render.py | 59 +++++++++++++++++++++++++++----------- 2 files changed, 54 insertions(+), 29 deletions(-) diff --git a/Interface/movement.py b/Interface/movement.py index 546c8f5..63eaed4 100644 --- a/Interface/movement.py +++ b/Interface/movement.py @@ -2,24 +2,24 @@ import pygame import sys -def robot_movement(grid_width, grid_height, tile_width, tile_height, x, y): +def movement_key_press(board_size, x, y): for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() if event.type == pygame.KEYDOWN: # go left - if event.key == pygame.K_LEFT and x > (tile_width / 2): - x -= tile_width + if event.key == pygame.K_LEFT and x > 0: + x -= 1 - # go right - if event.key == pygame.K_RIGHT and x < (grid_width - (tile_width / 2)): - x += tile_width + # go right + if event.key == pygame.K_RIGHT and x < board_size - 1: + x += 1 - # go up - if event.key == pygame.K_UP and y > (tile_height / 2): - y -= tile_height + # go up + if event.key == pygame.K_UP and y > 0: + y -= 1 - # go down - if event.key == pygame.K_DOWN and y < (grid_height - (tile_height / 2)): - y += tile_height + # go down + if event.key == pygame.K_DOWN and y < board_size - 1: + y += 1 return (x, y) diff --git a/Interface/vacuum_render.py b/Interface/vacuum_render.py index 38eaee0..a4fca0d 100644 --- a/Interface/vacuum_render.py +++ b/Interface/vacuum_render.py @@ -3,7 +3,7 @@ from typing import List from Interface.grid_draw import GridDraw, Colors import sys import pygame -from Interface.movement import robot_movement +from Interface.movement import movement_key_press # window_dimensions says how many pixels window have @@ -18,23 +18,30 @@ def initial_draw(window_dimensions, board_size): # initialize board array newGrid = Grid(board_size) newGrid.add(objectOnTile(1, 1, acceptedType.PLAYER)) + player = newGrid.findFirst(acceptedType.PLAYER) + newGrid.move(1, 1, 1, 2) + newGrid.move(1, 2, 1, 1) # set window dimension window_width = window_dimensions window_height = window_dimensions - # FIXME @countingthedots: please tell me what is going on there and why??? - # - renderer = GridDraw(window_width, window_height) + # initialize drawer + drawer = GridDraw(window_width, window_height) # rendering loop while True: - renderer.start_draw() - renderer.board(board_size, board_size) + drawer.start_draw() + drawer.board(board_size, board_size) - newGrid.render(renderer, window_dimensions, board_size) + player = newGrid.findFirst(acceptedType.PLAYER) - renderer.end_draw() + (x, y) = movement_key_press(board_size, player.position_x, player.position_y) + + newGrid.move(player.position_x, player.position_y, x, y) + + newGrid.render(drawer, window_dimensions, board_size) + drawer.end_draw() pygame.time.delay(30) @@ -68,7 +75,7 @@ class Grid: self.list: List[objectOnTile] = [] # render the array - def render(self, renderer: GridDraw, window_dimensions, board_size): + def render(self, drawer: GridDraw, window_dimensions, board_size): tile_size = window_dimensions / board_size # render object with respect to type @@ -87,7 +94,7 @@ class Grid: ) # image rendering function - renderer.circle( + drawer.circle( render_x, render_y, tile_size / PLAYER_RADIUS_RATIO, @@ -109,7 +116,9 @@ class Grid: self.array[newObject.position_x][newObject.position_y] = newObject self.list.append(newObject) - def delete(self, position_x, position_y): + # deletes object from game + # untested, potentially not working + def delete(self, position_x: int, position_y: int): # Find the object with the given position in the list for obj in self.list: if obj.position_x == position_x and obj.position_y == position_y: @@ -123,22 +132,38 @@ class Grid: self.array[position_x][position_y] = objectOnTile(position_x, position_y) self.list.remove(obj) - # TODO update: update position from (start_x, start_y) to (end_x, end_y) - def update(self, start_x, start_y, end_x, end_y): + # move: update position from (start_x, start_y) to (end_x, end_y) + def move(self, start_x: int, start_y: int, end_x: int, end_y: int): + # no change + if start_x == end_x and start_y == end_y: + return + # check if obj exist at starting position if self.array[start_x][start_y].type == acceptedType.EMPTY: print( f"Cannot move object at ({start_x}, {start_y}): no object on position" ) return + # check if destination is empty if self.array[end_x][end_y].type != acceptedType.EMPTY: print( f"Cannot move object to ({end_x}, {end_y}): position already occupied" ) return - # all OK - self.array[end_x][end_y].type = self.array[start_x][start_y].type - self.array[start_x][start_y].type = acceptedType.EMPTY - # TODO change movement to work with arrays + # all OK + # change position attribute in array + self.array[start_x][start_y].position_x = end_x + self.array[start_x][start_y].position_y = end_y + + # change position in array + self.array[end_x][end_y] = self.array[start_x][start_y] + self.array[start_x][start_y] = objectOnTile(start_x, start_y) + + def findFirst(self, find_type: acceptedType) -> objectOnTile: + for item in self.list: + if item.type == find_type: + return item + else: + print(f"Cannot find object of type: ({find_type})!")