Compare commits

..

No commits in common. "ad828cb7d14a98023e15e99f583d500c3643a29f" and "51a629285dfe291861c5b1286541dc0e0a0b4d55" have entirely different histories.

5 changed files with 40 additions and 174 deletions

View File

@ -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.

View File

@ -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
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
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
if event.key == pygame.K_DOWN and y < (grid_height - (tile_height / 2)):
y += tile_height
return (x, y)

View File

@ -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)

View File

@ -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.
******

View File

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