netfishing/world/generation/terrain_chunk_generator.gd

class_name TerrainChunkGenerator
extends Node3D

signal generation_completed(summary: Dictionary)

const CONSTRAINT_PROFILE_QUANTIZATION := 0.001
const CANDIDATE_WEIGHT_SCALE := 10000.0

@export var catalog: TerrainChunkCatalog
@export var grid_size := Vector2i(7, 7)
@export var generation_seed := 13001
@export var generate_on_ready := true
@export var build_collision := true
@export var show_chunk_labels := false
@export var force_center_chunk_id: StringName = &"chunk_0000"
@export var required_chunk_ids := PackedStringArray()
@export_range(1.0, 100.0, 1.0) var required_chunk_weight_multiplier := 64.0
@export_range(1.0, 4.0, 0.05) var preferred_neighbor_weight_multiplier := 1.6
@export_range(0.01, 1.0, 0.01) var long_repeat_weight_multiplier := 0.3
@export_range(1.0, 10.0, 0.1) var boundary_preference_multiplier := 4.0
@export_range(0.001, 0.1, 0.001) var edge_match_tolerance := 0.01
@export_range(1, 100000, 1) var maximum_backtracks := 20000

# Every allowed authored rotation remains available for visual placement.
var _variants: Array[TerrainChunkVariant] = []
# Rotations with identical terrain edges and connector directions share one
# solver candidate, then resolve back to an authored rotation after solving.
var _solver_variants: Array[TerrainChunkVariant] = []
var _equivalent_rotations: Dictionary[String, PackedInt32Array] = {}
var _solver_variant_indices: Dictionary = {}
var _edge_compatibility := PackedByteArray()
var _placements: Array[TerrainChunkVariant] = []
var _random := RandomNumberGenerator.new()
var _generated_chunks: Node3D
var _backtrack_count := 0


func _ready() -> void:
	if generate_on_ready:
		call_deferred(&"generate")


func generate() -> bool:
	if not _prepare_catalog():
		return false
	var previous_placements: Array[TerrainChunkVariant] = []
	previous_placements.assign(_placements)
	_random.seed = generation_seed
	_backtrack_count = 0
	_placements.clear()
	_placements.resize(grid_size.x * grid_size.y)
	if not _solve_cell(0):
		_placements.assign(previous_placements)
		push_error(
			"Terrain generation could not solve a %dx%d grid with seed %d."
			% [grid_size.x, grid_size.y, generation_seed]
		)
		return false
	_resolve_equivalent_rotations()
	var solution_root := _build_solution_root()
	if solution_root == null:
		_placements.assign(previous_placements)
		return false
	_replace_generated_chunks(solution_root)
	var summary := _build_summary()
	generation_completed.emit(summary)
	return true


func generate_from_placement_keys(keys: PackedStringArray) -> bool:
	if not _prepare_catalog():
		return false
	if keys.size() != grid_size.x * grid_size.y:
		push_error(
			"Terrain layout contains %d cells; expected %d."
			% [keys.size(), grid_size.x * grid_size.y]
		)
		return false
	var variants_by_key: Dictionary[String, TerrainChunkVariant] = {}
	for variant: TerrainChunkVariant in _variants:
		variants_by_key[variant.stable_key()] = variant
	var resolved: Array[TerrainChunkVariant] = []
	for key: String in keys:
		var variant: TerrainChunkVariant = variants_by_key.get(key)
		if variant == null:
			push_error("Terrain layout references unknown variant %s." % key)
			return false
		resolved.append(variant)
	var validation_error := _resolved_layout_validation_error(resolved)
	if not validation_error.is_empty():
		push_error("Terrain layout is invalid: " + validation_error)
		return false

	var previous_placements: Array[TerrainChunkVariant] = []
	previous_placements.assign(_placements)
	_placements.assign(resolved)
	_backtrack_count = 0
	var solution_root := _build_solution_root()
	if solution_root == null:
		_placements.assign(previous_placements)
		return false
	_replace_generated_chunks(solution_root)
	var summary := _build_summary()
	generation_completed.emit(summary)
	return true


func _resolved_layout_validation_error(
	layout: Array[TerrainChunkVariant],
) -> String:
	var counts: Dictionary[StringName, int] = {}
	for variant: TerrainChunkVariant in layout:
		if variant == null:
			return "one or more cells are empty."
		var stable_id := variant.definition.stable_id
		counts[stable_id] = counts.get(stable_id, 0) + 1
		var maximum := variant.definition.maximum_placements
		if maximum >= 0 and counts[stable_id] > maximum:
			return "%s exceeds its placement limit." % stable_id
	for required_id_value: String in required_chunk_ids:
		var required_id := StringName(required_id_value)
		if counts.get(required_id, 0) <= 0:
			return "required chunk %s is missing." % required_id
	if force_center_chunk_id != &"":
		var center := Vector2i(grid_size.x / 2, grid_size.y / 2)
		var center_index := center.y * grid_size.x + center.x
		if layout[center_index].definition.stable_id != force_center_chunk_id:
			return "the forced center chunk is missing from the center cell."
	for index: int in layout.size():
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		var current := layout[index]
		if not _variant_respects_ocean_boundary(current, coordinate):
			return (
				"cell %d has an ocean-facing edge directed into the terrain grid."
				% index
			)
		if coordinate.x + 1 < grid_size.x:
			var east := layout[index + 1]
			if not _edges_are_compatible(
				current,
				TerrainChunkTopology.Edge.EAST,
				east,
				TerrainChunkTopology.Edge.WEST,
			):
				return "cells %d and %d have incompatible east/west edges." % [
					index,
					index + 1,
				]
		if coordinate.y + 1 < grid_size.y:
			var south := layout[index + grid_size.x]
			if not _edges_are_compatible(
				current,
				TerrainChunkTopology.Edge.SOUTH,
				south,
				TerrainChunkTopology.Edge.NORTH,
			):
				return "cells %d and %d have incompatible south/north edges." % [
					index,
					index + grid_size.x,
				]
	var neighbor_error := _neighbor_requirement_validation_error(layout)
	if not neighbor_error.is_empty():
		return neighbor_error
	return _walkable_connectivity_validation_error(layout)


func _prepare_catalog() -> bool:
	if catalog == null:
		push_error("TerrainChunkGenerator requires a catalog.")
		return false
	if grid_size.x <= 0 or grid_size.y <= 0:
		push_error("TerrainChunkGenerator grid dimensions must be positive.")
		return false
	var catalog_errors := catalog.validation_errors()
	if not catalog_errors.is_empty():
		push_error("Terrain chunk catalog is invalid:\n" + "\n".join(catalog_errors))
		return false
	if not _validate_generation_requirements():
		return false

	_variants.clear()
	_solver_variants.clear()
	_equivalent_rotations.clear()
	_solver_variant_indices.clear()
	for definition: TerrainChunkDefinition in catalog.definitions:
		var analyzed := TerrainChunkAnalyzer.create_variants(
			definition,
			catalog.chunk_size,
		)
		if analyzed.is_empty():
			push_error(
				"Terrain chunk %s produced no usable rotation variants."
				% definition.stable_id
			)
			return false
		for variant: TerrainChunkVariant in analyzed:
			_variants.append(variant)
			var constraint_key := _constraint_key(variant)
			var rotations: PackedInt32Array = _equivalent_rotations.get(
				constraint_key,
				PackedInt32Array(),
			)
			rotations.append(variant.quarter_turns)
			_equivalent_rotations[constraint_key] = rotations
			if rotations.size() == 1:
				_solver_variants.append(variant)
	if _variants.is_empty():
		push_error("Terrain chunk catalog produced no usable variants.")
		return false
	for index: int in _solver_variants.size():
		_solver_variant_indices[_solver_variants[index]] = index
	_build_edge_compatibility_cache()
	return true


func _constraint_key(variant: TerrainChunkVariant) -> String:
	return "%s|%s" % [
		variant.definition.stable_id,
		variant.constraint_signature(CONSTRAINT_PROFILE_QUANTIZATION),
	]


func _build_edge_compatibility_cache() -> void:
	var variant_count := _solver_variants.size()
	_edge_compatibility.resize(variant_count * 4 * variant_count)
	_edge_compatibility.fill(0)
	for first_index: int in variant_count:
		var first := _solver_variants[first_index]
		for first_edge_value: int in TerrainChunkTopology.Edge.values():
			var first_edge := first_edge_value as TerrainChunkTopology.Edge
			var second_edge := TerrainChunkTopology.opposite_edge(first_edge)
			for second_index: int in variant_count:
				var second := _solver_variants[second_index]
				var cache_index := _edge_compatibility_index(
					first_index,
					first_edge,
					second_index,
				)
				_edge_compatibility[cache_index] = int(
					_calculate_edge_compatibility(
					first,
					first_edge,
					second,
					second_edge,
					)
				)


func _edge_compatibility_index(
	first_index: int,
	first_edge: TerrainChunkTopology.Edge,
	second_index: int,
) -> int:
	var variant_count := _solver_variants.size()
	return (
		(first_index * 4 + int(first_edge)) * variant_count
		+ second_index
	)


func _validate_generation_requirements() -> bool:
	var seen_required: Dictionary[StringName, bool] = {}
	for required_id_value: String in required_chunk_ids:
		var required_id := StringName(required_id_value)
		if seen_required.has(required_id):
			continue
		seen_required[required_id] = true
		var definition := catalog.definition_for_id(required_id)
		if definition == null:
			push_error("Required terrain chunk %s is not in the catalog." % required_id)
			return false
		if definition.maximum_placements == 0:
			push_error("Required terrain chunk %s permits no placements." % required_id)
			return false
	if seen_required.size() > grid_size.x * grid_size.y:
		push_error("The terrain grid has fewer cells than required chunk IDs.")
		return false
	if force_center_chunk_id != &"":
		var center_definition := catalog.definition_for_id(force_center_chunk_id)
		if center_definition == null:
			push_error(
				"Forced center terrain chunk %s is not in the catalog."
				% force_center_chunk_id
			)
			return false
		if center_definition.maximum_placements == 0:
			push_error(
				"Forced center terrain chunk %s permits no placements."
				% force_center_chunk_id
			)
			return false
	return true


func _solve_cell(placed_count: int) -> bool:
	if placed_count >= _placements.size():
		return (
			_required_chunks_are_present()
			and _neighbor_requirement_validation_error(_placements).is_empty()
			and _walkable_connectivity_validation_error(_placements).is_empty()
		)
	if _backtrack_count >= maximum_backtracks:
		return false
	if not _requirements_can_still_be_satisfied():
		return false
	var next_cell := _select_next_cell()
	var index := int(next_cell.get("index", -1))
	if index < 0:
		return false
	var candidates := next_cell.get(
		"candidates",
		[],
	) as Array[TerrainChunkVariant]
	for candidate: TerrainChunkVariant in _weighted_candidate_order(
		candidates,
		index,
	):
		_placements[index] = candidate
		if _solve_cell(placed_count + 1):
			return true
		_placements[index] = null
		_backtrack_count += 1
		if _backtrack_count >= maximum_backtracks:
			break
	return false


func _select_next_cell() -> Dictionary:
	# Rebuild and propagate the small domain table on every branch. This catches
	# unsupported connector chains before they turn into a deep recursive dead
	# end, while keeping placement state simple and deterministic.
	var domains: Dictionary = {}
	for index: int in _placements.size():
		if _placements[index] != null:
			continue
		var candidates := _compatible_candidates(index)
		if candidates.is_empty():
			return {"index": index, "candidates": candidates}
		domains[index] = candidates
	if not _propagate_domains(domains):
		return {"index": -1, "candidates": []}

	# Minimum-remaining-values traversal exposes contradictions before a long
	# row-major branch has already filled most of the map.
	var best_index := -1
	var best_candidates: Array[TerrainChunkVariant] = []
	for index_value: Variant in domains:
		var index := int(index_value)
		var candidates: Array[TerrainChunkVariant] = []
		candidates.assign(domains[index])
		if best_index < 0 or candidates.size() < best_candidates.size():
			best_index = index
			best_candidates = candidates
			if candidates.size() == 1:
				break
	return {"index": best_index, "candidates": best_candidates}


func _propagate_domains(domains: Dictionary) -> bool:
	var changed := true
	while changed:
		changed = false
		for index_value: Variant in domains.keys():
			var index := int(index_value)
			var candidates: Array[TerrainChunkVariant] = []
			candidates.assign(domains[index])
			var supported: Array[TerrainChunkVariant] = []
			for candidate: TerrainChunkVariant in candidates:
				if _candidate_has_domain_support(candidate, index, domains):
					supported.append(candidate)
			if supported.is_empty():
				return false
			if supported.size() != candidates.size():
				domains[index] = supported
				changed = true
		var required_result := _constrain_required_domains(domains)
		if required_result < 0:
			return false
		if required_result > 0:
			changed = true
		if not _placed_neighbor_requirements_have_domain_support(domains):
			return false
	return true


func _candidate_has_domain_support(
	candidate: TerrainChunkVariant,
	index: int,
	domains: Dictionary,
) -> bool:
	var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
	var possible_required_neighbors := 0
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var edge := edge_value as TerrainChunkTopology.Edge
		var neighbor_coordinate := (
			coordinate + TerrainChunkTopology.grid_offset(edge)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		var neighbor_index := (
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		)
		var placed_neighbor := _placements[neighbor_index]
		if placed_neighbor != null:
			if _definition_matches_required_neighbor_tags(
				candidate.definition,
				placed_neighbor.definition,
			):
				possible_required_neighbors += 1
			continue
		var neighbor_candidates: Array[TerrainChunkVariant] = []
		neighbor_candidates.assign(domains.get(neighbor_index, []))
		var has_support := false
		var has_required_support := false
		for neighbor: TerrainChunkVariant in neighbor_candidates:
			if not _definitions_have_joint_capacity(
				candidate.definition,
				neighbor.definition,
			):
				continue
			if _edges_are_compatible(
				candidate,
				edge,
				neighbor,
				TerrainChunkTopology.opposite_edge(edge),
			):
				has_support = true
				if _definition_matches_required_neighbor_tags(
					candidate.definition,
					neighbor.definition,
				):
					has_required_support = true
		if not has_support:
			return false
		if has_required_support:
			possible_required_neighbors += 1
	return (
		possible_required_neighbors
		>= candidate.definition.minimum_required_neighbors
	)


func _placed_neighbor_requirements_have_domain_support(
	domains: Dictionary,
) -> bool:
	for index: int in _placements.size():
		var placement := _placements[index]
		if placement == null or placement.definition.minimum_required_neighbors <= 0:
			continue
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		var possible_neighbors := 0
		for edge_value: int in TerrainChunkTopology.Edge.values():
			var edge := edge_value as TerrainChunkTopology.Edge
			var neighbor_coordinate := (
				coordinate + TerrainChunkTopology.grid_offset(edge)
			)
			if not _coordinate_is_inside_grid(neighbor_coordinate):
				continue
			var neighbor_index := (
				neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
			)
			var neighbor := _placements[neighbor_index]
			if neighbor != null:
				if _definition_matches_required_neighbor_tags(
					placement.definition,
					neighbor.definition,
				):
					possible_neighbors += 1
				continue
			var domain_candidates: Array[TerrainChunkVariant] = []
			domain_candidates.assign(domains.get(neighbor_index, []))
			for candidate: TerrainChunkVariant in domain_candidates:
				if (
					_definition_matches_required_neighbor_tags(
						placement.definition,
						candidate.definition,
					)
					and _edges_are_compatible(
						placement,
						edge,
						candidate,
						TerrainChunkTopology.opposite_edge(edge),
					)
				):
					possible_neighbors += 1
					break
		if possible_neighbors < placement.definition.minimum_required_neighbors:
			return false
	return true


func _definition_matches_required_neighbor_tags(
	definition: TerrainChunkDefinition,
	neighbor: TerrainChunkDefinition,
) -> bool:
	return (
		definition != null
		and neighbor != null
		and TerrainChunkDefinition.has_any_tag(
			neighbor.tags,
			definition.required_neighbor_tags,
		)
	)


func _definitions_have_joint_capacity(
	first: TerrainChunkDefinition,
	second: TerrainChunkDefinition,
) -> bool:
	if first != second or first.maximum_placements < 0:
		return true
	return (
		_definition_placement_count(first) + 2
		<= first.maximum_placements
	)


## Returns -1 for a contradiction, 0 for no change, or 1 when at least one
## required definition was forced into its only remaining cell.
func _constrain_required_domains(domains: Dictionary) -> int:
	var changed := false
	for stable_id: StringName in _missing_required_ids():
		var supporting_cells: Array[int] = []
		for index_value: Variant in domains:
			var index := int(index_value)
			for candidate: TerrainChunkVariant in domains[index]:
				if candidate.definition.stable_id == stable_id:
					supporting_cells.append(index)
					break
		if supporting_cells.is_empty():
			return -1
		if supporting_cells.size() != 1:
			continue
		var forced_index := supporting_cells[0]
		var forced_candidates: Array[TerrainChunkVariant] = []
		for candidate: TerrainChunkVariant in domains[forced_index]:
			if candidate.definition.stable_id == stable_id:
				forced_candidates.append(candidate)
		if forced_candidates.is_empty():
			return -1
		if forced_candidates.size() != domains[forced_index].size():
			domains[forced_index] = forced_candidates
			changed = true
	return 1 if changed else 0


func _compatible_candidates(index: int) -> Array[TerrainChunkVariant]:
	var result: Array[TerrainChunkVariant] = []
	var missing_required := _missing_required_ids()
	var remaining_cells := _unfilled_cell_count()
	var must_place_missing_required := missing_required.size() >= remaining_cells
	for candidate: TerrainChunkVariant in _solver_variants:
		if (
			must_place_missing_required
			and not missing_required.has(candidate.definition.stable_id)
		):
			continue
		if not _candidate_can_occupy_cell(candidate, index):
			continue
		result.append(candidate)
	return result


func _candidate_can_occupy_cell(
	candidate: TerrainChunkVariant,
	index: int,
) -> bool:
	if not _definition_has_capacity(candidate.definition):
		return false
	var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
	var center := Vector2i(grid_size.x / 2, grid_size.y / 2)
	var center_index := center.y * grid_size.x + center.x
	if (
		coordinate == center
		and force_center_chunk_id != &""
		and candidate.definition.stable_id != force_center_chunk_id
	):
		return false
	if (
		index != center_index
		and _placements[center_index] == null
		and candidate.definition.stable_id == force_center_chunk_id
		and candidate.definition.maximum_placements >= 0
		and _definition_placement_count(candidate.definition)
		>= candidate.definition.maximum_placements - 1
	):
		return false
	return (
		_variant_respects_ocean_boundary(candidate, coordinate)
		and _candidate_matches_placed_neighbors(candidate, coordinate)
		and _candidate_neighbor_requirement_can_still_be_met(
			candidate.definition,
			coordinate,
		)
		and _candidate_preserves_placed_neighbor_requirements(
			candidate.definition,
			coordinate,
		)
	)


func _variant_respects_ocean_boundary(
	variant: TerrainChunkVariant,
	coordinate: Vector2i,
) -> bool:
	var ocean_edges := variant.rotated_edge_mask(
		variant.definition.ocean_facing_edges
	)
	for edge_value: int in TerrainChunkTopology.Edge.values():
		if (ocean_edges & (1 << edge_value)) == 0:
			continue
		var ocean_coordinate := (
			coordinate
			+ TerrainChunkTopology.grid_offset(
				edge_value as TerrainChunkTopology.Edge
			)
		)
		if _coordinate_is_inside_grid(ocean_coordinate):
			return false
	return true


func _candidate_matches_placed_neighbors(
	candidate: TerrainChunkVariant,
	coordinate: Vector2i,
) -> bool:
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var edge := edge_value as TerrainChunkTopology.Edge
		var neighbor_coordinate := (
			coordinate + TerrainChunkTopology.grid_offset(edge)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		var neighbor_index := (
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		)
		var neighbor := _placements[neighbor_index]
		if neighbor == null:
			continue
		if not _edges_are_compatible(
			candidate,
			edge,
			neighbor,
			TerrainChunkTopology.opposite_edge(edge),
		):
			return false
	return true


func _coordinate_is_inside_grid(coordinate: Vector2i) -> bool:
	return (
		coordinate.x >= 0
		and coordinate.y >= 0
		and coordinate.x < grid_size.x
		and coordinate.y < grid_size.y
	)


func _candidate_neighbor_requirement_can_still_be_met(
	definition: TerrainChunkDefinition,
	coordinate: Vector2i,
) -> bool:
	if definition.minimum_required_neighbors <= 0:
		return true
	var possible_neighbors := 0
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var neighbor_coordinate := (
			coordinate
			+ TerrainChunkTopology.grid_offset(
				edge_value as TerrainChunkTopology.Edge
			)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		var neighbor := _placements[
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		]
		if (
			neighbor == null
			or _definition_matches_required_neighbor_tags(
				definition,
				neighbor.definition,
			)
		):
			possible_neighbors += 1
	return possible_neighbors >= definition.minimum_required_neighbors


func _candidate_preserves_placed_neighbor_requirements(
	definition: TerrainChunkDefinition,
	coordinate: Vector2i,
) -> bool:
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var neighbor_coordinate := (
			coordinate
			+ TerrainChunkTopology.grid_offset(
				edge_value as TerrainChunkTopology.Edge
			)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		var neighbor := _placements[
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		]
		if neighbor == null or neighbor.definition.minimum_required_neighbors <= 0:
			continue
		if not _placed_requirement_can_still_be_met_with_candidate(
			neighbor.definition,
			neighbor_coordinate,
			definition,
			coordinate,
		):
			return false
	return true


func _placed_requirement_can_still_be_met_with_candidate(
	definition: TerrainChunkDefinition,
	coordinate: Vector2i,
	candidate_definition: TerrainChunkDefinition,
	candidate_coordinate: Vector2i,
) -> bool:
	var possible_neighbors := 0
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var neighbor_coordinate := (
			coordinate
			+ TerrainChunkTopology.grid_offset(
				edge_value as TerrainChunkTopology.Edge
			)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		if neighbor_coordinate == candidate_coordinate:
			if _definition_matches_required_neighbor_tags(
				definition,
				candidate_definition,
			):
				possible_neighbors += 1
			continue
		var neighbor := _placements[
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		]
		if (
			neighbor == null
			or _definition_matches_required_neighbor_tags(
				definition,
				neighbor.definition,
			)
		):
			possible_neighbors += 1
	return possible_neighbors >= definition.minimum_required_neighbors


func _definition_has_capacity(definition: TerrainChunkDefinition) -> bool:
	if definition.maximum_placements < 0:
		return true
	return _definition_placement_count(definition) < definition.maximum_placements


func _definition_placement_count(definition: TerrainChunkDefinition) -> int:
	var count := 0
	for placement: TerrainChunkVariant in _placements:
		if placement != null and placement.definition == definition:
			count += 1
	return count


func _edges_are_compatible(
	first: TerrainChunkVariant,
	first_edge: TerrainChunkTopology.Edge,
	second: TerrainChunkVariant,
	second_edge: TerrainChunkTopology.Edge,
) -> bool:
	if (
		second_edge == TerrainChunkTopology.opposite_edge(first_edge)
		and _solver_variant_indices.has(first)
		and _solver_variant_indices.has(second)
	):
		var cache_index := _edge_compatibility_index(
			int(_solver_variant_indices[first]),
			first_edge,
			int(_solver_variant_indices[second]),
		)
		return _edge_compatibility[cache_index] != 0
	return _calculate_edge_compatibility(
		first,
		first_edge,
		second,
		second_edge,
	)


func _calculate_edge_compatibility(
	first: TerrainChunkVariant,
	first_edge: TerrainChunkTopology.Edge,
	second: TerrainChunkVariant,
	second_edge: TerrainChunkTopology.Edge,
) -> bool:
	if not first.profile(first_edge).matches(
		second.profile(second_edge),
		edge_match_tolerance,
	):
		return false
	var first_inlet := _variant_edge_has_connector(
		first,
		first.definition.water_inlet_edges,
		first_edge,
	)
	var first_outlet := _variant_edge_has_connector(
		first,
		first.definition.water_outlet_edges,
		first_edge,
	)
	var second_inlet := _variant_edge_has_connector(
		second,
		second.definition.water_inlet_edges,
		second_edge,
	)
	var second_outlet := _variant_edge_has_connector(
		second,
		second.definition.water_outlet_edges,
		second_edge,
	)
	var first_has_water := first_inlet or first_outlet
	var second_has_water := second_inlet or second_outlet
	if first_has_water or second_has_water:
		return (
			(first_outlet and second_inlet)
			or (first_inlet and second_outlet)
		)
	return (
		first.allows_non_water_neighbor_on_edge(second, first_edge)
		and second.allows_non_water_neighbor_on_edge(first, second_edge)
	)


func _variant_edge_has_connector(
	variant: TerrainChunkVariant,
	source_mask: int,
	edge: TerrainChunkTopology.Edge,
) -> bool:
	return (variant.rotated_edge_mask(source_mask) & (1 << int(edge))) != 0


func _required_chunks_are_present() -> bool:
	return _missing_required_ids().is_empty()


func _requirements_can_still_be_satisfied() -> bool:
	var missing_required := _missing_required_ids()
	if missing_required.size() > _unfilled_cell_count():
		return false
	for stable_id: StringName in missing_required:
		var definition := catalog.definition_for_id(stable_id)
		if definition == null or not _definition_has_capacity(definition):
			return false
		if not _definition_has_available_cell(definition):
			return false
	return true


func _definition_has_available_cell(
	definition: TerrainChunkDefinition,
) -> bool:
	for index: int in _placements.size():
		if _placements[index] != null:
			continue
		for candidate: TerrainChunkVariant in _solver_variants:
			if (
				candidate.definition == definition
				and _candidate_can_occupy_cell(candidate, index)
			):
				return true
	return false


func _unfilled_cell_count() -> int:
	var count := 0
	for placement: TerrainChunkVariant in _placements:
		if placement == null:
			count += 1
	return count


func _missing_required_ids() -> Array[StringName]:
	var found: Dictionary[StringName, bool] = {}
	for placement: TerrainChunkVariant in _placements:
		if placement != null:
			found[placement.definition.stable_id] = true
	var result: Array[StringName] = []
	for required_id_value: String in required_chunk_ids:
		var required_id := StringName(required_id_value)
		if not found.has(required_id) and not result.has(required_id):
			result.append(required_id)
	return result


func _weighted_candidate_order(
	candidates: Array[TerrainChunkVariant],
	index: int,
) -> Array[TerrainChunkVariant]:
	var candidate_counts: Dictionary[StringName, int] = {}
	for candidate: TerrainChunkVariant in candidates:
		var stable_id := candidate.definition.stable_id
		candidate_counts[stable_id] = candidate_counts.get(stable_id, 0) + 1
	var remaining: Array[TerrainChunkVariant] = []
	var weight_units: Array[int] = []
	for candidate: TerrainChunkVariant in candidates:
		var stable_id := candidate.definition.stable_id
		var rotation_count := maxi(candidate_counts.get(stable_id, 1), 1)
		var weight := (
			maxf(candidate.definition.selection_weight, 0.01)
			/ float(rotation_count)
		)
		if _required_chunk_is_missing(candidate.definition.stable_id):
			weight *= required_chunk_weight_multiplier
		var preferred_neighbors := _preferred_neighbor_count(
			index,
			candidate.definition,
		)
		for _preferred_index: int in preferred_neighbors:
			weight *= preferred_neighbor_weight_multiplier
		for _repeat_index: int in _long_definition_run_count(
			index,
			candidate.definition,
		):
			weight *= long_repeat_weight_multiplier
		if (
			candidate.definition.prefers_map_boundary
			and _coordinate_is_on_boundary(
				Vector2i(index % grid_size.x, index / grid_size.x)
			)
		):
			weight *= boundary_preference_multiplier
		remaining.append(candidate)
		weight_units.append(
			maxi(roundi(weight * CANDIDATE_WEIGHT_SCALE), 1)
		)
	var result: Array[TerrainChunkVariant] = []
	while not remaining.is_empty():
		var total_units := 0
		for units: int in weight_units:
			total_units += units
		var ticket := _random.randi_range(1, total_units)
		var accumulated := 0
		var selected_index := 0
		for candidate_index: int in remaining.size():
			accumulated += weight_units[candidate_index]
			if ticket <= accumulated:
				selected_index = candidate_index
				break
		result.append(remaining[selected_index])
		remaining.remove_at(selected_index)
		weight_units.remove_at(selected_index)
	return result


func _adjacent_definition_repeat_count(
	index: int,
	definition: TerrainChunkDefinition,
) -> int:
	var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
	var count := 0
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var edge := edge_value as TerrainChunkTopology.Edge
		var neighbor_coordinate := (
			coordinate + TerrainChunkTopology.grid_offset(edge)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		var neighbor := _placements[
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		]
		if neighbor != null and neighbor.definition == definition:
			count += 1
	return count


func _preferred_neighbor_count(
	index: int,
	definition: TerrainChunkDefinition,
) -> int:
	var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
	var count := 0
	for edge_value: int in TerrainChunkTopology.Edge.values():
		var edge := edge_value as TerrainChunkTopology.Edge
		var neighbor_coordinate := (
			coordinate + TerrainChunkTopology.grid_offset(edge)
		)
		if not _coordinate_is_inside_grid(neighbor_coordinate):
			continue
		var neighbor := _placements[
			neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
		]
		if neighbor != null and definition.prefers_neighbor(neighbor.definition):
			count += 1
	return count


func _long_definition_run_count(
	index: int,
	definition: TerrainChunkDefinition,
) -> int:
	var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
	var count := 0
	for axis: Vector2i in [Vector2i.RIGHT, Vector2i.DOWN]:
		if (
			_definition_at(coordinate - axis) == definition
			and _definition_at(coordinate + axis) == definition
		):
			count += 1
		for direction: int in [-1, 1]:
			if (
				_definition_at(coordinate + axis * direction) == definition
				and _definition_at(coordinate + axis * direction * 2)
				== definition
			):
				count += 1
	return count


func _definition_at(coordinate: Vector2i) -> TerrainChunkDefinition:
	if not _coordinate_is_inside_grid(coordinate):
		return null
	var placement := _placements[coordinate.y * grid_size.x + coordinate.x]
	return placement.definition if placement != null else null


func _coordinate_is_on_boundary(coordinate: Vector2i) -> bool:
	return (
		coordinate.x == 0
		or coordinate.y == 0
		or coordinate.x == grid_size.x - 1
		or coordinate.y == grid_size.y - 1
	)


func _neighbor_requirement_validation_error(
	layout: Array[TerrainChunkVariant],
) -> String:
	for index: int in layout.size():
		var placement := layout[index]
		if placement == null or placement.definition.minimum_required_neighbors <= 0:
			continue
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		var matching_neighbors := 0
		for edge_value: int in TerrainChunkTopology.Edge.values():
			var neighbor_coordinate := (
				coordinate
				+ TerrainChunkTopology.grid_offset(
					edge_value as TerrainChunkTopology.Edge
				)
			)
			if not _coordinate_is_inside_grid(neighbor_coordinate):
				continue
			var neighbor := layout[
				neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
			]
			if (
				neighbor != null
				and _definition_matches_required_neighbor_tags(
					placement.definition,
					neighbor.definition,
				)
			):
				matching_neighbors += 1
		if matching_neighbors < placement.definition.minimum_required_neighbors:
			return (
				"%s at cell %d has %d required neighbors; expected at least %d."
				% [
					placement.definition.stable_id,
					index,
					matching_neighbors,
					placement.definition.minimum_required_neighbors,
				]
			)
	return ""


func _walkable_connectivity_validation_error(
	layout: Array[TerrainChunkVariant],
) -> String:
	var walkable_indices: Array[int] = []
	for index: int in layout.size():
		var placement := layout[index]
		if placement != null and "walkable" in placement.definition.tags:
			walkable_indices.append(index)
	if walkable_indices.is_empty():
		return ""
	var start_index := walkable_indices[0]
	if force_center_chunk_id != &"":
		var center := Vector2i(grid_size.x / 2, grid_size.y / 2)
		var center_index := center.y * grid_size.x + center.x
		if (
			layout[center_index] != null
			and "walkable" in layout[center_index].definition.tags
		):
			start_index = center_index
	var visited: Dictionary[int, bool] = {start_index: true}
	var pending: Array[int] = [start_index]
	var pending_cursor := 0
	while pending_cursor < pending.size():
		var index := pending[pending_cursor]
		pending_cursor += 1
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		var current := layout[index]
		for edge_value: int in TerrainChunkTopology.Edge.values():
			var edge := edge_value as TerrainChunkTopology.Edge
			var neighbor_coordinate := (
				coordinate + TerrainChunkTopology.grid_offset(edge)
			)
			if not _coordinate_is_inside_grid(neighbor_coordinate):
				continue
			var neighbor_index := (
				neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
			)
			if visited.has(neighbor_index):
				continue
			var neighbor := layout[neighbor_index]
			if neighbor == null or "walkable" not in neighbor.definition.tags:
				continue
			if not _edges_are_compatible(
				current,
				edge,
				neighbor,
				TerrainChunkTopology.opposite_edge(edge),
			):
				continue
			visited[neighbor_index] = true
			pending.append(neighbor_index)
	if visited.size() != walkable_indices.size():
		return (
			"walkable terrain is split into disconnected regions "
			+ "(%d of %d cells reachable from spawn)."
			% [visited.size(), walkable_indices.size()]
		)
	return ""


func _required_chunk_is_missing(stable_id: StringName) -> bool:
	if not required_chunk_ids.has(String(stable_id)):
		return false
	for placement: TerrainChunkVariant in _placements:
		if (
			placement != null
			and placement.definition.stable_id == stable_id
		):
			return false
	return true


func _resolve_equivalent_rotations() -> void:
	for index: int in _placements.size():
		var placement := _placements[index]
		if placement == null:
			continue
		var rotations: PackedInt32Array = _equivalent_rotations.get(
			_constraint_key(placement),
			PackedInt32Array([placement.quarter_turns]),
		)
		if rotations.size() <= 1:
			continue
		var selected_turns := _least_repeated_equivalent_rotation(
			index,
			placement.definition,
			rotations,
		)
		var resolved := _authored_variant(
			placement.definition,
			selected_turns,
		)
		if resolved != null:
			_placements[index] = resolved


func _least_repeated_equivalent_rotation(
	index: int,
	definition: TerrainChunkDefinition,
	rotations: PackedInt32Array,
) -> int:
	var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
	var best_score := 3
	var best_rotations := PackedInt32Array()
	for turns: int in rotations:
		var score := 0
		for neighbor_coordinate: Vector2i in [
			coordinate + Vector2i.LEFT,
			coordinate + Vector2i.UP,
		]:
			if not _coordinate_is_inside_grid(neighbor_coordinate):
				continue
			var neighbor := _placements[
				neighbor_coordinate.y * grid_size.x + neighbor_coordinate.x
			]
			if (
				neighbor != null
				and neighbor.definition == definition
				and neighbor.quarter_turns == turns
			):
				score += 1
		if score < best_score:
			best_score = score
			best_rotations = PackedInt32Array([turns])
		elif score == best_score:
			best_rotations.append(turns)
	return best_rotations[_random.randi_range(0, best_rotations.size() - 1)]


func _authored_variant(
	definition: TerrainChunkDefinition,
	quarter_turns: int,
) -> TerrainChunkVariant:
	for variant: TerrainChunkVariant in _variants:
		if (
			variant.definition == definition
			and variant.quarter_turns == quarter_turns
		):
			return variant
	return null


func _build_solution_root() -> Node3D:
	var solution_root := Node3D.new()
	solution_root.name = "GeneratedChunks"
	var half_grid := Vector2(
		float(grid_size.x - 1) * 0.5,
		float(grid_size.y - 1) * 0.5,
	)
	for index: int in _placements.size():
		var variant := _placements[index]
		if variant == null:
			continue
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		var chunk_root := variant.definition.packed_scene.instantiate() as Node3D
		if chunk_root == null:
			push_error("%s does not instantiate as Node3D." % variant.stable_key())
			solution_root.free()
			return null
		chunk_root.name = "%s_%d_%d" % [
			variant.stable_key().replace("@", "r"),
			coordinate.x,
			coordinate.y,
		]
		chunk_root.position = Vector3(
			(float(coordinate.x) - half_grid.x) * catalog.chunk_size,
			0.0,
			(float(coordinate.y) - half_grid.y) * catalog.chunk_size,
		)
		chunk_root.rotation.y = variant.rotation_radians()
		chunk_root.set_meta(&"terrain_chunk_coordinate", coordinate)
		chunk_root.set_meta(
			&"terrain_chunk_id",
			variant.definition.stable_id,
		)
		solution_root.add_child(chunk_root)
		if build_collision:
			_add_collision(chunk_root, variant.definition)
		if show_chunk_labels:
			_add_chunk_label(chunk_root, variant)
	return solution_root


func _replace_generated_chunks(solution_root: Node3D) -> void:
	_clear_generated_chunks()
	_generated_chunks = solution_root
	add_child(_generated_chunks)


func _add_collision(
	chunk_root: Node3D,
	definition: TerrainChunkDefinition,
) -> void:
	var primary_mesh := TerrainChunkAnalyzer.find_primary_mesh(
		chunk_root,
		definition.primary_mesh_name,
	)
	if primary_mesh == null or primary_mesh.mesh == null:
		return
	var terrain_shape := primary_mesh.mesh.create_trimesh_shape()
	if terrain_shape == null or terrain_shape.get_faces().is_empty():
		push_warning("%s produced no terrain collision." % definition.stable_id)
		return
	var concave_shape := terrain_shape as ConcavePolygonShape3D
	if concave_shape != null:
		# Authored terrain can expose cliff walls and transitional surfaces with
		# mixed winding. Treat both sides as solid so a visible walkable surface
		# can never become an invisible collision gap.
		concave_shape.backface_collision = true
	var collision_body := StaticBody3D.new()
	collision_body.name = "TerrainCollision"
	collision_body.collision_layer = 1
	collision_body.collision_mask = 0
	primary_mesh.add_child(collision_body)
	var collision_shape := CollisionShape3D.new()
	collision_shape.name = "TerrainShape"
	collision_shape.shape = terrain_shape
	collision_body.add_child(collision_shape)


func _add_chunk_label(
	chunk_root: Node3D,
	variant: TerrainChunkVariant,
) -> void:
	var label := Label3D.new()
	label.name = "ChunkLabel"
	label.text = "%s  r%d" % [
		variant.definition.stable_id,
		variant.quarter_turns,
	]
	label.position = Vector3(0.0, 1.25, 0.0)
	label.font_size = 24
	label.billboard = BaseMaterial3D.BILLBOARD_ENABLED
	label.no_depth_test = true
	chunk_root.add_child(label)


func _clear_generated_chunks() -> void:
	if is_instance_valid(_generated_chunks):
		remove_child(_generated_chunks)
		_generated_chunks.free()
	_generated_chunks = null


func _build_summary() -> Dictionary:
	var counts: Dictionary[StringName, int] = {}
	var variant_counts: Dictionary[StringName, int] = {}
	for variant: TerrainChunkVariant in _variants:
		var variant_id := variant.definition.stable_id
		variant_counts[variant_id] = variant_counts.get(variant_id, 0) + 1
	for variant: TerrainChunkVariant in _placements:
		if variant == null:
			continue
		var stable_id := variant.definition.stable_id
		counts[stable_id] = counts.get(stable_id, 0) + 1
	return {
		"seed": generation_seed,
		"grid_size": grid_size,
		"chunk_count": _placements.size(),
		"variant_count": _variants.size(),
		"solver_variant_count": _solver_variants.size(),
		"compatible_edge_pairs": _compatible_edge_pair_count(),
		"backtracks": _backtrack_count,
		"adjacent_repeat_edges": _count_adjacent_repeat_edges(),
		"counts": counts,
		"variant_counts": variant_counts,
		"placements": placement_keys(),
		"layout_fingerprint": placement_fingerprint(),
	}


func _compatible_edge_pair_count() -> int:
	var count := 0
	for compatible: int in _edge_compatibility:
		if compatible != 0:
			count += 1
	return count


func _count_adjacent_repeat_edges() -> int:
	var count := 0
	for index: int in _placements.size():
		var current := _placements[index]
		if current == null:
			continue
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		if coordinate.x > 0:
			var west := _placements[index - 1]
			if west != null and west.definition == current.definition:
				count += 1
		if coordinate.y > 0:
			var north := _placements[index - grid_size.x]
			if north != null and north.definition == current.definition:
				count += 1
	return count


func placement_keys() -> PackedStringArray:
	var result := PackedStringArray()
	for variant: TerrainChunkVariant in _placements:
		result.append(variant.stable_key() if variant != null else "empty")
	return result


func placement_fingerprint() -> String:
	var fingerprint_input := PackedStringArray([
		"grid:%dx%d" % [grid_size.x, grid_size.y],
		"chunk_size:%.6f" % (catalog.chunk_size if catalog != null else 0.0),
	])
	fingerprint_input.append_array(placement_keys())
	return "\n".join(fingerprint_input).sha256_text()


func placement_records() -> Array[Dictionary]:
	var result: Array[Dictionary] = []
	for index: int in _placements.size():
		var variant: TerrainChunkVariant = _placements[index]
		if variant == null:
			continue
		var coordinate := Vector2i(index % grid_size.x, index / grid_size.x)
		result.append({
			"coordinate": coordinate,
			"position": chunk_position(coordinate),
			"rotation_quarters": variant.quarter_turns,
			"stable_id": variant.definition.stable_id,
			"tags": variant.definition.tags,
			"ocean_facing_edges": variant.rotated_edge_mask(
				variant.definition.ocean_facing_edges
			),
			"water_surface_size": variant.definition.water_surface_size,
			"water_surface_offset": variant.definition.water_surface_offset,
		})
	return result


func chunk_position(coordinate: Vector2i) -> Vector3:
	if catalog == null:
		return Vector3.ZERO
	var half_grid := Vector2(
		float(grid_size.x - 1) * 0.5,
		float(grid_size.y - 1) * 0.5,
	)
	return Vector3(
		(float(coordinate.x) - half_grid.x) * catalog.chunk_size,
		0.0,
		(float(coordinate.y) - half_grid.y) * catalog.chunk_size,
	)


func get_generated_chunks_root() -> Node3D:
	return _generated_chunks


func get_primary_terrain_meshes() -> Array[MeshInstance3D]:
	var result: Array[MeshInstance3D] = []
	if not is_instance_valid(_generated_chunks):
		return result
	var chunk_count := mini(
		_generated_chunks.get_child_count(),
		_placements.size(),
	)
	for index: int in chunk_count:
		var placement := _placements[index]
		var chunk_root := _generated_chunks.get_child(index)
		if placement == null or chunk_root == null:
			continue
		var primary_mesh := TerrainChunkAnalyzer.find_primary_mesh(
			chunk_root,
			placement.definition.primary_mesh_name,
		)
		if primary_mesh != null and primary_mesh.mesh != null:
			result.append(primary_mesh)
	return result