## 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)