Respan Dataset Explorer

Is it okay to replicate the character actor in the ability?

In general, it is okay to replicate the `CharacterActor` in the ability class, as long as you manage the replication properly.

However, be aware that replicating the character actor might lead to some potential issues:

1. Unnecessary Network Traffic: If the same character actor is replicated in multiple abilities, it can lead to increased network traffic, which might cause performance issues.

2. Circular Dependencies: If the character actor and the ability have a circular dependency, the replication could go into an infinite loop, causing the application to hang or crash.

To mitigate these potential issues, consider refactoring your code either by not replicating the character actor directly or by storing a unique identifier (e.g., network ID) in the ability class as a replicated variable. Then, when you need to access the character actor on clients, you can look up the actor based on the identifier.

For example, you could replace `CharacterActor` with a `NetworkID` property, like:

```cpp
UPROPERTY(Replicated)
int32 NetworkID;
```

Afterward, implement the `GetLifetimeReplicatedProps` function accordingly:

```cpp
void MyClass::GetLifetimeReplicatedProps(TArray< FLifetimeProperty > & OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
	DOREPLIFETIME(MyClass, NetworkID);
}
```

Now, on the server-side logic where you would set the `CharacterActor`, you would store its network ID instead:

```cpp
NetworkID = CharacterActor->GetUniqueID(); // or another identifier
```

Then, when you need to access the character actor in your ability class, you can look up the actor based on its network ID:

```cpp
AActor* CharacterActor = UGameplayStatics::GetActorByID(GetWorld(), NetworkID);
```

This approach can help you avoid potential issues related to replicating the character actor directly in multiple abilities.

For some reason, the replicated niagaraactor is spawning at the origin for the other clients. #include "RagnaAbilityNiagaraActor.h"
#include "NiagaraComponent.h"
#include <NiagaraFunctionLibrary.h>

ARagnaAbilityNiagaraActor::ARagnaAbilityNiagaraActor(const FObjectInitializer& ObjectInitializer)
: ANiagaraActor(ObjectInitializer)
{
	PrimaryActorTick.bCanEverTick = false;
	bReplicates = true;
	GetNiagaraComponent()->SetIsReplicated(true);

	//NiagaraComponent = CreateDefaultSubobject<UNiagaraComponent>(TEXT("NiagaraComponent"));
	//NiagaraComponent->SetupAttachment(RootComponent);
	GetNiagaraComponent()->SetIsReplicated(true);
	GetNiagaraComponent()->SetAutoActivate(false);  // Set to false if you want to activate it later
	GetNiagaraComponent()->SetAutoDestroy(true);
}

void ARagnaAbilityNiagaraActor::BeginPlay()
{
	Super::BeginPlay();
	GetNiagaraComponent()->Activate();
	//if (NiagaraSystem != nullptr)
	//{
		//GetNiagaraComponent()->SetAsset(NiagaraSystem);
		//GetNiagaraComponent()->Activate();
	//}
}

void ARagnaAbilityNiagaraActor::SetEmitterParameter(FVector SpawnLocation, FVector PositionToTarget, int AbilityLevel)
{
	GetNiagaraComponent()->SetVectorParameter("StartLocation", SpawnLocation);
	GetNiagaraComponent()->SetVectorParameter("AimPosition", PositionToTarget);
	GetNiagaraComponent()->SetIntParameter("SpawnCount", AbilityLevel);
}

//void ARagnaAbilityNiagaraActor::InitNiagaraComponent(TObjectPtr<UNiagaraSystem> NiagaraSystem)
//{
//	UNiagaraComponent* NiagaraComponent = UNiagaraFunctionLibrary::SpawnSystemAttached(NiagaraSystem, Character->GetMesh(), SocketName, FVector::ZeroVector, FRotator::ZeroRotator, EAttachLocation::SnapToTarget, true, true, ENCPoolMethod::None, true);
//}
//
//void ARagnaAbilityNiagaraActor::SetEmitterParameter()
//{
//
//}// Copyright 2022 Sabre Dart Studios


#include "Skills/RagnaTargetedAbility.h"
#include "Combat/CombatComponent.h"
#include "GameFramework/MovementComponent.h"
#include "PlayerCharacterGASController.h"
#include "AbilitySystemComponent.h"
#include "Character/PlayerCharacterBase.h"
#include <Abilities/Tasks/AbilityTask_WaitTargetData.h>
#include <Abilities/GameplayAbilityTargetActor_GroundTrace.h>
#include "Abilities/GameplayAbilityWorldReticle.h"
#include "Abilities/GameplayAbilityWorldReticle_ActorVisualization.h"
#include "RagnaAbilityWorldReticle.h"
#include "NiagaraFunctionLibrary.h"
#include "NiagaraSystem.h"
#include "NiagaraComponent.h"
#include "Data/GameStateData.h"
#include <RagnaAbilTargetActor_GroundTrace.h>
#include <GameplayAbilityPayloadData.h>
#include <Kismet/GameplayStatics.h>
#include <Data/Interface/AbilityCastBarDataInterface.h>
#include <RagnaAbilityNiagaraActor.h>

URagnaTargetedAbility::URagnaTargetedAbility()
{
	InstancingPolicy = EGameplayAbilityInstancingPolicy::InstancedPerActor;
	NetExecutionPolicy = EGameplayAbilityNetExecutionPolicy::ServerOnly;
}

void URagnaTargetedAbility::ActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, const FGameplayEventData* TriggerEventData)
{
	// Get the payload data with the actual level of the ability.
	UGameplayAbilityPayloadData* GameplayAbilityPayloadData = Cast<UGameplayAbilityPayloadData>(TriggerEventData->OptionalObject);

	this->AbilityLevel = GameplayAbilityPayloadData->GetCurrentAbilityLevel();
	this->TargetActorGroundTrace = GameplayAbilityPayloadData->GetTargetingActor();

	check(TargetActorGroundTrace.IsValid());

	WaitTargetDataTask = UAbilityTask_WaitTargetData::WaitTargetDataUsingActor(this, "Select Target", EGameplayTargetingConfirmation::UserConfirmed, TargetActorGroundTrace.Get());

	WaitTargetDataTask->ValidData.AddDynamic(this, &URagnaTargetedAbility::OnTargetDataReady);
	WaitTargetDataTask->Cancelled.AddDynamic(this, &URagnaTargetedAbility::OnTargetDataCancelled);
	WaitTargetDataTask->Activate();

	CharacterActor = Cast<AGameplayCharacterBase>(ActorInfo->OwnerActor);
	RagnaBaseAbilityType = NewObject<URagnaBaseAbilityType>(this, RagnaBaseAbilityTypeClass);
}

void URagnaTargetedAbility::OnTargetDataReady(const FGameplayAbilityTargetDataHandle& TargetData)
{
	DestroyAndResetTargetingWidgetRef();
	InternalTargetDataHandle = TargetData;
	// TODO: Need to investigate the index here. Assuming 0 for now.

	bool IsSingleTargetSkill = !this->AbilityTags.HasTag(FGameplayTag::RequestGameplayTag("Ability.AOE"));

	if (IsSingleTargetSkill)
	{
		AttemptToUseSingleTargetSkill(InternalTargetDataHandle);
	}
	else
	{
		AttempToUseAoeTargetSkill(InternalTargetDataHandle);
	}
}

void URagnaTargetedAbility::AttempToUseAoeTargetSkill(const FGameplayAbilityTargetDataHandle& TargetData)
{
	// The last item in the list is the center of the AOE where we should move our character.
	const FGameplayAbilityTargetData* MouseLocationTargetData = TargetData.Get(TargetData.Num() - 1);
	const FHitResult* MouseLocationHitResult = MouseLocationTargetData->GetHitResult();

	// TODO: Use Paper2Z to replicate the notification system for the character state machine for movement.
	ESpriteAction CurrentSpriteAction = GetCharacterCurrentAction();

	bool IsAvatarWithinRangeOfTarget = this->IsAvatarWithinRangeOfLocation(MouseLocationHitResult->Location);

	FTimerDelegate TimerDelegate;
	TimerDelegate.BindUFunction(this, FName("OnTargetDataReady"), TargetData);
	// Tries to move to the Target using the set range of the ability.
	TryToMoveToTarget(CurrentSpriteAction, IsAvatarWithinRangeOfTarget, TimerDelegate, MouseLocationHitResult->Location);

	if (!IsAvatarWithinRangeOfTarget)
	{
		// TryToMoveToTarget will call the ability again using a timer. 
		// So we can just return here and try again when it is called again.
		return;
	}

	StopCharacterMovement(CurrentSpriteAction);

	// TODO: Need to move to AOE center instead of the actual targets.
	// Apply ability affect on all targeted actors.
	if (!CommitAbility(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo(), GetCurrentActivationInfo()))
	{
		return;
	}

	FInternalCastBarDelegate LocalInternalCastBarDelegate;
	LocalInternalCastBarDelegate.BindUObject(this, &URagnaTargetedAbility::CastAOEAbility);
	// Not all abilities will have a cast bar, check if the currently active ability has a cast bar.
	if (TryStartAbilityCastBar(LocalInternalCastBarDelegate))
	{
		// Once the timer finishes the ability will be casted, we can end this end here for now.
		return;
	}
	CastAOEAbility();
}

void URagnaTargetedAbility::CastAOEAbility()
{
	// TODO: Use niagara component to update collision list of target per tick.
	// The last item in the list is the mouse location where we should use the AOE.
	// Let's ignore/skip it.
	for (int i = 0; i < InternalTargetDataHandle.Num() - 1; i++)
	{
		check(InternalTargetDataHandle.IsValid(i));

		const FGameplayAbilityTargetData* GameplayAbilityTargetData = InternalTargetDataHandle.Get(i);

		if (GameplayAbilityTargetData->GetActors().Num() > 0)
		{
			check(GameplayAbilityTargetData->GetActors().Num() == 1);
			TargetActor = GameplayAbilityTargetData->GetActors()[0];
		}
		else
		{
			TargetActor = GameplayAbilityTargetData->GetHitResult()->GetActor();
		}

		if (!TargetActor.IsValid())
		{
			continue;
		}

		AActor* ActorToTarget = TargetActor.Get();

		if (!ActorToTarget)
		{
			continue;
		}

		if (!RagnaBaseAbilityType->CanTargetActor(CharacterActor.Get(), ActorToTarget))
		{
			continue;
		}

		UseAbilityOnTarget(ActorToTarget);
	}
	EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, false, false);
}

void URagnaTargetedAbility::AttemptToUseSingleTargetSkill(const FGameplayAbilityTargetDataHandle& TargetData)
{
	check(TargetData.IsValid(0));

	const FGameplayAbilityTargetData* GameplayAbilityTargetData = TargetData.Get(0);

	check(GameplayAbilityTargetData->GetActors().Num() == 1);

	TargetActor = GameplayAbilityTargetData->GetActors()[0];

	// TODO: Use Paper2Z to replicate the notification system for the character state machine for movement.
	ESpriteAction CurrentSpriteAction = GetCharacterCurrentAction();

	bool IsAvatarWithinRangeOfTarget = this->IsAvatarWithinRangeOfLocation(TargetActor->GetActorLocation());

	FTimerDelegate TimerDelegate;
	TimerDelegate.BindUFunction(this, FName("OnTargetDataReady"), TargetData);
	// Tries to move to the Target using the set range of the ability.
	TryToMoveToTarget(CurrentSpriteAction, IsAvatarWithinRangeOfTarget, TimerDelegate, TargetActor->GetActorLocation());

	if (!IsAvatarWithinRangeOfTarget)
	{
		// TryToMoveToTarget will call the ability again using a timer. 
		// So we can just return here and try again when it is called again.
		return;
	}

	StopCharacterMovement(CurrentSpriteAction);

	AActor* ActorToTarget = TargetActor.Get();

	if (!RagnaBaseAbilityType->CanTargetActor(CharacterActor.Get(), ActorToTarget))
	{
		UE_LOG(LogTemp, Warning, TEXT("Not a valid target, not using ability on this actor."))
			EndAbility(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo(), GetCurrentActivationInfo(), true, true);
		return;
	}

	if (!CommitAbility(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo(), GetCurrentActivationInfo()))
	{
		EndAbility(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo(), GetCurrentActivationInfo(), true, true);
		return;
	}

	FInternalCastBarDelegate LocalInternalCastBarDelegate;
	LocalInternalCastBarDelegate.BindUObject(this, &URagnaTargetedAbility::CastSingleTargetAbility);
	// Not all abilities will have a cast bar, check if the currently active ability has a cast bar.
	if (TryStartAbilityCastBar(LocalInternalCastBarDelegate))
	{
		// Once the timer finishes the ability will be casted, we can end this end here for now.
		return;
	}

	CastSingleTargetAbility();

}

void URagnaTargetedAbility::CastSingleTargetAbility()
{
	//if (HasAuthority)
	//{
		UseNiagaraSystemEffect(CharacterActor->GetActorLocation(), TargetActor->GetActorLocation());
	//}
	UseAbilityOnTarget(TargetActor.Get());
	EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, false, false);
}

void URagnaTargetedAbility::OnTargetDataCancelled(const FGameplayAbilityTargetDataHandle& TargetData)
{
	DestroyAndResetTargetingWidgetRef();

	// The player has cancelled the target selection, so we need to end the ability execution
	EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true);
}

void URagnaTargetedAbility::UseNiagaraSystemEffect_Implementation(FVector SpawnLocation, FVector PositionToTarget)
{
	// TODO: Possible avoid showing the move effect when the move location is not a valid location.
	if (this->AbilityNiagaraAnimationAffect)
	{
		FActorSpawnParameters SpawnParameters;

		SpawnParameters.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
		SpawnParameters.Owner = CharacterActor.Get();
		SpawnParameters.bNoFail = true;
		SpawnParameters.bDeferConstruction = false;

		ARagnaAbilityNiagaraActor* NiagaraActor =
			GetWorld()->SpawnActorDeferred<ARagnaAbilityNiagaraActor>(RagnaAbilityNiagaraActorClass,
				FTransform(SpawnLocation), nullptr, nullptr, ESpawnActorCollisionHandlingMethod::AlwaysSpawn);

		if (NiagaraActor)
		{
			//NiagaraActor->InitNiagaraComponent(AbilityNiagaraAnimationAffect);
			NiagaraActor->SetEmitterParameter(SpawnLocation, PositionToTarget, this->AbilityLevel);
			//NiagaraActor->SetEmitterParameter(“StartLocation”, SpawnLocation);
			//NiagaraActor->SetEmitterParameter(“AimPosition”, PositionToTarget);
			//NiagaraActor->SetEmitterParameter(“SpawnCount”, this->AbilityLevel);

			// Finish deferred spawning, which will also start the Niagara System
			UGameplayStatics::FinishSpawningActor(NiagaraActor, FTransform(FRotator::ZeroRotator, SpawnLocation));

			// Set niagara actor lifespan
			NiagaraActor->SetLifeSpan(1.5);
			
			//NiagaraActor->ResetInLevel();
		}
	}
}

bool URagnaTargetedAbility::TryStartAbilityCastBar(FInternalCastBarDelegate CastBarDelegate)
{
	AGameStateBase* GameState = GetWorld()->GetGameState();
	// TODO: Might be fine to just store the data in the ability itself and not have to
	// store in the game state data.
	if (GameState->Implements<UAbilityCastBarDataInterface>())
	{
		// TODO: Error Prone, get the gameplaytag of the ability another way.
		FGameplayTag AbilityGameplayTag = this->AbilityTags.GetByIndex(0);
		FAbilityCastBarData AbilityCastBarData;
		if (Cast<IAbilityCastBarDataInterface>(GameState)->GetAbilityCastBarDataFromDataTable(AbilityCastBarData, AbilityGameplayTag))
		{
			APlayerCharacterBase* PlayerCharacter = Cast<APlayerCharacterBase>(CharacterActor);
			PlayerCharacter->InitCastBarUIWidget(AbilityCastBarData.CastbarColor);


			FTimerDelegate Delegate;
			float TimerTickRate = 0.05;
			float StartCastTimer = 0.0f;
			// Key into the data using the ability level - 1.
			float MaxCastTimer = AbilityCastBarData.CastTimes[AbilityLevel - 1];
			Delegate.BindLambda([=]() mutable
				{
					StartCastTimer += TimerTickRate;

					PlayerCharacter->UpdateCastBarUIWidget(StartCastTimer, MaxCastTimer);

					if (StartCastTimer >= MaxCastTimer)
					{
						CastBarDelegate.ExecuteIfBound();
						ClearAbilityCastTimer();
					}
				});
			GetWorld()->GetTimerManager().SetTimer(CastBarTimerHandle, Delegate, TimerTickRate, true, TimerTickRate);
			return true;
		}
	}
	return false;
}

void URagnaTargetedAbility::ClearAbilityCastTimer()
{
	if (GetWorld()->GetTimerManager().IsTimerActive(CastBarTimerHandle))
	{
		GetWorld()->GetTimerManager().ClearTimer(CastBarTimerHandle);
	}
}

bool URagnaTargetedAbility::CanActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayTagContainer* SourceTags, const FGameplayTagContainer* TargetTags, OUT FGameplayTagContainer* OptionalRelevantTags) const
{
	return Super::CanActivateAbility(Handle, ActorInfo, SourceTags, TargetTags, OptionalRelevantTags);
}

void URagnaTargetedAbility::UseAbilityOnTarget(AActor* ActorGettingTargeted)
{
	if (!ActorGettingTargeted)
	{
		UE_LOG(LogTemp, Warning, TEXT("No actor getting targeted for targeting ability."))
			EndAbility(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo(), GetCurrentActivationInfo(), true, true);
		return;
	}

	if (!AbilityEffect)
	{
		UE_LOG(LogTemp, Warning, TEXT("Ability does not have an effect set on the blueprint."))
			EndAbility(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo(), GetCurrentActivationInfo(), true, true);
		return;
	}

	UAbilitySystemComponent* OwnerAbilitySystem = GetAbilitySystemComponentFromActorInfo();
	const FGameplayEffectContextHandle EffectContext = MakeEffectContext(GetCurrentAbilitySpecHandle(), GetCurrentActorInfo());
	FGameplayEffectSpecHandle SpecHandle = OwnerAbilitySystem->MakeOutgoingSpec(AbilityEffect, this->AbilityLevel, EffectContext);

	UAbilitySystemComponent* TargetAbilitySystem = ActorGettingTargeted->FindComponentByClass<UAbilitySystemComponent>();
	FActiveGameplayEffectHandle EffectHandle = OwnerAbilitySystem->ApplyGameplayEffectSpecToTarget(*SpecHandle.Data.Get(), TargetAbilitySystem);
}

void URagnaTargetedAbility::EndAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled)
{
	DestroyAndResetTargetingWidgetRef();
	ClearAbilityCastTimer();
	Cast<APlayerCharacterBase>(CharacterActor)->ResetCastBarUIWidget();
	Super::EndAbility(Handle, ActorInfo, ActivationInfo, bReplicateEndAbility, bWasCancelled);
}

void URagnaTargetedAbility::DestroyAndResetTargetingWidgetRef()
{
	if (TargetActorGroundTrace.IsValid())
	{
		TargetActorGroundTrace->EndTargeting();
	}
	APlayerController* PlayerController = UGameplayStatics::GetPlayerController(GetOwningActorFromActorInfo(), 0);

	if (PlayerController)
	{
		APlayerCharacterGASController* MyPlayerController = Cast<APlayerCharacterGASController>(PlayerController);

		if (MyPlayerController)
		{
			// Assuming you have a function in your player controller to reset the widget reference
			MyPlayerController->ResetTargetingWidgetReference();
		}
	}
}

The reason for the Niagara actor spawning at the origin for other clients might be due to the `SpawnLocation` parameter not being set correctly when calling the `UseNiagaraSystemEffect` function from other clients.

To debug this issue, I recommend adding some log messages to check the values of the variables used in the spawning process. Add logs to print the `SpawnLocation` and `PositionToTarget` values when calling the `UseNiagaraSystemEffect` function, and in the `SetEmitterParameter` function inside the `ARagnaAbilityNiagaraActor` class where you set the actual parameters for the Niagara system.

For example, in the `UseNiagaraSystemEffect_Implementation` function, you can add some logs like this:

```cpp
UE_LOG(LogTemp, Warning, TEXT("UseNiagaraSystemEffect_Implementation called from %s, SpawnLocation: %s, PositionToTarget: %s"), *HasAuthority() ? TEXT("Server") : TEXT("Client"), *SpawnLocation.ToString(), *PositionToTarget.ToString());
```

And in the `ARagnaAbilityNiagaraActor::SetEmitterParameter()` function, add a log like this:

```cpp
UE_LOG(LogTemp, Warning, TEXT("ARagnaAbilityNiagaraActor::SetEmitterParameter called, setting StartLocation: %s, AimPosition: %s"), *SpawnLocation.ToString(), *PositionToTarget.ToString());
```

Run the game again and watch for these log messages to see if the values are correct and match between clients and the server.

Another thing to check is that the `CharacterActor` variable is replicated properly and initialized before the `UseNiagaraSystemEffect_Implementation` function is called on all clients. If this variable is null for other clients when the function is being called, it might cause the spawned Niagara actor to appear at the origin.

If you find that some values are incorrect or not synchronized properly across clients and the server, you may need to adjust your replication logic or use a multicast function to ensure that all actors and variables are synchronized correctly across clients.

How do I get HasAuthority inside an ability?

To check for authority within a gameplay ability, you can use the `HasAuthority` function from the `UGameplayAbility` class, which is inherited in your custom ability class. The `HasAuthority` function checks if the current `GameplayAbility` instance running on the server or the client.

Here's an example of how you can use `HasAuthority` in a gameplay ability:

```cpp
void UMyGameplayAbility::MyFunction()
{
    if (HasAuthority())
    {
        // Your server-side logic here
    }
    else
    {
        // Your client-side logic here
    }
}
```

Keep in mind that `HasAuthority` is a convenience function that essentially checks `IsAuthority()` of the `UGameplayAbility`'s `CurrentActorInfo`. `IsAuthority()` in turn checks if the `Role` of the `OwnerActor` of the ability is set to `ROLE_Authority`. Here's the source code of `HasAuthority()`:

```cpp
FORCEINLINE bool HasAuthority() const
{
	return (GetActorInfo().IsAuthority());
}
```

Be cautious about the execution flow when you use `HasAuthority`. It is best to ensure that your server-side and client-side logic is separated correctly and validate the simulation on the clients when necessary, since otherwise you may run into issues such as desynchronization between the server and the clients.

LogTemp: Warning: ARagnaAbilityNiagaraActor::SetEmitterParameter called, setting StartLocation : X=-280.099 Y=318.841 Z=89.650, AimPosition : X=-70.000 Y=740.000 Z=89.650
LogTemp: Warning: UseNiagaraSystemEffect_Implementation called from SpawnLocation: X=-280.099 Y=318.841 Z=89.650, PositionToTarget : X=-70.000 Y=740.000 Z=89.650
LogTemp: Warning: ARagnaAbilityNiagaraActor::SetEmitterParameter called, setting StartLocation : X=-280.099 Y=318.841 Z=89.650, AimPosition : X=-70.000 Y=740.000 Z=89.650
LogTemp: Warning: UseNiagaraSystemEffect_Implementation called from SpawnLocation: X=-280.099 Y=318.841 Z=89.650, PositionToTarget : X=-70.000 Y=740.000 Z=89.650 The data looks good. Any other ideas why it could be spawning at the origin. I am not currently replicating the character actor.

If the data seems correct, it's possible that the issue lies within the Niagara system itself. You should check the Niagara system's settings and script logic to make sure it's correctly using the passed parameters.

It could also be an issue with the deferred spawn method you're using. Instead of using `SpawnActorDeferred` and `UGameplayStatics::FinishSpawningActor`, you can try using `SpawnActor` directly to see if it resolves the issue. If it does, you can investigate further into the deferred spawning process.

Here's an example of how you can spawn your Niagara actor using the `SpawnActor` method:

```cpp
ARagnaAbilityNiagaraActor* NiagaraActor = GetWorld()->SpawnActor<ARagnaAbilityNiagaraActor>(RagnaAbilityNiagaraActorClass, FTransform(SpawnLocation), SpawnParameters);

if (NiagaraActor)
{
    NiagaraActor->SetEmitterParameter(SpawnLocation, PositionToTarget, this->AbilityLevel);
}
```

Another possible reason for the issue could be related to the initial state of the Niagara system or components. If the Niagara system starts immediately when the actor is spawned, it could be causing the effect to spawn at the origin before the parameters are set in the `SetEmitterParameter` call.

To investigate this, try disabling the auto-activation of the Niagara component to make sure it doesn't start until the parameters are set. In the `ARagnaAbilityNiagaraActor` constructor, you've already disabled auto-activation:

```cpp
GetNiagaraComponent()->SetAutoActivate(false);
```

Now, activate the Niagara system after setting the parameters:

```cpp
ARagnaAbilityNiagaraActor* NiagaraActor = GetWorld()->SpawnActor<ARagnaAbilityNiagaraActor>(RagnaAbilityNiagaraActorClass, FTransform(SpawnLocation), SpawnParameters);

if (NiagaraActor)
{
    NiagaraActor->SetEmitterParameter(SpawnLocation, PositionToTarget, this->AbilityLevel);
    NiagaraActor->GetNiagaraComponent()->Activate();
}
```

If none of these suggestions work, it could be worth verifying if the parameters are being applied correctly in the Niagara system scripts. You can try spawning the effect in the level manually and setting the parameters via the Blueprint Editor or Level Editor to see if the effect behaves correctly with the given parameters. This can help you identify if the issue is within the Niagara system or its implementation within your gameplay ability.

Changing it SpawnActor Now the actor not replicating to the other clients

It is likely that the issue lies in the replication settings of the `ARagnaAbilityNiagaraActor`. You've already set `bReplicates` to true, but you also need to set `bAlwaysRelevant` in order for the actor to be replicated to all clients:

```cpp
ARagnaAbilityNiagaraActor::ARagnaAbilityNiagaraActor(const FObjectInitializer& ObjectInitializer)
: ANiagaraActor(ObjectInitializer)
{
    // ...

    bReplicates = true;
    bAlwaysRelevant = true;

    // ...
}
```

Setting `bAlwaysRelevant` ensures that the actor is always considered relevant for replication, even if it's not in the view of the clients.

In addition to that, you should confirm that the Niagara component's replication settings are set correctly. You've already set the component's `SetIsReplicated` property to true:

```cpp
GetNiagaraComponent()->SetIsReplicated(true);
```

You can also try setting the Niagara component's `bNetAddressable` property to true:

```cpp
GetNiagaraComponent()->bNetAddressable = true;
```

This should ensure that the Niagara component will be replicated across all clients.

If the issue persists, you may consider using a multicast function to spawn the actor on all clients, just as you were doing with the `UseNiagaraSystemEffect` function. In this case, you would create a multicast function in your ability, call it after the server-side spawn or on the correct event, and provide the necessary parameters, such as the actor location.

Here's an example:

```cpp
// URagnaTargetedAbility.h

UFUNCTION(NetMulticast, Reliable)
void MulticastSpawnNiagaraActor(FVector SpawnLocation, FVector PositionToTarget);

// URagnaTargetedAbility.cpp

void URagnaTargetedAbility::MulticastSpawnNiagaraActor_Implementation(FVector SpawnLocation, FVector PositionToTarget)
{
    if (!HasAuthority())
    {
        FActorSpawnParameters SpawnParameters;
        SpawnParameters.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;

        ARagnaAbilityNiagaraActor* NiagaraActor = GetWorld()->SpawnActor<ARagnaAbilityNiagaraActor>(RagnaAbilityNiagaraActorClass, FTransform(SpawnLocation), SpawnParameters);

        if (NiagaraActor)
        {
            NiagaraActor->SetEmitterParameter(SpawnLocation, PositionToTarget, this->AbilityLevel);
        }
    }
}

// Usage:

void URagnaTargetedAbility::SomeOtherFunction()
{
    FVector SpawnLocation; // Get spawn location
    FVector PositionToTarget; // Get position to target

    if (HasAuthority())
    {
        MulticastSpawnNiagaraActor(SpawnLocation, PositionToTarget);
    }
}
```

Remember that calling the multicast function should be done in the correct place within your ability logic to ensure correct state on both server and clients.

For some reason, the replicated niagara actor is using the default user parameters set in the system. It's not using 	GetNiagaraComponent()->SetVectorParameter("StartLocation", SpawnLocation);
	GetNiagaraComponent()->SetVectorParameter("AimPosition", PositionToTarget);
	GetNiagaraComponent()->SetIntParameter("SpawnCount", AbilityLevel); for some reason. Why would this be the case?

This issue could be related to the timing of the function calls. Since you are using replication, there could be a delay in setting the parameters in the Niagara system, causing it to use the default values when activated.

To address this issue, you can try the following approach:

1. In the `ARagnaAbilityNiagaraActor::BeginPlay()` function, where you currently activate the Niagara System, remove the call to `GetNiagaraComponent()->Activate();`.

```cpp
void ARagnaAbilityNiagaraActor::BeginPlay()
{
    Super::BeginPlay();
}
```

2. Modify the `ARagnaAbilityNiagaraActor::SetEmitterParameter()` function to activate the Niagara System after setting the parameters.

```cpp
void ARagnaAbilityNiagaraActor::SetEmitterParameter(FVector SpawnLocation, FVector PositionToTarget, int AbilityLevel)
{
    GetNiagaraComponent()->SetVectorParameter("StartLocation", SpawnLocation);
    GetNiagaraComponent()->SetVectorParameter("AimPosition", PositionToTarget);
    GetNiagaraComponent()->SetIntParameter("SpawnCount", AbilityLevel);
    GetNiagaraComponent()->Activate();
}
```

By activating the Niagara System within the `SetEmitterParameter()` function, you ensure that the Niagara animation won't start until after the parameters are set.

If this doesn't resolve the issue, it's possible that there is an error within the Niagara System itself, causing it to not recognize the updated parameters. Make sure the Niagara setup scripts and emitters are correctly using the parameters you've set. Double-check any conditions, executions, or script logic related to those parameters in your Niagara System, and confirm that the parameters are being applied consistently throughout the Niagara emitters and modules.

Could it be possible that the user parameters isn't replicating properly?

Yes, it's possible that the user parameters aren't being replicated properly. Niagara systems themselves are not designed to replicate by default; only the spawning and destruction of the Niagara actors are replicated. Therefore, you need to handle the replication of the user parameters manually.

To do this, you can use a multicast function to set the parameters on all clients. Here's an example that demonstrates how to create a multicast function to set the Niagara parameters and activate the Niagara system:

1. Add a `NetMulticast` function to the `ARagnaAbilityNiagaraActor` class:

```cpp
// ARagnaAbilityNiagaraActor.h

UFUNCTION(NetMulticast, Reliable)
void MulticastSetEmitterParametersAndActivate(FVector SpawnLocation, FVector PositionToTarget, int AbilityLevel);
```

2. Implement the multicast function in the `ARagnaAbilityNiagaraActor.cpp` file:

```cpp
void ARagnaAbilityNiagaraActor::MulticastSetEmitterParametersAndActivate_Implementation(FVector SpawnLocation, FVector PositionToTarget, int AbilityLevel)
{
    GetNiagaraComponent()->SetVectorParameter("StartLocation", SpawnLocation);
    GetNiagaraComponent()->SetVectorParameter("AimPosition", PositionToTarget);
    GetNiagaraComponent()->SetIntParameter("SpawnCount", AbilityLevel);
    GetNiagaraComponent()->Activate();
}
```

3. Call the multicast function in your ability class:

```cpp
void URagnaTargetedAbility::SpawnNiagaraActorAndSetParameters(FVector SpawnLocation, FVector PositionToTarget, int AbilityLevel)
{
    FActorSpawnParameters SpawnParameters;
    SpawnParameters.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
    SpawnParameters.Owner = CharacterActor.Get();
    SpawnParameters.bNoFail = true;
    SpawnParameters.bDeferConstruction = false;

    ARagnaAbilityNiagaraActor* NiagaraActor =
        GetWorld()->SpawnActor<ARagnaAbilityNiagaraActor>(RagnaAbilityNiagaraActorClass,
            FTransform(SpawnLocation), SpawnParameters);

    if (NiagaraActor)
    {
        NiagaraActor->MulticastSetEmitterParametersAndActivate(SpawnLocation, PositionToTarget, AbilityLevel);
    }
}
```

By using a multicast function to apply the parameters and activate the Niagara system, you ensure that the custom user parameters are correctly set on all connected clients.

However, remember to call this function correctly in your ability's logic flow. If your gameplay ability uses the `HasAuthority()` check as in previous examples, make sure to call this new function on the server side only:

```cpp
if (HasAuthority())
{
    SpawnNiagaraActorAndSetParameters(SpawnLocation, PositionToTarget, AbilityLevel);
}
```

//@version=5
//Idea by ALKHO_OLY on APR 7, 2022.


indicator('ULTIMATE-12IN1 (BY KHO_OLIO)-2023', shorttitle='12IN1 FRAME BY KHOOLIO-2023', overlay=false, timeframe="", timeframe_gaps=true)

// Check for higher highs and lower lows


//BANDS strength
normal1 = ta.ema(high, 4)
normal2 = ta.ema(low, 4)
normal3 = ta.ema(high, 7)
normal4 = ta.ema(low, 7)
normal5 = ta.wma(high, 4)
normal6 = ta.wma(low, 4)
normal7 = ta.wma(high, 7)
normal8 = ta.wma(low, 7)
up1 = normal1 > normal3 and normal2 > normal4
down1 = normal2 < normal4 and normal1 < normal3
up2 = normal5 > normal7 and normal6 > normal8
down2 = normal6 < normal8 and normal5 < normal7
bandupi = up1 and up2 and normal1 > normal1[1] and normal3 > normal3[1] and normal2 > normal2[1] and normal4 > normal4[1] and normal5 > normal5[1] and normal7 > normal7[1] and normal6 > normal6[1] and normal8 > normal8[1]
banddowni = down1 and down2 and normal2 < normal2[1] and normal4 < normal4[1] and normal1 < normal1[1] and normal3 < normal3[1] and normal6 < normal6[1] and normal8 < normal8[1] and normal5 < normal5[1] and normal7 < normal7[1]



//MACD strength 
fast = ta.ema(close, 50)
slow = ta.ema(close, 64)
MACD = fast - slow
signal = ta.ema(MACD, 47)
hist = MACD - signal
macdupi = MACD > signal and hist > hist[1] or MACD < signal and hist > hist[1]
macddowni = MACD < signal and hist < hist[1] or MACD > signal and hist < hist[1]



//PARABOLICSAR strength
out = ta.sar(0.02, 0.022, 0.2)
sarupi = close > out and out > out[1]
sardowni = close < out and out < out[1]



//RSI strength 
RSI1s = ta.rma(ta.rsi(close, 14), 7)
RSI1 = ta.sma(RSI1s, 7)
RSI2s = ta.rma(RSI1, 7)
RSI2 = ta.sma(RSI2s, 7)
rsiupi = RSI1 > RSI2
rsidowni = RSI1 < RSI2



//Stochastic strength
STOCHKs = ta.rma(ta.stoch(close, high, low, 14), 3)
STOCHK = ta.sma(STOCHKs, 3)
STOCHDs = ta.rma(STOCHK, 3)
STOCHD = ta.sma(STOCHDs, 3)
stochupi = STOCHK > STOCHD
stochdowni = STOCHK < STOCHD



//CCI strength
CCI1s = ta.rma(ta.cci(close, 14), 14)
CCI1 = ta.sma(CCI1s, 14)
CCI2s = ta.rma(CCI1, 4)
CCI2 = ta.sma(CCI2s, 4)
cciupi = CCI1 > CCI2
ccidowni = CCI1 < CCI2



//ADX strength
TrueRange = math.max(math.max(high - low, math.abs(high - nz(close[1]))), math.abs(low - nz(close[1])))
DirectionalMovementPlus = high - nz(high[1]) > nz(low[1]) - low ? math.max(high - nz(high[1]), 0) : 0
DirectionalMovementMinus = nz(low[1]) - low > high - nz(high[1]) ? math.max(nz(low[1]) - low, 0) : 0
SmoothedTrueRange = nz(TrueRange[1]) - nz(TrueRange[1]) / 14 + TrueRange
SmoothedDirectionalMovementPlus = nz(DirectionalMovementPlus[1]) - nz(DirectionalMovementPlus[1]) / 14 + DirectionalMovementPlus
SmoothedDirectionalMovementMinus = nz(DirectionalMovementMinus[1]) - nz(DirectionalMovementMinus[1]) / 14 + DirectionalMovementMinus
DIPlus = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIMinus = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = math.abs(DIPlus - DIMinus) / (DIPlus + DIMinus) * 100
ADX = ta.sma(DX, 14)
ADIPLUS = ta.sma(DIPlus, 14)
ADIMINUS = ta.sma(DIMinus, 14)
adxupi = ADIPLUS > ADIMINUS and ADX > 20
adxdowni = ADIPLUS < ADIMINUS and ADX > 20



//ATR strength 
atr2s = ta.ema(ta.tr, 7)
atr2 = ta.ema(atr2s, 7)
atr = ta.atr(7)
up = hl2 - 0.4 * atr
upr = nz(up[1], up)
up := close[1] > upr ? math.max(up, upr) : up
dn = hl2 + 0.4 * atr
dnr = nz(dn[1], dn)
dn := close[1] < dnr ? math.min(dn, dnr) : dn
trend = 1
trend := nz(trend[1], trend)
trend := trend == -1 and close > dnr ? 1 : trend == 1 and close < upr ? -1 : trend
Atrup = trend == 1 and trend[1] == -1
Atrdown = trend == -1 and trend[1] == 1
atrup = close > upr and trend == 1
atrdown = close < dnr and trend == -1



//Trend direction&strengthBars
td1s = ta.rma(close, 4)
td1 = ta.sma(td1s, 4)
td2s = ta.rma(open, 4)
td2 = ta.sma(td2s, 4)
tdup = td1 > td2
tddown = td1 < td2
tdupi = tdup
tddowni = tddown
tdups = tdup
tddowns = tddown
tbupi = tdup and close > td1
tbdowni = tddown and close < td1



//volume 
p1 = close
v1 = volume
p2 = p1[21]
v2 = v1[21]
va1 = p1 > p2 and v1 > v2
va2 = p1 > p2 and v1 < v2
va3 = p1 < p2 and v1 < v2
va4 = p1 < p2 and v1 > v2
vaupi = va1 or va2
vadowni = va3 or va4



//Bullish & Bearish strength 
bbsource = (close > open) ? (high-low) : (low-high)
bbupi = (ta.ema(bbsource, 3)) > 0
bbdowni = (ta.ema(bbsource, 3)) < 0



//Indicator strength&alert
x = 1
y = -1
z = 0
bandupn = bandupi ? x : z
banddownn = banddowni ? y : z
macdupn = macdupi ? x : z
macddownn = macddowni ? y : z
sarupn = sarupi ? x : z
sardownn = sardowni ? y : z
rsiupn = rsiupi ? x : z
rsidownn = rsidowni ? y : z
stochupn = stochupi ? x : z
stochdownn = stochdowni ? y : z
cciupn = cciupi ? x : z
ccidownn = ccidowni ? y : z
adxupn = adxupi ? x : z
adxdownn = adxdowni ? y : z
atrupn = atrup ? x : z
atrdownn = atrdown ? y : z
tdupn = tdupi ? x : z
tddownn = tddowni ? y : z
tbupn = tbupi ? x : z
tbdownn = tbdowni ? y : z
vaupn = vaupi ? x : z
vadownn = vadowni ? y : z
bbupn = bbupi ? x : z
bbdownn = bbdowni ? y : z
a = bandupn == 0 and banddownn == 0
b = macdupn == 0 and macddownn == 0
c = sarupn == 0 and sardownn == 0
d = rsiupn == 0 and rsidownn == 0
e = stochupn == 0 and stochdownn == 0
f = cciupn == 0 and ccidownn == 0
g = adxupn == 0 and adxdownn == 0
h = atrupn == 0 and atrdownn == 0
i = tdupn == 0 and tddownn == 0
j = tbupn == 0 and tbdownn == 0
k = vaupn == 0 and vadownn == 0
m = bbupn == 0 and bbdownn == 0
bandn = a ? x : z
macdn = b ? x : z
sarn = c ? x : z
rsin = d ? x : z
stochn = e ? x : z
ccin = f ? x : z
adxn = g ? x : z
atrn = h ? x : z
tdn = i ? x : z
tbn = j ? x : z
van = k ? x : z
bbn = m ? x : z

indicatorresualt = bandupn + banddownn + macdupn + macddownn + sarupn + sardownn + rsiupn + rsidownn + stochupn + stochdownn + cciupn + ccidownn + adxupn + adxdownn + atrupn + atrdownn + tdupn + tddownn + tbupn + tbdownn + vaupn + vadownn + bbupn + bbdownn
indicatoractive = (bandn + macdn + sarn + rsin + stochn + ccin + adxn + atrn + tdn + tbn + van + bbn) -12
indicatorsource = indicatorresualt / indicatoractive * -12
indicatorp = input(defval = 80, title='indicator Length')
ipush = ta.rma(indicatorsource, indicatorp)
[supertrend, direction] = ta.supertrend(indicatorp/100, indicatorp)
ipushcolor1 = (direction < 0) ? color.new(color.gray,70) : (direction > 0) ? color.new(color.black,40): na  
plot(ipush, title='Market Sentiments Moves', style=plot.style_areabr, linewidth=1, color=ipushcolor1)
l0= hline(0,'CENTER',color.black,hline.style_solid,1)
l1= hline(2,'R1',color.new(color.red, 50),hline.style_solid,1)
l3= hline(4,'R2',color.new(color.red, 50),hline.style_solid,2)
l5= hline(6,'R3',color.new(color.red, 60),hline.style_solid,3)
l2= hline(-2,'S1',color.new(color.teal, 50),hline.style_solid,1)
l4= hline(-4,'S2',color.new(color.teal, 50),hline.style_solid,2)
l6= hline(-6,'S3',color.new(color.teal, 60),hline.style_solid,3)
l01= hline(0.8,'CorrectionArea-UpperBand', color.black, hline.style_dotted,2)
l02= hline(-0.8,'CorrectionArea-LowerBand',color.black, hline.style_dotted,2)
fill(l01,l02,title='CorrectionArea',color=color.new(color.yellow,90))


//fibonacci
high_point = ta.highest(ipush,indicatorp)
low_point = ta.lowest(ipush, indicatorp)
fib0 = high_point
fib1 = low_point
f4p = plot(fib1, title='Support', style=plot.style_linebr, linewidth=2, color=color.new(color.black,0))
f0p = plot(fib0, title='Resistance', style=plot.style_linebr, linewidth=2, color=color.new(color.black,0))
f0c = (fib0 > fib0[1]) ? color.new(color.green, 0) :na
f0pp= plot(fib0, title= 'Bullish-Break/R', style=plot.style_stepline_diamond, linewidth=2, color=f0c)
f1c = (fib1 < fib1[1]) ? color.new(color.red, 0) :na
f4pp= plot(fib1, title= 'Bearish-Break/S', style=plot.style_stepline_diamond, linewidth=2, color=f1c)

The Ultimate-12in1 indicator is a custom indicator that combines a wide range of technical analysis tools, including moving averages, MACD, Parabolic SAR, RSI, Stochastic, CCI, ADX, ATR, Trend Direction & Strength bars, volume and bullish/bearish strength indicators. The primary goal of the Ultimate-12in1 indicator is to provide traders with a comprehensive view of market conditions by integrating multiple technical analysis tools into a single indicator.

The indicator works by calculating the strength of each technical tool and then aggregating their results. The combined results are then displayed on a chart as an areabr plot, which depicts the market sentiment and potential support and resistance levels. The indicator also includes a correction area between two dotted lines, which may indicate a potential reversal zone for price action.

The Ultimate-12in1 indicator is useful for traders looking for a comprehensive overview of the market sentiment and potential trading opportunities derived from multiple technical tools. By combining various technical analysis tools, traders can save time and screen space while analyzing the market.

Traders should remember that no single indicator can guarantee accurate trading signals, and the Ultimate-12in1 indicator should be used in conjunction with other technical analysis tools, fundamental analysis, and risk management techniques to develop a well-rounded trading strategy.

explain more 

The Ultimate-12in1 indicator integrates twelve popular technical analysis tools to provide a comprehensive view of the market sentiment, potential support and resistance levels, and possible trading opportunities. Here is a brief explanation of the components used in this powerful indicator:

1. Bands strength: The indicator incorporates Exponential Moving Averages (EMAs) and Weighted Moving Averages (WMAs) of highs and lows to determine the strength of up and down movements in the market.

2. MACD strength: The Moving Average Convergence Divergence (MACD) component measures the relationship between two EMAs of closing prices. MACD histograms are used to understand the momentum by comparing the MACD line with its corresponding signal line.

3. Parabolic SAR strength: This component follows the trend and stops when the trend reverses. Upward and downward trends are determined by comparing the closing price and Parabolic SAR values.

4. RSI strength: The Relative Strength Index (RSI) measures the speed and change of price movement. Smoothed and adapted versions of RSI are used to ascertain bullish and bearish momentum in the market.

5. Stochastic strength: This component compares the closing price with the high and low range over a certain period. The Stochastic oscillator helps to determine overbought and oversold conditions and possible trend reversals.

6. CCI strength: The Commodity Channel Index (CCI) measures the difference between the typical price of an asset and its moving average. CCI is used to identify cyclical trends and potential reversals.

7. ADX strength: The Average Directional Index (ADX) is a momentum indicator that measures the strength of the trend. It can help determine if the market is trending or consolidating.

8. ATR strength: The Average True Range (ATR) component is a measure of volatility that captures the range of price movements. The ATR-based stop and reverse mechanism is used to detect potential trend reversals.

9. Trend Direction & Strength bars: This component calculates the relationship between the closing and opening prices to identify trend direction and strength.

10. Volume: The volume component helps assess whether price movements are supported by strong or weak market participation, potentially indicating the continuation or exhaustion of current trends.

11. Bullish and Bearish strength: This component measures the bullish and bearish strength by calculating the difference between the close and open prices in relation to the high-low range.

12. Fibonacci levels: The indicator also includes Fibonacci levels, which are used as potential support and resistance levels based on the highest and lowest values of the combined indicator.

While the Ultimate-12in1 indicator attempts to provide comprehensive market analysis by combining multiple tools, traders should not solely rely on this indicator for trading decisions. In addition, they should use other analysis techniques, such as chart patterns, support and resistance levels, and appropriate risk management strategies to minimize losses and protect potential profits.

how many people use this script 

As an AI language model, I don't have the real-time data or ability to accurately determine the exact number of people using the Ultimate-12in1 indicator script. However, the popularity and usage of custom scripts or indicators often depend on the preferences and needs of individual traders.

The Ultimate-12in1 indicator is a combination of various technical analysis tools, making it particularly useful for traders who want to analyze the market using multiple techniques in one unified way. As a result, it might be popular among traders looking for comprehensive market analysis. Remember that this indicator may not be widely known or used since it is a custom script and not a built-in feature of common trading platforms.