2023-09-20 04:02:04 +00:00
|
|
|
import 'dart:math' as math;
|
|
|
|
|
2023-09-21 22:37:12 +00:00
|
|
|
import 'package:dartterm/algorithms/geometry.dart' as geo;
|
2023-09-21 03:56:30 +00:00
|
|
|
import 'package:dartterm/algorithms/regionalize.dart';
|
|
|
|
import 'package:dartterm/bitmap.dart';
|
|
|
|
import 'package:dartterm/skreek.dart';
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
part 'direction.dart';
|
|
|
|
part 'direction_set.dart';
|
|
|
|
part 'orientation.dart';
|
|
|
|
part 'requirement.dart';
|
|
|
|
part 'vault.dart';
|
|
|
|
part 'vaults.dart';
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-22 00:33:48 +00:00
|
|
|
const vaultTries = 30;
|
2023-09-21 02:30:03 +00:00
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
class Generator {
|
|
|
|
final math.Random _random;
|
|
|
|
final Vaults _vaults;
|
2023-09-21 02:30:03 +00:00
|
|
|
List<Vault> _queue = [];
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
Generator(this._random, this._vaults);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-22 00:33:48 +00:00
|
|
|
Vault generate(Requirement requirement) {
|
|
|
|
var out = _generateOriented(requirement, false);
|
|
|
|
return _finalize(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vault _generateOriented(Requirement requirement, bool canBeVault) {
|
2023-09-21 05:00:45 +00:00
|
|
|
if (canBeVault) {
|
|
|
|
Vault? suggested = _suggest(vaultTries, requirement);
|
|
|
|
if (suggested != null) {
|
2023-09-21 23:11:34 +00:00
|
|
|
return _fillMetaRegions(requirement, suggested);
|
2023-09-21 05:00:45 +00:00
|
|
|
}
|
2023-09-21 02:30:03 +00:00
|
|
|
}
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
// First of all: randomize orientation
|
2023-09-20 04:02:04 +00:00
|
|
|
// This way we only have to consider one kind of spilt
|
2023-09-21 01:09:08 +00:00
|
|
|
var orientation = randomOrientation(_random);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
|
|
|
// Try to make vx the long axis if possible
|
2023-09-21 01:09:08 +00:00
|
|
|
var req2 = unReorientRequirement(requirement, orientation);
|
2023-09-21 05:00:45 +00:00
|
|
|
if (req2.vyMax > (req2.vxMax - 2) * 3 / 2) {
|
2023-09-20 04:02:04 +00:00
|
|
|
orientation = (orientation + 2) % 8; // rotate once more
|
|
|
|
}
|
2023-09-21 05:00:45 +00:00
|
|
|
// if only one of "left" and "right" needs to be smooth, prioritize right
|
|
|
|
// as left is generated first
|
2023-09-21 01:09:08 +00:00
|
|
|
req2 = unReorientRequirement(requirement, orientation);
|
2023-09-21 05:00:45 +00:00
|
|
|
if (req2.smooth.directions.contains(Direction.left) &&
|
|
|
|
req2.smooth.directions.contains(Direction.right)) {
|
|
|
|
orientation = (orientation + 4) % 8;
|
|
|
|
}
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 05:00:45 +00:00
|
|
|
req2 = unReorientRequirement(requirement, orientation);
|
2023-09-22 00:33:48 +00:00
|
|
|
var out2 = _generateBsp(req2);
|
2023-09-21 01:09:08 +00:00
|
|
|
var out1 = reorientVault(out2, orientation);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 03:56:30 +00:00
|
|
|
// log("$orientation ${requirement.vx} ${requirement.vy} ${req2.vx} ${req2.vy} ${out2.vx} ${out2.vy} ${out1.vx} ${out1.vy}");
|
2023-09-21 22:37:12 +00:00
|
|
|
var geo.Size(:dx, :dy) = out1.size;
|
|
|
|
assert(dx >= requirement.vxMin && dx <= requirement.vxMax);
|
|
|
|
assert(dy >= requirement.vyMin && dy <= requirement.vyMax);
|
2023-09-21 05:00:45 +00:00
|
|
|
assert(out1.smooth.directions.containsAll(requirement.smooth.directions));
|
2023-09-20 04:02:04 +00:00
|
|
|
return out1;
|
|
|
|
}
|
|
|
|
|
2023-09-22 00:33:48 +00:00
|
|
|
Vault _generateBsp(Requirement req) {
|
2023-09-21 05:00:45 +00:00
|
|
|
var vxMin = req.vxMin;
|
|
|
|
var vyMin = req.vyMin;
|
|
|
|
var vxMax = req.vxMax;
|
|
|
|
var vyMax = req.vyMax;
|
|
|
|
|
|
|
|
var smoothUp = req.smooth.directions.contains(Direction.up);
|
|
|
|
var smoothDown = req.smooth.directions.contains(Direction.down);
|
|
|
|
var smoothUpDown = smoothUp && smoothDown;
|
|
|
|
|
|
|
|
// var vxRand = _random.nextInt(vxMax - vxMin) + vxMin;
|
|
|
|
var vyRand = _random.nextInt(vyMax + 1 - vyMin) + vyMin;
|
|
|
|
|
|
|
|
if (vxMax < 2 || vyMax < 2) {
|
2023-09-22 00:33:48 +00:00
|
|
|
return Vault.blank(vxMax, vyRand, VaultTile.defaultwall, req.smooth);
|
2023-09-21 05:00:45 +00:00
|
|
|
} else if (vxMax < 9 || (vxMax - 2) * (vyMax - 2) < 12) {
|
2023-09-21 22:37:12 +00:00
|
|
|
var v2 = Vault.blank(
|
|
|
|
vxMax - 2, vyMax - 2, VaultTile.bspfloor, req.smooth.clone());
|
|
|
|
var v = Vault.blank(vxMax, vyMax, VaultTile.wall, req.smooth.clone());
|
2023-09-21 04:08:46 +00:00
|
|
|
v.blitFrom(v2, 1, 1);
|
2023-09-21 05:00:45 +00:00
|
|
|
return v;
|
2023-09-20 04:02:04 +00:00
|
|
|
} else {
|
2023-09-21 05:00:45 +00:00
|
|
|
var leftReq = Requirement(
|
|
|
|
math.max(vxMin - 4, 2), vxMax - 4, vyMin, vyMax, req.smooth.clone());
|
|
|
|
leftReq.smooth.directions.add(Direction.right);
|
2023-09-22 00:33:48 +00:00
|
|
|
var leftChild = _generateOriented(leftReq, true);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 05:00:45 +00:00
|
|
|
var vyMinRight = vyMin;
|
|
|
|
var vyMaxRight = vyMax;
|
|
|
|
|
|
|
|
if (smoothUpDown) {
|
2023-09-21 22:37:12 +00:00
|
|
|
vyMaxRight = vyMinRight = leftChild.size.dy;
|
2023-09-21 05:00:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var rightReq = Requirement(
|
|
|
|
vxMin - (leftChild.vx - 1),
|
|
|
|
vxMax - (leftChild.vx - 1),
|
|
|
|
vyMinRight,
|
|
|
|
vyMaxRight,
|
|
|
|
req.smooth.clone(),
|
|
|
|
);
|
|
|
|
rightReq.smooth.directions.add(Direction.left);
|
2023-09-22 00:33:48 +00:00
|
|
|
var rightChild = _generateOriented(rightReq, true);
|
2023-09-21 05:00:45 +00:00
|
|
|
|
|
|
|
var vxTotal = leftChild.vx + rightChild.vx - 1;
|
|
|
|
var vyTotal = math.max(leftChild.vy, rightChild.vy);
|
|
|
|
|
|
|
|
if (smoothUp) {
|
2023-09-22 00:33:48 +00:00
|
|
|
var v = Vault.blank(
|
|
|
|
vxTotal, vyTotal, VaultTile.defaultwall, req.smooth.clone());
|
2023-09-21 05:00:45 +00:00
|
|
|
v.blitFrom(leftChild, 0, 0);
|
|
|
|
v.blitFrom(rightChild, leftChild.vx - 1, 0);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
if (smoothDown) {
|
2023-09-22 00:33:48 +00:00
|
|
|
var v = Vault.blank(
|
|
|
|
vxTotal, vyTotal, VaultTile.defaultwall, req.smooth.clone());
|
2023-09-21 05:00:45 +00:00
|
|
|
v.blitFrom(leftChild, 0, vyTotal - leftChild.vy);
|
|
|
|
v.blitFrom(rightChild, leftChild.vx - 1, vyTotal - rightChild.vy);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// no smoothing reqs
|
|
|
|
// min: ensure some overlap
|
|
|
|
var vyTMax = math.min(vyMax, leftChild.vy + rightChild.vy - 3);
|
|
|
|
if (vyTMax > vyTotal) {
|
|
|
|
vyTotal += _random.nextInt(vyTMax - vyTotal);
|
|
|
|
}
|
2023-09-22 00:33:48 +00:00
|
|
|
var v = Vault.blank(
|
|
|
|
vxTotal, vyTotal, VaultTile.defaultwall, req.smooth.clone());
|
2023-09-21 05:00:45 +00:00
|
|
|
if (_random.nextBool()) {
|
|
|
|
v.blitFrom(leftChild, 0, 0);
|
|
|
|
v.blitFrom(rightChild, leftChild.vx - 1, vyTotal - rightChild.vy);
|
|
|
|
} else {
|
|
|
|
v.blitFrom(leftChild, 0, vyTotal - leftChild.vy);
|
|
|
|
v.blitFrom(rightChild, leftChild.vx - 1, 0);
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
2023-09-20 04:02:04 +00:00
|
|
|
}
|
2023-09-21 02:30:03 +00:00
|
|
|
|
|
|
|
Vault? _suggest(int tries, Requirement req) {
|
|
|
|
for (var i = 0; i < tries; i++) {
|
|
|
|
var sugg = _popSuggestion();
|
|
|
|
if (sugg == null) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
sugg = reorientVault(sugg, randomOrientation(_random));
|
|
|
|
sugg = _tidy(sugg, req);
|
|
|
|
if (sugg != null) {
|
|
|
|
return sugg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vault? _popSuggestion() {
|
|
|
|
if (_queue.isEmpty) {
|
|
|
|
_queue = _vaults.randomFlight(_random);
|
|
|
|
}
|
|
|
|
if (_queue.isEmpty) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return _queue.removeLast();
|
|
|
|
}
|
|
|
|
|
|
|
|
Vault? _tidy(Vault vault, Requirement req) {
|
2023-09-21 05:00:45 +00:00
|
|
|
if (vault.vx > req.vxMax || vault.vy > req.vyMax) {
|
2023-09-21 02:30:03 +00:00
|
|
|
return null;
|
|
|
|
}
|
2023-09-21 05:00:45 +00:00
|
|
|
if (vault.vx < req.vxMin || vault.vy < req.vyMin) {
|
2023-09-21 02:30:03 +00:00
|
|
|
return null;
|
|
|
|
}
|
2023-09-21 03:56:30 +00:00
|
|
|
if (!vault.smooth.directions.containsAll(req.smooth.directions)) {
|
|
|
|
return null;
|
|
|
|
}
|
2023-09-21 22:37:12 +00:00
|
|
|
// NOTE: If the vault has metaBSP regions, and they touch the outer edge, then it should be possible
|
|
|
|
// to extend those regions
|
|
|
|
// Extending a metaBSP region results in _two_ metaBSP regions:
|
|
|
|
// a big version of the original, and a second one covering all the space left over
|
|
|
|
// in the set of rows or columns the metabsp region did not touch
|
|
|
|
//
|
|
|
|
// Ex:
|
|
|
|
// XXXX##
|
|
|
|
// XXXX #
|
|
|
|
// XXXX #
|
|
|
|
// # #
|
|
|
|
// ######
|
|
|
|
//
|
|
|
|
// becomes
|
|
|
|
//
|
|
|
|
// XXXZYY
|
|
|
|
// XXXZYY
|
|
|
|
// XXXZYY
|
|
|
|
// XXXX##
|
|
|
|
// XXXX #
|
|
|
|
// XXXX #
|
|
|
|
// # #
|
|
|
|
// ######
|
|
|
|
//
|
|
|
|
// (where the Zs are spaces that Xs and Ys both touch)
|
|
|
|
//
|
|
|
|
// Extension can happen more than once, on each axis:
|
|
|
|
//
|
|
|
|
// XXXXXZYY
|
|
|
|
// XXXXXZYY
|
|
|
|
// XXXXXZYY
|
|
|
|
// XXXXXX##
|
|
|
|
// XXXXXX #
|
|
|
|
// BBXXXX #
|
|
|
|
// AA# #
|
|
|
|
// AA######
|
|
|
|
//
|
2023-09-21 05:00:45 +00:00
|
|
|
return vault;
|
2023-09-21 02:30:03 +00:00
|
|
|
}
|
2023-09-21 23:11:34 +00:00
|
|
|
|
|
|
|
Vault _fillMetaRegions(Requirement requirement, Vault vault) {
|
|
|
|
var geo.Size(:dx, :dy) = vault.size;
|
|
|
|
var metaregions = regionalize(geo.Rect(0, 0, dx, dy),
|
|
|
|
(x, y) => vault.tiles.get(x, y) == VaultTile.meta0);
|
|
|
|
|
|
|
|
for (var i in metaregions) {
|
|
|
|
assert(i.isRectangle);
|
|
|
|
var sz = i.rect.size;
|
|
|
|
// TODO: Relax these based on our environs -- for instance, if one of our sides doesn't need to be smooth, that metaregion doesn't either
|
|
|
|
var metaRequirement = Requirement(
|
|
|
|
sz.dx,
|
|
|
|
sz.dx,
|
|
|
|
sz.dy,
|
|
|
|
sz.dy,
|
|
|
|
DirectionSet(
|
|
|
|
{Direction.up, Direction.left, Direction.down, Direction.right}));
|
2023-09-22 00:33:48 +00:00
|
|
|
var inner = _generateOriented(metaRequirement, true);
|
|
|
|
var dest = Vault(Bitmap.blank(vault.vx, vault.vy, VaultTile.defaultwall),
|
2023-09-21 23:11:34 +00:00
|
|
|
vault.smooth.clone());
|
|
|
|
dest.blitFrom(vault, 0, 0);
|
|
|
|
dest.blitFrom(inner, i.rect.x0, i.rect.y0);
|
|
|
|
vault = dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
return vault;
|
|
|
|
}
|
2023-09-22 00:33:48 +00:00
|
|
|
|
|
|
|
Vault _finalize(Vault subj) {
|
|
|
|
var vx = subj.vx, vy = subj.vy;
|
|
|
|
subj = Vault.blankWith(vx, vy, (x, y) {
|
|
|
|
var bed = VaultTile.defaultwall;
|
|
|
|
if (x == 0 || x == vx - 1 || y == 0 || y == vy - 1) {
|
|
|
|
bed = VaultTile.wall;
|
|
|
|
}
|
|
|
|
var tile = mergeVaultTile(bed, subj.tiles.get(x, y)!);
|
|
|
|
return tile;
|
|
|
|
}, subj.smooth.clone());
|
|
|
|
|
|
|
|
bool canSupportArch(VaultTile? tile) {
|
|
|
|
return tile == VaultTile.bspfloor ||
|
|
|
|
tile == VaultTile.floor ||
|
|
|
|
tile == VaultTile.exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
var orthoOffsets = [(0, -1), (0, 1), (-1, 0), (1, 0)];
|
|
|
|
List<(int, int)> newArches = [];
|
|
|
|
for (int x = 0; x < vx; x++) {
|
|
|
|
for (int y = 0; y < vy; y++) {
|
|
|
|
var t = subj.tiles.get(x, y);
|
|
|
|
if (t == VaultTile.archwall) {
|
|
|
|
var supporters = 0;
|
|
|
|
for (var (dx, dy) in orthoOffsets) {
|
|
|
|
VaultTile? neighbor = subj.tiles.get(x + dx, y + dy);
|
|
|
|
if (canSupportArch(neighbor)) {
|
|
|
|
supporters++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (supporters == 2) {
|
|
|
|
newArches.add((x, y));
|
|
|
|
}
|
|
|
|
subj.tiles.set(x, y, VaultTile.wall);
|
|
|
|
}
|
|
|
|
if (t == VaultTile.archpronewall || t == VaultTile.defaultwall) {
|
|
|
|
subj.tiles.set(x, y, VaultTile.wall);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (var (ax, ay) in newArches) {
|
|
|
|
subj.tiles.set(ax, ay, VaultTile.floor);
|
|
|
|
}
|
|
|
|
return subj;
|
|
|
|
}
|
2023-09-20 04:02:04 +00:00
|
|
|
}
|