demo

board.py

@@ -122,4 +122,5 @@ class Board:
         self.vegetables[row][col] = self.vegetables[row][col]
 
     def set_fakedirt(self, row, col):
-        self.board[row][col] = 11
+        self.board[row][col] = 11
+

generate_board.py

@@ -0,0 +1,221 @@
+import random
+import numpy as np
+import pygame
+
+# Wymiary planszy
+rows, cols = 10, 10  # Ustalona liczba wierszy i kolumn
+size = 50  # Rozmiar pojedynczego pola na planszy
+
+
+# Klasa reprezentująca planszę
+class Board:
+    def __init__(self):
+        self.board = []  # Tablica reprezentująca planszę
+        self.vegetables = []  # Tablica przechowująca warzywa na planszy
+        self.soil_features = None  # Cechy gleby (wilgotność, temperatura itp.)
+        self.vegetable_names = []  # Tablica przechowująca nazwy warzyw na planszy
+        self.load_images()  # Ładowanie obrazów warzyw i innych elementów planszy
+        self.generate_board()  # Generowanie początkowej planszy
+
+    # Metoda do ładowania obrazów
+    def load_images(self):
+        self.grass = pygame.Surface((size, size))  # Tworzenie powierzchni dla trawy
+        self.grass.fill((0, 255, 0))  # Wypełnienie powierzchni zielonym kolorem (trawa)
+
+        # Tworzenie powierzchni dla różnych warzyw
+        self.warzywa_images = {
+            "pomidor": [pygame.Surface((size, size)) for _ in range(9)],
+            "ogorek": [pygame.Surface((size, size)) for _ in range(9)],
+            "kalafior": [pygame.Surface((size, size)) for _ in range(9)]
+        }
+
+        # Kolory przypisane do każdego warzywa
+        colors = {
+            "pomidor": (255, 0, 0),  # Czerwony
+            "ogorek": (255, 165, 0),  # Pomarańczowy
+            "kalafior": (255, 255, 255)  # Biały
+        }
+
+        # Wypełnianie powierzchni odpowiednim kolorem dla każdego warzywa
+        for veg, color in colors.items():
+            for surface in self.warzywa_images[veg]:
+                surface.fill(color)
+
+        # Typy warzyw przypisane do liczb
+        self.vegetable_types = {
+            "pomidor": 1,
+            "ogorek": 2,
+            "kalafior": 3
+        }
+
+    # Metoda do generowania początkowej planszy
+    def generate_board(self):
+        self.board = [[random.choice([0, 1, 2, 3]) for _ in range(cols)] for _ in range(rows)]
+        self.vegetables = [[None for _ in range(cols)] for _ in range(rows)]
+        self.vegetable_names = [[None for _ in range(cols)] for _ in range(rows)]
+
+        # Losowe przypisanie warzyw do planszy
+        for row in range(rows):
+            for col in range(cols):
+                if self.board[row][col] in (1, 2, 3):
+                    vegetable_type = list(self.warzywa_images.keys())[self.board[row][col] - 1]
+                    vegetable_image = random.choice(self.warzywa_images[vegetable_type])
+                    self.vegetables[row][col] = vegetable_image
+                    self.vegetable_names[row][col] = vegetable_type
+
+        self.soil_features = self.generate_soil_features()  # Generowanie cech gleby
+
+    # Metoda do generowania cech gleby
+    def generate_soil_features(self):
+        return {
+            "wilgotnosc_gleby": random.randint(30, 70),
+            "temperatura_gleby": random.randint(13, 26),
+            "opady_deszczu": random.randint(0, 11),
+            "wiek_rosliny": random.randint(1, 9),
+            "proc_ekspo_na_swiatlo": random.randint(10, 90),
+            "pora_dnia": random.randint(8, 20),
+            "pora_roku": random.randint(1, 4)
+        }
+
+    # Metoda oceniająca jakość planszy
+    def evaluate(self):
+        score = 0
+        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # Kierunki: prawo, dół, lewo, góra
+
+        # Sprawdzanie sąsiednich pól dla każdego warzywa
+        for row in range(rows):
+            for col in range(cols):
+                if self.is_vegetable(row, col):
+                    for dr, dc in directions:
+                        new_row, new_col = row + dr, col + dc
+                        if 0 <= new_row < rows and 0 <= new_col < cols:
+                            if self.vegetable_names[row][col] == self.vegetable_names[new_row][new_col]:
+                                score += 1
+        return score
+
+    # Metoda mutująca planszę
+    def mutate(self, mutation_rate):
+        for row in range(rows):
+            for col in range(cols):
+                if random.random() < mutation_rate:
+                    self.board[row][col] = random.choice([0, 1, 2, 3])
+                    if self.board[row][col] in (1, 2, 3):
+                        vegetable_type = list(self.warzywa_images.keys())[self.board[row][col] - 1]
+                        vegetable_image = random.choice(self.warzywa_images[vegetable_type])
+                        self.vegetables[row][col] = vegetable_image
+                        self.vegetable_names[row][col] = vegetable_type
+
+    # Metoda krzyżująca planszę z inną planszą
+    def crossover(self, other_board):
+        crossover_point = random.randint(0, rows * cols - 1)
+        for i in range(rows):
+            for j in range(cols):
+                if i * cols + j > crossover_point:
+                    self.board[i][j], other_board.board[i][j] = other_board.board[i][j], self.board[i][j]
+                    self.vegetables[i][j], other_board.vegetables[i][j] = other_board.vegetables[i][j], \
+                    self.vegetables[i][j]
+                    self.vegetable_names[i][j], other_board.vegetable_names[i][j] = other_board.vegetable_names[i][j], \
+                    self.vegetable_names[i][j]
+
+    # Metoda kopiująca planszę
+    def copy(self):
+        new_board = Board()
+        new_board.board = [row[:] for row in self.board]
+        new_board.vegetables = [row[:] for row in self.vegetables]
+        new_board.vegetable_names = [row[:] for row in self.vegetable_names]
+        new_board.soil_features = self.soil_features.copy()
+        return new_board
+
+    # Sprawdza, czy dane pole zawiera warzywo
+    def is_vegetable(self, row, col):
+        return self.board[row][col] in (1, 2, 3)
+
+    # Rysowanie planszy na oknie pygame
+    def draw_cubes(self, win):
+        for row in range(rows):
+            for col in range(cols):
+                cube_rect = pygame.Rect(col * size, row * size, size, size)
+                cube = self.board[row][col]
+                if cube == 0:
+                    win.blit(self.grass, cube_rect)
+                else:
+                    if self.vegetables[row][col]:
+                        vegetable_image = pygame.transform.scale(self.vegetables[row][col], (size, size))
+                        win.blit(vegetable_image, cube_rect)
+
+
+# Funkcja oceniająca planszę (wywołuje metodę evaluate)
+def evaluate(board):
+    return board.evaluate()
+
+
+# Generowanie początkowej populacji plansz
+def generate_population(size):
+    return [Board() for _ in range(size)]
+
+
+# Selekcja metodą ruletki
+def roulette_wheel_selection(population, fitnesses):
+    total_fitness = sum(fitnesses)
+    selection_probs = [f / total_fitness for f in fitnesses]
+    return population[random.choices(range(len(population)), weights=selection_probs, k=1)[0]]
+
+
+# Krzyżowanie jednopunktowe
+def crossover(parent1, parent2):
+    child1, child2 = parent1.copy(), parent2.copy()
+    child1.crossover(child2)
+    return child1, child2
+
+
+# Mutacja planszy
+def mutate(board, mutation_rate):
+    board.mutate(mutation_rate)
+
+
+# Algorytm genetyczny
+def genetic_algorithm(pop_size, generations, mutation_rate):
+    population = generate_population(pop_size)  # Generowanie początkowej populacji
+    for _ in range(generations):
+        fitnesses = [evaluate(board) for board in population]  # Ocenianie każdej planszy
+        new_population = []
+        while len(new_population) < pop_size:
+            parent1 = roulette_wheel_selection(population, fitnesses)  # Wybór rodzica 1 metodą ruletki
+            parent2 = roulette_wheel_selection(population, fitnesses)  # Wybór rodzica 2 metodą ruletki
+            offspring1, offspring2 = crossover(parent1, parent2)  # Krzyżowanie rodziców
+            mutate(offspring1, mutation_rate)  # Mutacja potomka 1
+            mutate(offspring2, mutation_rate)  # Mutacja potomka 2
+            new_population.extend([offspring1, offspring2])  # Dodanie potomków do nowej populacji
+        population = new_population  # Zamiana starej populacji na nową
+    best_board = max(population, key=evaluate)  # Wybór najlepszej planszy z populacji
+    return best_board
+
+
+# Parametry algorytmu
+pop_size = 50  # Rozmiar populacji
+generations = 200  # Liczba generacji
+mutation_rate = 0.05  # Wskaźnik mutacji
+
+# Inicjalizacja Pygame
+pygame.init()
+win = pygame.display.set_mode((cols * size, rows * size))  # Ustawienie rozmiaru okna
+pygame.display.set_caption('Generated Board')  # Ustawienie tytułu okna
+
+# Generowanie najlepszej planszy
+best_board = genetic_algorithm(pop_size, generations, mutation_rate)
+
+# Rysowanie najlepszej planszy
+best_board.draw_cubes(win)
+pygame.display.update()
+
+# Zapisywanie planszy do pliku
+np.save('generated_board.npy', best_board.board)
+
+# Utrzymanie okna otwartego do zamknięcia przez użytkownika
+run = True
+while run:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            run = False
+
+pygame.quit()

main.py

@@ -60,8 +60,11 @@ def main():
     initial_state = Stan(4, 4, "down")
     run = True
     clock = pygame.time.Clock()
+
     board = Board()
     board.load_images()
+
+
     tractor = Tractor(4, 4, model, feature_columns, neuralnetwork_model)
 
     while run: