124 lines
4.2 KiB
Python
124 lines
4.2 KiB
Python
# Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
from enum import auto, Enum
|
|
from random import choice, random, randint
|
|
from typing import Tuple
|
|
|
|
from ..interfaces import Map, Tile
|
|
|
|
|
|
DEFAULT_PARAMS = {
|
|
"split_chance": .15,
|
|
"turn_chance": .5,
|
|
"death_chance": .1,
|
|
"max_walkers": 15,
|
|
"width": 100,
|
|
"height": 100,
|
|
"fill": .4,
|
|
"no_lone_walls": False,
|
|
}
|
|
|
|
|
|
class Directions(Enum):
|
|
up = auto()
|
|
down = auto()
|
|
left = auto()
|
|
right = auto()
|
|
|
|
|
|
class Walker:
|
|
def __init__(self, x: int, y: int):
|
|
self.x = x
|
|
self.y = y
|
|
self.dir = choice(list(Directions))
|
|
|
|
def random_turn(self) -> None:
|
|
self.dir = choice(list(Directions))
|
|
|
|
def next_pos(self) -> Tuple[int, int]:
|
|
if self.dir == Directions.up:
|
|
return self.x, self.y + 1
|
|
elif self.dir == Directions.down:
|
|
return self.x, self.y - 1
|
|
elif self.dir == Directions.right:
|
|
return self.x + 1, self.y
|
|
elif self.dir == Directions.left:
|
|
return self.x - 1, self.y
|
|
|
|
def move_in_bounds(self, width: int, height: int) -> None:
|
|
nx, ny = self.next_pos()
|
|
if 0 < nx < width and 0 < ny < height:
|
|
self.x, self.y = nx, ny
|
|
|
|
def split(self) -> "Walker":
|
|
child = Walker(self.x, self.y)
|
|
child.dir = self.dir
|
|
return child
|
|
|
|
|
|
class Generator:
|
|
def __init__(self, params: dict = DEFAULT_PARAMS):
|
|
self.params = params
|
|
|
|
def run(self) -> Map:
|
|
width, height = self.params["width"], self.params["height"]
|
|
walkers = [Walker(width // 2, height // 2)]
|
|
grid = [[Tile.EMPTY for _ in range(width)] for _ in range(height)]
|
|
count = 0
|
|
while count < self.params["fill"] * width * height:
|
|
# because we can't add or remove walkers while looping over the pop
|
|
# we need lists to keep track of what will be the walkers for the
|
|
# next iteration of the main loop
|
|
next_walker_pop = []
|
|
|
|
for walker in walkers:
|
|
if grid[walker.y][walker.x] == Tile.EMPTY:
|
|
count += 1
|
|
grid[walker.y][walker.x] = Tile.FLOOR
|
|
if random() < self.params["turn_chance"]:
|
|
walker.random_turn()
|
|
walker.move_in_bounds(width, height)
|
|
if random() > self.params["death_chance"]:
|
|
next_walker_pop.append(walker)
|
|
|
|
# we make sure to never kill all walkers
|
|
if not next_walker_pop:
|
|
next_walker_pop.append(choice(walkers))
|
|
|
|
# we use a second loop for spliting so we're not bothered by cases
|
|
# like a walker not spliting because we hit the population cap even
|
|
# though the next one would have died and freed a place
|
|
# not a big if it happened though
|
|
for walker in walkers:
|
|
if len(next_walker_pop) < self.params["max_walkers"]:
|
|
if random() < self.params["split_chance"]:
|
|
next_walker_pop.append(walker.split())
|
|
walkers = next_walker_pop
|
|
|
|
start_x, start_y = randint(0, width - 1), randint(0, height - 1)
|
|
while grid[start_y][start_x] != Tile.FLOOR:
|
|
start_x, start_y = randint(0, width - 1), randint(0, height - 1)
|
|
|
|
result = Map(width, height, grid, start_y, start_x)
|
|
|
|
# post-processing: add walls
|
|
for x in range(width):
|
|
for y in range(height):
|
|
if grid[y][x] == Tile.EMPTY:
|
|
c = sum([1 if grid[j][i] == Tile.FLOOR else 0 for j, i in Map.neighbourhood(grid, y, x, large=True)])
|
|
if c == 4 and self.params["no_lone_walls"]:
|
|
result.tiles[y][x] = Tile.FLOOR
|
|
elif c > 0:
|
|
result.tiles[y][x] = Tile.WALL
|
|
for x in range(width):
|
|
for y in [0, height-1]:
|
|
if grid[y][x] == Tile.FLOOR:
|
|
grid[y][x] = Tile.WALL
|
|
for y in range(height):
|
|
for x in [0, width-1]:
|
|
if grid[y][x] == Tile.FLOOR:
|
|
grid[y][x] = Tile.WALL
|
|
|
|
return result
|