feat added moving client

This commit is contained in:
MlodyJacky 2024-05-26 11:50:42 +02:00
parent 997564080e
commit 7aeea71cfc
3 changed files with 235 additions and 19 deletions

62
app.py
View File

@ -10,12 +10,24 @@ from collections import deque
import threading import threading
import time import time
import random import random
from classes.data.klient import Klient
pygame.init() pygame.init()
window = pygame.display.set_mode((prefs.WIDTH, prefs.HEIGHT)) window = pygame.display.set_mode((prefs.WIDTH, prefs.HEIGHT))
pygame.display.set_caption("Game Window") pygame.display.set_caption("Game Window")
table_coords = [(4, 4), (4, prefs.GRID_SIZE-5), (prefs.GRID_SIZE-5, 4), (prefs.GRID_SIZE-5, prefs.GRID_SIZE-5)] table_coords = [(4, 4), (4, prefs.GRID_SIZE-5), (prefs.GRID_SIZE-5, 4), (prefs.GRID_SIZE-5, prefs.GRID_SIZE-5)]
chosen_coords = random.choice(table_coords)
chosen_index = random.randint(0, len(table_coords)-1)
chosen_coords = table_coords[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(): def initBoard():
wall_probability = 0.001 wall_probability = 0.001
global cells global cells
@ -36,19 +48,9 @@ def initBoard():
if random.random() < wall_probability: if random.random() < wall_probability:
cell.prepareTexture("sprites/wall.png") cell.prepareTexture("sprites/wall.png")
cell.blocking_movement = True cell.blocking_movement = True
# Wybierz kolor dla płytki na podstawie jej położenia
row.append(cell) row.append(cell)
cells.append(row) cells.append(row)
# Test
# Na potrzeby prezentacji tworzę sobie prostokątne ściany na które nie da się wejść
# x1 = 3
# y1 = 6
# for i in range(x1, x1+4):
# for j in range(y1, y1+2):
# cells[i][j].prepareTexture("sprites/wall.png")
# cells[i][j].blocking_movement = True
for i in range(prefs.GRID_SIZE): for i in range(prefs.GRID_SIZE):
for j 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): if i == 0 or j==0 or j==prefs.GRID_SIZE-1 or (i == prefs.GRID_SIZE-1 and j != 17):
@ -92,8 +94,10 @@ def draw_grid(window, cells, agent):
initBoard() initBoard()
agent = Agent(prefs.SPAWN_POINT[0], prefs.SPAWN_POINT[1], cells) agent = Agent(prefs.SPAWN_POINT[0], prefs.SPAWN_POINT[1], cells)
klient = Klient(prefs.GRID_SIZE-1, 17,cells)
target_x, target_y = klientx_target-1, klienty_target
target_x, target_y = 18, 18
def watekDlaSciezkiAgenta(): def watekDlaSciezkiAgenta():
time.sleep(3) time.sleep(3)
@ -112,6 +116,41 @@ def watekDlaSciezkiAgenta():
agent.moveto(x, y) agent.moveto(x, y)
time.sleep(1) time.sleep(1)
def watekDlaSciezkiKlienta():
time.sleep(3)
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(1)
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 running = True
while running: while running:
for event in pygame.event.get(): for event in pygame.event.get():
@ -156,6 +195,7 @@ while running:
window.fill((255, 0, 0)) window.fill((255, 0, 0))
draw_grid(window, cells, agent) draw_grid(window, cells, agent)
agent.update(window) agent.update(window)
klient.update(window)
pygame.display.update() pygame.display.update()
time.sleep(0.1) time.sleep(0.1)

View File

@ -1,16 +1,103 @@
import pygame import pygame
from rachunek import Rachunek from classes.cell import Cell
import prefs
import random import random
import heapq
from collections import deque
class Klient: class Klient:
def __init__(self,imie,nazwisko,wiek,ulubiony_posilek=None, restrykcje_dietowe=None): def __init__(self,x,y,cells):
self.imie = imie self.sprite = pygame.image.load("sprites/klient.png").convert_alpha()
self.nazwisko = nazwisko self.sprite = pygame.transform.scale(self.sprite, (prefs.CELL_SIZE, prefs.CELL_SIZE))
self.wiek = wiek self.current_cell = cells[x][y]
self.current_x = x
self.current_y = y
# self.imie = imie
# self.nazwisko = nazwisko
# self.wiek = wiek
przyStoliku = False
self.stolik = None self.stolik = None
self.rachunek = Rachunek(random.randint(1,1000)) # self.rachunek = Rachunek(random.randint(1,1000))
self.ulubiony_posilek = ulubiony_posilek # self.ulubiony_posilek = ulubiony_posilek
self.restrykcje_dietowe = restrykcje_dietowe # self.restrykcje_dietowe = restrykcje_dietowe
self.cells = cells
self.X = x
self.Y = y
self.last_move_time = pygame.time.get_ticks()
self.last_interact_time = pygame.time.get_ticks()
self.last_update_time = pygame.time.get_ticks()
self.direction = 0
self.directionPOM = 0
self.xPOM = x
self.yPOM = y
self.g_scores = {}
self.textures = [
pygame.image.load("sprites/klient.png").convert_alpha(),
pygame.image.load("sprites/klient.png").convert_alpha(),
pygame.image.load("sprites/klient.png").convert_alpha(),
pygame.image.load("sprites/klient.png").convert_alpha()
]
def update(self, surface):
surface.blit(self.sprite, (self.current_cell.X * prefs.CELL_SIZE,
self.current_cell.Y * prefs.CELL_SIZE))
def moveto(self,x,y):
if not self.cells[x][y].blocking_movement:
self.current_cell = self.cells[x][y]
self.moved=True
self.last_move_time=pygame.time.get_ticks()
print("Agent moved to x,y: ",x,y)
else:
print("Agent cannot move to this direction")
def move_direction(self):
if self.direction == 0 and pygame.time.get_ticks()-self.last_move_time > 125 and self.current_cell.Y < prefs.GRID_SIZE-1 and not self.cells[self.current_cell.X][self.current_cell.Y+1].blocking_movement:
self.current_cell = self.cells[self.current_cell.X][self.current_cell.Y+1]
self.moved=True
self.last_move_time=pygame.time.get_ticks()
if self.direction == 1 and pygame.time.get_ticks()-self.last_move_time > 125 and self.current_cell.X > 0 and not self.cells[self.current_cell.X-1][self.current_cell.Y].blocking_movement:
self.current_cell = self.cells[self.current_cell.X-1][self.current_cell.Y]
self.moved=True
self.last_move_time=pygame.time.get_ticks()
if self.direction == 2 and pygame.time.get_ticks()-self.last_move_time > 125 and self.current_cell.Y > 0 and not self.cells[self.current_cell.X][self.current_cell.Y-1].blocking_movement:
self.current_cell = self.cells[self.current_cell.X][self.current_cell.Y-1]
self.moved=True
self.last_move_time=pygame.time.get_ticks()
if self.direction == 3 and pygame.time.get_ticks()-self.last_move_time > 125 and self.current_cell.X < prefs.GRID_SIZE-1 and not self.cells[self.current_cell.X+1][self.current_cell.Y].blocking_movement:
self.current_cell = self.cells[self.current_cell.X+1][self.current_cell.Y]
self.moved=True
self.last_move_time=pygame.time.get_ticks()
def rotate_left(self):
if pygame.time.get_ticks()-self.last_move_time > 125:
self.direction +=1
if self.direction==4:
self.direction=0
self.sprite = self.textures[self.direction]
self.sprite = pygame.transform.scale(self.sprite, (prefs.CELL_SIZE, prefs.CELL_SIZE))
self.last_move_time=pygame.time.get_ticks()
print(self.direction)
def rotate_right(self):
if pygame.time.get_ticks()-self.last_move_time > 125:
self.direction-=1
if self.direction==-1:
self.direction=3
self.sprite = self.textures[self.direction]
self.sprite = pygame.transform.scale(self.sprite, (prefs.CELL_SIZE, prefs.CELL_SIZE))
self.last_move_time=pygame.time.get_ticks()
print(self.direction)
def zloz_zamowienie(self,zamowienie,stolik): def zloz_zamowienie(self,zamowienie,stolik):
if self.stolik is None: if self.stolik is None:
self.stolik = stolik self.stolik = stolik
@ -23,3 +110,92 @@ class Klient:
def __str__(self): def __str__(self):
return f"Klient: {self.imie} {self.nazwisko} {self.wiek}, ulubione Danie: {self.ulubiony_posilek}, restrykcje diet: {self.restrykcje_dietowe}" return f"Klient: {self.imie} {self.nazwisko} {self.wiek}, ulubione Danie: {self.ulubiony_posilek}, restrykcje diet: {self.restrykcje_dietowe}"
def get_possible_moves(self):
possible_moves = []
if self.directionPOM == 0: # Patrzy w dół
possible_moves.append((0, 'left'))
possible_moves.append((0, 'right'))
if self.yPOM < prefs.GRID_SIZE - 1 and not self.cells[self.xPOM][self.yPOM + 1].blocking_movement:
possible_moves.append((self.directionPOM, 'forward'))
elif self.directionPOM == 1: # Patrzy w lewo
possible_moves.append((1, 'left'))
possible_moves.append((1, 'right'))
if self.xPOM > 0 and not self.cells[self.xPOM - 1][self.yPOM].blocking_movement:
possible_moves.append((self.directionPOM, 'forward'))
elif self.directionPOM == 2: # Patrzy w górę
possible_moves.append((2, 'left'))
possible_moves.append((2, 'right'))
if self.yPOM > 0 and not self.cells[self.xPOM][self.yPOM - 1].blocking_movement:
possible_moves.append((self.directionPOM, 'forward'))
elif self.directionPOM == 3: # Patrzy w prawo
possible_moves.append((3, 'left'))
possible_moves.append((3, 'right'))
if self.xPOM < prefs.GRID_SIZE - 1 and not self.cells[self.xPOM + 1][self.yPOM].blocking_movement:
possible_moves.append((self.directionPOM, 'forward'))
return possible_moves
def calculate_priority(self, el):
return el[0]
def bfs2(self, target_x, target_y):
visited = set()
self.directionPOM = self.direction
start_state = (self.current_cell.X, self.current_cell.Y, self.directionPOM)
#print(start_state)
queue = []
heapq.heappush(queue, (0,(start_state, [], 0)))
while queue:
_, que = heapq.heappop(queue)
state, actions, gscore = que
self.xPOM, self.yPOM, self.directionPOM = state
if self.xPOM == target_x and self.yPOM == target_y:
return actions
if (self.xPOM, self.yPOM, self.directionPOM) in visited:
continue
visited.add((self.xPOM, self.yPOM, self.directionPOM))
possible_moves = self.get_possible_moves()
for new_direction, action in possible_moves:
new_x, new_y = self.xPOM, self.yPOM
new_actions = actions + [action]
if action == 'left':
new_direction = (self.directionPOM + 1) % 4
elif action == 'right':
new_direction = (self.directionPOM - 1) % 4
else: # forward
if self.directionPOM == 0:
new_y += 1
elif self.directionPOM == 1:
new_x -= 1
elif self.directionPOM == 2:
new_y -= 1
else: # direction == 3
new_x += 1
if 0 <= new_x < prefs.GRID_SIZE and 0 <= new_y < prefs.GRID_SIZE \
and not self.cells[new_x][new_y].blocking_movement:
new_state = (new_x, new_y, new_direction)
if (action == 'left' or action == 'right') :
gscore = gscore + 1
else:
gscore = gscore + self.cells[new_x][new_y].waga
f_score = gscore + self.heuristic((new_x,new_y), (target_x,target_y))
heapq.heappush(queue, (f_score, (new_state, new_actions, gscore)))
return []
def heuristic(self, current, target):
# Manhattan distance heuristic
dx = abs(current[0] - target[0])
dy = abs(current[1] - target[1])
return dx + dy

BIN
sprites/klient.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 649 B