220 lines
7.3 KiB
Python
220 lines
7.3 KiB
Python
import pygame
|
|
from config import *
|
|
from agent import *
|
|
from map_add_ons import *
|
|
from mobs import *
|
|
#from unknown_mob import * #unknown mob
|
|
from bfs import *
|
|
from heapq import *
|
|
|
|
class Game:
|
|
|
|
def __init__(self):
|
|
pygame.init()
|
|
self.state =[-1,-1,-1,-1,-1,-1,-1,-1]
|
|
self.SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
|
|
self.running = True
|
|
self.clock = pygame.time.Clock()
|
|
|
|
self.BACKGROUND_IMG= pygame.image.load("./zdjecia/podloze.jpg")
|
|
self.BACKGROUND = pygame.transform.scale(self.BACKGROUND_IMG,(64,64))
|
|
|
|
self.LVL_ICON_PNG = pygame.image.load("./zdjecia/lvl_icon.png")
|
|
self.LVL_ICON = pygame.transform.scale(self.LVL_ICON_PNG,(24,24))
|
|
|
|
pygame.display.set_caption('Gra-SI')
|
|
|
|
self.bfs = Bfs(self)
|
|
|
|
def new(self): # tworzy się nowa sesja grania
|
|
self.all_sprites = pygame.sprite.LayeredUpdates()
|
|
|
|
self.rock_sprites = pygame.sprite.LayeredUpdates()
|
|
self.grass_sprites = pygame.sprite.LayeredUpdates()
|
|
self.archer_orks = pygame.sprite.LayeredUpdates()
|
|
self.infantry_orks = pygame.sprite.LayeredUpdates()
|
|
#self.infantry_orks2 = pygame.sprite.LayeredUpdates()
|
|
self.sauronL = pygame.sprite.LayeredUpdates()
|
|
self.flowers = pygame.sprite.LayeredUpdates()
|
|
self.little_rock_sprites = pygame.sprite.LayeredUpdates()
|
|
|
|
#self.unknown_mobs = pygame.sprite.LayeredUpdates() #unknown mob
|
|
self.agent = Agent(self,1,1)
|
|
self.archer_ork = Archer_ork(self,10,10)
|
|
self.bfs.enemy_cells.append(self.bfs.get_cell_number(self.archer_ork.x,self.archer_ork.y))
|
|
self.infantry_ork = Infantry_ork(self,10,4)
|
|
self.bfs.enemy_cells.append(self.bfs.get_cell_number(self.infantry_ork.x,self.infantry_ork.y))
|
|
#self.infantry_ork2 = Infantry_ork2(self,6,3)
|
|
#self.bfs.enemy_cells.append(self.bfs.get_cell_number(self.infantry_ork2.x,self.infantry_ork2.y))
|
|
self.sauron = Sauron(self, 1, 10)
|
|
self.bfs.enemy_cells.append(self.bfs.get_cell_number(self.sauron.x,self.sauron.y))
|
|
self.flower = Health_flower(self, 8,2)
|
|
#self.unknown_mob = Unknown_mob(self,8,8) #unknown mob
|
|
self.grass = Grass(self,0,2)
|
|
self.grass = Grass(self,1,2)
|
|
self.grass = Grass(self,0,3)
|
|
self.grass = Grass(self,1,3)
|
|
self.grass = Grass(self,0,4)
|
|
self.grass = Grass(self,1,4)
|
|
cost_cell_1000=[13,26,27,40]
|
|
for y in range(5):
|
|
self.rock = Rocks(self,3,y)
|
|
self.bfs.wall_cells.append(self.bfs.get_cell_number(self.rock.x,self.rock.y))
|
|
'''
|
|
for i in range(10):
|
|
x = random.randint(0,12)
|
|
y = random.randint(0,11)
|
|
self.grass = Grass(self,x,y)
|
|
self.grass_cells.append(self.bfs.get_cell_number(self.grass.x,self.grass.y))
|
|
|
|
for y in range(5,8):
|
|
self.little_rocks = Little_Rocks(self,4,y)
|
|
'''
|
|
|
|
|
|
|
|
|
|
def update(self):
|
|
self.all_sprites.update()
|
|
|
|
|
|
def events(self):
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
self.running = False
|
|
pygame.quit()
|
|
if event.type == pygame.MOUSEBUTTONDOWN:
|
|
mouse_presses = pygame.mouse.get_pressed()
|
|
if mouse_presses[0]:
|
|
self.bfs.bfs()
|
|
|
|
def map(self): # tworzenie mapy
|
|
self.clock.tick(FRAMERATE)
|
|
for x in range(0, WIDTH, TILE_SIZE):
|
|
for y in range(0, 768, TILE_SIZE):
|
|
self.SCREEN.blit(self.BACKGROUND,(x,y))
|
|
self.rect = pygame.Rect(x, y, TILE_SIZE, TILE_SIZE)
|
|
pygame.draw.rect(self.SCREEN, BLACK, self.rect, 1)
|
|
self.flowers.draw(self.SCREEN)
|
|
self.all_sprites.draw(self.SCREEN)
|
|
self.rock_sprites.draw(self.SCREEN)
|
|
self.grass_sprites.draw(self.SCREEN)
|
|
self.SCREEN.blit(self.LVL_ICON, (340 ,780))
|
|
pygame.display.update()
|
|
|
|
def main(self):
|
|
self.events()
|
|
self.update()
|
|
self.map()
|
|
|
|
grass_cells = []
|
|
|
|
|
|
cols, rows = 13,12
|
|
def get_circle(x,y):
|
|
return (x * TILE_SIZE + TILE_SIZE//2, y* TILE_SIZE + TILE_SIZE//2), TILE_SIZE//4
|
|
def get_rect(x,y):
|
|
return x*TILE_SIZE +1, y* TILE_SIZE +1, TILE_SIZE -2, TILE_SIZE -2
|
|
'''
|
|
def get_next_nodes(x,y):
|
|
check_next_node = lambda x, y:True if 0<= x < cols and 0<=y < rows else False
|
|
ways =[-1,0],[0,-1],[1,0],[0,1]
|
|
return [(grid[y + dy][x + dx], (x + dx, y + dy)) for dx, dy in ways if check_next_node(x + dx, y + dy)]
|
|
'''
|
|
def get_neighbours(x, y):
|
|
check_neighbour = lambda x, y: True if 0 <= x < cols and 0 <= y < rows else False
|
|
ways = [-1, 0], [0, -1], [1, 0], [0, 1]
|
|
return [(grid[y + dy][x + dx], (x + dx, y + dy)) for dx, dy in ways if check_neighbour(x + dx, y + dy)]
|
|
def heuristic(a, b):
|
|
return abs(a[0] - b[0]) + abs(a[1] - b[1])
|
|
def dijkstra(start, goal, graph):
|
|
queue = []
|
|
heappush(queue, (0, start))
|
|
cost_visited = {start: 0}
|
|
visited = {start: None}
|
|
|
|
while queue:
|
|
cur_cost, cur_node = heappop(queue)
|
|
if cur_node == goal:
|
|
break
|
|
|
|
neighbours = graph[cur_node]
|
|
for neighbour in neighbours:
|
|
neigh_cost, neigh_node = neighbour
|
|
new_cost = cost_visited[cur_node] + neigh_cost
|
|
|
|
if neigh_node not in cost_visited or new_cost < cost_visited[neigh_node]:
|
|
priority = new_cost + heuristic(neigh_node, goal)
|
|
heappush(queue, (priority, neigh_node))
|
|
cost_visited[neigh_node] = new_cost
|
|
visited[neigh_node] = cur_node
|
|
return visited
|
|
grid =['2229222222222',
|
|
'2229222222222',
|
|
'9929222222222',
|
|
'9929222222222',
|
|
'9929222222222',
|
|
'2222222222222',
|
|
'2222222222222',
|
|
'2222222222222',
|
|
'2222222222222',
|
|
'2222222222222',
|
|
'2222222222222',
|
|
'2222222222222'
|
|
]
|
|
grid = [[int(char) for char in string ] for string in grid]
|
|
|
|
|
|
graph ={}
|
|
for y, row in enumerate(grid):
|
|
for x, col in enumerate(row):
|
|
graph[(x, y)] = graph.get((x, y), []) + get_neighbours(x, y)
|
|
print("graph 2 0",graph[(2,0)])
|
|
|
|
start = (1,1)
|
|
goal =(0,5)
|
|
queue =[]
|
|
heappush(queue, (0,start))
|
|
cost_visited = {start:0}
|
|
visited = {start: None}
|
|
goall=1
|
|
while goall==1:
|
|
if queue:
|
|
visited=dijkstra(start,goal,graph)
|
|
goall=0
|
|
|
|
path=[]
|
|
path_head, path_segment = goal, goal
|
|
while path_segment:
|
|
print("path_segment: ",path_segment)
|
|
|
|
path_segment =visited[path_segment]
|
|
path.append(path_segment)
|
|
print("path_head",path_head)
|
|
path.pop(len(path)-1)
|
|
path.reverse()
|
|
path_true=[]
|
|
bfss =Bfs(Game)
|
|
|
|
|
|
for i in path:
|
|
z=str(i)
|
|
print("Z:",z)
|
|
x=z[1]
|
|
y=z[4]
|
|
x=int(x)*64
|
|
y=int(y)*64
|
|
a=bfss.get_cell_number(x,y)
|
|
path_true.append(a)
|
|
print("path:",path)
|
|
print("path_true:",path_true)
|
|
#bfss.move_agent(path_true)
|
|
|
|
|
|
|
|
|
|
g = Game()
|
|
g.new()
|
|
while g.running:
|
|
g.main()
|