367 lines
12 KiB
Python
367 lines
12 KiB
Python
"""
|
|
Create a maze using a recursive division method.
|
|
|
|
For more information on the algorithm, see "Recursive Division Method"
|
|
at https://en.wikipedia.org/wiki/Maze_generation_algorithm
|
|
|
|
Artwork from http://kenney.nl
|
|
|
|
If Python and Arcade are installed, this example can be run from the command line with:
|
|
python -m arcade.examples.maze_recursive
|
|
"""
|
|
import random
|
|
import arcade
|
|
import timeit
|
|
import os
|
|
|
|
NATIVE_SPRITE_SIZE = 128
|
|
SPRITE_SCALING = 0.25
|
|
SPRITE_SIZE = NATIVE_SPRITE_SIZE * SPRITE_SCALING
|
|
|
|
SCREEN_WIDTH = 1000
|
|
SCREEN_HEIGHT = 700
|
|
SCREEN_TITLE = "Maze Recursive Example"
|
|
|
|
MOVEMENT_SPEED = 8
|
|
|
|
TILE_EMPTY = 0
|
|
TILE_CRATE = 1
|
|
|
|
# Maze must have an ODD number of rows and columns.
|
|
# Walls go on EVEN rows/columns.
|
|
# Openings go on ODD rows/columns
|
|
MAZE_HEIGHT = 51
|
|
MAZE_WIDTH = 51
|
|
|
|
|
|
# How many pixels to keep as a minimum margin between the character
|
|
# and the edge of the screen.
|
|
VIEWPORT_MARGIN = 200
|
|
|
|
MERGE_SPRITES = True
|
|
|
|
|
|
def create_empty_grid(width, height, default_value=TILE_EMPTY):
|
|
""" Create an empty grid. """
|
|
grid = []
|
|
for row in range(height):
|
|
grid.append([])
|
|
for column in range(width):
|
|
grid[row].append(default_value)
|
|
return grid
|
|
|
|
|
|
def create_outside_walls(maze):
|
|
""" Create outside border walls."""
|
|
|
|
# Create left and right walls
|
|
for row in range(len(maze)):
|
|
maze[row][0] = TILE_CRATE
|
|
maze[row][len(maze[row])-1] = TILE_CRATE
|
|
|
|
# Create top and bottom walls
|
|
for column in range(1, len(maze[0]) - 1):
|
|
maze[0][column] = TILE_CRATE
|
|
maze[len(maze) - 1][column] = TILE_CRATE
|
|
|
|
|
|
def make_maze_recursive_call(maze, top, bottom, left, right):
|
|
"""
|
|
Recursive function to divide up the maze in four sections
|
|
and create three gaps.
|
|
Walls can only go on even numbered rows/columns.
|
|
Gaps can only go on odd numbered rows/columns.
|
|
Maze must have an ODD number of rows and columns.
|
|
"""
|
|
|
|
# Figure out where to divide horizontally
|
|
start_range = bottom + 2
|
|
end_range = top - 1
|
|
y = random.randrange(start_range, end_range, 2)
|
|
|
|
# Do the division
|
|
for column in range(left + 1, right):
|
|
maze[y][column] = TILE_CRATE
|
|
|
|
# Figure out where to divide vertically
|
|
start_range = left + 2
|
|
end_range = right - 1
|
|
x = random.randrange(start_range, end_range, 2)
|
|
|
|
# Do the division
|
|
for row in range(bottom + 1, top):
|
|
maze[row][x] = TILE_CRATE
|
|
|
|
# Now we'll make a gap on 3 of the 4 walls.
|
|
# Figure out which wall does NOT get a gap.
|
|
wall = random.randrange(4)
|
|
if wall != 0:
|
|
gap = random.randrange(left + 1, x, 2)
|
|
maze[y][gap] = TILE_EMPTY
|
|
|
|
if wall != 1:
|
|
gap = random.randrange(x + 1, right, 2)
|
|
maze[y][gap] = TILE_EMPTY
|
|
|
|
if wall != 2:
|
|
gap = random.randrange(bottom + 1, y, 2)
|
|
maze[gap][x] = TILE_EMPTY
|
|
|
|
if wall != 3:
|
|
gap = random.randrange(y + 1, top, 2)
|
|
maze[gap][x] = TILE_EMPTY
|
|
|
|
# If there's enough space, to a recursive call.
|
|
if top > y + 3 and x > left + 3:
|
|
make_maze_recursive_call(maze, top, y, left, x)
|
|
|
|
if top > y + 3 and x + 3 < right:
|
|
make_maze_recursive_call(maze, top, y, x, right)
|
|
|
|
if bottom + 3 < y and x + 3 < right:
|
|
make_maze_recursive_call(maze, y, bottom, x, right)
|
|
|
|
if bottom + 3 < y and x > left + 3:
|
|
make_maze_recursive_call(maze, y, bottom, left, x)
|
|
|
|
|
|
def make_maze_recursion(maze_width, maze_height):
|
|
""" Make the maze by recursively splitting it into four rooms. """
|
|
maze = create_empty_grid(maze_width, maze_height)
|
|
# Fill in the outside walls
|
|
create_outside_walls(maze)
|
|
|
|
# Start the recursive process
|
|
make_maze_recursive_call(maze, maze_height - 1, 0, 0, maze_width - 1)
|
|
return maze
|
|
|
|
|
|
class MyGame(arcade.Window):
|
|
""" Main application class. """
|
|
|
|
def __init__(self, width, height, title):
|
|
"""
|
|
Initializer
|
|
"""
|
|
super().__init__(width, height, title)
|
|
|
|
# Set the working directory (where we expect to find files) to the same
|
|
# directory this .py file is in. You can leave this out of your own
|
|
# code, but it is needed to easily run the examples using "python -m"
|
|
# as mentioned at the top of this program.
|
|
file_path = os.path.dirname(os.path.abspath(__file__))
|
|
os.chdir(file_path)
|
|
|
|
# Sprite lists
|
|
self.player_list = None
|
|
self.wall_list = None
|
|
|
|
# Player info
|
|
self.score = 0
|
|
self.player_sprite = None
|
|
|
|
# Physics engine
|
|
self.physics_engine = None
|
|
|
|
# Used to scroll
|
|
self.view_bottom = 0
|
|
self.view_left = 0
|
|
|
|
# Time to process
|
|
self.processing_time = 0
|
|
self.draw_time = 0
|
|
|
|
def setup(self):
|
|
""" Set up the game and initialize the variables. """
|
|
|
|
# Sprite lists
|
|
self.player_list = arcade.SpriteList()
|
|
self.wall_list = arcade.SpriteList()
|
|
|
|
# Set up the player
|
|
self.score = 0
|
|
|
|
maze = make_maze_recursion(MAZE_WIDTH, MAZE_HEIGHT)
|
|
|
|
# Create sprites based on 2D grid
|
|
if not MERGE_SPRITES:
|
|
# This is the simple-to-understand method. Each grid location
|
|
# is a sprite.
|
|
for row in range(MAZE_HEIGHT):
|
|
for column in range(MAZE_WIDTH):
|
|
if maze[row][column] == 1:
|
|
wall = arcade.Sprite("images/grassCenter.png", SPRITE_SCALING)
|
|
wall.center_x = column * SPRITE_SIZE + SPRITE_SIZE / 2
|
|
wall.center_y = row * SPRITE_SIZE + SPRITE_SIZE / 2
|
|
self.wall_list.append(wall)
|
|
else:
|
|
# This uses new Arcade 1.3.1 features, that allow me to create a
|
|
# larger sprite with a repeating texture. So if there are multiple
|
|
# cells in a row with a wall, we merge them into one sprite, with a
|
|
# repeating texture for each cell. This reduces our sprite count.
|
|
for row in range(MAZE_HEIGHT):
|
|
column = 0
|
|
while column < len(maze):
|
|
while column < len(maze) and maze[row][column] == 0:
|
|
column += 1
|
|
start_column = column
|
|
while column < len(maze) and maze[row][column] == 1:
|
|
column += 1
|
|
end_column = column - 1
|
|
|
|
column_count = end_column - start_column + 1
|
|
column_mid = (start_column + end_column) / 2
|
|
|
|
wall = arcade.Sprite("images/grassCenter.png", SPRITE_SCALING,
|
|
repeat_count_x=column_count)
|
|
wall.center_x = column_mid * SPRITE_SIZE + SPRITE_SIZE / 2
|
|
wall.center_y = row * SPRITE_SIZE + SPRITE_SIZE / 2
|
|
wall.width = SPRITE_SIZE * column_count
|
|
self.wall_list.append(wall)
|
|
|
|
# Set up the player
|
|
self.player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING)
|
|
self.player_list.append(self.player_sprite)
|
|
|
|
# Randomly place the player. If we are in a wall, repeat until we aren't.
|
|
placed = False
|
|
while not placed:
|
|
|
|
# Randomly position
|
|
self.player_sprite.center_x = random.randrange(MAZE_WIDTH * SPRITE_SIZE)
|
|
self.player_sprite.center_y = random.randrange(MAZE_HEIGHT * SPRITE_SIZE)
|
|
|
|
# Are we in a wall?
|
|
walls_hit = arcade.check_for_collision_with_list(self.player_sprite, self.wall_list)
|
|
if len(walls_hit) == 0:
|
|
# Not in a wall! Success!
|
|
placed = True
|
|
|
|
self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list)
|
|
|
|
# Set the background color
|
|
arcade.set_background_color(arcade.color.AMAZON)
|
|
|
|
# Set the viewport boundaries
|
|
# These numbers set where we have 'scrolled' to.
|
|
self.view_left = 0
|
|
self.view_bottom = 0
|
|
print(f"Total wall blocks: {len(self.wall_list)}")
|
|
|
|
def on_draw(self):
|
|
"""
|
|
Render the screen.
|
|
"""
|
|
|
|
# This command has to happen before we start drawing
|
|
arcade.start_render()
|
|
|
|
# Start timing how long this takes
|
|
draw_start_time = timeit.default_timer()
|
|
|
|
# Draw all the sprites.
|
|
self.wall_list.draw()
|
|
self.player_list.draw()
|
|
|
|
# Draw info on the screen
|
|
sprite_count = len(self.wall_list)
|
|
|
|
output = f"Sprite Count: {sprite_count}"
|
|
arcade.draw_text(output,
|
|
self.view_left + 20,
|
|
SCREEN_HEIGHT - 20 + self.view_bottom,
|
|
arcade.color.WHITE, 16)
|
|
|
|
output = f"Drawing time: {self.draw_time:.3f}"
|
|
arcade.draw_text(output,
|
|
self.view_left + 20,
|
|
SCREEN_HEIGHT - 40 + self.view_bottom,
|
|
arcade.color.WHITE, 16)
|
|
|
|
output = f"Processing time: {self.processing_time:.3f}"
|
|
arcade.draw_text(output,
|
|
self.view_left + 20,
|
|
SCREEN_HEIGHT - 60 + self.view_bottom,
|
|
arcade.color.WHITE, 16)
|
|
|
|
self.draw_time = timeit.default_timer() - draw_start_time
|
|
|
|
def on_key_press(self, key, modifiers):
|
|
"""Called whenever a key is pressed. """
|
|
|
|
if key == arcade.key.UP:
|
|
self.player_sprite.change_y = MOVEMENT_SPEED
|
|
elif key == arcade.key.DOWN:
|
|
self.player_sprite.change_y = -MOVEMENT_SPEED
|
|
elif key == arcade.key.LEFT:
|
|
self.player_sprite.change_x = -MOVEMENT_SPEED
|
|
elif key == arcade.key.RIGHT:
|
|
self.player_sprite.change_x = MOVEMENT_SPEED
|
|
|
|
def on_key_release(self, key, modifiers):
|
|
"""Called when the user releases a key. """
|
|
|
|
if key == arcade.key.UP or key == arcade.key.DOWN:
|
|
self.player_sprite.change_y = 0
|
|
elif key == arcade.key.LEFT or key == arcade.key.RIGHT:
|
|
self.player_sprite.change_x = 0
|
|
|
|
def update(self, delta_time):
|
|
""" Movement and game logic """
|
|
|
|
start_time = timeit.default_timer()
|
|
|
|
# Call update on all sprites (The sprites don't do much in this
|
|
# example though.)
|
|
self.physics_engine.update()
|
|
|
|
# --- Manage Scrolling ---
|
|
|
|
# Track if we need to change the viewport
|
|
|
|
changed = False
|
|
|
|
# Scroll left
|
|
left_bndry = self.view_left + VIEWPORT_MARGIN
|
|
if self.player_sprite.left < left_bndry:
|
|
self.view_left -= left_bndry - self.player_sprite.left
|
|
changed = True
|
|
|
|
# Scroll right
|
|
right_bndry = self.view_left + SCREEN_WIDTH - VIEWPORT_MARGIN
|
|
if self.player_sprite.right > right_bndry:
|
|
self.view_left += self.player_sprite.right - right_bndry
|
|
changed = True
|
|
|
|
# Scroll up
|
|
top_bndry = self.view_bottom + SCREEN_HEIGHT - VIEWPORT_MARGIN
|
|
if self.player_sprite.top > top_bndry:
|
|
self.view_bottom += self.player_sprite.top - top_bndry
|
|
changed = True
|
|
|
|
# Scroll down
|
|
bottom_bndry = self.view_bottom + VIEWPORT_MARGIN
|
|
if self.player_sprite.bottom < bottom_bndry:
|
|
self.view_bottom -= bottom_bndry - self.player_sprite.bottom
|
|
changed = True
|
|
|
|
if changed:
|
|
arcade.set_viewport(self.view_left,
|
|
SCREEN_WIDTH + self.view_left,
|
|
self.view_bottom,
|
|
SCREEN_HEIGHT + self.view_bottom)
|
|
|
|
# Save the time it took to do this.
|
|
self.processing_time = timeit.default_timer() - start_time
|
|
|
|
|
|
def main():
|
|
""" Main method """
|
|
window = MyGame(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
|
|
window.setup()
|
|
arcade.run()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|