# Copyright (C) 2020 by ÿnérant, eichhornchen, nicomarg, charlse # SPDX-License-Identifier: GPL-3.0-or-later from random import random, randint, shuffle from typing import List, Tuple from ..interfaces import Map, Tile DEFAULT_PARAMS = { "width": 120, "height": 35, "tries": 300, "max_rooms": 20, "max_room_tries": 15, "cross_room": 1, "corridor_chance": .6, "min_v_corr": 2, "max_v_corr": 6, "min_h_corr": 4, "max_h_corr": 12, "large_circular_room": .10, "circular_holes": .5, } class Generator: def __init__(self, params: dict = None): self.params = params or DEFAULT_PARAMS @staticmethod def room_fits(level: List[List[Tile]], y: int, x: int, room: List[List[Tile]], door_y: int, door_x: int, dy: int, dx: int) -> bool: lh, lw = len(level), len(level[0]) rh, rw = len(room), len(room[0]) if not(0 < y + dy < lh and 0 < x + dx < lw): return False if level[y][x] != Tile.EMPTY or level[y + dy][x + dx] != Tile.FLOOR: return False for ry in range(rh): for rx in range(rw): if room[ry][rx] == Tile.FLOOR: ly, lx = y + ry - door_y, x + rx - door_x # tile must be in bounds and empty if not(0 <= ly < lh and 0 <= lx < lw) or \ level[ly][lx] == Tile.FLOOR: return False # so do all neighbouring tiles bc we may # need to place walls there eventually for ny, nx in Map.neighbourhood(level, ly, lx, large=True, oob=True): if not(0 <= ny < lh and 0 <= nx < lw) or \ level[ny][nx] != Tile.EMPTY: return False return True @staticmethod def place_room(level: List[List[Tile]], y: int, x: int, room: List[List[Tile]], door_y: int, door_x: int) -> None: rh, rw = len(room), len(room[0]) # maybe place Tile.DOOR here ? level[y][x] = Tile.FLOOR for ry in range(rh): for rx in range(rw): if room[ry][rx] == Tile.FLOOR: level[y - door_y + ry][x - door_x + rx] = Tile.FLOOR @staticmethod def place_walls(level: List[List[Tile]]) -> None: h, w = len(level), len(level[0]) for y in range(h): for x in range(w): if level[y][x] == Tile.FLOOR: for ny, nx in Map.neighbourhood(level, y, x): if level[ny][nx] == Tile.EMPTY: level[ny][nx] = Tile.WALL def corr_meta_info(self) -> Tuple[int, int, int, int]: if random() < self.params["corridor_chance"]: h_sup = randint(self.params["min_v_corr"], self.params["max_v_corr"]) if random() < .5 else 0 w_sup = 0 if h_sup else randint(self.params["min_h_corr"], self.params["max_h_corr"]) h_off = h_sup if random() < .5 else 0 w_off = w_sup if random() < .5 else 0 return h_sup, w_sup, h_off, w_off return 0, 0, 0, 0 def attach_door(self, room: List[List[Tile]], h_sup: int, w_sup: int, h_off: int, w_off: int) \ -> Tuple[int, int, int, int]: length = h_sup + w_sup dy, dx = 0, 0 if length > 0: if h_sup: dy = -1 if h_off else 1 else: dx = -1 if w_off else 1 else: if random() < .5: dy = -1 if random() < .5 else 1 else: dx = -1 if random() < .5 else 1 rh, rw = len(room), len(room[0]) yxs = [i for i in range(rh * rw)] shuffle(yxs) for pos in yxs: y, x = pos // rw, pos % rw if room[y][x] == Tile.EMPTY: # verify we are pointing away from a floor tile if not(0 <= y - dy < rh and 0 <= x - dx < rw) \ or room[y - dy][x - dx] != Tile.FLOOR: continue # verify there's no other floor tile around us for ny, nx in [[y + dy, x + dx], [y - dx, x - dy], [y + dx, x + dy]]: if 0 <= ny < rh and 0 <= nx < rw \ and room[ny][nx] != Tile.EMPTY: break else: for i in range(length): if room[y + i * dy][x + i * dx] != Tile.EMPTY: break else: for i in range(length): room[y + i * dy][x + i * dx] = Tile.FLOOR break return y + length * dy, x + length * dx, dy, dx def create_circular_room(self) -> Tuple[List[List[Tile]], int, int, int, int]: if random() < self.params["large_circular_room"]: r = randint(5, 10) else: r = randint(2, 4) room = [] h_sup, w_sup, h_off, w_off = self.corr_meta_info() height = 2 * r + 2 width = 2 * r + 2 make_hole = r > 6 and random() < self.params["circular_holes"] r2 = 0 if make_hole: r2 = randint(3, r - 3) for i in range(height + h_sup): room.append([]) d = (i - h_off - height // 2) ** 2 for j in range(width + w_sup): if d + (j - w_off - width // 2) ** 2 < r ** 2 and \ (not make_hole or d + (j - w_off - width // 2) ** 2 >= r2 ** 2): room[-1].append(Tile.FLOOR) else: room[-1].append(Tile.EMPTY) door_y, door_x, dy, dx = self.attach_door(room, h_sup, w_sup, h_off, w_off) return room, door_y, door_x, dy, dx def create_random_room(self) -> Tuple[List[list], int, int, int, int]: return self.create_circular_room() def run(self) -> Map: height, width = self.params["height"], self.params["width"] level = [width * [Tile.EMPTY] for _ignored in range(height)] # the starting room must have no corridor mem, self.params["corridor_chance"] = self.params["corridor_chance"], 0 starting_room, _, _, _, _ = self.create_random_room() dim_v, dim_h = len(starting_room), len(starting_room[0]) pos_y, pos_x = randint(0, height - dim_v - 1),\ randint(0, width - dim_h - 1) self.place_room(level, pos_y, pos_x, starting_room, 0, 0) if starting_room[0][0] != Tile.FLOOR: level[pos_y][pos_x] = Tile.EMPTY self.params["corridor_chance"] = mem # find a starting position sy, sx = randint(0, height - 1), randint(0, width - 1) while level[sy][sx] != Tile.FLOOR: sy, sx = randint(0, height - 1), randint(0, width - 1) # now we loop until we've tried enough, or we've added enough rooms tries, rooms_built = 0, 0 while tries < self.params["tries"] \ and rooms_built < self.params["max_rooms"]: room, door_y, door_x, dy, dx = self.create_random_room() positions = [i for i in range(height * width)] shuffle(positions) for pos in positions: y, x = pos // width, pos % width if self.room_fits(level, y, x, room, door_y, door_x, dy, dx): self.place_room(level, y, x, room, door_y, door_x) rooms_built += 1 break tries += 1 # post-processing self.place_walls(level) return Map(width, height, level, sy, sx)