AProjectileBase Class Reference

#include <ProjectileBase.h>

Inheritance diagram for AProjectileBase:

Public Member Functions
	AProjectileBase ()
virtual void	DelayTrigger ()
void	SetMesh (UStaticMesh *StaticMesh) const
virtual void	SetProjectileStats (const struct FWeaponProjectileStats_T &Stats) override
virtual void	SetDefaultDamage (const float Damage) override
virtual void	SetActorsToIgnore (const TArray< AActor * > &ActorsToIgnore) override
virtual void	SetDebuggingMode (const bool bValue) override
virtual void	SetInstigator (AController *Controller) override

Public Attributes
bool	bDebuggingMode = false

Protected Member Functions
virtual void	BeginPlay () override
virtual void	OnProjectileStop (const FHitResult &HitResult)
virtual void	ProjectileDestroy ()

Protected Attributes
class UCapsuleComponent *	CapsuleComponent
class UStaticMeshComponent *	StaticMeshComponent
class UProjectileMovementComponent *	ProjectileMovementComponent
UNiagaraComponent *	TrailEffects
struct FWeaponProjectileStats_T	ProjectileStats
UAudioComponent *	ProjectileSound = nullptr
class UNiagaraSystem *	ExplosionEffects
TSubclassOf< AActor >	DestructionField
TArray< AActor * >	DamageActorsToIgnore
AController *	InstigatorController
USceneComponent *	HomingTarget

Private Member Functions
void	SpawnTrailEffects () const
void	SpawnProjectileSound ()
void	SetCapsuleSize () const
void	SpawnImpactEffects (const FVector &Location) const
void	SpawnImpactSound (const FVector &Location) const
void	RagdollActor (AActor *Actor) const
void	AttachToHitActor (AActor *Actor, const FName &BoneName)

Private Attributes
float	DefaultDamage = 20.0f
FHitResult	StoredHitResult
FTimerHandle	ProjectileFTimerHandle
FTimerHandle	DelayTriggerTimerHandle

Constructor & Destructor Documentation

AProjectileBase()

AProjectileBase::AProjectileBase

(

)

{
    bReplicates = true;
    
    PrimaryActorTick.bCanEverTick = false;
    CapsuleComponent = CreateDefaultSubobject<UCapsuleComponent>("Capsule");
    CapsuleComponent->SetEnableGravity(false);
    FWalkableSlopeOverride WalkableSlopeOverride;
    WalkableSlopeOverride.WalkableSlopeBehavior = EWalkableSlopeBehavior::WalkableSlope_Unwalkable;
    CapsuleComponent->SetWalkableSlopeOverride(WalkableSlopeOverride);
    CapsuleComponent->CanCharacterStepUpOn = ECanBeCharacterBase::ECB_No;
    SetRootComponent(CapsuleComponent);
    
    StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>("Static Mesh");
    StaticMeshComponent->SetupAttachment(CapsuleComponent);
    StaticMeshComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
 
    TrailEffects = CreateDefaultSubobject<UNiagaraComponent>(TEXT("Trail Effects"));
    TrailEffects->SetupAttachment(StaticMeshComponent);
 
    ProjectileMovementComponent = CreateDefaultSubobject<UProjectileMovementComponent>("Projectile Movement");
    ProjectileMovementComponent->InitialSpeed = 1.0f;
    ProjectileMovementComponent->bRotationFollowsVelocity = true;
    ProjectileMovementComponent->OnProjectileStop.AddDynamic(this, &AProjectileBase::OnProjectileStop);
}

Member Function Documentation

AttachToHitActor()

void AProjectileBase::AttachToHitActor ( AActor * Actor, const FName & BoneName )

private

{
    if(Actor == nullptr){return;}
    ICharacterBaseInterface* CharacterHit = Cast<ICharacterBaseInterface>(Actor);
    if(CharacterHit != nullptr)
    {
        USkeletalMeshComponent* CharacterMesh = CharacterHit->GetCharacterMesh();
        if(CharacterMesh != nullptr)
        {
            AttachToComponent(CharacterMesh, FAttachmentTransformRules::KeepWorldTransform, BoneName);
        }
    }
    else
    {
        AttachToActor(Actor, FAttachmentTransformRules::KeepWorldTransform, BoneName);
    }
}

BeginPlay()

void AProjectileBase::BeginPlay ( )

overrideprotectedvirtual

Reimplemented in AHomingProjectile.

{
    Super::BeginPlay();
    if(ProjectileMovementComponent != nullptr)
    {
        ProjectileMovementComponent->InitialSpeed = ProjectileStats.InitialSpeed;
        ProjectileMovementComponent->Velocity = ProjectileMovementComponent->Velocity.GetSafeNormal() * ProjectileStats.InitialSpeed + ProjectileStats.Velocity;
        ProjectileMovementComponent->bRotationFollowsVelocity = ProjectileStats.bRotationFollowsVelocity;
        ProjectileMovementComponent->Bounciness = ProjectileStats.Bounciness;
        ProjectileMovementComponent->bShouldBounce = ProjectileStats.bShouldBounce;
        ProjectileMovementComponent->Friction = ProjectileStats.Friction;
        ProjectileMovementComponent->ProjectileGravityScale = ProjectileStats.GravityScale;
    }
    SpawnProjectileSound();
    SpawnTrailEffects();
    SetCapsuleSize();
    //@TODO have it on COnstruction 
    SetMesh(ProjectileStats.StaticMesh);
}

DelayTrigger()

void AProjectileBase::DelayTrigger ( )

virtual

{
    ProjectileStats.bDelayedTrigger = false;
    OnProjectileStop(StoredHitResult);
}

OnProjectileStop()

void AProjectileBase::OnProjectileStop ( const FHitResult & HitResult )

protectedvirtual

{
    if(!HasAuthority())
    {
        return;
    }
    if(ProjectileStats.bDelayedTrigger)
    {
        GetWorld()->GetTimerManager().SetTimer(DelayTriggerTimerHandle, this, &AProjectileBase::DelayTrigger, ProjectileStats.TriggerDelay, false);
        StoredHitResult = HitResult;
        return;
    }
    if(CapsuleComponent != nullptr){CapsuleComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);}
    // if
    if(HitResult.PhysMaterial.Get() != nullptr)
    {
        UE_LOG(LogWeaponSystem, Error, TEXT("Physical Material Hit"));
        UE_LOG(LogWeaponSystem, Error, TEXT("Physical Material: %s"), *HitResult.PhysMaterial.Get()->GetName());
    }
    if(ProjectileStats.bSticky)
    {
        AttachToHitActor(HitResult.GetActor(), HitResult.BoneName);
    }
 
    SpawnImpactEffects(HitResult.Location);
    SpawnImpactSound(HitResult.Location);
    
    TArray<AActor*> ActorsToIgnore;
    //- Should ignore Self  //
    if(ProjectileStats.bIgnoreOwner || ProjectileStats.DamageType == UBulletDamage::StaticClass() || ProjectileStats.DamageType == UElectricalDamage::StaticClass() || ProjectileStats.DamageType == UFireDamage::StaticClass())
    {
        ActorsToIgnore = DamageActorsToIgnore;
        DamageActorsToIgnore.Add(GetOwner());
    }
    // //- Should hit self  //
    if(ProjectileStats.DamageType == UExplosionDamage::StaticClass())
    {
        ActorsToIgnore.Empty();
    }
 
    const FVector TraceStart = HitResult.ImpactPoint;
    const FVector TraceEnd = TraceStart - FVector(1.0f,1.0f,1.0f);
    
    TArray<FHitResult> SphereHits;
    const bool bHit = UKismetSystemLibrary::SphereTraceMulti(
    this, TraceStart, TraceEnd,
                 ProjectileStats.DamageOuterRadius, UEngineTypes::ConvertToTraceType(ECC_GameTraceChannel4),
                 true, ActorsToIgnore, UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode),
                 SphereHits, true, FLinearColor::Red, FLinearColor::Yellow, 2.0f);
    if(ProjectileStats.bDealsImpulse)
    {
        if(HitResult.Component != nullptr)
        {
            if(HitResult.Component->IsSimulatingPhysics())
            {
                const FVector ProjectileVelocity = GetVelocity() * ProjectileStats.ImpulseMultiplier;
                const FVector ClampedVector = UKismetMathLibrary::ClampVectorSize(ProjectileVelocity, 0.0, ProjectileStats.ImpulseMax);
                HitResult.Component->AddImpulseAtLocation(ClampedVector, HitResult.Location, HitResult.BoneName);
            }
        }
        RagdollActor(HitResult.GetActor());
        if(bDebuggingMode)
        {
            DrawDebugSphere(GetWorld(), TraceStart, ProjectileStats.DamageInnerRadius, 4, FColor::Emerald, false, 2.0f);
        }
        TArray<AActor*> ActorsPushed;
        if(bHit)
        {
            for(FHitResult& SphereHit : SphereHits)
            {
                if(SphereHit.Component != nullptr)
                {
                    UPrimitiveComponent* PrimitiveComponent = Cast<UPrimitiveComponent>(SphereHit.Component);
                    if(PrimitiveComponent != nullptr)
                    {
                        if(ActorsPushed.Contains(SphereHit.GetActor())){continue;}
                        ERadialImpulseFalloff ImpulseFalloff = ERadialImpulseFalloff::RIF_Constant;
                        if(ProjectileStats.bImpulseFalloffLinear)
                        {
                            ImpulseFalloff = ERadialImpulseFalloff::RIF_Linear;
                        }
                        ACharacter* CharacterHit = Cast<ACharacter>(SphereHit.GetActor());
                        if(CharacterHit != nullptr)
                        {
                            const float ExplosionDistance = UKismetMathLibrary::Vector_Distance(HitResult.ImpactPoint,CharacterHit->GetActorLocation());
                            const float ExplosionClamped = UKismetMathLibrary::MapRangeClamped(ExplosionDistance, 0.0f, ProjectileStats.CharacterExplosionClampMax, ProjectileStats.CharacterExplosionClampMaxOutput, ProjectileStats.CharacterExplosionClampMinOutput);
                            FRotator LookAtRotation = UKismetMathLibrary::FindLookAtRotation(HitResult.ImpactPoint, SphereHit.GetActor()->GetActorLocation());
                            const FVector LaunchVelocity = LookAtRotation.Vector() * ProjectileStats.RadialForceStrength * ExplosionClamped;
                            CharacterHit->LaunchCharacter(LaunchVelocity, true, true);
                            PrimitiveComponent->AddRadialForce(HitResult.ImpactPoint, ProjectileStats.DamageOuterRadius, ProjectileStats.RadialForceStrength, ImpulseFalloff, true);                        
                        }
                        else
                        {
                            PrimitiveComponent->AddRadialForce(HitResult.ImpactPoint, ProjectileStats.DamageOuterRadius, ProjectileStats.RadialForceStrength, ImpulseFalloff, true);
                        }
                        ActorsPushed.AddUnique(SphereHit.GetActor());
                    }
                }
            }
        }
    }
    if(bDebuggingMode){UE_LOG(LogWeaponSystem,Warning,TEXT("Projectile Stop"));}
    if(ProjectileStats.bDealsDamage)
    {
        UGameplayStatics::ApplyRadialDamageWithFalloff(this, DefaultDamage, 1.0f, HitResult.ImpactPoint, ProjectileStats.DamageInnerRadius, ProjectileStats.DamageOuterRadius, ProjectileStats.DamageFalloff, ProjectileStats.DamageType, ActorsToIgnore, this, InstigatorController);
    }
    if(ProjectileStats.bHideMeshOnHit && StaticMeshComponent != nullptr)
    {
        StaticMeshComponent->SetHiddenInGame(true);
        StaticMeshComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    }
    if(TrailEffects != nullptr)
    {
        TrailEffects->DestroyComponent();
    }
    if(ProjectileSound != nullptr)
    {
        ProjectileSound->Stop();
        ProjectileSound->DestroyComponent();
    }
    if(ProjectileStats.bDestroyAfterHit)
    {
        GetWorld()->GetTimerManager().SetTimer(ProjectileFTimerHandle,this,  &AProjectileBase::ProjectileDestroy, ProjectileStats.DestroyDelay, false);
    }
}

ProjectileDestroy()

void AProjectileBase::ProjectileDestroy ( )

protectedvirtual

{
    if(bDebuggingMode){UE_LOG(LogWeaponSystem,Warning,TEXT("Projectile Destory"));}
    GetWorld()->GetTimerManager().ClearTimer(ProjectileFTimerHandle);
    Destroy();
}

RagdollActor()

void AProjectileBase::RagdollActor ( AActor * Actor ) const

private

{
    if(Actor == nullptr){return;}
    ICharacterBaseInterface* CharacterHit = Cast<ICharacterBaseInterface>(Actor);
    if(CharacterHit != nullptr)
    {
        CharacterHit->Ragdoll();
    }
}

SetActorsToIgnore()

void AProjectileBase::SetActorsToIgnore ( const TArray< AActor * > & ActorsToIgnore )

overridevirtual

Implements IProjectile.

{
    DamageActorsToIgnore.Append(ActorsToIgnore);
}

SetCapsuleSize()

void AProjectileBase::SetCapsuleSize ( ) const

private

{
    if(CapsuleComponent == nullptr){return;}
    CapsuleComponent->SetCapsuleRadius(ProjectileStats.CapsuleRadius);
    CapsuleComponent->SetCapsuleHalfHeight(ProjectileStats.CapsuleHalfHeight);
}

SetDebuggingMode()

void AProjectileBase::SetDebuggingMode ( const bool bValue )

overridevirtual

Implements IProjectile.

{
    bDebuggingMode = bValue;
}

SetDefaultDamage()

void AProjectileBase::SetDefaultDamage ( const float Damage )

overridevirtual

Implements IProjectile.

{
    DefaultDamage = Damage;
}

SetInstigator()

void AProjectileBase::SetInstigator ( AController * Controller )

overridevirtual

Implements IProjectile.

{
    InstigatorController = Controller;
}

SetMesh()

void AProjectileBase::SetMesh

(

UStaticMesh *

StaticMesh

)

const

{
    if(StaticMeshComponent != nullptr && StaticMesh != nullptr)
    {
        StaticMeshComponent->SetStaticMesh(StaticMesh);
        StaticMeshComponent->AddRelativeRotation(ProjectileStats.RotationOffset);
    }
}

SetProjectileStats()

void AProjectileBase::SetProjectileStats ( const struct FWeaponProjectileStats_T & Stats )

overridevirtual

Implements IProjectile.

{
    ProjectileStats = Stats;
}

SpawnImpactEffects()

void AProjectileBase::SpawnImpactEffects ( const FVector & Location ) const

private

{
    if(ProjectileStats.ImpactEffects == nullptr){return;}
    UNiagaraFunctionLibrary::SpawnSystemAtLocation(this, ProjectileStats.ImpactEffects, Location);
}

SpawnImpactSound()

void AProjectileBase::SpawnImpactSound ( const FVector & Location ) const

private

{
    if(ProjectileStats.ImpactSound == nullptr){return;}
    UGameplayStatics::SpawnSoundAtLocation(this, ProjectileStats.ImpactSound, Location);
}

SpawnProjectileSound()

void AProjectileBase::SpawnProjectileSound ( )

private

{
    if(StaticMeshComponent != nullptr && ProjectileStats.ProjectileSound != nullptr)
    {
        ProjectileSound = UGameplayStatics::SpawnSoundAttached(ProjectileStats.ProjectileSound, StaticMeshComponent);
    }
}

SpawnTrailEffects()

void AProjectileBase::SpawnTrailEffects ( ) const

private

{
    if(ProjectileStats.TrailEffects == nullptr)
    {
        TrailEffects->DestroyComponent();
        return;
    }
    TrailEffects->SetAsset(ProjectileStats.TrailEffects);   
}

Member Data Documentation

bDebuggingMode

bool AProjectileBase::bDebuggingMode = false

CapsuleComponent

class UCapsuleComponent* AProjectileBase::CapsuleComponent

protected

DamageActorsToIgnore

TArray<AActor*> AProjectileBase::DamageActorsToIgnore

protected

DefaultDamage

float AProjectileBase::DefaultDamage = 20.0f

private

DelayTriggerTimerHandle

FTimerHandle AProjectileBase::DelayTriggerTimerHandle

private

DestructionField

TSubclassOf<AActor> AProjectileBase::DestructionField

protected

ExplosionEffects

class UNiagaraSystem* AProjectileBase::ExplosionEffects

protected

HomingTarget

USceneComponent* AProjectileBase::HomingTarget

protected

InstigatorController

AController* AProjectileBase::InstigatorController

protected

ProjectileFTimerHandle

FTimerHandle AProjectileBase::ProjectileFTimerHandle

private

ProjectileMovementComponent

class UProjectileMovementComponent* AProjectileBase::ProjectileMovementComponent

protected

ProjectileSound

UAudioComponent* AProjectileBase::ProjectileSound = nullptr

protected

ProjectileStats

struct FWeaponProjectileStats_T AProjectileBase::ProjectileStats

protected

StaticMeshComponent

class UStaticMeshComponent* AProjectileBase::StaticMeshComponent

protected

StoredHitResult

FHitResult AProjectileBase::StoredHitResult

private

TrailEffects

UNiagaraComponent* AProjectileBase::TrailEffects

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/WeaponSystem/Source/WeaponSystem/Public/Projectiles/ProjectileBase.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/WeaponSystem/Source/WeaponSystem/Private/Projectiles/ProjectileBase.cpp