// Milestone M3 scenarios (DESIGN_UE.md section 10, "Board, launch, dive, swim, dock"): m3_launch_dock, m3_carousel, m3_rotor,
// m3_no_walls (requirement U7), m3_swim, m3_crush. The player is driven through the same actions the keys call (Descent.Player.Use,
// Descent.Tender.*, Descent.Player.Intent); shots are taken with the sim paused so a picture does not cost the animation its time.

#include "Core/DescentMath.h"
#include "Core/DescentSimSubsystem.h"
#include "Core/Tuning/DescentTune_Carrier.h"
#include "Core/Tuning/DescentTune_Player.h"
#include "Core/Tuning/DescentTune_Tender.h"
#include "Debug/DescentDebugSubsystem.h"
#include "Debug/DescentScenario.h"
#include "Player/DescentCharacter.h"
#include "Player/DescentCharacterMovement.h"
#include "Player/DescentInteraction.h"
#include "Player/DescentPlayerController.h"
#include "Player/DescentVitals.h"
#include "UI/DescentDash.h"
#include "UI/DescentHudSubsystem.h"
#include "UI/DescentUiShot.h"
#include "Vehicles/CarrierCarousel.h"
#include "Vehicles/CarrierLayout.h"
#include "Vehicles/DescentCarrier.h"
#include "Vehicles/KazahTender.h"
#include "Vehicles/TenderFlight.h"
#include "World/DescentShear.h"
#include "World/DescentTerrainSubsystem.h"
#include "World/DescentWorldDef.h"
#include "World/DescentWorldScenarioSteps.h"
#include "DescentUnits.h"
#include "TheDescent.h"

#include "Components/StaticMeshComponent.h"
#include "Engine/World.h"

namespace
{
	namespace M3T = Descent::Tune::Tender;
	namespace M3P = Descent::Tune::Player;
	const FVector M3CarrierOrigin(0.0, 0.0, Descent::Tune::Carrier::StartZM);   // the carrier does not move in these scenarios
	const FVector M3Pocket(5000.0, 0.0, -300.0);                                 // outside every v2 bound (v2: 560 x 700 x 600 m)

	ADescentPlayerController* M3PC(const FDescentScenarioContext& C)
	{
		return C.World ? Cast<ADescentPlayerController>(C.World->GetFirstPlayerController()) : nullptr;
	}
	ADescentCharacter* M3Char(const FDescentScenarioContext& C)
	{
		ADescentPlayerController* PC = M3PC(C);
		return PC ? PC->GetDescentCharacter() : nullptr;
	}
	UCarrierCarouselComponent* M3Carousel(const FDescentScenarioContext& C)
	{
		ADescentPlayerController* PC = M3PC(C);
		return PC ? PC->GetCarousel() : nullptr;
	}
	AKazahTender* M3Tender(const FDescentScenarioContext& C, int32 Index = 0)
	{
		const UDescentTenderFleet* Fleet = UDescentTenderFleet::Get(C.World);
		return Fleet ? Fleet->At(Index) : nullptr;
	}
	FDescentHudModel* M3Hud(const FDescentScenarioContext& C)
	{
		UDescentHudSubsystem* Hud = UDescentHudSubsystem::Get(C.World);
		return Hud ? &Hud->Model() : nullptr;
	}

	/** Waits (sim time) until the player's mode is M. */
	void M3WaitMode(FDescentScenarioBuilder& S, EDescentMode M, double MaxSimSeconds = 12.0)
	{
		TSharedRef<double> Start = MakeShared<double>(-1.0);
		S.Until(FString::Printf(TEXT("mode becomes %s"), DescentModeName(M)), [M, MaxSimSeconds, Start](FDescentScenarioContext& C)
		{
			const ADescentPlayerController* PC = M3PC(C);
			const UDescentSimSubsystem* Sim = C.Sim();
			if (!PC || !Sim) { C.Fail(TEXT("no player controller")); return true; }
			if (*Start < 0.0) { *Start = Sim->SimTime(); }
			if (PC->GetMode() == M) { return true; }
			if (Sim->SimTime() - *Start > MaxSimSeconds)
			{
				C.Fail(FString::Printf(TEXT("mode is %s after %.1f s of sim, expected %s"), DescentModeName(PC->GetMode()), MaxSimSeconds, DescentModeName(M)));
				return true;
			}
			return false;
		});
	}

	void M3ExpectMode(FDescentScenarioBuilder& S, EDescentMode M)
	{
		S.Expect(FString::Printf(TEXT("mode is %s"), DescentModeName(M)), [M](FDescentScenarioContext& C)
		{
			const ADescentPlayerController* PC = M3PC(C);
			if (!PC || PC->GetMode() != M) { C.Fail(FString::Printf(TEXT("mode is %s, expected %s"), PC ? DescentModeName(PC->GetMode()) : TEXT("(none)"), DescentModeName(M))); return false; }
			return true;
		});
	}

	/** Gives the view back to what the player would see (the Tender's cockpit camera, or the body's eyes). */
	void M3ViewPlayer(FDescentScenarioBuilder& S)
	{
		S.Do(TEXT("view: the player's own eyes"), [](FDescentScenarioContext& C)
		{
			ADescentPlayerController* PC = M3PC(C);
			if (!PC) { return; }
			AActor* Target = PC->GetTender() ? static_cast<AActor*>(PC->GetTender()) : static_cast<AActor*>(PC->GetDescentCharacter());
			if (Target) { PC->SetViewTarget(Target); }
		});
		S.WaitFrames(2);
	}

	/** Board with the command, wait for Docked, launch, wait for Sub. */
	void M3BoardAndLaunch(FDescentScenarioBuilder& S)
	{
		S.Exec(TEXT("Descent.Tender.Board"));
		M3WaitMode(S, EDescentMode::Docked);
		S.Exec(TEXT("Descent.Tender.Launch"));
		M3WaitMode(S, EDescentMode::Sub);
	}

	/** Carves a room around Centre: a sphere of radius R at the centre and one at +-Step on each axis. */
	void M3CarveRoom(FDescentScenarioBuilder& S, const FVector& Centre, double R, double Step)
	{
		const FVector Offsets[7] = { FVector(0, 0, 0), FVector(Step, 0, 0), FVector(-Step, 0, 0), FVector(0, Step, 0), FVector(0, -Step, 0), FVector(0, 0, Step), FVector(0, 0, -Step) };
		for (const FVector& O : Offsets)
		{
			const FVector P = Centre + O;
			S.Exec(FString::Printf(TEXT("Descent.World.Carve %.1f %.1f %.1f %.1f"), P.X, P.Y, P.Z, R));
		}
	}

	/** Pauses the sim, takes a picture from a fixed camera, resumes. */
	void M3PausedShot(FDescentScenarioBuilder& S, const FString& Label, const FVector& CamM, const FVector& TargetM, float Fov)
	{
		S.Exec(TEXT("Descent.Sim.Pause 1"));
		S.LookAt(CamM, TargetM, Fov);
		S.Shot(Label);
		S.Exec(TEXT("Descent.Sim.Pause 0"));
	}

	/** The piloted Tender flies with an intent for Seconds of sim, without rendering. */
	void M3Fly(FDescentScenarioBuilder& S, double Fwd, double Right, double Up, double Seconds, bool bBoost)
	{
		S.Exec(FString::Printf(TEXT("Descent.Player.Intent %.2f %.2f %.2f 0 0 %.2f 0 0 %d"), Fwd, Right, Up, Seconds, bBoost ? 1 : 0));
		S.FastForward(Seconds);
	}

	/**
	 * A picture WITH the HUD (fix list after M3: every other shot is taken with the UI off, so none showed the real HUD over real play).
	 * Saved/Shots/<scenario>_<Label>.png, through the UI track's Descent::Ui::RequestUiShot.
	 */
	void M3HudShot(FDescentScenarioBuilder& S, const FString& Label)
	{
		struct FSt { int32 Phase = 0; bool bDone = false; Descent::Ui::FUiShotResult R; };
		TSharedRef<FSt> St = MakeShared<FSt>();
		S.WaitFrames(8);   // the HUD model is written at 10 Hz, the widgets read it the frame after
		S.Until(FString::Printf(TEXT("HudShot(%s)"), *Label), [St, Label](FDescentScenarioContext& C)
		{
			if (St->Phase == 0)
			{
				TSharedRef<FSt> Keep = St;
				if (!Descent::Ui::RequestUiShot(C.ScenarioName + TEXT("_") + Label, [Keep](const Descent::Ui::FUiShotResult& R) { Keep->R = R; Keep->bDone = true; }) && !St->bDone)
				{
					C.Fail(TEXT("the UI screenshot request was refused"));
					return true;
				}
				St->Phase = 1;
				return false;
			}
			if (!St->bDone) { return false; }
			if (!St->R.bOk) { C.Fail(FString::Printf(TEXT("HudShot(%s) failed: %s"), *Label, *St->R.Error)); return true; }
			UE_LOG(LogDescent, Display, TEXT("HudShot(%s): %s  %dx%d  mean luma %.3f"), *Label, *St->R.Path, St->R.Size.X, St->R.Size.Y, St->R.Stats.MeanLuma);
			return true;
		});
	}

	struct FM3Track
	{
		FVector StartM = FVector::ZeroVector;
		double Value = 0.0, Value2 = 0.0, Max = -1e9, MaxJump = 0.0, Prev = -1.0, Time0 = -1.0;
		bool bFlag = false, bFlag2 = false;
		int32 Count = 0;
	};
}

// =====================================================================================================================
// m3_launch_dock (V5): Foot -> Board -> Docked -> Launch -> Sub -> Dock -> Docked, nothing ever closer than 0.3 m.
// =====================================================================================================================

DESCENT_SCENARIO(m3_launch_dock, "V5: walk to the pool, board the Tender with E, launch through the moon pool, fly, dock again; the mode sequence, the carousel clearance throughout, and the shots bay_carousel, launch_mid, cockpit, tender_close, dock_rise.")
{
	S.TimeLimit(300.f);
	DescentWorldScn::WaitStreamIdle(S, 60.f);
	S.Expect(TEXT("three Tenders hang in the carousel, BT-01 at BOARD over the pool"), [](FDescentScenarioContext& C)
	{
		const UCarrierCarouselComponent* Car = M3Carousel(C);
		if (!Car || Car->NumTenders() != 3) { C.Fail(TEXT("no carousel with three Tenders")); return false; }
		const ADescentCarrier* K = UDescentCarrierSubsystem::GetCarrier(C.World);
		const FVector L0 = K->ToLocalM(Car->GetTender(0)->GetActorLocation());
		if (Car->TenderAtBoard() != Car->GetTender(0) || !L0.Equals(FVector(-29.0, 6.0, M3T::BoardZ), 0.01))
		{
			C.Fail(FString::Printf(TEXT("BT-01 is at carrier-local (%.2f, %.2f, %.2f), expected (-29, 6, -6.3) at BOARD"), L0.X, L0.Y, L0.Z));
			return false;
		}
		for (int32 I = 1; I < 3; ++I)
		{
			const double Z = K->ToLocalM(Car->GetTender(I)->GetActorLocation()).Z;
			if (FMath::Abs(Z - M3T::StowedZ) > 0.01) { C.Fail(FString::Printf(TEXT("Tender %d hangs at z %.2f, expected STOWED -1.0"), I, Z)); return false; }
		}
		const_cast<UCarrierCarouselComponent*>(Car)->ResetMinClearanceSeen();
		return true;
	});
	S.Do(TEXT("start the mode record"), [](FDescentScenarioContext& C) { if (ADescentPlayerController* PC = M3PC(C)) { PC->ClearModeHistory(); } });

	// the bay with its three Tenders, from the deck near the gallery stairs
	S.Exec(TEXT("Descent.Player.Place bay"));
	S.WaitSim(0.5);
	S.LookAt(M3CarrierOrigin + FVector(-20.6, -6.6, -5.7), M3CarrierOrigin + FVector(-29.5, 1.5, -3.0), 95.f);
	S.Shot(TEXT("bay_carousel"));
	S.LookAt(M3CarrierOrigin + FVector(-38.8, -7.8, -5.7), M3CarrierOrigin + FVector(-28.0, 2.0, -2.8), 95.f);
	S.Shot(TEXT("bay_carousel_aft"));
	M3ViewPlayer(S);

	// walk to the pool rim, face the Tender, press E
	S.Exec(TEXT("Descent.Player.MoveTo -29 2.4"));
	S.Until(TEXT("arrived at the pool rim"), [](FDescentScenarioContext& C) { const ADescentCharacter* P = M3Char(C); return !P || !P->GetAutoWalk().bActive; });
	S.Exec(TEXT("Descent.Player.Look 90 2"));
	S.WaitSim(0.4);
	S.Expect(TEXT("the prompt offers to board BT-01"), [](FDescentScenarioContext& C)
	{
		const ADescentCharacter* P = M3Char(C);
		const FString Label = P ? P->Interaction->GetFocusLabel() : FString();
		if (!Label.Contains(TEXT("Board BT-01"))) { C.Fail(FString::Printf(TEXT("focus label is '%s'"), *Label)); return false; }
		return true;
	});
	S.Shot(TEXT("board_prompt_view"));
	S.Exec(TEXT("Descent.Player.Use"));
	M3ExpectMode(S, EDescentMode::Board);
	S.Until(TEXT("the canopy lid is open"), [](FDescentScenarioContext& C) { const AKazahTender* T = M3Tender(C); return !T || T->GetCanopyOpen01() >= 0.99 || C.SecondsInStep() > 20.0; });
	M3PausedShot(S, TEXT("canopy_open"), M3CarrierOrigin + FVector(-23.6, 8.2, -5.0), M3CarrierOrigin + FVector(-26.9, 6.0, -5.7), 55.f);
	M3ViewPlayer(S);
	M3WaitMode(S, EDescentMode::Docked, 3.0);
	S.Expect(TEXT("boarding took 1.4 s and the reference point is the Tender origin"), [](FDescentScenarioContext& C)
	{
		const ADescentPlayerController* PC = M3PC(C);
		const AKazahTender* T = M3Tender(C);
		const FVector Ref = PC->RefPointM();
		if (!T || !Ref.Equals(Descent::UUToMetres(T->GetActorLocation()), 0.01)) { C.Fail(TEXT("the reference point is not the Tender origin while docked")); return false; }
		return true;
	});
	S.WaitSim(0.6);
	S.Shot(TEXT("cockpit_docked"));
	// the Tender from close by, in the light of the bay: the glass with the interior through it
	S.LookAt(M3CarrierOrigin + FVector(-23.6, 8.2, -5.2), M3CarrierOrigin + FVector(-26.9, 6.0, -5.9), 50.f);
	S.Shot(TEXT("tender_close"));
	M3ViewPlayer(S);

	// launch: straight down through the pool, 3.2 s
	S.Exec(TEXT("Descent.Tender.Launch"));
	M3ExpectMode(S, EDescentMode::Launch);
	S.Until(TEXT("half-way down"), [](FDescentScenarioContext& C) { const UCarrierCarouselComponent* Car = M3Carousel(C); return !Car || Car->AnimRemaining() <= M3T::LaunchSec * 0.5; });
	M3PausedShot(S, TEXT("launch_mid"), M3CarrierOrigin + FVector(-19.5, -1.0, -19.5), M3CarrierOrigin + FVector(-29.0, 6.0, -11.5), 70.f);
	M3ViewPlayer(S);
	M3WaitMode(S, EDescentMode::Sub, 6.0);
	S.Expect(TEXT("handed over at DOCK_BELOW with 1 m/s downward"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const ADescentCarrier* K = UDescentCarrierSubsystem::GetCarrier(C.World);
		const FVector L = K->ToLocalM(T->GetActorLocation());
		UE_LOG(LogDescent, Display, TEXT("M3 launch: handed over at carrier-local (%.2f, %.2f, %.2f), velocity (%.2f, %.2f, %.2f) m/s"), L.X, L.Y, L.Z, T->Flight->VelMps.X, T->Flight->VelMps.Y, T->Flight->VelMps.Z);
		if (FMath::Abs(L.X + 29.0) > 0.05 || FMath::Abs(L.Y - 6.0) > 0.05 || L.Z > M3T::DockBelowZ + 0.1 || L.Z < M3T::DockBelowZ - 0.3) { C.Fail(TEXT("the Tender was not released at (-29, 6, -16)")); return false; }
		return true;
	});

	// fly ahead with the headlamp, then the cockpit picture: canopy frame and a readable dash
	S.Exec(TEXT("Descent.Player.Intent 1 0 -0.25 0 0 5 0 0 0"));
	S.WaitSim(5.2);
	S.Expect(TEXT("the Tender flew and the dash model follows it"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const UDescentDashComponent* Dash = T ? T->GetDashMain() : nullptr;
		const FTenderDashModel M = T->Flight->MakeDashModel();
		const FDescentHudModel* Hud = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 cockpit: depth %.1f m, dash '%s', HUD '%s', hull %.0f, power %.1f, speed %.2f, dash redraws %d"), M.DepthM,
			*SDescentDash::MakeReadout(M).DepthText, Hud ? *Hud->DepthText : TEXT(""), M.HullPct, M.PowerPct, M.SpeedMps, Dash ? Dash->RedrawCount() : -1);
		if (!Dash || !T->GetDashCargo()) { C.Fail(TEXT("the dashboards are not mounted in the cockpit")); return false; }
		if (!Dash->GetDashModel() || FMath::Abs(Dash->GetDashModel()->DepthM - M.DepthM) > 2.0) { C.Fail(TEXT("the mounted dash does not show the Tender's depth")); return false; }
		if (!Hud || Hud->DepthText != SDescentDash::MakeReadout(M).DepthText) { C.Fail(TEXT("HUD depth and dash depth differ (section 5.9)")); return false; }
		return T->Flight->VelMps.Size() > 4.0;
	});
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("cockpit"));
	M3HudShot(S, TEXT("hud_piloting"));   // the same moment with the real HUD on
	// the Tender from outside at sea, lit by the surface light and its own lamps
	S.Do(TEXT("camera beside the canopy"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector Cam = Descent::UUToMetres(T->ToWorldUU(FVector(5.6, 2.9, 1.5))), Look = Descent::UUToMetres(T->ToWorldUU(FVector(1.9, 0.0, 0.55)));
		C.Debug->PlaceCamera(Cam, (Look - Cam).Rotation(), 50.f);
	});
	S.Shot(TEXT("tender_sea_close"));
	S.Do(TEXT("camera off the port bow"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector Cam = Descent::UUToMetres(T->ToWorldUU(FVector(8.5, -6.5, 2.6))), Look = Descent::UUToMetres(T->ToWorldUU(FVector(0.3, 0.0, 0.2)));
		C.Debug->PlaceCamera(Cam, (Look - Cam).Rotation(), 50.f);
	});
	S.Shot(TEXT("tender_sea"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	M3ViewPlayer(S);

	// back under the pool and dock with E
	S.Do(TEXT("refused away from the pool"), [](FDescentScenarioContext& C)
	{
		FString Why;
		if (M3Carousel(C)->CanDock(M3Tender(C), &Why)) { C.Fail(TEXT("docking is allowed 30 m away from the pool")); }
		UE_LOG(LogDescent, Display, TEXT("M3 dock: refused away from the pool (%s)"), *Why);
	});
	S.Exec(FString::Printf(TEXT("Descent.Tender.Teleport %.1f %.1f %.1f"), -34.0, 9.0, M3CarrierOrigin.Z - 22.0));
	S.Exec(FString::Printf(TEXT("Descent.Tender.LookAt %.1f %.1f %.1f"), -60.0, 30.0, M3CarrierOrigin.Z - 22.0));
	S.WaitSim(0.3);
	S.Expect(TEXT("the prompt offers to dock"), [](FDescentScenarioContext& C) { const FDescentHudModel* H = M3Hud(C); return H && H->Prompt.Contains(TEXT("Dock")); });
	S.Exec(TEXT("Descent.Player.Use"));
	M3ExpectMode(S, EDescentMode::Dock);
	S.Until(TEXT("rising through the pool"), [](FDescentScenarioContext& C) { const UCarrierCarouselComponent* Car = M3Carousel(C); return !Car || Car->AnimRemaining() <= 0.55; });
	M3PausedShot(S, TEXT("dock_rise"), M3CarrierOrigin + FVector(-23.4, -0.6, -5.7), M3CarrierOrigin + FVector(-29.0, 6.0, -7.0), 80.f);
	M3ViewPlayer(S);
	M3WaitMode(S, EDescentMode::Docked, 6.0);
	S.WaitSim(0.5);
	S.Expect(TEXT("mode sequence Foot > Board > Docked > Launch > Sub > Dock > Docked"), [](FDescentScenarioContext& C)
	{
		FString Seq;
		for (EDescentMode M : M3PC(C)->GetModeHistory()) { Seq += (Seq.IsEmpty() ? TEXT("") : TEXT(">")) + FString(DescentModeName(M)); }
		UE_LOG(LogDescent, Display, TEXT("M3 mode sequence: %s"), *Seq);
		if (Seq != TEXT("Foot>Board>Docked>Launch>Sub>Dock>Docked")) { C.Fail(FString::Printf(TEXT("mode sequence was %s"), *Seq)); return false; }
		return true;
	});
	S.Expect(TEXT("docked again at BOARD, recharging; carousel clearance stayed >= 0.3 m throughout"), [](FDescentScenarioContext& C)
	{
		const UCarrierCarouselComponent* Car = M3Carousel(C);
		const AKazahTender* T = M3Tender(C);
		const FVector L = UDescentCarrierSubsystem::GetCarrier(C.World)->ToLocalM(T->GetActorLocation());
		UE_LOG(LogDescent, Display, TEXT("M3 dock: Tender at carrier-local (%.3f, %.3f, %.3f), min clearance now %.3f m, smallest seen %.3f m"), L.X, L.Y, L.Z, Car->GetMinClearanceM(), Car->GetMinClearanceSeenM());
		if (!L.Equals(FVector(-29.0, 6.0, M3T::BoardZ), 0.01) || T->Flight->State != ETenderState::Cradle) { C.Fail(TEXT("the Tender is not back in the hoist cradle at BOARD")); return false; }
		if (Car->GetMinClearanceSeenM() < M3T::MinLiveClearanceM) { C.Fail(FString::Printf(TEXT("carousel clearance fell to %.3f m"), Car->GetMinClearanceSeenM())); return false; }
		return true;
	});
	// leave to the pool rim
	S.Exec(TEXT("Descent.Player.Use"));
	S.WaitSim(0.8);
	M3ExpectMode(S, EDescentMode::Foot);
	S.Expect(TEXT("on foot at the pool rim"), [](FDescentScenarioContext& C)
	{
		const FVector F = M3Char(C)->GetFeetLocalM();
		if (!F.Equals(FVector(M3P::LadderExitX, M3P::LadderExitY, M3P::LadderExitZ), 0.15)) { C.Fail(FString::Printf(TEXT("feet at (%.2f, %.2f, %.2f)"), F.X, F.Y, F.Z)); return false; }
		return true;
	});
	S.DumpState(TEXT("end"));
	S.Quit();
}

// =====================================================================================================================
// m3_carousel: three steps of 120 degrees; refused while a Tender is out.
// =====================================================================================================================

DESCENT_SCENARIO(m3_carousel, "The carousel turns three steps of 120 degrees (raise, rotate, lower), each Tender in turn over the pool; a rotation is refused while a Tender is out. Shot rotation_mid.")
{
	S.TimeLimit(300.f);
	S.Do(TEXT("reset the clearance record"), [](FDescentScenarioContext& C) { if (UCarrierCarouselComponent* Car = M3Carousel(C)) { Car->ResetMinClearanceSeen(); } else { C.Fail(TEXT("no carousel")); } });
	S.Exec(TEXT("Descent.Player.Place bay"));
	for (int32 Step = 1; Step <= 3; ++Step)
	{
		S.Exec(TEXT("Descent.Carrier.Carousel"));
		if (Step == 2)
		{
			S.Until(TEXT("half-way through the rotation"), [](FDescentScenarioContext& C)
			{
				const UCarrierCarouselComponent* Car = M3Carousel(C);
				return Car->GetPhase() == ECarouselPhase::Rotating && Car->GetAngleDeg() >= 180.0;
			});
			M3PausedShot(S, TEXT("rotation_mid"), M3CarrierOrigin + FVector(-20.6, -6.6, -5.7), M3CarrierOrigin + FVector(-29.5, 1.5, -2.6), 95.f);
		}
		TSharedRef<double> T0 = MakeShared<double>(-1.0);
		S.Until(FString::Printf(TEXT("carousel step %d finished"), Step), [T0](FDescentScenarioContext& C)
		{
			if (*T0 < 0.0) { *T0 = C.Sim()->SimTime(); }
			if (C.Sim()->SimTime() - *T0 > 20.0) { C.Fail(TEXT("the carousel did not come to rest in 20 s")); return true; }
			return !M3Carousel(C)->IsBusy();
		});
		S.Expect(FString::Printf(TEXT("after step %d: %d degrees +- 0.5, the next Tender at BOARD"), Step, Step * 120), [Step](FDescentScenarioContext& C)
		{
			const UCarrierCarouselComponent* Car = M3Carousel(C);
			const int32 ExpectSlot = (3 - Step) % 3;
			const AKazahTender* T = Car->TenderAtBoard();
			const FVector L = T ? UDescentCarrierSubsystem::GetCarrier(C.World)->ToLocalM(T->GetActorLocation()) : FVector::ZeroVector;
			UE_LOG(LogDescent, Display, TEXT("M3 carousel step %d: angle %.3f deg, launch slot %d, hoist z %.2f, at BOARD %s at (%.2f, %.2f, %.2f) yaw %.2f, smallest clearance seen %.3f m"), Step, Car->GetAngleDeg(),
				Car->GetLaunchSlot(), Car->GetHoistZ(), T ? T->Flight->Spec().Id : TEXT("(none)"), L.X, L.Y, L.Z, T ? T->GetActorRotation().Yaw : 0.0, Car->GetMinClearanceSeenM());
			if (FMath::Abs(Car->GetAngleDeg() - 120.0 * Step) > 0.5) { C.Fail(FString::Printf(TEXT("angle %.3f"), Car->GetAngleDeg())); return false; }
			if (Car->GetLaunchSlot() != ExpectSlot || !T || T->GetFleetIndex() != ExpectSlot) { C.Fail(TEXT("the wrong Tender is over the pool")); return false; }
			if (!L.Equals(FVector(-29.0, 6.0, M3T::BoardZ), 0.02) || FMath::Abs(FRotator::NormalizeAxis(T->GetActorRotation().Yaw)) > 0.5) { C.Fail(TEXT("the Tender at the launch slot is not at (-29, 6, -6.3) nose to the bow")); return false; }
			return true;
		});
	}
	S.Expect(TEXT("Tenders stayed at least 2 m apart and clear of the bay through the three rotations"), [](FDescentScenarioContext& C)
	{
		const double Seen = M3Carousel(C)->GetMinClearanceSeenM();
		if (Seen < M3T::MinLiveClearanceM) { C.Fail(FString::Printf(TEXT("clearance fell to %.3f m"), Seen)); return false; }
		return true;
	});
	// with a Tender out the console refuses
	M3BoardAndLaunch(S);
	S.Do(TEXT("a rotation is refused while a Tender is out"), [](FDescentScenarioContext& C)
	{
		UCarrierCarouselComponent* Car = M3Carousel(C);
		FString Why;
		const double Before = Car->GetAngleDeg();
		if (Car->RequestRotate(&Why) || Car->GetAngleDeg() != Before || Car->IsBusy()) { C.Fail(TEXT("the carousel accepted a rotation with a Tender out")); }
		UE_LOG(LogDescent, Display, TEXT("M3 carousel: refused with a Tender out (%s)"), *Why);
	});
	S.DumpState(TEXT("end"));
	S.Quit();
}

// =====================================================================================================================
// m3_rotor (V10): the rotors turn with the thrust.
// =====================================================================================================================

DESCENT_SCENARIO(m3_rotor, "V10: rotor_rpm is 0 at idle, 305 +- 5 at thrust 1, 518 at boost, and the rotor parts turn in opposite directions.")
{
	S.TimeLimit(180.f);
	M3BoardAndLaunch(S);
	S.WaitSim(1.0);
	S.Expect(TEXT("idle: rotor_rpm == 0"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		UE_LOG(LogDescent, Display, TEXT("M3 rotor: idle rpm %.2f, thrust %.3f"), T->RotorRPM, T->Flight->Thrust);
		return T->RotorRPM == 0.f;
	});
	TSharedRef<FM3Track> Tr = MakeShared<FM3Track>();
	S.Do(TEXT("remember the rotor angle"), [Tr](FDescentScenarioContext& C) { Tr->Value = M3Tender(C)->GetRotorTotalDeg(); });
	S.Exec(TEXT("Descent.Player.Intent 1 0 0 0 0 3 0 0 0"));
	S.WaitSim(1.5);
	S.Expect(TEXT("thrust 1: rotor_rpm 305 +- 5 and the rotors turn, counter-rotating"), [Tr](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const double Turned = T->GetRotorTotalDeg() - Tr->Value;
		const double RollP = T->GetPart(TEXT("Rotor_Port"))->GetRelativeRotation().Roll, RollS = T->GetPart(TEXT("Rotor_Stbd"))->GetRelativeRotation().Roll;
		UE_LOG(LogDescent, Display, TEXT("M3 rotor: thrust %.3f, rpm %.2f, turned %.0f deg in 1.5 s (305 rpm = 2745), port roll %.1f, starboard roll %.1f"), T->Flight->Thrust, T->RotorRPM, Turned, RollP, RollS);
		if (FMath::Abs(T->RotorRPM - 305.0) > 5.0) { C.Fail(FString::Printf(TEXT("rotor_rpm %.2f"), T->RotorRPM)); return false; }
		if (Turned < 2400.0 || Turned > 2900.0) { C.Fail(FString::Printf(TEXT("the rotors turned %.0f degrees in 1.5 s"), Turned)); return false; }
		return FMath::Abs(RollP + RollS) < 0.5;
	});
	S.Exec(TEXT("Descent.Player.Intent 1 0 0 0 0 2 0 0 1"));
	S.WaitSim(0.5);
	S.ExpectNear(TEXT("boost: rotor_rpm 305 x 1.7"), [](FDescentScenarioContext& C) { return static_cast<double>(M3Tender(C)->RotorRPM); }, 518.5, 5.0);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Do(TEXT("camera behind the stern"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector Cam = Descent::UUToMetres(T->ToWorldUU(FVector(-6.2, -1.6, 1.3))), Look = Descent::UUToMetres(T->ToWorldUU(FVector(-2.8, 0.0, 0.15)));
		C.Debug->PlaceCamera(Cam, (Look - Cam).Rotation(), 50.f);
	});
	DescentWorldScn::ShotAllowDark(S, TEXT("rotors"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	S.WaitSim(2.5);
	S.ExpectNear(TEXT("back to idle: rotor_rpm 0"), [](FDescentScenarioContext& C) { return static_cast<double>(M3Tender(C)->RotorRPM); }, 0.0, 0.01);
	S.DumpState(TEXT("end"));
	S.Quit();
}

// =====================================================================================================================
// m3_crush (V8): nothing above the rating, 1.4 HP/s 20 m below it.
// =====================================================================================================================

DESCENT_SCENARIO(m3_crush, "V8: 5 s at depth 2,280 m costs no hull; 5 s at 2,320 m costs 7.0 +- 0.5 HP; the dash warns from 50 m above the rating.")
{
	S.TimeLimit(180.f);
	// two rooms in solid rock far from everything, at the two depths (Z = 1780 - depth)
	M3CarveRoom(S, FVector(5000.0, 300.0, -500.0), 7.0, 4.0);
	M3CarveRoom(S, FVector(5000.0, 300.0, -540.0), 7.0, 4.0);
	M3BoardAndLaunch(S);
	TSharedRef<FM3Track> Tr = MakeShared<FM3Track>();
	S.Exec(TEXT("Descent.Tender.Teleport 5000 300 -500"));
	S.WaitFrames(2);
	S.Do(TEXT("hull before, at 2,280 m"), [Tr](FDescentScenarioContext& C) { Tr->Value = M3Tender(C)->Flight->HullHP; });
	S.FastForward(5.0);
	S.WaitFrames(8);
	S.Expect(TEXT("5 s at 2,280 m: no hull loss; the warning is on (within 50 m of the rating)"), [Tr](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FDescentHudModel* H = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 crush: depth %.1f m, hull %.3f -> %.3f HP, contacts %d, HUD crush warning %d '%s'"), T->Flight->DepthM(), Tr->Value, T->Flight->HullHP, T->Flight->Contacts, H ? H->Warnings.bCrush : 0, H ? *H->Warnings.Text : TEXT(""));
		if (FMath::Abs(T->Flight->DepthM() - 2280.0) > 0.5) { C.Fail(FString::Printf(TEXT("the Tender is at depth %.1f"), T->Flight->DepthM())); return false; }
		if (T->Flight->HullHP != Tr->Value) { C.Fail(TEXT("the hull lost HP above the rating")); return false; }
		return H && H->Warnings.bCrush;
	});
	S.Exec(TEXT("Descent.Tender.Teleport 5000 300 -540"));
	S.WaitFrames(2);
	S.Do(TEXT("hull before, at 2,320 m"), [Tr](FDescentScenarioContext& C) { Tr->Value = M3Tender(C)->Flight->HullHP; });
	S.FastForward(5.0);
	S.Expect(TEXT("5 s at 2,320 m: 7.0 +- 0.5 HP lost"), [Tr](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const double Lost = Tr->Value - T->Flight->HullHP;
		UE_LOG(LogDescent, Display, TEXT("M3 crush: depth %.1f m, hull %.3f -> %.3f HP: lost %.3f in 5 s (expected 7.0)"), T->Flight->DepthM(), Tr->Value, T->Flight->HullHP, Lost);
		if (FMath::Abs(T->Flight->DepthM() - 2320.0) > 0.5) { C.Fail(FString::Printf(TEXT("the Tender is at depth %.1f"), T->Flight->DepthM())); return false; }
		if (FMath::Abs(Lost - 7.0) > 0.5) { C.Fail(FString::Printf(TEXT("lost %.3f HP"), Lost)); return false; }
		return true;
	});
	S.WaitFrames(8);
	S.Expect(TEXT("the dash reads !! CRUSH DEPTH"), [](FDescentScenarioContext& C)
	{
		const SDescentDash::FReadout R = SDescentDash::MakeReadout(M3Tender(C)->Flight->MakeDashModel());
		UE_LOG(LogDescent, Display, TEXT("M3 crush: dash '%s' / '%s'"), *R.DepthText, *R.RatingText);
		return R.bCrush && R.RatingText.Contains(TEXT("CRUSH"));
	});
	M3ViewPlayer(S);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("cockpit_crush"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	// an honest void: full pressure, 14 HP per second whatever the depth rating says
	S.Exec(TEXT("Descent.Tender.Set hull 100"));
	S.Exec(TEXT("Descent.Tender.Teleport honest"));
	S.WaitFrames(2);
	S.Do(TEXT("hull before, in the honest void"), [Tr](FDescentScenarioContext& C) { Tr->Value = M3Tender(C)->Flight->HullHP; });
	S.FastForward(2.0);
	S.Do(TEXT("hull after 2 s"), [Tr](FDescentScenarioContext& C) { Tr->Value2 = Tr->Value - M3Tender(C)->Flight->HullHP; });
	S.WaitFrames(8);   // for the HUD model (10 Hz); the hull keeps failing meanwhile, so the loss was read before
	S.Expect(TEXT("2 s in the honest void: 28 +- 1 HP lost, and the HUD warns"), [Tr](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FDescentHudModel* H = M3Hud(C);
		const double Lost = Tr->Value2;
		UE_LOG(LogDescent, Display, TEXT("M3 crush: honest void at depth %.0f m (rating %.0f): hull %.2f -> %.2f, lost %.2f in 2 s (expected 28), contacts %d, warning '%s'"), T->Flight->DepthM(), T->Flight->Stats().Rating, Tr->Value, T->Flight->HullHP, Lost, T->Flight->Contacts, H ? *H->Warnings.Text : TEXT(""));
		return T->Flight->bInHonestVoid && FMath::Abs(Lost - 28.0) < 1.0 && H && H->Warnings.Text.Contains(TEXT("PRESSURE"));
	});
	S.Exec(TEXT("Descent.Tender.Teleport 5000 300 -540"));
	S.WaitFrames(2);
	// hull 0 is the death "implode": the Tender is printed again in its cradle, the debt grows by 4,800
	S.Exec(TEXT("Descent.Tender.Set hull 1.0"));
	M3WaitMode(S, EDescentMode::Dead, 4.0);
	M3WaitMode(S, EDescentMode::Foot, 5.0);
	S.Expect(TEXT("implosion: respawn in the galley, debt +4,800, the Tender back in its cradle with a full hull and 60 % power"), [](FDescentScenarioContext& C)
	{
		const ADescentCharacter* P = M3Char(C);
		const AKazahTender* T = M3Tender(C);
		const Descent::Carrier::FRoomDef* Room = Descent::Carrier::FLayout::Get().RoomAt(P->GetFeetLocalM() + FVector(0, 0, 0.3));
		UE_LOG(LogDescent, Display, TEXT("M3 implode: room %s, debt %.0f, health %.0f, Tender state %s hull %.0f power %.1f"), Room ? *Room->Id.ToString() : TEXT("(none)"), P->Vitals->State.Debt, P->Vitals->State.Health,
			TenderStateName(T->Flight->State), T->Flight->HullHP, T->Flight->PowerPct);
		return Room && Room->Id == TEXT("galley") && P->Vitals->State.Debt == 4800.0 && T->Flight->State == ETenderState::Cradle && T->Flight->HullHP == 100.0 && FMath::Abs(T->Flight->PowerPct - 60.0) < 2.0;
	});
	S.DumpState(TEXT("end"));
	S.Quit();
}

// =====================================================================================================================
// m3_swim (V9): pool drop, O2, the ladder, drowning, respawn.
// =====================================================================================================================

DESCENT_SCENARIO(m3_swim, "V9: walk through the gap in the pool rail and drop in -> Swim; O2 falls 1.0 per second; out through the belly and back; the ladder -> Foot and O2 refills; with O2 0 health falls 9 per second, death, respawn in the galley, debt +900.")
{
	S.TimeLimit(300.f);
	DescentWorldScn::WaitStreamIdle(S, 60.f);
	// the real drop: stand at the gap in the rail, walk forward
	S.Exec(TEXT("Descent.Player.PlaceLocal -28.2 2.2 -7.5 90"));
	S.WaitSim(0.5);
	S.Shot(TEXT("pool_gap"));
	S.Exec(TEXT("Descent.Player.Intent 1 0 0 0 0 2.5 0 0 0"));
	M3WaitMode(S, EDescentMode::Swim, 5.0);
	S.Expect(TEXT("in the pool, O2 on the HUD"), [](FDescentScenarioContext& C)
	{
		const ADescentCharacter* P = M3Char(C);
		const FVector F = P->GetFeetLocalM();
		UE_LOG(LogDescent, Display, TEXT("M3 swim: entered the water at carrier-local feet (%.2f, %.2f, %.2f), rescues %d"), F.X, F.Y, F.Z, P->RescueCount);
		return P->IsSwimming() && F.Y > 3.5 && F.Z < Descent::Tune::Carrier::PoolWaterZ && P->RescueCount == 0;
	});
	// down the shaft, away from the surface (within 0.6 m of it O2 refills)
	S.Exec(TEXT("Descent.Player.Intent 0 0 -1 0 0 1.6 0 0 0"));
	S.WaitSim(1.8);
	TSharedRef<FM3Track> Tr = MakeShared<FM3Track>();
	S.Do(TEXT("O2 at the start"), [Tr](FDescentScenarioContext& C) { Tr->Value = M3Char(C)->Vitals->State.O2; Tr->Time0 = C.Sim()->SimTime(); });
	S.WaitSim(5.0);
	S.Expect(TEXT("O2 falls 1.0 +- 0.05 per second"), [Tr](FDescentScenarioContext& C)
	{
		const double Dt = C.Sim()->SimTime() - Tr->Time0;
		const double Rate = (Tr->Value - M3Char(C)->Vitals->State.O2) / Dt;
		const FDescentHudModel* H = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 swim: O2 %.3f -> %.3f s over %.3f s of sim: %.4f per second; HUD shows O2 %d (%.1f s)"), Tr->Value, M3Char(C)->Vitals->State.O2, Dt, Rate, H ? H->Vitals.bShowO2 : 0, H ? H->Vitals.O2Seconds : 0.f);
		if (FMath::Abs(Rate - 1.0) > 0.05) { C.Fail(FString::Printf(TEXT("O2 rate %.4f per second"), Rate)); return false; }
		return H && H->Vitals.bShowO2;
	});
	S.Exec(TEXT("Descent.Player.Look 90 35"));
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	M3HudShot(S, TEXT("hud_swim"));   // swimming in the shaft with the real HUD on: the O2 gauge
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	// the free drop: out through the belly of the carrier into the open sea
	S.Exec(TEXT("Descent.Player.Intent 0 0 -1 0 0 3.2 0 0 1"));
	S.WaitSim(3.4);
	S.Expect(TEXT("out below the hull, in open water (no invisible floor in the pool)"), [](FDescentScenarioContext& C)
	{
		const FVector F = M3Char(C)->GetFeetLocalM();
		UE_LOG(LogDescent, Display, TEXT("M3 swim: after the drop the swimmer is at carrier-local (%.2f, %.2f, %.2f)"), F.X, F.Y, F.Z);
		return F.Z < -14.0;
	});
	S.Exec(TEXT("Descent.Player.Look 20 62"));
	S.WaitSim(0.3);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("swim_under_carrier"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	// back up the shaft to the ladder (x -29, on the inboard wall y 3.5)
	S.Exec(TEXT("Descent.Player.Set o2 45"));
	TSharedRef<FM3Track> Up = MakeShared<FM3Track>();
	S.Until(TEXT("swim up to the ladder"), [Up](FDescentScenarioContext& C)
	{
		ADescentPlayerController* PC = M3PC(C);
		ADescentCharacter* P = M3Char(C);
		if (Up->Time0 < 0.0) { Up->Time0 = C.Sim()->SimTime(); }
		if (PC->CanClimb()) { C.Sim()->ClearDebugIntent(); return true; }
		if (C.Sim()->SimTime() - Up->Time0 > 25.0) { const FVector F = P->GetFeetLocalM(); C.Fail(FString::Printf(TEXT("did not reach the ladder in 25 s; at (%.2f, %.2f, %.2f)"), F.X, F.Y, F.Z)); return true; }
		// steer like a player: look at the ladder zone, swim forward
		const ADescentCarrier* K = UDescentCarrierSubsystem::GetCarrier(C.World);
		const FVector Target = K->ToWorldUU(FVector(-29.0, 4.3, Descent::Tune::Carrier::PoolWaterZ - 0.6));
		const FRotator Want = (Target - P->EyeWorldUU()).Rotation();
		PC->SetControlRotation(FRotator(FMath::Clamp(Want.Pitch, -80.0, 80.0), Want.Yaw, 0.0));
		FDescentIntent I;
		I.Move.X = 1.0;
		C.Sim()->SetDebugIntent(I, 0.2);
		return false;
	});
	S.Exec(TEXT("Descent.Player.Look -90 10"));
	S.WaitSim(0.3);
	S.Expect(TEXT("at the ladder: the prompt says climb; the head stays under the pool surface"), [](FDescentScenarioContext& C)
	{
		const ADescentCharacter* P = M3Char(C);
		const FVector Head = UDescentCarrierSubsystem::GetCarrier(C.World)->ToLocalM(P->EyeWorldUU());
		const FDescentHudModel* H = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 swim: at the ladder, head at carrier-local (%.2f, %.2f, %.2f) (pool surface %.2f), prompt '%s'"), Head.X, Head.Y, Head.Z, Descent::Tune::Carrier::PoolWaterZ, H ? *H->Prompt : TEXT(""));
		return H && H->Prompt.Contains(TEXT("Climb")) && Head.Z <= Descent::Tune::Carrier::PoolWaterZ - M3P::SwimHeadBelowSurfaceM + 0.05;
	});
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("ladder"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	S.Do(TEXT("use up some O2 first"), [](FDescentScenarioContext& C) { M3Char(C)->Vitals->State.O2 = 20.0; });
	S.Exec(TEXT("Descent.Player.Use"));
	M3ExpectMode(S, EDescentMode::Ladder);
	M3WaitMode(S, EDescentMode::Foot, 3.0);
	S.WaitSim(1.5);
	S.Expect(TEXT("on foot at the pool rim in the bay, O2 refilled"), [](FDescentScenarioContext& C)
	{
		const ADescentCharacter* P = M3Char(C);
		const FVector F = P->GetFeetLocalM();
		UE_LOG(LogDescent, Display, TEXT("M3 swim: climbed out to (%.2f, %.2f, %.2f), O2 %.1f s"), F.X, F.Y, F.Z, P->Vitals->State.O2);
		return F.Equals(FVector(M3P::LadderExitX, M3P::LadderExitY, M3P::LadderExitZ), 0.15) && P->Vitals->State.O2 == P->Vitals->State.O2Max && !P->IsSwimming();
	});
	S.Shot(TEXT("after_ladder"));

	// drowning: back in (E at the ladder sign does the same), no O2
	S.Exec(TEXT("Descent.Player.PoolDrop"));
	M3ExpectMode(S, EDescentMode::Swim);
	S.Exec(TEXT("Descent.Player.Intent 0 0 -1 0 0 1.5 0 0 0"));
	S.WaitSim(1.7);
	S.Exec(TEXT("Descent.Player.Set o2 0"));
	S.WaitFrames(2);
	S.Do(TEXT("health at the start"), [Tr](FDescentScenarioContext& C) { Tr->Value = M3Char(C)->Vitals->State.Health; Tr->Time0 = C.Sim()->SimTime(); Tr->Value2 = M3Char(C)->Vitals->State.Debt; });
	S.WaitSim(3.0);
	S.Expect(TEXT("with O2 0 health falls 9 per second; the HUD says DROWNING"), [Tr](FDescentScenarioContext& C)
	{
		const double Dt = C.Sim()->SimTime() - Tr->Time0;
		const double Rate = (Tr->Value - M3Char(C)->Vitals->State.Health) / Dt;
		const FDescentHudModel* H = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 swim: health %.2f -> %.2f over %.3f s of sim: %.3f per second; warning '%s'"), Tr->Value, M3Char(C)->Vitals->State.Health, Dt, Rate, H ? *H->Warnings.Text : TEXT(""));
		if (FMath::Abs(Rate - 9.0) > 0.3) { C.Fail(FString::Printf(TEXT("health rate %.3f per second"), Rate)); return false; }
		return H && H->Warnings.Text == TEXT("DROWNING");
	});
	S.Exec(TEXT("Descent.Player.Set health 12"));
	M3WaitMode(S, EDescentMode::Dead, 3.0);
	S.Do(TEXT("when death came"), [Tr](FDescentScenarioContext& C) { Tr->Time0 = C.Sim()->SimTime(); });
	M3WaitMode(S, EDescentMode::Foot, 4.0);
	S.Expect(TEXT("respawn after 2.6 s in the galley at (24, -5, -3), health 60, O2 full, debt +900"), [Tr](FDescentScenarioContext& C)
	{
		const ADescentCharacter* P = M3Char(C);
		const FVector F = P->GetFeetLocalM();
		const Descent::Carrier::FRoomDef* Room = Descent::Carrier::FLayout::Get().RoomAt(F + FVector(0, 0, 0.3));
		const FDescentVitalsState& V = P->Vitals->State;
		const double Took = C.Sim()->SimTime() - Tr->Time0;
		UE_LOG(LogDescent, Display, TEXT("M3 swim: respawn after %.2f s in room %s at (%.2f, %.2f, %.2f), health %.1f, O2 %.1f, debt %.0f -> %.0f, reason '%s'"), Took, Room ? *Room->Id.ToString() : TEXT("(none)"), F.X, F.Y, F.Z, V.Health, V.O2, Tr->Value2, V.Debt, *V.DeadReason);
		return Room && Room->Id == TEXT("galley") && FVector2D(F.X - M3P::RespawnX, F.Y - M3P::RespawnY).Size() < 0.3 && FMath::Abs(V.Health - 60.0) < 1.0 && V.O2 == V.O2Max
			&& V.Debt - Tr->Value2 == M3P::DebtDrownCr && FMath::Abs(Took - M3P::RespawnAfterSec) < 0.15 && V.DeadReason == TEXT("drown");
	});
	S.WaitSim(1.2);
	S.Shot(TEXT("respawn_galley"));
	S.DumpState(TEXT("end"));
	S.Quit();
}

// =====================================================================================================================
// m3_no_walls (U7): nothing invisible stops the Tender or the swimmer anywhere.
// =====================================================================================================================

namespace
{
	/** Moves the Tender from the pocket centre along one axis by intent and checks the distance and the depth readouts. */
	void M3TenderAxis(FDescentScenarioBuilder& S, const TCHAR* Name, const FVector& Axis)
	{
		S.Exec(FString::Printf(TEXT("Descent.Tender.Teleport %.1f %.1f %.1f"), M3Pocket.X, M3Pocket.Y, M3Pocket.Z));
		const bool bVertical = FMath::Abs(Axis.Z) > 0.5;
		if (!bVertical)
		{
			const FVector Look = M3Pocket + Axis * 50.0;
			S.Exec(FString::Printf(TEXT("Descent.Tender.LookAt %.1f %.1f %.1f"), Look.X, Look.Y, Look.Z));
		}
		S.WaitFrames(2);
		M3Fly(S, bVertical ? 0.0 : 1.0, 0.0, bVertical ? Axis.Z : 0.0, 1.8, false);   // about 11.4 m at 9 m/s: short of the pocket wall
		S.WaitFrames(6);   // the HUD model is written at 10 Hz
		S.Expect(FString::Printf(TEXT("(b) the Tender moves >= 10 m along %s in the pocket and the depth readouts follow"), Name), [Axis, Name](FDescentScenarioContext& C)
		{
			const AKazahTender* T = M3Tender(C);
			const FVector P = Descent::UUToMetres(T->GetActorLocation());
			const double Along = FVector::DotProduct(P - M3Pocket, Axis);
			const FString Want = FDescentHudModel::FormatDepth(Descent::DepthOfZ(P.Z));
			const FString Dash = SDescentDash::MakeReadout(T->Flight->MakeDashModel()).DepthText;
			const FDescentHudModel* H = M3Hud(C);
			UE_LOG(LogDescent, Display, TEXT("M3 no_walls (b) Tender %s: moved %.2f m to (%.1f, %.1f, %.1f), contacts %d, dash '%s', HUD '%s', expected '%s'"), Name, Along, P.X, P.Y, P.Z, T->Flight->Contacts, *Dash, H ? *H->DepthText : TEXT(""), *Want);
			if (Along < 10.0) { C.Fail(FString::Printf(TEXT("moved only %.2f m along %s"), Along, Name)); return false; }
			if (Dash != Want || !H || H->DepthText != Want) { C.Fail(TEXT("the depth readout did not follow")); return false; }
			return true;
		});
	}

	/** The same for the swimmer: real character movement, so it runs in real frames. */
	void M3SwimAxis(FDescentScenarioBuilder& S, const TCHAR* Name, const FVector& Axis)
	{
		S.Exec(FString::Printf(TEXT("Descent.Player.Swim %.1f %.1f %.1f"), M3Pocket.X, M3Pocket.Y, M3Pocket.Z));
		S.Exec(TEXT("Descent.Player.Set o2 45"));
		const bool bVertical = FMath::Abs(Axis.Z) > 0.5;
		const double Yaw = FMath::RadiansToDegrees(FMath::Atan2(Axis.Y, Axis.X));
		S.Exec(FString::Printf(TEXT("Descent.Player.Look %.1f 0"), bVertical ? 0.0 : Yaw));
		S.WaitFrames(3);
		S.Exec(FString::Printf(TEXT("Descent.Player.Intent %d 0 %d 0 0 3.4 0 0 1"), bVertical ? 0 : 1, bVertical ? static_cast<int32>(Axis.Z) : 0));
		S.WaitSim(3.6);
		S.Expect(FString::Printf(TEXT("(e) the swimmer moves >= 10 m along %s in the pocket and the depth readout follows"), Name), [Axis, Name](FDescentScenarioContext& C)
		{
			const ADescentCharacter* P = M3Char(C);
			const FVector Pos = Descent::UUToMetres(P->GetActorLocation());
			const double Along = FVector::DotProduct(Pos - M3Pocket, Axis);
			const FString Want = FDescentHudModel::FormatDepth(Descent::DepthOfZ(Pos.Z));
			const FDescentHudModel* H = M3Hud(C);
			UE_LOG(LogDescent, Display, TEXT("M3 no_walls (e) swimmer %s: moved %.2f m to (%.1f, %.1f, %.1f), HUD '%s', expected '%s'"), Name, Along, Pos.X, Pos.Y, Pos.Z, H ? *H->DepthText : TEXT(""), *Want);
			if (Along < 10.0) { C.Fail(FString::Printf(TEXT("swam only %.2f m along %s"), Along, Name)); return false; }
			return H && H->DepthText == Want;
		});
	}
}

DESCENT_SCENARIO(m3_no_walls, "U7: (a) east from canyon_mid at boost until rock is touched; (b) 10 m along +-X, +-Y, +-Z in a pocket carved at (5000, 0, -300), outside every v2 bound; (c) the dash reads 3,680 m at Z -1,900; (d) flying up: Shear warning above Z 10, never above Z 135, never more than 2 m/s of change in a step; (e) the same pocket for the swimmer. Shot shear.")
{
	S.TimeLimit(420.f);
	// the pocket and the deep shaft, in rock that has never been part of any map
	M3CarveRoom(S, M3Pocket, 11.0, 9.0);
	M3CarveRoom(S, FVector(5000.0, 0.0, -1900.0), 7.0, 4.0);
	S.Expect(TEXT("the pocket is water, the rock 40 m from it is solid"), [](FDescentScenarioContext& C)
	{
		UDescentTerrainSubsystem* T = UDescentTerrainSubsystem::Get(C.World);
		return T->Density(M3Pocket) < 0.0 && T->Density(M3Pocket + FVector(40, 0, 0)) > 0.0 && T->Density(FVector(5000, 0, -1900)) < 0.0;
	});

	// ---- (e) the swimmer in the pocket (first: the player is still on foot) ----
	M3SwimAxis(S, TEXT("+X"), FVector(1, 0, 0));
	M3SwimAxis(S, TEXT("-X"), FVector(-1, 0, 0));
	M3SwimAxis(S, TEXT("+Y"), FVector(0, 1, 0));
	M3SwimAxis(S, TEXT("-Y"), FVector(0, -1, 0));
	M3SwimAxis(S, TEXT("+Z"), FVector(0, 0, 1));
	M3SwimAxis(S, TEXT("-Z"), FVector(0, 0, -1));
	// keep going down: the only thing that ends the swim is the pocket's own rock
	S.Exec(TEXT("Descent.Player.Set o2 45"));
	S.Exec(TEXT("Descent.Player.Intent 0 0 -1 0 0 6 0 0 1"));
	S.WaitSim(5.0);
	S.Expect(TEXT("(e) and the swimmer is stopped by the pocket's rock, not before it"), [](FDescentScenarioContext& C)
	{
		const UDescentCharacterMovement* Mv = Cast<UDescentCharacterMovement>(M3Char(C)->GetCharacterMovement());
		const FVector Pos = Descent::UUToMetres(M3Char(C)->GetActorLocation());
		const double D = UDescentTerrainSubsystem::Get(C.World)->Density(Pos);
		UE_LOG(LogDescent, Display, TEXT("M3 no_walls (e): at the end of -Z the swimmer is %.2f m from rock (density %.3f), rock contacts %d"), -D, D, Mv ? Mv->SwimContacts : -1);
		return D < 0.0 && D > -1.5 && Pos.Z < M3Pocket.Z - 15.0;
	});
	S.Exec(TEXT("Descent.Player.Place bay"));
	S.WaitSim(0.5);
	M3BoardAndLaunch(S);

	// ---- (a) east from canyon_mid at boost until the hull touches rock ----
	S.Exec(TEXT("Descent.Tender.Teleport canyon_mid"));
	S.Do(TEXT("face east (+Y)"), [](FDescentScenarioContext& C)
	{
		AKazahTender* T = M3Tender(C);
		T->SetActorRotation(FRotator(0.0, 90.0, 0.0));
		T->Flight->SyncFromActor();
	});
	DescentWorldScn::WaitStreamIdle(S, 60.f);
	TSharedRef<FM3Track> A = MakeShared<FM3Track>();
	S.Until(TEXT("(a) fly east at boost until contacts > 0"), [A](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector P = Descent::UUToMetres(T->GetActorLocation());
		if (A->Time0 < 0.0) { A->Time0 = C.Sim()->SimTime(); A->StartM = P; }
		if (T->Flight->Contacts > 0) { C.Sim()->ClearDebugIntent(); return true; }
		if (C.Sim()->SimTime() - A->Time0 > 60.0) { C.Fail(FString::Printf(TEXT("no rock touched in 60 s of flying east; at (%.1f, %.1f, %.1f)"), P.X, P.Y, P.Z)); return true; }
		A->Max = FMath::Max(A->Max, T->Flight->VelMps.Size());
		FDescentIntent I;
		I.Move.X = 1.0;
		I.bSprint = true;
		C.Sim()->SetDebugIntent(I, 0.2);
		return false;
	});
	S.Expect(TEXT("(a) the Tender kept moving until it met rock that is really there"), [A](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector P = Descent::UUToMetres(T->GetActorLocation());
		UDescentTerrainSubsystem* Terrain = UDescentTerrainSubsystem::Get(C.World);
		const FVector Nose = Descent::UUToMetres(T->ToWorldUU(FVector(3.7, 0.0, 0.0)));
		const double NoseD = Terrain->Density(Nose), Ahead = Terrain->Density(Nose + FVector(0, 3, 0));
		const double Ray = Terrain->Raycast(Descent::UUToMetres(T->ToWorldUU(FVector(1.95, 0.0, 0.72))), FVector(0, 1, 0), 30.0);
		UE_LOG(LogDescent, Display, TEXT("M3 no_walls (a): flew %.1f m east from (%.0f, %.0f, %.0f) to (%.1f, %.1f, %.1f) in %.1f s, top speed %.2f m/s, contacts %d; density at the nose %.2f, 3 m ahead %.2f; rock %.2f m ahead of the eye"),
			P.Y - A->StartM.Y, A->StartM.X, A->StartM.Y, A->StartM.Z, P.X, P.Y, P.Z, C.Sim()->SimTime() - A->Time0, A->Max, T->Flight->Contacts, NoseD, Ahead, Ray);
		if (P.Y - A->StartM.Y < 15.0) { C.Fail(TEXT("the Tender stopped within 15 m of the start")); return false; }
		if (A->Max < 14.0) { C.Fail(FString::Printf(TEXT("top speed %.2f m/s, boost should reach about 15.3"), A->Max)); return false; }
		if (Ahead <= 0.0 || Ray < 0.0 || Ray > 8.0) { C.Fail(TEXT("the Tender stopped with no rock in front of it")); return false; }
		return true;
	});
	// back off a few metres so the headlamp shows the wall that stopped the Tender (pressed against it, the lamp lights only its own spot)
	S.Exec(TEXT("Descent.Player.Intent -1 0 0 0 0 1.3 0 0 0"));
	S.WaitSim(1.8);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("rock_east"));
	S.Expect(TEXT("(a) the rock is in the picture: lit by the headlamp"), [](FDescentScenarioContext& C)
	{
		UE_LOG(LogDescent, Display, TEXT("M3 no_walls (a): shot rock_east mean luma %.4f, centre %.4f"), C.LastShotStats.MeanLuma, C.LastShotStats.CentreLuma);
		return C.LastShotStats.CentreLuma > 0.05;
	});
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	S.Exec(TEXT("Descent.Tender.Set hull 100"));

	// ---- (b) the pocket at (5000, 0, -300) ----
	M3TenderAxis(S, TEXT("+X"), FVector(1, 0, 0));
	M3TenderAxis(S, TEXT("-X"), FVector(-1, 0, 0));
	M3TenderAxis(S, TEXT("+Y"), FVector(0, 1, 0));
	M3TenderAxis(S, TEXT("-Y"), FVector(0, -1, 0));
	M3TenderAxis(S, TEXT("+Z"), FVector(0, 0, 1));
	M3TenderAxis(S, TEXT("-Z"), FVector(0, 0, -1));
	S.Exec(FString::Printf(TEXT("Descent.Tender.Teleport %.1f %.1f %.1f"), M3Pocket.X, M3Pocket.Y, M3Pocket.Z));
	DescentWorldScn::WaitStreamIdle(S, 60.f);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("pocket_cockpit"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));

	// ---- (c) Z -1,900: the dash reads 3,680 m (1,380 m below the rating: checked at once, the hull is failing) ----
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Exec(TEXT("Descent.Tender.Teleport 5000 0 -1900"));
	S.WaitFrames(8);
	S.Expect(TEXT("(c) at Z -1,900 the dash and the HUD read 3,680 m"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const SDescentDash::FReadout R = SDescentDash::MakeReadout(T->Flight->MakeDashModel());
		const FTenderDashModel* Mounted = T->GetDashMain() ? T->GetDashMain()->GetDashModel() : nullptr;
		const FDescentHudModel* H = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 no_walls (c): Z %.1f, dash '%s' '%s', mounted dash depth %.1f, HUD '%s' band '%s'"), T->GetActorLocation().Z / 100.0, *R.DepthText, *R.RatingText, Mounted ? Mounted->DepthM : -1.0, H ? *H->DepthText : TEXT(""), H ? *H->Band : TEXT(""));
		return R.DepthText == TEXT("3,680 m") && H && H->DepthText == TEXT("3,680 m") && Mounted && FMath::Abs(Mounted->DepthM - 3680.0) < 0.5;
	});
	S.Shot(TEXT("deep_cockpit"));
	S.Exec(TEXT("Descent.Tender.Teleport canyon_mid"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));

	// ---- (d) up from the canyon into the Shear ----
	S.Do(TEXT("level, over the canyon"), [](FDescentScenarioContext& C)
	{
		AKazahTender* T = M3Tender(C);
		T->SetActorRotation(FRotator(0.0, 0.0, 0.0));
		T->Flight->SyncFromActor();
		T->Flight->HullHP = T->Flight->Stats().HullMax;
	});
	TSharedRef<FM3Track> D = MakeShared<FM3Track>();
	S.Until(TEXT("(d) rise at boost for 25 s"), [D](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector P = Descent::UUToMetres(T->GetActorLocation());
		const double Now = C.Sim()->SimTime();
		if (D->Time0 < 0.0) { D->Time0 = Now; D->StartM = P; D->Value = Now; D->Prev = -1.0; }
		else if (Now > D->Value + 1e-6)
		{
			// the speed the Tender really moves with (thrust plus current), from one step to the next
			const double Speed = (P - D->StartM).Size() / (Now - D->Value);
			if (D->Prev >= 0.0) { D->MaxJump = FMath::Max(D->MaxJump, FMath::Abs(Speed - D->Prev)); }
			D->Prev = Speed;
			D->StartM = P;
			D->Value = Now;
			++D->Count;
		}
		D->Max = FMath::Max(D->Max, P.Z);
		const FDescentHudModel* H = M3Hud(C);
		if (P.Z > 13.0 && H && !H->Warnings.bShear) { D->bFlag = true; }      // above Z 10 without a warning (the HUD model is written at 10 Hz: 3 m of grace at 15 m/s)
		if (P.Z > 13.0 && H && H->Warnings.bShear) { D->bFlag2 = true; }
		if (Now - D->Time0 > 25.0) { C.Sim()->ClearDebugIntent(); return true; }
		FDescentIntent I;
		I.Move.Z = 1.0;
		I.bSprint = true;
		C.Sim()->SetDebugIntent(I, 0.2);
		return false;
	});
	S.Expect(TEXT("(d) a current, not a wall: warned above Z 10, never above Z 135, never more than 2 m/s of change in one step"), [D](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector P = Descent::UUToMetres(T->GetActorLocation());
		const FDescentHudModel* H = M3Hud(C);
		UE_LOG(LogDescent, Display, TEXT("M3 no_walls (d): highest Z %.2f m, settled at Z %.2f with the Shear at %.2f m/s against 15.3 m/s of thrust; largest change of speed in one step %.3f m/s over %d steps; warning seen %d, missed %d; HUD '%s'"),
			D->Max, P.Z, Descent::World::FDescentShear::VelocityAt(P).Size(), D->MaxJump, D->Count, D->bFlag2, D->bFlag, H ? *H->Warnings.Text : TEXT(""));
		if (D->Max > 135.0) { C.Fail(FString::Printf(TEXT("the Tender reached Z %.1f"), D->Max)); return false; }
		if (D->Max < 40.0) { C.Fail(FString::Printf(TEXT("the Tender only reached Z %.1f: something stopped it below the rim"), D->Max)); return false; }
		if (D->MaxJump > 2.0) { C.Fail(FString::Printf(TEXT("the speed changed by %.2f m/s in one step"), D->MaxJump)); return false; }
		if (!D->bFlag2 || D->bFlag) { C.Fail(TEXT("the Shear warning was not shown above Z 10")); return false; }
		return H && H->Warnings.Text.Contains(TEXT("SHEAR CURRENT"));
	});
	S.Exec(TEXT("Descent.Player.Intent 0 0 1 0 0 3 0 0 1"));
	S.WaitSim(0.5);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("shear"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	S.Expect(TEXT("ui.hud.shear_warning is true in the state dump"), [](FDescentScenarioContext& C)
	{
		const TSharedRef<FJsonObject> Snap = C.Snapshot();
		const TSharedPtr<FJsonObject>* Ui = nullptr; const TSharedPtr<FJsonObject>* Hud = nullptr;
		bool bShear = false;
		return Snap->TryGetObjectField(TEXT("ui"), Ui) && (*Ui)->TryGetObjectField(TEXT("hud"), Hud) && (*Hud)->TryGetBoolField(TEXT("shear_warning"), bShear) && bShear;
	});
	S.DumpState(TEXT("end"));
	S.Quit();
}

// =====================================================================================================================
// m3_cockpit (V6, V10): what the pilot sees, and that the dashboards sit inside the hull.
// =====================================================================================================================

DESCENT_SCENARIO(m3_cockpit, "V6 / V10: the cockpit from the pilot's eye in the lit bay (ahead, left, right, down at the dash) and at sea with the headlamp on; the nose from outside, to see that the dashboards do not poke through the hull.")
{
	S.TimeLimit(240.f);
	S.Exec(TEXT("Descent.Tender.Board"));
	M3WaitMode(S, EDescentMode::Docked);
	S.WaitSim(0.8);
	S.Shot(TEXT("bay_ahead"));
	S.Exec(TEXT("Descent.Player.Intent 0 0 0 -60 0 1 0 0 0"));
	S.WaitSim(1.2);
	S.Shot(TEXT("bay_left"));
	S.Exec(TEXT("Descent.Player.Intent 0 0 0 120 0 1 0 0 0"));
	S.WaitSim(1.2);
	S.Shot(TEXT("bay_right"));
	S.Exec(TEXT("Descent.Player.Intent 0 0 0 -60 -30 1 0 0 0"));
	S.WaitSim(1.2);
	S.Expect(TEXT("docked: the mouse looks around the cockpit and does not steer"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector2D L = T->GetCockpitLook();
		UE_LOG(LogDescent, Display, TEXT("M3 cockpit: docked look yaw %.1f pitch %.1f, Tender yaw %.2f"), L.X, L.Y, T->GetActorRotation().Yaw);
		return FMath::Abs(L.X) < 1.0 && FMath::Abs(L.Y + 30.0) < 1.0 && FMath::Abs(FRotator::NormalizeAxis(T->GetActorRotation().Yaw)) < 0.01;
	});
	S.Shot(TEXT("bay_dash"));
	// from outside, in the light of the bay: above the nose and from the starboard bow
	S.LookAt(M3CarrierOrigin + FVector(-25.6, 6.0, -3.6), M3CarrierOrigin + FVector(-26.6, 6.0, -6.0), 60.f);
	S.Shot(TEXT("nose_from_above"));
	S.LookAt(M3CarrierOrigin + FVector(-23.6, 8.2, -5.2), M3CarrierOrigin + FVector(-26.9, 6.0, -5.9), 50.f);
	S.Shot(TEXT("tender_close_bay"));
	M3ViewPlayer(S);
	S.Exec(TEXT("Descent.Tender.Launch"));
	M3WaitMode(S, EDescentMode::Sub);
	// at sea: toward the canyon wall so the headlamp has something to show
	S.Exec(TEXT("Descent.Tender.Teleport spur_e1"));
	DescentWorldScn::WaitStreamIdle(S, 60.f);
	S.Exec(TEXT("Descent.Player.Intent 0.6 0 0 0 0 1.5 0 0 0"));
	S.WaitSim(1.5);
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("sea_ahead"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	// U11: the cargo display with a partly filled hold, from the hold itself (Descent.Tender.GiveOre appends real chunks)
	S.Exec(TEXT("Descent.Tender.GiveOre ferrite 3"));
	S.Exec(TEXT("Descent.Tender.GiveOre cobalt 2"));
	S.WaitSim(1.0);
	S.Expect(TEXT("the mounted cargo display shows the hold: 5 of 8, ferrite then cobalt"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FCargoDisplayModel* M = T->GetDashCargo() ? T->GetDashCargo()->GetCargoModel() : nullptr;
		return M && M->Used() == 5 && M->Cap == 8 && M->CountOf(TEXT("ferrite")) == 3 && M->CountOf(TEXT("cobalt")) == 2 && M->Order[0] == TEXT("ferrite") && M->Order[4] == TEXT("cobalt");
	});
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Shot(TEXT("cargo_filled"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	// leave through the roof hatch, look at it open, get back in
	S.WaitSim(2.5);
	S.Exec(TEXT("Descent.Tender.Exit"));
	M3ExpectMode(S, EDescentMode::Swim);
	S.Until(TEXT("the roof hatch is open"), [](FDescentScenarioContext& C) { const AKazahTender* T = M3Tender(C); return !T || T->GetHatchOpen01() >= 0.99 || C.SecondsInStep() > 20.0; });
	S.Exec(TEXT("Descent.Sim.Pause 1"));
	S.Do(TEXT("camera above the hatch"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector Cam = Descent::UUToMetres(T->ToWorldUU(FVector(2.4, -2.6, 3.0))), Look = Descent::UUToMetres(T->ToWorldUU(FVector(0.0, 0.0, 1.2)));
		C.Debug->PlaceCamera(Cam, (Look - Cam).Rotation(), 50.f);
	});
	DescentWorldScn::ShotAllowDark(S, TEXT("hatch_open"));
	S.Exec(TEXT("Descent.Sim.Pause 0"));
	M3ViewPlayer(S);
	S.Exec(TEXT("Descent.Tender.Enter"));
	M3ExpectMode(S, EDescentMode::Sub);
	// rising into the moon pool docks without E: nothing invisible holds the Tender under the open mouth
	S.Exec(FString::Printf(TEXT("Descent.Tender.Teleport %.1f %.1f %.1f"), -29.0, 6.0, M3CarrierOrigin.Z - 21.0));
	S.Exec(FString::Printf(TEXT("Descent.Tender.LookAt %.1f %.1f %.1f"), 30.0, 6.0, M3CarrierOrigin.Z - 21.0));
	S.Exec(TEXT("Descent.Player.Intent 0 0 1 0 0 4 0 0 0"));
	M3WaitMode(S, EDescentMode::Dock, 4.0);
	S.Expect(TEXT("the hoist took the Tender as it rose into the pool mouth"), [](FDescentScenarioContext& C)
	{
		const AKazahTender* T = M3Tender(C);
		const FVector L = UDescentCarrierSubsystem::GetCarrier(C.World)->ToLocalM(T->GetActorLocation());
		UE_LOG(LogDescent, Display, TEXT("M3 cockpit: auto-dock began at carrier-local z %.2f, contacts %d"), L.Z, T->Flight->Contacts);
		return L.Z > -14.5 && L.Z < -11.5;
	});
	M3WaitMode(S, EDescentMode::Docked, 6.0);
	S.DumpState(TEXT("end"));
	S.Quit();
}