Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

feat(verse): add the knife strike and the paired finisher (#1140)

Ruben Lütked4f17c4db779
diff --git a/unreal/Verse/Data/melee/hookbill.json b/unreal/Verse/Data/melee/hookbill.json
new file mode 100644
index 0000000000..34f71b302a
--- /dev/null
+++ b/unreal/Verse/Data/melee/hookbill.json
@@ -0,0 +1,30 @@
+{
+ "schema": "verse.melee/1",
+ "id": "hookbill",
+ "display_name": "Hookbill",
+ "owner": "WP04",
+ "strike": {
+ "damage": 55,
+ "hit_delay_s": 0.15,
+ "cooldown_s": 0.7,
+ "range_m": 2.0,
+ "cone_half_angle_deg": 30
+ },
+ "finisher": {
+ "range_m": 1.5,
+ "max_height_delta_m": 0.6,
+ "front_half_angle_deg": 60,
+ "attacker_facing_max_deg": 45,
+ "duration_s": 2.5,
+ "kill_time_s": 2.1
+ },
+ "presentation": {
+ "equip_s": 0.12,
+ "swing_recover_s": 0.3,
+ "paired_offset_m": 0.7,
+ "victim_snap_s": 0.1,
+ "camera_distance_m": 2.6,
+ "camera_height_m": 1.2,
+ "camera_blend_s": 0.15
+ }
+}
diff --git a/unreal/Verse/Source/VerseCombat/Private/Finisher/VerseFinisherTimeline.cpp b/unreal/Verse/Source/VerseCombat/Private/Finisher/VerseFinisherTimeline.cpp
new file mode 100644
index 0000000000..746caff546
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Finisher/VerseFinisherTimeline.cpp
@@ -0,0 +1,267 @@
+#include "Finisher/VerseFinisherTimeline.h"
+
+namespace
+{
+ double Smoothstep(double X)
+ {
+ X = FMath::Clamp(X, 0.0, 1.0);
+ return X * X * (3.0 - 2.0 * X);
+ }
+
+ FTransform Blend(const FTransform& A, const FTransform& B, double Alpha)
+ {
+ const FVector Location = FMath::Lerp(A.GetLocation(), B.GetLocation(), Alpha);
+ const FQuat Rotation = FQuat::Slerp(A.GetRotation(), B.GetRotation(), Alpha).GetNormalized();
+ return FTransform(Rotation, Location, B.GetScale3D());
+ }
+
+ FRotator YawOnly(double YawDeg)
+ {
+ return FRotator(0.0, YawDeg, 0.0);
+ }
+}
+
+double VerseFinisher::PhaseOffset(EVerseFinisherPhase Phase)
+{
+ switch (Phase)
+ {
+ case EVerseFinisherPhase::Locked:
+ return 0.0;
+ case EVerseFinisherPhase::Takedown:
+ return TakedownAt;
+ case EVerseFinisherPhase::Struggle:
+ return StruggleAt;
+ case EVerseFinisherPhase::Kill:
+ return KillAt;
+ case EVerseFinisherPhase::Recover:
+ return RecoverAt;
+ default:
+ return -1.0;
+ }
+}
+
+EVerseFinisherPhase VerseFinisher::PhaseAt(double Elapsed)
+{
+ const double T = Elapsed + TimeTolerance;
+ if (T >= RecoverAt)
+ {
+ return EVerseFinisherPhase::Recover;
+ }
+ if (T >= KillAt)
+ {
+ return EVerseFinisherPhase::Kill;
+ }
+ if (T >= StruggleAt)
+ {
+ return EVerseFinisherPhase::Struggle;
+ }
+ if (T >= TakedownAt)
+ {
+ return EVerseFinisherPhase::Takedown;
+ }
+ return EVerseFinisherPhase::Locked;
+}
+
+void FVerseFinisherSession::Start(double Now)
+{
+ StartTime = Now;
+ Phase = EVerseFinisherPhase::Locked;
+ bActive = true;
+ bKillApplied = false;
+ bAborted = false;
+ bReleased = false;
+}
+
+bool FVerseFinisherSession::Advance(double Now, double AttackerDeathTime, TArray<FVerseFinisherStep>& OutEntered)
+{
+ if (!bActive || bReleased)
+ {
+ return false;
+ }
+ const EVerseFinisherPhase Order[] = {EVerseFinisherPhase::Takedown, EVerseFinisherPhase::Struggle,
+ EVerseFinisherPhase::Kill, EVerseFinisherPhase::Recover};
+ // D5: the attacker's death before the kill time aborts; at or after it the kill stands.
+ // Strict: the death time is an event stamp, not a tick, so no tick tolerance applies here.
+ const bool bDiesBeforeKill = AttackerDeathTime < StartTime + VerseFinisher::RecoverAt;
+ for (const EVerseFinisherPhase Next : Order)
+ {
+ if (uint8(Next) <= uint8(Phase))
+ {
+ continue;
+ }
+ const double At = StartTime + VerseFinisher::PhaseOffset(Next);
+ if (bDiesBeforeKill && AttackerDeathTime <= At && AttackerDeathTime <= Now)
+ {
+ break;
+ }
+ if (Now + VerseFinisher::TimeTolerance < At)
+ {
+ break;
+ }
+ Phase = Next;
+ OutEntered.Add({Next, Now});
+ if (Next == EVerseFinisherPhase::Recover)
+ {
+ bKillApplied = true;
+ }
+ }
+ if (bDiesBeforeKill && AttackerDeathTime <= Now && !bKillApplied)
+ {
+ Phase = EVerseFinisherPhase::Aborted;
+ bAborted = true;
+ bReleased = true;
+ bActive = false;
+ OutEntered.Add({EVerseFinisherPhase::Aborted, Now});
+ return true;
+ }
+ if (VerseFinisher::IsOver(Elapsed(Now)))
+ {
+ bReleased = true;
+ bActive = false;
+ return true;
+ }
+ return false;
+}
+
+void FVerseFinisherPose::ComputePaired(const FTransform& Attacker, const FTransform& Victim, double PairedOffsetCm,
+ FTransform& OutVictim, FTransform& OutWarpTarget)
+{
+ const FVector A = Attacker.GetLocation();
+ const FVector V = Victim.GetLocation();
+ FVector2D Dir(V.X - A.X, V.Y - A.Y);
+ if (Dir.SizeSquared() < 1e-4)
+ {
+ const FVector Forward = Victim.GetRotation().GetForwardVector();
+ Dir = FVector2D(Forward.X, Forward.Y);
+ }
+ Dir.Normalize();
+ const double YawDeg = FMath::RadiansToDegrees(FMath::Atan2(Dir.Y, Dir.X));
+ OutVictim = FTransform(YawOnly(YawDeg), V, Victim.GetScale3D());
+ const FVector Target(V.X - Dir.X * PairedOffsetCm, V.Y - Dir.Y * PairedOffsetCm, A.Z);
+ OutWarpTarget = FTransform(YawOnly(YawDeg), Target, Attacker.GetScale3D());
+}
+
+FTransform FVerseFinisherPose::VictimFromWarpTarget(const FTransform& WarpTarget, double PairedOffsetCm, double VictimZ)
+{
+ const FVector Forward = WarpTarget.GetRotation().GetForwardVector().GetSafeNormal2D();
+ FVector Location = WarpTarget.GetLocation() + Forward * PairedOffsetCm;
+ Location.Z = VictimZ;
+ return FTransform(WarpTarget.GetRotation(), Location, WarpTarget.GetScale3D());
+}
+
+FTransform FVerseFinisherPose::EvaluateWarp(const FTransform& StartPose, double StartElapsed, const FTransform& Target,
+ double Elapsed)
+{
+ const double Span = VerseFinisher::TakedownAt - StartElapsed;
+ // Too little time left to blend (Locked arrived late): snap, so the pose is right at Takedown.
+ if (Span < VerseFinisher::MinWarpS || Elapsed + VerseFinisher::TimeTolerance >= VerseFinisher::TakedownAt)
+ {
+ return Target;
+ }
+ return Blend(StartPose, Target, Smoothstep((Elapsed - StartElapsed) / Span));
+}
+
+FTransform FVerseFinisherPose::EvaluateSnap(const FTransform& From, const FTransform& To, double SinceLocked, double SnapS)
+{
+ if (SnapS <= VerseFinisher::TimeTolerance || SinceLocked >= SnapS)
+ {
+ return To;
+ }
+ return Blend(From, To, Smoothstep(SinceLocked / SnapS));
+}
+
+FVerseFinisherViewState VerseFinisher::EvaluateView(double Elapsed, bool bAborted, EVerseGoreLevel Gore)
+{
+ FVerseFinisherViewState S;
+ if (bAborted || IsOver(Elapsed) || Elapsed < -TimeTolerance)
+ {
+ return S;
+ }
+ S.bKnifeInHand = true;
+ S.bActiveWeaponEquipped = false;
+ const double T = Elapsed + TimeTolerance;
+ const bool bCut = Gore == EVerseGoreLevel::Reduced && T >= TakedownAt && T < RecoverAt;
+ S.View = bCut ? EVerseFinisherView::Black : EVerseFinisherView::ThirdPerson;
+ return S;
+}
+
+FVerseFinisherViewState VerseFinisher::EvaluateVictimView(double Elapsed, bool bAborted, EVerseGoreLevel Gore)
+{
+ FVerseFinisherViewState S;
+ if (bAborted || Elapsed < -TimeTolerance)
+ {
+ return S;
+ }
+ if (Elapsed + TimeTolerance >= RecoverAt)
+ {
+ S.bReleasedToDeathView = true;
+ S.bActiveWeaponEquipped = false;
+ return S;
+ }
+ S = EvaluateView(Elapsed, false, Gore);
+ S.bKnifeInHand = false;
+ S.bActiveWeaponEquipped = false;
+ return S;
+}
+
+FTransform VerseFinisher::CameraTransform(const FTransform& Attacker, const FTransform& Victim, double DistanceCm,
+ double HeightCm)
+{
+ const FVector A = Attacker.GetLocation();
+ const FVector V = Victim.GetLocation();
+ const FVector Mid = (A + V) * 0.5;
+ FVector Along = (V - A).GetSafeNormal2D();
+ if (Along.IsNearlyZero())
+ {
+ Along = Victim.GetRotation().GetForwardVector().GetSafeNormal2D();
+ }
+ // To the pair's right, slightly behind the attacker, so both bodies are in the shot.
+ const FVector Side(-Along.Y, Along.X, 0.0);
+ const FVector Eye = Mid + (Side * 0.94 - Along * 0.34) * DistanceCm + FVector(0.0, 0.0, HeightCm);
+ const FVector LookAt = Mid + FVector(0.0, 0.0, HeightCm * 0.35);
+ return FTransform((LookAt - Eye).Rotation(), Eye);
+}
+
+void FVerseKnifePresentation::Press(double Now, bool bKnifeSlot)
+{
+ PressTime = Now;
+ bKnifeSlotActive = bKnifeSlot;
+ bNeedsEquip = !bKnifeSlot;
+ bConfirmed = false;
+ Confirmed = EVerseMeleeOutcome::Whiff;
+}
+
+void FVerseKnifePresentation::Confirm(EVerseMeleeOutcome Outcome)
+{
+ bConfirmed = true;
+ Confirmed = Outcome;
+}
+
+EVerseKnifeAnim FVerseKnifePresentation::Evaluate(double Now) const
+{
+ const EVerseKnifeAnim Rest = bKnifeSlotActive ? EVerseKnifeAnim::Ready : EVerseKnifeAnim::Hidden;
+ const double T = Now - PressTime;
+ if (T < 0.0)
+ {
+ return Rest;
+ }
+ if (bConfirmed && Confirmed == EVerseMeleeOutcome::Finisher)
+ {
+ // The finisher presentation takes the knife over (VerseFinisher::EvaluateView).
+ return EVerseKnifeAnim::Hidden;
+ }
+ const double Equip = bNeedsEquip ? FMath::Min(EquipS, HitDelayS) : 0.0;
+ if (T < Equip)
+ {
+ return EVerseKnifeAnim::Equipping;
+ }
+ if (T < HitDelayS)
+ {
+ return EVerseKnifeAnim::Swinging;
+ }
+ if (T < HitDelayS + RecoverS)
+ {
+ return EVerseKnifeAnim::Recovering;
+ }
+ return Rest;
+}
diff --git a/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeComponent.cpp b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeComponent.cpp
new file mode 100644
index 0000000000..12c845bc5c
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeComponent.cpp
@@ -0,0 +1,720 @@
+#include "Melee/VerseMeleeComponent.h"
+
+#include "Camera/CameraActor.h"
+#include "Camera/PlayerCameraManager.h"
+#include "Combat/VerseMeleeDefinition.h"
+#include "Damage/VerseCombatStateComponent.h"
+#include "Engine/World.h"
+#include "Events/VerseEventHub.h"
+#include "GameFramework/Character.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "GameFramework/GameStateBase.h"
+#include "GameFramework/Pawn.h"
+#include "GameFramework/PlayerController.h"
+#include "Melee/VerseMeleeWorld.h"
+#include "VerseGameplayTags.h"
+#include "VerseLog.h"
+
+namespace
+{
+ /** Rewind cap (combat-state.md 1, architecture 3.2). */
+ constexpr double MaxRewindS = 0.25;
+
+ FTransform ActorFromBase(const FTransform& Base, const APawn* Pawn)
+ {
+ FTransform Out = Base;
+ Out.AddToTranslation(FVector(0.0, 0.0, VerseMelee::HalfHeightOf(Pawn)));
+ return Out;
+ }
+
+ FTransform BaseFromActor(const APawn* Pawn)
+ {
+ FVector Location = Pawn->GetActorLocation();
+ Location.Z -= VerseMelee::HalfHeightOf(Pawn);
+ return FTransform(FRotator(0.0, Pawn->GetActorRotation().Yaw, 0.0), Location);
+ }
+
+ bool IsDead(const APawn* Pawn)
+ {
+ const UVerseCombatStateComponent* State = Pawn ? Pawn->FindComponentByClass<UVerseCombatStateComponent>() : nullptr;
+ return State && State->Phase == EVerseCombatPhase::Dead;
+ }
+
+ /** The local player controller of Viewer: its own, or the one a lock remembered (a dead victim may be unpossessed). */
+ APlayerController* LocalPlayerController(APawn* Viewer, AController* Remembered)
+ {
+ AController* Controller = Viewer ? Viewer->GetController() : nullptr;
+ if (!Controller)
+ {
+ Controller = Remembered;
+ }
+ APlayerController* PC = Cast<APlayerController>(Controller);
+ return PC && PC->IsLocalController() ? PC : nullptr;
+ }
+}
+
+UVerseMeleeComponent::UVerseMeleeComponent()
+{
+ PrimaryComponentTick.bCanEverTick = true;
+ PrimaryComponentTick.bStartWithTickEnabled = false;
+ PrimaryComponentTick.TickGroup = TG_PrePhysics;
+ SetIsReplicatedByDefault(true);
+}
+
+EVerseMeleeOutcome UVerseMeleeComponent::Classify(const FTransform& Attacker, const FTransform& Victim,
+ const UVerseMeleeDefinition& Def, bool bVictimEligible, bool bSweepClear)
+{
+ return VerseMelee::ClassifyMeasured(FVerseMeleeGeometry::Measure(Attacker, Victim), Def, bVictimEligible, bSweepClear);
+}
+
+void UVerseMeleeComponent::BeginPlay()
+{
+ Super::BeginPlay();
+ EnsureDefinition();
+ if (UVerseEventHub* Hub = UVerseEventHub::Get(this))
+ {
+ DeathHandle = Hub->OnDeath.AddUObject(this, &UVerseMeleeComponent::OnHubDeath);
+ }
+}
+
+void UVerseMeleeComponent::EndPlay(const EEndPlayReason::Type Reason)
+{
+ if (UVerseEventHub* Hub = UVerseEventHub::Get(this))
+ {
+ Hub->OnDeath.Remove(DeathHandle);
+ }
+ EndPresentation();
+ Super::EndPlay(Reason);
+}
+
+void UVerseMeleeComponent::EnsureDefinition()
+{
+ if (Definition)
+ {
+ return;
+ }
+ Definition = NewObject<UVerseMeleeDefinition>(this, TEXT("Melee_Hookbill"), RF_Transient);
+ FString Error;
+ if (!FVerseMeleeImport::FromFile(FVerseMeleeImport::DefaultPath(), *Definition, Tuning, Error))
+ {
+ UE_LOG(LogVerseCombat, Warning, TEXT("melee: %s; using the contract start values"), *Error);
+ }
+ Knife.EquipS = Tuning.EquipS;
+ Knife.HitDelayS = Definition->StrikeHitDelay;
+ Knife.RecoverS = Tuning.SwingRecoverS;
+}
+
+const UVerseMeleeDefinition& UVerseMeleeComponent::GetDefinition() const
+{
+ return Definition ? *Definition : *GetDefault<UVerseMeleeDefinition>();
+}
+
+IVerseMeleeWorld* UVerseMeleeComponent::MeleeWorld() const
+{
+ return UVerseMeleeWorldSubsystem::Get(this);
+}
+
+APawn* UVerseMeleeComponent::OwnerPawn() const
+{
+ return Cast<APawn>(GetOwner());
+}
+
+double UVerseMeleeComponent::ServerNow() const
+{
+ const UWorld* World = GetWorld();
+ if (!World)
+ {
+ return 0.0;
+ }
+ if (const AGameStateBase* GameState = World->GetGameState())
+ {
+ return GameState->GetServerWorldTimeSeconds();
+ }
+ return World->GetTimeSeconds();
+}
+
+EVerseKnifeAnim UVerseMeleeComponent::GetKnifeAnim() const
+{
+ return Knife.Evaluate(ServerNow());
+}
+
+void UVerseMeleeComponent::PressMelee(bool bKnifeSlotActive)
+{
+ EnsureDefinition();
+ const double Now = ServerNow();
+ if (IsInFinisher() || !Clock.CanPress(Now))
+ {
+ return;
+ }
+ // Predicted presentation only; the client's clock copy never decides anything.
+ Knife.Press(Now, bKnifeSlotActive);
+ if (!GetOwner()->HasAuthority())
+ {
+ // A remote client keeps its own copy of the cooldown so it does not spam the server.
+ Clock.TryPress(Now, GetDefinition().StrikeCooldown);
+ }
+ ServerMelee(float(Now));
+}
+
+void UVerseMeleeComponent::ServerMelee_Implementation(float ClientServerTime)
+{
+ EVerseMeleeOutcome Outcome = EVerseMeleeOutcome::Whiff;
+ HandleMeleePress(double(ClientServerTime), Outcome);
+}
+
+void UVerseMeleeComponent::ClientConfirmMelee_Implementation(EVerseMeleeOutcome Outcome)
+{
+ Knife.Confirm(Outcome);
+}
+
+bool UVerseMeleeComponent::HandleMeleePress(double ViewServerTime, EVerseMeleeOutcome& OutOutcome)
+{
+ OutOutcome = EVerseMeleeOutcome::Whiff;
+ APawn* Me = OwnerPawn();
+ IVerseMeleeWorld* World = MeleeWorld();
+ if (!Me || !World || !Me->HasAuthority())
+ {
+ return false;
+ }
+ EnsureDefinition();
+ const UVerseMeleeDefinition& Def = GetDefinition();
+ const double Now = World->ServerNow();
+ const FVerseMeleeParticipant MeState = World->Describe(Me);
+ if (!VerseMelee::CanStartMelee(MeState) || Session.bActive || !Clock.TryPress(Now, Def.StrikeCooldown))
+ {
+ return false;
+ }
+ // A melee press is an offensive action (combat-state.md 9.3).
+ VerseMelee::EndSpawnProtection(Me, Now);
+
+ const double ViewTime = FMath::Clamp(ViewServerTime, Now - MaxRewindS, Now);
+ const FTransform MeBase = World->GetBaseTransformAt(Me, ViewTime);
+ TArray<APawn*> Candidates;
+ World->GetCandidates(Me, Candidates);
+
+ APawn* FinisherTarget = nullptr;
+ APawn* StrikeTarget = nullptr;
+ double FinisherDist = TNumericLimits<double>::Max();
+ double StrikeDist = TNumericLimits<double>::Max();
+ for (APawn* Candidate : Candidates)
+ {
+ const FVerseMeleeParticipant Target = World->Describe(Candidate);
+ if (Target.Phase == EVerseCombatPhase::Dead)
+ {
+ continue;
+ }
+ const FTransform TargetBase = World->GetBaseTransformAt(Candidate, ViewTime);
+ const FVerseMeleeGeometry Geometry = FVerseMeleeGeometry::Measure(MeBase, TargetBase);
+ const bool bEligible = VerseMelee::IsFinisherEligible(MeState, Target);
+ EVerseMeleeOutcome Result = VerseMelee::ClassifyMeasured(Geometry, Def, bEligible, true);
+ if (Result == EVerseMeleeOutcome::Finisher && !World->IsSweepClear(Me, Candidate))
+ {
+ Result = VerseMelee::ClassifyMeasured(Geometry, Def, bEligible, false);
+ }
+ if (Result == EVerseMeleeOutcome::Finisher && Geometry.HorizontalCm < FinisherDist)
+ {
+ FinisherTarget = Candidate;
+ FinisherDist = Geometry.HorizontalCm;
+ }
+ else if (Result == EVerseMeleeOutcome::Strike && VerseMelee::CanBeStruck(Target) && Geometry.ReachCm() < StrikeDist)
+ {
+ StrikeTarget = Candidate;
+ StrikeDist = Geometry.ReachCm();
+ }
+ }
+
+ if (FinisherTarget)
+ {
+ OutOutcome = EVerseMeleeOutcome::Finisher;
+ StartFinisher(FinisherTarget, Now);
+ }
+ else if (StrikeTarget)
+ {
+ OutOutcome = EVerseMeleeOutcome::Strike;
+ RaiseNoise(VerseTags::Noise_Melee);
+ const TWeakObjectPtr<APawn> Weak(StrikeTarget);
+ if (Def.StrikeHitDelay <= 0.f)
+ {
+ ApplyStrike(Weak);
+ }
+ else
+ {
+ // Applied by the server tick on the first tick at or after the hit delay (7.3).
+ PendingStrikes.Add({Weak, Now + Def.StrikeHitDelay});
+ SetComponentTickEnabled(true);
+ }
+ }
+ else
+ {
+ RaiseNoise(VerseTags::Noise_Melee);
+ }
+ ClientConfirmMelee(OutOutcome);
+ return true;
+}
+
+void UVerseMeleeComponent::ApplyStrike(TWeakObjectPtr<APawn> Victim)
+{
+ APawn* Me = OwnerPawn();
+ IVerseMeleeWorld* World = MeleeWorld();
+ if (!Me || !World || !Victim.IsValid())
+ {
+ return;
+ }
+ if (World->Describe(Me).Phase == EVerseCombatPhase::Dead)
+ {
+ return;
+ }
+ FVerseHitEvent Hit;
+ Hit.InstigatorId = VerseMelee::PlayerIdOf(Me);
+ Hit.VictimId = VerseMelee::PlayerIdOf(Victim.Get());
+ Hit.WeaponId = Tuning.WeaponId;
+ Hit.Source = EVerseDamageSource::Melee;
+ // StrikeZone: multiplier 1.0 regardless of bone (7.3); reported as the torso.
+ Hit.Zone = EVerseHitZone::UpperTorso;
+ const FVector From = Me->GetActorLocation();
+ const FVector To = Victim->GetActorLocation();
+ Hit.ImpactWorld = FVector_NetQuantize10(To);
+ Hit.Direction = FVector_NetQuantizeNormal((To - From).GetSafeNormal());
+ Hit.DistanceM = float(FVector::Dist(From, To) / 100.0);
+ Hit.Damage = GetDefinition().StrikeDamage;
+ World->ApplyMeleeHit(Me, Victim.Get(), Hit);
+}
+
+void UVerseMeleeComponent::RaiseNoise(const FGameplayTag& Tag) const
+{
+ const APawn* Me = OwnerPawn();
+ UVerseEventHub* Hub = UVerseEventHub::Get(this);
+ if (!Me || !Hub)
+ {
+ return;
+ }
+ FVerseNoiseEvent Noise;
+ Noise.Noise = Tag;
+ Noise.SourceId = VerseMelee::PlayerIdOf(Me);
+ Noise.Location = Me->GetActorLocation();
+ Noise.ServerTime = float(ServerNow());
+ Hub->OnNoise.Broadcast(Noise);
+}
+
+void UVerseMeleeComponent::StartFinisher(APawn* Victim, double Now)
+{
+ APawn* Me = OwnerPawn();
+ Session.Start(Now);
+ SessionVictim = Victim;
+ AttackerDeathTime = FVerseFinisherSession::NoDeath;
+ Clock.BlockUntil(Now + VerseFinisher::EndAt);
+
+ FTransform VictimPaired;
+ FTransform WarpBase;
+ FVerseFinisherPose::ComputePaired(BaseFromActor(Me), BaseFromActor(Victim), Tuning.PairedOffsetCm, VictimPaired, WarpBase);
+ SessionWarpTarget = ActorFromBase(WarpBase, Me);
+ SessionWarpStart = Me->GetActorTransform();
+
+ VerseMelee::SetPhase(Me, EVerseCombatPhase::FinisherAttacker);
+ VerseMelee::SetPhase(Victim, EVerseCombatPhase::FinisherVictim);
+ // 7.4 "no input": both pawns are held from Locked to release (owning clients lock on the event).
+ LockPawn(Me, SessionWarpTarget.Rotator().Yaw);
+ LockPawn(Victim, VictimPaired.Rotator().Yaw);
+ // The server snaps the victim to the paired pose at once; clients smooth to it (4.6).
+ Victim->SetActorLocationAndRotation(ActorFromBase(VictimPaired, Victim).GetLocation(), VictimPaired.GetRotation());
+
+ SetComponentTickEnabled(true);
+ SendPhase(EVerseFinisherPhase::Locked);
+}
+
+void UVerseMeleeComponent::SendPhase(EVerseFinisherPhase Phase)
+{
+ FVerseFinisherEvent E;
+ E.AttackerId = VerseMelee::PlayerIdOf(OwnerPawn());
+ E.VictimId = VerseMelee::PlayerIdOf(SessionVictim.Get());
+ E.Phase = Phase;
+ E.SequenceStartServerTime = float(Session.StartTime);
+ E.WarpTarget = SessionWarpTarget;
+ MulticastFinisher(E);
+}
+
+void UVerseMeleeComponent::OnHubDeath(const FVerseDeathEvent& E)
+{
+ if (Session.bActive && E.VictimId == VerseMelee::PlayerIdOf(OwnerPawn()))
+ {
+ AttackerDeathTime = FMath::Min(AttackerDeathTime, double(E.ServerTime));
+ }
+}
+
+void UVerseMeleeComponent::AdvanceFinisherServer(double Now)
+{
+ APawn* Me = OwnerPawn();
+ IVerseMeleeWorld* World = MeleeWorld();
+ if (!Me || !World)
+ {
+ return;
+ }
+ if (World->Describe(Me).Phase == EVerseCombatPhase::Dead)
+ {
+ AttackerDeathTime = FMath::Min(AttackerDeathTime, Now);
+ }
+ TArray<FVerseFinisherStep> Entered;
+ const bool bReleased = Session.Advance(Now, AttackerDeathTime, Entered);
+ for (const FVerseFinisherStep& Step : Entered)
+ {
+ switch (Step.Phase)
+ {
+ case EVerseFinisherPhase::Takedown:
+ RaiseNoise(VerseTags::Noise_Finisher);
+ break;
+ case EVerseFinisherPhase::Recover:
+ if (APawn* Victim = SessionVictim.Get())
+ {
+ FVerseHitEvent Hit;
+ Hit.InstigatorId = VerseMelee::PlayerIdOf(Me);
+ Hit.VictimId = VerseMelee::PlayerIdOf(Victim);
+ Hit.WeaponId = Tuning.WeaponId;
+ Hit.Source = EVerseDamageSource::Finisher;
+ Hit.Zone = EVerseHitZone::Neck;
+ Hit.Bone = FName(TEXT("Neck"));
+ Hit.ImpactWorld = FVector_NetQuantize10(Victim->GetActorLocation());
+ Hit.Direction = FVector_NetQuantizeNormal(Victim->GetActorForwardVector());
+ World->ApplyMeleeHit(Me, Victim, Hit);
+ }
+ break;
+ case EVerseFinisherPhase::Aborted:
+ // Both released; the victim keeps its health (nothing was applied to it).
+ if (APawn* Victim = SessionVictim.Get())
+ {
+ if (World->Describe(Victim).Phase == EVerseCombatPhase::FinisherVictim)
+ {
+ VerseMelee::SetPhase(Victim, EVerseCombatPhase::Alive);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ SendPhase(Step.Phase);
+ }
+ if (bReleased)
+ {
+ if (World->Describe(Me).Phase == EVerseCombatPhase::FinisherAttacker)
+ {
+ VerseMelee::SetPhase(Me, EVerseCombatPhase::Alive);
+ }
+ ReleaseLocks();
+ SessionVictim.Reset();
+ }
+}
+
+void UVerseMeleeComponent::MulticastFinisher_Implementation(const FVerseFinisherEvent& E)
+{
+ if (UVerseEventHub* Hub = UVerseEventHub::Get(this))
+ {
+ Hub->OnFinisher.Broadcast(E);
+ }
+ if (E.Phase == EVerseFinisherPhase::Locked)
+ {
+ BeginPresentation(E);
+ }
+ else if (E.Phase == EVerseFinisherPhase::Aborted)
+ {
+ bPresentAborted = true;
+ UpdateLocalViews(ServerNow() - PresentStart);
+ EndPresentation();
+ }
+}
+
+void UVerseMeleeComponent::BeginPresentation(const FVerseFinisherEvent& E)
+{
+ APawn* Me = OwnerPawn();
+ if (!Me)
+ {
+ return;
+ }
+ const double Now = ServerNow();
+ bPresenting = true;
+ bPresentAborted = false;
+ PresentStart = E.SequenceStartServerTime;
+ WarpTarget = E.WarpTarget;
+ WarpStartElapsed = Me->HasAuthority() ? 0.0 : FMath::Max(0.0, Now - PresentStart);
+ WarpStartPose = Me->HasAuthority() ? SessionWarpStart : Me->GetActorTransform();
+ PresentVictim = VerseMelee::FindPawnById(GetWorld(), E.VictimId);
+ if (APawn* Victim = PresentVictim.Get())
+ {
+ VictimFrom = Victim->GetActorTransform();
+ VictimTo = FVerseFinisherPose::VictimFromWarpTarget(WarpTarget, Tuning.PairedOffsetCm, VictimFrom.GetLocation().Z);
+ LockPawn(Victim, VictimTo.Rotator().Yaw);
+ }
+ LockPawn(Me, WarpTarget.Rotator().Yaw);
+ SnapStartTime = Now;
+ LastViews.Reset();
+ Knife.Confirm(EVerseMeleeOutcome::Finisher);
+ SetComponentTickEnabled(true);
+ TickPresentation(Now);
+}
+
+void UVerseMeleeComponent::TickPresentation(double Now)
+{
+ APawn* Me = OwnerPawn();
+ if (!bPresenting || !Me)
+ {
+ return;
+ }
+ const double Elapsed = Now - PresentStart;
+ // 4.4: the attacker reaches Warp_Finisher at Takedown on every machine.
+ if (Elapsed <= VerseFinisher::TakedownAt + 0.1)
+ {
+ const FTransform Pose = FVerseFinisherPose::EvaluateWarp(WarpStartPose, WarpStartElapsed, WarpTarget, Elapsed);
+ Me->SetActorLocationAndRotation(Pose.GetLocation(), Pose.GetRotation());
+ }
+ // 4.6: the victim's client smooths to the paired pose (the server snapped it already).
+ if (APawn* Victim = PresentVictim.Get())
+ {
+ const double Since = Now - SnapStartTime;
+ if (!Me->HasAuthority() && Since <= Tuning.VictimSnapS + 0.1)
+ {
+ const FTransform Pose = FVerseFinisherPose::EvaluateSnap(VictimFrom, VictimTo, Since, Tuning.VictimSnapS);
+ Victim->SetActorLocationAndRotation(Pose.GetLocation(), Pose.GetRotation());
+ }
+ }
+ UpdateLocalViews(Elapsed);
+ if (VerseFinisher::IsOver(Elapsed))
+ {
+ EndPresentation();
+ }
+}
+
+bool UVerseMeleeComponent::IsPawnLocked(const APawn* Pawn) const
+{
+ return Pawn && Locks.ContainsByPredicate([Pawn](const FPawnLock& L) { return L.Pawn.Get() == Pawn; });
+}
+
+void UVerseMeleeComponent::LockPawn(APawn* Pawn, double PairedYaw)
+{
+ if (!Pawn)
+ {
+ return;
+ }
+ if (FPawnLock* Existing = Locks.FindByPredicate([Pawn](const FPawnLock& L) { return L.Pawn.Get() == Pawn; }))
+ {
+ Existing->Yaw = PairedYaw;
+ return;
+ }
+ // The server holds every pawn; a client holds only the pawn it controls (the rest follow replication).
+ const bool bAuthority = Pawn->HasAuthority();
+ const bool bLocal = Pawn->IsLocallyControlled();
+ if (!bAuthority && !bLocal)
+ {
+ return;
+ }
+ FPawnLock Lock;
+ Lock.Pawn = Pawn;
+ Lock.Yaw = PairedYaw;
+ if (AController* Controller = Pawn->GetController())
+ {
+ Controller->SetIgnoreMoveInput(true);
+ Controller->SetIgnoreLookInput(true);
+ Lock.Controller = Controller;
+ Lock.bInputIgnored = true;
+ // bUseControllerRotationYaw puts the actor back to the control rotation every frame, so the
+ // control rotation carries the paired yaw.
+ const FRotator Paired(0.0, PairedYaw, 0.0);
+ Controller->SetControlRotation(Paired);
+ APlayerController* PC = Cast<APlayerController>(Controller);
+ if (PC && bAuthority && !bLocal)
+ {
+ PC->ClientSetRotation(Paired, false);
+ }
+ }
+ if (ACharacter* Character = Cast<ACharacter>(Pawn))
+ {
+ if (UCharacterMovementComponent* Movement = Character->GetCharacterMovement())
+ {
+ Lock.PrevMovementMode = uint8(Movement->MovementMode.GetValue());
+ Lock.PrevCustomMode = Movement->CustomMovementMode;
+ Movement->StopMovementImmediately();
+ Movement->DisableMovement();
+ Lock.bMovementStopped = true;
+ }
+ }
+ Locks.Add(Lock);
+}
+
+void UVerseMeleeComponent::HoldLocks()
+{
+ for (const FPawnLock& Lock : Locks)
+ {
+ // A bot's focus or a stray rotation update must not turn a locked pawn.
+ AController* Controller = Lock.Controller.Get();
+ if (Controller && Lock.bInputIgnored
+ && FMath::Abs(FRotator::NormalizeAxis(Controller->GetControlRotation().Yaw - Lock.Yaw)) > 0.01)
+ {
+ Controller->SetControlRotation(FRotator(0.0, Lock.Yaw, 0.0));
+ }
+ }
+}
+
+void UVerseMeleeComponent::ReleaseLocks()
+{
+ for (const FPawnLock& Lock : Locks)
+ {
+ AController* Controller = Lock.Controller.Get();
+ if (Controller && Lock.bInputIgnored)
+ {
+ Controller->SetIgnoreMoveInput(false);
+ Controller->SetIgnoreLookInput(false);
+ }
+ // A dead pawn's movement belongs to the death path (ragdoll, respawn).
+ ACharacter* Character = Cast<ACharacter>(Lock.Pawn.Get());
+ if (Character && Lock.bMovementStopped && !IsDead(Character) && Character->GetCharacterMovement())
+ {
+ Character->GetCharacterMovement()->SetMovementMode(EMovementMode(Lock.PrevMovementMode), Lock.PrevCustomMode);
+ }
+ }
+ Locks.Reset();
+}
+
+void UVerseMeleeComponent::UpdateLocalViews(double Elapsed)
+{
+ APawn* Me = OwnerPawn();
+ APawn* Victim = PresentVictim.Get();
+ if (!Me)
+ {
+ return;
+ }
+ // Per role (7.4): only the attacker returns to first person with its weapon; the victim is
+ // released to the death view at Recover.
+ const EVerseGoreLevel Gore = VerseMelee::GetLocalGoreLevel();
+ const FTransform Camera = VerseFinisher::CameraTransform(Me->GetActorTransform(),
+ Victim ? Victim->GetActorTransform() : Me->GetActorTransform(), Tuning.CameraDistanceCm, Tuning.CameraHeightCm);
+ const TPair<APawn*, FVerseFinisherViewState> Viewers[] = {
+ {Me, VerseFinisher::EvaluateView(Elapsed, bPresentAborted, Gore)},
+ {Victim, VerseFinisher::EvaluateVictimView(Elapsed, bPresentAborted, Gore)}};
+ for (const TPair<APawn*, FVerseFinisherViewState>& V : Viewers)
+ {
+ if (!V.Key)
+ {
+ continue;
+ }
+ const FVerseFinisherViewState* Last = LastViews.Find(V.Key);
+ const bool bWasBlack = Last && Last->View == EVerseFinisherView::Black;
+ if (!Last || !(*Last == V.Value))
+ {
+ LastViews.Add(V.Key, V.Value);
+ OnFinisherView.Broadcast(V.Key, V.Value);
+ }
+ ApplyView(V.Key, V.Value, Camera, bWasBlack);
+ }
+}
+
+void UVerseMeleeComponent::ApplyView(APawn* Viewer, const FVerseFinisherViewState& State, const FTransform& Camera, bool bWasBlack)
+{
+ const FPawnLock* Lock = Locks.FindByPredicate([Viewer](const FPawnLock& L) { return L.Pawn.Get() == Viewer; });
+ APlayerController* Controller = LocalPlayerController(Viewer, Lock ? Lock->Controller.Get() : nullptr);
+ if (!Controller)
+ {
+ return;
+ }
+ APlayerCameraManager* CameraManager = Controller->PlayerCameraManager;
+ if (State.bReleasedToDeathView)
+ {
+ // The death view owns the view target and the fade now; only undo the cut this component made.
+ if (bWasBlack && CameraManager)
+ {
+ CameraManager->StopCameraFade();
+ }
+ return;
+ }
+ if (State.View != EVerseFinisherView::FirstPerson)
+ {
+ if (!FinisherCamera)
+ {
+ FActorSpawnParameters Params;
+ Params.ObjectFlags |= RF_Transient;
+ Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+ FinisherCamera = GetWorld()->SpawnActor<ACameraActor>(Camera.GetLocation(), Camera.Rotator(), Params);
+ }
+ if (FinisherCamera)
+ {
+ FinisherCamera->SetActorTransform(Camera);
+ if (Controller->GetViewTarget() != FinisherCamera)
+ {
+ Controller->SetViewTargetWithBlend(FinisherCamera, float(Tuning.CameraBlendS));
+ }
+ }
+ }
+ else if (Controller->GetViewTarget() != Viewer)
+ {
+ Controller->SetViewTargetWithBlend(Viewer, float(Tuning.CameraBlendS));
+ }
+ if (CameraManager)
+ {
+ if (State.View == EVerseFinisherView::Black)
+ {
+ CameraManager->SetManualCameraFade(1.f, FLinearColor::Black, false);
+ }
+ else if (bWasBlack)
+ {
+ // Only the cut this component started; a fade another system started stays.
+ CameraManager->StopCameraFade();
+ }
+ }
+}
+
+void UVerseMeleeComponent::EndPresentation()
+{
+ if (bPresenting)
+ {
+ bPresenting = false;
+ UpdateLocalViews(VerseFinisher::EndAt);
+ // A dead victim still viewing the finisher camera means no death view took it: fall back
+ // to its own pawn before the camera goes.
+ APawn* Victim = PresentVictim.Get();
+ if (Victim && FinisherCamera)
+ {
+ const FPawnLock* Lock = Locks.FindByPredicate([Victim](const FPawnLock& L) { return L.Pawn.Get() == Victim; });
+ APlayerController* Controller = LocalPlayerController(Victim, Lock ? Lock->Controller.Get() : nullptr);
+ if (Controller && Controller->GetViewTarget() == FinisherCamera)
+ {
+ Controller->SetViewTarget(Victim);
+ }
+ }
+ }
+ if (FinisherCamera)
+ {
+ FinisherCamera->Destroy();
+ FinisherCamera = nullptr;
+ }
+ ReleaseLocks();
+ PresentVictim.Reset();
+ LastViews.Reset();
+}
+
+void UVerseMeleeComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+ Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+ const double Now = ServerNow();
+ if (GetOwner() && GetOwner()->HasAuthority())
+ {
+ for (int32 Index = 0; Index < PendingStrikes.Num();)
+ {
+ if (Now + VerseMelee::TimeTolerance >= PendingStrikes[Index].ApplyAt)
+ {
+ const TWeakObjectPtr<APawn> Victim = PendingStrikes[Index].Victim;
+ PendingStrikes.RemoveAt(Index);
+ ApplyStrike(Victim);
+ }
+ else
+ {
+ ++Index;
+ }
+ }
+ if (Session.bActive)
+ {
+ AdvanceFinisherServer(Now);
+ }
+ }
+ HoldLocks();
+ TickPresentation(Now);
+ if (!Session.bActive && !bPresenting && PendingStrikes.Num() == 0)
+ {
+ SetComponentTickEnabled(false);
+ }
+}
diff --git a/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeImport.cpp b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeImport.cpp
new file mode 100644
index 0000000000..d9eb0bfc32
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeImport.cpp
@@ -0,0 +1,174 @@
+#include "Melee/VerseMeleeImport.h"
+
+#include "Combat/VerseMeleeDefinition.h"
+#include "Finisher/VerseFinisherTimeline.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+#include "Melee/VerseMeleeJson.h"
+#include "VerseCoords.h"
+
+namespace
+{
+ using EType = FVerseMeleeJson::EType;
+
+ struct FReader
+ {
+ FString& Error;
+
+ const FVerseMeleeJson* Section(const FVerseMeleeJson& Root, const TCHAR* Name)
+ {
+ const FVerseMeleeJson* Out = Root.Field(Name, EType::Object);
+ if (!Out)
+ {
+ Error = FString::Printf(TEXT("missing object '%s'"), Name);
+ }
+ return Out;
+ }
+
+ /** A number in (Min, Max]; Min itself is allowed when bMinInclusive. */
+ bool Number(const FVerseMeleeJson& Obj, const TCHAR* Section, const TCHAR* Name, double Min,
+ double Max, bool bMinInclusive, double& Out)
+ {
+ if (!Error.IsEmpty())
+ {
+ return false;
+ }
+ const FVerseMeleeJson* Field = Obj.Field(Name, EType::Number);
+ if (!Field)
+ {
+ Error = FString::Printf(TEXT("missing number '%s.%s'"), Section, Name);
+ return false;
+ }
+ Out = Field->Number;
+ const bool bAboveMin = bMinInclusive ? Out >= Min : Out > Min;
+ if (!bAboveMin || Out > Max || !FMath::IsFinite(Out))
+ {
+ Error = FString::Printf(TEXT("'%s.%s' = %g is outside %s%g, %g]"), Section, Name, Out,
+ bMinInclusive ? TEXT("[") : TEXT("("), Min, Max);
+ return false;
+ }
+ return true;
+ }
+ };
+}
+
+FString FVerseMeleeImport::DefaultPath()
+{
+ return FPaths::Combine(FPaths::ProjectDir(), TEXT("Data/melee/hookbill.json"));
+}
+
+bool FVerseMeleeImport::FromJsonString(const FString& Text, UVerseMeleeDefinition& OutDef,
+ FVerseMeleePresentationTuning& OutTuning, FString& OutError)
+{
+ OutError.Reset();
+ FString ParseError;
+ const TSharedPtr<FVerseMeleeJson> Root = FVerseMeleeJson::Parse(Text, ParseError);
+ if (!Root.IsValid() || Root->Type != EType::Object)
+ {
+ OutError = FString::Printf(TEXT("not a JSON object (%s)"), *ParseError);
+ return false;
+ }
+ const FVerseMeleeJson* SchemaValue = Root->Field(TEXT("schema"), EType::String);
+ if (!SchemaValue || SchemaValue->String != Schema)
+ {
+ OutError = FString::Printf(TEXT("schema must be '%s'"), Schema);
+ return false;
+ }
+ const FVerseMeleeJson* IdValue = Root->Field(TEXT("id"), EType::String);
+ if (!IdValue || IdValue->String.IsEmpty())
+ {
+ OutError = TEXT("missing string 'id'");
+ return false;
+ }
+ const FString Id = IdValue->String;
+
+ FReader R{OutError};
+ const FVerseMeleeJson* Strike = R.Section(*Root, TEXT("strike"));
+ if (!Strike)
+ {
+ return false;
+ }
+ const FVerseMeleeJson* Finisher = R.Section(*Root, TEXT("finisher"));
+ if (!Finisher)
+ {
+ return false;
+ }
+ const FVerseMeleeJson* Presentation = R.Section(*Root, TEXT("presentation"));
+ if (!Presentation)
+ {
+ return false;
+ }
+
+ double Damage = 0, HitDelay = 0, Cooldown = 0, Range = 0, Cone = 0;
+ double FRange = 0, FHeight = 0, FFront = 0, FFacing = 0, FDuration = 0, FKill = 0;
+ double Equip = 0, Recover = 0, Offset = 0, Snap = 0, CamDist = 0, CamHeight = 0, CamBlend = 0;
+ R.Number(*Strike, TEXT("strike"), TEXT("damage"), 0.0, 1000.0, false, Damage);
+ R.Number(*Strike, TEXT("strike"), TEXT("hit_delay_s"), 0.0, 1.0, true, HitDelay);
+ R.Number(*Strike, TEXT("strike"), TEXT("cooldown_s"), 0.0, 5.0, false, Cooldown);
+ R.Number(*Strike, TEXT("strike"), TEXT("range_m"), 0.0, 5.0, false, Range);
+ R.Number(*Strike, TEXT("strike"), TEXT("cone_half_angle_deg"), 0.0, 90.0, false, Cone);
+ R.Number(*Finisher, TEXT("finisher"), TEXT("range_m"), 0.0, 5.0, false, FRange);
+ R.Number(*Finisher, TEXT("finisher"), TEXT("max_height_delta_m"), 0.0, 2.0, true, FHeight);
+ R.Number(*Finisher, TEXT("finisher"), TEXT("front_half_angle_deg"), 0.0, 180.0, true, FFront);
+ R.Number(*Finisher, TEXT("finisher"), TEXT("attacker_facing_max_deg"), 0.0, 180.0, true, FFacing);
+ R.Number(*Finisher, TEXT("finisher"), TEXT("duration_s"), 0.0, 10.0, false, FDuration);
+ R.Number(*Finisher, TEXT("finisher"), TEXT("kill_time_s"), 0.0, 10.0, false, FKill);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("equip_s"), 0.0, 2.0, true, Equip);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("swing_recover_s"), 0.0, 2.0, true, Recover);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("paired_offset_m"), 0.0, 3.0, false, Offset);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("victim_snap_s"), 0.0, 1.0, true, Snap);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("camera_distance_m"), 0.0, 10.0, false, CamDist);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("camera_height_m"), -5.0, 10.0, true, CamHeight);
+ R.Number(*Presentation, TEXT("presentation"), TEXT("camera_blend_s"), 0.0, 2.0, true, CamBlend);
+ if (!OutError.IsEmpty())
+ {
+ return false;
+ }
+ // The phase offsets are frozen (combat-state.md 7.4); the two fields must agree with them.
+ if (!FMath::IsNearlyEqual(FDuration, VerseFinisher::EndAt, 1e-6) || !FMath::IsNearlyEqual(FKill, VerseFinisher::RecoverAt, 1e-6))
+ {
+ OutError = FString::Printf(TEXT("finisher duration_s/kill_time_s must be %g/%g (frozen phase offsets)"),
+ VerseFinisher::EndAt, VerseFinisher::RecoverAt);
+ return false;
+ }
+ if (Offset > FRange)
+ {
+ OutError = TEXT("presentation.paired_offset_m must not exceed finisher.range_m");
+ return false;
+ }
+
+ OutDef.StrikeDamage = float(Damage);
+ OutDef.StrikeHitDelay = float(HitDelay);
+ OutDef.StrikeCooldown = float(Cooldown);
+ OutDef.StrikeRange = float(Range);
+ OutDef.StrikeConeHalfAngle = float(Cone);
+ OutDef.FinisherRange = float(FRange);
+ OutDef.FinisherMaxHeightDelta = float(FHeight);
+ OutDef.FrontHalfAngle = float(FFront);
+ OutDef.AttackerFacingMax = float(FFacing);
+ OutDef.FinisherDuration = float(FDuration);
+ OutDef.FinisherKillTime = float(FKill);
+
+ using namespace Verse::Coords;
+ OutTuning.WeaponId = FName(*Id);
+ OutTuning.EquipS = FMath::Min(Equip, HitDelay);
+ OutTuning.SwingRecoverS = Recover;
+ OutTuning.PairedOffsetCm = MetresToCm(Offset);
+ OutTuning.VictimSnapS = Snap;
+ OutTuning.CameraDistanceCm = MetresToCm(CamDist);
+ OutTuning.CameraHeightCm = MetresToCm(CamHeight);
+ OutTuning.CameraBlendS = CamBlend;
+ return true;
+}
+
+bool FVerseMeleeImport::FromFile(const FString& Path, UVerseMeleeDefinition& OutDef,
+ FVerseMeleePresentationTuning& OutTuning, FString& OutError)
+{
+ FString Text;
+ if (!FFileHelper::LoadFileToString(Text, *Path))
+ {
+ OutError = FString::Printf(TEXT("cannot read %s"), *Path);
+ return false;
+ }
+ return FromJsonString(Text, OutDef, OutTuning, OutError);
+}
diff --git a/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeJson.h b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeJson.h
new file mode 100644
index 0000000000..4fcbf9dbff
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeJson.h
@@ -0,0 +1,259 @@
+#pragma once
+
+#include "CoreMinimal.h"
+
+/**
+ * A small strict JSON reader for the melee text surface. VerseCombat does not link the
+ * engine's Json module (its Build.cs belongs to the integration owner), and the importer only
+ * needs objects, strings and numbers. Arrays, booleans and null parse but are not used.
+ */
+struct FVerseMeleeJson
+{
+ enum class EType : uint8 { Null, Bool, Number, String, Array, Object };
+
+ EType Type = EType::Null;
+ bool Bool = false;
+ double Number = 0.0;
+ FString String;
+ TArray<TSharedPtr<FVerseMeleeJson>> Array;
+ TMap<FString, TSharedPtr<FVerseMeleeJson>> Object;
+
+ /** Parses a whole document; nullptr with OutError on any syntax error or trailing text. */
+ static TSharedPtr<FVerseMeleeJson> Parse(const FString& Text, FString& OutError)
+ {
+ FParser P{*Text, 0, Text.Len(), OutError};
+ TSharedPtr<FVerseMeleeJson> Root = P.Value(0);
+ P.Space();
+ if (Root.IsValid() && P.Pos != P.Len)
+ {
+ OutError = FString::Printf(TEXT("trailing text at %d"), P.Pos);
+ return nullptr;
+ }
+ return Root;
+ }
+
+ const FVerseMeleeJson* Field(const TCHAR* Name, EType Want) const
+ {
+ const TSharedPtr<FVerseMeleeJson>* Found = Type == EType::Object ? Object.Find(Name) : nullptr;
+ return (Found && Found->IsValid() && (*Found)->Type == Want) ? Found->Get() : nullptr;
+ }
+
+private:
+ struct FParser
+ {
+ const TCHAR* S;
+ int32 Pos;
+ int32 Len;
+ FString& Error;
+
+ void Space()
+ {
+ while (Pos < Len && FChar::IsWhitespace(S[Pos]))
+ {
+ ++Pos;
+ }
+ }
+
+ TSharedPtr<FVerseMeleeJson> Fail(const TCHAR* What)
+ {
+ if (Error.IsEmpty())
+ {
+ Error = FString::Printf(TEXT("%s at %d"), What, Pos);
+ }
+ return nullptr;
+ }
+
+ bool Literal(const TCHAR* Word)
+ {
+ const int32 N = FCString::Strlen(Word);
+ if (Pos + N <= Len && FCString::Strncmp(S + Pos, Word, N) == 0)
+ {
+ Pos += N;
+ return true;
+ }
+ return false;
+ }
+
+ bool StringBody(FString& Out)
+ {
+ ++Pos; // opening quote
+ while (Pos < Len)
+ {
+ const TCHAR C = S[Pos++];
+ if (C == TEXT('"'))
+ {
+ return true;
+ }
+ if (C == TEXT('\\'))
+ {
+ if (Pos >= Len)
+ {
+ return false;
+ }
+ const TCHAR E = S[Pos++];
+ switch (E)
+ {
+ case TEXT('"'): Out.AppendChar(TEXT('"')); break;
+ case TEXT('\\'): Out.AppendChar(TEXT('\\')); break;
+ case TEXT('/'): Out.AppendChar(TEXT('/')); break;
+ case TEXT('n'): Out.AppendChar(TEXT('\n')); break;
+ case TEXT('t'): Out.AppendChar(TEXT('\t')); break;
+ case TEXT('r'): Out.AppendChar(TEXT('\r')); break;
+ case TEXT('b'): Out.AppendChar(TEXT('\b')); break;
+ case TEXT('f'): Out.AppendChar(TEXT('\f')); break;
+ case TEXT('u'):
+ {
+ if (Pos + 4 > Len)
+ {
+ return false;
+ }
+ Out.AppendChar(TCHAR(FParse::HexNumber(*FString::ConstructFromPtrSize(S + Pos, 4))));
+ Pos += 4;
+ break;
+ }
+ default:
+ return false;
+ }
+ }
+ else
+ {
+ Out.AppendChar(C);
+ }
+ }
+ return false;
+ }
+
+ TSharedPtr<FVerseMeleeJson> Value(int32 Depth)
+ {
+ if (Depth > 32)
+ {
+ return Fail(TEXT("nesting too deep"));
+ }
+ Space();
+ if (Pos >= Len)
+ {
+ return Fail(TEXT("unexpected end"));
+ }
+ TSharedPtr<FVerseMeleeJson> V = MakeShared<FVerseMeleeJson>();
+ const TCHAR C = S[Pos];
+ if (C == TEXT('{'))
+ {
+ V->Type = EType::Object;
+ ++Pos;
+ Space();
+ if (Pos < Len && S[Pos] == TEXT('}'))
+ {
+ ++Pos;
+ return V;
+ }
+ while (true)
+ {
+ Space();
+ if (Pos >= Len || S[Pos] != TEXT('"'))
+ {
+ return Fail(TEXT("expected a key"));
+ }
+ FString Key;
+ if (!StringBody(Key))
+ {
+ return Fail(TEXT("bad key"));
+ }
+ Space();
+ if (Pos >= Len || S[Pos] != TEXT(':'))
+ {
+ return Fail(TEXT("expected ':'"));
+ }
+ ++Pos;
+ TSharedPtr<FVerseMeleeJson> Child = Value(Depth + 1);
+ if (!Child.IsValid())
+ {
+ return nullptr;
+ }
+ V->Object.Add(Key, Child);
+ Space();
+ if (Pos < Len && S[Pos] == TEXT(','))
+ {
+ ++Pos;
+ continue;
+ }
+ if (Pos < Len && S[Pos] == TEXT('}'))
+ {
+ ++Pos;
+ return V;
+ }
+ return Fail(TEXT("expected ',' or '}'"));
+ }
+ }
+ if (C == TEXT('['))
+ {
+ V->Type = EType::Array;
+ ++Pos;
+ Space();
+ if (Pos < Len && S[Pos] == TEXT(']'))
+ {
+ ++Pos;
+ return V;
+ }
+ while (true)
+ {
+ TSharedPtr<FVerseMeleeJson> Child = Value(Depth + 1);
+ if (!Child.IsValid())
+ {
+ return nullptr;
+ }
+ V->Array.Add(Child);
+ Space();
+ if (Pos < Len && S[Pos] == TEXT(','))
+ {
+ ++Pos;
+ continue;
+ }
+ if (Pos < Len && S[Pos] == TEXT(']'))
+ {
+ ++Pos;
+ return V;
+ }
+ return Fail(TEXT("expected ',' or ']'"));
+ }
+ }
+ if (C == TEXT('"'))
+ {
+ V->Type = EType::String;
+ return StringBody(V->String) ? V : Fail(TEXT("bad string"));
+ }
+ if (Literal(TEXT("true")))
+ {
+ V->Type = EType::Bool;
+ V->Bool = true;
+ return V;
+ }
+ if (Literal(TEXT("false")))
+ {
+ V->Type = EType::Bool;
+ return V;
+ }
+ if (Literal(TEXT("null")))
+ {
+ return V;
+ }
+ const int32 Begin = Pos;
+ while (Pos < Len && (FChar::IsDigit(S[Pos]) || S[Pos] == TEXT('-') || S[Pos] == TEXT('+')
+ || S[Pos] == TEXT('.') || S[Pos] == TEXT('e') || S[Pos] == TEXT('E')))
+ {
+ ++Pos;
+ }
+ if (Pos == Begin)
+ {
+ return Fail(TEXT("unexpected character"));
+ }
+ const FString Token = FString::ConstructFromPtrSize(S + Begin, Pos - Begin);
+ if (!(FChar::IsDigit(Token[0]) || Token[0] == TEXT('-')) || !FChar::IsDigit(Token[Token.Len() - 1]))
+ {
+ return Fail(TEXT("bad number"));
+ }
+ V->Type = EType::Number;
+ V->Number = FCString::Atod(*Token);
+ return V;
+ }
+ };
+};
diff --git a/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeRules.cpp b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeRules.cpp
new file mode 100644
index 0000000000..2f0d0932a7
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeRules.cpp
@@ -0,0 +1,116 @@
+#include "Melee/VerseMeleeRules.h"
+
+#include "Combat/VerseMeleeDefinition.h"
+#include "VerseCoords.h"
+
+const FName VerseMelee::KnifeWeaponId(TEXT("hookbill"));
+
+namespace
+{
+ EVerseGoreLevel GLocalGoreLevel = EVerseGoreLevel::Full;
+}
+
+void VerseMelee::SetLocalGoreLevel(EVerseGoreLevel Gore)
+{
+ GLocalGoreLevel = Gore;
+}
+
+EVerseGoreLevel VerseMelee::GetLocalGoreLevel()
+{
+ return GLocalGoreLevel;
+}
+
+namespace
+{
+ FVector2D FacingOf(const FTransform& Base)
+ {
+ const double YawRad = FMath::DegreesToRadians(Base.Rotator().Yaw);
+ return FVector2D(FMath::Cos(YawRad), FMath::Sin(YawRad));
+ }
+
+ double AngleBetweenDeg(const FVector2D& A, const FVector2D& B)
+ {
+ const double Dot = FMath::Clamp(FVector2D::DotProduct(A, B), -1.0, 1.0);
+ return FMath::RadiansToDegrees(FMath::Acos(Dot));
+ }
+}
+
+FVerseMeleeGeometry FVerseMeleeGeometry::Measure(const FTransform& AttackerBase, const FTransform& VictimBase)
+{
+ FVerseMeleeGeometry G;
+ const FVector A = AttackerBase.GetLocation();
+ const FVector V = VictimBase.GetLocation();
+ const FVector2D Delta(A.X - V.X, A.Y - V.Y);
+ G.HorizontalCm = Delta.Size();
+ G.DzCm = A.Z - V.Z;
+ if (G.HorizontalCm < 0.1)
+ {
+ G.ThetaDeg = 0.0;
+ G.PhiDeg = 0.0;
+ return G;
+ }
+ const FVector2D D = Delta / G.HorizontalCm;
+ G.ThetaDeg = AngleBetweenDeg(FacingOf(VictimBase), D);
+ G.PhiDeg = AngleBetweenDeg(FacingOf(AttackerBase), -D);
+ return G;
+}
+
+bool VerseMelee::IsFinisherEligible(const FVerseMeleeParticipant& Attacker, const FVerseMeleeParticipant& Victim)
+{
+ const bool bVictimOk = Victim.Phase == EVerseCombatPhase::Alive && !Victim.bSpawnProtected
+ && Victim.Stance != EVerseStance::Prone && !Victim.bMantling;
+ const bool bAttackerOk = Attacker.Phase == EVerseCombatPhase::Alive && !Attacker.bAirborne
+ && Attacker.Stance != EVerseStance::Prone;
+ return bVictimOk && bAttackerOk;
+}
+
+bool VerseMelee::CanStartMelee(const FVerseMeleeParticipant& Attacker)
+{
+ return Attacker.Phase == EVerseCombatPhase::Alive;
+}
+
+bool VerseMelee::CanBeStruck(const FVerseMeleeParticipant& Victim)
+{
+ return Victim.Phase == EVerseCombatPhase::Alive || Victim.Phase == EVerseCombatPhase::FinisherAttacker;
+}
+
+EVerseMeleeOutcome VerseMelee::ClassifyMeasured(const FVerseMeleeGeometry& G, const UVerseMeleeDefinition& Def,
+ bool bEligible, bool bSweepClear)
+{
+ using namespace Verse::Coords;
+ const bool bFront = G.ThetaDeg <= Def.FrontHalfAngle + AngleToleranceDeg;
+ const bool bFinisherGeometry = !bFront
+ && G.HorizontalCm <= MetresToCm(Def.FinisherRange) + DistanceToleranceCm
+ && G.PhiDeg <= Def.AttackerFacingMax + AngleToleranceDeg
+ && FMath::Abs(G.DzCm) <= MetresToCm(Def.FinisherMaxHeightDelta) + DistanceToleranceCm;
+ if (bFinisherGeometry && bEligible && bSweepClear)
+ {
+ return EVerseMeleeOutcome::Finisher;
+ }
+ const bool bStrike = G.ReachCm() <= MetresToCm(Def.StrikeRange) + DistanceToleranceCm
+ && G.PhiDeg <= Def.StrikeConeHalfAngle + AngleToleranceDeg;
+ return bStrike ? EVerseMeleeOutcome::Strike : EVerseMeleeOutcome::Whiff;
+}
+
+bool VerseMelee::AllowsDamage(EVerseCombatPhase VictimPhase, EVerseDamageSource Source)
+{
+ switch (VictimPhase)
+ {
+ case EVerseCombatPhase::Dead:
+ return false;
+ case EVerseCombatPhase::FinisherVictim:
+ return Source == EVerseDamageSource::Finisher;
+ default:
+ return true;
+ }
+}
+
+bool FVerseMeleeClock::TryPress(double Now, double CooldownS)
+{
+ if (!CanPress(Now))
+ {
+ return false;
+ }
+ NextPressAllowed = Now + CooldownS;
+ return true;
+}
diff --git a/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeWorld.cpp b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeWorld.cpp
new file mode 100644
index 0000000000..bf70f5665e
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Melee/VerseMeleeWorld.cpp
@@ -0,0 +1,247 @@
+#include "Melee/VerseMeleeWorld.h"
+
+#include "CollisionQueryParams.h"
+#include "Components/CapsuleComponent.h"
+#include "Damage/VerseCombatStateComponent.h"
+#include "Engine/World.h"
+#include "EngineUtils.h"
+#include "Events/VerseEventHub.h"
+#include "GameFramework/Character.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "GameFramework/GameStateBase.h"
+#include "GameFramework/Pawn.h"
+#include "GameFramework/PlayerState.h"
+#include "Movement/VerseMovementQuery.h"
+#include "Net/Core/PushModel/PushModel.h"
+#include "Stubs/VerseNullStubs.h"
+
+int32 VerseMelee::PlayerIdOf(const APawn* Pawn)
+{
+ if (!Pawn)
+ {
+ return -1;
+ }
+ if (const APlayerState* State = Pawn->GetPlayerState())
+ {
+ return State->GetPlayerId();
+ }
+ return int32(Pawn->GetUniqueID());
+}
+
+APawn* VerseMelee::FindPawnById(const UWorld* World, int32 Id)
+{
+ if (!World)
+ {
+ return nullptr;
+ }
+ for (TActorIterator<APawn> It(const_cast<UWorld*>(World)); It; ++It)
+ {
+ if (PlayerIdOf(*It) == Id)
+ {
+ return *It;
+ }
+ }
+ return nullptr;
+}
+
+void VerseMelee::SetPhase(APawn* Pawn, EVerseCombatPhase Phase)
+{
+ UVerseCombatStateComponent* State = Pawn ? Pawn->FindComponentByClass<UVerseCombatStateComponent>() : nullptr;
+ if (State && State->Phase != Phase)
+ {
+ State->Phase = Phase;
+ MARK_PROPERTY_DIRTY_FROM_NAME(UVerseCombatStateComponent, Phase, State);
+ }
+}
+
+void VerseMelee::EndSpawnProtection(APawn* Pawn, double ServerNow)
+{
+ UVerseCombatStateComponent* State = Pawn ? Pawn->FindComponentByClass<UVerseCombatStateComponent>() : nullptr;
+ if (!State)
+ {
+ return;
+ }
+ if (State->bSpawnProtected)
+ {
+ State->bSpawnProtected = false;
+ MARK_PROPERTY_DIRTY_FROM_NAME(UVerseCombatStateComponent, bSpawnProtected, State);
+ }
+ if (double(State->SpawnProtectedUntil) > ServerNow)
+ {
+ State->SpawnProtectedUntil = float(ServerNow);
+ MARK_PROPERTY_DIRTY_FROM_NAME(UVerseCombatStateComponent, SpawnProtectedUntil, State);
+ }
+}
+
+double VerseMelee::HalfHeightOf(const APawn* Pawn)
+{
+ const ACharacter* Character = Cast<ACharacter>(Pawn);
+ return Character && Character->GetCapsuleComponent() ? Character->GetCapsuleComponent()->GetScaledCapsuleHalfHeight() : 0.0;
+}
+
+double FVerseInterimMeleeWorld::ServerNow() const
+{
+ const UWorld* W = World.Get();
+ if (!W)
+ {
+ return 0.0;
+ }
+ if (const AGameStateBase* GameState = W->GetGameState())
+ {
+ return GameState->GetServerWorldTimeSeconds();
+ }
+ return W->GetTimeSeconds();
+}
+
+FTransform FVerseInterimMeleeWorld::GetBaseTransformAt(const APawn* Pawn, double /*ServerTime*/) const
+{
+ // Fake rewind (WP02.8 pending): the current transform.
+ if (!Pawn)
+ {
+ return FTransform::Identity;
+ }
+ FVector Location = Pawn->GetActorLocation();
+ Location.Z -= VerseMelee::HalfHeightOf(Pawn);
+ return FTransform(FRotator(0.0, Pawn->GetActorRotation().Yaw, 0.0), Location);
+}
+
+FVerseMeleeParticipant FVerseInterimMeleeWorld::Describe(const APawn* Pawn) const
+{
+ FVerseMeleeParticipant P;
+ if (!Pawn)
+ {
+ P.Phase = EVerseCombatPhase::Dead;
+ return P;
+ }
+ if (const UVerseCombatStateComponent* State = Pawn->FindComponentByClass<UVerseCombatStateComponent>())
+ {
+ P.Phase = State->Phase;
+ P.bSpawnProtected = State->bSpawnProtected;
+ }
+ const IVerseMovementQuery* Query = nullptr;
+ if (UActorComponent* Component = Pawn->FindComponentByInterface(UVerseMovementQuery::StaticClass()))
+ {
+ Query = Cast<IVerseMovementQuery>(Component);
+ }
+ if (!Query)
+ {
+ Query = GetDefault<UVerseNullMovementQuery>();
+ }
+ P.Stance = Query->GetStance();
+ P.bMantling = Query->IsMantling();
+ P.bAirborne = Query->IsAirborne();
+ return P;
+}
+
+bool FVerseInterimMeleeWorld::IsSweepClear(const APawn* Attacker, const APawn* Victim) const
+{
+ UWorld* W = World.Get();
+ if (!W || !Attacker || !Victim)
+ {
+ return false;
+ }
+ FCollisionQueryParams Params(SCENE_QUERY_STAT(VerseMeleeSweep), false);
+ Params.AddIgnoredActor(Attacker);
+ Params.AddIgnoredActor(Victim);
+ FCollisionObjectQueryParams Objects;
+ Objects.AddObjectTypesToQuery(ECC_WorldStatic);
+ Objects.AddObjectTypesToQuery(ECC_WorldDynamic);
+ // A thin capsule between the two chest heights: walls, cover and glass block, the floor does not.
+ const FVector From = Attacker->GetActorLocation();
+ const FVector To = Victim->GetActorLocation();
+ return !W->SweepTestByObjectType(From, To, FQuat::Identity, Objects, FCollisionShape::MakeCapsule(15.f, 40.f), Params);
+}
+
+void FVerseInterimMeleeWorld::GetCandidates(const APawn* Attacker, TArray<APawn*>& Out) const
+{
+ UWorld* W = World.Get();
+ if (!W)
+ {
+ return;
+ }
+ for (TActorIterator<APawn> It(W); It; ++It)
+ {
+ if (*It != Attacker && !It->IsPendingKillPending())
+ {
+ Out.Add(*It);
+ }
+ }
+}
+
+float FVerseInterimMeleeWorld::GetHealth(const APawn* Pawn) const
+{
+ const float* Found = Health.Find(Pawn);
+ return Found ? *Found : StartHealth;
+}
+
+void FVerseInterimMeleeWorld::ApplyMeleeHit(APawn* Attacker, APawn* Victim, FVerseHitEvent& Hit)
+{
+ if (!Victim)
+ {
+ return;
+ }
+ const FVerseMeleeParticipant Target = Describe(Victim);
+ const float Before = GetHealth(Victim);
+ float Applied = 0.f;
+ if (Target.bSpawnProtected && Hit.Source != EVerseDamageSource::Finisher)
+ {
+ Hit.bBlockedBySpawnProtection = 1;
+ }
+ else if (VerseMelee::AllowsDamage(Target.Phase, Hit.Source) && Before > 0.f)
+ {
+ const float Asked = Hit.Source == EVerseDamageSource::Finisher ? Before : Hit.Damage;
+ Applied = FMath::Min(Asked, Before);
+ }
+ const float After = Before - Applied;
+ Health.Add(Victim, After);
+ Hit.Damage = Applied;
+ Hit.bKillingBlow = (Applied > 0.f && After <= 0.f) ? 1 : 0;
+ Hit.ServerTime = float(ServerNow());
+
+ UVerseEventHub* Hub = UVerseEventHub::Get(Victim);
+ if (Hub)
+ {
+ Hub->OnHit.Broadcast(Hit);
+ }
+ if (Hit.bKillingBlow)
+ {
+ VerseMelee::SetPhase(Victim, EVerseCombatPhase::Dead);
+ if (Hub)
+ {
+ FVerseDeathEvent Death;
+ Death.VictimId = Hit.VictimId;
+ Death.KillerId = Hit.InstigatorId;
+ Death.Cause = Hit.Source;
+ Death.WeaponId = Hit.WeaponId;
+ Death.LastZone = Hit.Zone;
+ Death.ServerTime = Hit.ServerTime;
+ // The respawn delay is the ruleset's (WP11); 3.0 s is the deathmatch start value.
+ Death.RespawnAt = Hit.ServerTime + 3.f;
+ Hub->OnDeath.Broadcast(Death);
+ }
+ }
+}
+
+IVerseMeleeWorld* UVerseMeleeWorldSubsystem::Get(const UObject* WorldContextObject)
+{
+ if (!WorldContextObject || !GEngine)
+ {
+ return nullptr;
+ }
+ const UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::ReturnNull);
+ const UVerseMeleeWorldSubsystem* Subsystem = World ? World->GetSubsystem<UVerseMeleeWorldSubsystem>() : nullptr;
+ return Subsystem ? &Subsystem->GetWorldPort() : nullptr;
+}
+
+void UVerseMeleeWorldSubsystem::Initialize(FSubsystemCollectionBase& Collection)
+{
+ Super::Initialize(Collection);
+ Interim = MakeShared<FVerseInterimMeleeWorld>(GetWorld());
+}
+
+void UVerseMeleeWorldSubsystem::Deinitialize()
+{
+ Override.Reset();
+ Interim.Reset();
+ Super::Deinitialize();
+}
diff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Finisher/VerseFinisherTests.cpp b/unreal/Verse/Source/VerseCombat/Private/Tests/Finisher/VerseFinisherTests.cpp
new file mode 100644
index 0000000000..a8b67db8ac
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Tests/Finisher/VerseFinisherTests.cpp
@@ -0,0 +1,694 @@
+#include "Combat/VerseMeleeDefinition.h"
+#include "Events/VerseEventHub.h"
+#include "Finisher/VerseFinisherTimeline.h"
+#include "GameFramework/PlayerController.h"
+#include "Melee/VerseMeleeComponent.h"
+#include "Melee/VerseMeleeRules.h"
+#include "Misc/AutomationTest.h"
+#include "Tests/Melee/Fakes/VerseMeleeTestWorld.h"
+#include "VerseGameplayTags.h"
+#include "VerseRng.h"
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#define VERSE_FINISHER_TEST_FLAGS (EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)
+
+namespace VerseFinisherTest
+{
+ constexpr double ServerTick = 1.0 / 60.0;
+
+ const EVerseFinisherPhase TimedPhases[] = {EVerseFinisherPhase::Takedown, EVerseFinisherPhase::Struggle,
+ EVerseFinisherPhase::Kill, EVerseFinisherPhase::Recover};
+
+ /** One lagged client of the netcode simulation (architecture 3.1: PktLag=60, variance 10, loss 1 %). */
+ struct FSimClient
+ {
+ const TCHAR* Name;
+ double FrameHz;
+ double ClockErrorS; // server-time estimate minus true server time
+ double FramePhaseS; // first frame offset
+ double MaxLatencyS; // cap for this client's one-way latency
+ };
+
+ /** Reliable, ordered arrival times for events sent at SendTimes. */
+ TArray<double> Deliver(const TArray<double>& SendTimes, FVerseRng& Rng, double MaxLatencyS)
+ {
+ TArray<double> Out;
+ double Last = -1.0e9;
+ for (const double Sent : SendTimes)
+ {
+ double Latency = FMath::Min(Rng.Range(0.050, 0.070), MaxLatencyS);
+ if (Rng.Chance(0.01))
+ {
+ Latency += 2.0 * Latency; // lost once, resent after a round trip
+ }
+ Last = FMath::Max(Last, Sent + Latency);
+ Out.Add(Last);
+ }
+ return Out;
+ }
+
+ /** {"Phase": seconds after Start, ...} (VerseCombat does not link the Json module). */
+ FString PhaseTimes(const TMap<FString, double>& Times, double Start)
+ {
+ TArray<FString> Parts;
+ for (const TPair<FString, double>& P : Times)
+ {
+ Parts.Add(FString::Printf(TEXT("\"%s\": %.6f"), *P.Key, P.Value - Start));
+ }
+ return TEXT("{") + FString::Join(Parts, TEXT(", ")) + TEXT("}");
+ }
+
+ FString PhaseName(EVerseFinisherPhase Phase)
+ {
+ return StaticEnum<EVerseFinisherPhase>()->GetNameStringByValue(int64(Phase));
+ }
+
+}
+
+// Unit check for A4.3 (not the acceptance run): the timeline math on a simulated transport.
+// Phase times 0.25/0.9/1.8/2.1/2.5 s within 1 tick when clients play the timeline from the
+// server's stamp in the Locked event. A4.3 itself needs the WP10 netcode run (one server, two
+// lagged -game clients) that measures the phases on every machine; that is still open.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherTimelineTest, "Verse.Combat.Finisher.Timeline", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherTimelineTest::RunTest(const FString& Parameters)
+{
+ using namespace VerseFinisherTest;
+ TestEqual(TEXT("PhaseAt 0"), VerseFinisher::PhaseAt(0.0), EVerseFinisherPhase::Locked);
+ TestEqual(TEXT("PhaseAt 0.25"), VerseFinisher::PhaseAt(0.25), EVerseFinisherPhase::Takedown);
+ TestEqual(TEXT("PhaseAt 0.89"), VerseFinisher::PhaseAt(0.89), EVerseFinisherPhase::Takedown);
+ TestEqual(TEXT("PhaseAt 0.9"), VerseFinisher::PhaseAt(0.9), EVerseFinisherPhase::Struggle);
+ TestEqual(TEXT("PhaseAt 1.8"), VerseFinisher::PhaseAt(1.8), EVerseFinisherPhase::Kill);
+ TestEqual(TEXT("PhaseAt 2.1"), VerseFinisher::PhaseAt(2.1), EVerseFinisherPhase::Recover);
+ TestFalse(TEXT("not over at 2.49"), VerseFinisher::IsOver(2.49));
+ TestTrue(TEXT("over at 2.5"), VerseFinisher::IsOver(2.5));
+
+ const FSimClient Clients[] = {
+ {TEXT("client_a"), 120.0, +0.003, 0.0041, 0.25},
+ {TEXT("client_b"), 90.0, -0.003, 0.0077, 0.25},
+ };
+ const double Expected[] = {VerseFinisher::TakedownAt, VerseFinisher::StruggleAt, VerseFinisher::KillAt,
+ VerseFinisher::RecoverAt, VerseFinisher::EndAt};
+ const TCHAR* ExpectedNames[] = {TEXT("Takedown"), TEXT("Struggle"), TEXT("Kill"), TEXT("Recover"), TEXT("End")};
+
+ TArray<FString> Runs;
+ double WorstError = 0.0;
+ const int32 RunCount = 50;
+ for (int32 Run = 0; Run < RunCount; ++Run)
+ {
+ FVerseRng Rng(0x5EED0400ull, uint64(Run), EVerseRngSalt::Harness);
+ // The press lands on a server tick.
+ const double Start = 1000.0 + Rng.RangeInt(0, 600) * ServerTick;
+ FVerseFinisherSession Session;
+ Session.Start(Start);
+ TArray<double> SendTimes = {Start};
+ TMap<FString, double> ServerTimes;
+ for (int32 N = 1; N < 400; ++N)
+ {
+ const double Now = Start + N * ServerTick;
+ TArray<FVerseFinisherStep> Steps;
+ const bool bReleased = Session.Advance(Now, FVerseFinisherSession::NoDeath, Steps);
+ for (const FVerseFinisherStep& Step : Steps)
+ {
+ ServerTimes.Add(PhaseName(Step.Phase), Step.ServerTime);
+ SendTimes.Add(Step.ServerTime);
+ }
+ if (bReleased)
+ {
+ ServerTimes.Add(TEXT("End"), Now);
+ break;
+ }
+ }
+ TestTrue(TEXT("server applied the kill"), Session.bKillApplied);
+
+ FString RunObj = FString::Printf(TEXT("{\"run\": %d, \"server\": %s"), Run, *PhaseTimes(ServerTimes, Start));
+ for (int32 I = 0; I < 5; ++I)
+ {
+ const double* Got = ServerTimes.Find(ExpectedNames[I]);
+ const double Error = Got ? FMath::Abs(*Got - Start - Expected[I]) : 1.0e9;
+ WorstError = FMath::Max(WorstError, Error);
+ if (Error > ServerTick + 1e-9)
+ {
+ AddError(FString::Printf(TEXT("run %d server %s off by %.4f s"), Run, ExpectedNames[I], Error));
+ }
+ }
+
+ for (const FSimClient& Client : Clients)
+ {
+ const TArray<double> Arrivals = Deliver(SendTimes, Rng, Client.MaxLatencyS);
+ const double LockedArrives = Arrivals[0];
+ TMap<FString, double> Shown;
+ for (int32 K = 0; K < 2000; ++K)
+ {
+ const double Frame = Start - 0.05 + Client.FramePhaseS + K / Client.FrameHz; // true server time
+ if (Frame < LockedArrives)
+ {
+ continue;
+ }
+ const double Estimate = Frame + Client.ClockErrorS;
+ const double Elapsed = Estimate - Start; // SequenceStartServerTime from the event
+ const FString Name = VerseFinisher::IsOver(Elapsed) ? FString(TEXT("End")) : PhaseName(VerseFinisher::PhaseAt(Elapsed));
+ if (!Shown.Contains(Name))
+ {
+ // Phases skipped by a late Locked are shown at the receive frame.
+ Shown.Add(Name, Frame);
+ }
+ if (Name == TEXT("End"))
+ {
+ break;
+ }
+ }
+ RunObj += FString::Printf(TEXT(", \"%s\": %s"), Client.Name, *PhaseTimes(Shown, Start));
+ for (int32 I = 0; I < 5; ++I)
+ {
+ const double* Got = Shown.Find(ExpectedNames[I]);
+ const double Error = Got ? FMath::Abs(*Got - Start - Expected[I]) : 1.0e9;
+ WorstError = FMath::Max(WorstError, Error);
+ if (Error > ServerTick + 1e-9)
+ {
+ AddError(FString::Printf(TEXT("run %d %s %s off by %.4f s"), Run, Client.Name, ExpectedNames[I], Error));
+ }
+ }
+ }
+ Runs.Add(RunObj + TEXT("}"));
+ }
+
+ const FString Json = FString::Printf(TEXT("{\"test\": \"Verse.Combat.Finisher.Timeline\", \"kind\": \"unit check, not A4.3 acceptance: simulated netcode: 60 Hz server, reliable ordered delivery 50-70 ms one way, 1 %% loss resent after a round trip, clients at 120 and 90 Hz with +-3 ms clock error\", \"tick_s\": %.6f, \"worst_error_s\": %.6f, \"runs\": [\n%s\n]}\n"),
+ ServerTick, WorstError, *FString::Join(Runs, TEXT(",\n")));
+ TestTrue(TEXT("timeline JSON written"), VerseWp04WriteProof(TEXT("4.3"), TEXT("finisher_timeline.json"), Json));
+ AddInfo(FString::Printf(TEXT("A4.3 unit check (simulated): %d runs, worst phase error %.4f s (tick %.4f s)"), RunCount, WorstError, ServerTick));
+ TestTrue(TEXT("every phase within 1 tick"), WorstError <= ServerTick + 1e-9);
+ return true;
+}
+
+// A4.4 (D5): 500 seeded finishers: 100 % kill unless the attacker dies before 2.1 s; aborts
+// leave the victim's health unchanged. A4.6 rides along: other damage to the victim is refused
+// on every tick, damage to the attacker goes through.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherD5Test, "Verse.Combat.Finisher.D5", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherD5Test::RunTest(const FString& Parameters)
+{
+ using namespace VerseFinisherTest;
+ int32 Kills = 0;
+ int32 Aborts = 0;
+ int32 Failures = 0;
+ for (int32 Seed = 0; Seed < 500; ++Seed)
+ {
+ FVerseRng Rng(0xD5D5ull, uint64(Seed), EVerseRngSalt::Harness);
+ const double Start = 50.0 + Rng.Range(0.0, 100.0);
+ const float VictimHealth = float(Rng.RangeInt(1, 100));
+ const bool bAttackerDies = Rng.Chance(0.5);
+ const double DeathOffset = bAttackerDies ? Rng.Range(0.0, 3.0) : FVerseFinisherSession::NoDeath;
+ const double TickPhase = Rng.Range(0.0, ServerTick);
+
+ FVerseFinisherSession Session;
+ Session.Start(Start);
+ float Health = VictimHealth;
+ double AttackerDeath = FVerseFinisherSession::NoDeath;
+ bool bOtherDamageLeaked = false;
+ bool bAttackerImmune = false;
+ for (int32 N = 1; N < 400 && !Session.bReleased; ++N)
+ {
+ const double Now = Start + TickPhase + N * ServerTick;
+ if (bAttackerDies && Start + DeathOffset <= Now)
+ {
+ AttackerDeath = Start + DeathOffset; // FVerseDeathEvent::ServerTime
+ }
+ TArray<FVerseFinisherStep> Steps;
+ Session.Advance(Now, AttackerDeath, Steps);
+ for (const FVerseFinisherStep& Step : Steps)
+ {
+ if (Step.Phase == EVerseFinisherPhase::Recover && VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Finisher))
+ {
+ Health = 0.f;
+ }
+ }
+ if (Session.bActive)
+ {
+ bOtherDamageLeaked |= VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Bolt)
+ || VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Gadget)
+ || VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Melee);
+ bAttackerImmune |= !VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherAttacker, EVerseDamageSource::Bolt);
+ }
+ }
+ const bool bShouldKill = !bAttackerDies || DeathOffset >= VerseFinisher::RecoverAt;
+ bool bOk = Session.bReleased && !bOtherDamageLeaked && !bAttackerImmune;
+ if (bShouldKill)
+ {
+ bOk &= Session.bKillApplied && !Session.bAborted && Health == 0.f;
+ Kills += Session.bKillApplied ? 1 : 0;
+ }
+ else
+ {
+ bOk &= Session.bAborted && !Session.bKillApplied && Health == VictimHealth;
+ Aborts += Session.bAborted ? 1 : 0;
+ }
+ if (!bOk && ++Failures <= 10)
+ {
+ AddError(FString::Printf(TEXT("seed %d: dies %d at +%.4f s, killed %d aborted %d health %g of %g"), Seed,
+ bAttackerDies, DeathOffset, Session.bKillApplied, Session.bAborted, Health, VictimHealth));
+ }
+ }
+ AddInfo(FString::Printf(TEXT("D5: 500 finishers, %d kills, %d aborts, %d failures"), Kills, Aborts, Failures));
+ TestEqual(TEXT("D5 holds for every seed"), Failures, 0);
+ TestTrue(TEXT("both branches exercised"), Kills > 100 && Aborts > 100);
+
+ // The exact boundary: dying at 2.1 s or later keeps the kill, any earlier aborts.
+ for (const double Offset : {2.0999, 2.1, 2.1001})
+ {
+ FVerseFinisherSession S;
+ S.Start(0.0);
+ TArray<FVerseFinisherStep> Steps;
+ for (int32 N = 1; N <= 160; ++N)
+ {
+ S.Advance(N * ServerTick, Offset <= N * ServerTick ? Offset : FVerseFinisherSession::NoDeath, Steps);
+ }
+ TestEqual(FString::Printf(TEXT("attacker dies at %.4f s"), Offset), S.bKillApplied, Offset >= 2.1);
+ }
+
+ // The vulnerability table of 7.4 (A4.6).
+ TestFalse(TEXT("victim: no bolt damage"), VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Bolt));
+ TestFalse(TEXT("victim: no gadget damage"), VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Gadget));
+ TestFalse(TEXT("victim: no world damage"), VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::World));
+ TestTrue(TEXT("victim: the finisher's own kill"), VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherVictim, EVerseDamageSource::Finisher));
+ TestTrue(TEXT("attacker: bolts hurt"), VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherAttacker, EVerseDamageSource::Bolt));
+ TestTrue(TEXT("attacker: breach charge hurts"), VerseMelee::AllowsDamage(EVerseCombatPhase::FinisherAttacker, EVerseDamageSource::Gadget));
+ TestFalse(TEXT("dead pawns take nothing"), VerseMelee::AllowsDamage(EVerseCombatPhase::Dead, EVerseDamageSource::Bolt));
+ return true;
+}
+
+// Unit check for A4.5 (not the acceptance run): the warp pose math reaches the target at
+// Takedown from any start sampled at the receive time. It measures no replicated actor; A4.5
+// needs the WP10 netcode run that measures the real attacker position on every machine.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherWarpTest, "Verse.Combat.Finisher.Warp", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherWarpTest::RunTest(const FString& Parameters)
+{
+ using namespace VerseFinisherTest;
+ const double OffsetCm = 70.0;
+ double WorstServer = 0.0;
+ double WorstClient = 0.0;
+ TArray<FString> Samples;
+ for (int32 Seed = 0; Seed < 200; ++Seed)
+ {
+ FVerseRng Rng(0xA45ull, uint64(Seed), EVerseRngSalt::Harness);
+ const FTransform Victim(FRotator(0.0, Rng.Range(-180.0, 180.0), 0.0), FVector(Rng.Range(-2000.0, 2000.0), Rng.Range(-2000.0, 2000.0), 88.0));
+ const double Theta = Rng.Range(65.0, 180.0) * (Rng.Chance(0.5) ? 1.0 : -1.0);
+ const FVector Back = Victim.GetRotation().RotateVector(FRotator(0.0, Theta, 0.0).RotateVector(FVector::ForwardVector));
+ const double R = Rng.Range(40.0, 150.0);
+ const FVector AttackerLoc = Victim.GetLocation() + Back * R + FVector(0.0, 0.0, Rng.Range(-60.0, 60.0));
+ const FTransform Attacker((-Back).Rotation(), AttackerLoc);
+
+ FTransform VictimPaired;
+ FTransform Target;
+ FVerseFinisherPose::ComputePaired(Attacker, Victim, OffsetCm, VictimPaired, Target);
+ TestEqual(TEXT("target is the paired offset from the victim"), FVector::Dist2D(Target.GetLocation(), VictimPaired.GetLocation()), OffsetCm, 1e-6);
+ const FVerseMeleeGeometry Paired = FVerseMeleeGeometry::Measure(Target, VictimPaired);
+ TestTrue(TEXT("paired pose: attacker straight behind the victim"), Paired.ThetaDeg > 179.9 && Paired.PhiDeg < 0.1);
+
+ // Server: warp starts at Locked (elapsed 0) and is sampled on the tick Takedown is entered.
+ const double TakedownTick = FMath::CeilToDouble(VerseFinisher::TakedownAt / ServerTick - 1e-6) * ServerTick;
+ const double ServerError = FVerseFinisherPose::PositionErrorCm(FVerseFinisherPose::EvaluateWarp(Attacker, 0.0, Target, TakedownTick), Target);
+ WorstServer = FMath::Max(WorstServer, ServerError);
+
+ // Two lagged clients: the attacker's local pose at receipt carries interpolation error,
+ // the Locked event arrives 50-70 ms late (one client capped at the 250 ms extreme).
+ for (int32 C = 0; C < 2; ++C)
+ {
+ const double Latency = C == 0 ? Rng.Range(0.050, 0.070) : Rng.Range(0.050, 0.250);
+ const double FrameHz = C == 0 ? 120.0 : 90.0;
+ const double ClockError = C == 0 ? 0.003 : -0.003;
+ const FTransform LocalStart(Attacker.GetRotation(), Attacker.GetLocation() + Rng.UnitVector() * Rng.Range(0.0, 10.0));
+ // First client frame at or after the server's Takedown time.
+ const double Frame = FMath::CeilToDouble((VerseFinisher::TakedownAt) * FrameHz) / FrameHz;
+ const double Elapsed = FMath::Max(Frame, Latency) + ClockError;
+ const FTransform Pose = FVerseFinisherPose::EvaluateWarp(LocalStart, Latency + ClockError, Target, Elapsed);
+ const double Error = FVerseFinisherPose::PositionErrorCm(Pose, Target);
+ WorstClient = FMath::Max(WorstClient, Error);
+ if (Seed < 20)
+ {
+ Samples.Add(FString::Printf(TEXT("{\"seed\": %d, \"client\": %d, \"latency_s\": %.4f, \"error_cm\": %.6f}"), Seed, C, Latency, Error));
+ }
+ }
+ }
+ VerseWp04WriteProof(TEXT("4.4"), TEXT("finisher_warp.json"), FString::Printf(
+ TEXT("{\"test\": \"Verse.Combat.Finisher.Warp\", \"kind\": \"unit check of the pose math, not A4.5 acceptance\", \"pairs\": 200, \"worst_server_error_cm\": %.6f, \"worst_client_error_cm\": %.6f, \"samples\": [\n%s\n]}\n"),
+ WorstServer, WorstClient, *FString::Join(Samples, TEXT(",\n"))));
+ AddInfo(FString::Printf(TEXT("A4.5 unit check (pose math): worst warp error at Takedown: server %.3f cm, clients %.3f cm"), WorstServer, WorstClient));
+ TestTrue(TEXT("server error at most 5 cm"), WorstServer <= 5.0);
+ TestTrue(TEXT("client error at most 5 cm"), WorstClient <= 5.0);
+ return true;
+}
+
+// WP04.5: cameras. Both third person from Locked, first person with the weapon at 2.5 s;
+// gore Reduced cuts to black from Takedown to Recover.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherCameraTest, "Verse.Combat.Finisher.Camera", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherCameraTest::RunTest(const FString& Parameters)
+{
+ for (double T = 0.0; T < 2.5 - 1e-3; T += 1.0 / 120.0)
+ {
+ const FVerseFinisherViewState Full = VerseFinisher::EvaluateView(T, false, EVerseGoreLevel::Full);
+ if (Full.View != EVerseFinisherView::ThirdPerson || !Full.bKnifeInHand || Full.bActiveWeaponEquipped)
+ {
+ AddError(FString::Printf(TEXT("Full at %.3f s is not third person with the knife"), T));
+ }
+ const FVerseFinisherViewState Reduced = VerseFinisher::EvaluateView(T, false, EVerseGoreLevel::Reduced);
+ const bool bCut = T + 1e-4 >= VerseFinisher::TakedownAt && T + 1e-4 < VerseFinisher::RecoverAt;
+ const EVerseFinisherView Want = bCut ? EVerseFinisherView::Black : EVerseFinisherView::ThirdPerson;
+ if (Reduced.View != Want)
+ {
+ AddError(FString::Printf(TEXT("Reduced at %.3f s: view %d, want %d"), T, int32(Reduced.View), int32(Want)));
+ }
+ }
+ const FVerseFinisherViewState End = VerseFinisher::EvaluateView(2.5, false, EVerseGoreLevel::Full);
+ TestEqual(TEXT("2.5 s: first person"), End.View, EVerseFinisherView::FirstPerson);
+ TestTrue(TEXT("2.5 s: active weapon re-equipped"), End.bActiveWeaponEquipped);
+ TestFalse(TEXT("2.5 s: knife put away"), End.bKnifeInHand);
+ const FVerseFinisherViewState Aborted = VerseFinisher::EvaluateView(1.0, true, EVerseGoreLevel::Reduced);
+ TestEqual(TEXT("abort: first person at once"), Aborted.View, EVerseFinisherView::FirstPerson);
+ TestTrue(TEXT("abort: weapon back"), Aborted.bActiveWeaponEquipped);
+
+ // The victim's view (7.4, 9.1): the same shot without the knife until Recover, then released
+ // to the death view; never first person with a weapon after its death.
+ for (double T = 0.0; T < 3.0; T += 1.0 / 120.0)
+ {
+ const FVerseFinisherViewState Victim = VerseFinisher::EvaluateVictimView(T, false, EVerseGoreLevel::Reduced);
+ const bool bDead = T + 1e-4 >= VerseFinisher::RecoverAt;
+ if (Victim.bKnifeInHand || Victim.bActiveWeaponEquipped || Victim.bReleasedToDeathView != bDead)
+ {
+ AddError(FString::Printf(TEXT("victim view at %.3f s: knife %d weapon %d released %d"), T,
+ int32(Victim.bKnifeInHand), int32(Victim.bActiveWeaponEquipped), int32(Victim.bReleasedToDeathView)));
+ }
+ if (!bDead && Victim.View != VerseFinisher::EvaluateView(T, false, EVerseGoreLevel::Reduced).View)
+ {
+ AddError(FString::Printf(TEXT("victim view at %.3f s is not the attacker's shot"), T));
+ }
+ }
+ const FVerseFinisherViewState VictimAbort = VerseFinisher::EvaluateVictimView(1.0, true, EVerseGoreLevel::Full);
+ TestEqual(TEXT("abort: the living victim is back in first person"), VictimAbort.View, EVerseFinisherView::FirstPerson);
+ TestTrue(TEXT("abort: the living victim has its weapon"), VictimAbort.bActiveWeaponEquipped);
+ TestFalse(TEXT("abort: the living victim is not handed to the death view"), VictimAbort.bReleasedToDeathView);
+
+ const FTransform A(FRotator::ZeroRotator, FVector(0.0, 0.0, 88.0));
+ const FTransform V(FRotator::ZeroRotator, FVector(70.0, 0.0, 88.0));
+ const FTransform Cam = VerseFinisher::CameraTransform(A, V, 260.0, 120.0);
+ const FVector Mid(35.0, 0.0, 88.0);
+ TestTrue(TEXT("camera stands off the pair"), FVector::Dist2D(Cam.GetLocation(), Mid) > 200.0);
+ TestTrue(TEXT("camera is above the pair"), Cam.GetLocation().Z > Mid.Z + 100.0);
+ const FVector ToMid = (Mid - Cam.GetLocation()).GetSafeNormal();
+ TestTrue(TEXT("camera looks at the pair"), FVector::DotProduct(Cam.GetRotation().GetForwardVector(), ToMid) > 0.95);
+ return true;
+}
+
+// WP04.6: the victim's client smooths into the paired pose on Locked.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherSnapTest, "Verse.Combat.Finisher.VictimSnap", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherSnapTest::RunTest(const FString& Parameters)
+{
+ const FTransform Attacker(FRotator(0.0, 10.0, 0.0), FVector(0.0, 0.0, 88.0));
+ const FTransform Victim(FRotator(0.0, 140.0, 0.0), FVector(100.0, 40.0, 90.0));
+ FTransform Paired;
+ FTransform Target;
+ FVerseFinisherPose::ComputePaired(Attacker, Victim, 70.0, Paired, Target);
+ const FTransform Derived = FVerseFinisherPose::VictimFromWarpTarget(Target, 70.0, Victim.GetLocation().Z);
+ TestTrue(TEXT("client derives the server's paired victim pose from WarpTarget"),
+ FVerseFinisherPose::PositionErrorCm(Derived, Paired) < 1e-6 && Derived.GetRotation().Equals(Paired.GetRotation(), 1e-6));
+ TestTrue(TEXT("victim keeps its location in the paired pose"), FVerseFinisherPose::PositionErrorCm(Paired, Victim) < 1e-6);
+
+ // A client whose local victim pose is off by 12 cm and 30 deg.
+ const FTransform Local(FRotator(0.0, Paired.Rotator().Yaw + 30.0, 0.0), Paired.GetLocation() + FVector(12.0, 0.0, 0.0));
+ const double SnapS = 0.1;
+ TestTrue(TEXT("snap starts at the local pose"), FVerseFinisherPose::PositionErrorCm(FVerseFinisherPose::EvaluateSnap(Local, Paired, 0.0, SnapS), Local) < 1e-6);
+ TestTrue(TEXT("snap ends on the paired pose"), FVerseFinisherPose::PositionErrorCm(FVerseFinisherPose::EvaluateSnap(Local, Paired, SnapS, SnapS), Paired) < 1e-6);
+ double Last = 1.0e9;
+ double LargestStep = 0.0;
+ FTransform Prev = Local;
+ for (int32 I = 0; I <= 12; ++I)
+ {
+ const FTransform Pose = FVerseFinisherPose::EvaluateSnap(Local, Paired, I * SnapS / 12.0, SnapS);
+ const double Remaining = FVerseFinisherPose::PositionErrorCm(Pose, Paired);
+ TestTrue(TEXT("error shrinks monotonically"), Remaining <= Last + 1e-9);
+ LargestStep = FMath::Max(LargestStep, FVerseFinisherPose::PositionErrorCm(Pose, Prev));
+ Last = Remaining;
+ Prev = Pose;
+ }
+ TestTrue(FString::Printf(TEXT("no pop: largest per-frame step %.2f cm of 12"), LargestStep), LargestStep < 2.5);
+ TestTrue(TEXT("zero snap time snaps"), FVerseFinisherPose::PositionErrorCm(FVerseFinisherPose::EvaluateSnap(Local, Paired, 0.0, 0.0), Paired) < 1e-6);
+ return true;
+}
+
+// End to end on a game world: press from the back, lock, phases, warp, noise, kill, release;
+// invulnerability of the victim (A4.6) and an abort that leaves the victim's health unchanged.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherWorldTest, "Verse.Combat.Finisher.World", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherWorldTest::RunTest(const FString& Parameters)
+{
+ using namespace VerseFinisherTest;
+ FVerseMeleeTestWorld W;
+ ACharacter* Attacker = W.Spawn(FVector(0.0, 0.0, 0.0), 0.0);
+ ACharacter* Victim = W.Spawn(FVector(100.0, 30.0, 0.0), 10.0);
+ W.Step(3);
+ UVerseEventHub* Hub = UVerseEventHub::Get(W.World);
+ if (!TestNotNull(TEXT("hub"), Hub))
+ {
+ return false;
+ }
+ TArray<TPair<EVerseFinisherPhase, double>> Phases;
+ TArray<FVerseFinisherEvent> Events;
+ TArray<FVerseDeathEvent> Deaths;
+ TArray<TPair<APawn*, FVerseFinisherViewState>> Views;
+ int32 FinisherNoises = 0;
+ Hub->OnFinisher.AddLambda([&](const FVerseFinisherEvent& E) { Phases.Emplace(E.Phase, W.Now()); Events.Add(E); });
+ Hub->OnDeath.AddLambda([&](const FVerseDeathEvent& E) { Deaths.Add(E); });
+ Hub->OnNoise.AddLambda([&](const FVerseNoiseEvent& E) { FinisherNoises += E.Noise == VerseTags::Noise_Finisher.GetTag() ? 1 : 0; });
+ UVerseMeleeComponent* Melee = FVerseMeleeTestWorld::Melee(Attacker);
+ Melee->OnFinisherView.AddLambda([&](APawn* Viewer, const FVerseFinisherViewState& S) { Views.Emplace(Viewer, S); });
+
+ const double Start = W.Now();
+ EVerseMeleeOutcome Outcome;
+ TestTrue(TEXT("press accepted"), Melee->HandleMeleePress(Start, Outcome));
+ TestEqual(TEXT("from the back within 1.5 m: finisher"), Outcome, EVerseMeleeOutcome::Finisher);
+ TestEqual(TEXT("attacker locked"), FVerseMeleeTestWorld::State(Attacker)->Phase, EVerseCombatPhase::FinisherAttacker);
+ TestEqual(TEXT("victim locked"), FVerseMeleeTestWorld::State(Victim)->Phase, EVerseCombatPhase::FinisherVictim);
+ EVerseMeleeOutcome Second;
+ TestFalse(TEXT("no second press during the finisher"), Melee->HandleMeleePress(W.Now(), Second));
+ const FTransform WarpTarget = Events.Num() > 0 ? Events[0].WarpTarget : FTransform::Identity;
+
+ double TakedownError = -1.0;
+ bool bInvulnerabilityChecked = false;
+ while (W.Now() - Start < 2.7)
+ {
+ W.Step();
+ const double Elapsed = W.Now() - Start;
+ if (TakedownError < 0.0 && Elapsed + 1e-4 >= VerseFinisher::TakedownAt)
+ {
+ TakedownError = FVerseFinisherPose::PositionErrorCm(Attacker->GetActorTransform(), WarpTarget);
+ }
+ if (!bInvulnerabilityChecked && Elapsed >= 1.0)
+ {
+ bInvulnerabilityChecked = true;
+ FVerseHitEvent Bolt;
+ Bolt.Source = EVerseDamageSource::Bolt;
+ Bolt.Damage = 40.f;
+ W.Port().ApplyMeleeHit(nullptr, Victim, Bolt);
+ TestEqual(TEXT("A4.6: the victim takes 0 other damage"), Bolt.Damage, 0.f);
+ FVerseHitEvent Shot;
+ Shot.Source = EVerseDamageSource::Bolt;
+ Shot.Damage = 40.f;
+ W.Port().ApplyMeleeHit(nullptr, Attacker, Shot);
+ TestEqual(TEXT("A4.6: the attacker takes damage normally"), Shot.Damage, 40.f);
+ }
+ }
+ const EVerseFinisherPhase Order[] = {EVerseFinisherPhase::Locked, EVerseFinisherPhase::Takedown,
+ EVerseFinisherPhase::Struggle, EVerseFinisherPhase::Kill, EVerseFinisherPhase::Recover};
+ TestEqual(TEXT("five phase events"), Phases.Num(), 5);
+ for (int32 I = 0; I < FMath::Min(5, Phases.Num()); ++I)
+ {
+ TestEqual(FString::Printf(TEXT("phase %d"), I), Phases[I].Key, Order[I]);
+ const double Error = FMath::Abs(Phases[I].Value - Start - VerseFinisher::PhaseOffset(Order[I]));
+ TestTrue(FString::Printf(TEXT("phase %d within 1 tick (%.4f s)"), I, Error), Error <= ServerTick + 1e-6);
+ TestEqual(FString::Printf(TEXT("phase %d stamp"), I), double(Events[I].SequenceStartServerTime), Start, 1e-3);
+ }
+ TestTrue(FString::Printf(TEXT("A4.5 world: warp error at Takedown %.3f cm"), TakedownError), TakedownError >= 0.0 && TakedownError <= 5.0);
+ TestEqual(TEXT("Noise.Finisher once, at Takedown"), FinisherNoises, 1);
+ TestEqual(TEXT("one death"), Deaths.Num(), 1);
+ if (Deaths.Num() == 1)
+ {
+ TestEqual(TEXT("cause Finisher"), Deaths[0].Cause, EVerseDamageSource::Finisher);
+ TestEqual(TEXT("killer is the attacker"), Deaths[0].KillerId, VerseMelee::PlayerIdOf(Attacker));
+ TestTrue(TEXT("death at 2.1 s within 1 tick"), FMath::Abs(Deaths[0].ServerTime - Start - 2.1) <= ServerTick + 1e-3);
+ }
+ TestEqual(TEXT("victim Dead"), FVerseMeleeTestWorld::State(Victim)->Phase, EVerseCombatPhase::Dead);
+ TestEqual(TEXT("attacker released"), FVerseMeleeTestWorld::State(Attacker)->Phase, EVerseCombatPhase::Alive);
+ TestEqual(TEXT("attacker kept the bolt damage"), W.Port().GetHealth(Attacker), 60.f);
+ TestFalse(TEXT("finisher over"), Melee->IsInFinisher());
+ bool bAttackerThird = false;
+ bool bVictimThird = false;
+ bool bBackToFirst = false;
+ bool bVictimReleased = false;
+ bool bVictimRearmed = false;
+ for (const TPair<APawn*, FVerseFinisherViewState>& V : Views)
+ {
+ bVictimReleased |= V.Key == Victim && V.Value.bReleasedToDeathView;
+ bVictimRearmed |= V.Key == Victim && V.Value.bActiveWeaponEquipped;
+ bAttackerThird |= V.Key == Attacker && V.Value.View == EVerseFinisherView::ThirdPerson;
+ bVictimThird |= V.Key == Victim && V.Value.View == EVerseFinisherView::ThirdPerson;
+ bBackToFirst |= V.Key == Attacker && V.Value.View == EVerseFinisherView::FirstPerson && V.Value.bActiveWeaponEquipped;
+ }
+ TestTrue(TEXT("attacker view went third person"), bAttackerThird);
+ TestTrue(TEXT("victim view went third person"), bVictimThird);
+ TestTrue(TEXT("attacker back in first person with the weapon"), bBackToFirst);
+ TestTrue(TEXT("dead victim released to the death view"), bVictimReleased);
+ TestFalse(TEXT("dead victim never re-armed in first person"), bVictimRearmed);
+
+ // Abort: the attacker dies at 1.0 s; the victim is released with full health.
+ ACharacter* A2 = W.Spawn(FVector(0.0, 800.0, 0.0), 90.0);
+ ACharacter* V2 = W.Spawn(FVector(0.0, 900.0, 0.0), 90.0);
+ W.Step(2);
+ Phases.Reset();
+ Deaths.Reset();
+ const double Start2 = W.Now();
+ TestTrue(TEXT("abort case: press accepted"), FVerseMeleeTestWorld::Melee(A2)->HandleMeleePress(Start2, Outcome));
+ TestEqual(TEXT("abort case: finisher"), Outcome, EVerseMeleeOutcome::Finisher);
+ bool bKilledAttacker = false;
+ while (W.Now() - Start2 < 2.7)
+ {
+ W.Step();
+ if (!bKilledAttacker && W.Now() - Start2 >= 1.0)
+ {
+ bKilledAttacker = true;
+ FVerseHitEvent Shot;
+ Shot.Source = EVerseDamageSource::Bolt;
+ Shot.VictimId = VerseMelee::PlayerIdOf(A2);
+ Shot.Damage = 500.f;
+ W.Port().ApplyMeleeHit(nullptr, A2, Shot);
+ }
+ }
+ TestTrue(TEXT("abort event raised"), Phases.ContainsByPredicate([](const TPair<EVerseFinisherPhase, double>& P) { return P.Key == EVerseFinisherPhase::Aborted; }));
+ TestFalse(TEXT("no Recover after the abort"), Phases.ContainsByPredicate([](const TPair<EVerseFinisherPhase, double>& P) { return P.Key == EVerseFinisherPhase::Recover; }));
+ TestEqual(TEXT("only the attacker died"), Deaths.Num(), 1);
+ TestEqual(TEXT("victim released Alive"), FVerseMeleeTestWorld::State(V2)->Phase, EVerseCombatPhase::Alive);
+ TestEqual(TEXT("victim health unchanged"), W.Port().GetHealth(V2), 100.f);
+ TestEqual(TEXT("attacker stays Dead"), FVerseMeleeTestWorld::State(A2)->Phase, EVerseCombatPhase::Dead);
+ return true;
+}
+
+// WP04.3 / 7.4 "no input": both pawns possessed by controllers that keep pushing movement and
+// look input through the whole finisher. Neither moves or turns out of the paired pose; both
+// get their input and movement back at release, and the abort releases the living victim.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseFinisherLockTest, "Verse.Combat.Finisher.Lock", VERSE_FINISHER_TEST_FLAGS)
+bool FVerseFinisherLockTest::RunTest(const FString& Parameters)
+{
+ FVerseMeleeTestWorld W;
+ ACharacter* Attacker = W.Spawn(FVector(0.0, 0.0, 0.0), 0.0);
+ ACharacter* Victim = W.Spawn(FVector(100.0, 30.0, 0.0), 10.0);
+ APlayerController* AttackerPC = W.Possess(Attacker);
+ APlayerController* VictimPC = W.Possess(Victim);
+ for (ACharacter* C : {Attacker, Victim})
+ {
+ C->bUseControllerRotationYaw = true;
+ C->GetCharacterMovement()->SetMovementMode(MOVE_Flying);
+ }
+ W.Step(3);
+
+ // Sanity: a free pawn accepts movement input before the finisher.
+ Victim->AddMovementInput(FVector(0.0, 1.0, 0.0), 1.f);
+ TestTrue(TEXT("a free pawn takes movement input"), !Victim->GetPendingMovementInputVector().IsNearlyZero());
+ Victim->ConsumeMovementInputVector();
+ W.Step();
+
+ UVerseMeleeComponent* Melee = FVerseMeleeTestWorld::Melee(Attacker);
+ const double Start = W.Now();
+ EVerseMeleeOutcome Outcome;
+ TestTrue(TEXT("press accepted"), Melee->HandleMeleePress(Start, Outcome));
+ TestEqual(TEXT("finisher"), Outcome, EVerseMeleeOutcome::Finisher);
+ TestTrue(TEXT("attacker locked"), Melee->IsPawnLocked(Attacker));
+ TestTrue(TEXT("victim locked"), Melee->IsPawnLocked(Victim));
+ TestTrue(TEXT("attacker move input ignored"), AttackerPC->IsMoveInputIgnored());
+ TestTrue(TEXT("victim move input ignored"), VictimPC->IsMoveInputIgnored());
+ TestTrue(TEXT("attacker look input ignored"), AttackerPC->IsLookInputIgnored());
+ TestTrue(TEXT("victim look input ignored"), VictimPC->IsLookInputIgnored());
+ TestEqual(TEXT("attacker movement off"), Attacker->GetCharacterMovement()->MovementMode.GetValue(), MOVE_None);
+ TestEqual(TEXT("victim movement off"), Victim->GetCharacterMovement()->MovementMode.GetValue(), MOVE_None);
+
+ const FVector VictimPaired = Victim->GetActorLocation();
+ const double VictimYaw = Victim->GetActorRotation().Yaw;
+ double WorstVictimDrift = 0.0;
+ double WorstAttackerDrift = 0.0;
+ double WorstYaw = 0.0;
+ FVector AttackerHeld = FVector::ZeroVector;
+ bool bHeld = false;
+ bool bInputLeaked = false;
+ while (W.Now() - Start < VerseFinisher::EndAt - 0.03)
+ {
+ for (ACharacter* C : {Attacker, Victim})
+ {
+ C->AddMovementInput(FVector(1.0, 1.0, 0.0), 1.f);
+ bInputLeaked |= !C->GetPendingMovementInputVector().IsNearlyZero();
+ C->AddControllerYawInput(15.f);
+ // What PlayerController::UpdateRotation does every frame for bUseControllerRotationYaw.
+ if (AController* Controller = C->GetController())
+ {
+ C->FaceRotation(Controller->GetControlRotation(), float(FVerseMeleeTestWorld::Tick));
+ }
+ }
+ W.Step();
+ const double Elapsed = W.Now() - Start;
+ if (FVerseMeleeTestWorld::State(Victim)->Phase != EVerseCombatPhase::Dead)
+ {
+ WorstVictimDrift = FMath::Max(WorstVictimDrift, FVector::Dist(VictimPaired, Victim->GetActorLocation()));
+ WorstYaw = FMath::Max(WorstYaw, FMath::Abs(FRotator::NormalizeAxis(Victim->GetActorRotation().Yaw - VictimYaw)));
+ }
+ // The warp owns the attacker up to Takedown; after that it must hold the warp target.
+ if (Elapsed > VerseFinisher::TakedownAt + 0.12)
+ {
+ if (!bHeld)
+ {
+ bHeld = true;
+ AttackerHeld = Attacker->GetActorLocation();
+ }
+ WorstAttackerDrift = FMath::Max(WorstAttackerDrift, FVector::Dist(AttackerHeld, Attacker->GetActorLocation()));
+ }
+ }
+ TestFalse(TEXT("no movement input reached either pawn during the finisher"), bInputLeaked);
+ TestTrue(FString::Printf(TEXT("victim held in the paired pose (drift %.3f cm)"), WorstVictimDrift), WorstVictimDrift < 0.5);
+ TestTrue(FString::Printf(TEXT("victim kept the paired yaw (%.3f deg)"), WorstYaw), WorstYaw < 0.1);
+ TestTrue(FString::Printf(TEXT("attacker held at the warp target (drift %.3f cm)"), WorstAttackerDrift), bHeld && WorstAttackerDrift < 0.5);
+
+ W.Step(6);
+ TestFalse(TEXT("finisher over"), Melee->IsInFinisher());
+ TestFalse(TEXT("attacker released"), Melee->IsPawnLocked(Attacker));
+ TestFalse(TEXT("attacker move input back"), AttackerPC->IsMoveInputIgnored());
+ TestFalse(TEXT("attacker look input back"), AttackerPC->IsLookInputIgnored());
+ TestFalse(TEXT("victim controller input counters balanced"), VictimPC->IsMoveInputIgnored());
+ TestEqual(TEXT("attacker movement restored"), Attacker->GetCharacterMovement()->MovementMode.GetValue(), MOVE_Flying);
+ Attacker->AddMovementInput(FVector(0.0, 1.0, 0.0), 1.f);
+ TestTrue(TEXT("attacker takes movement input again after release"), !Attacker->GetPendingMovementInputVector().IsNearlyZero());
+ Attacker->ConsumeMovementInputVector();
+
+ // Abort: the attacker dies at 1.0 s; the living victim gets input and movement back.
+ ACharacter* A2 = W.Spawn(FVector(0.0, 800.0, 0.0), 90.0);
+ ACharacter* V2 = W.Spawn(FVector(0.0, 900.0, 0.0), 90.0);
+ W.Possess(A2);
+ APlayerController* V2PC = W.Possess(V2);
+ V2->GetCharacterMovement()->SetMovementMode(MOVE_Flying);
+ W.Step(2);
+ const double Start2 = W.Now();
+ TestTrue(TEXT("abort case: press accepted"), FVerseMeleeTestWorld::Melee(A2)->HandleMeleePress(Start2, Outcome));
+ bool bShot = false;
+ while (W.Now() - Start2 < 1.2)
+ {
+ W.Step();
+ if (!bShot && W.Now() - Start2 >= 1.0)
+ {
+ bShot = true;
+ FVerseHitEvent Shot;
+ Shot.Source = EVerseDamageSource::Bolt;
+ Shot.VictimId = VerseMelee::PlayerIdOf(A2);
+ Shot.Damage = 500.f;
+ W.Port().ApplyMeleeHit(nullptr, A2, Shot);
+ }
+ }
+ TestFalse(TEXT("abort: victim released"), FVerseMeleeTestWorld::Melee(A2)->IsPawnLocked(V2));
+ TestFalse(TEXT("abort: victim move input back"), V2PC->IsMoveInputIgnored());
+ TestEqual(TEXT("abort: victim movement restored"), V2->GetCharacterMovement()->MovementMode.GetValue(), MOVE_Flying);
+ return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS
diff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseFakeMeleeWorld.h b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseFakeMeleeWorld.h
new file mode 100644
index 0000000000..f65f292a1a
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseFakeMeleeWorld.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "CoreMinimal.h"
+#include "Melee/VerseMeleeWorld.h"
+
+/**
+ * Fake of the melee world seam for tests: the interim world plus a scripted rewind history
+ * (WP02.8 stand-in) and per-pawn movement flags (WP01 stand-in).
+ */
+class FFakeMeleeWorld : public FVerseInterimMeleeWorld
+{
+public:
+ explicit FFakeMeleeWorld(UWorld* InWorld) : FVerseInterimMeleeWorld(InWorld) {}
+
+ /** Pawn base transforms by server time; GetBaseTransformAt answers the latest entry at or before the time. */
+ TMap<const APawn*, TArray<TPair<double, FTransform>>> History;
+ /** Movement flag overrides (stance, mantling, airborne); combat phase still comes from the pawn. */
+ TMap<const APawn*, FVerseMeleeParticipant> Movement;
+
+ virtual FTransform GetBaseTransformAt(const APawn* Pawn, double ServerTime) const override
+ {
+ if (const TArray<TPair<double, FTransform>>* Samples = History.Find(Pawn))
+ {
+ const FTransform* Best = nullptr;
+ for (const TPair<double, FTransform>& Sample : *Samples)
+ {
+ if (Sample.Key <= ServerTime + 1e-6)
+ {
+ Best = &Sample.Value;
+ }
+ }
+ if (Best)
+ {
+ return *Best;
+ }
+ }
+ return FVerseInterimMeleeWorld::GetBaseTransformAt(Pawn, ServerTime);
+ }
+
+ virtual FVerseMeleeParticipant Describe(const APawn* Pawn) const override
+ {
+ FVerseMeleeParticipant P = FVerseInterimMeleeWorld::Describe(Pawn);
+ if (const FVerseMeleeParticipant* Override = Movement.Find(Pawn))
+ {
+ P.Stance = Override->Stance;
+ P.bMantling = Override->bMantling;
+ P.bAirborne = Override->bAirborne;
+ }
+ return P;
+ }
+};
+
+#endif // WITH_DEV_AUTOMATION_TESTS
diff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseMeleeTestWorld.h b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseMeleeTestWorld.h
new file mode 100644
index 0000000000..3f2e70537c
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseMeleeTestWorld.h
@@ -0,0 +1,108 @@
+#pragma once
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#include "Components/CapsuleComponent.h"
+#include "CoreMinimal.h"
+#include "Damage/VerseCombatStateComponent.h"
+#include "Engine/Engine.h"
+#include "Engine/World.h"
+#include "GameFramework/Character.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "GameFramework/PlayerController.h"
+#include "GameFramework/WorldSettings.h"
+#include "HAL/FileManager.h"
+#include "Melee/VerseMeleeComponent.h"
+#include "Melee/VerseMeleeWorld.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+
+/**
+ * A transient game world with placeholder pawns (plain characters with the combat state and
+ * melee components, no mesh, movement off) ticked at the 60 Hz server rate. Standalone net
+ * mode: the world is the server, RPCs run locally.
+ */
+struct FVerseMeleeTestWorld
+{
+ static constexpr double Tick = 1.0 / 60.0;
+
+ UWorld* World = nullptr;
+
+ FVerseMeleeTestWorld()
+ {
+ World = UWorld::CreateWorld(EWorldType::Game, false, FName(TEXT("VerseMeleeTestWorld")));
+ FWorldContext& Context = GEngine->CreateNewWorldContext(EWorldType::Game);
+ Context.SetCurrentWorld(World);
+ World->InitializeActorsForPlay(FURL());
+ World->BeginPlay();
+ if (!World->GetBegunPlay())
+ {
+ World->GetWorldSettings()->NotifyBeginPlay();
+ }
+ }
+
+ ~FVerseMeleeTestWorld()
+ {
+ World->EndPlay(EEndPlayReason::Quit);
+ GEngine->DestroyWorldContext(World);
+ World->DestroyWorld(false);
+ }
+
+ /** A pawn whose capsule base is at Base, facing YawDeg. */
+ ACharacter* Spawn(const FVector& Base, double YawDeg)
+ {
+ FActorSpawnParameters Params;
+ Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+ ACharacter* Character = World->SpawnActor<ACharacter>(ACharacter::StaticClass(), Base, FRotator(0.0, YawDeg, 0.0), Params);
+ Character->GetCharacterMovement()->SetMovementMode(MOVE_None);
+ Character->GetCharacterMovement()->GravityScale = 0.f;
+ const double Half = Character->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();
+ Character->SetActorLocation(Base + FVector(0.0, 0.0, Half));
+ UVerseCombatStateComponent* State = NewObject<UVerseCombatStateComponent>(Character, TEXT("CombatState"));
+ State->RegisterComponent();
+ UVerseMeleeComponent* Melee = NewObject<UVerseMeleeComponent>(Character, TEXT("Melee"));
+ Melee->RegisterComponent();
+ return Character;
+ }
+
+ /** A player controller (no local player) possessing Pawn; standalone, so it counts as local. */
+ APlayerController* Possess(APawn* Pawn)
+ {
+ FActorSpawnParameters Params;
+ Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+ APlayerController* Controller = World->SpawnActor<APlayerController>(APlayerController::StaticClass(), Params);
+ Controller->Possess(Pawn);
+ return Controller;
+ }
+
+ static UVerseMeleeComponent* Melee(const APawn* Pawn) { return Pawn->FindComponentByClass<UVerseMeleeComponent>(); }
+ static UVerseCombatStateComponent* State(const APawn* Pawn) { return Pawn->FindComponentByClass<UVerseCombatStateComponent>(); }
+
+ IVerseMeleeWorld& Port() const { return *UVerseMeleeWorldSubsystem::Get(World); }
+
+ double Now() const { return World->GetTimeSeconds(); }
+
+ void Step(int32 Ticks = 1)
+ {
+ for (int32 I = 0; I < Ticks; ++I)
+ {
+ ++GFrameCounter;
+ World->Tick(LEVELTICK_All, float(Tick));
+ }
+ }
+};
+
+/** Evidence files land in Saved/Harness/proof/WP04/<sub-task>/ (work-packages.md 0.4). */
+inline FString VerseWp04ProofPath(const TCHAR* SubTask, const TCHAR* File)
+{
+ return FPaths::Combine(FPaths::ProjectSavedDir(), TEXT("Harness/proof/WP04"), SubTask, File);
+}
+
+inline bool VerseWp04WriteProof(const TCHAR* SubTask, const TCHAR* File, const FString& Text)
+{
+ const FString Path = VerseWp04ProofPath(SubTask, File);
+ IFileManager::Get().MakeDirectory(*FPaths::GetPath(Path), true);
+ return FFileHelper::SaveStringToFile(Text, *Path, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM);
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS
diff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/VerseMeleeTests.cpp b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/VerseMeleeTests.cpp
new file mode 100644
index 0000000000..9b12e22d4e
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/VerseMeleeTests.cpp
@@ -0,0 +1,386 @@
+#include "Combat/VerseMeleeDefinition.h"
+#include "Events/VerseEventHub.h"
+#include "Finisher/VerseFinisherTimeline.h"
+#include "Melee/VerseMeleeComponent.h"
+#include "Melee/VerseMeleeImport.h"
+#include "Melee/VerseMeleeRules.h"
+#include "Misc/AutomationTest.h"
+#include "Tests/Melee/Fakes/VerseFakeMeleeWorld.h"
+#include "Tests/Melee/Fakes/VerseMeleeTestWorld.h"
+#include "VerseGameplayTags.h"
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+#define VERSE_MELEE_TEST_FLAGS (EAutomationTestFlags_ApplicationContextMask | EAutomationTestFlags::EngineFilter)
+
+namespace VerseMeleeTest
+{
+ /** combat-state.md 7.2 written out again over nominal values, as the oracle of A4.1. */
+ EVerseMeleeOutcome Oracle(double ThetaDeg, double PhiDeg, double RCm, double DzCm, bool bEligible, bool bSweep)
+ {
+ if (RCm == 0.0)
+ {
+ ThetaDeg = 0.0; // d undefined: the attacker counts as in front, looking at the victim
+ PhiDeg = 0.0;
+ }
+ const bool bFlankOrBack = ThetaDeg > 60.0;
+ if (bFlankOrBack && RCm <= 150.0 && PhiDeg <= 45.0 && FMath::Abs(DzCm) <= 60.0 && bEligible && bSweep)
+ {
+ return EVerseMeleeOutcome::Finisher;
+ }
+ if (FMath::Sqrt(RCm * RCm + DzCm * DzCm) <= 200.0 && PhiDeg <= 30.0)
+ {
+ return EVerseMeleeOutcome::Strike;
+ }
+ return EVerseMeleeOutcome::Whiff;
+ }
+
+ FVector2D Rotate(const FVector2D& V, double Deg)
+ {
+ const double R = FMath::DegreesToRadians(Deg);
+ return FVector2D(V.X * FMath::Cos(R) - V.Y * FMath::Sin(R), V.X * FMath::Sin(R) + V.Y * FMath::Cos(R));
+ }
+}
+
+// A4.1: grid 0-180 deg in 5 deg steps x 0-2.5 m in 0.1 m x dz -1..1 m in 0.2 m (plus attacker
+// facings and both eligibility inputs): 100 % match with 7.2.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseMeleeClassifyTest, "Verse.Combat.Melee.Classify", VERSE_MELEE_TEST_FLAGS)
+bool FVerseMeleeClassifyTest::RunTest(const FString& Parameters)
+{
+ using namespace VerseMeleeTest;
+ const UVerseMeleeDefinition& Def = *GetDefault<UVerseMeleeDefinition>();
+ const double VictimYaw = 37.0;
+ const FVector2D VictimFacing = Rotate(FVector2D(1.0, 0.0), VictimYaw);
+ const double Phis[] = {0.0, 25.0, 30.0, 45.0, 50.0, 90.0, 180.0};
+ int32 Total = 0;
+ int32 Mismatches = 0;
+ int32 Counts[3] = {0, 0, 0};
+ for (int32 K = 0; K <= 36; ++K)
+ {
+ const double Theta = 5.0 * K;
+ const double Side = (K % 2 == 0) ? 1.0 : -1.0;
+ const FVector2D D = Rotate(VictimFacing, Side * Theta);
+ for (int32 I = 0; I <= 25; ++I)
+ {
+ const double R = 10.0 * I;
+ for (int32 J = -5; J <= 5; ++J)
+ {
+ const double Dz = 20.0 * J;
+ for (const double Phi : Phis)
+ {
+ const double Turn = (J % 2 == 0) ? Phi : -Phi;
+ const FVector2D Look = Rotate(-D, Turn);
+ const FTransform Victim(FRotator(0.0, VictimYaw, 0.0), FVector(120.0, -340.0, 15.0));
+ const FVector AttackerLoc = Victim.GetLocation() + FVector(D.X * R, D.Y * R, Dz);
+ const FTransform Attacker(FRotator(0.0, FMath::RadiansToDegrees(FMath::Atan2(Look.Y, Look.X)), 0.0), AttackerLoc);
+ for (int32 Flags = 0; Flags < 4; ++Flags)
+ {
+ const bool bEligible = (Flags & 1) != 0;
+ const bool bSweep = (Flags & 2) != 0;
+ const EVerseMeleeOutcome Got = UVerseMeleeComponent::Classify(Attacker, Victim, Def, bEligible, bSweep);
+ const EVerseMeleeOutcome Want = Oracle(Theta, Phi, R, Dz, bEligible, bSweep);
+ ++Total;
+ ++Counts[uint8(Got)];
+ if (Got != Want)
+ {
+ if (++Mismatches <= 10)
+ {
+ AddError(FString::Printf(TEXT("theta %g phi %g r %g cm dz %g cm eligible %d sweep %d: got %d want %d"),
+ Theta, Phi, R, Dz, bEligible, bSweep, int32(Got), int32(Want)));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ AddInfo(FString::Printf(TEXT("A4.1: %d cases, %d mismatches (whiff %d, strike %d, finisher %d)"), Total, Mismatches,
+ Counts[0], Counts[1], Counts[2]));
+ TestEqual(TEXT("100 % match with 7.2"), Mismatches, 0);
+ TestTrue(TEXT("grid reaches every outcome"), Counts[0] > 0 && Counts[1] > 0 && Counts[2] > 0);
+
+ // The boundaries named in 7.1/7.2, measured from transforms.
+ auto At = [&](double Theta, double R, double Dz, double Phi)
+ {
+ const FVector2D D = Rotate(VictimFacing, Theta);
+ const FTransform Victim(FRotator(0.0, VictimYaw, 0.0), FVector::ZeroVector);
+ const FVector2D Look = Rotate(-D, Phi);
+ const FTransform Attacker(FRotator(0.0, FMath::RadiansToDegrees(FMath::Atan2(Look.Y, Look.X)), 0.0), FVector(D.X * R, D.Y * R, Dz));
+ return UVerseMeleeComponent::Classify(Attacker, Victim, Def, true, true);
+ };
+ TestEqual(TEXT("theta 60 is Front: strike"), At(60.0, 100.0, 0.0, 0.0), EVerseMeleeOutcome::Strike);
+ TestEqual(TEXT("theta 61 is Flank: finisher"), At(61.0, 100.0, 0.0, 0.0), EVerseMeleeOutcome::Finisher);
+ TestEqual(TEXT("r 1.5 m inclusive"), At(150.0, 150.0, 0.0, 0.0), EVerseMeleeOutcome::Finisher);
+ TestEqual(TEXT("r 1.51 m: strike"), At(150.0, 151.0, 0.0, 0.0), EVerseMeleeOutcome::Strike);
+ TestEqual(TEXT("|dz| 0.6 m inclusive"), At(150.0, 100.0, -60.0, 0.0), EVerseMeleeOutcome::Finisher);
+ TestEqual(TEXT("phi 46 deg: no finisher, outside the 30 deg cone"), At(150.0, 100.0, 0.0, 46.0), EVerseMeleeOutcome::Whiff);
+ TestEqual(TEXT("2.0 m strike reach inclusive"), At(0.0, 200.0, 0.0, 0.0), EVerseMeleeOutcome::Strike);
+ TestEqual(TEXT("2.01 m whiffs"), At(0.0, 201.0, 0.0, 0.0), EVerseMeleeOutcome::Whiff);
+
+ // Eligibility (7.2 condition list).
+ FVerseMeleeParticipant A;
+ FVerseMeleeParticipant V;
+ TestTrue(TEXT("both standing and alive: eligible"), VerseMelee::IsFinisherEligible(A, V));
+ V.bSpawnProtected = true;
+ TestFalse(TEXT("spawn-protected victim"), VerseMelee::IsFinisherEligible(A, V));
+ V = {};
+ V.Stance = EVerseStance::Prone;
+ TestFalse(TEXT("prone victim"), VerseMelee::IsFinisherEligible(A, V));
+ V = {};
+ V.bMantling = true;
+ TestFalse(TEXT("mantling victim"), VerseMelee::IsFinisherEligible(A, V));
+ V = {};
+ V.Phase = EVerseCombatPhase::FinisherVictim;
+ TestFalse(TEXT("victim already in a finisher"), VerseMelee::IsFinisherEligible(A, V));
+ V = {};
+ V.Stance = EVerseStance::Crouch;
+ TestTrue(TEXT("crouched victim is eligible"), VerseMelee::IsFinisherEligible(A, V));
+ A.bAirborne = true;
+ TestFalse(TEXT("airborne attacker"), VerseMelee::IsFinisherEligible(A, V));
+ A = {};
+ A.Stance = EVerseStance::Prone;
+ TestFalse(TEXT("prone attacker"), VerseMelee::IsFinisherEligible(A, V));
+ return true;
+}
+
+// WP04.1: the importer reads the shipped text surface and rejects malformed files.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseMeleeImportTest, "Verse.Combat.Melee.Import", VERSE_MELEE_TEST_FLAGS)
+bool FVerseMeleeImportTest::RunTest(const FString& Parameters)
+{
+ UVerseMeleeDefinition* Def = NewObject<UVerseMeleeDefinition>(GetTransientPackage());
+ FVerseMeleePresentationTuning Tuning;
+ FString Error;
+ const bool bOk = FVerseMeleeImport::FromFile(FVerseMeleeImport::DefaultPath(), *Def, Tuning, Error);
+ TestTrue(FString::Printf(TEXT("hookbill.json imports (%s)"), *Error), bOk);
+ TestEqual(TEXT("StrikeDamage"), Def->StrikeDamage, 55.f);
+ TestEqual(TEXT("StrikeHitDelay"), Def->StrikeHitDelay, 0.15f);
+ TestEqual(TEXT("StrikeCooldown"), Def->StrikeCooldown, 0.7f);
+ TestEqual(TEXT("StrikeRange"), Def->StrikeRange, 2.f);
+ TestEqual(TEXT("StrikeConeHalfAngle"), Def->StrikeConeHalfAngle, 30.f);
+ TestEqual(TEXT("FinisherRange"), Def->FinisherRange, 1.5f);
+ TestEqual(TEXT("FinisherMaxHeightDelta"), Def->FinisherMaxHeightDelta, 0.6f);
+ TestEqual(TEXT("FrontHalfAngle"), Def->FrontHalfAngle, 60.f);
+ TestEqual(TEXT("AttackerFacingMax"), Def->AttackerFacingMax, 45.f);
+ TestEqual(TEXT("FinisherDuration"), Def->FinisherDuration, 2.5f);
+ TestEqual(TEXT("FinisherKillTime"), Def->FinisherKillTime, 2.1f);
+ TestEqual(TEXT("weapon id"), Tuning.WeaponId, FName(TEXT("hookbill")));
+ TestEqual(TEXT("paired offset in cm"), Tuning.PairedOffsetCm, 70.0, 1e-9);
+ TestTrue(TEXT("equip never delays the contact frame"), Tuning.EquipS <= Def->StrikeHitDelay + 1e-6);
+
+ FString Text;
+ FFileHelper::LoadFileToString(Text, *FVerseMeleeImport::DefaultPath());
+ struct FCase
+ {
+ const TCHAR* What;
+ FString From;
+ FString To;
+ };
+ const FCase Cases[] = {
+ {TEXT("wrong schema"), TEXT("verse.melee/1"), TEXT("verse.melee/2")},
+ {TEXT("missing damage"), TEXT("\"damage\""), TEXT("\"damage_x\"")},
+ {TEXT("negative cooldown"), TEXT("\"cooldown_s\": 0.7"), TEXT("\"cooldown_s\": -0.7")},
+ {TEXT("duration off the frozen timeline"), TEXT("\"duration_s\": 2.5"), TEXT("\"duration_s\": 3.0")},
+ {TEXT("kill time off the frozen timeline"), TEXT("\"kill_time_s\": 2.1"), TEXT("\"kill_time_s\": 2.0")},
+ {TEXT("missing presentation"), TEXT("\"presentation\""), TEXT("\"presentation_x\"")},
+ };
+ for (const FCase& Case : Cases)
+ {
+ TestTrue(FString::Printf(TEXT("fixture contains '%s'"), *Case.From), Text.Contains(Case.From));
+ const FString Broken = Text.Replace(*Case.From, *Case.To);
+ UVerseMeleeDefinition* Scratch = NewObject<UVerseMeleeDefinition>(GetTransientPackage());
+ FVerseMeleePresentationTuning ScratchTuning;
+ FString CaseError;
+ TestFalse(FString::Printf(TEXT("rejects: %s"), Case.What), FVerseMeleeImport::FromJsonString(Broken, *Scratch, ScratchTuning, CaseError));
+ TestFalse(FString::Printf(TEXT("says why: %s"), Case.What), CaseError.IsEmpty());
+ }
+ TestFalse(TEXT("rejects non-JSON"), FVerseMeleeImport::FromJsonString(TEXT("[1,2"), *Def, Tuning, Error));
+ return true;
+}
+
+// A4.2: 55 damage, 2 strikes kill from 100, cooldown 0.7 s within 1 tick; noise on every press.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseMeleeStrikeTest, "Verse.Combat.Melee.Strike", VERSE_MELEE_TEST_FLAGS)
+bool FVerseMeleeStrikeTest::RunTest(const FString& Parameters)
+{
+ // Pure clock: presses on every 60 Hz tick are accepted exactly every 0.7 s.
+ {
+ FVerseMeleeClock Clock;
+ TArray<double> Accepted;
+ for (int32 T = 0; T <= 150; ++T)
+ {
+ const double Now = 100.0 + T / 60.0;
+ if (Clock.TryPress(Now, 0.7))
+ {
+ Accepted.Add(Now);
+ }
+ }
+ TestEqual(TEXT("clock: presses accepted in 2.5 s"), Accepted.Num(), 4);
+ for (int32 I = 1; I < Accepted.Num(); ++I)
+ {
+ TestTrue(FString::Printf(TEXT("clock: interval %d is 0.7 s within 1 tick (%.4f)"), I, Accepted[I] - Accepted[I - 1]),
+ FMath::Abs(Accepted[I] - Accepted[I - 1] - 0.7) <= FVerseMeleeTestWorld::Tick + 1e-9);
+ }
+ }
+
+ FVerseMeleeTestWorld W;
+ ACharacter* Attacker = W.Spawn(FVector(0.0, 0.0, 0.0), 0.0);
+ ACharacter* Victim = W.Spawn(FVector(150.0, 0.0, 0.0), 180.0);
+ UVerseEventHub* Hub = UVerseEventHub::Get(W.World);
+ if (!TestNotNull(TEXT("hub"), Hub))
+ {
+ return false;
+ }
+ TArray<FVerseHitEvent> Hits;
+ TArray<double> HitTimes;
+ TArray<FVerseDeathEvent> Deaths;
+ int32 MeleeNoises = 0;
+ Hub->OnHit.AddLambda([&](const FVerseHitEvent& E) { Hits.Add(E); HitTimes.Add(W.Now()); });
+ Hub->OnDeath.AddLambda([&](const FVerseDeathEvent& E) { Deaths.Add(E); });
+ Hub->OnNoise.AddLambda([&](const FVerseNoiseEvent& E) { MeleeNoises += E.Noise == VerseTags::Noise_Melee.GetTag() ? 1 : 0; });
+
+ UVerseMeleeComponent* Melee = FVerseMeleeTestWorld::Melee(Attacker);
+ TArray<double> Presses;
+ TArray<EVerseMeleeOutcome> Outcomes;
+ for (int32 T = 0; T < 100; ++T)
+ {
+ EVerseMeleeOutcome Outcome;
+ if (Melee->HandleMeleePress(W.Now(), Outcome))
+ {
+ Presses.Add(W.Now());
+ Outcomes.Add(Outcome);
+ }
+ W.Step();
+ }
+ TestEqual(TEXT("presses accepted in 1.67 s"), Presses.Num(), 3);
+ if (Presses.Num() >= 3)
+ {
+ TestEqual(TEXT("first press strikes"), Outcomes[0], EVerseMeleeOutcome::Strike);
+ TestEqual(TEXT("second press strikes"), Outcomes[1], EVerseMeleeOutcome::Strike);
+ TestEqual(TEXT("third press finds only a dead pawn: whiff"), Outcomes[2], EVerseMeleeOutcome::Whiff);
+ TestTrue(FString::Printf(TEXT("cooldown 0.7 s within 1 tick (%.4f)"), Presses[1] - Presses[0]),
+ FMath::Abs(Presses[1] - Presses[0] - 0.7) <= FVerseMeleeTestWorld::Tick + 1e-6);
+ }
+ TestEqual(TEXT("two hits"), Hits.Num(), 2);
+ if (Hits.Num() == 2 && Presses.Num() >= 2)
+ {
+ TestEqual(TEXT("first strike: 55 damage"), Hits[0].Damage, 55.f);
+ TestEqual(TEXT("source Melee"), Hits[0].Source, EVerseDamageSource::Melee);
+ TestEqual(TEXT("knife weapon id"), Hits[0].WeaponId, FName(TEXT("hookbill")));
+ TestFalse(TEXT("first strike is not a kill"), bool(Hits[0].bKillingBlow));
+ TestEqual(TEXT("second strike: the remaining 45"), Hits[1].Damage, 45.f);
+ TestTrue(TEXT("second strike kills"), bool(Hits[1].bKillingBlow));
+ TestTrue(FString::Printf(TEXT("hit delay 0.15 s within 1 tick (%.4f)"), HitTimes[0] - Presses[0]),
+ FMath::Abs(HitTimes[0] - Presses[0] - 0.15) <= FVerseMeleeTestWorld::Tick + 1e-6);
+ }
+ TestEqual(TEXT("one death"), Deaths.Num(), 1);
+ if (Deaths.Num() == 1)
+ {
+ TestEqual(TEXT("death cause Melee"), Deaths[0].Cause, EVerseDamageSource::Melee);
+ }
+ TestEqual(TEXT("victim health 0"), W.Port().GetHealth(Victim), 0.f);
+ TestEqual(TEXT("victim Dead"), FVerseMeleeTestWorld::State(Victim)->Phase, EVerseCombatPhase::Dead);
+ TestEqual(TEXT("Noise.Melee on every accepted press"), MeleeNoises, 3);
+
+ // A spawn-protected target takes nothing; the hit still says so (combat-state.md 9.3).
+ ACharacter* Fresh = W.Spawn(FVector(0.0, 400.0, 0.0), 0.0);
+ ACharacter* Protected = W.Spawn(FVector(100.0, 400.0, 0.0), 180.0);
+ FVerseMeleeTestWorld::State(Protected)->bSpawnProtected = true;
+ FVerseMeleeTestWorld::State(Fresh)->bSpawnProtected = true;
+ Hits.Reset();
+ EVerseMeleeOutcome Outcome;
+ TestTrue(TEXT("protected attacker may press"), FVerseMeleeTestWorld::Melee(Fresh)->HandleMeleePress(W.Now(), Outcome));
+ TestFalse(TEXT("the press ends the attacker's own protection"), FVerseMeleeTestWorld::State(Fresh)->bSpawnProtected);
+ W.Step(12);
+ TestEqual(TEXT("one blocked hit"), Hits.Num(), 1);
+ if (Hits.Num() == 1)
+ {
+ TestTrue(TEXT("blocked by spawn protection"), bool(Hits[0].bBlockedBySpawnProtection));
+ TestEqual(TEXT("no damage"), Hits[0].Damage, 0.f);
+ }
+ TestEqual(TEXT("protected health untouched"), W.Port().GetHealth(Protected), 100.f);
+ return true;
+}
+
+// WP02.8 stand-in: the server classifies at the attacker's view time, not at the current pose.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseMeleeRewindTest, "Verse.Combat.Melee.Rewind", VERSE_MELEE_TEST_FLAGS)
+bool FVerseMeleeRewindTest::RunTest(const FString& Parameters)
+{
+ FVerseMeleeTestWorld W;
+ ACharacter* Attacker = W.Spawn(FVector(0.0, 0.0, 0.0), 0.0);
+ ACharacter* Victim = W.Spawn(FVector(400.0, 0.0, 0.0), 0.0);
+ TSharedPtr<FFakeMeleeWorld> Fake = MakeShared<FFakeMeleeWorld>(W.World);
+ W.World->GetSubsystem<UVerseMeleeWorldSubsystem>()->SetWorld(Fake);
+ W.Step(30);
+ const double Now = W.Now();
+ // 100 ms ago the victim stood 1 m in front of the attacker with its back turned.
+ auto Record = [&Fake](const APawn* Pawn, double T0, const FVector& L0, double T1, const FVector& L1)
+ {
+ TArray<TPair<double, FTransform>>& Samples = Fake->History.FindOrAdd(Pawn);
+ Samples.Emplace(T0, FTransform(L0));
+ Samples.Emplace(T1, FTransform(L1));
+ };
+ Record(Victim, Now - 0.1, FVector(100.0, 0.0, 0.0), Now, FVector(400.0, 0.0, 0.0));
+ EVerseMeleeOutcome Outcome;
+ TestTrue(TEXT("press accepted"), FVerseMeleeTestWorld::Melee(Attacker)->HandleMeleePress(Now - 0.1, Outcome));
+ TestEqual(TEXT("rewound pose: finisher from the back"), Outcome, EVerseMeleeOutcome::Finisher);
+ W.Step(160);
+
+ // Rewind is capped at 250 ms: a view time 0.4 s old reads the pose at now - 0.25 s.
+ ACharacter* A2 = W.Spawn(FVector(0.0, 1000.0, 0.0), 0.0);
+ ACharacter* V2 = W.Spawn(FVector(500.0, 1000.0, 0.0), 0.0);
+ const double Now2 = W.Now();
+ Record(V2, Now2 - 0.4, FVector(100.0, 1000.0, 0.0), Now2 - 0.25, FVector(500.0, 1000.0, 0.0));
+ TestTrue(TEXT("second press accepted"), FVerseMeleeTestWorld::Melee(A2)->HandleMeleePress(Now2 - 0.4, Outcome));
+ TestEqual(TEXT("capped rewind: target out of reach"), Outcome, EVerseMeleeOutcome::Whiff);
+
+ // Movement flags come from the movement query: a prone victim gets a strike, not a finisher.
+ ACharacter* A3 = W.Spawn(FVector(0.0, 2000.0, 0.0), 0.0);
+ ACharacter* V3 = W.Spawn(FVector(100.0, 2000.0, 0.0), 0.0);
+ FVerseMeleeParticipant Prone;
+ Prone.Stance = EVerseStance::Prone;
+ Fake->Movement.Add(V3, Prone);
+ TestTrue(TEXT("third press accepted"), FVerseMeleeTestWorld::Melee(A3)->HandleMeleePress(W.Now(), Outcome));
+ TestEqual(TEXT("prone victim from the back: strike"), Outcome, EVerseMeleeOutcome::Strike);
+ W.World->GetSubsystem<UVerseMeleeWorldSubsystem>()->SetWorld(nullptr);
+ return true;
+}
+
+// WP04.7: predicted swing, whiff, quick equip.
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FVerseMeleeKnifeTest, "Verse.Combat.Melee.KnifePresentation", VERSE_MELEE_TEST_FLAGS)
+bool FVerseMeleeKnifeTest::RunTest(const FString& Parameters)
+{
+ FVerseKnifePresentation K;
+ K.EquipS = 0.12;
+ K.HitDelayS = 0.15;
+ K.RecoverS = 0.3;
+ TestEqual(TEXT("before any press, another slot: hidden"), K.Evaluate(0.0), EVerseKnifeAnim::Hidden);
+ K.Press(10.0, false);
+ TestEqual(TEXT("quick knife draws first"), K.Evaluate(10.05), EVerseKnifeAnim::Equipping);
+ TestEqual(TEXT("then swings"), K.Evaluate(10.13), EVerseKnifeAnim::Swinging);
+ TestEqual(TEXT("contact frame at the hit delay"), K.ContactTime(), 10.15, 1e-9);
+ TestEqual(TEXT("follow-through after contact"), K.Evaluate(10.2), EVerseKnifeAnim::Recovering);
+ TestEqual(TEXT("knife put away again"), K.Evaluate(10.5), EVerseKnifeAnim::Hidden);
+ TestFalse(TEXT("unconfirmed is not a whiff yet"), K.IsWhiff());
+ K.Confirm(EVerseMeleeOutcome::Whiff);
+ TestTrue(TEXT("server answer: whiff"), K.IsWhiff());
+
+ K.Press(20.0, true);
+ TestEqual(TEXT("knife slot active: no equip, swing at once"), K.Evaluate(20.01), EVerseKnifeAnim::Swinging);
+ TestEqual(TEXT("knife slot rests ready"), K.Evaluate(21.0), EVerseKnifeAnim::Ready);
+ K.Confirm(EVerseMeleeOutcome::Strike);
+ TestFalse(TEXT("strike is not a whiff"), K.IsWhiff());
+
+ K.Press(30.0, true);
+ K.Confirm(EVerseMeleeOutcome::Finisher);
+ TestEqual(TEXT("finisher takes the knife over"), K.Evaluate(30.05), EVerseKnifeAnim::Hidden);
+
+ // The component predicts locally and then asks the server; in a standalone world both run here.
+ FVerseMeleeTestWorld W;
+ ACharacter* Attacker = W.Spawn(FVector(0.0, 0.0, 0.0), 0.0);
+ UVerseMeleeComponent* Melee = FVerseMeleeTestWorld::Melee(Attacker);
+ Melee->PressMelee(false);
+ TestEqual(TEXT("component: predicted swing starts on the press"), Melee->GetKnifeAnim(), EVerseKnifeAnim::Equipping);
+ TestTrue(TEXT("component: server answered whiff (nobody near)"), Melee->GetKnife().IsWhiff());
+ return true;
+}
+
+#endif // WITH_DEV_AUTOMATION_TESTS
diff --git a/unreal/Verse/Source/VerseCombat/Public/Finisher/VerseFinisherTimeline.h b/unreal/Verse/Source/VerseCombat/Public/Finisher/VerseFinisherTimeline.h
new file mode 100644
index 0000000000..257bed895a
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Public/Finisher/VerseFinisherTimeline.h
@@ -0,0 +1,190 @@
+#pragma once
+
+#include "Combat/VerseCombatTypes.h"
+#include "CoreMinimal.h"
+#include "Melee/VerseMeleeRules.h"
+
+#include "VerseFinisherTimeline.generated.h"
+
+/**
+ * The finisher timeline of combat-state.md 7.4 as pure code: the frozen phase offsets, the
+ * server session (validate happened before; lock, phases, kill, abort, release), the paired
+ * pose and warp, the victim snap, the camera rules and the knife presentation. Everything here
+ * is deterministic in server time, so the server and every client derive the same phase and
+ * pose from FVerseFinisherEvent::SequenceStartServerTime alone.
+ */
+namespace VerseFinisher
+{
+ inline constexpr double TakedownAt = 0.25;
+ inline constexpr double StruggleAt = 0.9;
+ inline constexpr double KillAt = 1.8;
+ /** Death is applied when Recover starts. */
+ inline constexpr double RecoverAt = 2.1;
+ inline constexpr double EndAt = 2.5;
+ inline constexpr double TimeTolerance = 1e-4;
+ /** A client that learns of the finisher less than this before Takedown snaps the attacker instead of blending. */
+ inline constexpr double MinWarpS = 0.05;
+
+ /** Offset of a phase from the sequence start; Aborted has none (-1). */
+ VERSECOMBAT_API double PhaseOffset(EVerseFinisherPhase Phase);
+
+ /** Phase at Elapsed seconds after Locked (Locked before 0, Recover from 2.1 on). */
+ VERSECOMBAT_API EVerseFinisherPhase PhaseAt(double Elapsed);
+
+ /** The sequence has ended (both pawns released). */
+ inline bool IsOver(double Elapsed) { return Elapsed + TimeTolerance >= EndAt; }
+}
+
+/** One phase entered by the server session, stamped with the server time it was entered at. */
+struct FVerseFinisherStep
+{
+ EVerseFinisherPhase Phase = EVerseFinisherPhase::Locked;
+ double ServerTime = 0.0;
+};
+
+/**
+ * Server-side finisher sequence. Once Start ran (the press passed 7.2 and both pawns are
+ * locked), Advance walks the phases on each server tick. The kill is applied exactly when
+ * Recover is entered, unless the attacker died before t = 2.1 s (D5): then the session goes to
+ * Aborted at the attacker's death time and the victim is released with its health untouched.
+ */
+struct VERSECOMBAT_API FVerseFinisherSession
+{
+ static constexpr double NoDeath = 1.0e30;
+
+ double StartTime = 0.0;
+ EVerseFinisherPhase Phase = EVerseFinisherPhase::Locked;
+ bool bActive = false;
+ bool bKillApplied = false;
+ bool bAborted = false;
+ bool bReleased = false;
+
+ void Start(double Now);
+
+ /**
+ * Advances to Now. AttackerDeathTime is the server time the attacker died (NoDeath while
+ * alive). Appends every phase entered since the last call, in order. Returns true on the call
+ * that releases both pawns (t = 2.5 s, or the abort).
+ */
+ bool Advance(double Now, double AttackerDeathTime, TArray<FVerseFinisherStep>& OutEntered);
+
+ double Elapsed(double Now) const { return Now - StartTime; }
+};
+
+/** Pose math of the paired finisher (4.4 warp, 4.6 victim snap). Transforms are actor transforms. */
+struct VERSECOMBAT_API FVerseFinisherPose
+{
+ /**
+ * The paired pose: the victim keeps its location and turns its back to the attacker; the
+ * attacker's Warp_Finisher target is PairedOffsetCm behind the victim, facing the same way,
+ * at the attacker's own height (both stand on their floors, |dz| <= 0.6 m).
+ */
+ static void ComputePaired(const FTransform& Attacker, const FTransform& Victim, double PairedOffsetCm,
+ FTransform& OutVictim, FTransform& OutWarpTarget);
+
+ /** The victim's paired pose as a client derives it from the event's WarpTarget (Z from the victim). */
+ static FTransform VictimFromWarpTarget(const FTransform& WarpTarget, double PairedOffsetCm, double VictimZ);
+
+ /**
+ * Attacker pose during the warp. StartPose was sampled at StartElapsed (0 on the server, the
+ * receive time on a client); the pose reaches Target exactly at Takedown (0.25 s) with a
+ * smoothstep and holds it afterwards. A client that learns of the finisher after Takedown snaps.
+ */
+ static FTransform EvaluateWarp(const FTransform& StartPose, double StartElapsed, const FTransform& Target, double Elapsed);
+
+ /** Victim correction on a client: smoothstep from the local pose to the paired pose over SnapS. */
+ static FTransform EvaluateSnap(const FTransform& From, const FTransform& To, double SinceLocked, double SnapS);
+
+ /** Horizontal plus vertical position error, cm. */
+ static double PositionErrorCm(const FTransform& A, const FTransform& B) { return FVector::Dist(A.GetLocation(), B.GetLocation()); }
+};
+
+/** What a viewer of the finisher sees (4.5). */
+UENUM(BlueprintType)
+enum class EVerseFinisherView : uint8
+{
+ FirstPerson,
+ ThirdPerson,
+ /** Gore Reduced: cut away from Takedown to Recover (combat-state.md 8). */
+ Black
+};
+
+struct VERSECOMBAT_API FVerseFinisherViewState
+{
+ EVerseFinisherView View = EVerseFinisherView::FirstPerson;
+ /** The attacker holds the knife (Weapon_L) from Locked to the end. */
+ bool bKnifeInHand = false;
+ /** At 2.5 s (or on an abort) the active weapon is back in hand. */
+ bool bActiveWeaponEquipped = true;
+ /**
+ * Victim only: dead from Recover on; its view target and fade belong to the death view or
+ * kill cam owner (combat-state.md 9.1), so the finisher no longer drives them.
+ */
+ bool bReleasedToDeathView = false;
+
+ bool operator==(const FVerseFinisherViewState& O) const
+ {
+ return View == O.View && bKnifeInHand == O.bKnifeInHand && bActiveWeaponEquipped == O.bActiveWeaponEquipped
+ && bReleasedToDeathView == O.bReleasedToDeathView;
+ }
+};
+
+namespace VerseFinisher
+{
+ /**
+ * The attacker's camera and hands at Elapsed seconds after Locked: third person from Locked,
+ * first person with the active weapon back at 2.5 s or on an abort.
+ */
+ VERSECOMBAT_API FVerseFinisherViewState EvaluateView(double Elapsed, bool bAborted, EVerseGoreLevel Gore);
+
+ /**
+ * The victim's view: the same shot as the attacker (no knife, no weapon) until Recover; from
+ * Recover on it is dead and released to the death view (bReleasedToDeathView). On an abort it
+ * is alive and back in first person with its weapon.
+ */
+ VERSECOMBAT_API FVerseFinisherViewState EvaluateVictimView(double Elapsed, bool bAborted, EVerseGoreLevel Gore);
+
+ /**
+ * Third-person finisher camera: to the side of the pair at DistanceCm, HeightCm above the
+ * pair's base, looking at the pair's midpoint. Both participants use the same shot.
+ */
+ VERSECOMBAT_API FTransform CameraTransform(const FTransform& Attacker, const FTransform& Victim,
+ double DistanceCm, double HeightCm);
+}
+
+/** Animation state of the first-person knife (4.7). */
+UENUM(BlueprintType)
+enum class EVerseKnifeAnim : uint8
+{
+ Hidden,
+ Equipping,
+ Swinging,
+ Recovering,
+ Ready
+};
+
+/**
+ * Predicted knife presentation on the owning client. A press starts the swing at once (the
+ * server decides the outcome); the server's answer marks it a whiff, a strike or the start
+ * of a finisher. A quick knife from another slot draws the knife during the swing and puts it
+ * away afterwards, so the contact frame always lands at StrikeHitDelay.
+ */
+struct VERSECOMBAT_API FVerseKnifePresentation
+{
+ double EquipS = 0.12;
+ double HitDelayS = 0.15;
+ double RecoverS = 0.3;
+
+ double PressTime = -1.0e9;
+ bool bKnifeSlotActive = false;
+ bool bNeedsEquip = false;
+ bool bConfirmed = false;
+ EVerseMeleeOutcome Confirmed = EVerseMeleeOutcome::Whiff;
+
+ void Press(double Now, bool bKnifeSlot);
+ void Confirm(EVerseMeleeOutcome Outcome);
+ EVerseKnifeAnim Evaluate(double Now) const;
+ bool IsWhiff() const { return bConfirmed && Confirmed == EVerseMeleeOutcome::Whiff; }
+ /** Contact frame of the swing (hit spark or whiff swish). */
+ double ContactTime() const { return PressTime + HitDelayS; }
+};
diff --git a/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeComponent.h b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeComponent.h
new file mode 100644
index 0000000000..e289a73a1b
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeComponent.h
@@ -0,0 +1,162 @@
+#pragma once
+
+#include "Combat/VerseCombatTypes.h"
+#include "Components/ActorComponent.h"
+#include "CoreMinimal.h"
+#include "Finisher/VerseFinisherTimeline.h"
+#include "Melee/VerseMeleeImport.h"
+#include "Melee/VerseMeleeRules.h"
+
+#include "VerseMeleeComponent.generated.h"
+
+class ACameraActor;
+class AController;
+class APawn;
+class IVerseMeleeWorld;
+class UVerseMeleeDefinition;
+
+DECLARE_MULTICAST_DELEGATE_TwoParams(FOnVerseFinisherView, APawn* /*Viewer*/, const FVerseFinisherViewState&);
+
+/**
+ * Knife strike and paired finisher on one pawn (combat-state.md 7, WP04). The server decides
+ * every press (7.2) at the attacker's view time and runs the finisher timeline; every machine
+ * plays the same timeline from FVerseFinisherEvent (reliable multicast) and the hub's OnFinisher.
+ *
+ * The finisher runs as a server-driven sequence in this component (validate, lock both,
+ * phases, abort on attacker death, release). Locking a pawn ignores its controller's move and
+ * look input, stops its character movement and holds its control rotation at the paired yaw,
+ * on the server and on the machine that controls it, until release or abort. It is shaped so a GAS ability can own it once
+ * VerseCombat links GameplayAbilities; the attacker's warp to Warp_Finisher is evaluated
+ * here from the event on every machine (the motion warping component needs the MotionWarping
+ * module edge, also pending).
+ */
+UCLASS(ClassGroup = (Verse), meta = (BlueprintSpawnableComponent))
+class VERSECOMBAT_API UVerseMeleeComponent : public UActorComponent
+{
+ GENERATED_BODY()
+
+public:
+ UVerseMeleeComponent();
+
+ /** The melee press, stamped with the client's estimate of server time (its view time). */
+ UFUNCTION(Server, Reliable)
+ void ServerMelee(float ClientServerTime);
+
+ /** Every phase of a finisher, stamped by the server (combat-state.md 7.4). */
+ UFUNCTION(NetMulticast, Reliable)
+ void MulticastFinisher(const FVerseFinisherEvent& E);
+
+ /** The server's answer to the owner's press, for the predicted swing. */
+ UFUNCTION(Client, Reliable)
+ void ClientConfirmMelee(EVerseMeleeOutcome Outcome);
+
+ /** 7.2 with the contract signature. Transforms are base transforms (capsule base, pawn yaw). */
+ static EVerseMeleeOutcome Classify(const FTransform& Attacker, const FTransform& Victim,
+ const UVerseMeleeDefinition& Def, bool bVictimEligible, bool bSweepClear);
+
+ /** Local press (person input or bot input frame): predicts the swing and sends ServerMelee. */
+ void PressMelee(bool bKnifeSlotActive);
+
+ /**
+ * Server: resolves a press at ViewServerTime (clamped to the 250 ms rewind cap). Returns
+ * false when the press was refused (cooldown, attacker not Alive); OutOutcome says what
+ * an accepted press became.
+ */
+ bool HandleMeleePress(double ViewServerTime, EVerseMeleeOutcome& OutOutcome);
+
+ const UVerseMeleeDefinition& GetDefinition() const;
+ const FVerseMeleePresentationTuning& GetTuning() const { return Tuning; }
+ const FVerseFinisherSession& GetSession() const { return Session; }
+ const FVerseKnifePresentation& GetKnife() const { return Knife; }
+ EVerseKnifeAnim GetKnifeAnim() const;
+ bool IsInFinisher() const { return Session.bActive || bPresenting; }
+ const FVerseMeleeClock& GetClock() const { return Clock; }
+
+ /** Optional asset; when unset the component imports Data/melee/hookbill.json. */
+ UPROPERTY(EditAnywhere, Category = "Verse|Melee")
+ TObjectPtr<UVerseMeleeDefinition> Definition;
+
+ /**
+ * Raised on every machine whenever a participant's finisher view changes. A victim's state
+ * with bReleasedToDeathView hands its view target and fade to the death view owner.
+ */
+ FOnVerseFinisherView OnFinisherView;
+
+ /** Server time on this machine (game state clock; world time without a game state). */
+ double ServerNow() const;
+
+ /** The pawn is held in the paired pose by this component (no move or look input, movement off). */
+ bool IsPawnLocked(const APawn* Pawn) const;
+
+protected:
+ virtual void BeginPlay() override;
+ virtual void EndPlay(const EEndPlayReason::Type Reason) override;
+ virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
+
+private:
+ IVerseMeleeWorld* MeleeWorld() const;
+ APawn* OwnerPawn() const;
+ void EnsureDefinition();
+ void RaiseNoise(const FGameplayTag& Tag) const;
+ void ApplyStrike(TWeakObjectPtr<APawn> Victim);
+ void StartFinisher(APawn* Victim, double Now);
+ void AdvanceFinisherServer(double Now);
+ void SendPhase(EVerseFinisherPhase Phase);
+ void OnHubDeath(const FVerseDeathEvent& E);
+ void BeginPresentation(const FVerseFinisherEvent& E);
+ void TickPresentation(double Now);
+ void EndPresentation();
+ void UpdateLocalViews(double Elapsed);
+ void ApplyView(APawn* Viewer, const FVerseFinisherViewState& State, const FTransform& Camera, bool bWasBlack);
+ void LockPawn(APawn* Pawn, double PairedYaw);
+ void HoldLocks();
+ void ReleaseLocks();
+
+ /** What LockPawn changed on one pawn, so ReleaseLocks undoes exactly that. */
+ struct FPawnLock
+ {
+ TWeakObjectPtr<APawn> Pawn;
+ TWeakObjectPtr<AController> Controller;
+ double Yaw = 0.0;
+ bool bInputIgnored = false;
+ bool bMovementStopped = false;
+ uint8 PrevMovementMode = 0;
+ uint8 PrevCustomMode = 0;
+ };
+ TArray<FPawnLock> Locks;
+
+ struct FPendingStrike
+ {
+ TWeakObjectPtr<APawn> Victim;
+ double ApplyAt = 0.0;
+ };
+ TArray<FPendingStrike> PendingStrikes;
+
+ FVerseMeleePresentationTuning Tuning;
+ FVerseMeleeClock Clock;
+ FVerseKnifePresentation Knife;
+
+ // Server finisher state.
+ FVerseFinisherSession Session;
+ TWeakObjectPtr<APawn> SessionVictim;
+ FTransform SessionWarpTarget;
+ FTransform SessionWarpStart;
+ double AttackerDeathTime = FVerseFinisherSession::NoDeath;
+ FDelegateHandle DeathHandle;
+
+ // Presentation state (every machine).
+ bool bPresenting = false;
+ bool bPresentAborted = false;
+ double PresentStart = 0.0;
+ double WarpStartElapsed = 0.0;
+ double SnapStartTime = 0.0;
+ FTransform WarpStartPose;
+ FTransform WarpTarget;
+ FTransform VictimFrom;
+ FTransform VictimTo;
+ TWeakObjectPtr<APawn> PresentVictim;
+ TMap<TWeakObjectPtr<APawn>, FVerseFinisherViewState> LastViews;
+
+ UPROPERTY(Transient)
+ TObjectPtr<ACameraActor> FinisherCamera;
+};
diff --git a/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeImport.h b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeImport.h
new file mode 100644
index 0000000000..a9351d2d6c
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeImport.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "CoreMinimal.h"
+
+class UVerseMeleeDefinition;
+
+/**
+ * Presentation values that live next to the melee definition in
+ * unreal/Verse/Data/melee/hookbill.json but are not gameplay fields of UVerseMeleeDefinition:
+ * knife swing timing, the paired finisher pose and the finisher camera. Units as in the
+ * JSON are converted once here (seconds stay seconds, metres become cm through VerseCoords).
+ */
+struct VERSECOMBAT_API FVerseMeleePresentationTuning
+{
+ FName WeaponId = FName(TEXT("hookbill"));
+ /** Knife draw when another slot is active; capped at the strike hit delay so contact lands on time. */
+ double EquipS = 0.12;
+ /** Swing follow-through after the contact frame. */
+ double SwingRecoverS = 0.3;
+ /** Attacker stands this far behind the victim in the paired pose (the Warp_Finisher target). */
+ double PairedOffsetCm = 70.0;
+ /** Victim correction to the paired pose on a client (4.6). */
+ double VictimSnapS = 0.1;
+ double CameraDistanceCm = 260.0;
+ double CameraHeightCm = 120.0;
+ double CameraBlendS = 0.15;
+};
+
+/** Importer for the verse.melee/1 text surface (WP04.1). Strict: every field must be present and valid. */
+struct VERSECOMBAT_API FVerseMeleeImport
+{
+ static constexpr const TCHAR* Schema = TEXT("verse.melee/1");
+
+ /** <Project>/Data/melee/hookbill.json */
+ static FString DefaultPath();
+
+ static bool FromJsonString(const FString& Text, UVerseMeleeDefinition& OutDef,
+ FVerseMeleePresentationTuning& OutTuning, FString& OutError);
+
+ static bool FromFile(const FString& Path, UVerseMeleeDefinition& OutDef,
+ FVerseMeleePresentationTuning& OutTuning, FString& OutError);
+};
diff --git a/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeRules.h b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeRules.h
new file mode 100644
index 0000000000..93790b861b
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeRules.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include "Combat/VerseCombatTypes.h"
+#include "CoreMinimal.h"
+
+#include "VerseMeleeRules.generated.h"
+
+class UVerseMeleeDefinition;
+
+/** What a melee press becomes (combat-state.md 7.2, 11.2). */
+UENUM(BlueprintType)
+enum class EVerseMeleeOutcome : uint8
+{
+ Whiff,
+ Strike,
+ Finisher
+};
+
+/**
+ * The quantities of combat-state.md 7.1, measured on the horizontal plane from two base
+ * transforms (location at the capsule base, rotation = pawn yaw), in Unreal centimetres.
+ * When both pawns stand on the same spot (r below 0.1 cm) the direction d is undefined; the
+ * rule is then theta = 0 and phi = 0 (the attacker counts as in front and looking at the victim).
+ */
+struct VERSECOMBAT_API FVerseMeleeGeometry
+{
+ /** Angle between the victim's facing and d (victim -> attacker), 0..180 deg. */
+ double ThetaDeg = 0.0;
+ /** Angle between the attacker's facing and -d, 0..180 deg. */
+ double PhiDeg = 0.0;
+ /** r: horizontal distance between the capsules, cm. */
+ double HorizontalCm = 0.0;
+ /** dz: attacker base minus victim base, cm. */
+ double DzCm = 0.0;
+
+ static FVerseMeleeGeometry Measure(const FTransform& AttackerBase, const FTransform& VictimBase);
+
+ /** Strike reach: straight-line distance between the bases, cm. */
+ double ReachCm() const { return FMath::Sqrt(HorizontalCm * HorizontalCm + DzCm * DzCm); }
+};
+
+/** The parts of a pawn's state the 7.2 rules read. Movement flags come from IVerseMovementQuery. */
+struct VERSECOMBAT_API FVerseMeleeParticipant
+{
+ EVerseCombatPhase Phase = EVerseCombatPhase::Alive;
+ bool bSpawnProtected = false;
+ EVerseStance Stance = EVerseStance::Stand;
+ bool bMantling = false;
+ bool bAirborne = false;
+};
+
+namespace VerseMelee
+{
+ /** Comparisons accept values this close to a limit, so grid points on a limit classify as the table says. */
+ inline constexpr double AngleToleranceDeg = 1e-3;
+ inline constexpr double DistanceToleranceCm = 1e-2;
+ /** Server press timing tolerance, s (a press on the cooldown tick is accepted). */
+ inline constexpr double TimeTolerance = 1e-4;
+ /** Weapon id carried by melee hit events (combat-state.md 2.2: the knife). */
+ VERSECOMBAT_API extern const FName KnifeWeaponId;
+
+ /**
+ * Gore level of the person at this machine (combat-state.md 8: local per viewer). One value
+ * per machine, set by the primary module from UVerseSettings; every finisher this machine
+ * shows (as attacker, victim or neither) reads it. Full until set.
+ */
+ VERSECOMBAT_API void SetLocalGoreLevel(EVerseGoreLevel Gore);
+ VERSECOMBAT_API EVerseGoreLevel GetLocalGoreLevel();
+
+ /**
+ * The non-geometric finisher conditions of 7.2: victim Alive (a victim already in a finisher
+ * is not Alive, so it cannot be hit by a second one), not spawn protected, not prone, not
+ * mantling; attacker Alive, grounded and not prone.
+ */
+ VERSECOMBAT_API bool IsFinisherEligible(const FVerseMeleeParticipant& Attacker, const FVerseMeleeParticipant& Victim);
+
+ /** A melee press is processed only while the attacker is Alive (not dead, not in a finisher). */
+ VERSECOMBAT_API bool CanStartMelee(const FVerseMeleeParticipant& Attacker);
+
+ /** A strike target: Alive, or a finisher attacker (who takes damage normally, 7.4). */
+ VERSECOMBAT_API bool CanBeStruck(const FVerseMeleeParticipant& Victim);
+
+ /** 7.2 over measured geometry. bEligible is IsFinisherEligible; bSweepClear the capsule sweep. */
+ VERSECOMBAT_API EVerseMeleeOutcome ClassifyMeasured(const FVerseMeleeGeometry& Geometry,
+ const UVerseMeleeDefinition& Def, bool bEligible, bool bSweepClear);
+
+ /**
+ * The finisher's vulnerability rule (7.4, A4.6): a FinisherVictim takes no damage except the
+ * finisher's own kill; a Dead pawn takes none; everyone else (the finisher attacker included)
+ * takes damage normally. Every damage path (WP02.9) asks this before applying damage.
+ */
+ VERSECOMBAT_API bool AllowsDamage(EVerseCombatPhase VictimPhase, EVerseDamageSource Source);
+}
+
+/** Server press gate for the strike cooldown (7.3) and the finisher lock-out. Server time, s. */
+struct VERSECOMBAT_API FVerseMeleeClock
+{
+ double NextPressAllowed = -1.0e9;
+
+ bool CanPress(double Now) const { return Now + VerseMelee::TimeTolerance >= NextPressAllowed; }
+
+ /** Accepts the press and starts the cooldown, or refuses it. */
+ bool TryPress(double Now, double CooldownS);
+
+ /** No press is accepted before Time (a running finisher). */
+ void BlockUntil(double Time) { NextPressAllowed = FMath::Max(NextPressAllowed, Time); }
+};
diff --git a/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeWorld.h b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeWorld.h
new file mode 100644
index 0000000000..6b6e272d27
--- /dev/null
+++ b/unreal/Verse/Source/VerseCombat/Public/Melee/VerseMeleeWorld.h
@@ -0,0 +1,121 @@
+#pragma once
+
+#include "Combat/VerseCombatTypes.h"
+#include "CoreMinimal.h"
+#include "Melee/VerseMeleeRules.h"
+#include "Subsystems/WorldSubsystem.h"
+
+#include "VerseMeleeWorld.generated.h"
+
+class APawn;
+
+/**
+ * Everything melee and the finisher need from the rest of combat, as one seam:
+ * rewound transforms (WP02.8), the participant flags (WP01 movement query, combat state) and
+ * the damage path (WP02.9). Until those land the interim implementation below answers with
+ * current transforms and a small health ledger; WP02 replaces it with SetWorld() and keeps
+ * these semantics.
+ */
+class VERSECOMBAT_API IVerseMeleeWorld
+{
+public:
+ virtual ~IVerseMeleeWorld() = default;
+
+ /** Server time in seconds. */
+ virtual double ServerNow() const = 0;
+
+ /** Base transform (capsule base location, pawn yaw) at ServerTime, rewound (capped at 250 ms). */
+ virtual FTransform GetBaseTransformAt(const APawn* Pawn, double ServerTime) const = 0;
+
+ virtual FVerseMeleeParticipant Describe(const APawn* Pawn) const = 0;
+
+ /** No world geometry between the two capsules (7.2, "clear capsule sweep"). */
+ virtual bool IsSweepClear(const APawn* Attacker, const APawn* Victim) const = 0;
+
+ /** Every pawn that could be a melee target of Attacker. */
+ virtual void GetCandidates(const APawn* Attacker, TArray<APawn*>& Out) const = 0;
+
+ /**
+ * Applies a melee or finisher hit on the server. In: ids, source, zone, damage asked for
+ * (a finisher asks for the victim's remaining health). Out: the damage applied and the
+ * killing-blow and spawn-protection flags. Raises FVerseHitEvent and, on a kill,
+ * FVerseDeathEvent on the hub, honouring VerseMelee::AllowsDamage.
+ */
+ virtual void ApplyMeleeHit(APawn* Attacker, APawn* Victim, FVerseHitEvent& InOutHit) = 0;
+
+ virtual float GetHealth(const APawn* Pawn) const = 0;
+};
+
+namespace VerseMelee
+{
+ /** Player state id, or the pawn's object id when it has no player state (tests, placeholders). */
+ VERSECOMBAT_API int32 PlayerIdOf(const APawn* Pawn);
+
+ /** The pawn whose PlayerIdOf is Id, or nullptr. */
+ VERSECOMBAT_API APawn* FindPawnById(const UWorld* World, int32 Id);
+
+ /** Sets the combat phase on the pawn's UVerseCombatStateComponent (server, push model). */
+ VERSECOMBAT_API void SetPhase(APawn* Pawn, EVerseCombatPhase Phase);
+
+ /**
+ * Ends spawn protection on the first own offensive action (combat-state.md 9.3): clears the
+ * flag and pulls SpawnProtectedUntil back to ServerNow, so protection derived from the end
+ * time cannot come back on the next tick.
+ */
+ VERSECOMBAT_API void EndSpawnProtection(APawn* Pawn, double ServerNow);
+
+ /** Capsule half height, 0 when the pawn has no capsule. */
+ VERSECOMBAT_API double HalfHeightOf(const APawn* Pawn);
+}
+
+/**
+ * Interim melee world (until WP02.8 rewind and WP02.9 damage land): current transforms,
+ * movement flags from IVerseMovementQuery (null stub answers when absent), a world-static
+ * capsule sweep, and a per-world health ledger that starts every pawn at 100.
+ */
+class VERSECOMBAT_API FVerseInterimMeleeWorld : public IVerseMeleeWorld
+{
+public:
+ explicit FVerseInterimMeleeWorld(UWorld* InWorld) : World(InWorld) {}
+
+ static constexpr float StartHealth = 100.f;
+
+ virtual double ServerNow() const override;
+ virtual FTransform GetBaseTransformAt(const APawn* Pawn, double ServerTime) const override;
+ virtual FVerseMeleeParticipant Describe(const APawn* Pawn) const override;
+ virtual bool IsSweepClear(const APawn* Attacker, const APawn* Victim) const override;
+ virtual void GetCandidates(const APawn* Attacker, TArray<APawn*>& Out) const override;
+ virtual void ApplyMeleeHit(APawn* Attacker, APawn* Victim, FVerseHitEvent& InOutHit) override;
+ virtual float GetHealth(const APawn* Pawn) const override;
+
+ /** Tests and respawn: put a pawn back at full health. */
+ void ResetHealth(const APawn* Pawn) { Health.Remove(Pawn); }
+
+private:
+ TWeakObjectPtr<UWorld> World;
+ TMap<TWeakObjectPtr<const APawn>, float> Health;
+};
+
+/** Holds the melee world of one game world: the interim one, or the one WP02 installs. */
+UCLASS()
+class VERSECOMBAT_API UVerseMeleeWorldSubsystem : public UWorldSubsystem
+{
+ GENERATED_BODY()
+
+public:
+ static IVerseMeleeWorld* Get(const UObject* WorldContextObject);
+
+ virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+ virtual void Deinitialize() override;
+
+ IVerseMeleeWorld& GetWorldPort() const { return Override.IsValid() ? *Override : *Interim; }
+
+ /** Install another implementation (WP02, tests); nullptr restores the interim one. */
+ void SetWorld(TSharedPtr<IVerseMeleeWorld> InWorld) { Override = MoveTemp(InWorld); }
+
+ FVerseInterimMeleeWorld* GetInterim() const { return Interim.Get(); }
+
+private:
+ TSharedPtr<FVerseInterimMeleeWorld> Interim;
+ TSharedPtr<IVerseMeleeWorld> Override;
+};