|
|
|
@@ -0,0 +1,250 @@
|
|
|
|
|
## The procedural island. One seed gives one island, on the server and on every client,
|
|
|
|
|
## so terrain is never sent over the network: both ends call `Island.generate(seed)`.
|
|
|
|
|
##
|
|
|
|
|
## The island is built in layers, each a pure function of the seed:
|
|
|
|
|
## 1. a warped coastline around the world centre, falling to the sea floor outside it;
|
|
|
|
|
## 2. a raised interior plateau that keeps land joined through the early tide;
|
|
|
|
|
## 3. two to four summits, joined by ridges, which become the last dry ground;
|
|
|
|
|
## 4. rolling detail, rocky highland detail, and flattened marsh in wet lowland.
|
|
|
|
|
## Then the land is scaled so the tallest summit lands in the tuned peak range.
|
|
|
|
|
##
|
|
|
|
|
## All randomness comes from the match seed's "worldgen" stream. FastNoiseLite is a
|
|
|
|
|
## seeded, pure function in the engine core with no rendering dependency.
|
|
|
|
|
class_name Island
|
|
|
|
|
extends RefCounted
|
|
|
|
|
|
|
|
|
|
enum Band { SEA, BEACH, MARSH, FOREST, HIGHLAND, SUMMIT }
|
|
|
|
|
|
|
|
|
|
## Height of the coastal shelf the land rises to, before detail and summits, in metres.
|
|
|
|
|
const PLATEAU_HEIGHT: float = 11.0
|
|
|
|
|
## Extra height of a broad dome over the interior, so each tide phase takes a ring of
|
|
|
|
|
## land rather than the whole plateau at once.
|
|
|
|
|
const DOME_HEIGHT: float = 16.0
|
|
|
|
|
## Fraction of the radius, measured inward from the coast, over which land rises to the plateau.
|
|
|
|
|
const COAST_RISE: float = 0.32
|
|
|
|
|
## How far the coastline is pushed in or out, as a fraction of the radius.
|
|
|
|
|
const COAST_WARP: float = 0.22
|
|
|
|
|
const DETAIL_METRES: float = 6.5
|
|
|
|
|
const ROCK_METRES: float = 7.0
|
|
|
|
|
const RIDGE_FRACTION: float = 0.55
|
|
|
|
|
const MARSH_LEVEL: float = 3.6
|
|
|
|
|
## Moisture above this turns wet lowland into marsh.
|
|
|
|
|
const MARSH_MOISTURE: float = 0.05
|
|
|
|
|
|
|
|
|
|
var match_seed: int = 0
|
|
|
|
|
var ground: SimGround
|
|
|
|
|
## Elevation band per heightfield sample, same layout as `ground.heights`.
|
|
|
|
|
var bands: PackedByteArray = PackedByteArray()
|
|
|
|
|
## The summit centres the generator placed, as (x, height, z), tallest first.
|
|
|
|
|
var summits: Array[Vector3] = []
|
|
|
|
|
## Wall-clock generation time is measured by callers; the island never reads a clock.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Builds the island for `seed_value`.
|
|
|
|
|
static func generate(seed_value: int) -> Island:
|
|
|
|
|
var island: Island = Island.new()
|
|
|
|
|
island.match_seed = seed_value
|
|
|
|
|
island._build()
|
|
|
|
|
return island
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## SHA-256 hex digest of the heightfield, heights rounded to millimetres. Two machines
|
|
|
|
|
## that agree on this agree on every walkable surface.
|
|
|
|
|
func heightmap_hash() -> String:
|
|
|
|
|
var buffer: StreamPeerBuffer = StreamPeerBuffer.new()
|
|
|
|
|
buffer.big_endian = false
|
|
|
|
|
buffer.put_32(ground.samples)
|
|
|
|
|
buffer.put_32(roundi(ground.cell * 1000.0))
|
|
|
|
|
for value: float in ground.heights:
|
|
|
|
|
buffer.put_32(roundi(value * 1000.0))
|
|
|
|
|
buffer.put_data(bands)
|
|
|
|
|
var hasher: HashingContext = HashingContext.new()
|
|
|
|
|
hasher.start(HashingContext.HASH_SHA256)
|
|
|
|
|
hasher.update(buffer.data_array)
|
|
|
|
|
return hasher.finish().hex_encode()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## The elevation band at world position (x, z), from the nearest sample.
|
|
|
|
|
func band_at(x: float, z: float) -> Band:
|
|
|
|
|
var limit: int = ground.samples - 1
|
|
|
|
|
var gx: int = clampi(roundi(x / ground.cell), 0, limit)
|
|
|
|
|
var gz: int = clampi(roundi(z / ground.cell), 0, limit)
|
|
|
|
|
return bands[gz * ground.samples + gx] as Band
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## The highest terrain sample, in metres.
|
|
|
|
|
func max_height() -> float:
|
|
|
|
|
var best: float = -INF
|
|
|
|
|
for value: float in ground.heights:
|
|
|
|
|
best = maxf(best, value)
|
|
|
|
|
return best
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func _build() -> void:
|
|
|
|
|
var rng: RandomNumberGenerator = SimRng.new(match_seed).stream("worldgen")
|
|
|
|
|
var size: float = Tuning.WORLD_SIZE_METRES
|
|
|
|
|
var cell: float = Tuning.ISLAND_GRID_METRES
|
|
|
|
|
var side: int = roundi(size / cell) + 1
|
|
|
|
|
var centre: Vector2 = Vector2(size, size) * 0.5
|
|
|
|
|
var radius: float = Tuning.ISLAND_RADIUS_METRES
|
|
|
|
|
|
|
|
|
|
var coast: FastNoiseLite = _noise(rng.randi(), 1.0 / 260.0, 3)
|
|
|
|
|
var detail: FastNoiseLite = _noise(rng.randi(), 1.0 / 170.0, 4)
|
|
|
|
|
var rock: FastNoiseLite = _noise(rng.randi(), 1.0 / 60.0, 3)
|
|
|
|
|
rock.fractal_type = FastNoiseLite.FRACTAL_RIDGED
|
|
|
|
|
var moisture: FastNoiseLite = _noise(rng.randi(), 1.0 / 200.0, 2)
|
|
|
|
|
|
|
|
|
|
var peaks: Array[Dictionary] = _place_summits(rng, centre, radius)
|
|
|
|
|
var ridges: Array[Dictionary] = _link_summits(peaks)
|
|
|
|
|
|
|
|
|
|
var heights: PackedFloat32Array = PackedFloat32Array()
|
|
|
|
|
heights.resize(side * side)
|
|
|
|
|
var wet: PackedFloat32Array = PackedFloat32Array()
|
|
|
|
|
wet.resize(side * side)
|
|
|
|
|
for gz: int in side:
|
|
|
|
|
var z: float = gz * cell
|
|
|
|
|
for gx: int in side:
|
|
|
|
|
var x: float = gx * cell
|
|
|
|
|
var index: int = gz * side + gx
|
|
|
|
|
var offset: Vector2 = Vector2(x, z) - centre
|
|
|
|
|
# Inland is 0 at the coast, 1 at the centre, negative out to sea.
|
|
|
|
|
var inland: float = 1.0 - offset.length() / radius + COAST_WARP * coast.get_noise_2d(x, z)
|
|
|
|
|
if inland <= 0.0:
|
|
|
|
|
heights[index] = -Tuning.ISLAND_SEA_DEPTH * clampf(-inland / 0.12, 0.0, 1.0) - 0.4
|
|
|
|
|
continue
|
|
|
|
|
var rise: float = _smooth(0.0, COAST_RISE, inland)
|
|
|
|
|
var height: float = PLATEAU_HEIGHT * rise + DOME_HEIGHT * _smooth(0.15, 1.1, inland) + 0.6
|
|
|
|
|
var raise: float = 0.0
|
|
|
|
|
for peak: Dictionary in peaks:
|
|
|
|
|
var reach: float = Vector2(x, z).distance_squared_to(peak["at"]) / pow(peak["radius"], 2.0)
|
|
|
|
|
raise = maxf(raise, peak["height"] * exp(-1.6 * reach))
|
|
|
|
|
for ridge: Dictionary in ridges:
|
|
|
|
|
var gap: float = _distance_to_segment(Vector2(x, z), ridge["from"], ridge["to"])
|
|
|
|
|
raise = maxf(raise, ridge["height"] * exp(-pow(gap / ridge["width"], 2.0)))
|
|
|
|
|
var inner: float = _smooth(0.08, 0.45, inland)
|
|
|
|
|
height += raise * inner
|
|
|
|
|
height += DETAIL_METRES * detail.get_noise_2d(x, z) * rise
|
|
|
|
|
# Rock grows with altitude, so highlands are craggy and lowlands rolling.
|
|
|
|
|
var altitude: float = clampf((height - PLATEAU_HEIGHT - DOME_HEIGHT) / 28.0, 0.0, 1.0)
|
|
|
|
|
height += ROCK_METRES * (rock.get_noise_2d(x, z) + 0.3) * altitude
|
|
|
|
|
heights[index] = height
|
|
|
|
|
wet[index] = moisture.get_noise_2d(x, z)
|
|
|
|
|
|
|
|
|
|
_scale_to_peak(heights, rng)
|
|
|
|
|
var band_data: PackedByteArray = PackedByteArray()
|
|
|
|
|
band_data.resize(side * side)
|
|
|
|
|
for index: int in heights.size():
|
|
|
|
|
var height: float = heights[index]
|
|
|
|
|
if height > 0.0 and height < Tuning.ISLAND_MARSH_TOP + 1.5 and wet[index] > MARSH_MOISTURE:
|
|
|
|
|
# Flatten wet lowland towards a marsh level just above the beach.
|
|
|
|
|
var weight: float = _smooth(MARSH_MOISTURE, MARSH_MOISTURE + 0.25, wet[index])
|
|
|
|
|
weight *= 1.0 - _smooth(Tuning.ISLAND_MARSH_TOP - 1.0, Tuning.ISLAND_MARSH_TOP + 1.5, height)
|
|
|
|
|
height = lerpf(height, maxf(MARSH_LEVEL, Tuning.ISLAND_BEACH_TOP + 0.3), weight)
|
|
|
|
|
heights[index] = height
|
|
|
|
|
band_data[index] = _classify(height, wet[index])
|
|
|
|
|
|
|
|
|
|
ground = SimGround.from_heights(heights, side, cell)
|
|
|
|
|
bands = band_data
|
|
|
|
|
for peak: Dictionary in peaks:
|
|
|
|
|
var at: Vector2 = peak["at"]
|
|
|
|
|
summits.append(Vector3(at.x, ground.terrain_height(at.x, at.y), at.y))
|
|
|
|
|
summits.sort_custom(func(a: Vector3, b: Vector3) -> bool: return a.y > b.y)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func _noise(noise_seed: int, frequency: float, octaves: int) -> FastNoiseLite:
|
|
|
|
|
var noise: FastNoiseLite = FastNoiseLite.new()
|
|
|
|
|
noise.noise_type = FastNoiseLite.TYPE_SIMPLEX_SMOOTH
|
|
|
|
|
noise.seed = noise_seed & 0x7FFFFFFF
|
|
|
|
|
noise.frequency = frequency
|
|
|
|
|
noise.fractal_type = FastNoiseLite.FRACTAL_FBM
|
|
|
|
|
noise.fractal_octaves = octaves
|
|
|
|
|
return noise
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Picks summit centres well inside the coast and far enough apart. The first is the
|
|
|
|
|
## tallest. Heights here are before scaling to the peak range.
|
|
|
|
|
func _place_summits(rng: RandomNumberGenerator, centre: Vector2, radius: float) -> Array[Dictionary]:
|
|
|
|
|
var count: int = rng.randi_range(Tuning.ISLAND_MIN_SUMMITS, Tuning.ISLAND_MAX_SUMMITS)
|
|
|
|
|
var peaks: Array[Dictionary] = []
|
|
|
|
|
var spacing: float = Tuning.ISLAND_SUMMIT_SPACING_METRES
|
|
|
|
|
var attempts: int = 0
|
|
|
|
|
while peaks.size() < count and attempts < 400:
|
|
|
|
|
attempts += 1
|
|
|
|
|
# Relax the spacing slowly if the island can't fit them all.
|
|
|
|
|
var needed: float = spacing * (1.0 - 0.3 * attempts / 400.0)
|
|
|
|
|
var angle: float = rng.randf() * TAU
|
|
|
|
|
var distance: float = radius * rng.randf_range(0.12, 0.55)
|
|
|
|
|
var at: Vector2 = centre + Vector2(cos(angle), sin(angle)) * distance
|
|
|
|
|
var clear: bool = true
|
|
|
|
|
for peak: Dictionary in peaks:
|
|
|
|
|
if at.distance_to(peak["at"]) < needed:
|
|
|
|
|
clear = false
|
|
|
|
|
break
|
|
|
|
|
if not clear:
|
|
|
|
|
continue
|
|
|
|
|
var height: float = 46.0 if peaks.is_empty() else rng.randf_range(30.0, 42.0)
|
|
|
|
|
peaks.append({"at": at, "height": height, "radius": rng.randf_range(95.0, 145.0)})
|
|
|
|
|
return peaks
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Joins each summit to its nearest neighbour with a lower ridge, giving highland spines.
|
|
|
|
|
func _link_summits(peaks: Array[Dictionary]) -> Array[Dictionary]:
|
|
|
|
|
var ridges: Array[Dictionary] = []
|
|
|
|
|
var linked: Dictionary = {}
|
|
|
|
|
for index: int in peaks.size():
|
|
|
|
|
var nearest: int = -1
|
|
|
|
|
var best: float = INF
|
|
|
|
|
for other: int in peaks.size():
|
|
|
|
|
var gap: float = (peaks[index]["at"] as Vector2).distance_to(peaks[other]["at"])
|
|
|
|
|
if other != index and gap < best:
|
|
|
|
|
best = gap
|
|
|
|
|
nearest = other
|
|
|
|
|
if nearest < 0:
|
|
|
|
|
continue
|
|
|
|
|
var key: Vector2i = Vector2i(mini(index, nearest), maxi(index, nearest))
|
|
|
|
|
if linked.has(key):
|
|
|
|
|
continue
|
|
|
|
|
linked[key] = true
|
|
|
|
|
var low: float = minf(peaks[index]["height"], peaks[nearest]["height"])
|
|
|
|
|
ridges.append({
|
|
|
|
|
"from": peaks[index]["at"], "to": peaks[nearest]["at"],
|
|
|
|
|
"height": low * RIDGE_FRACTION, "width": 50.0,
|
|
|
|
|
})
|
|
|
|
|
return ridges
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Scales land heights so the tallest point lands in the tuned peak range. The sea
|
|
|
|
|
## floor is left alone, so the coastline doesn't move.
|
|
|
|
|
func _scale_to_peak(heights: PackedFloat32Array, rng: RandomNumberGenerator) -> void:
|
|
|
|
|
var highest: float = 0.0
|
|
|
|
|
for value: float in heights:
|
|
|
|
|
highest = maxf(highest, value)
|
|
|
|
|
var target: float = rng.randf_range(Tuning.ISLAND_PEAK_MIN, Tuning.ISLAND_PEAK_MAX)
|
|
|
|
|
var factor: float = target / highest
|
|
|
|
|
for index: int in heights.size():
|
|
|
|
|
if heights[index] > 0.0:
|
|
|
|
|
heights[index] *= factor
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func _classify(height: float, wetness: float) -> int:
|
|
|
|
|
if height <= 0.0:
|
|
|
|
|
return Band.SEA
|
|
|
|
|
if height < Tuning.ISLAND_BEACH_TOP:
|
|
|
|
|
return Band.BEACH
|
|
|
|
|
if height < Tuning.ISLAND_MARSH_TOP and wetness > MARSH_MOISTURE:
|
|
|
|
|
return Band.MARSH
|
|
|
|
|
if height < Tuning.ISLAND_FOREST_TOP:
|
|
|
|
|
return Band.FOREST
|
|
|
|
|
if height < Tuning.ISLAND_SUMMIT_BAND:
|
|
|
|
|
return Band.HIGHLAND
|
|
|
|
|
return Band.SUMMIT
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static func _smooth(from: float, to: float, value: float) -> float:
|
|
|
|
|
return smoothstep(from, to, value)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static func _distance_to_segment(point: Vector2, from: Vector2, to: Vector2) -> float:
|
|
|
|
|
var span: Vector2 = to - from
|
|
|
|
|
var t: float = clampf((point - from).dot(span) / maxf(span.length_squared(), 0.0001), 0.0, 1.0)
|
|
|
|
|
return point.distance_to(from + span * t)
|