AWeaponFramework Class Reference

A weapon base class. More...

#include <WeaponFramework.h>

Inheritance diagram for AWeaponFramework:

Public Member Functions
	AWeaponFramework ()

Public Attributes
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 Member Functions
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
virtual float	CalculateDistanceDamage (const float Distance) const
virtual FHitResult	BlindFireWeaponTrace (const float Accuracy, const AActor *ActorToIgnore=nullptr)
virtual bool	LineTrace (FHitResult &Hit, FVector &ShotDirection, const FLinearColor &Color=FLinearColor::Green, const FVector &CustomLineEnd=FVector::ZeroVector) const
void	OnMeshReplicated ()
void	OnRep_WeaponStats ()

Protected Attributes
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

Private Member Functions
void	SetWeaponFireMode ()
void	AddWeaponAttachments ()
void	ShootHitScan ()
void	ShootProjectile ()

Private Attributes
FWeaponStats_T	CurrentWeaponStats
bool	bWeaponEffectsSetup = false
float	AccuracyMultiplier = 1.0f
bool	bLaserOn = false
bool	bIsBeingReloaded
FTimerHandle	ReloadTimerHandle

Detailed Description

A weapon base class.

This class represents a weapon in the game. It inherits from AActor, IWeapon, and IBaseInterface. It provides functionality for firing, reloading, switching fire mode, aiming, and other weapon-related actions.

See also

WeaponFramework

Constructor & Destructor Documentation

AWeaponFramework()

AWeaponFramework::AWeaponFramework

(

)

{
    PrimaryActorTick.bCanEverTick = false;
    bReplicates = true;
    
    SceneRoot = CreateDefaultSubobject<USceneComponent>(TEXT("Scene Root"));
    RootComponent = SceneRoot;
    GunMeshComponent = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Gun Mesh"));
    GunMeshComponent->SetupAttachment(SceneRoot);
    // RootComponent = GunMeshComponent;
    Muzzle = CreateDefaultSubobject<USceneComponent>(TEXT("Muzzle Location"));
    Muzzle->SetupAttachment(GunMeshComponent);
    RecoilPivotPoint = CreateDefaultSubobject<USceneComponent>(TEXT("Recoil Pivot Point"));
    RecoilPivotPoint->SetupAttachment(GunMeshComponent);
 
    WeaponEffects = CreateDefaultSubobject<UWeaponEffectsComponent>(TEXT("Weapon Effects"));
    HitscanWeaponComponent = CreateDefaultSubobject<UHitscanWeaponComponent>(TEXT("Hit Scan"));
    ProjectileWeaponComponent = CreateDefaultSubobject<UProjectileWeaponComponent>(TEXT("Projectiles"));
 
    ProjectileClass = UBaseHelpersBPLib::GetDefaultActorBPClass("/WeaponSystem/Weapons/Projectiles/BP_ProjectileBase");
}

Member Function Documentation

AddAttachment()

void AWeaponFramework::AddAttachment ( const FString & AttachmentID )

overrideprotectedvirtual

Attachments

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::AddAttachment);
    bool bSuccess = false;
    const FWeaponAttachment WeaponAttachment = UWeaponBPLib::GetWeaponAttachment(this, AttachmentID, bSuccess);
    if(!bSuccess){return;}
    if(!WeaponAttachment.IsValid()){return;}
    if(!GunMeshComponent->DoesSocketExist(WeaponAttachment.AttachmentTypeName())){return;}
    if(!GetWeaponStats().GetIsAttachmentCompatible(AttachmentID, WeaponAttachment.AttachmentType))
    {
        RemoveAttachment(AttachmentID, WeaponAttachment.AttachmentType);
        return;
    }
    UStaticMeshComponent* AttachmentComponent = NewObject<UStaticMeshComponent>(this);
    if(AttachmentComponent == nullptr){return;}
    AttachmentComponent->RegisterComponent(); 
    AttachmentComponent->SetStaticMesh(WeaponAttachment.StaticMesh);
    AttachmentComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    AttachmentComponent->AttachToComponent(GunMeshComponent, FAttachmentTransformRules::SnapToTargetIncludingScale, WeaponAttachment.AttachmentTypeName());
    AttachmentComponent->ComponentTags.Add(FName(WeaponAttachment.WeaponAttachmentID));
    AttachmentComponent->ComponentTags.Add(WeaponAttachment.AttachmentTypeName());
    AttachmentComponent->SetRelativeLocation(WeaponAttachment.AttachmentOffset);
    AttachmentComponent->SetRelativeRotation(WeaponAttachment.AttachmentRotationOffset);
    if(WeaponAttachment.bModifyMuzzleLocation && Muzzle != nullptr)
    {
        Muzzle->SetRelativeLocation(WeaponAttachment.MuzzleOffset);
    }
    WeaponData.AddAttachment(AttachmentID);
    ToggleAttachment(WeaponAttachment.AttachmentType);
    
    AttachmentComponents.Add(AttachmentComponent);
}

AddWeaponAttachments()

void AWeaponFramework::AddWeaponAttachments ( )

private

{
    // RemoveAllAttachments();
    for(const FString& WeaponAttachmentID : WeaponData.CurrentWeaponAttachments)
    {
        AddAttachment(WeaponAttachmentID);
    }
}

Aiming()

void AWeaponFramework::Aiming ( bool bIsAiming )

overrideprotectedvirtual

Implements IWeapon.

Reimplemented in AProjectileWeaponFramework.

{
    // LogDebugMessage("Aiming Function");
}

ApplyDamageToActor()

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

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::ApplyDamageToActor);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    LogDebugMessage(FString::Printf(TEXT("Damage Multipler %f"), Multiplier));
    //-     Multiplier should never be 0    //
    if(Multiplier <= 0.0f){Multiplier = 1.0f;}
    //? FVector TracerEndPoint = Hit.TraceEnd;
    //? EPhysicalSurface SurfaceType;
    //? int SurfaceIndex;
    //? FVector TracerEndPoint = Hit.ImpactPoint;
    //? PlayImpactEffects(SurfaceIndex, TracerEndPoint);
    
    if(Hit.GetActor() == nullptr){return;}
    //? Hit.ImpactNormal * -1; - not as Realistic, but it's more satisfying, i.e. you shoot a box, the force will come from the face it was hit
    ShotDirection *= -1;
    AController* EventInstigator = nullptr;
    if(TraceActorToIgnore != nullptr)
    {
        EventInstigator = TraceActorToIgnore->GetInstigatorController();
    }
    UGameplayStatics::ApplyPointDamage(Hit.GetActor(), (GetWeaponStats().DefaultDamage * Multiplier), ShotDirection, Hit, EventInstigator, this, GetWeaponStats().DamageType);
    WeaponEffects->WeaponDamageEvent(Hit.GetActor(),  GetWeaponStats().DefaultDamage, GetActorLocation(), Hit.Location, FName("WeaponDamage"));
}

BeginPlay()

void AWeaponFramework::BeginPlay ( )

overrideprotectedvirtual

Reimplemented in AProjectileWeaponFramework.

{
    Super::BeginPlay();
}

BlindFireWeapon()

void AWeaponFramework::BlindFireWeapon ( const FVector Location, const FRotator Rotation, const AActor * ActorToIgnore, const float Accuracy )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::BlindFireWeapon);
    //@ TODO This should call a different function, or set something, currently does the same as Fire? 
    Fire(Location, Rotation, ActorToIgnore, Accuracy);
}

BlindFireWeaponTrace()

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

protectedvirtual

Reimplemented in AHitscanWeaponFramework.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::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;
}

CalculateBulletSpread()

void AWeaponFramework::CalculateBulletSpread ( FVector & NewBulletSpread ) const

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::CalculateBulletSpread);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
 
    if(GetOwner() == nullptr){NewBulletSpread = FVector::ZeroVector; return;}
    float OwnerSpeed = GetOwner()->GetVelocity().Size();
    //- Still // 
    if(OwnerSpeed < 10)
    {
        //@ TODO Add these Number to WeaponData Struct
        //- If Full Auto Weapon is in Single Mode, Apply Bonus  //
        if(GetWeaponStats().bHasAutoMode && WeaponData.FireMode == EWeaponFireMode::Single) {OwnerSpeed = 0.65f;}
        //- if Auto Weapon is in Burst Mode //
        else if(GetWeaponStats().bHasAutoMode && WeaponData.FireMode == EWeaponFireMode::Burst) {OwnerSpeed = 0.85f;}
        //- If Burst Weapon is in single Apply Bonus    //
        else if(GetWeaponStats().bHasBurstMode && WeaponData.FireMode == EWeaponFireMode::Single){OwnerSpeed = 0.75f;}
        else{OwnerSpeed = 1.0f;}
    }
    //- Moving // 
    else
    {
        //- If Full Auto Weapon is in Single Mode, Apply Bonus  //
        if(GetWeaponStats().bHasAutoMode && WeaponData.FireMode == EWeaponFireMode::Single) {OwnerSpeed = 1.25f;}
        //- if Auto Weapon is in Burst Mode //
        else if(GetWeaponStats().bHasAutoMode && WeaponData.FireMode == EWeaponFireMode::Burst) {OwnerSpeed = 1.45f;}
        //- If Burst Weapon is in single Apply Bonus    //
        else if(GetWeaponStats().bHasBurstMode && WeaponData.FireMode == EWeaponFireMode::Single){OwnerSpeed = 1.35f;}
 
        else{OwnerSpeed = 1.75f;}
    }
    OwnerSpeed = (OwnerSpeed / AccuracyMultiplier);
 
    // - Random Variation to X and Y axis //
    const float Spread = GetWeaponStats().BulletSpread * OwnerSpeed; 
    const float BulletX = FMath::RandRange((Spread * -1), Spread);
    const float BulletY = FMath::RandRange((Spread * -1), Spread);
    const float BulletZ = FMath::RandRange((Spread * -1), Spread);
    NewBulletSpread = FVector(BulletX,BulletY,BulletZ);
}

CalculateDistanceDamage()

float AWeaponFramework::CalculateDistanceDamage ( const float Distance ) const

protectedvirtual

Reimplemented in AHitscanWeaponFramework.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::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;
    return 0.0f;
}

CancelReload()

void AWeaponFramework::CancelReload ( )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::CancelReload);
    ServerSetReloading(false);
}

CanShoot()

bool AWeaponFramework::CanShoot ( ) const

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::CanShoot);
    if(bIsBeingReloaded) return false;
    if(WeaponData.CurrentAmmo <= 0) return false; 
    return true; 
}

Fire()

void AWeaponFramework::Fire ( const FVector Location, const FRotator Rotation, const AActor * ActorToIgnore, const float Accuracy )

overrideprotectedvirtual

Shooting

Implements IWeapon.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::Fire);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
 
    if(!bWeaponEffectsSetup){SetupWeaponEffects();}
    if(OwnerPawn != nullptr && OwnerPawn->GetController() != nullptr)
    {
        APlayerController* OwnerController = Cast<APlayerController>(OwnerPawn->GetController());
        //- only camera shake and vibrate if we got ammo
        if(CanShoot() && OwnerController != nullptr && OwnerController->IsLocalController())
        {
            WeaponEffects->PlayFeedbackEffects(OwnerController, WeaponData.FireMode, Accuracy);
        }
    }
    ServerFire(Location, Rotation, ActorToIgnore, Accuracy);
}

GetAccuracyMultiplier()

float AWeaponFramework::GetAccuracyMultiplier ( ) const

inlineprotected

{return AccuracyMultiplier;};

GetAimDownSightSocket()

FTransform AWeaponFramework::GetAimDownSightSocket ( ) const

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::GetAimDownSightSocket);
    if(GunMeshComponent == nullptr){return FTransform(FVector(1));}
    if(GunMeshComponent->DoesSocketExist(FName("ADS_Socket")) == false){return FTransform(FVector(1));}
    return GunMeshComponent->GetSocketTransform(FName("ADS_Socket"));
}

GetAllWeaponAttachmentModifiers()

TArray< FWeaponModifiers > AWeaponFramework::GetAllWeaponAttachmentModifiers ( ) const

protected

Weapon Attachments

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::GetAllWeaponAttachmentModifiers);
    TArray<FWeaponModifiers> Modifiers;
    for(const auto& Attachment : GetAllWeaponAttachments())
    {
        Modifiers.Add(Attachment.WeaponStatModifiers);
    }
    return Modifiers;
}

GetAllWeaponAttachments()

TArray< FWeaponAttachment > AWeaponFramework::GetAllWeaponAttachments ( ) const

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::GetAllWeaponAttachments);
    TArray<FWeaponAttachment> Attachments;
    for(const FString& WeaponAttachmentID : WeaponData.CurrentWeaponAttachments)
    {
        Attachments.Add(GetWeaponAttachment(WeaponAttachmentID));
    }
    return Attachments;
}

GetFireMode()

virtual EWeaponFireMode AWeaponFramework::GetFireMode ( ) const

inlineoverrideprotectedvirtual

Implements IWeapon.

{return WeaponData.FireMode;};

GetPivotPoint()

virtual FTransform AWeaponFramework::GetPivotPoint ( ) const

inlineoverrideprotectedvirtual

Implements IWeapon.

{return RecoilPivotPoint->GetRelativeTransform();};

GetWeaponAttachment()

FWeaponAttachment AWeaponFramework::GetWeaponAttachment ( const FString & AttachmentID ) const

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::GetWeaponAttachment);
    bool bSuccess = false;
    FWeaponAttachment WeaponAttachment = UWeaponBPLib::GetWeaponAttachment(this, AttachmentID, bSuccess);
    if(bSuccess)
    {
        return WeaponAttachment;
    }
    return FWeaponAttachment::Empty();
}

GetWeaponData()

virtual FWeaponData_T AWeaponFramework::GetWeaponData ( ) const

inlineoverrideprotectedvirtual

Get Weapon infos

Implements IWeapon.

{return WeaponData;};

GetWeaponFOV()

float AWeaponFramework::GetWeaponFOV ( ) const

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::GetWeaponFOV);
    const FWeaponStats_T WeaponStats = GetWeaponStats();
    if(WeaponStats.IsValid() == false){return 0.0f;}
    return WeaponStats.FOV;
}

GetWeaponStats()

FWeaponStats_T AWeaponFramework::GetWeaponStats ( ) const

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::GetWeaponStats);
    FWeaponStats_T WeaponStats;
    if(CurrentWeaponStats.IsValid() == false)
    {
        bool bSuccess = false;
        WeaponStats = UWeaponBPLib::GetWeaponStats(this, WeaponData.WeaponID, bSuccess);
        if(!bSuccess){LogDebugMessage("AWeaponFramework::GetWeaponStats WeaponStats", true);}
    }
    else
    {
        WeaponStats = CurrentWeaponStats;
    }
    WeaponStats = WeaponStats.AddModifiers(GetAllWeaponAttachmentModifiers());
    return WeaponStats;
}

GetWeaponType()

virtual EWeaponType AWeaponFramework::GetWeaponType ( ) const

inlineoverrideprotectedvirtual

Implements IWeapon.

{return WeaponType;};

InitWeapon()

void AWeaponFramework::InitWeapon ( )

overrideprotectedvirtual

Implements IWeapon.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::InitWeapon);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    if(HasAuthority())
    {
        bool bSuccess = false;
        CurrentWeaponStats = UWeaponBPLib::GetWeaponStats(this, WeaponData.WeaponID, bSuccess);
        if(!bSuccess){LogDebugMessage("AWeaponFramework::InitWeapon CurrentWeaponStats", true);}
        SetWeaponFireMode();
        AddWeaponAttachments();
        SetupWeaponEffects();
        ActorsToIgnore.Emplace(this);
        ActorsToIgnore.Emplace(GetOwner());
        if(GunMeshComponent != nullptr)
        {
            GunMeshComponent->SetRelativeRotation(CurrentWeaponStats.RotationOffset);
            GunMeshComponent->SetRelativeLocation(CurrentWeaponStats.WeaponOffset);     
            LogDebugMessage(FString::Printf(TEXT("InitWeapon Set Relative LocatioN: %s"), *CurrentWeaponStats.RotationOffset.ToString()));
        }
        OnRep_WeaponStats();
    }
    Server_InitWeapon();
}

IsClipEmpty()

virtual bool AWeaponFramework::IsClipEmpty ( ) const

inlineoverrideprotectedvirtual

Implements IWeapon.

{return WeaponData.CurrentAmmo <= 0;};

LineTrace()

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

protectedvirtual

Reimplemented in AHitscanWeaponFramework.

{
    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;
 
    const 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;
    Params.AddIgnoredActor(OwnerPawn);
    Params.AddIgnoredActor(GetOwner());
    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 false;
}

LogDebugMessage()

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

protected

{
    if(bDebuggingMode == false){return;}
    const FString FullMessage = FString::Printf(TEXT(" %s  - in %s of %s"), ToCStr(Message), ToCStr(GetName()), GetOwner() ? ToCStr(GetOwner()->GetName()) : ToCStr("Invalid Owner"));
    UBaseHelpersBPLib::PrintToLogWithCategory(GetWorld(), LogWeaponFramework, FullMessage, true, bError);
}

MoveUMG()

void AWeaponFramework::MoveUMG ( bool bIsRightShoulder )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::MoveUMG);
}

Multicast_SetWeaponMeshHidden()

void AWeaponFramework::Multicast_SetWeaponMeshHidden ( const bool bValue )

protected

OnMeshReplicated()

void AWeaponFramework::OnMeshReplicated ( )

protected

{
    GunMeshComponent->SetSkeletalMesh(WeaponMesh);
}

OnRep_WeaponStats()

void AWeaponFramework::OnRep_WeaponStats ( )

protected

{
    if(GunMeshComponent != nullptr)
    {
        GunMeshComponent->SetRelativeRotation(CurrentWeaponStats.RotationOffset);
        GunMeshComponent->SetRelativeLocation(CurrentWeaponStats.WeaponOffset);     
        LogDebugMessage(FString::Printf(TEXT("OnRep Set Relative LocatioN: %s"), *CurrentWeaponStats.RotationOffset.ToString()));
    }
}

ReceiveFire()

void AWeaponFramework::ReceiveFire ( FHitResult Hit, APawn * InstigatorPawn )

protected

Reload()

void AWeaponFramework::Reload ( const float ReloadTime )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::Reload);
 
    if(!GetWeaponStats().IsValid()){return;}
    if(WeaponData.CurrentAmmo >= GetWeaponStats().ClipSize){return;}
    if(WeaponData.TotalAmmoCount <= 0){return;}
    if(bIsBeingReloaded){return;}
    ServerSetReloading(true);
    GetWorldTimerManager().SetTimer(ReloadTimerHandle, this, &AWeaponFramework::ServerReload, ReloadTime, false);
}

RemoveAllAttachments()

void AWeaponFramework::RemoveAllAttachments ( )

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::RemoveAllAttachments);
    for(UStaticMeshComponent* Component : AttachmentComponents)
    {
        if(Component != nullptr && Component->IsValidLowLevel())
        {
            Component->DestroyComponent();
        }
    }
}

RemoveAttachment()

bool AWeaponFramework::RemoveAttachment ( const FString AttachmentID, const EAttachmentType AttachmentType )

protected

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::RemoveAttachment);
    if(AttachmentType == EAttachmentType::Laser)
    {
        ToggleLaser(true);
    }
    for(UStaticMeshComponent* Component : AttachmentComponents)
    {
        for(const FName& NameTag : Component->ComponentTags)
        {
            if(NameTag == FName(AttachmentID))
            {
                if(Component != nullptr && Component->IsValidLowLevel())
                {
                    LogDebugMessage(FString::Printf(TEXT("Attachemnt %s Destroyed"), *AttachmentID));
                    Component->DestroyComponent();
                }
                WeaponData.CurrentWeaponAttachments.Remove(AttachmentID);
                return true;
            }
        }
    }
    return false;
}

Server_InitWeapon()

void AWeaponFramework::Server_InitWeapon ( )

protected

Server_SetWeaponShouldAutoReload()

virtual void AWeaponFramework::Server_SetWeaponShouldAutoReload ( const bool bValue )

protectedvirtual

ServerFire()

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

protected

ServerReload()

void AWeaponFramework::ServerReload ( )

protected

ServerSetReloading()

void AWeaponFramework::ServerSetReloading ( const bool bReloading )

protected

ServerShoot()

virtual void AWeaponFramework::ServerShoot ( )

protectedvirtual

Reimplemented in AMeleeWeaponFramework, and AProjectileWeaponFramework.

SetDebuggingStats()

virtual void AWeaponFramework::SetDebuggingStats ( const bool bDebug, const bool bInfinite, const bool bBottomless )

inlineoverrideprotectedvirtual

Implements IWeapon.

{bDebuggingMode = bDebug; bInfiniteAmmo = bInfinite, bBottomlessClip = bBottomless;};

SetMuzzleOffset()

void AWeaponFramework::SetMuzzleOffset ( const FVector & Location, const FRotator & Rotation )

overrideprotectedvirtual

Implements IWeapon.

{
    Muzzle->SetRelativeLocation(Location);
    Muzzle->SetRelativeRotation(Rotation);
}

SetRecoilPivotPoint()

void AWeaponFramework::SetRecoilPivotPoint ( const FVector & Location, const FRotator & Rotation )

overrideprotectedvirtual

Implements IWeapon.

{
    RecoilPivotPoint->SetRelativeLocation(Location);
    RecoilPivotPoint->SetRelativeRotation(Rotation);
}

SetupWeaponEffects()

void AWeaponFramework::SetupWeaponEffects ( )

protectedvirtual

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::SetupWeaponEffects);
    OwnerPawn = Cast<APawn>(GetOwner());
    if(OwnerPawn == nullptr){LogDebugMessage("OwnerPawn SetupWeaponEffects", true);return;}
    bWeaponEffectsSetup = WeaponEffects->SetupEffectsComponent(OwnerPawn, Muzzle, GetWeaponStats().WeaponEffectsID);
    // if(bWeaponEffectsSetup)
    // {
    //  WeaponEffects->GetWeaponEffectsFromID(WeaponData.WeaponID);
    // }
}

SetWeaponData()

virtual void AWeaponFramework::SetWeaponData ( const FWeaponData_T NewWeaponData )

inlineoverrideprotectedvirtual

Implements IWeapon.

{WeaponData = NewWeaponData;};

SetWeaponFireMode()

void AWeaponFramework::SetWeaponFireMode ( )

private

{
    WeaponData.FireMode = EWeaponFireMode::Single;
    // - Automatic Weapons will always start in Auto Mode   //
    if(GetWeaponStats().bHasAutoMode)
    {
        WeaponData.FireMode = EWeaponFireMode::FullAuto;
    }
    else if(GetWeaponStats().bHasBurstMode)
    {
        WeaponData.FireMode = EWeaponFireMode::Burst;
    }
}

SetWeaponMesh()

void AWeaponFramework::SetWeaponMesh ( USkeletalMesh * SkeletalMesh )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::SetWeaponMesh_Implementation);
    if(SkeletalMesh == nullptr){LogDebugMessage("SetWeaponMesh Null Mesh");return;}
    WeaponMesh = SkeletalMesh;
    OnMeshReplicated();
    GunMeshComponent->SetSkeletalMesh(SkeletalMesh);
}

SetWeaponMeshHidden()

void AWeaponFramework::SetWeaponMeshHidden ( const bool bValue )

overrideprotectedvirtual

Sets the Guns Mesh to be Hidden in Game, Used for Turrets and Ships, Things with invisible Weapons

Implements IWeapon.

{
    if(GunMeshComponent != nullptr)
    {
        GunMeshComponent->SetHiddenInGame(bValue, true);
    }
    Multicast_SetWeaponMeshHidden(bValue);
}

SetWeaponShouldAutoReload()

void AWeaponFramework::SetWeaponShouldAutoReload ( const bool bValue )

overrideprotectedvirtual

Implements IWeapon.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::SetWeaponShouldAutoReload);
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    Server_SetWeaponShouldAutoReload(bValue);
}

ShootHitScan()

void AWeaponFramework::ShootHitScan ( )

private

{
    // if(HitscanWeaponComponent !=  nullptr)
    // {
    //  if(bBottomlessClip){WeaponData.CurrentAmmo++;}
    //  WeaponData.CurrentAmmo--;
    //  HitscanWeaponComponent->SetMuzzle(Muzzle);
    //  FHitResult Hit = HitscanWeaponComponent->ServerShoot();
    //  FVector TracerEndPoint = Hit.TraceEnd;
    //  TArray<FVector> HitLocations;
    // }
    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);
}

ShootProjectile()

void AWeaponFramework::ShootProjectile ( )

private

{
    if(!CanShoot()) {return;}
    if(GetWeaponStats().IsValid() == false){return;}
    if(HasAuthority())
    {
        ActorsToIgnore.Emplace(GetOwner());
        if(bBottomlessClip){WeaponData.CurrentAmmo++;}
        WeaponData.CurrentAmmo--;
        const FVector MuzzleLocation = Muzzle->GetComponentLocation();
        const FActorSpawnParameters SpawnParameters;
        const FTransform SpawnTransform = FTransform(TraceRotation + GetWeaponStats().ProjectileRotationOffset, MuzzleLocation, FVector(1));
        AActor* SpawnedProjectile = UGameplayStatics::BeginDeferredActorSpawnFromClass(this, ProjectileClass, SpawnTransform, ESpawnActorCollisionHandlingMethod::AlwaysSpawn, this);
        if(SpawnedProjectile == nullptr){UE_LOG(LogWeaponSystem, Warning,TEXT("Spawn Projectile failed in Projectile Weapon"));return;}
        IProjectile* Projectile = Cast<IProjectile>(SpawnedProjectile);
        if(Projectile == nullptr){UE_LOG(LogWeaponSystem, Warning,TEXT("Projectile cast failed in Projectile Weapon"));return;}
        Projectile->SetProjectileStats(GetWeaponStats().WeaponProjectileStats);
        Projectile->SetDefaultDamage(GetWeaponStats().DefaultDamage);
        Projectile->SetActorsToIgnore(ActorsToIgnore);
        Projectile->SetDebuggingMode(bDebuggingMode);
        AController* EventInstigator = nullptr;
        if(TraceActorToIgnore != nullptr)
        {
            EventInstigator = TraceActorToIgnore->GetInstigatorController();
        }
        Projectile->SetInstigator(EventInstigator);
        if(GetOwner() != nullptr)
        {
            SpawnedProjectile->SetOwner(GetOwner());
        }
        else
        {
            UE_LOG(LogWeaponSystem, Error, TEXT("Projectile weapon, GetOwner FAILED"));
        }
        UGameplayStatics::FinishSpawningActor(SpawnedProjectile, SpawnTransform);
    }
    //- Weapon Effects  //
    OwnerPawn = Cast<APawn>(GetOwner());
    if(OwnerPawn != nullptr)
    {
        WeaponEffects->MuzzleFlashEvent(GetWeaponStats().MuzzleFlashOffset);
        FHitResult HitResult;
        ReceiveFire(HitResult, OwnerPawn);
        APlayerController* OwnerController = Cast<APlayerController>(OwnerPawn->GetController());
        WeaponEffects->PlayFeedbackEffects(OwnerController, WeaponData.FireMode, GetAccuracyMultiplier());
    }
    WeaponEffects->WeaponFireNoiseEvent();
}

SwitchAutoMode()

void AWeaponFramework::SwitchAutoMode ( )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::SwitchAutoMode);
    switch (WeaponData.FireMode)
    {
    case EWeaponFireMode::Single:
        if(GetWeaponStats().bHasAutoMode)
        {
            WeaponData.FireMode = EWeaponFireMode::FullAuto;
            break;
        }
        if(GetWeaponStats().bHasBurstMode)
        {
            WeaponData.FireMode = EWeaponFireMode::Burst;
        }
        break;
    case EWeaponFireMode::Burst:
        WeaponData.FireMode = EWeaponFireMode::Single;
        break;
    case EWeaponFireMode::FullAuto:
        if(GetWeaponStats().bHasBurstMode)
        {
            WeaponData.FireMode = EWeaponFireMode::Burst;
        }
        else
        {
            WeaponData.FireMode = EWeaponFireMode::Single; 
        }
        break;
    default:
        WeaponData.FireMode = EWeaponFireMode::Single; 
        break;
    }
}

ToggleAttachment()

void AWeaponFramework::ToggleAttachment ( const EAttachmentType & AttachmentType )

overrideprotectedvirtual

Implements IWeapon.

{
    SCOPE_CYCLE_COUNTER(STATGROUP_WeaponSystem_Weapons);
    TRACE_CPUPROFILER_EVENT_SCOPE(AWeaponFramework::ToggleAttachment);
    switch (AttachmentType)
    {
    case EAttachmentType::Light:
        break;
    case EAttachmentType::Laser:
        ToggleLaser();
        break;
    default:
        break;
    }
}

ToggleLaser()

void AWeaponFramework::ToggleLaser ( const bool bForceOff = false )

protectedvirtual

{
    if(bLaserOn)
    {
        bLaserOn = false;
    }
    else
    {
        bLaserOn = true;
    }
    if(bForceOff)
    {
        bLaserOn = false;
    }
}

Member Data Documentation

AccuracyMultiplier

float AWeaponFramework::AccuracyMultiplier = 1.0f

private

ActorsToIgnore

TArray<AActor*> AWeaponFramework::ActorsToIgnore

protected

AttachmentComponents

TArray<UStaticMeshComponent*> AWeaponFramework::AttachmentComponents

protected

bBottomlessClip

bool AWeaponFramework::bBottomlessClip = false

bDebuggingMode

bool AWeaponFramework::bDebuggingMode = false

bInfiniteAmmo

bool AWeaponFramework::bInfiniteAmmo = false

bIsBeingReloaded

bool AWeaponFramework::bIsBeingReloaded

private

bLaserOn

bool AWeaponFramework::bLaserOn = false

private

BlindFireTraceColor

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

bReturnPhysicalMaterial

bool AWeaponFramework::bReturnPhysicalMaterial = false

bTraceComplex

bool AWeaponFramework::bTraceComplex = false

bWeaponEffectsSetup

bool AWeaponFramework::bWeaponEffectsSetup = false

private

CurrentWeaponStats

FWeaponStats_T AWeaponFramework::CurrentWeaponStats

private

DrawDebugColorDarkMultiplier

float AWeaponFramework::DrawDebugColorDarkMultiplier = 0.1f

DrawDebugColorLightMultiplier

float AWeaponFramework::DrawDebugColorLightMultiplier = 2.0f

DrawDebugPointSize

float AWeaponFramework::DrawDebugPointSize = 16.0f

DrawDebugTime

float AWeaponFramework::DrawDebugTime = 2.0f

GunMeshComponent

USkeletalMeshComponent* AWeaponFramework::GunMeshComponent

protected

HitscanWeaponComponent

UHitscanWeaponComponent* AWeaponFramework::HitscanWeaponComponent

protected

MainTraceColor

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

Muzzle

USceneComponent* AWeaponFramework::Muzzle

protected

OwnerPawn

APawn* AWeaponFramework::OwnerPawn

protected

ProjectileClass

TSubclassOf<class AActor> AWeaponFramework::ProjectileClass

protected

ProjectileWeaponComponent

UProjectileWeaponComponent* AWeaponFramework::ProjectileWeaponComponent

protected

RecoilPivotPoint

USceneComponent* AWeaponFramework::RecoilPivotPoint

protected

ReloadTimerHandle

FTimerHandle AWeaponFramework::ReloadTimerHandle

private

SceneRoot

USceneComponent* AWeaponFramework::SceneRoot

protected

TraceActorToIgnore

const AActor* AWeaponFramework::TraceActorToIgnore

protected

TraceDistanceTooClose

float AWeaponFramework::TraceDistanceTooClose = 0.075f

TraceLocation

FVector AWeaponFramework::TraceLocation

protected

TraceRotation

FRotator AWeaponFramework::TraceRotation

protected

WeaponData

FWeaponData_T AWeaponFramework::WeaponData

protected

WeaponEffects

class UWeaponEffectsComponent* AWeaponFramework::WeaponEffects

protected

WeaponMesh

USkeletalMesh* AWeaponFramework::WeaponMesh

protected

WeaponType

EWeaponType AWeaponFramework::WeaponType = EWeaponType::Default

protected

---

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

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