Skip to content

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

11.3 KB
Raw Blame
#include "Perception/VersePerceptionService.h"

#include "Components/SkeletalMeshComponent.h"
#include "Damage/VerseCombatStateComponent.h"
#include "Destruction/VerseDestructionInterfaces.h"
#include "Engine/World.h"
#include "EngineUtils.h"
#include "Events/VerseEventHub.h"
#include "GameFramework/Character.h"
#include "GameFramework/Controller.h"
#include "GameFramework/Pawn.h"
#include "GameFramework/PlayerState.h"
#include "Movement/VerseMovementQuery.h"
#include "Noise/VerseAudibilityTable.h"
#include "Perception/VersePlainSightQuery.h"
#include "Stats/Stats.h"

const FName UVersePerceptionService::SampleBones[8] = {
	TEXT("Head"),
	TEXT("Neck"),
	TEXT("Spine_03"),
	TEXT("Hips"),
	TEXT("UpperArm_L"),
	TEXT("UpperArm_R"),
	TEXT("Calf_L"),
	TEXT("Calf_R"),
};

const FName UVersePerceptionService::EyeBone(TEXT("Camera"));

namespace
{
	const IVerseMovementQuery* FindMovementQuery(const APawn& Pawn)
	{
		if (const IVerseMovementQuery* OnPawn = Cast<IVerseMovementQuery>(const_cast<APawn*>(&Pawn)))
		{
			return OnPawn;
		}
		TInlineComponentArray<UActorComponent*> Components(&Pawn);
		for (UActorComponent* Component : Components)
		{
			if (const IVerseMovementQuery* Query = Cast<IVerseMovementQuery>(Component))
			{
				return Query;
			}
		}
		return nullptr;
	}

	const USkeletalMeshComponent* FindMesh(const APawn& Pawn)
	{
		if (const ACharacter* Character = Cast<ACharacter>(&Pawn))
		{
			if (Character->GetMesh())
			{
				return Character->GetMesh();
			}
		}
		return Pawn.FindComponentByClass<USkeletalMeshComponent>();
	}

	bool BoneLocation(const USkeletalMeshComponent* Mesh, const FName& Bone, FVector& Out)
	{
		if (!Mesh || !Mesh->GetSkeletalMeshAsset() || Mesh->GetBoneIndex(Bone) == INDEX_NONE)
		{
			return false;
		}
		Out = Mesh->GetBoneLocation(Bone);
		return true;
	}

	EVerseStance StanceOf(const APawn& Pawn, const IVerseMovementQuery* Query)
	{
		if (Query)
		{
			return Query->GetStance();
		}
		const ACharacter* Character = Cast<ACharacter>(&Pawn);
		return Character && Character->bIsCrouched ? EVerseStance::Crouch : EVerseStance::Stand;
	}
}

UVersePerceptionService* UVersePerceptionService::Get(const UObject* WorldContextObject)
{
	const UWorld* World = WorldContextObject ? WorldContextObject->GetWorld() : nullptr;
	return World ? World->GetSubsystem<UVersePerceptionService>() : nullptr;
}

void UVersePerceptionService::Initialize(FSubsystemCollectionBase& Collection)
{
	Collection.InitializeDependency(UVerseEventHub::StaticClass());
	Super::Initialize(Collection);
	SetSightQuery(NewObject<UVersePlainSightQuery>(this));
	Audibility = NewObject<UVerseAudibilityTable>(this);
	BindHub();
}

void UVersePerceptionService::Deinitialize()
{
	UnbindHub();
	Registered.Reset();
	Super::Deinitialize();
}

bool UVersePerceptionService::DoesSupportWorldType(const EWorldType::Type WorldType) const
{
	return WorldType == EWorldType::Game || WorldType == EWorldType::PIE;
}

TStatId UVersePerceptionService::GetStatId() const
{
	RETURN_QUICK_DECLARE_CYCLE_STAT(UVersePerceptionService, STATGROUP_Tickables);
}

void UVersePerceptionService::BindHub()
{
	UVerseEventHub* HubPtr = UVerseEventHub::Get(this);
	if (!HubPtr)
	{
		return;
	}
	Hub = HubPtr;
	NoiseHandle = HubPtr->OnNoise.AddUObject(this, &UVersePerceptionService::HandleNoise);
	FireHandle = HubPtr->OnFire.AddUObject(this, &UVersePerceptionService::HandleFire);
	ReloadHandle = HubPtr->OnReload.AddUObject(this, &UVersePerceptionService::HandleReload);
	HitHandle = HubPtr->OnHit.AddUObject(this, &UVersePerceptionService::HandleHit);
	DeathHandle = HubPtr->OnDeath.AddUObject(this, &UVersePerceptionService::HandleDeath);
	ArenaHandle = HubPtr->OnArenaSwitch.AddUObject(this, &UVersePerceptionService::HandleArenaSwitch);
}

void UVersePerceptionService::UnbindHub()
{
	if (UVerseEventHub* HubPtr = Hub.Get())
	{
		HubPtr->OnNoise.Remove(NoiseHandle);
		HubPtr->OnFire.Remove(FireHandle);
		HubPtr->OnReload.Remove(ReloadHandle);
		HubPtr->OnHit.Remove(HitHandle);
		HubPtr->OnDeath.Remove(DeathHandle);
		HubPtr->OnArenaSwitch.Remove(ArenaHandle);
	}
	Hub.Reset();
}

int32 UVersePerceptionService::PlayerIdOf(const AController& Controller)
{
	return Controller.PlayerState ? Controller.PlayerState->GetPlayerId() : INDEX_NONE;
}

bool UVersePerceptionService::IsServer() const
{
	const UWorld* World = GetWorld();
	return World && World->GetNetMode() != NM_Client;
}

void UVersePerceptionService::RegisterObserver(AController* Observer, const FVersePerceptionProfile& Profile)
{
	if (!Observer)
	{
		return;
	}
	UnregisterObserver(Observer);
	FRegistered& Entry = Registered.AddDefaulted_GetRef();
	Entry.Controller = Observer;
	Entry.PlayerId = PlayerIdOf(*Observer);
	Model.AddObserver(Entry.PlayerId, Profile);
}

void UVersePerceptionService::UnregisterObserver(AController* Observer)
{
	for (int32 Index = Registered.Num() - 1; Index >= 0; --Index)
	{
		if (Registered[Index].Controller.Get() == Observer || !Registered[Index].Controller.IsValid())
		{
			Model.RemoveObserver(Registered[Index].PlayerId);
			Registered.RemoveAt(Index);
		}
	}
}

bool UVersePerceptionService::IsRegistered(const AController* Observer) const
{
	return Registered.ContainsByPredicate([Observer](const FRegistered& Entry) { return Entry.Controller.Get() == Observer; });
}

void UVersePerceptionService::SetSightQuery(TScriptInterface<IVersePenetrationQuery> Query)
{
	SightQueryObject = Query.GetObject();
	SightQuery = Query.GetInterface();
}

void UVersePerceptionService::SetAudibilityTable(const UVerseAudibilityTable* Table)
{
	if (Table)
	{
		Audibility = Table;
	}
}

void UVersePerceptionService::SetVisibilityFactorProvider(TFunction<float(const FVector&)> Provider)
{
	VisibilityProvider = MoveTemp(Provider);
}

void UVersePerceptionService::SetLevelBands(float InMidMinZCm, float InUpperMinZCm)
{
	MidMinZCm = InMidMinZCm;
	UpperMinZCm = InUpperMinZCm;
}

void UVersePerceptionService::SetSelfPerceptFiller(TFunction<void(const APawn&, FVerseSelfPercept&)> Filler)
{
	SelfFiller = MoveTemp(Filler);
}

void UVersePerceptionService::SetBodyFiller(TFunction<void(const APawn&, FVersePerceptionBody&)> Filler)
{
	BodyFiller = MoveTemp(Filler);
}

void UVersePerceptionService::HandleReload(const FVerseReloadEvent& Event)
{
	Model.OnReload(Event);
}

void UVersePerceptionService::HandleNoise(const FVerseNoiseEvent& Event)
{
	Model.OnNoise(Event);
}

void UVersePerceptionService::HandleFire(const FVerseFireEvent& Event)
{
	Model.OnFire(Event);
}

void UVersePerceptionService::HandleHit(const FVerseHitEvent& Event)
{
	Model.OnHit(Event);
}

void UVersePerceptionService::HandleDeath(const FVerseDeathEvent& Event)
{
	TOptional<FVersePerceptionBody> Killer;
	if (const UWorld* World = GetWorld())
	{
		for (TActorIterator<APawn> It(World); It; ++It)
		{
			const APlayerState* State = It->GetPlayerState();
			if (State && State->GetPlayerId() == Event.KillerId)
			{
				Killer = MakeBody(**It, Event.KillerId);
				break;
			}
		}
	}
	Model.OnDeath(Event, Killer.GetPtrOrNull());
}

void UVersePerceptionService::HandleArenaSwitch(const FVerseArenaSwitchEvent& Event)
{
	Model.ResetEvents();
}

FVersePerceptionBody UVersePerceptionService::MakeBody(const APawn& Pawn, int32 PlayerId)
{
	FVersePerceptionBody Body;
	Body.PlayerId = PlayerId;
	const IVerseMovementQuery* Query = FindMovementQuery(Pawn);
	const USkeletalMeshComponent* Mesh = FindMesh(Pawn);

	Body.Velocity = Pawn.GetVelocity();
	Body.FacingYawDeg = float(Pawn.GetActorRotation().Yaw);
	const FRotator Aim = Pawn.GetBaseAimRotation();
	Body.FacingPitchDeg = float(FRotator::NormalizeAxis(Aim.Pitch));
	Body.Stance = StanceOf(Pawn, Query);
	Body.LeanQuantized = Query ? Query->GetLeanQuantized() : 0;
	if (const UVerseCombatStateComponent* Combat = Pawn.FindComponentByClass<UVerseCombatStateComponent>())
	{
		Body.bAlive = Combat->Phase != EVerseCombatPhase::Dead;
		Body.bSpawnProtected = Combat->bSpawnProtected;
	}

	if (!BoneLocation(Mesh, SampleBones[int32(EVerseSightSample::Pelvis)], Body.Pelvis))
	{
		Body.Pelvis = Pawn.GetActorLocation();
	}
	bool bAllBones = Mesh != nullptr;
	for (int32 Index = 0; Index < 8 && bAllBones; ++Index)
	{
		bAllBones = BoneLocation(Mesh, SampleBones[Index], Body.SamplePoints[Index]);
	}
	if (!bAllBones)
	{
		Body.SetSamplePointsFromStance();
	}

	if (!BoneLocation(Mesh, EyeBone, Body.Eye))
	{
		FRotator Unused;
		Pawn.GetActorEyesViewPoint(Body.Eye, Unused);
	}
	Body.View = Aim;
	return Body;
}

void UVersePerceptionService::GatherBodies(TArray<FVersePerceptionBody>& OutBodies) const
{
	OutBodies.Reset();
	const UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}
	for (TActorIterator<APawn> It(World); It; ++It)
	{
		const APlayerState* State = It->GetPlayerState();
		if (!State)
		{
			continue;
		}
		FVersePerceptionBody& Body = OutBodies.Add_GetRef(MakeBody(**It, State->GetPlayerId()));
		if (BodyFiller)
		{
			BodyFiller(**It, Body);
		}
	}
	// Actor iteration order is not part of the contract; sort so frames are deterministic (B5).
	OutBodies.Sort([](const FVersePerceptionBody& A, const FVersePerceptionBody& B) { return A.PlayerId < B.PlayerId; });
}

FVersePerceptionWorld UVersePerceptionService::MakeWorld() const
{
	FVersePerceptionWorld World;
	if (IVersePenetrationQuery* Query = SightQuery)
	{
		World.TestSight = [Query](const FVector& Eye, const FVector& Target) { return Query->TestSight(Eye, Target); };
	}
	World.VisibilityFactor = VisibilityProvider;
	World.Audibility = Audibility.Get();
	World.MidMinZCm = MidMinZCm;
	World.UpperMinZCm = UpperMinZCm;
	return World;
}

void UVersePerceptionService::Tick(float DeltaTime)
{
	if (IsServer())
	{
		StepPerception(DeltaTime);
	}
}

void UVersePerceptionService::StepPerception(float DeltaS)
{
	const UWorld* World = GetWorld();
	if (!World || Registered.Num() == 0)
	{
		return;
	}
	LastStepDeltaS = DeltaS;
	TArray<FVersePerceptionBody> Bodies;
	GatherBodies(Bodies);
	const FVersePerceptionWorld PerceptionWorld = MakeWorld();
	const uint32 NowMs = uint32(FMath::RoundToInt64(World->GetTimeSeconds() * 1000.0));

	// Copy: a delegate may unregister an observer.
	const TArray<FRegistered> Entries = Registered;
	for (const FRegistered& Entry : Entries)
	{
		AController* Controller = Entry.Controller.Get();
		if (!Controller)
		{
			continue;
		}
		FVersePerceptionObserverInput Input;
		if (const APawn* Pawn = Controller->GetPawn())
		{
			const FVersePerceptionBody* Own =
				Bodies.FindByPredicate([&Entry](const FVersePerceptionBody& Body) { return Body.PlayerId == Entry.PlayerId; });
			FVersePerceptionBody Body = Own ? *Own : MakeBody(*Pawn, Entry.PlayerId);
			if (!Own && BodyFiller)
			{
				BodyFiller(*Pawn, Body);
			}
			Input.Self.Location = Pawn->GetActorLocation();
			Input.Self.Velocity = Body.Velocity;
			Input.Self.EyeLocation = Body.Eye;
			Input.Self.ViewRotation = Controller->GetControlRotation();
			Input.Self.Stance = Body.Stance;
			Input.Self.bSpawnProtected = Body.bSpawnProtected;
			Input.Self.Phase = Body.bAlive ? EVerseCombatPhase::Alive : EVerseCombatPhase::Dead;
			if (const UVerseCombatStateComponent* Combat = Pawn->FindComponentByClass<UVerseCombatStateComponent>())
			{
				Input.Self.Phase = Combat->Phase;
			}
			Input.bAds = Body.bAds;
			Input.AdsFovDeg = Body.AdsFovDeg;
			if (SelfFiller)
			{
				SelfFiller(*Pawn, Input.Self);
			}
		}
		else
		{
			Input.Self.Phase = EVerseCombatPhase::Dead;
		}
		const FVersePerceptFrame Frame = Model.BuildFrame(Entry.PlayerId, Input, Bodies, PerceptionWorld, NowMs, DeltaS);
		OnPerceptFrame.Broadcast(Controller, Frame);
	}
}