#include <HitscanWeaponFramework.h>

Inheritance diagram for AHitscanWeaponFramework:

Public Member Functions
	AHitscanWeaponFramework ()

virtual void	ServerShoot_Implementation () override

virtual bool	ServerShoot_Validate () override

Public Member Functions inherited from AWeaponFramework
	AWeaponFramework ()

Protected Member Functions
virtual bool	LineTrace (FHitResult &Hit, FVector &ShotDirection, const FLinearColor &Color=FLinearColor::Green, const FVector &CustomLineEnd=FVector::ZeroVector) const override

virtual FHitResult	BlindFireWeaponTrace (const float Accuracy, const AActor *ActorToIgnore=nullptr) override

virtual float	CalculateDistanceDamage (const float Distance) const override

Protected Member Functions inherited from AWeaponFramework
virtual void	BeginPlay () override

virtual void	SetupWeaponEffects ()

void	LogDebugMessage (const FString &Message, const bool bError=false) const

void	Server_InitWeapon ()

virtual void	InitWeapon () override

virtual void	Fire (const FVector Location, const FRotator Rotation, const AActor *ActorToIgnore, const float Accuracy) override

virtual void	Reload (const float ReloadTime) override

virtual void	CancelReload () override

virtual void	SwitchAutoMode () override

virtual void	BlindFireWeapon (const FVector Location, const FRotator Rotation, const AActor *ActorToIgnore, const float Accuracy) override

virtual void	AddAttachment (const FString &AttachmentID) override

virtual void	ToggleAttachment (const EAttachmentType &AttachmentType) override

virtual void	MoveUMG (bool bIsRightShoulder) override

virtual void	Aiming (bool bIsAiming) override

virtual FWeaponData_T	GetWeaponData () const override

virtual FWeaponStats_T	GetWeaponStats () const override

virtual EWeaponType	GetWeaponType () const override

virtual EWeaponFireMode	GetFireMode () const override

virtual FTransform	GetPivotPoint () const override

virtual FTransform	GetAimDownSightSocket () const override

virtual float	GetWeaponFOV () const override

virtual bool	IsClipEmpty () const override

virtual void	SetWeaponData (const FWeaponData_T NewWeaponData) override

virtual void	SetWeaponShouldAutoReload (const bool bValue) override

virtual void	SetWeaponMesh (USkeletalMesh *SkeletalMesh) override

virtual void	SetMuzzleOffset (const FVector &Location, const FRotator &Rotation) override

virtual void	SetRecoilPivotPoint (const FVector &Location, const FRotator &Rotation) override

virtual void	SetWeaponMeshHidden (const bool bValue) override

void	Multicast_SetWeaponMeshHidden (const bool bValue)

virtual void	SetDebuggingStats (const bool bDebug, const bool bInfinite, const bool bBottomless) override

virtual void	ToggleLaser (const bool bForceOff=false)

void	ReceiveFire (FHitResult Hit, APawn *InstigatorPawn)

TArray< FWeaponModifiers >	GetAllWeaponAttachmentModifiers () const

TArray< FWeaponAttachment >	GetAllWeaponAttachments () const

FWeaponAttachment	GetWeaponAttachment (const FString &AttachmentID) const

bool	RemoveAttachment (const FString AttachmentID, const EAttachmentType AttachmentType)

void	RemoveAllAttachments ()

bool	CanShoot () const

float	GetAccuracyMultiplier () const

void	ApplyDamageToActor (const FHitResult &Hit, FVector ShotDirection, float Multiplier=1.0f)

void	ServerFire (const FVector Location, const FRotator Rotation, const AActor *ActorToIgnore, const float Accuracy)

virtual void	ServerShoot ()

void	ServerSetReloading (const bool bReloading)

void	ServerReload ()

virtual void	Server_SetWeaponShouldAutoReload (const bool bValue)

void	CalculateBulletSpread (FVector &NewBulletSpread) const

void	OnMeshReplicated ()

void	OnRep_WeaponStats ()

Additional Inherited Members
Public Attributes inherited from AWeaponFramework
bool	bDebuggingMode = false

bool	bInfiniteAmmo = false

bool	bBottomlessClip = false

float	DrawDebugTime = 2.0f

float	DrawDebugColorDarkMultiplier = 0.1f

float	DrawDebugColorLightMultiplier = 2.0f

float	DrawDebugPointSize = 16.0f

FLinearColor	MainTraceColor = FLinearColor(0.9f, 0.1f, 0.1f)

FLinearColor	BlindFireTraceColor = FLinearColor(0.1f, 0.9f, 0.1f)

bool	bTraceComplex = false

bool	bReturnPhysicalMaterial = false

float	TraceDistanceTooClose = 0.075f

Protected Attributes inherited from AWeaponFramework
UHitscanWeaponComponent *	HitscanWeaponComponent

UProjectileWeaponComponent *	ProjectileWeaponComponent

FVector	TraceLocation

FRotator	TraceRotation

const AActor *	TraceActorToIgnore

TArray< AActor * >	ActorsToIgnore

APawn *	OwnerPawn

FWeaponData_T	WeaponData

EWeaponType	WeaponType = EWeaponType::Default

USceneComponent *	SceneRoot

USkeletalMeshComponent *	GunMeshComponent

USceneComponent *	Muzzle

USceneComponent *	RecoilPivotPoint

TArray< UStaticMeshComponent * >	AttachmentComponents

class UWeaponEffectsComponent *	WeaponEffects

USkeletalMesh *	WeaponMesh

TSubclassOf< class AActor >	ProjectileClass

Detailed Description

This class represents a hitscan weapon in the weapon system. It is a subclass of AWeaponFramework.

See also: HitscanWeaponFramework; AWeaponFramework

Constructor & Destructor Documentation

◆ AHitscanWeaponFramework()

AHitscanWeaponFramework::AHitscanWeaponFramework ( )

{
    WeaponType = EWeaponType::HitScan;
}

Member Function Documentation

◆ BlindFireWeaponTrace()

FHitResult AHitscanWeaponFramework::BlindFireWeaponTrace	(	const float	Accuracy,
		const AActor *	ActorToIgnore = nullptr )

overrideprotectedvirtual

Reimplemented from AWeaponFramework.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_HitScan);
    TRACE_CPUPROFILER_EVENT_SCOPE(AHitscanWeaponFramework::BlindFireWeaponTrace);
    //- Linetrace but from the MuzzleLocation //
    //- V2 has the LineEnd calculated from the Muzzle Location  // 
    TraceLocation = Muzzle->GetComponentLocation();
    FHitResult BlindFireHit;
    FVector ShotDirection;
    LineTrace(BlindFireHit, ShotDirection, BlindFireTraceColor);
    //-             Apply Damage             //
    if(BlindFireHit.GetActor() != nullptr)
    {
        ApplyDamageToActor(BlindFireHit, ShotDirection, CalculateDistanceDamage(BlindFireHit.Distance));
    }
    return BlindFireHit;
}

◆ CalculateDistanceDamage()

float AHitscanWeaponFramework::CalculateDistanceDamage ( const float Distance ) const

overrideprotectedvirtual

Reimplemented from AWeaponFramework.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_HitScan);
    TRACE_CPUPROFILER_EVENT_SCOPE(AHitscanWeaponFramework::CalculateDistanceDamage);
    const float MaxDamageMultiplier = GetWeaponStats().MaxDamageMultiplier;
    const float MinDamageMultiplier = GetWeaponStats().MinDamageMultiplier;
    const float WeaponRangeMin = GetWeaponStats().WeaponRangeMin;
    const float WeaponRangeMax = GetWeaponStats().WeaponRangeMax;
    //- Full damage up to WeaponRangeMin
    if (Distance <= WeaponRangeMin)
    {
        LogDebugMessage(FString::Printf(TEXT("Weapon Distance %.2f Multiplier: %.2f (BELOW MIN DISTANCE = MAX Multiplier)"), Distance, MaxDamageMultiplier));
        return MaxDamageMultiplier;
    }
    //- Damage decreases linearly between WeaponRangeMin and WeaponRangeMax
    if (Distance <= WeaponRangeMax)
    {
        const float Alpha = (Distance - WeaponRangeMin) / (WeaponRangeMax - WeaponRangeMin);
        LogDebugMessage(FString::Printf(TEXT("Weapon Distance %.2f Multiplier: %.2f (IN BETWEEN DISTANCE)"), Distance, FMath::Lerp(MaxDamageMultiplier, MinDamageMultiplier, Alpha)));
        return FMath::Lerp(MaxDamageMultiplier, MinDamageMultiplier, Alpha);
    }
    //- Constant minimum damage beyond WeaponRangeMax
    LogDebugMessage(FString::Printf(TEXT("Weapon Distance %.2f Multiplier: %.2f (FATHER THAN MAX DISTANCE = MIN MULTIPLIER)"), Distance, MinDamageMultiplier));
    return MinDamageMultiplier;
}

◆ LineTrace()

bool AHitscanWeaponFramework::LineTrace	(	FHitResult &	Hit,
		FVector &	ShotDirection,
		const FLinearColor &	Color = FLinearColor::Green,
		const FVector &	CustomLineEnd = FVector::ZeroVector ) const

overrideprotectedvirtual

Reimplemented from AWeaponFramework.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::LineTrace);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    const FVector ForwardVector = (FRotationMatrix(TraceRotation).GetScaledAxis( EAxis::X ));
    FVector BulletSpread;
    CalculateBulletSpread(BulletSpread);
    ShotDirection = -TraceRotation.Vector();
    const FVector LineEnd = ((ForwardVector * GetWeaponStats().GunRange) + TraceLocation) + BulletSpread;
 
    ECollisionChannel CollisionChannel = UEngineTypes::ConvertToCollisionChannel(UEngineTypes::ConvertToTraceType(ECC_GameTraceChannel4));
    static const FName LineTraceSingleName(TEXT("LineTraceSingle"));
    FCollisionQueryParams Params;// = ConfigureCollisionParams(LineTraceSingleName, bTraceComplex, ActorsToIgnore, bIgnoreSelf, WorldContextObject);
    // Params.bDebugQuery
    Params.bTraceComplex = bTraceComplex;
    Params.bReturnPhysicalMaterial = bReturnPhysicalMaterial;
    bool const bHit = GetWorld() ? GetWorld()->LineTraceSingleByChannel(Hit, TraceLocation, LineEnd, CollisionChannel, Params) : false;
    
    if(UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode) != EDrawDebugTrace::None)
    {
        const bool bPersistent = UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode) == EDrawDebugTrace::Persistent;
        const float LifeTime = (UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode) == EDrawDebugTrace::ForDuration) ? DrawDebugTime : 0.f;
 
        if (bHit && Hit.bBlockingHit)
        {
            const FLinearColor DarkerColor = FLinearColor(Color.R * DrawDebugColorDarkMultiplier, Color.G * DrawDebugColorDarkMultiplier, Color.B * DrawDebugColorDarkMultiplier, Color.A);
            const FLinearColor LighterColor = FLinearColor((Color.R + 0.1f) * DrawDebugColorLightMultiplier, (Color.G + 0.1f) * DrawDebugColorLightMultiplier, (Color.B + 0.1f) * DrawDebugColorLightMultiplier, Color.A);
            // Red up to the blocking hit, green thereafter
            DrawDebugLine(GetWorld(), TraceLocation, Hit.ImpactPoint, Color.ToFColor(true), bPersistent, LifeTime);
            DrawDebugLine(GetWorld(), Hit.ImpactPoint, LineEnd, LighterColor.ToFColor(true), bPersistent, LifeTime);
            DrawDebugPoint(GetWorld(), Hit.ImpactPoint, DrawDebugPointSize, DarkerColor.ToFColor(true), bPersistent, LifeTime);
        }
        else
        {
            // no hit means all red
            DrawDebugLine(GetWorld(), TraceLocation, LineEnd, Color.ToFColor(true), bPersistent, LifeTime);
        }
    }
    return bHit;
    // return GetWorld()->LineTraceSingleByChannel(
    //  );
    // return UKismetSystemLibrary::LineTraceSingle(
    //  this,
    //  TraceLocation,
    //  LineEnd,
    //  UEngineTypes::ConvertToTraceType(ECC_GameTraceChannel4),
    // bTraceComplex,
    //  ActorsToIgnore,
    //  UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode),
    //  Hit,
    //  true,
    // Color,   Color,
    // DrawDebugTime);
}

◆ ServerShoot_Implementation()

void AHitscanWeaponFramework::ServerShoot_Implementation ( )

overridevirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::ServerShoot_Implementation);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    ActorsToIgnore.Emplace(GetOwner());
    if(bBottomlessClip){WeaponData.CurrentAmmo++;}
    WeaponData.CurrentAmmo--;
    //- Bullet is only Decreased in fire Function   //
    if(GetWeaponStats().bMultiFire)
    {
        WeaponData.CurrentAmmo++;
    }
    if(!bBottomlessClip){LogDebugMessage(FString::Printf(TEXT("Current Ammo: %i"), WeaponData.CurrentAmmo));}
    
 
    //- Weapon Effects  //
    WeaponEffects->WeaponFireNoiseEvent(GetWeaponStats().bSilenced);
    WeaponEffects->MuzzleFlashEvent(GetWeaponStats().MuzzleFlashOffset);
 
 
    FHitResult Hit;
    FVector ShotDirection;
    bool bSuccess = LineTrace(Hit, ShotDirection, MainTraceColor);
 
    //- Defaults for Impact Effects
    FVector TracerEndPoint = Hit.TraceEnd;
    TArray<FVector> HitLocations;
 
    //- No Hit  //
    if(!bSuccess)
    {
        TracerEndPoint = Hit.TraceEnd;
        HitLocations.Add(Hit.TraceEnd);
        if(WeaponEffects != nullptr)
        {
            WeaponEffects->TracerEvent(HitLocations);
        }
        ReceiveFire(Hit, OwnerPawn);
        return;
    }
    
    //- Check how close the gun is to the hit location
    FVector MuzzleLocation = Muzzle->GetComponentLocation();
    FVector NormalVector = (MuzzleLocation - Hit.Location);
    NormalVector.Normalize(0.0001);
    FVector ForwardVector = (FRotationMatrix(TraceRotation).GetScaledAxis( EAxis::X ));
    float VectorDistance = UKismetMathLibrary::Dot_VectorVector(NormalVector,(ForwardVector * -1));
    if(VectorDistance < TraceDistanceTooClose) 
    {
        //- If the gun is too close to the Hit location
        //- eg. gun against the wall 
        FHitResult BlindFireHit = BlindFireWeaponTrace(GetAccuracyMultiplier());
        if(BlindFireHit.bBlockingHit)
        {
            HitLocations.Add(BlindFireHit.Location);
            ApplyDamageToActor(BlindFireHit, ShotDirection, CalculateDistanceDamage(BlindFireHit.Distance));
            ReceiveFire(BlindFireHit, OwnerPawn);
            if(WeaponEffects != nullptr)
            {
                WeaponEffects->ImpactEvent(BlindFireHit);
            }
            LogDebugMessage(FString::Printf(TEXT("Hit 1: X %f,Y: %f,Z: %f"), BlindFireHit.Location.X, BlindFireHit.Location.Y, BlindFireHit.Location.Z));
        }
        else
        {
            HitLocations.Add(BlindFireHit.TraceEnd);
            ApplyDamageToActor(BlindFireHit, ShotDirection, CalculateDistanceDamage(BlindFireHit.Distance));
            ReceiveFire(BlindFireHit, OwnerPawn);
            if(WeaponEffects != nullptr)
            {
                WeaponEffects->ImpactEvent(BlindFireHit);
            }
            LogDebugMessage(FString::Printf(TEXT("Hit 1.5: X %f,Y: %f,Z: %f"), BlindFireHit.TraceEnd.X, BlindFireHit.TraceEnd.Y, BlindFireHit.TraceEnd.Z));
        }
    }
    else
    {
        //- Check if Anything is between the player and where they should be shooting //
        //- i.e. can see someone around the corner but gun is pointed at the wall //
 
        //todo Change this to Linetrace Function, TraceLocation = Hit.Location
        // way to change just the end
        FHitResult HitCheck;
        ActorsToIgnore.Add(Hit.GetActor());
 
 
        //- LineTrace, Did we hit something 
        if(UKismetSystemLibrary::LineTraceSingle(this,
            Hit.Location,
            MuzzleLocation,
            UEngineTypes::ConvertToTraceType(ECC_GameTraceChannel4),
            bTraceComplex, ActorsToIgnore,
            //~ Debugging
            UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode), HitCheck,
            true, FLinearColor::Blue,
            FLinearColor::Blue, DrawDebugTime))
        {
            FHitResult BlindFireHit = BlindFireWeaponTrace(GetAccuracyMultiplier());
            if(BlindFireHit.bBlockingHit)
            {
                HitLocations.Add(BlindFireHit.Location);
                ApplyDamageToActor(BlindFireHit, ShotDirection, CalculateDistanceDamage(BlindFireHit.Distance));
                ReceiveFire(BlindFireHit, OwnerPawn);
                if(WeaponEffects != nullptr)
                {
                    WeaponEffects->ImpactEvent(BlindFireHit);
                }
                LogDebugMessage(FString::Printf(TEXT("Hit 2: X %f,Y: %f,Z: %f"), BlindFireHit.Location.X, BlindFireHit.Location.Y, BlindFireHit.Location.Z));
            }
            else
            {
                HitLocations.Add(BlindFireHit.TraceEnd);
                ApplyDamageToActor(BlindFireHit, ShotDirection, CalculateDistanceDamage(BlindFireHit.Distance));
                ReceiveFire(BlindFireHit, OwnerPawn);
                if(WeaponEffects != nullptr)
                {
                    WeaponEffects->ImpactEvent(BlindFireHit);
                }
                LogDebugMessage(FString::Printf(TEXT("Hit 2.5: X %f,Y: %f,Z: %f"), BlindFireHit.TraceEnd.X, BlindFireHit.TraceEnd.Y, BlindFireHit.TraceEnd.Z));
            }
        }
        else
        {
            //- Nothing in the way
            if(Hit.GetActor() != nullptr)
            {
                ApplyDamageToActor(Hit, ShotDirection, CalculateDistanceDamage(Hit.Distance));
                LogDebugMessage(FString::Printf(TEXT("Hit 3: X %f,Y: %f,Z: %f"), Hit.Location.X, Hit.Location.Y, Hit.Location.Z));
                HitLocations.Add(Hit.Location);
                ReceiveFire(Hit, OwnerPawn);
                if(WeaponEffects != nullptr)
                {
                    WeaponEffects->ImpactEvent(Hit);
                }
            }
        }
        //Remove as the var is kept
        ActorsToIgnore.Remove(Hit.GetActor());
    }
    WeaponEffects->TracerEvent(HitLocations);
    // EPhysicalSurface SurfaceType = SurfaceType_Default;
    // SurfaceType = UPhysicalMaterial::DetermineSurfaceType(Hit.PhysMaterial.Get());
 
    //- v1 Replication? 
    // if(HasAuthority())
    // {
    //  HitScanTrace.TraceTo = TracerEndPoint;
    //  // HitScanTrace.SurfaceType = SurfaceType;
    //  HitScanTrace.a++;
    //
    // }
    //todo temp
    // EPhysicalSurface SurfaceType = SurfaceType_Default;
    // SurfaceType = UPhysicalMaterial::DetermineSurfaceType(Hit.PhysMaterial.Get());
    //
    // PlayFireEffects(TracerEndPoint);
    // if(HasAuthority())
    // {
    //  HitScanTrace.TraceTo = TracerEndPoint;
    //  HitScanTrace.SurfaceType = SurfaceType;
    //  HitScanTrace.a++;
    // }
}

◆ ServerShoot_Validate()

bool AHitscanWeaponFramework::ServerShoot_Validate ( )

overridevirtual

{
    return Super::ServerShoot_Validate();
}

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

T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/WeaponSystem/Source/WeaponSystem/Public/Weapons/HitscanWeaponFramework.h
T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/WeaponSystem/Source/WeaponSystem/Private/Weapons/HitscanWeaponFramework.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AHitscanWeaponFramework()

Member Function Documentation

◆ BlindFireWeaponTrace()

◆ CalculateDistanceDamage()

◆ LineTrace()

◆ ServerShoot_Implementation()

◆ ServerShoot_Validate()