.idea/.gitignore

@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml

agentActionType.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-class AgentActionType (Enum):
-    MOVE_FORWARD = 0
-    TURN_LEFT = 1
-    TURN_RIGHT = 2
-    UNKNOWN = None

agentOrientation.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-class AgentOrientation (Enum):
-    UP = 0
-    RIGHT = 1
-    DOWN = 2
-    LEFT = 3

agentState.py

@@ -1,10 +0,0 @@
-from agentOrientation import AgentOrientation
-from typing import Tuple
-
-class AgentState:
-    orientation: AgentOrientation
-    position: Tuple[int, int]
-
-    def __init__(self, position: Tuple[int, int], orientation: AgentOrientation) -> None:
-        self.orientation = orientation
-        self.position = position

bfs.py

@@ -1,165 +0,0 @@
-from agentState import AgentState
-from typing import Dict, Tuple, List
-from city import City
-from gridCellType import GridCellType
-from agentActionType import AgentActionType
-from agentOrientation import AgentOrientation
-from queue import Queue, PriorityQueue
-from turnCar import turn_left_orientation, turn_right_orientation
-
-
-class Successor:  # klasa reprezentuje sukcesora, stan i akcję którą można po nim podjąć
-
-    def __init__(self, state: AgentState, action: AgentActionType, cost: int, predicted_cost: int) -> None:
-        self.state = state
-        self.action = action
-        self.cost = cost
-        self.predicted_cost = predicted_cost
-
-
-class SuccessorList:  # lista sukcesorów, czyli możliwych ścieżek po danym stanie
-    succ_list: list[Successor]
-
-    def __init__(self, succ_list: list[Successor]) -> None:
-        self.succ_list = succ_list
-
-    def __gt__(self, other):
-        return self.succ_list[-1].predicted_cost > other.succ_list[-1].predicted_cost
-
-    def __lt__(self, other):
-        return self.succ_list[-1].predicted_cost < other.succ_list[-1].predicted_cost
-
-
-def find_path_to_nearest_can(startState: AgentState, grid: Dict[Tuple[int, int], GridCellType], city: City) -> List[
-    AgentActionType]:  # znajduje ścieżkę do najbliższego kosza na smieci
-    visited: List[AgentState] = []
-    queue: PriorityQueue[SuccessorList] = PriorityQueue()  # kolejka priorytetowa przechodująca listę sukcesorów
-    queue.put(SuccessorList([Successor(startState, AgentActionType.UNKNOWN, 0, _heuristics(startState.position, city))]))
-
-    while not queue.empty():  # dopóki kolejka nie jest pusta, pobiera z niej aktualny element
-        current = queue.get()
-        previous = current.succ_list[-1]
-        visited.append(previous.state)
-
-        if is_state_success(previous.state, grid):  # jeśli ostatni stan w liście jest stanem końcowym (agent dotarł do śmietnika)
-            return extract_actions(current)
-
-        successors = get_successors(previous, grid, city)
-        for s in successors:
-            already_visited = False
-            for v in visited:
-                if v.position == s.state.position and v.orientation == s.state.orientation:
-                    already_visited = True
-                    break
-            if already_visited:
-                continue
-            if is_state_valid(s.state, grid):
-                new_list = current.succ_list.copy()
-                new_list.append(s)
-                queue.put(SuccessorList(new_list))
-
-    return []
-
-
-def extract_actions(successors: SuccessorList) -> list[AgentActionType]:  # wyodrębnienie akcji z listy sukcesorów, z pominięciem uknown
-    output: list[AgentActionType] = []
-    for s in successors.succ_list:
-        if s.action != AgentActionType.UNKNOWN:
-            output.append(s.action)
-    return output
-
-
-def get_successors(succ: Successor, grid: Dict[Tuple[int, int], GridCellType], city: City) -> List[Successor]:
-    result: List[Successor] = []  # generuje następników dla danego stanu,
-
-    turn_left_cost = 1 + succ.cost
-    turn_left_state = AgentState(succ.state.position, turn_left_orientation(succ.state.orientation))
-    turn_left_heuristics = _heuristics(succ.state.position, city)
-    result.append(
-        Successor(turn_left_state, AgentActionType.TURN_LEFT, turn_left_cost, turn_left_cost + turn_left_heuristics))
-
-    turn_right_cost = 1 + succ.cost
-    turn_right_state = AgentState(succ.state.position, turn_right_orientation(succ.state.orientation))
-    turn_right_heuristics = _heuristics(succ.state.position, city)
-    result.append(
-        Successor(turn_right_state, AgentActionType.TURN_RIGHT, turn_right_cost,
-                  turn_right_cost + turn_right_heuristics))
-
-    state_succ = move_forward_succ(succ, city, grid)
-    if state_succ is not None:
-        result.append(state_succ)
-
-    return result
-
-
-def move_forward_succ(succ: Successor, city: City, grid: Dict[Tuple[int, int], GridCellType]) -> Successor:
-    position = get_next_cell(succ.state)
-    if position is None:
-        return None
-
-    cost = get_cost_for_action(AgentActionType.MOVE_FORWARD, grid[position]) + succ.cost
-    predicted_cost = cost + _heuristics(position, city)
-    new_state = AgentState(position, succ.state.orientation)
-    return Successor(new_state, AgentActionType.MOVE_FORWARD, cost, predicted_cost)
-
-
-def get_next_cell(state: AgentState) -> Tuple[int, int]:
-    x, y = state.position
-    orientation = state.orientation
-
-    if orientation == AgentOrientation.UP:
-        if y - 1 < 1:
-            return None
-        return x, y - 1
-    elif orientation == AgentOrientation.DOWN:
-        if y + 1 > 27:
-            return None
-        return x, y + 1
-    elif orientation == AgentOrientation.LEFT:
-        if x - 1 < 1:
-            return None
-        return x - 1, y
-    elif x + 1 > 27:
-        return None
-    else:
-        return x + 1, y
-
-
-def is_state_success(state: AgentState, grid: Dict[Tuple[int, int], GridCellType]) -> bool:
-    next_cell = get_next_cell(state)
-    try:
-        return grid[next_cell] == GridCellType.GARBAGE_CAN  # agent dotarł do śmietnika
-    except KeyError:
-        return False
-
-
-def get_cost_for_action(action: AgentActionType, cell_type: GridCellType) -> int:
-    if action in [AgentActionType.TURN_LEFT, AgentActionType.TURN_RIGHT]:
-        return 1
-    if cell_type == GridCellType.SPEED_BUMP and action == AgentActionType.MOVE_FORWARD:
-        return -10000
-    if action == AgentActionType.MOVE_FORWARD:
-        return 3
-
-
-def is_state_valid(state: AgentState, grid: Dict[Tuple[int, int], GridCellType]) -> bool:
-    try:
-        return grid[state.position] == GridCellType.STREET_HORIZONTAL or grid[
-            state.position] == GridCellType.STREET_VERTICAL or grid[state.position] == GridCellType.SPEED_BUMP
-    except KeyError:
-        return False
-
-
-def _heuristics(position: Tuple[int, int], city: City):
-    min_distance: int = 300
-    found_nonvisited: bool = False
-    for can in city.cans:
-        if can.is_visited:
-            continue
-        found_nonvisited = True
-        distance = 3 * (abs(position[0] - can.position[0]) + abs(position[1] - can.position[1]))
-        if distance < min_distance:
-            min_distance = distance
-    if found_nonvisited:
-        return min_distance
-    return -1

city.py

@@ -1,44 +1,39 @@
-from typing import List, Dict, Tuple
+from typing import List, Tuple
 from garbageCan import GarbageCan
-from speedBump import SpeedBump
-from street import Street
-from gameContext import GameContext
 
+class Node:
+    garbageCan: GarbageCan
+    id: int
+
+    def __init__(self, id: int, can: GarbageCan) -> None:
+        self.id = id
+        self.can = can
 
 class City:
-    cans: List[GarbageCan]
-    bumps: List[SpeedBump]
-    streets: List[Street]
-    cans_dict: Dict[Tuple[int, int], GarbageCan] = {}
+    nodes: List[Node]
+    streets: List[Tuple[int, int]]
 
     def __init__(self) -> None:
-        self.cans = []
+        self.nodes = []
         self.streets = []
-        self.bumps = []
 
-    def add_can(self, can: GarbageCan) -> None:
-        self.cans.append(can)
-        self.cans_dict[can.position] = can
+    def add_node(self, node: Node) -> None:
+        self.nodes.append(node)
+    
+    def add_street(self, street: Tuple[int, int]) -> None:
+        firstFound: bool = False
+        secondFound: bool = False
+
+        for node in self.nodes:
+            if firstFound and secondFound:
+                break
+            if node.id == street.__getitem__(0):
+                firstFound = True
+                continue
+            if node.id == street.__getitem__(1):
+                secondFound = True
+        
+        if not firstFound or not secondFound:
+            return
         
-    def add_street(self, street: Street) -> None:
         self.streets.append(street)
-
-    def add_bump(self, bump: SpeedBump) -> None:
-        self.streets.append(bump)
-
-    def render_city(self, game_context: GameContext) -> None:
-        self._render_streets(game_context)
-        self._render_nodes(game_context)
-        self._render_bumps(game_context)
-
-    def _render_streets(self, game_context: GameContext) -> None:
-        for street in self.streets:
-            street.render(game_context)
-
-    def _render_nodes(self, game_context: GameContext) -> None:
-        for node in self.cans:
-            node.render(game_context)
-
-    def _render_bumps(self, game_context: GameContext) -> None:
-        for bump in self.bumps:
-            bump.render(game_context)

gameContext.py

@@ -1,7 +1,5 @@
-from typing import Tuple, List, Dict
 import pygame
 from PIL import Image
-from gridCellType import GridCellType
 
 class GameContext:
     dust_car_speed = 20
@@ -10,27 +8,12 @@ class GameContext:
     dust_car_pygame = None
     dust_car_pil = None
     canvas = None
-    _cell_size: int = 30
-    city = None
-    grid: Dict[Tuple[int, int], GridCellType] = {}
-    dust_car = None
-    landfill = None
-    
-
-
-    def __init__(self) -> None:
-        self._init_grid()
-
-    def _init_grid(self) -> None:
-        for i in range(1, 28):
-            for j in range(1, 28):
-                self.grid[(i, j)] = GridCellType.NOTHING
-
-    def render_in_cell(self, cell: Tuple[int, int], img_path: str):
-        img = Image.open(img_path)
-        pygame_img = pygame.image.frombuffer(img.tobytes(), (self._cell_size,self._cell_size), 'RGB')
-        start_x = (cell[0] - 1) * self._cell_size
-        start_y = (cell[1] - 1) * self._cell_size
-        self.canvas.blit(pygame_img, (start_x, start_y))
 
+def startup(game_context: GameContext):
+    render_background(game_context)
+    game_context.canvas.blit(game_context.dust_car_pygame, (game_context.dust_car_position_x, game_context.dust_car_position_y))
 
+def render_background(game_context: GameContext):
+    bg_img = Image.open("imgs/background.jpg")
+    pygame_bg_image = pygame.image.frombuffer(bg_img.tobytes(), bg_img.size, 'RGB')
+    game_context.canvas.blit(pygame_bg_image, (0, 0))

gameEventHandler.py

@@ -2,4 +2,23 @@ import pygame
 from gameContext import GameContext
 
 def handle_game_event(event, game_context: GameContext):
-    pass
+    dust_car_movement(event, game_context)
+    return
+
+def dust_car_movement(event, game_context:GameContext):
+    if event.type != pygame.KEYDOWN:
+        return
+    (width, height) = game_context.dust_car_pil.size
+    if event.key == pygame.K_LEFT:
+        pygame.draw.rect(game_context.canvas, (0, 0, 0), (game_context.dust_car_position_x, game_context.dust_car_position_y, width, height))
+        game_context.dust_car_position_x -= game_context.dust_car_speed
+    elif event.key == pygame.K_RIGHT:
+        pygame.draw.rect(game_context.canvas, (0, 0, 0), (game_context.dust_car_position_x, game_context.dust_car_position_y, width, height))
+        game_context.dust_car_position_x += game_context.dust_car_speed
+    elif event.key == pygame.K_UP:
+        pygame.draw.rect(game_context.canvas, (0, 0, 0), (game_context.dust_car_position_x, game_context.dust_car_position_y, width, height))
+        game_context.dust_car_position_y -= game_context.dust_car_speed
+    elif event.key == pygame.K_DOWN:
+        pygame.draw.rect(game_context.canvas, (0, 0, 0), (game_context.dust_car_position_x, game_context.dust_car_position_y, width, height))
+        game_context.dust_car_position_y += game_context.dust_car_speed 
+    game_context.canvas.blit(game_context.dust_car_pygame, (game_context.dust_car_position_x, game_context.dust_car_position_y))

garbage.py

@@ -1,6 +1,5 @@
 from enum import Enum
 
-
 class GarbageType (Enum):
     PAPER = 0,
     PLASTIC_AND_METAL = 1
@@ -8,34 +7,15 @@ class GarbageType(Enum):
     BIO = 4
     MIXED = 5
 
-
 class Garbage:
     img: str
-    shape: str
-    flexibility: str
-    does_smell: str
-    weight: str
-    size: str
-    color: str
-    softness: str
-    does_din: str
 
-    def __init__(self, img: str, shape: str, flexibility: str, does_smell: str, weight: str, size: str, color: str, softness: str, does_din: str) -> None:
+    def __init__(self, img: str) -> None:
         self.img = img
-        self.shape = shape
-        self.flexibility = flexibility
-        self.does_smell = does_smell
-        self.weight = weight
-        self.size = size
-        self.color = color
-        self.softness = softness
-        self.does_din = does_din
 
-
-class RecognizedGarbage:
+class RecognizedGarbage (Garbage):
     garbage_type: GarbageType
-    src: Garbage
 
     def __init__(self, src: Garbage, garbage_type: GarbageType) -> None:
+        super().__init__(src.img)
         self.garbage_type = garbage_type
-        self.src = src

garbageCan.py

@@ -1,26 +1,16 @@
 from garbage import Garbage
 from typing import List, Tuple
-from gameContext import GameContext
-from gridCellType import GridCellType
-
 
 class GarbageCan:
     position: Tuple[int, int]
     garbage: List[Garbage]
-    is_visited: bool
 
     def __init__(self, position: Tuple[int, int]) -> None:
         self.position = position
         self.garbage = []
-        self.is_visited = False
 
     def add_garbage(self, garbage: Garbage) -> None:
         self.garbage.append(garbage)
 
     def remove_garbage(self, garbage: Garbage) -> None:
         self.garbage.remove(garbage)
-
-
-    def render(self, game_context: GameContext) -> None:
-        game_context.render_in_cell(self.position, "imgs/container.png")
-        game_context.grid[self.position] = GridCellType.GARBAGE_CAN

garbageTruck.py

@@ -1,7 +1,6 @@
 from typing import List, Tuple
-from agentOrientation import AgentOrientation
-from garbage import GarbageType, RecognizedGarbage
-from gameContext import GameContext
+
+from garbage import RecognizedGarbage
 
 class GarbageTruck:
     position: Tuple[int, int]
@@ -10,9 +9,8 @@ class GarbageTruck:
     glass: List[RecognizedGarbage]
     bio: List[RecognizedGarbage]
     mixed: List[RecognizedGarbage]
-    orientation: AgentOrientation = AgentOrientation.RIGHT
-
-    def __init__(self, position: Tuple[int, int]) -> None:
+    truckSpritePath = 'imgs/dust_car.png'
+    def __init__(self, position: List[int, int]) -> None:
         self.position = position
         self.paper = []
         self.plastic_and_metal = []
@@ -22,29 +20,17 @@ class GarbageTruck:
         
 
     def sort_garbage(self, RecognizedGarbage) -> None:
-        if RecognizedGarbage.garbage_type == GarbageType.PAPER:
+        if RecognizedGarbage.garbage_type == 0:
             self.paper.append(RecognizedGarbage)
 
-        elif RecognizedGarbage.garbage_type == GarbageType.PLASTIC_AND_METAL:
+        elif RecognizedGarbage.garbage_type == 1:
             self.plastic_and_metal.append(RecognizedGarbage)
 
-        elif RecognizedGarbage.garbage_type == GarbageType.GLASS:
+        elif RecognizedGarbage.garbage_type == 3:
             self.glass.append(RecognizedGarbage)
 
-        elif RecognizedGarbage.garbage_type == GarbageType.BIO:
+        elif RecognizedGarbage.garbage_type == 4:
             self.bio.append(RecognizedGarbage)
 
-        elif RecognizedGarbage.garbage_type == GarbageType.MIXED:
+        elif RecognizedGarbage.garbage_type == 5:
             self.mixed.append(RecognizedGarbage)
-
-    def render(self, game_context: GameContext) -> None:
-        path = None
-        if self.orientation == AgentOrientation.LEFT:
-            path = 'imgs/dust_car_left.png'
-        elif self.orientation == AgentOrientation.RIGHT:
-            path = 'imgs/dust_car_right.png'
-        elif self.orientation == AgentOrientation.UP:
-            path = 'imgs/dust_car_up.png'
-        elif self.orientation == AgentOrientation.DOWN:
-            path = 'imgs/dust_car_down.png'
-        game_context.render_in_cell(self.position, path)

gridCellType.py

@@ -1,11 +0,0 @@
-from enum import Enum
-
-class GridCellType(Enum):
-    NOTHING = 0
-    STREET_VERTICAL = 1
-    STREET_HORIZONTAL = 2
-    GARBAGE_CAN = 3
-    VISITED_GARBAGE_CAN = 4
-    LANDFILL = 5
-    SPEED_BUMP = 6
-    UNKNOWN = None

landfill.py

@@ -1,39 +0,0 @@
-from typing import Tuple
-from gameContext import GameContext
-from garbage import RecognizedGarbage
-from gridCellType import GridCellType
-
-class Landfill:
-    position: Tuple[int, int] = []
-    paper: list[RecognizedGarbage]
-    plastic_and_metal: list[RecognizedGarbage] = []
-    glass: list[RecognizedGarbage] = []
-    bio: list[RecognizedGarbage] = []
-    mixed: list[RecognizedGarbage] = []
-
-    def __init__(self, position: Tuple[int, int]) -> None:
-        self.position = position
-    
-    def add_paper(self, paper: list[RecognizedGarbage]) -> None:
-        for p in paper:
-            self.paper.append(p)
-
-    def add_plastic_and_metal(self, plastic_and_metal: list[RecognizedGarbage]) -> None:
-        for p in plastic_and_metal:
-            self.plastic_and_metal.append(p)
-
-    def add_glass(self, glass: list[RecognizedGarbage]) -> None:
-        for g in glass:
-            self.glass.append(g)
-
-    def add_paper(self, bio: list[RecognizedGarbage]) -> None:
-        for b in bio:
-            self.bio.append(b)
-
-    def add_mixed(self, mixed: list[RecognizedGarbage]) -> None:
-        for m in mixed:
-            self.mixed.append(m)
-
-    def render(self, game_context: GameContext) -> None:
-        game_context.render_in_cell(self.position, 'imgs/landfill.png')
-        game_context.grid[self.position] = GridCellType.LANDFILL

machine_learning/decisionTree.py

@@ -1,95 +0,0 @@
-import os
-from trainingData import TrainingData
-from sklearn import tree
-import joblib
-from sklearn.preprocessing import LabelEncoder, OneHotEncoder
-import numpy as np
-
-def _read_training_data() -> TrainingData:
-    attributes = []
-    classes = []
-    location = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
-    file = open(os.path.join(location, 'training_data.csv'))
-    lines = file.readlines()[1:]
-    file.close()
-    for line in lines:
-        actual_row = line.replace('\n', '')
-        values = actual_row.split(',')
-        line_attributes = values[:-1]
-        line_class = values[-1]
-        attributes.append(line_attributes)
-        classes.append(line_class.strip())
-    return TrainingData(attributes, classes)
-
-def _attributes_to_floats(attributes: list[str]) -> list[float]:
-    output: list[float] = []
-    if attributes[0] == 'Longitiudonal':
-        output.append(0)
-    elif attributes[0] == 'Round':
-        output.append(1)
-    elif attributes[0] == 'Flat':
-        output.append(2)
-    elif attributes[0] == 'Irregular':
-        output.append(3)
-    
-    if attributes[1] == 'Low':
-        output.append(0)
-    elif attributes[1] == 'Medium':
-        output.append(1)
-    elif attributes[1] == 'High':
-        output.append(2)
-    
-
-    if attributes[2] == "Yes":
-        output.append(0)
-    else:
-        output.append(1)
-    
-    if attributes[3] == 'Low':
-        output.append(0)
-    elif attributes[3] == 'Medium':
-        output.append(1)
-    elif attributes[3] == 'High':
-        output.append(2)
-
-    if attributes[4] == 'Low':
-        output.append(0)
-    elif attributes[4] == 'Medium':
-        output.append(1)
-    elif attributes[4] == 'High':
-        output.append(2)
-
-    if attributes[5] == 'Transparent':
-        output.append(0)
-    elif attributes[5] == 'Light':
-        output.append(1)
-    elif attributes[5] == 'Dark':
-        output.append(2)
-    elif attributes[5] == "Colorful":
-        output.append(3)
-
-    if attributes[6] == 'Low':
-        output.append(0)
-    elif attributes[6] == 'Medium':
-        output.append(1)
-    elif attributes[6] == 'High':
-        output.append(2)
-
-    if attributes[7] == "Yes":
-        output.append(0)
-    else:
-        output.append(1)
-    return output
-
-
-
-trainning_data = _read_training_data()
-
-X = trainning_data.attributes
-Y = trainning_data.classes
-
-
-model = tree.DecisionTreeClassifier()
-encoded = [_attributes_to_floats(x) for x in X]
-dtc = model.fit(encoded, Y)
-joblib.dump(model, 'model.pkl')

machine_learning/garbage_infill.csv

@@ -1,29 +0,0 @@
-Shape,Flexibility,DoesSmell,Weight,Size,Color,Softness,DoesDin
-Irregular,High,No,High,Medium,Dark,Low,Yes
-Longitiudonal,Low,No,Low,Low,Light,Medium,Yes
-Longitiudonal,Medium,No,Medium,Low,Dark,High,No
-Longitiudonal,Low,No,Medium,Low,Dark,High,Yes
-Round,Low,Yes,High,High,Transparent,High,Yes
-Irregular,Medium,Yes,High,Low,Transparent,Medium,No
-Longitiudonal,Medium,Yes,Low,High,Colorful,Medium,Yes
-Longitiudonal,Low,No,Low,Medium,Dark,Medium,Yes
-Flat,Medium,Yes,High,Low,Transparent,Low,Yes
-Irregular,Medium,Yes,High,Medium,Dark,Low,No
-Longitiudonal,High,No,Low,High,Colorful,Low,Yes
-Round,Medium,No,Medium,Medium,Dark,Low,No
-Longitiudonal,Medium,No,Medium,Medium,Transparent,High,No
-Flat,Medium,Yes,Low,Low,Light,Medium,No
-Flat,Medium,Yes,Medium,High,Light,Medium,No
-Flat,Low,No,High,Low,Dark,High,No
-Longitiudonal,Medium,Yes,High,High,Dark,Low,Yes
-Flat,Low,Yes,Low,Low,Transparent,Low,No
-Flat,Low,No,Medium,Low,Colorful,Low,No
-Longitiudonal,Low,Yes,High,Medium,Transparent,Low,No
-Longitiudonal,Low,No,Medium,High,Dark,Low,Yes
-Irregular,Medium,No,Medium,Medium,Light,Low,Yes
-Longitiudonal,High,No,High,High,Colorful,Low,No
-Flat,Low,No,Low,Low,Dark,High,No
-Flat,Low,Yes,Low,High,Dark,Low,Yes
-Irregular,Medium,Yes,High,High,Dark,Low,No
-Flat,High,No,High,Low,Dark,Medium,Yes
-Longitiudonal,High,Yes,Low,Medium,Colorful,Low,Yes