Drzewo + algorytm genetyczny

This commit is contained in:
s481847 2024-06-25 14:07:11 +02:00
parent bc6bcc0aed
commit 9bebdee4de

695
gen+tree.py Normal file
View File

@ -0,0 +1,695 @@
import pygame
import random
import time
import pandas as pd
import math
import matplotlib.pyplot as plt
import random
import copy
pop_size = 100
mutacje = 1
kuchnia_xy = 0
pozycja_startowa = 0
losuj_uklad = False # Gdy True, losuje uklad stolikow oraz przeszkod
# ------------Ustawienia siatki
blockSize = 60
rows = 14
columns = 24
# -----------------------------Inicjacja klas
class Kelner:
def __init__(self, x, y):
self.x = x
self.y = y
self.speed = 80 # od 0 do 100, preferowane 80
self.stanPrzestrzeni = [0, 0, 0]
self.stan = "stoi" # Stan kelnera: stoi, odbiera lub wraca
self.stolik_docelowy = None # Stolik, do którego idzie kelner
self.chodzi = True
self.cel_x = x
self.cel_y = y
self.kierunek = 0 # 0 - północ, 1 - wschód, 2 - południe, 3 - zachód
self.indexRuchu = 0
def wklej(self):
kelnerRotated = pygame.transform.rotate(kelnerImg, -90 * kelner.kierunek)
screen.blit(kelnerRotated, (self.x * blockSize, self.y * blockSize))
# def idz_do_stolika(self):
# self.cel_x, self.cel_y = self.stolik_docelowy.x, self.stolik_docelowy.y
# kelner.stan = "odbiera"
def idz_do_kuchni(self):
self.cel_x, self.cel_y = kuchnia_xy, kuchnia_xy
self.stolik_docelowy = None
kelner.stan = "wraca"
def obrot_w_lewo(self):
self.kierunek = (self.kierunek - 1) % 4
self.stanPrzestrzeni[2] = (self.stanPrzestrzeni[2] - 1) % 4
def obrot_w_prawo(self):
self.kierunek = (self.kierunek + 1) % 4
self.stanPrzestrzeni[2] = (self.stanPrzestrzeni[2] + 1) % 4
def idz_do_przodu(self):
if self.kierunek == 0:
self.y -= 1
self.stanPrzestrzeni[1] -= 1
elif self.kierunek == 1:
self.x += 1
self.stanPrzestrzeni[0] += 1
elif self.kierunek == 2:
self.y += 1
self.stanPrzestrzeni[1] += 1
elif self.kierunek == 3:
self.x -= 1
self.stanPrzestrzeni[0] -= 1
def wykonajAkcje(self, ruchy):
if self.indexRuchu < len(ruchy):
akcja = ruchy[self.indexRuchu]
if akcja == 'F':
self.idz_do_przodu()
elif akcja == 'L':
self.obrot_w_lewo()
elif akcja == 'R':
self.obrot_w_prawo()
self.indexRuchu += 1
if self.indexRuchu >= len(ruchy): # Reset po zakończeniu wszystkich ruchów
self.indexRuchu = 0
class Stolik:
def __init__(self, x, y):
self.x = x
self.y = y
self.zamowione = False
def wklej(self):
screen.blit(stolikImg, (self.x * blockSize, self.y * blockSize))
class Przeszkoda:
def __init__(self, x, y, typ):
self.x = x
self.y = y
self.typ = typ
# ocena kosztu przeszkody
if self.typ == "sliska podloga":
self.cena = 2
elif self.typ == "dywan":
self.cena = 4
def wklej(self):
if self.typ == "sliska podloga":
screen.blit(sliskaPodlogaImg, (self.x * blockSize, self.y * blockSize))
elif self.typ == "dywan":
screen.blit(dywanImg, (self.x * blockSize, self.y * blockSize))
# -----------------Przeszukiwanie przestrzeni stanów
import heapq
def a_star(start, cel, stoliki, przeszkody):
queue = [] # Kolejka priorytetowa
heapq.heappush(queue, (0, start)) # (koszt, stan)
odwiedzone = set([start])
poprzednicy = {start: (None, None, 0)} # (poprzedni stan, ruch, koszt do tej pory)
while queue:
obecny_koszt, obecny = heapq.heappop(queue) # pobranie stanu z najniższym kosztem
if obecny[:2] == cel:
return odtworz_ruchy(poprzednicy, obecny)
for nastepnik, ruch, koszt_ruchu in generuj_nastepniki_i_ruchy(obecny, stoliki, przeszkody):
nowy_koszt = poprzednicy[obecny][2] + koszt_ruchu # Obliczanie nowego kosztu dojscia do nastepnika
# nastepnik nie był odwiedzony lub znaleziono tansza sciezke do niego
if nastepnik not in odwiedzone or nowy_koszt < poprzednicy.get(nastepnik, (None, None, float('inf')))[2]:
heapq.heappush(queue, (nowy_koszt + heurystyka(nastepnik, cel), nastepnik))
poprzednicy[nastepnik] = (obecny, ruch, nowy_koszt)
odwiedzone.add(nastepnik)
return []
def heurystyka(nastepnik, cel):
# Oszacowanie sumy odleglosci w pionie i w poziomie
return abs(nastepnik[0] - cel[0]) + abs(nastepnik[1] - cel[1])
# ----------Funkcja generowania następników dla poszczególnych stanów
def generuj_nastepniki_i_ruchy(stan, stoliki, przeszkody):
x, y, kierunek = stan
ruchy = []
# Obrot w lewo
nowy_kierunek = (kierunek - 1) % 4
ruchy.append(((x, y, nowy_kierunek), 'L', 1))
# Obrot w prawo
nowy_kierunek = (kierunek + 1) % 4
ruchy.append(((x, y, nowy_kierunek), 'R', 1))
# Krok do przodu
if kierunek == 0:
nowy_x, nowy_y = x, y - 1
elif kierunek == 1:
nowy_x, nowy_y = x + 1, y
elif kierunek == 2:
nowy_x, nowy_y = x, y + 1
elif kierunek == 3:
nowy_x, nowy_y = x - 1, y
# sprawdzamy, czy następny stan jest w granicach planszy
if 0 <= nowy_x < columns and 0 <= nowy_y < rows:
# sprawdzamy, czy następny stan nie wchodzi w stolik
if not any(stolik.x == nowy_x and stolik.y == nowy_y for stolik in stoliki):
koszt = next(
(przeszkoda.cena for przeszkoda in przeszkody if przeszkoda.x == nowy_x and przeszkoda.y == nowy_y), 1)
ruchy.append(((nowy_x, nowy_y, kierunek), 'F', koszt))
return ruchy
# -----Funkcja tworząca listę kroków potrzebnych do uzyskania celu
def odtworz_ruchy(poprzednicy, cel):
ruchy = []
krok = cel
while krok and poprzednicy[krok][0] is not None:
ruchy.append(poprzednicy[krok][1])
krok = poprzednicy[krok][0]
ruchy.reverse()
return ruchy
def licz_entropie(data, target_column):
total_rows = len(data)
target_values = data[target_column].unique()
entropy = 0
for value in target_values:
value_count = len(data[data[target_column] == value])
proportion = value_count / total_rows
entropy -= proportion * math.log2(proportion)
return entropy
def licz_zysk(atrybut,korzen,data):
entropia_wazona = 0
unique_values = data[atrybut].unique()
for value in unique_values:
subset = data[data[atrybut] == value]
proportion = len(subset) / len(data)
entropia_wazona += proportion * licz_entropie(subset, data.columns[-1])
zysk = korzen - entropia_wazona
return zysk
def szukaj_split(z, atrybuty):
max = 0
max_atr = "None"
for atrybut in atrybuty:
if z[atrybut]>max:
max = z[atrybut]
max_atr = atrybut
return max_atr
def GenerujDane(ques):
k = [0,0,0,0,0,0,0,0]
for n in range(8):
k[n] = random.choice([0,1])
print(ques[n] + str(k[n]))
return k
def id3(data,mode,klient):
zysk = {}
korzen = licz_entropie(data,data.columns[-1])
lista = data.columns
for atrybut in lista[:-1]:
zysk[atrybut] = licz_zysk(atrybut,korzen,data)
split = szukaj_split(zysk, data.head(0).columns[:-1])
if split == "None":
wynik = data.iloc[0, -1]
if wynik == 1 and mode == "klient":
print("Klient zadowolony!")
elif wynik == 0 and mode == "klient":
print("Klient niezadowolony!")
print("---------------------------------------------------------------------------------------")
else:
#print("Split: " + str(split))
subset0 = data[data[split] == 0]
subset0 = subset0.drop([split], axis=1)
subset1 = data[data[split] == 1]
subset1 = subset1.drop([split], axis=1)
#print("Klient: " + str(klient))
if len(subset0) < len(data) and len(subset1) < len(data):
if mode == "klient":
if klient[split] == 0:
frames.append(subset0)
else:
frames.append(subset1)
elif mode == "full":
frames.append(subset0)
frames.append(subset1)
if len(frames) > 0:
newData = frames.pop()
id3(newData,mode, klient)
def Zamiana(populacja_pref, pokolenie_pref):#---------------------------------------------------------------------------------
nowe_pokolenie = []
for i in range(len(pokolenie_pref)):
if populacja_pref[i][-1] < pokolenie_pref[i][-1]:
nowe_pokolenie.append(pokolenie_pref[i][0:-1])
elif populacja_pref[i][-1] >= pokolenie_pref[i][-1]:
nowe_pokolenie.append(populacja_pref[i][0:-1])
return nowe_pokolenie
def Mutacje(dzieci):
nowe_pokolenie = []
nowe_pokolenie1 = []
x = 0
ryba = []
ryba.append("nic")
mieso = []
mieso.append("nic")
deser = []
deser.append("nic")
napoj = []
napoj.append("nic")
for x in range(len(klient)):
if klient[x]["typ"] == "ryba":
ryba.append(klient[x]["nazwa"])
elif klient[x]["typ"] == "mieso":
mieso.append(klient[x]["nazwa"])
elif klient[x]["typ"] == "deser":
deser.append(klient[x]["nazwa"])
elif klient[x]["typ"] == "napoj":
napoj.append(klient[x]["nazwa"])
for a in dzieci:
for b in range(len(a)):
if random.randrange(0, 10) < mutacje:
if b == 0:
a[b] = random.choice(ryba)
if b == 1:
a[b] = random.choice(mieso)
if b == 2:
a[b] = random.choice(deser)
if b == 3:
a[b] = random.choice(napoj)
nowe_pokolenie.append(a)
return nowe_pokolenie
def Krzyzowanie(populacja, top):
dzieci = []
for i in range(len(populacja)):
r1 = random.choice(top)
r2 = random.choice(populacja)
rodzic1 = r1[0:-1]
rodzic2 = r2[0:-1]
crossover_point = random.randint(1, len(populacja[0])-2)
dziecko = rodzic1[:crossover_point] + rodzic2[crossover_point:]
if dziecko not in dzieci:
dzieci.append(dziecko)
nowe_pokolenie = Mutacje(dzieci)
return nowe_pokolenie
def LiczZadowolenie(klient, populacja):
preferencje = []
for x in populacja:
satysfakcja = 0
for y in x:
for a in range(len(klient)):
if klient[a]["nazwa"] == y:
satysfakcja = satysfakcja + klient[a]["popularnosc"]
d2 = copy.deepcopy(x)
d2.append(satysfakcja)
preferencje.append(d2)
return preferencje
def UsunZleChromosomy(klient, chromosomy, budzet):
populacja = []
for chromosom in chromosomy:
suma = 0
cena = 0
for y in chromosom:
for a in range(len(klient)):
if klient[a]["nazwa"] == y:
cena = klient[a]["cena"]
suma = suma + cena
elif y == "nic":
cena = 0
suma = suma + cena
if(suma<=budzet):
populacja.append(chromosom)
return populacja
def UtworzPopulacje(klient, budzet):
ryba = []
ryba.append("nic")
mieso = []
mieso.append("nic")
deser = []
deser.append("nic")
napoj = []
napoj.append("nic")
x = 0
for x in range(len(klient)):
if klient[x]["typ"] == "ryba":
ryba.append(klient[x]["nazwa"])
elif klient[x]["typ"] == "mieso":
mieso.append(klient[x]["nazwa"])
elif klient[x]["typ"] == "deser":
deser.append(klient[x]["nazwa"])
elif klient[x]["typ"] == "napoj":
napoj.append(klient[x]["nazwa"])
chromosomy = []
for i in range(pop_size):
chromosom = []
chromosom.append(ryba[random.randint(0, len(ryba)-1)])
chromosom.append(mieso[random.randint(0, len(mieso)-1)])
chromosom.append(deser[random.randint(0, len(deser)-1)])
chromosom.append(napoj[random.randint(0, len(napoj)-1)])
if chromosom not in chromosomy:
chromosomy.append(chromosom)
populacja = UsunZleChromosomy(klient, chromosomy, budzet)
print("Budzet klienta: " + str(budzet))
return populacja
def Algorytm_genetyczny(populacja, budzet, gen, klient):
populacja_pref = LiczZadowolenie(klient, populacja)
top = []
for x in populacja_pref:
d2 = copy.deepcopy(x)
top.append(d2)
top.sort(key=lambda x: x[4], reverse = True)
for i in range (int(len(top)/2)):
top.pop()
pokolenie = Krzyzowanie(populacja_pref, top)
pokolenie1 = UsunZleChromosomy(klient, pokolenie, budzet)
pokolenie_pref = LiczZadowolenie(klient, pokolenie1)
nowe_pokolenie = Zamiana(populacja_pref, pokolenie_pref)
if gen == 3:
print("Najlepsze dopasowanie: " + str(top[0]))
return nowe_pokolenie
def najlepszeDopasowanie():
pop_size = 100
klient = []
dania = [
{"nazwa": "Losos", "typ": "ryba", "cena": 50, "popularnosc": 45},
{"nazwa": "Sledz", "typ": "ryba", "cena": 28, "popularnosc": 28},
{"nazwa": "Karp", "typ": "ryba", "cena": 43, "popularnosc": 45},
{"nazwa": "Tunczyk", "typ": "ryba", "cena": 53, "popularnosc": 46},
{"nazwa": "Dorsz", "typ": "ryba", "cena": 42, "popularnosc": 45},
{"nazwa": "Pstrag", "typ": "ryba", "cena": 34, "popularnosc": 38},
{"nazwa": "Makrela", "typ": "ryba", "cena": 40, "popularnosc": 44},
{"nazwa": "Kaczka", "typ": "mieso", "cena": 32, "popularnosc": 30},
{"nazwa": "Kurczak", "typ": "mieso", "cena": 27, "popularnosc": 29},
{"nazwa": "Indyk", "typ": "mieso", "cena": 31, "popularnosc": 32},
{"nazwa": "Wieprzowina", "typ": "mieso", "cena": 20, "popularnosc": 25},
{"nazwa": "Wolowina", "typ": "mieso", "cena": 25, "popularnosc": 28},
{"nazwa": "Krolik", "typ": "mieso", "cena": 36, "popularnosc": 33},
{"nazwa": "Stek", "typ": "mieso", "cena": 37, "popularnosc": 35},
{"nazwa": "Tiramisu", "typ": "deser", "cena": 27, "popularnosc": 40},
{"nazwa": "Ciasto", "typ": "deser", "cena": 24, "popularnosc": 33},
{"nazwa": "Gofry", "typ": "deser", "cena": 23, "popularnosc": 35},
{"nazwa": "Sernik", "typ": "deser", "cena": 19, "popularnosc": 30},
{"nazwa": "Churros", "typ": "deser", "cena": 35, "popularnosc": 50},
{"nazwa": "Pudding", "typ": "deser", "cena": 29, "popularnosc": 42},
{"nazwa": "Lody", "typ": "deser", "cena": 20, "popularnosc": 33},
{"nazwa": "Herbata", "typ": "napoj", "cena": 15, "popularnosc": 25},
{"nazwa": "Sok", "typ": "napoj", "cena": 18, "popularnosc": 30},
{"nazwa": "Kawa", "typ": "napoj", "cena": 20, "popularnosc": 30},
{"nazwa": "Lemoniada", "typ": "napoj", "cena": 16, "popularnosc": 29},
{"nazwa": "Mirinda", "typ": "napoj", "cena": 14, "popularnosc": 27},
{"nazwa": "Woda", "typ": "napoj", "cena": 8, "popularnosc": 14},
{"nazwa": "Pepsi", "typ": "napoj", "cena": 16, "popularnosc": 28}
]
mnoznik_ryba = random.randint(1, 8) * 0.25 # -----------------------preferencje klienta
mnoznik_mieso = random.randint(1, 8) * 0.25
mnoznik_deser = random.randint(1, 8) * 0.25
mnoznik_napoj = random.randint(1, 8) * 0.25
budzet = random.randint(100, 200)
pop_size = 100 # --------------------------------------------liczba chromosomow w populacji
mutacje = 1 # ------------------------------------------------od 0 do 10
print("Preferencje klienta: Ryba: " + str(mnoznik_ryba) + "; Mieso: " + str(mnoznik_mieso) + "; Deser: " + str(
mnoznik_deser) + "; Napoj: " + str(mnoznik_napoj))
for x in dania:
d2 = copy.deepcopy(x)
klient.append(d2)
for i in range(len(dania)):
if klient[i]["typ"] == "ryba":
klient[i]["popularnosc"] = klient[i]["popularnosc"] * mnoznik_ryba
if klient[i]["typ"] == "mieso":
klient[i]["popularnosc"] = klient[i]["popularnosc"] * mnoznik_mieso
if klient[i]["typ"] == "deser":
klient[i]["popularnosc"] = klient[i]["popularnosc"] * mnoznik_deser
if klient[i]["typ"] == "napoj":
klient[i]["popularnosc"] = klient[i]["popularnosc"] * mnoznik_napoj
populacja = UtworzPopulacje(klient, budzet)
gen = 0
for i in range(3):
gen = gen + 1
populacja_pom = Algorytm_genetyczny(populacja, budzet, gen, klient)
populacja = populacja_pom
start = (0, 0, 0) # Początkowy stan
cel = (0, 0) # Docelowe współrzędne
# --------------Inicjacja obiektów
kelner = Kelner(pozycja_startowa, pozycja_startowa)
# -----------wspolrzedne stolikow
coords = ["8 4", "16 4", "0 7", "23 7", "12 9", "8 10", "16 10", "4 12", "12 12", "20 12"]
# -----------wspolrzedne sliskich podlog
coords2 = ["0 2", "0 3", "0 4", "0 5", "4 8", "4 9", "12 2", "12 3", "15 8", "16 8", "19 4", "20 4", "21 4"]
# -----------wspolrzedne dywanow
coords3 = ["6 0", "6 1", "2 2", "3 2", "4 2", "5 2", "1 5", "6 2", "8 6", "8 7", "20 2", "20 3", "19 9", "20 9", "21 9"]
# Tworzenie listy stolikow i przeszkod
stoliki = []
przeszkody = []
if not losuj_uklad:
for coord in coords:
x, y = map(int, coord.split())
stoliki.append(Stolik(x, y))
for coord in coords2:
x, y = map(int, coord.split())
przeszkody.append(Przeszkoda(x, y, "sliska podloga"))
for coord in coords3:
x, y = map(int, coord.split())
przeszkody.append(Przeszkoda(x, y, "dywan"))
else:
juzbyly = []
for j in range(1, rows):
for i in range(columns):
if (random.randrange(7) == 0) and ((i, j - 1) not in juzbyly) and (
((i - 1, j - 1) not in juzbyly) or ((i + 1, j - 1) not in juzbyly)):
stoliki.append(Stolik(i, j))
juzbyly.append((i, j))
elif random.randrange(9) == 0:
przeszkody.append(Przeszkoda(i, j, "sliska podloga"))
elif random.randrange(12) == 0:
przeszkody.append(Przeszkoda(i, j, "dywan"))
# stoliki = []
# for i in range(rows)
pygame.init()
pygame.display.set_caption("Automatyczny kelner")
# ----------------wymiary okna
width = columns * blockSize
height = rows * blockSize
screen = pygame.display.set_mode((width, height))
kelnerImg = pygame.image.load("kelner.png")
kelnerImg = pygame.transform.scale(kelnerImg, (blockSize, blockSize))
stolikImg = pygame.image.load("stolik.png")
stolikImg = pygame.transform.scale(stolikImg, (blockSize, blockSize))
menuImg = pygame.image.load("menu.png")
menuImg = pygame.transform.scale(menuImg, (blockSize / 2, blockSize / 2))
kitchenImg = pygame.image.load("kitchen.png")
kitchenImg = pygame.transform.scale(kitchenImg, (blockSize * 2, blockSize * 2))
sliskaPodlogaImg = pygame.image.load("plama.png")
sliskaPodlogaImg = pygame.transform.scale(sliskaPodlogaImg, (blockSize, blockSize))
dywanImg = pygame.image.load("dywan.png")
dywanImg = pygame.transform.scale(dywanImg, (blockSize, blockSize))
def kuchnia(x, y):
screen.blit(kitchenImg, (x * blockSize, y * blockSize))
def menu(x, y):
screen.blit(menuImg, (x * blockSize, y * blockSize))
def wypiszOkno():
screen.fill((0, 0, 0))
for x in range(0, width, blockSize):
for y in range(0, height, blockSize):
rect = pygame.Rect(x, y, blockSize, blockSize)
pygame.draw.rect(screen, (200, 200, 200), rect, 1) # -------------Wypisz kratę -TA
# pygame.draw.rect(screen, (0, 0, 0), rect, 1) #-------------Wypisz kratę -TA
def czyZadowolony():
data = pd.read_csv('zbior_uczacy.csv')
frames = []
frames.append(data)
ques = ["Czy klient sie usmiecha? ", "Czy zostawil napiwek? ", "Czy zachowywal sie grzecznie? ",
"Czy zjadl cala porcje? ", "Czy zlozyl dodatkowe zamowienia? ",
"Czy wyrazil zainteresowanie karta stalego klienta? ", "Czy zarezerwowal stolik na przyszlosc? ",
"Czy zabral wizytowke? "]
k = GenerujDane(ques)
atrybuty = []
for column in data.columns[:-1]:
atrybuty.append(column)
klient = {}
i = 0
for atr in atrybuty:
klient[atr] = k[i]
i = i + 1
while len(frames) > 0:
data = frames.pop()
id3(data, "klient", klient)
run = True
# czcionka = pygame.font.SysFont('Arial',50)
licznik = 0
ruchy = []
cel2 = []
klient = {}
frames = []
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.tree import plot_tree, DecisionTreeClassifier
data = pd.read_csv('zbior_uczacy.csv')
data.head()
#print(heart_data)
data_x = data.drop('Zadowolony', axis=1)
data_y = data['Zadowolony']
data_x_encoded = pd.get_dummies(data_x, drop_first = True)
data_x_encoded.head()
best_acc = 0
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
X_train, X_test, y_train, y_test = train_test_split(data_x_encoded, data_y, test_size=0.3)
dtree = DecisionTreeClassifier(max_depth=100)
dtree.fit(X_train, y_train)
fig = plt.figure(figsize=((25,20)))
plot_tree(dtree,
feature_names=data_x_encoded.columns,
class_names=['niezadowolony', 'zadowolony'],
impurity=False,
proportion=False,
filled=True)
fig.savefig('tree.png')
while run:
cel2 = list(cel)
# print(f"{kelner.stanPrzestrzeni}, {cel2}, {kelner.indexRuchu} {kelner.stan}")
wypiszOkno()
kuchnia(kuchnia_xy, kuchnia_xy)
for stolik in stoliki:
stolik.wklej()
for przeszkoda in przeszkody:
przeszkoda.wklej()
kelner.wklej()
if kelner.stan == "wraca":
menu(kelner.x, kelner.y)
licznik += 1
# ------------weź zamowienie
for stolik in stoliki:
if stolik.zamowione == True:
menu(stolik.x, stolik.y)
if kelner.stan == "stoi":
kelner.stolik_docelowy = stolik
kelner.cel_x, kelner.cel_y = kelner.stolik_docelowy.x, kelner.stolik_docelowy.y - 1
cel = (kelner.cel_x, kelner.cel_y)
print("Szukam ścieżki do stolika...")
ruchy = a_star(tuple(kelner.stanPrzestrzeni), cel, stoliki, przeszkody)
kelner.stan = "odbiera"
if ruchy:
print("Znaleziono ścieżkę ruchów: ", ruchy)
czyZadowolony()
najlepszeDopasowanie()
else:
print("Nie znaleziono ścieżki do celu.")
# ----------Losuje stoliki, które dokonają zamówienia
if kelner.stan == "stoi":
for stolik in stoliki:
if stolik.zamowione == True:
break
for i in range(len(stoliki)):
if random.randrange(2) == 1:
stoliki[i].zamowione = True
# print(kelner.stan)--------------------------Wypisuje stan kelnera
# print(f"{kelner.x} {kelner.y}")-------------Wypisuje wspolrzedne kelnera
# ----------------Zmiana pozycji kelnera
if kelner.chodzi == True and licznik % (101 - kelner.speed) == 0 and kelner.stanPrzestrzeni[
:2] != cel2: # ograniczenie prędkości
kelner.wykonajAkcje(ruchy)
if kelner.stanPrzestrzeni[:2] == cel2:
if kelner.stan == "odbiera" and kelner.x == kelner.stolik_docelowy.x and kelner.y == kelner.stolik_docelowy.y - 1:
kelner.stolik_docelowy.zamowione = False
kelner.idz_do_kuchni()
cel = (kelner.cel_x, kelner.cel_y)
print("Szukam ścieżki do kuchni...")
ruchy = a_star(tuple(kelner.stanPrzestrzeni), cel, stoliki, przeszkody)
if ruchy:
print("Znaleziono ścieżkę ruchów: ", ruchy)
else:
print("Nie znaleziono ścieżki do celu.")
elif kelner.stan == "wraca" and kelner.x == kuchnia_xy and kelner.y == kuchnia_xy:
kelner.stan = "stoi"
time.sleep(0.001)
key = pygame.key.get_pressed()
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
pygame.quit()