Implement production vertical slice foundation

game/application/dive/dive_tick_runner.gd

@@ -0,0 +1,75 @@
+class_name DiveTickRunner
+extends RefCounted
+
+const VehicleTelemetry = preload("res://game/application/dive/vehicle_telemetry.gd")
+const DiveSession = preload("res://game/domain/dive/dive_session.gd")
+const DiveTick = preload("res://game/domain/dive/dive_tick.gd")
+const DiveTelemetrySample = preload("res://game/domain/dive/dive_telemetry_sample.gd")
+const CollisionObservation = preload("res://game/domain/dive/collision_observation.gd")
+const ToolPowerDemand = preload("res://game/domain/dive/tool_power_demand.gd")
+const EjectionIntent = preload("res://game/domain/dive/ejection_intent.gd")
+const ReturnRouteSample = preload("res://game/domain/dive/return_route_sample.gd")
+const DiveStep = preload("res://game/domain/dive/dive_step.gd")
+const DiveUpdate = preload("res://game/domain/dive/dive_update.gd")
+
+var _session: DiveSession
+var _next_sequence := 0
+
+
+func _init(session: DiveSession) -> void:
+	_session = session
+
+
+func next_sequence() -> int:
+	return _next_sequence
+
+
+func initial_update() -> DiveUpdate:
+	return DiveUpdate.initial(_session.current_snapshot())
+
+
+func advance(
+	telemetry: VehicleTelemetry,
+	elapsed_seconds: float,
+	collisions: Array[CollisionObservation] = [],
+	tool_power_demands: Array[ToolPowerDemand] = [],
+	ejection_intent: EjectionIntent = null,
+	return_route: ReturnRouteSample = null
+) -> DiveUpdate:
+	if telemetry == null:
+		return DiveUpdate.rejected(
+			_next_sequence,
+			"vehicle telemetry is missing",
+			_session.current_snapshot()
+		)
+	var telemetry_error: String = telemetry.validation_error(
+		_session.session_id,
+		_next_sequence
+	)
+	if not telemetry_error.is_empty():
+		return DiveUpdate.rejected(
+			_next_sequence,
+			telemetry_error,
+			_session.current_snapshot()
+		)
+
+	var tick := DiveTick.new(_session.session_id, _next_sequence, elapsed_seconds)
+	var sample := DiveTelemetrySample.new(
+		telemetry.depth_m,
+		telemetry.longitudinal_effort,
+		telemetry.steering_effort,
+		telemetry.vertical_effort,
+		telemetry.high_thrust_active
+	)
+	var step := DiveStep.new(
+		tick,
+		sample,
+		collisions,
+		tool_power_demands,
+		ejection_intent,
+		return_route
+	)
+	var update: DiveUpdate = _session.advance(step)
+	if update.accepted:
+		_next_sequence += 1
+	return update

game/application/dive/vehicle_telemetry.gd

@@ -0,0 +1,74 @@
+class_name VehicleTelemetry
+extends RefCounted
+
+var session_id: StringName
+var sequence: int
+var world_position_m: Vector3
+var world_orientation: Quaternion
+var world_linear_velocity_mps: Vector3
+var local_angular_velocity_rps: Vector3
+var depth_m: float
+var longitudinal_effort: float
+var steering_effort: float
+var vertical_effort: float
+var high_thrust_active: bool
+
+
+func _init(
+	p_session_id: StringName,
+	p_sequence: int,
+	p_world_position_m: Vector3,
+	p_world_orientation: Quaternion,
+	p_world_linear_velocity_mps: Vector3,
+	p_local_angular_velocity_rps: Vector3,
+	p_depth_m: float,
+	p_longitudinal_effort: float,
+	p_steering_effort: float,
+	p_vertical_effort: float,
+	p_high_thrust_active: bool
+) -> void:
+	session_id = p_session_id
+	sequence = p_sequence
+	world_position_m = p_world_position_m
+	world_orientation = p_world_orientation
+	world_linear_velocity_mps = p_world_linear_velocity_mps
+	local_angular_velocity_rps = p_local_angular_velocity_rps
+	depth_m = p_depth_m
+	longitudinal_effort = p_longitudinal_effort
+	steering_effort = p_steering_effort
+	vertical_effort = p_vertical_effort
+	high_thrust_active = p_high_thrust_active
+
+
+func validation_error(expected_session_id: StringName, expected_sequence: int) -> String:
+	if session_id != expected_session_id:
+		return "telemetry session_id does not match"
+	if sequence != expected_sequence:
+		return "telemetry sequence does not match expected tick"
+	if not _vector_is_finite(world_position_m):
+		return "telemetry world position is not finite"
+	if not _quaternion_is_finite(world_orientation):
+		return "telemetry orientation is not finite"
+	if not _vector_is_finite(world_linear_velocity_mps):
+		return "telemetry linear velocity is not finite"
+	if not _vector_is_finite(local_angular_velocity_rps):
+		return "telemetry angular velocity is not finite"
+	if not is_finite(depth_m) or depth_m < 0.0:
+		return "telemetry depth must be finite and non-negative"
+	for effort: float in [longitudinal_effort, steering_effort, vertical_effort]:
+		if not is_finite(effort) or effort < -1.0 or effort > 1.0:
+			return "telemetry efforts must be between -1 and 1"
+	return ""
+
+
+func _vector_is_finite(value: Vector3) -> bool:
+	return is_finite(value.x) and is_finite(value.y) and is_finite(value.z)
+
+
+func _quaternion_is_finite(value: Quaternion) -> bool:
+	return (
+		is_finite(value.x)
+		and is_finite(value.y)
+		and is_finite(value.z)
+		and is_finite(value.w)
+	)