Inicjalizacja nowej wersji projektu

.gitignore

@@ -1,5 +1 @@
 VENV
-env
-**/__pycache__
-linux_env
-.vscode

Makefile

@@ -1,13 +0,0 @@
-.PHONY: init install start
-
-init-linux:
-	python3 -m venv env
-
-install:
-	env/bin/pip3 install -r requirements.txt
-
-start:
-	env/bin/python3 ./game.py --home-count=5
-
-
-

config.py

@@ -1,27 +1,12 @@
-import sys
-import getopt
-from sprites.cell import CELL_SIZE
 
+CELL_SIZE = 64
 
-def set_home_amount():
-    arguments = sys.argv[1:]
-    try:
-        optlist, args = getopt.getopt(arguments, '', ['home-count='])
-        for o, amount in optlist:
-            if o == '--home-count':
-                if int(amount) < 2:
-                    print('Home count too low - must be higher than 2')
-                    sys.exit(2)
-                return int(amount)
-        print('Missing argument: --home-count <amount>')
-        sys.exit(2)
-    except getopt.GetoptError as err:
-        print(err)
-        sys.exit(2)
+FPS = 60
 
+HOME_AMOUNT = 7
 
-home_amount = set_home_amount()
+GRID_HEIGHT = HOME_AMOUNT
+GRID_WIDTH = GRID_HEIGHT
 
-PLAY_WIDTH = (home_amount + 4)*CELL_SIZE
-PLAY_HEIGHT = PLAY_WIDTH
-HUD_HEIGHT = int(home_amount*CELL_SIZE/4)
+WINDOW_HEIGHT = GRID_HEIGHT * CELL_SIZE
+WINDOW_WIDTH = GRID_WIDTH * CELL_SIZE

enums/house_image.py

@@ -1,10 +0,0 @@
-from enum import Enum
-class House_image(Enum):
-    house = "images/house.png"
-    plastic = "images/house_plastic.png"
-    metal = "images/house_metal.png"
-    glass = "images/house_glass.png"
-    plastic_glass = "images/house_plastic_glass.png"
-    plastic_metal = "images/house_plastic_metal.png"
-    glass_metal = "images/house_glass_metal.png"
-    full = "images/house_full.png"

game.py

@@ -1,85 +0,0 @@
-from pygame import *
-import sys
-import random
-from config import PLAY_WIDTH, PLAY_HEIGHT, HUD_HEIGHT, home_amount
-from sprites.house import House
-from sprites.hud import Hud
-from pygame.locals import *
-import utils
-import csv
-import datetime
-
-##INITIALIZE STATIC VARIABLES#########
-FPS = 20
-
-all_sprites = sprite.Group()
-fps_clock = time.Clock()
-
-######################################
-
-interactables = {
-    "homes": [],
-    "landfills": []
-}
-
-
-##GAMEWINDOW##########################
-WINDOW_WIDTH = PLAY_WIDTH
-WINDOW_HEIGHT = PLAY_HEIGHT #+ HUD_HEIGHT
-GAMEWINDOW = display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT), 0, 32)
-hud = Hud(home_amount,WINDOW_WIDTH, WINDOW_HEIGHT,GAMEWINDOW)
-display.set_caption('Smieciarz WMI')
-icon = image.load('images/icon.png')
-display.set_icon(icon)
-######################################
-
-##
-# Generate level
-utils.generate_grass(all_sprites)
-utils.generate_landfills(all_sprites, interactables)
-utils.generate_houses(all_sprites, interactables)
-gc = utils.generate_garbage_collector(all_sprites, interactables)
-##
-
-##COUNTER FOR HUB BRAKE IN CONSOLE#####
-hud_break = 0
-#######################################
-
-##INIT CSV FILE########################
-csv_name, houses_csv_name = utils.init_csv()
-#######################################
-
-##GAME LOOP#######################################################################
-while(1):
-    for e in event.get():
-        if e.type == QUIT:
-            quit()
-            sys.exit()
-        if e.type == KEYUP:
-            if e.key == K_UP:
-                gc.move('up', interactables["homes"] + interactables["landfills"])
-            if e.key == K_DOWN:
-                gc.move('down', interactables["homes"] + interactables["landfills"])
-            if e.key == K_RIGHT:
-                gc.move('right', interactables["homes"] + interactables["landfills"])
-            if e.key == K_LEFT:
-                gc.move('left', interactables["homes"] + interactables["landfills"])
-            if e.key == K_SPACE:
-                gc.select_object(all_sprites)
-
-    all_sprites.update()
-    all_sprites.draw(GAMEWINDOW)
-
-    for item in all_sprites:
-        if(type(item) == House):
-            item.generate_rubbish()
-
-    ##LIMIT LOGS TO 1 LOG EVERY 2s#####
-    hud_break = (hud_break + 1) % (FPS*2)
-
-    if(hud_break == 0):
-    ###################################
-        hud.get_statistics(all_sprites, csv_name, houses_csv_name)
-    display.flip()
-    fps_clock.tick(FPS) 
-##################################################################################

logs/houses_stats_20190327101235.csv

@@ -1,12 +0,0 @@
-House 1 plastic,House 1 glass,House 1 metal,House 2 plastic,House 2 glass,House 2 metal,House 3 plastic,House 3 glass,House 3 metal,House 4 plastic,House 4 glass,House 4 metal
-5,7,7,5,9,3,7,4,3,8,4,9
-6,7,7,5,9,3,8,4,3,8,8,9
-7,7,8,6,9,3,9,4,4,9,8,10
-7,9,9,7,9,3,10,4,4,9,9,10
-7,9,9,7,10,3,0,1,0,10,5,5
-8,9,9,7,10,4,1,1,0,10,6,5
-8,9,10,7,10,6,2,1,1,10,6,5
-5,10,6,0,0,1,3,1,1,10,7,5
-6,10,7,1,0,1,3,2,1,10,7,5
-9,10,8,2,0,1,4,2,2,10,9,5
-9,10,8,3,0,1,5,4,3,10,9,5

logs/houses_stats_20190327101837.csv

@@ -1,5 +0,0 @@
-House 1 plastic,House 1 glass,House 1 metal,House 2 plastic,House 2 glass,House 2 metal,House 3 plastic,House 3 glass,House 3 metal,House 4 plastic,House 4 glass,House 4 metal
-10,10,3,10,9,0,8,0,10,3,3,7
-10,10,4,10,10,0,9,1,10,3,3,7
-0,1,0,10,10,0,9,1,10,4,4,7
-1,2,0,10,10,2,9,1,10,5,5,7

logs/stats_20190327101235.csv

@@ -1,12 +0,0 @@
-Plastic left,Glass left,Metal left,GC plastic,GC glass,GC metal,Total collected
-25,24,22,0/10,0/10,0/10,0
-27,28,22,0/10,0/10,0/10,0
-31,28,25,0/10,0/10,0/10,0
-33,31,26,0/10,0/10,0/10,0
-24,25,17,10/10,10/10,10/10,30
-26,26,18,0/10,0/10,10/10,30
-27,26,22,0/10,0/10,0/10,30
-18,18,13,10/10,10/10,10/10,60
-20,19,14,10/10,10/10,10/10,60
-25,21,16,10/10,0/10,0/10,60
-27,23,17,0/10,0/10,0/10,60

logs/stats_20190327101837.csv

@@ -1,5 +0,0 @@
-Plastic left,Glass left,Metal left,GC plastic,GC glass,GC metal,Total collected
-31,22,20,0/10,0/10,0/10,0
-32,24,21,0/10,0/10,0/10,0
-23,16,17,10/10,10/10,4/10,24
-25,18,19,10/10,0/10,0/10,24

main.py

@@ -0,0 +1,10 @@
+import pygame
+
+from config import WINDOW_HEIGHT, WINDOW_WIDTH
+
+pygame_sprites = pygame.sprite.Group()
+
+FPS_CLOCK = pygame.time.Clock()
+GAME_WINDOW = display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT), 0, 32)
+
+grid = [ [] for x in range(0)]

raports/SI_Raport_1.md

@@ -1,139 +0,0 @@
-# Sztuczna inteligencja 2019 - Raport 1
-
-**Czas trwania opisywanych prac:** 06.03.2018 - 26.03.2018
-
-**Członkowie zespołu:** Anna Nowak, Magdalena Wilczyńska, Konrad Pierzyński, Michał Starski
-
-**Wybrany temat:** Inteligentna śmieciarka
-
-**Link do repozytorium projektu:** https://git.wmi.amu.edu.pl/s440556/SZI2019SmieciarzWmi 
-
-## Środowisko agenta i reprezentacja wiedzy
-
-Pracę zaczeliśmy od spisania wszystkiego co będzie nam potrzebne do napisanie działającego środowiska. Notatki
-
-można obejrzeć pod [tym linkiem](https://git.wmi.amu.edu.pl/s440556/SZI2019SmieciarzWmi/src/master/README.md). Pod uwagę wzieliśmy następujące czynniki:
-
-* Jak dana technologia radzi sobie z graficznym przedstawieniem informacji (render mapy i rozmieszczenie na niej obiektów, zmiana stanów obiektów w zależności od sytuacji ...)
-
-* Poziom skomplikowania operacji na strukturach danych
-
-* Podejście języka do paradygmatu obiektowego
-
-* Trudność w implementacji mechanizmów sztucznej inteligencji
-
-* Preferencje programistyczne grupy
-
-Po naradzie i sugestiach od strony prowadzącego zdecydowaliśmy, że do projektu najlepiej będzie pasował język **python** z uwagi na jego uniwersalność i łatwość przetwarzania danych.
-
-### Plansza po której porusza się agent
-
-**Założenia**
-
-1. Plansza jest generowana losowo przy każdym uruchomieniu skryptu
-
-2. Każda plansza zawiera *n* domów i 3 wysypiska śmieci
-
-3. Każdy domek klatkę generuje jeden z 3 rodzajów śmieci z prawdopodobieństwem P (domyślnie 1/25)
-
-4. Agent chodzi po domkach zbiera śmieci i wyrzuca je na odpowiednie wysypisko
-
-5. Agent ma pojemność 10 na każdy rodzaj śmiecia
-
-6. Dom może wygenerować maksymalnie 10 śmieci każdego rodzaju
-
-7. Plansza jest dyskretna
-
-**Detale implementacyjne**
-
-Środowisko powstało przy użyciu biblioteki **pygame**, która udostępnia nam narzędzia do wygodnego zbudowania schludnie wyglądającej symulacji. Plansza ma postać dwuwymiarowiej płaszczyzny kartezjańskiej podzielonej na komórki (Cells).  Na komórkach umieszczane są po kolei obiekty, tak, aby nie doszło do sytuacji, w której agent nie ma możliwości ruchu. Środowisko jest generowane dynamicznie w zależności od parametru **home-count**, który podajemy przy starcie skryptu. Dzięki temu możemy testować agenta w możliwie różnych sytuacjach. Opis elementów środowiska został przedstawiony przy użyciu paradygmatu obiektowego, dzięki temu kod jest czytelniejszy i wydzielony.
-
-
-
-Na ten moment na planszy pojawiają się instancje klas: 
-
-*Grass* - klasa reprezentująca komórkę po której agent może swobodnie się poruszać, wypełnia większość mapy
-
-*House* - klasa reprezentująca dom, agent wchodzi z nią w interakcję, zabiera wygenerowane śmieci
-
-*Landfill* - klasa reprezentująca wysypisko, agent wchodzi z nią w interakcję, oddaje zebrane śmieci
-
-*Garbage_collector* - klasa reprezentująca agenta - porusza się po mapie i wchodzi w interakcję z innymi obiektami
-
-*HUD* - klasa reprezentująca HUD aplikacji (jeszcze niezaimplementowany)
-
-
-
-**Struktura plików projektu**
-
---enums     => Klasy dziedziczące po klasie *Enum*, ułatwiające parsowanie informacji
-
---fonts     => Czcionki
-
---images    => Obrazy i ikony używane w aplikacji
-
---raports    => Raporty
-
---sprites     => Klasy reprezentujące obiekty na mapie
-
-    .gitignore
-
-    config.py    => Plik przechowujący funkcję zarządzające konfiguracją aplikacji    
-
-    game.py    => Plik rozruchowy programu
-
-    utils.py    => Funkcje pomocnicze
-
-    README.md     => Informacje o aplikacji
-
-    requirements.txt    => Przechowuje informacje na temat używanych bibliotek
-
-    to_do.txt    => Lista przyszłych zadań do zrobienia
-
-
-
-### Reprezentacja Wiedzy
-
-Przyjeliśmy na potrzeby projektu, że agent będzie wiedział co się dzieje na całym obszarze środowiska. W tym momencie wszystko co wie agent wyświetlane jest w oknie terminala, w czasie rzeczywistym, podczas trwania programu. Dodatkowo, przy każdym puszczeniu programu, zostaje wygenerowany plik .csv, który zawiera takie same informacje. Do informacji posiadanych przez agenta należą: 
-
-
-
-* Ile zebrano śmieci od startu programu
-
-* Stopień zapełnienia śmieciarki
-
-* Ile śmieci zostało na mapie
-
-
-
-Podczas dalszego rozwoju powyższe informacje będą przedstawiane na ekranie aplikacji.
-
-
-
-### Uruchamianie aplikacji
-
-**Linux**
-
-Uruchomienie standardowe (z 5 domami)
-
-```bash
-make init #stworzenie wirtualnego środowiska
-make install #zainstalowanie zależności
-make start #uruchomienie z domyślnym parametrem home-count=5
-```
-
-Uruchomienie niestandardowe
-
-```bash
-env/bin/python3 ./game.py home-count=amount #Liczba domów nie może być mniejsza niż 3
-```
-
-**Windows**
-
-```powershell
-py -m virtualenv env # Stworzenie wirtualnego środowiska
-env\Scripts\pip.exe install -r requirements.txt
-env\Scripts\python.exe ./game.py --home-count=amount
-```
-
-

requirements.txt

@@ -1 +0,0 @@
-pygame==1.9.4

sprites/cell.py

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-import pygame
-import sys
-from pygame.locals import *
-
-CELL_SIZE = 64
-
-
-class Cell(pygame.sprite.Sprite):
-    def __init__(self, x, y):
-        pygame.sprite.Sprite.__init__(self)
-        self.x = x
-        self.y = y
-        self.update()
-
-    def update(self):
-        self.rect = pygame.Rect(
-            self.x*CELL_SIZE, self.y*CELL_SIZE, CELL_SIZE, CELL_SIZE) 

sprites/garbage_collector.py

@@ -1,77 +0,0 @@
-import pygame
-from sprites.cell import Cell, CELL_SIZE
-from sprites.house import House
-from sprites.landfill import Landfill
-from config import PLAY_HEIGHT, PLAY_WIDTH
-
-GC_CAPACITY = 10
-
-class Garbage_collector(Cell):
-
-    def __init__(self, x, y):
-        Cell.__init__(self, x, y)
-        self.image = pygame.image.load("images/garbage_collector.png")
-        self.move_options = {
-            "up": lambda forbidden: ('y', self.y - 1) if (self.x, self.y - 1) not in forbidden and self.y - 1 >= 0 else ('y', self.y),
-            "down": lambda forbidden: ('y', self.y + 1) if (self.x, self.y + 1) not in forbidden and self.y + 1 < PLAY_HEIGHT // CELL_SIZE else ('y', self.y),
-            "left": lambda forbidden: ('x', self.x - 1) if (self.x - 1, self.y) not in forbidden and self.x - 1 >= 0 else ('x', self.x),
-            "right": lambda forbidden: ('x', self.x + 1) if (self.x + 1, self.y) not in forbidden and self.x + 1 < PLAY_WIDTH // CELL_SIZE else ('x', self.x)
-        }
-        self.trash_space_taken = {
-            "plastic": 0,
-            "glass": 0,
-            "metal": 0
-        }
-        self.trash_collected = 0
-
-    def move(self, direction, forbidden):
-        (destination, value) = self.move_options[direction](forbidden)
-        if(destination is 'x'):
-            self.x = value
-        elif(destination is 'y'):
-            self.y = value
-        self.update()
-
-    def collect_trash(self, house):
-        global GC_CAPACITY
-        rubbish = house.get_rubbish_data()
-        to_collect = rubbish.copy()
-
-        dic = {
-            0: "plastic",
-            1: "glass",
-            2: "metal"
-        }
-
-        for i in range(0,3):
-
-            if(rubbish[i] > GC_CAPACITY - self.trash_space_taken.get(dic[i])):
-                to_collect[i] = GC_CAPACITY - self.trash_space_taken.get(dic[i])
-            self.trash_space_taken[dic[i]] += to_collect[i]
-            self.trash_collected += to_collect[i]
-            print("GARBAGE COLLECTOR>> Took "+str(to_collect[i])+" "+dic[i])
-
-        house.give_away_rubbish(to_collect[0], to_collect[1], to_collect[2])
-
-    def throw_trash(self, landfill):
-        landfill_type = landfill.get_type()
-        print("GARBAGE COLLECTOR>> REMOVED "+landfill_type)
-        self.trash_space_taken[landfill_type] = 0
-
-    def select_object(self, interactables):
-        print("### INTERACTION ###")
-        for item in interactables:
-            if(type(item)==House):
-                item_x, item_y = item.get_coordinates()
-                if((abs(self.x - item_x)==1 and abs(self.y - item_y)==0) or (abs(self.x - item_x)==0 and abs(self.y - item_y)==1)):
-                    self.collect_trash(item)
-            elif(type(item)==Landfill):
-                item_x, item_y = item.get_coordinates()
-                if((abs(self.x - item_x)==1 and abs(self.y - item_y)==0) or (abs(self.x - item_x)==0 and abs(self.y - item_y)==1)):
-                    self.throw_trash(item)
-
-    def get_collect_data(self):
-        return self.trash_collected
-
-    def get_space_data(self):
-        return self.trash_space_taken

sprites/grass.py

@@ -1,9 +0,0 @@
-import pygame
-import sys
-from sprites.cell import Cell
-
-
-class Grass(Cell):
-    def __init__(self, x, y):
-        Cell.__init__(self, x, y)
-        self.image = pygame.image.load("images/grass.png")

sprites/house.py

@@ -1,71 +0,0 @@
-import pygame
-import sys
-import random
-from enum import Enum
-from sprites.cell import Cell
-from enums.house_image import House_image
-
-PLASTIC = 0  # blue
-GLASS = 1  # green
-METAL = 2  # yellow
-
-
-class House(Cell):
-    def __init__(self, x, y, max_plastic, max_glass, max_metal):
-        Cell.__init__(self, x, y)
-        self.image = pygame.image.load(House_image.house.value)
-        self.rubbish = [random.randint(0, max_plastic), random.randint(
-            0, max_glass), random.randint(0, max_metal)]  # plastic, glass, metal
-
-        self.max_plastic = max_plastic
-        self.max_glass = max_glass
-        self.max_metal = max_metal
-
-    def generate_rubbish(self):
-        if(random.randint(0, 25) == 1):  # 1/25 szansa na wyrzucenie śmiecia w klatce
-            thrash_type = random.randint(0, 2)
-            if(thrash_type == 0 and self.rubbish[thrash_type] < self.max_plastic):
-                self.rubbish[thrash_type] = self.rubbish[thrash_type] + 1
-            if(thrash_type == 1 and self.rubbish[thrash_type] < self.max_glass):
-                self.rubbish[thrash_type] = self.rubbish[thrash_type] + 1
-            if(thrash_type == 2 and self.rubbish[thrash_type] < self.max_metal):
-                self.rubbish[thrash_type] = self.rubbish[thrash_type] + 1
-
-        #mozna ladniej?
-        if(self.rubbish[PLASTIC] == self.max_plastic):
-            if(self.rubbish[GLASS] == self.max_glass):
-                if(self.rubbish[METAL] == self.max_metal):
-                    self.image = pygame.image.load(House_image.full.value) #plastik, szklo, metal
-                else:
-                    self.image = pygame.image.load(House_image.plastic_glass.value) #plastik, szklo
-            elif(self.rubbish[METAL] == self.max_metal):
-                self.image = pygame.image.load(House_image.plastic_metal.value) #plastik, metal
-            else:
-                self.image = pygame.image.load(House_image.plastic.value) #plastik
-        elif(self.rubbish[GLASS] == self.max_glass):
-            if(self.rubbish[METAL] == self.max_metal):
-                self.image = pygame.image.load(House_image.glass_metal.value) #szklo, metal
-            else:
-                self.image = pygame.image.load(House_image.glass.value) #szklo
-        elif(self.rubbish[METAL] == self.max_metal):
-            self.image = pygame.image.load(House_image.metal.value) #metal
-        else:
-            self.image = pygame.image.load(House_image.house.value) #niezapelnione
-    
-    def give_away_rubbish(self, plastic, glass, metal):
-        print("HOUSE>> Before giving away "+str(self.rubbish[PLASTIC])+" plastic, "+str(self.rubbish[GLASS])+" glass, "+str(self.rubbish[METAL])+" metal, ")
-        self.rubbish[PLASTIC] -= plastic
-        self.rubbish[GLASS] -= glass
-        self.rubbish[METAL] -= metal
-        print("HOUSE>> Gave away "+str(plastic)+" plastic, "+str(glass)+" glass, "+str(metal)+" metal, ")
-        print("HOUSE>> After giving away "+str(self.rubbish[PLASTIC])+" plastic, "+str(self.rubbish[GLASS])+" glass, "+str(self.rubbish[METAL])+" metal, ")
-
-    def check_rubbish_status(self):
-        print("plastic: " + str(self.rubbish[PLASTIC]) + " glass: " + str(
-            self.rubbish[GLASS]) + " metal: " + str(self.rubbish[METAL]))
-    
-    def get_rubbish_data(self):
-        return self.rubbish
-
-    def get_coordinates(self):
-        return self.x, self.y

sprites/hud.py

@@ -1,73 +0,0 @@
-import pygame
-from sprites.house import House
-from sprites.garbage_collector import Garbage_collector
-from config import HUD_HEIGHT
-import csv
-HUD_COLOR = (51,21,4)
-WHITE = (255,255,255)
-class Hud():
-    texts = []
-    def __init__(self,house_amount,WINDOW_WIDTH, WINDOW_HEIGHT,GAMEWINDOW):
-        pygame.init()
-        hud_upper = WINDOW_WIDTH - HUD_HEIGHT
-        hud_lower = WINDOW_WIDTH
-        height = hud_upper - hud_lower
-        font_type = 'fonts/Bazgroly.ttf'
-        font_size = house_amount * 2
-        GAMEWINDOW.fill(HUD_COLOR)
-        font = pygame.font.Font(font_type, font_size)
-
-        gc_plastic_text = font.render("Plastic: 0/0",True,WHITE)
-        gc_metal_text = font.render("Metal: 0/0",True,WHITE)
-        gc_glass_text = font.render("Glass: 0/0",True,WHITE)
-        map_plastic_text =  font.render("Plastic: 0",True,WHITE)
-        map_metal_text = font.render("Metal: 0",True,WHITE)
-        map_glass_text = font.render("Glass: 0",True,WHITE)
-        overall_text = font.render("Garbage thrown away: 0",True,WHITE)
-        GAMEWINDOW.blit(overall_text,(20, 20))
-
-    def get_statistics(self, all_sprites, csv_name, houses_csv_name):
-        ###Garbage collector stats###
-        gc_taken_space_plastic = 0
-        gc_taken_space_metal = 0
-        gc_taken_space_glass = 0
-        gc_trash_space = 10
-
-        ###Board stats###############
-        plastic_left = 0
-        metal_left = 0
-        glass_left = 0
-        total_gathered = 0
-
-        houses_data = []
-
-        for item in all_sprites:
-            if(type(item) == House):
-                rubbish = item.get_rubbish_data()
-                plastic_left += rubbish[0]
-                glass_left += rubbish[1]
-                metal_left += rubbish[2]
-                houses_data.append(str(rubbish[0]))
-                houses_data.append(str(rubbish[1]))
-                houses_data.append(str(rubbish[2]))
-            if(type(item) == Garbage_collector):
-                space_taken = item.get_space_data()
-                gc_taken_space_plastic += space_taken.get("plastic")
-                gc_taken_space_glass += space_taken.get("glass")
-                gc_taken_space_metal += space_taken.get("metal")
-                total_gathered += item.get_collect_data()
-
-        print("plastic left: "+str(plastic_left)+" | glass left: "+str(glass_left)+" | metal left: "+str(metal_left))
-        print("    plastic: "+str(gc_taken_space_plastic)+"/"+str(gc_trash_space)+" | glass: "+str(gc_taken_space_glass)+"/"+str(gc_trash_space)+" | metal: "+str(gc_taken_space_metal)+"/"+str(gc_trash_space))
-        print("### TOTAL COLLECTED: "+str(total_gathered)+" ###") 
-
-        with open(csv_name, 'a', newline='') as csvfile:
-            filewriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
-            row = [str(plastic_left), str(glass_left), str(metal_left), str(gc_taken_space_plastic)+"/"+str(gc_trash_space), str(gc_taken_space_glass)+"/"+str(gc_trash_space), str(gc_taken_space_metal)+"/"+str(gc_trash_space), str(total_gathered)]
-            filewriter.writerow(row)
-            csvfile.close()      
-
-        with open(houses_csv_name, 'a', newline='') as csvfile:
-            filewriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
-            filewriter.writerow(houses_data)
-            csvfile.close()   

sprites/landfill.py

@@ -1,17 +0,0 @@
-import pygame
-import sys
-from sprites.cell import Cell
-
-
-class Landfill(Cell):
-    def __init__(self, x, y, type):
-        Cell.__init__(self, x, y)
-        types = ["plastic", "glass", "metal"]
-        self.type = types[type]
-        self.image = pygame.image.load("images/landfill_%s.png" % (self.type)) 
-    
-    def get_coordinates(self):
-        return self.x, self.y
-
-    def get_type(self):
-        return self.type

to_do.txt

@@ -1,6 +0,0 @@
-+Przy losowaniu domku: Sprawdzić, czy pole które wylosowaliśmy jest typu Grass (bo nie można go postawić na wysypisku ani na innym domku)
-+Dodanie metody od zapełniania śmietników która updatuje się co klatkę (Jeżeli zapełnienie == 100 to zmienia się sprite i trzeba zabrać czy coś takiego)
--Dodanie hudu
-+Wpisywanie na początku gry liczby domków
-+Umieszczenie na mapie wysypisk(I dodanie ich klasy)
--W JAKI SPOSÓB MOŻNA PREZENTOWAĆ KILKA RÓŻNYCH ŚMIECI NA DOMKU?

utils.py

@@ -1,100 +0,0 @@
-import sys
-import getopt
-import random
-import csv
-import datetime
-from config import PLAY_WIDTH, PLAY_HEIGHT, home_amount
-from sprites.cell import CELL_SIZE
-from sprites.grass import Grass
-from sprites.house import House
-from sprites.landfill import Landfill
-from sprites.garbage_collector import Garbage_collector
-
-
-def generate_rand_coordinates(max_x, max_y):
-    return (random.randint(0, max_x), random.randint(0, (max_y)))
-
-##GENERATE GRASS##################################################################
-def generate_grass(all_sprites):
-    grass = []
-    for k in range(0, (PLAY_WIDTH//CELL_SIZE)*(PLAY_HEIGHT//CELL_SIZE)):
-        x, y = (int(k % (PLAY_WIDTH//CELL_SIZE)),
-                int(k/(PLAY_WIDTH//CELL_SIZE)))
-        grass.append(Grass(x, y))
-
-    for item in grass:
-        all_sprites.add(item)
-##################################################################################
-
-##GENERATE HOUSES#################################################################
-
-
-def generate_houses(all_sprites, obstacles_coords):
-    houses = []
-    home_counter = home_amount
-    while(home_counter != 0):
-        x, y = generate_rand_coordinates(
-            (PLAY_WIDTH//CELL_SIZE)-1, (PLAY_HEIGHT//CELL_SIZE)-1)
-        if(((x, y)) not in obstacles_coords["homes"] and ((x, y)) not in obstacles_coords["landfills"] and ((x, y-1)) not in obstacles_coords["landfills"]):
-            houses.append(House(x, y, 10, 10, 10))
-            obstacles_coords["homes"].append((x, y))
-            home_counter = home_counter - 1
-
-    for item in houses:
-        all_sprites.add(item)
-##################################################################################
-
-##GENERATE LANDFILLS##############################################################
-
-
-def generate_landfills(all_sprites, obstacles_coords):
-    landfills = []
-    landfill_counter = 3
-    y=0
-    for x in range(landfill_counter):
-        landfills.append(Landfill(x,y,x))
-        obstacles_coords["landfills"].append((x,y))
-    for item in landfills:
-        all_sprites.add(item)
-##################################################################################
-
-##GENERATE GARBAGE COLLECTOR######################################################
-
-
-def generate_garbage_collector(all_sprites, obstacles_coords):
-    while(True):
-        x, y = generate_rand_coordinates(
-            (PLAY_WIDTH//CELL_SIZE)-1, (PLAY_HEIGHT//CELL_SIZE)-1)
-        if((x, y) not in obstacles_coords["landfills"] and (x, y) not in obstacles_coords["homes"]):
-            gc = Garbage_collector(x, y)
-            break
-    all_sprites.add(gc)
-    return gc
-##################################################################################
-
-##INIT CSV FILES#######################
-def init_csv():
-
-    currentDT = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
-    stats_csv_name = "logs/stats_" + currentDT + ".csv"
-
-    with open(stats_csv_name, 'w', newline='') as csvfile:
-        filewriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
-        row = ["Plastic left", "Glass left", "Metal left", "GC plastic", "GC glass", "GC metal", "Total collected"]
-        filewriter.writerow(row)
-        csvfile.close()
-
-    houses_csv_name = "logs/houses_stats_" + currentDT + ".csv"
-
-    with open(houses_csv_name, 'w', newline='') as csvfile:
-        filewriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
-        row = []
-        for i in range(home_amount):
-            row.append("House "+str(i+1)+" plastic")
-            row.append("House "+str(i+1)+" glass")
-            row.append("House "+str(i+1)+" metal")
-        filewriter.writerow(row)
-        csvfile.close()
-    
-    return stats_csv_name, houses_csv_name
-#######################################