# Procedural Caves - Cellular Automata¶

procedural_caves_cellular.py
```  1"""
2This example procedurally develops a random cave based on cellular automata.
3
4For more information, see:
5https://gamedevelopment.tutsplus.com/tutorials/generate-random-cave-levels-using-cellular-automata--gamedev-9664
6
7If Python and Arcade are installed, this example can be run from the command line with:
8python -m arcade.examples.procedural_caves_cellular
9"""
10
11import random
12import arcade
13import timeit
14
15# Sprite scaling. Make this larger, like 0.5 to zoom in and add
16# 'mystery' to what you can see. Make it smaller, like 0.1 to see
17# more of the map.
18SPRITE_SCALING = 0.25
19SPRITE_SIZE = 128 * SPRITE_SCALING
20
21# How big the grid is
22GRID_WIDTH = 450
23GRID_HEIGHT = 400
24
25# Parameters for cellular automata
26CHANCE_TO_START_ALIVE = 0.4
27DEATH_LIMIT = 3
28BIRTH_LIMIT = 4
29NUMBER_OF_STEPS = 4
30
31# How fast the player moves
32MOVEMENT_SPEED = 5
33
34# How close the player can get to the edge before we scroll.
35VIEWPORT_MARGIN = 300
36
37# How big the window is
38WINDOW_WIDTH = 800
39WINDOW_HEIGHT = 600
40WINDOW_TITLE = "Procedural Caves Cellular Automata Example"
41
42# How fast the camera pans to the player. 1.0 is instant.
43CAMERA_SPEED = 0.1
44
45
46def create_grid(width, height):
47    """ Create a two-dimensional grid of specified size. """
48    return [[0 for _x in range(width)] for _y in range(height)]
49
50
51def initialize_grid(grid):
52    """ Randomly set grid locations to on/off based on chance. """
53    height = len(grid)
54    width = len(grid[0])
55    for row in range(height):
56        for column in range(width):
57            if random.random() <= CHANCE_TO_START_ALIVE:
58                grid[row][column] = 1
59
60
61def count_alive_neighbors(grid, x, y):
62    """ Count neighbors that are alive. """
63    height = len(grid)
64    width = len(grid[0])
65    alive_count = 0
66    for i in range(-1, 2):
67        for j in range(-1, 2):
68            neighbor_x = x + i
69            neighbor_y = y + j
70            if i == 0 and j == 0:
71                continue
72            elif neighbor_x < 0 or neighbor_y < 0 or neighbor_y >= height or neighbor_x >= width:
73                # Edges are considered alive. Makes map more likely to appear naturally closed.
74                alive_count += 1
75            elif grid[neighbor_y][neighbor_x] == 1:
76                alive_count += 1
77    return alive_count
78
79
80def do_simulation_step(old_grid):
81    """ Run a step of the cellular automaton. """
82    height = len(old_grid)
83    width = len(old_grid[0])
84    new_grid = create_grid(width, height)
85    for x in range(width):
86        for y in range(height):
87            alive_neighbors = count_alive_neighbors(old_grid, x, y)
88            if old_grid[y][x] == 1:
89                if alive_neighbors < DEATH_LIMIT:
90                    new_grid[y][x] = 0
91                else:
92                    new_grid[y][x] = 1
93            else:
94                if alive_neighbors > BIRTH_LIMIT:
95                    new_grid[y][x] = 1
96                else:
97                    new_grid[y][x] = 0
98    return new_grid
99
100
101class InstructionView(arcade.View):
102    """ View to show instructions """
103
104    def __init__(self):
105        super().__init__()
106        self.frame_count = 0
107
108    def on_show_view(self):
109        """ This is run once when we switch to this view """
110        self.window.background_color = arcade.csscolor.DARK_SLATE_BLUE
111
112        # Reset the viewport, necessary if we have a scrolling game and we need
113        # to reset the viewport back to the start so we can see what we draw.
114        self.window.default_camera.use()
115
116    def on_draw(self):
117        """ Draw this view """
118        self.clear()
119        arcade.draw_text("Loading...", self.window.width / 2, self.window.height / 2,
120                         arcade.color.BLACK, font_size=50, anchor_x="center")
121
122    def on_update(self, dt):
123        if self.frame_count == 0:
124            self.frame_count += 1
125            return
126
127        """ If the user presses the mouse button, start the game. """
128        game_view = GameView()
129        game_view.setup()
130        self.window.show_view(game_view)
131
132
133class GameView(arcade.View):
134    """
135    Main application class.
136    """
137
138    def __init__(self):
139        super().__init__()
140
141        self.grid = None
142        self.wall_list = None
143        self.player_list = None
144        self.player_sprite = None
145        self.draw_time = 0
146        self.processing_time = 0
147        self.physics_engine = None
148
149        # Track the current state of what key is pressed
150        self.left_pressed = False
151        self.right_pressed = False
152        self.up_pressed = False
153        self.down_pressed = False
154
155        # Create the cameras. One for the GUI, one for the sprites.
156        # We scroll the 'sprite world' but not the GUI.
157        self.camera_sprites = arcade.camera.Camera2D()
158        self.camera_gui = arcade.camera.Camera2D()
159
160        self.window.background_color = arcade.color.BLACK
161
162        self.sprite_count_text = None
163        self.draw_time_text = None
164        self.processing_time_text = None
165
166    def setup(self):
167        self.wall_list = arcade.SpriteList(use_spatial_hash=True)
168        self.player_list = arcade.SpriteList()
169
170        # Create cave system using a 2D grid
171        self.grid = create_grid(GRID_WIDTH, GRID_HEIGHT)
172        initialize_grid(self.grid)
173        for step in range(NUMBER_OF_STEPS):
174            self.grid = do_simulation_step(self.grid)
175
176        texture = arcade.load_texture(":resources:images/tiles/grassCenter.png")
177        # Create sprites based on 2D grid
178        # Each grid location is a sprite.
179        for row in range(GRID_HEIGHT):
180            for column in range(GRID_WIDTH):
181                if self.grid[row][column] == 1:
182                    wall = arcade.BasicSprite(texture, scale=SPRITE_SCALING)
183                    wall.center_x = column * SPRITE_SIZE + SPRITE_SIZE / 2
184                    wall.center_y = row * SPRITE_SIZE + SPRITE_SIZE / 2
185                    self.wall_list.append(wall)
186
187        # Set up the player
188        self.player_sprite = arcade.Sprite(
189            ":resources:images/animated_characters/female_person/femalePerson_idle.png",
190            scale=SPRITE_SCALING)
191        self.player_list.append(self.player_sprite)
192
193        # Randomly place the player. If we are in a wall, repeat until we aren't.
194        placed = False
195        while not placed:
196
197            # Randomly position
198            max_x = int(GRID_WIDTH * SPRITE_SIZE)
199            max_y = int(GRID_HEIGHT * SPRITE_SIZE)
200            self.player_sprite.center_x = random.randrange(max_x)
201            self.player_sprite.center_y = random.randrange(max_y)
202
203            # Are we in a wall?
204            walls_hit = arcade.check_for_collision_with_list(self.player_sprite, self.wall_list)
205            if len(walls_hit) == 0:
206                # Not in a wall! Success!
207                placed = True
208
209        self.scroll_to_player(1.0)
210
211        self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite,
212                                                         self.wall_list)
213
214        # Draw info on the screen
215        sprite_count = len(self.wall_list)
216        output = f"Sprite Count: {sprite_count:,}"
217        self.sprite_count_text = arcade.Text(output,
218                                             20,
219                                             self.window.height - 20,
220                                             arcade.color.WHITE, 16)
221
222        output = "Drawing time:"
223        self.draw_time_text = arcade.Text(output,
224                                          20,
225                                          self.window.height - 40,
226                                          arcade.color.WHITE, 16)
227
228        output = "Processing time:"
229        self.processing_time_text = arcade.Text(output,
230                                                20,
231                                                self.window.height - 60,
232                                                arcade.color.WHITE, 16)
233
234    def on_draw(self):
235        """ Render the screen. """
236
237        # Start timing how long this takes
238        draw_start_time = timeit.default_timer()
239
240        # This command should happen before we start drawing. It will clear
241        # the screen to the background color, and erase what we drew last frame.
242        self.clear()
243
244        # Select the camera we'll use to draw all our sprites
245        self.camera_sprites.use()
246
247        # Draw the sprites
248        self.wall_list.draw(pixelated=True)
249        self.player_list.draw()
250
251        # Select the (unscrolled) camera for our GUI
252        self.camera_gui.use()
253
254        self.sprite_count_text.draw()
255        output = f"Drawing time: {self.draw_time:.3f}"
256        self.draw_time_text.text = output
257        self.draw_time_text.draw()
258
259        output = f"Processing time: {self.processing_time:.3f}"
260        self.processing_time_text.text = output
261        self.processing_time_text.draw()
262
263        self.draw_time = timeit.default_timer() - draw_start_time
264
265    def update_player_speed(self):
266
267        # Calculate speed based on the keys pressed
268        self.player_sprite.change_x = 0
269        self.player_sprite.change_y = 0
270
271        if self.up_pressed and not self.down_pressed:
272            self.player_sprite.change_y = MOVEMENT_SPEED
273        elif self.down_pressed and not self.up_pressed:
274            self.player_sprite.change_y = -MOVEMENT_SPEED
275        if self.left_pressed and not self.right_pressed:
276            self.player_sprite.change_x = -MOVEMENT_SPEED
277        elif self.right_pressed and not self.left_pressed:
278            self.player_sprite.change_x = MOVEMENT_SPEED
279
280    def on_key_press(self, key, modifiers):
281        """Called whenever a key is pressed. """
282
283        if key == arcade.key.UP:
284            self.up_pressed = True
285        elif key == arcade.key.DOWN:
286            self.down_pressed = True
287        elif key == arcade.key.LEFT:
288            self.left_pressed = True
289        elif key == arcade.key.RIGHT:
290            self.right_pressed = True
291
292    def on_key_release(self, key, modifiers):
293        """Called when the user releases a key. """
294
295        if key == arcade.key.UP:
296            self.up_pressed = False
297        elif key == arcade.key.DOWN:
298            self.down_pressed = False
299        elif key == arcade.key.LEFT:
300            self.left_pressed = False
301        elif key == arcade.key.RIGHT:
302            self.right_pressed = False
303
304    def scroll_to_player(self, speed=CAMERA_SPEED):
305        """
306        Scroll the window to the player.
307
308        if CAMERA_SPEED is 1, the camera will immediately move to the desired position.
309        Anything between 0 and 1 will have the camera move to the location with a smoother
310        pan.
311        """
312
313        position = (self.player_sprite.center_x, self.player_sprite.center_y)
314        arcade.camera.controllers.simple_follow_2D(speed, position, self.camera_sprites.view_data)
315
316    def on_resize(self, width: int, height: int):
317        """
318        Resize window
319        Handle the user grabbing the edge and resizing the window.
320        """
321        super().on_resize(width, height)
322        self.camera_sprites.match_screen(and_projection=True)
323        self.camera_gui.match_screen(and_projection=True)
324
325    def on_update(self, delta_time):
326        """ Movement and game logic """
327
328        start_time = timeit.default_timer()
329
330        # Call update on all sprites (The sprites don't do much in this
331        # example though.)
332        self.update_player_speed()
333        self.physics_engine.update()
334
335        # Scroll the screen to the player
336        self.scroll_to_player()
337
338        # Save the time it took to do this.
339        self.processing_time = timeit.default_timer() - start_time
340
341
342def main():
343    window = arcade.Window(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, resizable=True)
344    start_view = InstructionView()
345    window.show_view(start_view)
346    arcade.run()
347
348
349if __name__ == "__main__":
350    main()
```