yves
/
Laby
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Laby/laby.py

613 lines
19 KiB
Python
Raw Permalink Blame History

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import exit
import pygame
import random
# Parameters
WIDTH = 960
WAIT = 2000
SIZE = 15
WALL_COLOR = pygame.Color('#8F8F8FFF')
EXIT_COLOR = pygame.Color('#FF7F00FF')
SOFT_EDGE_COLOR = pygame.Color('#AFAFAFFF')
SHARP_EDGE_COLOR = pygame.Color('#5F5F9FFF')
FLOOR_COLOR = pygame.Color('#0F0F0FFF')
SEEN_COLOR = pygame.Color('#0F0F0FFF')
WIN_COLOR = pygame.Color('#FF0000FF')
START_COLOR = pygame.Color('#00FF00FF')
PLAYER_COLOR = pygame.Color('#0000FFFF')
UP = (-1, 0)
RIGHT = (0, 1)
DOWN = (1, 0)
LEFT = (0, -1)
FONT_FACE = 'Serif'
KP_NUMS = [pygame.K_KP0, pygame.K_KP1, pygame.K_KP2, pygame.K_KP3, pygame.K_KP4,
pygame.K_KP5, pygame.K_KP6, pygame.K_KP7, pygame.K_KP8, pygame.K_KP9]
# Secondary parameters
HEIGHT = 10*WIDTH//16
CENTERX = WIDTH // 2
CENTERY = HEIGHT // 3
WIDTHS = [(5 * WIDTH / (7 * (2 * depth + 1))) // 2 for depth in range(0, SIZE)]
WIDTHS.insert(0, 3 * WIDTHS[0] // 2)
HEIGHTS = [(6 * HEIGHT / (7 * (2 * depth + 1))) // 3 for depth in range(0, SIZE)]
HEIGHTS.insert(0, 3 * HEIGHTS[0] // 2)
FONT_SIZE = WIDTHS[1] // 15
DIRECTIONS = (UP, RIGHT, DOWN, LEFT)
ANGLESYX = ((UP, RIGHT), (DOWN, RIGHT), (DOWN, LEFT), (UP, LEFT))
SEEN_SIZE = max((SIZE * SIZE) // 50, 1)
def debug(message, maze = None, path = None):
return
print('-----------------')
print(message)
if maze is not None:
for row in range(0, len(maze)):
r = maze[row]
s = ''
sr = ''
for col in range(0, 2 * SIZE + 1):
sr += '1' if r & 1<<col else '0'
if (row % 2) or (col % 2):
if r & (1<<col):
if (row % 2) and (col % 2):
if path is not None and (row, col) in path:
s += 'O' if (row, col) == path[0] else 'o'
else:
s += '+'
else:
s += '*'
else:
s += '.'
else:
s += ' '
print(s, sr)
def back_dir(dir):
if dir is UP: return DOWN
if dir is DOWN: return UP
if dir is RIGHT: return LEFT
if dir is LEFT: return RIGHT
def shift_path(path, yx):
for i in range(0, len(path)):
p = path[i]
path[i] = (p[0] + yx[0], p[1] + yx[1])
def grow_maze(maze, path, yx = None, bdir = None, recurs = 1):
if yx is None:
for yx in range(0, len(path)):
grow_maze(maze, path, path[yx], None, 1)
return
debug(str(recurs) + ': growing', maze, path)
dontgo_dontblock = [bdir]
go_on = True
while go_on:
exits = []
for d in DIRECTIONS:
if d not in dontgo_dontblock:
d2 = d
if d is UP and yx[0] == 1:
if len(maze) < 2 * SIZE:
for row in (1, 2): maze.insert(0, 0)
shift_path(path, (2, 0))
yx = (yx[0] + 2, yx[1])
debug(str(recurs) + '...Expand UP.', maze, path)
else:
maze[0] |= 1<<(yx[1])
debug(str(recurs) + '...No UP.')
d2 = None
if d is RIGHT and yx[1] == 2 * SIZE - 1:
maze[yx[0]] |= 1<<(2 * SIZE)
debug(str(recurs) + '...No RIGHT')
d2 = None
if d is DOWN and yx[0] == len(maze) - 2:
if len(maze) < 2 * SIZE:
maze.extend([0, 0])
debug(str(recurs) + '...Expand DOWN.', maze, path)
else:
maze[2 * SIZE] |= 1<<(yx[1])
debug(str(recurs) + '...No DOWN')
d2 = None
if d is LEFT and yx[1] == 1:
if any(row & 1<<(2 * SIZE - 1) for row in maze):
maze[yx[0]] |= 1
debug(str(recurs) + '...No LEFT')
d2 = None
else:
for r in range(0, len(maze)): maze[r] = maze[r] << 2
shift_path(path, (0, 2))
yx = (yx[0], yx[1] + 2)
debug(str(recurs) + '...Expand LEFT.', maze, path)
if d2 is not None \
and not maze[yx[0] + d2[0]] & 1<<(yx[1] + d2[1]) \
and not maze[yx[0] + 2 * d2[0]] & 1<<(yx[1] + 2 * d2[1]):
debug(str(recurs) + '...exit added: ' + str(d2))
exits.append(d2)
else:
debug(str(recurs) + '...exit discarded: ' + str(d2))
if len(exits) == 0:
go_on = False
else:
d = exits[random.randrange(0, len(exits))]
debug(str(recurs) + '...Grow ' + str(d))
maze[yx[0] + 2 * d[0]] |= 1<<(yx[1] + 2 * d[1])
dontgo_dontblock.append(d)
for (y, x) in ANGLESYX:
if not maze[yx[0] + y[0]] & 1<<(yx[1]) and not maze[yx[0]] & 1<<(yx[1] + x[1]) \
and maze[yx[0] + 2 * y[0]] & 1<<(yx[1]) and maze[yx[0]] & 1<<(yx[1] + 2 * x[1]) \
and not (maze[yx[0] + 2 * y[0]] & 1<<(yx[1] + x[1]) and maze[yx[0] + y[0]] & 1<<(yx[1] + 2 * x[1])):
if (yx[0], yx[1]) in path:
action = 0
elif y in dontgo_dontblock and x in dontgo_dontblock:
action = 0
elif maze[yx[0] + 2 * y[0]] & 1<<(yx[1] + 2 * x[1]):
if y in dontgo_dontblock:
action = 2
elif x in dontgo_dontblock:
action = 1
elif not maze[yx[0] + 2 * y[0]] & 1<<(yx[1] + x[1]):
action = 1
elif not maze[yx[0] + y[0]] & 1<<(yx[1] + 2 * x[1]):
action = 2
else:
action = random.randrange(1, 3)
elif y in dontgo_dontblock:
action = random.randrange(2, 4)
elif x in dontgo_dontblock:
action = random.randrange(0, 2)
else:
action = random.randrange(0, 3)
if action == 1:
maze[yx[0] + y[0]] |= 1<<(yx[1])
elif action == 2:
maze[yx[0]] |= 1<<(yx[1] + x[1])
else:
maze[yx[0] + y[0]] |= 1<<(yx[1] + 2 * x[1])
maze[yx[0] + 2 * y[0]] |= 1<<(yx[1] + x[1])
if go_on:
yx2 = (yx[0] + 2 * d[0], yx[1] + 2 * d[1])
bdir2 = back_dir(d)
if bdir2 is not UP and (yx2[0] - 2, yx2[1]) in path:
maze[yx2[0] - 1] |= 1<<(yx2[1])
if bdir2 is not RIGHT and (yx2[0], yx2[1] + 2) in path:
maze[yx2[0]] |= 1<<(yx2[1] + 1)
if bdir2 is not DOWN and (yx2[0] + 2, yx2[1]) in path:
maze[yx2[0] + 1] |= 1<<(yx2[1])
if bdir2 is not LEFT and (yx2[0], yx2[1] - 2) in path:
maze[yx2[0]] |= 1<<(yx2[1] - 1)
oldstart = path[0]
grow_maze(maze, path, yx2, bdir2, recurs + 1)
newstart = path[0]
yx = (yx[0] + newstart[0] - oldstart[0], yx[1] + newstart[1] - oldstart[1])
def create_maze(recurs = 1, maze = None, yx = None, bdir = None, path = None):
if maze == None:
# bits are considered to be from bit 0 = LEFT to heaviest bit = RIGHT!
maze = [0, 2, 0] # 3 rows of 3 bits (for a start)
yx = (1, 1)
bdir = None
path = [yx]
debug(str(recurs) + ': coming from ' + str(bdir), maze, path)
exits = []
for d in (UP, RIGHT, DOWN, LEFT):
if d is bdir:
d2 = back_dir(d)
else:
d2 = d
if not maze[yx[0] + d2[0]] & 1<<(yx[1] + d2[1]):
exits.append(d2)
while len(exits) > 0:
d = exits[random.randrange(0, len(exits))]
exits.remove(d)
debug(str(recurs) + '...Try' + str(d))
nmaze = maze[:]
nyx = yx
npath = path[:]
if d is UP:
if nyx[0] == 1:
for row in (1, 2): nmaze.insert(0, 0)
shift_path(npath, (2, 0))
nyx = (nyx[0] + 2, nyx[1])
nmaze[nyx[0] - 2] |= 1<<(nyx[1])
npath.append((nyx[0] - 2, nyx[1]))
if nyx[1] > 1 and nmaze[nyx[0] - 2] & 1<<(nyx[1] - 2):
nmaze[nyx[0] - 2] |= 1<<(nyx[1] - 1)
if nmaze[nyx[0] - 2] & 1<<(nyx[1] + 2):
nmaze[nyx[0] - 2] |= 1<<(nyx[1] + 1)
if nyx[0] > 3 and nmaze[nyx[0] - 4] & 1<<(nyx[1]):
nmaze[nyx[0] - 3] |= 1<<(nyx[1])
if bdir is LEFT:
nmaze[nyx[0] - 1] |= 1<<(nyx[1] - 2)
nmaze[nyx[0] - 2] |= 1<<(nyx[1] - 1)
if bdir is RIGHT:
nmaze[nyx[0] - 1] |= 1<<(nyx[1] + 2)
nmaze[nyx[0] - 2] |= 1<<(nyx[1] + 1)
if len(nmaze) == 2 * SIZE + 1:
return nmaze, npath
nmaze, npath = create_maze(recurs + 1, nmaze, (nyx[0] - 2, nyx[1]), DOWN, npath)
if nmaze is not None:
return nmaze, npath
if d is RIGHT:
nmaze[nyx[0]] |= 1<<(nyx[1] + 2)
npath.append((nyx[0], nyx[1] + 2))
if nyx[0] > 1 and nmaze[nyx[0] - 2] & 1<<(nyx[1] + 2):
nmaze[nyx[0] - 1] |= 1<<(nyx[1] + 2)
if nyx[0] < len(nmaze) - 2 and nmaze[nyx[0] + 2] & 1<<(nyx[1] + 2):
nmaze[nyx[0] + 1] |= 1<<(nyx[1] + 2)
if nmaze[nyx[0]] & 1<<(nyx[1] + 4):
nmaze[nyx[0]] |= 1<<(nyx[1] + 3)
if bdir is UP:
nmaze[nyx[0] - 1] |= 1<<(nyx[1] + 2)
nmaze[nyx[0] - 2] |= 1<<(nyx[1] + 1)
if bdir is DOWN:
nmaze[nyx[0] + 1] |= 1<<(nyx[1] + 2)
nmaze[nyx[0] + 2] |= 1<<(nyx[1] + 1)
if any(row & 1<<(2 * SIZE - 1) for row in nmaze):
return nmaze, npath
nmaze, npath = create_maze(recurs + 1, nmaze, (nyx[0], nyx[1] + 2), LEFT, npath)
if nmaze is not None:
return nmaze, npath
if d is DOWN:
if nyx[0] == len(nmaze) - 2:
nmaze.extend([0, 0])
nmaze[nyx[0] + 2] |= 1<<(nyx[1])
npath.append((nyx[0] + 2, nyx[1]))
if nyx[1] > 1 and nmaze[nyx[0] + 2] & 1<<(nyx[1] - 2):
nmaze[nyx[0] + 2] |= 1<<(nyx[1] - 1)
if nmaze[nyx[0] + 2] & 1<<(nyx[1] + 2):
nmaze[nyx[0] + 2] |= 1<<(nyx[1] + 1)
if nyx[0] < len(nmaze) - 4 and nmaze[nyx[0] + 4] & 1<<(nyx[1]):
nmaze[nyx[0] + 3] |= 1<<(nyx[1])
if bdir is LEFT:
nmaze[nyx[0] + 1] |= 1<<(nyx[1] - 2)
nmaze[nyx[0] + 2] |= 1<<(nyx[1] - 1)
if bdir is RIGHT:
nmaze[nyx[0] + 1] |= 1<<(nyx[1] + 2)
nmaze[nyx[0] + 2] |= 1<<(nyx[1] + 1)
if len(nmaze) == 2 * SIZE + 1:
return nmaze, npath
nmaze, npath = create_maze(recurs + 1, nmaze, (nyx[0] + 2, nyx[1]), UP, npath)
if nmaze is not None:
return nmaze, npath
if d is LEFT:
if nyx[1] == 1:
for r in range(0, len(nmaze)): nmaze[r] = nmaze[r] << 2
shift_path(npath, (0, 2))
nyx = (nyx[0], nyx[1] + 2)
nmaze[nyx[0]] |= 1<<(nyx[1] - 2)
npath.append((nyx[0], nyx[1] - 2))
if nyx[0] > 1 and nmaze[nyx[0] - 2] & 1<<(nyx[1] - 2):
nmaze[nyx[0] - 1] |= 1<<(nyx[1] - 2)
if nyx[0] < len(nmaze) - 2 and nmaze[nyx[0] + 2] & 1<<(nyx[1] - 2):
nmaze[nyx[0] + 1] |= 1<<(nyx[1] - 2)
if nyx[1] > 3 and nmaze[nyx[0]] & 1<<(nyx[1] - 4):
nmaze[nyx[0]] |= 1<<(nyx[1] - 3)
if bdir is UP:
nmaze[nyx[0] - 1] |= 1<<(nyx[1] - 2)
nmaze[nyx[0] - 2] |= 1<<(nyx[1] - 1)
if bdir is DOWN:
nmaze[nyx[0] + 1] |= 1<<(nyx[1] - 2)
nmaze[nyx[0] + 2] |= 1<<(nyx[1] - 1)
if any(row & 1<<(2 * SIZE - 1) for row in nmaze):
return nmaze, npath
nmaze, npath = create_maze(recurs + 1, nmaze, (nyx[0], nyx[1] - 2), RIGHT, npath)
if nmaze is not None:
return nmaze, npath
return None, None
def relative(dir, rel):
if dir is UP:
return rel
elif rel is UP:
return dir
elif rel is DOWN:
if dir is RIGHT:
return LEFT
elif dir is LEFT:
return RIGHT
else:
return UP
elif rel == dir:
return DOWN
elif dir is DOWN:
if rel is RIGHT:
return LEFT
else:
return RIGHT
else:
return UP
def is_exit(path, pos, dir):
return (pos[0] + dir[0] == 0 or pos[0] + dir[0] == 2 * SIZE \
or pos[1] + dir[1] == 0 or pos[1] + dir[1] == 2 * SIZE) \
and (pos[0], pos[1]) == path[-1]
def is_wall(maze, pos, dir):
return maze[pos[0] + dir[0]] & 1<<(pos[1] + dir[1])
def new_pos(pos, dir):
return (pos[0] + 2 * dir[0], pos[1] + 2 * dir[1])
def rotate_dir(dir, left_or_right):
return DIRECTIONS[(DIRECTIONS.index(dir) + left_or_right[1]) % 4]
def draw_maze(maze, path, game, seen, pos, dir, shift = None, depth = None, clip = None):
s = pygame.display.get_surface()
if clip is None:
fake_path = [pos, new_pos(pos, dir)]
debug('played:', maze, fake_path)
s.set_clip(None)
s.fill(FLOOR_COLOR)
draw_maze(maze, path, game, seen, pos, dir, 0, 1, s.get_rect())
pygame.display.update()
s.set_clip(None)
return
# Inner/Outer - Width/Height/X/Y
iw = WIDTHS[depth]
ow = WIDTHS[depth - 1]
ih = HEIGHTS[depth]
oh = HEIGHTS[depth - 1]
ix = CENTERX + 2 * shift * iw
ox = CENTERX + 2 * shift * ow
iy = oy = CENTERY
if not pygame.Rect(ox - ow, oy - oh, 2 * ow + 1, 3 * oh + 1).colliderect(clip) \
and not pygame.Rect(ix - iw, iy - ih, 2 * iw + 1, 3 * ih + 1).colliderect(clip):
return
it = [None, (ix + iw, iy - ih), (ix - iw, iy - ih)]
ib = [None, (ix + iw, iy + ih * 2), (ix - iw, iy + ih * 2)]
ot = [None, (ox + ow, oy - oh), (ox - ow, oy - oh)]
ob = [None, (ox + ow, oy + oh * 2), (ox - ow, oy + oh * 2)]
# floor
if seen != 0 and pos in game:
alpha = game[::-1].index(pos)
if seen < 0:
alpha = 255 - 171 * alpha / len(game)
elif alpha > seen - 1:
alpha = -1
else:
alpha = 255 - 190 * alpha / seen
else:
alpha = -1
if alpha >= 0:
s.set_clip(clip)
p = pygame.Surface(((iw + ow) // 2, (oy + 2 * oh - iy - 2 * ih) // 2))
p.fill(FLOOR_COLOR)
p.set_colorkey(FLOOR_COLOR)
pygame.draw.ellipse(p, PLAYER_COLOR, p.get_rect())
p.set_alpha(alpha)
s.blit(p, ((2 * ix + 2 * ox - iw -ow) // 4, (3 * iy / 2 + 3 * ih + oy / 2 + oh) // 2))
# ahead
if is_wall(maze, pos, dir):
s.set_clip(clip)
pygame.draw.polygon(s, EXIT_COLOR if is_exit(path, pos, dir) else WALL_COLOR, [ib[1], it[1], it[-1], ib[-1]])
pygame.draw.line(s, SHARP_EDGE_COLOR, it[-1], it[1])
pygame.draw.line(s, SHARP_EDGE_COLOR, ib[-1], ib[1])
pygame.draw.line(s, SOFT_EDGE_COLOR, it[-1], ib[-1])
pygame.draw.line(s, SOFT_EDGE_COLOR, it[1], ib[1])
else:
r = pygame.Rect(ix - iw, iy - ih, 2 * iw + 1, 3 * ih + 1).clip(clip)
if r.width > 0 and r.height > 0:
draw_maze(maze, path, game, seen, new_pos(pos, dir), dir, shift, depth + 1, r)
# sides
for d in (LEFT, RIGHT):
tmpdir = relative(d, dir)
s.set_clip(clip)
if (d is LEFT and shift > 0) or (d is RIGHT and shift < 0):
if not is_wall(maze, pos, tmpdir):
pygame.draw.line(s, SHARP_EDGE_COLOR, ot[-1 * d[1]], ob[-1 * d[1]])
elif is_wall(maze, pos, tmpdir):
pygame.draw.polygon(s, EXIT_COLOR if is_exit(path, pos, tmpdir) else WALL_COLOR, [ib[d[1]], it[d[1]], ot[d[1]], ob[d[1]]])
pygame.draw.line(s, SHARP_EDGE_COLOR, it[d[1]], ot[d[1]])
pygame.draw.line(s, SHARP_EDGE_COLOR, ib[d[1]], ob[d[1]])
pygame.draw.line(s, SOFT_EDGE_COLOR, it[d[1]], ib[d[1]])
pygame.draw.line(s, SOFT_EDGE_COLOR, ot[d[1]], ob[d[1]])
else:
tmppos = new_pos(pos, tmpdir)
r = pygame.Rect(ix + iw if d is RIGHT else ox - ow, 0, d[1] * (ox + d[1] * ow) - d[1] * (ix + d[1] * iw) + 1, HEIGHT).clip(clip)
if r.width > 0 and r.height > 0:
draw_maze(maze, path, game, seen, tmppos, dir, shift + d[1], depth, r)
if not is_wall(maze, tmppos, dir):
s.set_clip(clip)
pygame.draw.line(s, SHARP_EDGE_COLOR, it[d[1]], ib[d[1]])
def get_help_surface(maze, path = None):
size = HEIGHT // SIZE
s = pygame.Surface((SIZE * size, SIZE * size)).convert()
for row in range(0, SIZE):
for col in range(0, SIZE):
yx = (2 * row + 1, 2 * col + 1)
if path and yx == path[0]:
color = START_COLOR
elif path and yx == path[-1]:
color = EXIT_COLOR
else:
color = FLOOR_COLOR
pygame.draw.rect(s, color, pygame.Rect(col * size + 1, row * size + 1, size - 2, size - 2))
if is_wall(maze, yx, UP):
color = SHARP_EDGE_COLOR
else:
color = FLOOR_COLOR
pygame.draw.line(s, color, (col * size, row * size), ((col + 1) * size - 1, row * size))
if is_wall(maze, yx, RIGHT):
color = SHARP_EDGE_COLOR
else:
color = FLOOR_COLOR
pygame.draw.line(s, color, ((col + 1) * size - 1, row * size), ((col + 1) * size - 1, (row + 1) * size - 1))
if is_wall(maze, yx, DOWN):
color = SHARP_EDGE_COLOR
else:
color = FLOOR_COLOR
pygame.draw.line(s, color, (col * size, (row + 1) * size - 1), ((col + 1) * size - 1, (row + 1) * size - 1))
if is_wall(maze, yx, LEFT):
color = SHARP_EDGE_COLOR
else:
color = FLOOR_COLOR
pygame.draw.line(s, color, (col * size, row * size), (col * size, (row + 1) * size - 1))
return s
def get_player_surface():
size = HEIGHT // SIZE
p = pygame.Surface((size, size)).convert()
p.fill(WALL_COLOR)
pygame.draw.line(p, PLAYER_COLOR, (size // 3, 2 * size // 3), (size // 2, size // 3))
pygame.draw.line(p, PLAYER_COLOR, (2 * size // 3, 2 * size // 3), (size // 2, size // 3))
p.set_colorkey(WALL_COLOR)
return p
def draw_help(helpmap, pos = None, dir = None, player = None):
s = pygame.display.get_surface()
s.fill(WALL_COLOR)
s.blit(helpmap, (CENTERX - helpmap.get_width() // 2, 0))
if pos:
size = HEIGHT // SIZE
x = CENTERX - helpmap.get_width() // 2 + ((pos[1] - 1) / 2) * size
y = ((pos[0] - 1) / 2) * size
if dir is RIGHT:
p = pygame.transform.rotate(player, -90)
elif dir is LEFT:
p = pygame.transform.rotate(player, 90)
elif dir is DOWN:
p = pygame.transform.rotate(player, 180)
else:
p = player
s.blit(p, (x + 1, y + 1))
pygame.display.update()
def draw_end(helpmap, path, game):
txt = pygame.font.SysFont(FONT_FACE, FONT_SIZE)\
.render(str(len(game) - 1) + ' STEPS (+ ' + str(len(game) - len(path)) + ')', True, WIN_COLOR)
pygame.display.get_surface().blit(txt, (CENTERX - txt.get_width() // 2, CENTERY - txt.get_height() // 2))
pygame.display.update()
pygame.time.wait(WAIT)
size = HEIGHT // SIZE
player = pygame.Surface((size, size)).convert()
player.fill(WALL_COLOR)
pygame.draw.circle(player, PLAYER_COLOR, (size // 2, size // 2), size // 3)
shadow = pygame.Surface((size, size)).convert()
shadow.blit(player, (0, 0))
player.set_colorkey(WALL_COLOR)
shadow.set_colorkey(WALL_COLOR)
shadow.set_alpha(84)
endwait = True
while endwait and len(game):
yx = game.pop(0)
y = ((yx[0] - 1) / 2) * size
x = ((yx[1] - 1) / 2) * size
helpmap.blit(shadow, (x, y))
draw_help(helpmap, yx, UP, player)
pygame.time.wait(200)
for evt in pygame.event.get():
if evt.type == pygame.QUIT:
endwait = False
elif evt.type == pygame.KEYUP and evt.key == pygame.K_ESCAPE:
endwait = False
if endwait:
pygame.time.wait(WAIT)
def draw_fake_maze():
high = 1
low = 1
for i in range(0, SIZE):
high = (high<<2) | 3
low = (low<<2) | 1
fake = [high]
for i in range(0, SIZE):
fake.extend([low, high])
draw_help(get_help_surface(fake))
# Pygame initialisation
pygame.init()
pygame.event.set_allowed([pygame.QUIT, pygame.KEYUP])
pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Laby')
pygame.mouse.set_visible(0)
# Choose maze size
draw_fake_maze()
redraw = False
while True:
evt = pygame.event.wait()
if evt.type == pygame.QUIT:
exit()
elif evt.type == pygame.KEYUP:
if evt.key == pygame.K_ESCAPE:
exit()
elif evt.key == pygame.K_KP_PLUS:
SIZE += 5
redraw = True
elif evt.key == pygame.K_KP_MINUS:
SIZE -= 5
redraw = True
else:
break
if redraw:
draw_fake_maze()
redraw = False
# Maze creation
maze, path = create_maze()
debug('PATH ', maze, path)
grow_maze(maze, path)
debug('GROWN ', maze, path)
# Player variables
play_pos = path[0]
play_dir = DIRECTIONS[random.randrange(0, 4)]
game = [play_pos]
helpmap = get_help_surface(maze, path)
heading = get_player_surface()
# Main loop
seen = 0
endwait = True
help = False
run = True
draw_maze(maze, path, game, seen, play_pos, play_dir)
while run:
evt = pygame.event.wait()
if evt.type == pygame.QUIT:
run = False
endwait = False
elif evt.type == pygame.KEYUP:
if evt.key == pygame.K_ESCAPE:
run = False
endwait = False
elif evt.key == pygame.K_h:
help = not help
elif evt.key == pygame.K_UP:
rel_dir = relative(UP, play_dir)
if is_exit(path, play_pos, rel_dir):
run = False
elif not is_wall(maze, play_pos, rel_dir):
play_pos = new_pos(play_pos, rel_dir)
game.append(play_pos)
elif evt.key == pygame.K_RIGHT:
play_dir = rotate_dir(play_dir, RIGHT)
elif evt.key == pygame.K_DOWN:
rel_dir = relative(DOWN, play_dir)
if is_exit(path, play_pos, rel_dir):
run = False
elif not is_wall(maze, play_pos, rel_dir):
play_pos = new_pos(play_pos, rel_dir)
game.append(play_pos)
elif evt.key == pygame.K_LEFT:
play_dir = rotate_dir(play_dir, LEFT)
elif evt.key in KP_NUMS:
seen = SEEN_SIZE * KP_NUMS.index(evt.key)
elif evt.key == pygame.K_KP_MULTIPLY:
seen = -SEEN_SIZE
elif evt.key == pygame.K_KP_PLUS:
seen += 5 * SEEN_SIZE
elif evt.key == pygame.K_KP_MINUS:
seen -= 5 * SEEN_SIZE
if help:
draw_help(helpmap, play_pos, play_dir, heading)
else:
draw_maze(maze, path, game, seen, play_pos, play_dir)
if endwait:
draw_end(helpmap, path, game)
Reference in New Issue View Git Blame Copy Permalink