2023-09-20 04:02:04 +00:00
|
|
|
import 'dart:developer';
|
|
|
|
import 'dart:math' as math;
|
|
|
|
|
|
|
|
import 'package:dartterm/world/level.dart';
|
|
|
|
|
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-21 02:30:03 +00:00
|
|
|
const vaultTries = 10;
|
|
|
|
|
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-21 01:09:08 +00:00
|
|
|
Vault generateBoxed(Requirement req) {
|
2023-09-20 04:02:04 +00:00
|
|
|
var vx = req.vx;
|
|
|
|
var vy = req.vy;
|
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
var v = Vault.blank(vx, vy, req.smooth, LevelTile.wall);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
|
|
|
if (req.vx < 2 || req.vy < 2) {
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
var req2 = Requirement(vx - 2, vy - 2, req.smooth);
|
2023-09-21 01:09:08 +00:00
|
|
|
var inner = generate(req2);
|
2023-09-20 04:02:04 +00:00
|
|
|
v.blitFrom(inner, 1, 1);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
Vault generate(Requirement requirement) {
|
2023-09-21 02:30:03 +00:00
|
|
|
Vault? suggested = _suggest(vaultTries, requirement);
|
|
|
|
if (suggested != null) {
|
|
|
|
return suggested;
|
|
|
|
}
|
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-20 04:02:04 +00:00
|
|
|
if (req2.vy > (req2.vx - 2) * 3 / 2) {
|
|
|
|
orientation = (orientation + 2) % 8; // rotate once more
|
|
|
|
}
|
2023-09-21 01:09:08 +00:00
|
|
|
req2 = unReorientRequirement(requirement, orientation);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
var out2 = _generate(req2);
|
|
|
|
var out1 = reorientVault(out2, orientation);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
|
|
|
log("$orientation ${requirement.vx} ${requirement.vy} ${req2.vx} ${req2.vy} ${out2.vx} ${out2.vy} ${out1.vx} ${out1.vy}");
|
|
|
|
assert(out1.vx == requirement.vx);
|
|
|
|
assert(out1.vy == requirement.vy);
|
|
|
|
return out1;
|
|
|
|
}
|
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
Vault _generate(Requirement req) {
|
2023-09-20 04:02:04 +00:00
|
|
|
var vx = req.vx;
|
|
|
|
var vy = req.vy;
|
2023-09-21 01:09:08 +00:00
|
|
|
var v = Vault.blank(vx, vy, req.smooth, LevelTile.wall);
|
2023-09-20 04:02:04 +00:00
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
if (vx < 5 || vx * vy < 10) {
|
2023-09-20 04:02:04 +00:00
|
|
|
v.clear(LevelTile.floor);
|
|
|
|
} else {
|
|
|
|
// pick a split point
|
2023-09-21 01:09:08 +00:00
|
|
|
var splitVx = _random.nextInt(vx - 4) + 2;
|
2023-09-20 04:02:04 +00:00
|
|
|
|
|
|
|
var reqLeft = Requirement(splitVx, vy, req.smooth.clone());
|
|
|
|
reqLeft.smooth.directions.add(Direction.right);
|
|
|
|
var reqRight = Requirement((vx - splitVx - 1), vy, req.smooth.clone());
|
|
|
|
reqRight.smooth.directions.add(Direction.left);
|
|
|
|
|
2023-09-21 01:09:08 +00:00
|
|
|
var vaultLeft = generate(reqLeft);
|
|
|
|
var vaultRight = generate(reqRight);
|
2023-09-20 04:02:04 +00:00
|
|
|
v.blitFrom(vaultLeft, 0, 0);
|
|
|
|
v.blitFrom(vaultRight, splitVx + 1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
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) {
|
|
|
|
if (vault.vx > req.vx || vault.vy > req.vy) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
if (vault.vx < req.vx / 2 || vault.vy < req.vy / 2) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
var rsd = req.smooth.directions;
|
|
|
|
bool mustFillX =
|
|
|
|
rsd.contains(Direction.left) && rsd.contains(Direction.right);
|
|
|
|
if (vault.vx != req.vx && mustFillX) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
bool mustFillY =
|
|
|
|
rsd.contains(Direction.left) && rsd.contains(Direction.right);
|
|
|
|
if (vault.vy != req.vy && mustFillY) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vault full = Vault.blank(req.vx, req.vy, req.smooth, LevelTile.wall);
|
|
|
|
int vx = vault.vx;
|
|
|
|
int dx;
|
|
|
|
if (rsd.contains(Direction.left)) {
|
|
|
|
dx = 0;
|
|
|
|
} else if (rsd.contains(Direction.right)) {
|
|
|
|
dx = req.vx - vx;
|
|
|
|
} else {
|
|
|
|
dx = _random.nextInt(req.vx - vx);
|
|
|
|
}
|
|
|
|
|
|
|
|
int vy = vault.vy;
|
|
|
|
int dy;
|
|
|
|
if (rsd.contains(Direction.up)) {
|
|
|
|
dy = 0;
|
|
|
|
} else if (rsd.contains(Direction.down)) {
|
|
|
|
dy = req.vy - vy;
|
|
|
|
} else {
|
|
|
|
dy = _random.nextInt(req.vx - vx);
|
|
|
|
}
|
|
|
|
full.blitFrom(vault, dx, dy);
|
|
|
|
return full;
|
|
|
|
}
|
2023-09-20 04:02:04 +00:00
|
|
|
}
|