def handle(self, *args, **options):
m = Maze()
m.generator = Prims(10, 10)
m.generate()
m.generate_entrances()
print()
self.stdout.write(self.style.SUCCESS('Successfully generated'))
def CreateMaze():
g = GWindow(GWINDOW_WIDTH, GWINDOW_HEIGHT)
maze = Maze(MAZE_ROWS, MAZE_COLS, SQUARE_SIZE)
x = (g.getWidth() - maze.getWidth()) / 2
y = (g.getHeight() - maze.getHeight()) / 2
createRandomMaze(maze)
g.add(maze, x, y)
def __init__(self,width = 20,height = 20,cell_size = 20):
self.width = width
self.height = height
self.cell_size = cell_size
self.maze = Maze()
self.options = ["dungeon","prims"]
def CreateMaze():
maze = Maze(MAZE_ROWS, MAZE_COLS, SQUARE_SIZE)
x = (g.getWidth() - maze.getWidth()) / 2
y = (g.getHeight() - maze.getHeight()) / 2
createRandomMaze(maze)
g.add(maze, x, y)
def generate_data(self):
results = []
for i in range(self.count):
m = Maze()
m.generator = Prims(20, 20)
m.generate()
m.generate_entrances()
results.append(toHTML(m.grid, m.start, m.end, 25))
self.data = results
return self.data
def CreateMaze2():
g = GWindow(GWINDOW_WIDTH, GWINDOW_HEIGHT)
maze = Maze(MAZE_ROWS, MAZE_COLS, SQUARE_SIZE)
x = (g.getWidth() - maze.getWidth()) / 2
y = (g.getHeight() - maze.getHeight()) / 2
#createRandomMaze(maze)
#g.add(maze, x, y)
#g.setInterval(g.add(wall.setColor("Black")), 2000)
walls = maze.getWalls()
random.shuffle(walls)
squares = maze.getSquares()
for square in squares:
square.setColor(randomColor())
for wall in walls:
updateMaze(maze, wall, g)
def main():
x = int(argv[1])
y = int(argv[2])
maze = Maze()
maze.generator = BacktrackingGenerator(x, y)
maze.generate()
aux = maze.tostring().split('\n')
print(len(aux), len(aux[0]))
for i, l in enumerate(aux):
if i == 1:
print('S' + l[1:])
elif i == x * 2 - 1:
print(l[:-1] + 'E')
else:
print(l)
def labyrinthe(carte, case_init, case_fin):
lab = Maze()
lab.start = case_init
lab.end = case_fin
lab.generator = Prims(6, 6)
lab.generate()
n = random.randint(0, 1)
for i in range(11):
for j in range(11):
if lab.grid[i + 1][j + 1] == 1:
if n == 0:
carte[i][j] = "eau"
else:
carte[i][j] = "lave"
else:
carte[i][j] = "herbe"
def _generate(self, w, h, complex):
'''
产生一个特定的迷宫
:param w: int 迷宫宽度
:param h: int 迷宫高度
:param complex: float 算法复杂度，与搜索复杂度不同
:return: Maze 迷宫对象
'''
m = Maze()
m.generator = CellularAutomaton(w, h, complex, default_density)
m.generate()
m.solver = BacktrackingSolver()
#m.start = (1, 1)
#m.end = (w, h)
m.generate_entrances()
m.solve()
return m
def generate_maps(tag: str, dest: str, count: int, xsize: int, ysize: int):
for i in range(count):
# Initialise ith maze.
m = Maze(i)
# Set up generator and generate.
# CellularAutomaton is used as it often gives multiple
# possible solutions for larger map sizes.
m.generator = CellularAutomaton(xsize, ysize)
m.generate()
m.generate_entrances(False, False)
with open(path_join(dest, f"{tag}.{i}.unsolved.map"), "w") as f:
f.write(str(m))
m.solver = ShortestPath()
m.solve()
with open(path_join(dest, f"{tag}.{i}.solved.map"), "w") as f:
f.write(str(m))
def make_maze(grid_size, num_objs, length, img_size, inter,
render_resize_factor):
"""
Args:
grid_size: G
num_objs: N
colors: list of length N, in range (0, 1)
Returns:
imgs: (T, H, W, 3), uint8
grid: (H, W), binary
trajs: (T, N, 2), 2 indices grid
"""
m = Maze()
m.generator = Kruskal(grid_size, grid_size)
m.generate()
remove_deadend(m.grid)
# uint8, binary
grid = m.grid
# Generate trajectories
trajs = []
# import ipdb; ipdb.set_trace()
for i in range(num_objs):
traj = random_trajectory(m.grid, length)
trajs.append(traj)
# SQUARE = np.full((16, 16, 3), 0, dtype=np.uint8)
# CIRCLE = imageio.imread('shapes/circle16.png')
render_size = (m.grid.shape[0]) * render_resize_factor
# render_size = img_size
# render_size = img_size
if SHAPE is CIRCLE:
imgs = smooth_render2(grid, trajs, render_size, img_size, SHAPE, inter)
else:
imgs = smooth_render(grid, trajs, render_size, img_size, SHAPE, inter)
imgs, grid, trajs = (np.array(x) for x in [imgs, grid, trajs])
# (N, T, 2) -> (T, N, 2)
trajs = trajs.transpose(1, 0, 2)
return imgs, grid, trajs
from mazelib import Maze
from mazelib.solve.BacktrackingSolver import BacktrackingSolver
import numpy as np
m = Maze()
m.solver = BacktrackingSolver()
miz = [[
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1],
[
1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,
0, 1
],
[
1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
0, 1
],
[
1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
1, 1
],
[
1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
0, 1
],
[
1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1,
0, 1
],
[
1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
0, 1
def __init__(self,
n=10,
cycles=3,
seed=np.random.randint(0, 10000),
state_representation='integer'):
'''
Initialize a maze
parameters :
n : (int) Maze has diameter 2n+1
cycles : (int) number of blocks to remove to create cycles
seed : (int) seed for random initialization
state_representation : (str) how state ought to be represented for the agent
'''
Maze.set_seed(seed)
m = Maze()
m.generator = DungeonRooms(n, n)
m.generate()
self.grid = m.grid
# remove some walls to create cycles
walls = np.argwhere(self.grid[1:(2 * n), 1:(2 * n)])
np.random.shuffle(walls)
for i in range(cycles):
row, col = walls[i]
row += 1
col += 1
self.grid[row, col] = 0
corners = [[1, 1], [1, 2 * n - 1], [2 * n - 1, 1],
[2 * n - 1, 2 * n - 1]]
self.start = random.choice(corners)
corners.remove(self.start)
self.end = random.choice(corners)
self.loc = self.start # location of agent
self.action_space = spaces.Discrete(4)
if state_representation == 'integer':
self.gen_state = self.gen_integer_state
self.observation_space = spaces.Discrete(np.prod(self.grid.shape))
elif state_representation == 'one_hot':
self.gen_state = self.gen_one_hot_state
self.observation_space = spaces.Discrete(np.prod(self.grid.shape))
self.observation_space = spaces.Box(low=0,
high=1,
shape=(np.prod(
self.grid.shape), ),
dtype=np.int8)
elif state_representation == 'flat_grid':
self.gen_state = self.gen_flat_grid_state
self.observation_space = spaces.Box(
low=0,
high=5,
shape=(np.prod(self.grid.shape), ),
dtype=np.int8) # not sure if this is right?
else:
raise NotImplementedError # add other ways to represent state here
self.episode_length = 0
self.MAX_LENGTH = 1000 # episodes are cut off at this length
from mazelib import Maze
from mazelib.generate.Prims import Prims
import matplotlib.pyplot as plt
"""
Kullanilmiyor eger daha zor labirentler gerekirse diye
"""
def generate_maze(arg):
pass
# grid ile maze ayni sey olmaya bilir
def showPNG(grid):
"""Generate a simple image of the maze."""
plt.figure(figsize=(10, 5))
plt.imshow(grid, cmap=plt.cm.binary, interpolation='nearest')
plt.xticks([]), plt.yticks([])
plt.show()
if __name__ == "__main__":
maze = Maze()
maze.generator = Prims(5, 5)
maze.generate()
print(maze)
