## Where the sea actually is. The tide sets one sea level, but water only reaches ground ## it can flow to: from the world's edge, through cells whose lowest ground is under the ## sea, and across cell edges that no breakwater seals. Low ground cut off by higher ## land or by a breakwater ring stays dry until the sea overtops what holds it back, or ## a breakwater breaks. Then the water pours in, and the newly reached cells fill at ## Tuning.BREACH_FLOW_METRES_PER_SECOND until they stand level with the sea. ## ## The grid's cells are Tuning.FLOOD_CELL_METRES square and line up with the building ## grid, so breakwaters stand exactly on cell edges. A cell's floor is the lowest terrain ## in it. Water never drains: once a cell is flooded it stays flooded. ## ## Updating is incremental. The flood remembers every edge where it was stopped, and ## re-tests only those when the sea rises or breakwaters change. class_name Flood extends RefCounted ## level_at() for a cell the sea doesn't reach. const NO_WATER: float = -1000.0 ## No breakwater stack yet on an edge, while reading barriers. const NO_STACK: int = -1000000 ## Neighbour steps by direction: +x, -x, +z, -z. const STEPS: Array[Vector2i] = [Vector2i(1, 0), Vector2i(-1, 0), Vector2i(0, 1), Vector2i(0, -1)] var side: int = 0 var cell: float = Tuning.FLOOD_CELL_METRES ## Per cell: lowest terrain, flooded (1) or not, and the filling group it belongs to (-1 ## once it stands level with the sea). var floors: PackedFloat32Array = PackedFloat32Array() var flooded: PackedByteArray = PackedByteArray() var fill_group: PackedInt32Array = PackedInt32Array() ## The sea level the flood was last spread for. var sea_level: float = Tuning.SEA_LEVEL_START ## Counts every pour, so a view can tell the flooded cells changed without comparing ## them. Not match state. var pours: int = 0 ## Filling groups: group ID -> {"level": float, "cells": PackedInt32Array}. var _groups: Dictionary = {} var _next_group: int = 0 ## Edges the water was stopped at, as cell * 4 + direction, in the order found. var _blocked: Dictionary = {} ## Sealed edges: edge key -> height of the breakwater top. See edge_key(). var _barriers: Dictionary = {} ## StructureSet next ID and piece count when barriers were last read. var _structures_seen: Vector2i = Vector2i(-1, -1) ## Builds the flood grid over `ground` and floods everything the starting sea reaches. static func create(ground: SimGround, level: float = Tuning.SEA_LEVEL_START) -> Flood: var flood: Flood = Flood.new() flood.side = ceili(Tuning.WORLD_SIZE_METRES / flood.cell) var count: int = flood.side * flood.side flood.floors.resize(count) flood.flooded.resize(count) flood.fill_group.resize(count) flood.fill_group.fill(-1) var per_cell: int = roundi(flood.cell / ground.cell) var direct: bool = is_equal_approx(per_cell * ground.cell, flood.cell) and (flood.side * per_cell) < ground.samples for cz: int in flood.side: for cx: int in flood.side: var lowest: float = INF if direct: # Read the heightfield samples in and around the cell straight from the array. for gz: int in range(cz * per_cell, cz * per_cell + per_cell + 1): var row: int = gz * ground.samples for gx: int in range(cx * per_cell, cx * per_cell + per_cell + 1): lowest = minf(lowest, ground.heights[row + gx]) else: for sz: int in 3: for sx: int in 3: lowest = minf(lowest, ground.terrain_height((cx + sx * 0.5) * flood.cell, (cz + sz * 0.5) * flood.cell)) flood.floors[cz * flood.side + cx] = lowest flood.sea_level = level # The open sea: every border cell under the starting level, filled at once. var start: PackedInt32Array = PackedInt32Array() for index: int in flood.side: for border: int in [index, (flood.side - 1) * flood.side + index, index * flood.side, index * flood.side + flood.side - 1]: if flood.flooded[border] == 0 and flood.floors[border] < level: flood.flooded[border] = 1 start.append(border) flood._spread(start) return flood ## The flood cell under a world point. func cell_of(x: float, z: float) -> int: var cx: int = clampi(floori(x / cell), 0, side - 1) var cz: int = clampi(floori(z / cell), 0, side - 1) return cz * side + cx ## Height of the water surface over the cell at a world point, or NO_WATER if the sea ## doesn't reach it. May be below the ground while a breached basin is still filling. func level_at(x: float, z: float) -> float: return level_of_cell(cell_of(x, z)) func level_of_cell(index: int) -> float: if flooded[index] == 0: return NO_WATER var group: int = fill_group[index] if group >= 0: return minf(float(_groups[group]["level"]), sea_level) return sea_level func is_flooded(x: float, z: float) -> bool: return flooded[cell_of(x, z)] != 0 ## Number of flooded cells. func flooded_count() -> int: return flooded.count(1) ## Key of the edge between cell (cx - 1, cz) and (cx, cz) for axis 0, or (cx, cz - 1) and ## (cx, cz) for axis 1. The same numbering as StructureSet's wall slots. func edge_key(cx: int, cz: int, axis: int) -> int: return (cz * side + cx) * 2 + axis ## The top of the breakwater sealing the edge between neighbouring cells, or -INF. func barrier_between(a: int, b: int) -> float: var ax: int = a % side var bx: int = b % side var key: int if ax != bx: key = edge_key(maxi(ax, bx), a / side, 0) else: key = edge_key(ax, maxi(a / side, b / side), 1) return float(_barriers.get(key, -INF)) ## Reads breakwaters from `structures` if it changed since last time. Returns true if ## it did. func refresh_barriers(structures: StructureSet) -> bool: var seen: Vector2i = Vector2i(structures.next_id(), structures.count()) if seen == _structures_seen: return false _structures_seen = seen # Breakwater levels by edge, then each edge's sealed height: a stack of breakwaters # from the ground up (the lowest may hang one level over lower ground, as its skirt # fills the gap), each starting no higher than the one under it ends. var levels: Dictionary = {} for piece: StructureSet.Piece in structures.pieces.values(): if piece.kind != StructureSet.BREAKWATER: continue var axis: int = 0 if piece.slot.w == StructureSet.SLOT_WALL_X else 1 if piece.slot.x < 0 or piece.slot.z < 0 or piece.slot.x >= side or piece.slot.z >= side: continue var key: int = edge_key(piece.slot.x, piece.slot.z, axis) if not levels.has(key): levels[key] = PackedInt32Array() levels[key].append(piece.slot.y) _barriers.clear() var piece_levels: int = roundi(Tuning.GRID_CELL_METRES / Tuning.BUILD_LEVEL_METRES) for key: int in levels: var stack: PackedInt32Array = levels[key] stack.sort() var index: int = key / 2 var cx: int = index % side var cz: int = index / side var other: int = (index - 1) if key % 2 == 0 else (index - side) if (key % 2 == 0 and cx == 0) or (key % 2 == 1 and cz == 0): continue var edge_floor: float = maxf(floors[index], floors[other]) var top_level: int = NO_STACK for level: int in stack: if top_level == NO_STACK: if level * Tuning.BUILD_LEVEL_METRES > edge_floor + Tuning.BUILD_LEVEL_METRES: break top_level = level + piece_levels elif level <= top_level: top_level = maxi(top_level, level + piece_levels) else: break if top_level != NO_STACK: _barriers[key] = top_level * Tuning.BUILD_LEVEL_METRES return true ## Spreads the water for a new sea level and the current breakwaters, and advances ## filling basins by `seconds` of flow. Returns how many cells newly flooded. func update(level: float, structures: StructureSet, seconds: float) -> int: sea_level = level if structures != null: refresh_barriers(structures) var reached: int = 0 var edges: Array = _blocked.keys() for key: int in edges: if not _blocked.has(key): continue var from: int = key / 4 var to: int = _neighbour(from, key % 4) if flooded[to] != 0: _blocked.erase(key) continue if _passable(from, to): _blocked.erase(key) reached += _pour(to) _advance_groups(seconds) return reached ## Follows the sea level and advances filling basins, without re-spreading. Cheap ## enough for every tick. func flow(level: float, seconds: float) -> void: sea_level = level _advance_groups(seconds) ## Writes the flooded cells, filling groups and barriers, for Simulation.state_hash(). func write_state(buffer: StreamPeerBuffer) -> void: buffer.put_64(roundi(sea_level * 1000.0)) buffer.put_data(flooded) buffer.put_64(_groups.size()) for group: int in _groups: buffer.put_32(group) buffer.put_64(roundi(float(_groups[group]["level"]) * 1000.0)) buffer.put_64(_barriers.size()) func _neighbour(index: int, direction: int) -> int: var step: Vector2i = STEPS[direction] var x: int = index % side + step.x var z: int = index / side + step.y if x < 0 or z < 0 or x >= side or z >= side: return -1 return z * side + x func _passable(from: int, to: int) -> bool: return floors[to] < sea_level and barrier_between(from, to) < sea_level ## Water pours across an edge into `to`, and on through everything it can reach. The ## reached cells fill together, from their lowest floor up. func _pour(to: int) -> int: pours += 1 flooded[to] = 1 var queue: PackedInt32Array = PackedInt32Array([to]) _spread(queue) var group: int = _next_group _next_group += 1 var bottom: float = INF for index: int in queue: bottom = minf(bottom, floors[index]) _groups[group] = {"level": bottom, "cells": queue} for index: int in queue: fill_group[index] = group return queue.size() ## Breadth-first flood from the cells in `queue`, which must already be marked flooded. ## Appends every newly flooded cell to `queue` and records where the water stopped. func _spread(queue: PackedInt32Array) -> void: var head: int = 0 while head < queue.size(): var index: int = queue[head] head += 1 for direction: int in 4: var next: int = _neighbour(index, direction) if next < 0 or flooded[next] != 0: continue if _passable(index, next): flooded[next] = 1 queue.append(next) else: _blocked[index * 4 + direction] = true func _advance_groups(seconds: float) -> void: if _groups.is_empty(): return var done: Array[int] = [] for group: int in _groups: var entry: Dictionary = _groups[group] entry["level"] = float(entry["level"]) + Tuning.BREACH_FLOW_METRES_PER_SECOND * seconds if float(entry["level"]) >= sea_level: done.append(group) for group: int in done: for index: int in _groups[group]["cells"]: if fill_group[index] == group: fill_group[index] = -1 _groups.erase(group)