forth attempt's first commit
This commit is contained in:
emil
@@ -1,301 +1,141 @@
|
||||
import pygame as pg
|
||||
import time
|
||||
MAP_SIZE = 9
|
||||
start = (0, 0)
|
||||
neo = start
|
||||
observer = neo
|
||||
keymaster = ()
|
||||
|
||||
class Cell:
|
||||
coordinates = (0, 0)
|
||||
position = (0, 0)
|
||||
size = 50
|
||||
perceptor = None
|
||||
content = None
|
||||
rect = pg.Rect(0, 0, size, size)
|
||||
border_width = 2
|
||||
closed = False
|
||||
g = 1
|
||||
h = 2
|
||||
f = g + h
|
||||
def __init__(self, position):
|
||||
self.set_position(position)
|
||||
self.rect = pg.Rect(self.coordinates[0], self.coordinates[1],
|
||||
self.size - self.border_width, self.size - self.border_width)
|
||||
def set_position(self, position):
|
||||
self.position = position
|
||||
self.coordinates = (self.position[0] * self.size,
|
||||
self.position[1] * self.size)
|
||||
def set_content(self, content):
|
||||
self.content = content
|
||||
self.content
|
||||
def set_perceptor(self, perceptor):
|
||||
self.perceptor = perceptor
|
||||
def clear_perceptor(self):
|
||||
self.perceptor = None
|
||||
def draw(self):
|
||||
pg.draw.rect(screen, "white", self.rect)
|
||||
|
||||
if self.perceptor == None:
|
||||
pg.draw.rect(screen, "white", self.rect)
|
||||
else:
|
||||
pg.draw.rect(screen, self.perceptor.color, self.rect)
|
||||
|
||||
g_font = pg.font.Font(None, 14)
|
||||
text = g_font.render((str)(self.g), True, "black")
|
||||
screen.blit(text, ((self.coordinates[0] + self.size * 0.05, self.coordinates[1] + self.size * 0.75)))
|
||||
|
||||
h_font = pg.font.Font(None, 14)
|
||||
text = h_font.render((str)(self.h), True, "black")
|
||||
screen.blit(text, ((self.coordinates[0] + self.size * 0.8, self.coordinates[1] + self.size * 0.75)))
|
||||
|
||||
f_font = pg.font.Font(None, 16)
|
||||
text = f_font.render((str)(self.f), True, "maroon")
|
||||
screen.blit(text, ((self.coordinates[0] + self.size * 0.425, self.coordinates[1] + self.size * 0.7)))
|
||||
|
||||
def calculate_cost(self):
|
||||
self.g = abs(self.position[0] - neo.position[0]) + abs(self.position[1] - neo.position[1])
|
||||
def calculate_heuristic(self):
|
||||
self.h = abs(self.position[0] - keymaker.position[0]) + abs(self.position[1] - keymaker.position[1])
|
||||
def calculate_estimated(self):
|
||||
self.f = self.g + self.h
|
||||
green_cells = [] #open cells +
|
||||
red_cells = [] #closed cells -
|
||||
black_cells = [] #blocked cells =
|
||||
blue_cells = [] #traversed cells #
|
||||
|
||||
class Map:
|
||||
cell_matrix = []
|
||||
dimensions = (8, 8)
|
||||
def __init__(self, dimensions:tuple):
|
||||
self.dimensions = dimensions
|
||||
for x in range(dimensions[0]):
|
||||
column = []
|
||||
for y in range(dimensions[1]):
|
||||
column.append(Cell((x,y)))
|
||||
self.cell_matrix.append(column)
|
||||
def get_cell(self, x, y):
|
||||
if (x < self.dimensions[0] and y < self.dimensions[1]):
|
||||
return self.cell_matrix[x][y]
|
||||
def calculate_costs(self):
|
||||
for x in range(self.dimensions[0]):
|
||||
for y in range(self.dimensions[1]):
|
||||
self.get_cell(x, y).calculate_cost()
|
||||
self.get_cell(x, y).calculate_heuristic()
|
||||
self.get_cell(x, y).calculate_estimated()
|
||||
def draw(self):
|
||||
for x in range(self.dimensions[0]):
|
||||
for y in range(self.dimensions[1]):
|
||||
self.get_cell(x, y).draw()
|
||||
|
||||
steps_count = 0
|
||||
#accumulated_g = 0
|
||||
map_dict = dict()
|
||||
|
||||
def initialize_weighted_map_dict():
|
||||
for x in range(MAP_SIZE):
|
||||
for y in range(MAP_SIZE):
|
||||
map_dict[(x, y)] = [float("inf"), float("inf"), float("inf"), '.'] # (x,y) : (h, g, f, status)
|
||||
|
||||
|
||||
class Entity:
|
||||
coordinates = (0, 0)
|
||||
position = (0, 0)
|
||||
offset = (0, 0)
|
||||
cell = None
|
||||
name = ""
|
||||
color = "black"
|
||||
font_size = 32
|
||||
def __init__(self, cell_position):
|
||||
self.set_cell(map.get_cell(cell_position[0], cell_position[1]))
|
||||
def set_cell(self, cell):
|
||||
self.cell = cell
|
||||
self.position = cell.position
|
||||
self.coordinates = (self.cell.coordinates[0] + self.offset[0],
|
||||
self.cell.coordinates[1] + self.offset[1])
|
||||
self.cell.set_content(self)
|
||||
def set_position(self, x, y):
|
||||
self.set_cell(map.get_cell(x, y))
|
||||
def draw(self):
|
||||
font = pg.font.Font(None, self.font_size)
|
||||
text = font.render(self.name, True, self.color)
|
||||
screen.blit(text, ((self.cell.coordinates[0] + self.offset[0], self.cell.coordinates[1] + self.offset[1])))
|
||||
def print_map():
|
||||
map_str = ""
|
||||
|
||||
|
||||
for x in range(MAP_SIZE):
|
||||
for y in range(MAP_SIZE):
|
||||
if map_dict[(x,y)][3] in "kon":
|
||||
set_status((x,y), '.')
|
||||
|
||||
pass
|
||||
class Actor(Entity):
|
||||
perception_radius = 1
|
||||
percepted_cells = []
|
||||
pass
|
||||
|
||||
class Neo(Actor):
|
||||
open_set = []
|
||||
def __init__(self, cell_position):
|
||||
super().__init__(cell_position)
|
||||
self.color = (100, 100, 255)
|
||||
self.name = "neo"
|
||||
def set_position(self, x, y):
|
||||
map.get_cell(x, y).closed = True
|
||||
self.update_open_set()
|
||||
return super().set_position(x, y)
|
||||
def update_open_set(self):
|
||||
|
||||
self.open_set = []
|
||||
|
||||
estimated_cells = []
|
||||
estimated_cells.append((self.position[0] + 1, self.position[1]))
|
||||
estimated_cells.append((self.position[0] - 1, self.position[1]))
|
||||
estimated_cells.append((self.position[0], self.position[1] + 1))
|
||||
estimated_cells.append((self.position[0], self.position[1] - 1))
|
||||
for i in estimated_cells:
|
||||
if 0 <= i[0] < map.dimensions[0] and 0 <= i[1] < map.dimensions[1]:
|
||||
if (map.get_cell(i[0], i[0]).closed == False):
|
||||
self.open_set.append(map.get_cell(i[0], i[1]))
|
||||
|
||||
|
||||
def percept(self):
|
||||
#clear percepted celles
|
||||
for i in self.percepted_cells:
|
||||
if (i != None):
|
||||
i.clear_perceptor()
|
||||
self.percepted_cells = []
|
||||
|
||||
self.open_set = []
|
||||
for x in range(MAP_SIZE):
|
||||
for y in range(MAP_SIZE):
|
||||
|
||||
for x in range(self.position[0] - self.perception_radius,
|
||||
self.position[0] + self.perception_radius + 1):
|
||||
for y in range(self.position[1] - self.perception_radius,
|
||||
self.position[1] + self.perception_radius + 1):
|
||||
if 0 <= x < map.dimensions[0] and 0 <= y < map.dimensions[1]:
|
||||
if (x != self.position[0] or y != self.position[1]):
|
||||
self.percepted_cells.append(map.get_cell(x, y)) #set current percieved cells
|
||||
|
||||
set_status(keymaster, 'k')
|
||||
set_status(observer, 'o')
|
||||
set_status(neo, 'n')
|
||||
|
||||
#set perceptors
|
||||
for i in self.percepted_cells:
|
||||
if (i != None):
|
||||
i.set_perceptor(self)
|
||||
map.draw()
|
||||
pg.display.update()
|
||||
map_str += " " + map_dict[(x, y)][3] + " "
|
||||
map_str += "\n"
|
||||
print(map_str)
|
||||
|
||||
def get_g(cell, accumulated_g): # TODO MAYBE FIX NEEDED
|
||||
return accumulated_g + 1
|
||||
|
||||
def get_h(cell):
|
||||
return abs(keymaster[0] - cell[0]) + abs(keymaster[1] - cell[1])
|
||||
|
||||
def get_f(cell, accumulated_g):
|
||||
if map_dict[cell][3] == '=':
|
||||
return float("inf")
|
||||
return get_g(cell, accumulated_g) + get_h(cell)
|
||||
|
||||
def get_walkable_cells(actor:tuple):
|
||||
potential_positions = [
|
||||
(actor[0], actor[1] + 1), (actor[0], actor[1] - 1),
|
||||
(actor[0] - 1, actor[1]), (actor[0] + 1, actor[1])
|
||||
]
|
||||
return [pos for pos in potential_positions if pos[0] in range(MAP_SIZE) and pos[1] in range(MAP_SIZE)]
|
||||
|
||||
def get_position_input():
|
||||
position_input_list = input().split(" ")
|
||||
return int(position_input_list[0]), int(position_input_list[1])
|
||||
|
||||
def set_status(position:tuple, status:str):
|
||||
map_dict[position][3] = status
|
||||
|
||||
def print_cells_paremeters(cells:list):
|
||||
str = ""
|
||||
for cell in cells:
|
||||
str += f"({cell[0]},{cell[1]}): {map_dict[cell][0]} + {map_dict[cell][1]} = {map_dict[cell][2]} ({map_dict[cell][3]}) | "
|
||||
print(str)
|
||||
def calculate_next_cell(actor, accumulated_g):
|
||||
|
||||
fs = []
|
||||
for cell in get_walkable_cells(actor):
|
||||
fs.append(get_f(cell, accumulated_g))
|
||||
min_f = min(fs)
|
||||
|
||||
min_cells_by_f = []
|
||||
for cell in get_walkable_cells(actor):
|
||||
if get_f(cell, accumulated_g) == min_f:
|
||||
min_cells_by_f.append(cell)
|
||||
|
||||
hs = []
|
||||
for cell in min_cells_by_f:
|
||||
hs.append(get_h(cell))
|
||||
min_h = min(hs)
|
||||
|
||||
min_cells_by_h = []
|
||||
for cell in min_cells_by_f:
|
||||
if get_h(cell) == min_h:
|
||||
min_cells_by_h.append(cell)
|
||||
|
||||
next_cell = min_cells_by_h[0]
|
||||
return next_cell
|
||||
|
||||
def regenerate_route():
|
||||
global green_cells, red_cells, black_cells, neo, observer
|
||||
accumulated_g = 0
|
||||
observer = neo
|
||||
previous_cell = ()
|
||||
finish = False
|
||||
while not finish:
|
||||
|
||||
pass
|
||||
class Smith(Actor):
|
||||
def __init__(self, cell_position):
|
||||
super().__init__(cell_position)
|
||||
self.color = "red"
|
||||
self.name = "smith"
|
||||
self.font_size = 26
|
||||
def percept(self):
|
||||
#clear percepted celles
|
||||
for i in self.percepted_cells:
|
||||
i.clear_perceptor()
|
||||
self.percepted_cells = []
|
||||
|
||||
for x in range(self.position[0] - self.perception_radius,
|
||||
self.position[0] + self.perception_radius + 1):
|
||||
for y in range(self.position[1] - self.perception_radius,
|
||||
self.position[1] + self.perception_radius + 1):
|
||||
if (x != self.position[0] or y != self.position[1]):
|
||||
self.percepted_cells.append(map.get_cell(x, y)) #set current percieved cells
|
||||
|
||||
#set perceptors
|
||||
for i in self.percepted_cells:
|
||||
i.set_perceptor(self)
|
||||
pass
|
||||
class Sentinel(Actor):
|
||||
def __init__(self, cell_position):
|
||||
super().__init__(cell_position)
|
||||
self.color = "orange"
|
||||
self.name = "sentinel"
|
||||
self.font_size = 18
|
||||
def percept(self):
|
||||
#clear percepted celles
|
||||
for i in self.percepted_cells:
|
||||
i.clear_perceptor()
|
||||
self.percepted_cells = []
|
||||
|
||||
stencil_cells_positions = []
|
||||
stencil_cells_positions.append((self.position[0], self.position[1] + 1))
|
||||
stencil_cells_positions.append((self.position[0] - 1, self.position[1]))
|
||||
stencil_cells_positions.append((self.position[0], self.position[1]))
|
||||
stencil_cells_positions.append((self.position[0] + 1, self.position[1]))
|
||||
stencil_cells_positions.append((self.position[0], self.position[1] - 1))
|
||||
|
||||
for i in stencil_cells_positions:
|
||||
if (i[0] != self.position[0] or i[1] != self.position[1]):
|
||||
self.percepted_cells.append(map.get_cell(i[0], i[1])) #set current percieved cells
|
||||
|
||||
#set perceptors
|
||||
for i in self.percepted_cells:
|
||||
i.set_perceptor(self)
|
||||
pass
|
||||
class Keymaker(Entity):
|
||||
def __init__(self, cell_position):
|
||||
super().__init__(cell_position)
|
||||
self.color = "green"
|
||||
self.name = "key maker"
|
||||
self.font_size = 14
|
||||
pass
|
||||
class Backdoor_key(Entity):
|
||||
pass
|
||||
# setting green cells
|
||||
for cell in get_walkable_cells(observer):
|
||||
if map_dict[cell][3] not in "kon-#=":
|
||||
set_status(cell, '+')
|
||||
|
||||
for cell in get_walkable_cells(observer):
|
||||
map_dict[cell][0] = get_h(cell)
|
||||
map_dict[cell][1] = get_g(cell, accumulated_g)
|
||||
map_dict[cell][2] = get_f(cell, accumulated_g)
|
||||
|
||||
|
||||
next_cell = calculate_next_cell(observer, accumulated_g)
|
||||
|
||||
print_cells_paremeters(get_walkable_cells(observer))
|
||||
print_map()
|
||||
|
||||
previous_cell = observer
|
||||
observer = next_cell
|
||||
|
||||
set_status(previous_cell, '-')
|
||||
|
||||
accumulated_g += 1
|
||||
red_cells.append(next_cell)
|
||||
|
||||
time.sleep(0.5)
|
||||
if observer == keymaster:
|
||||
finish = True
|
||||
|
||||
|
||||
perception_radius = 2 #input()
|
||||
keymaster = (6,4) #get_position_input()
|
||||
|
||||
def read_initial_inputs():
|
||||
neo.perception_radius = (int)(input())
|
||||
keymaker_position = input().split(" ")
|
||||
keymaker.set_position((int)(keymaker_position[0]), (int)(keymaker_position[1]))
|
||||
|
||||
def read_input():
|
||||
inpt = input().split(" ")
|
||||
return inpt
|
||||
|
||||
def move(x, y):
|
||||
for i in neo.open_set:
|
||||
print(i.position)
|
||||
if map.get_cell(x, y) in neo.open_set: #TODO: FIX CHECK
|
||||
neo.set_position(x, y)
|
||||
print(f"m {x} {y}")
|
||||
else:
|
||||
print("ERROR: CAN'T MOVE HERE")
|
||||
neo.update_open_set()
|
||||
|
||||
|
||||
map = Map((8, 8))
|
||||
neo = Neo((3, 3))
|
||||
neo.perception_radius = 2
|
||||
smith = Smith((1,1))
|
||||
sentinel = Sentinel((3,4))
|
||||
keymaker = Keymaker((5,5))
|
||||
pg.init()
|
||||
screen = pg.display.set_mode([1124,1124])
|
||||
pg.display.set_caption("Matrix Universe")
|
||||
running = True
|
||||
#pg.time.delay(7000)
|
||||
neo.set_position(0, 0) #TODO: ITS TEMPORARY
|
||||
neo.update_open_set()
|
||||
move(0, 0)
|
||||
read_initial_inputs()
|
||||
pg.time.delay(1500)
|
||||
while running:
|
||||
for event in pg.event.get():
|
||||
if event.type == pg.QUIT:
|
||||
running = False
|
||||
screen.fill("black")
|
||||
map.calculate_costs()
|
||||
map.draw()
|
||||
neo.percept()
|
||||
neo.draw()
|
||||
|
||||
keymaker.draw()
|
||||
pg.display.update()
|
||||
|
||||
move_input = read_input()
|
||||
pg.time.delay(1500)
|
||||
|
||||
move((int)(move_input[0]), (int)(move_input[1]))
|
||||
|
||||
|
||||
pg.display.update()
|
||||
'''
|
||||
|
||||
|
||||
|
||||
neo.set_position(5,6)
|
||||
|
||||
smith.draw()
|
||||
smith.percept()
|
||||
|
||||
sentinel.draw()
|
||||
sentinel.percept()
|
||||
|
||||
keymaker.draw()
|
||||
|
||||
'''
|
||||
|
||||
|
||||
#pg.time.delay(1000)
|
||||
|
||||
initialize_weighted_map_dict()
|
||||
set_status((0,4),'=')
|
||||
set_status((1,3),'=') # TODO FIX STUCK IN A DEAD END ISSUE
|
||||
regenerate_route()
|
||||
|
||||
@@ -125,7 +125,7 @@ while not finish:
|
||||
next_cell = min(min_f_cell_list, key=lambda cell: get_h(cell))
|
||||
neo = next_cell
|
||||
accumulated_g += 1 # TODO ENSURE THAT g WORKS PROPERLY
|
||||
closed_cells.append(next_cell)
|
||||
closed_cells.append(next_cell) # TODO DELETE
|
||||
passed_cells.append(next_cell)
|
||||
print(f"m {next_cell[1]} {next_cell[0]}") # TODO FIX OR ENSURE THAT x,y OR y,x DOES NOT MAKE ANY DIFFERENCE
|
||||
steps_count += 1
|
||||
|
||||
Reference in New Issue
Block a user