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.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
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.jsonnew file mode 100644index 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.cppnew file mode 100644index 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.cppnew file mode 100644index 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.cppnew file mode 100644index 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.hnew file mode 100644index 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.cppnew file mode 100644index 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.cppnew file mode 100644index 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.cppnew file mode 100644index 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_TESTSdiff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseFakeMeleeWorld.h b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseFakeMeleeWorld.hnew file mode 100644index 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_TESTSdiff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseMeleeTestWorld.h b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/Fakes/VerseMeleeTestWorld.hnew file mode 100644index 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_TESTSdiff --git a/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/VerseMeleeTests.cpp b/unreal/Verse/Source/VerseCombat/Private/Tests/Melee/VerseMeleeTests.cppnew file mode 100644index 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_TESTSdiff --git a/unreal/Verse/Source/VerseCombat/Public/Finisher/VerseFinisherTimeline.h b/unreal/Verse/Source/VerseCombat/Public/Finisher/VerseFinisherTimeline.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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;+};