Interface/grid_draw.py

@@ -54,4 +54,6 @@ class GridDraw:
 
     @default_color
     def circle(self, x, y, radius, color=None):
-        pygame.draw.circle(self.screen, color, (x, y), radius)
+        pygame.draw.circle(
+            self.screen, color, (x, y), radius
+        )  # TODO calculate radius (now 20) in terms of window size.

Interface/movement.py

@@ -2,24 +2,24 @@ import pygame
 import sys
 
 
-def movement_key_press(board_size, x, y):
+def robot_movement(grid_width, grid_height, tile_width, tile_height, 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 > 0:
-                x -= 1
+            if event.key == pygame.K_LEFT and x > (tile_width / 2):
+                x -= tile_width
 
-                # go right
-            if event.key == pygame.K_RIGHT and x < board_size - 1:
-                x += 1
+            # go right
+            if event.key == pygame.K_RIGHT and x < (grid_width - (tile_width / 2)):
+                x += tile_width
 
-                # go up
-            if event.key == pygame.K_UP and y > 0:
-                y -= 1
+            # go up
+            if event.key == pygame.K_UP and y > (tile_height / 2):
+                y -= tile_height
 
-                # go down
-            if event.key == pygame.K_DOWN and y < board_size - 1:
-                y += 1
+            # go down
+            if event.key == pygame.K_DOWN and y < (grid_height - (tile_height / 2)):
+                y += tile_height
     return (x, y)

Interface/vacuum_render.py

@@ -1,169 +1,34 @@
-from enum import Enum
-from typing import List
 from Interface.grid_draw import GridDraw, Colors
 import sys
 import pygame
-from Interface.movement import movement_key_press
+from Interface.movement import robot_movement
 
 
-# window_dimensions says how many pixels window have
-# board_size says how many lines board have in one row
-def initial_draw(window_dimensions, board_size):
+def initial_draw(grid_dimensions, board_size):
     # window name
     pygame.display.set_caption("AI Vacuum Cleaner")
 
-    # define additional variables
-    tile_size = 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)
+    # define array for grid
+    border_array = [["" for j in range(board_size)] for i in range(board_size)]
 
     # set window dimension
-    window_width = window_dimensions
-    window_height = window_dimensions
+    grid_width = grid_dimensions
+    grid_height = grid_dimensions
 
-    # initialize drawer
-    drawer = GridDraw(window_width, window_height)
+    # 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
+    x = tile_width / 2
+    y = tile_height / 2
+    radius = tile_height/3
 
     # rendering loop
     while True:
-        drawer.start_draw()
-        drawer.board(board_size, board_size)
-
-        player = newGrid.findFirst(acceptedType.PLAYER)
-
-        (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)
-
-
-# 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
-
-
-# calculate position from array position to window position eg.: array_position = 0 => window_position = 50 (px)
-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):
-        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, drawer: 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:
-                # constants for player
-                PLAYER_RADIUS_RATIO = 3
-                PLAYER_COLOR = Colors.RED
-
-                # position on screen
-                render_x = _translate_array_to_window_position(
-                    item.position_x, tile_size
-                )
-                render_y = _translate_array_to_window_position(
-                    item.position_y, tile_size
-                )
-
-                # image rendering function
-                drawer.circle(
-                    render_x,
-                    render_y,
-                    tile_size / 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)
-
-    # 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:
-                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)
-
-    # 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
-        # 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})!")
+        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)
+        grid.end_draw()
+        pygame.time.delay(10)

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 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.
+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.
 
 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 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.
+		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.
 
 	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 współrzędnych.
+		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.
 
 	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 zdjęć 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 zdięć jest oparta na sieciach neuronowych.
 
 ******
 

requirements.txt

@@ -1,2 +1 @@
 pygame
-formaFormatting: Provider - black