240 lines
8.2 KiB
Python
240 lines
8.2 KiB
Python
import pygame
|
|
import prefs
|
|
from classes.beerKeg import BeerKeg
|
|
from classes.coffeMachine import CoffeMachine
|
|
from classes.table import Table
|
|
from pygame.locals import K_w, K_s, K_a, K_d, K_q, K_e, K_r, K_b,K_g
|
|
from classes.cell import Cell
|
|
from classes.agent import Agent
|
|
from collections import deque
|
|
import threading
|
|
import time
|
|
import random
|
|
from classes.data.klient import Klient
|
|
from classes.data.klient import KlientCechy
|
|
import xml.etree.ElementTree as ET
|
|
from decisiontree import predict_client
|
|
from classes.Jimmy_Neuron.predict_image import predict_image
|
|
|
|
pygame.init()
|
|
window = pygame.display.set_mode((prefs.WIDTH, prefs.HEIGHT))
|
|
pygame.display.set_caption("Game Window")
|
|
table_coords = [(12, 2), (16, 11), (4, 4), (15, 4), (2, 9), (15, 15), (12, 12), (7, 8), (4, 15)]
|
|
table_ordered = [(4, 4), (12, 2), (15, 4), (16, 11), (15, 15), (12, 12), (7, 8), (4, 15), (2, 9)]
|
|
from classes.data.data_initializer import clients
|
|
|
|
orders = []
|
|
chosen_index = 0
|
|
chosen_coords = table_ordered[chosen_index]
|
|
klientx_target = chosen_coords[0] + 1
|
|
klienty_target = chosen_coords[1] + 1
|
|
# klientx_target = 16
|
|
# klienty_target = 16
|
|
|
|
print("klientx_target:", klientx_target)
|
|
print("klienty_target:", klienty_target)
|
|
|
|
def initBoard():
|
|
wall_probability = 0.001
|
|
global cells
|
|
cells = []
|
|
for i in range(prefs.GRID_SIZE):
|
|
row = []
|
|
for j in range(prefs.GRID_SIZE):
|
|
waga = random.choices([1, 4, 5], weights=[0.7, 0.1, 0.1], k=1)[0]
|
|
cell = Cell(i, j, waga)
|
|
|
|
if (i, j) not in table_coords:
|
|
if waga == 5:
|
|
cell.prepareTexture("sprites/plama.png")
|
|
|
|
if waga == 4:
|
|
cell.prepareTexture("sprites/dywan.png")
|
|
|
|
if random.random() < wall_probability:
|
|
cell.prepareTexture("sprites/wall.png")
|
|
cell.blocking_movement = True
|
|
row.append(cell)
|
|
cells.append(row)
|
|
|
|
for i in range(prefs.GRID_SIZE):
|
|
for j in range(prefs.GRID_SIZE):
|
|
if i == 0 or j==0 or j==prefs.GRID_SIZE-1 or (i == prefs.GRID_SIZE-1 and j != 17):
|
|
cells[i][j].prepareTexture("sprites/wall.png")
|
|
cells[i][j].blocking_movement = True
|
|
|
|
cells[6][6].interactableItem = BeerKeg(cells[6][6], "Beer Keg")
|
|
cells[4][10].interactableItem = CoffeMachine(cells[4][10], "Coffe Machine")
|
|
|
|
for cell in table_ordered:
|
|
cells[cell[0]][cell[1]].interactableItem = Table(cells[cell[0]][cell[1]], "Table")
|
|
|
|
# cells[9][9].waga = 2
|
|
# cells[9][8].waga = 10
|
|
# cells[8][8].waga = 10
|
|
# cells[prefs.SPAWN_POINT[0]+1][prefs.SPAWN_POINT[1]].waga = 100
|
|
# cells[prefs.SPAWN_POINT[0]][prefs.SPAWN_POINT[1]-1].waga = 100
|
|
|
|
# cells[9][7].waga = 2
|
|
# cells[10][6].waga = 2
|
|
# cells[7][7].waga = 2
|
|
|
|
def draw_grid(window, cells, agent):
|
|
for i in range(prefs.GRID_SIZE):
|
|
for j in range(prefs.GRID_SIZE):
|
|
cells[i][j].update(window)
|
|
|
|
if(cells[i][j].interactableItem):
|
|
cells[i][j].interactableItem.update(window)
|
|
if(not cells[i][j].blocking_movement):
|
|
cells[i][j].blit_text(cells[i][j].waga, i*50+6, j*52+6, 12,window)
|
|
font = pygame.font.SysFont('Comic Sans MS', 30)
|
|
scoreText = font.render("Score: {}".format(str(round(agent.score,2))), 1, (0, 0, 0))
|
|
multiplierText = font.render("Multiplier: {}".format(str(round(agent.multiplier,2))), 1, (0, 0, 0))
|
|
|
|
window.blit(scoreText, (0, 0))
|
|
window.blit(multiplierText, (0, 50))
|
|
|
|
initBoard()
|
|
agent = Agent(prefs.SPAWN_POINT[0], prefs.SPAWN_POINT[1], cells)
|
|
klients = [ Klient(table_ordered[i][0]+ 1, table_ordered[i][1]+ 1, cells) for i in range(len(table_ordered)) ]
|
|
target_x, target_y = klientx_target-1, klienty_target
|
|
|
|
def watekDlaSciezkiAgenta():
|
|
assigned = False
|
|
global chosen_index
|
|
|
|
time.sleep(1.5)
|
|
while True:
|
|
if len(path) > 0:
|
|
print(path)
|
|
element = path.pop(0)
|
|
if element == "left":
|
|
agent.rotate_left()
|
|
if element == "right":
|
|
agent.rotate_right()
|
|
if element == "forward":
|
|
agent.move_direction()
|
|
elif isinstance(element, tuple): # Check if it's a tuple indicating movement coordinates
|
|
x, y = element
|
|
agent.moveto(x, y)
|
|
|
|
|
|
if not assigned:
|
|
neighbors = agent.get_neighbors(agent.current_cell, agent.cells)
|
|
for neighbor in neighbors:
|
|
if neighbor == klients[chosen_index].current_cell and len(path) == 0:
|
|
if not assigned:
|
|
random_client_data = random.choice(clients)
|
|
glasses = predict_image(random_client_data.zdjecie)
|
|
print(random_client_data.zdjecie)
|
|
prediction = predict_client(random_client_data, glasses)
|
|
print("\nClient data:")
|
|
print(random_client_data)
|
|
print("Prediction (Glasses):", glasses)
|
|
print("Prediction (Adult):", prediction)
|
|
print("Prediction: ", prediction)
|
|
orders.append(prediction)
|
|
assigned = True
|
|
|
|
|
|
if assigned:
|
|
if(chosen_index < len(klients) - 1):
|
|
chosen_index += 1
|
|
target_x, target_y = table_ordered[chosen_index][0], table_ordered[chosen_index][1]+1
|
|
move_back = agent.bfs2(target_x,target_y)
|
|
if move_back:
|
|
path.extend(move_back)
|
|
assigned = False
|
|
else:
|
|
print("Orders: ", orders)
|
|
return
|
|
time.sleep(0.3)
|
|
|
|
# def watekDlaSciezkiKlienta():
|
|
# time.sleep(1)
|
|
# while True:
|
|
# if len(path2) > 0:
|
|
# element2 = path2.pop(0)
|
|
# print(element2)
|
|
# if element2 == "left":
|
|
# klient.rotate_left()
|
|
# if element2 == "right":
|
|
# klient.rotate_right()
|
|
# if element2 == "forward":
|
|
# klient.move_direction()
|
|
# elif isinstance(element2, tuple): # Check if it's a tuple indicating movement coordinates
|
|
# x, y = element2
|
|
# klient.moveto(x, y)
|
|
|
|
# if klient.current_cell == cells[klientx_target][klienty_target]:
|
|
# klient.przyStoliku = True
|
|
# klient.stolik = klient.current_cell
|
|
|
|
# time.sleep(0.5)
|
|
|
|
|
|
# path2 = klient.bfs2(klientx_target, klienty_target)
|
|
# print("Najkrótsza ścieżka:", path2)
|
|
# watek = threading.Thread(target=watekDlaSciezkiKlienta)
|
|
# watek.daemon = True
|
|
# watek.start()
|
|
|
|
path = agent.bfs2(target_x, target_y)
|
|
print("Najkrótsza ścieżka:", path)
|
|
watek = threading.Thread(target=watekDlaSciezkiAgenta)
|
|
watek.daemon = True
|
|
watek.start()
|
|
|
|
|
|
running = True
|
|
while running:
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
running = False
|
|
|
|
keys = pygame.key.get_pressed()
|
|
|
|
if keys[K_w] and not agent.moved:
|
|
agent.move_up()
|
|
if keys[K_s] and not agent.moved:
|
|
agent.move_down()
|
|
if keys[K_a] and not agent.moved:
|
|
agent.move_left()
|
|
if keys[K_d] and not agent.moved:
|
|
agent.move_right()
|
|
if not any([keys[K_w], keys[K_s], keys[K_a], keys[K_d]]):
|
|
agent.moved = False
|
|
|
|
if keys[K_q]:
|
|
agent.rotate_left()
|
|
if keys[K_e]:
|
|
agent.rotate_right()
|
|
|
|
if keys[K_r]:
|
|
agent.move_direction()
|
|
|
|
if keys[K_b]:
|
|
path = agent.bfs2(target_x, target_y)
|
|
print("Najkrótsza ścieżka:", path)
|
|
watek = threading.Thread(target=watekDlaSciezkiAgenta)
|
|
watek.daemon = True
|
|
watek.start()
|
|
|
|
|
|
|
|
if pygame.key.get_pressed()[pygame.K_e]:
|
|
if agent.current_cell.interactableItem and pygame.time.get_ticks() - agent.last_interact_time > 500:
|
|
agent.last_interact_time = pygame.time.get_ticks()
|
|
agent.current_cell.interactableItem.interact(agent)
|
|
|
|
window.fill((255, 0, 0))
|
|
draw_grid(window, cells, agent)
|
|
agent.update(window)
|
|
for klient in klients:
|
|
klient.update(window)
|
|
pygame.display.update()
|
|
time.sleep(0.05)
|
|
|
|
pygame.quit()
|