leap/documentation/_weapon_instance_8h_source.html

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.


#pragma once


#include "CoreMinimal.h"

#include "PlayerStructs.h"

#include "CosmeticAssetBase.h"

#include "Engine/DataTable.h"

#include "Components/ActorComponent.h"

#include "Components/MaterialBillboardComponent.h"

#include "ReactsToMatchEvents.h"

#include "GameFramework/CharacterMovementComponent.h"

#include "ObjectInfoInterface.h"

#include "WeaponInstance.generated.h"


class UAnimInstance;

class UAnimMontage;

class UTexture2D;

class USkeletalMesh;

class AProjectXCharacter;

class UWeaponComponent;

class UGlobalAmmoComponent;

class UMeleeDashMovementComponent;

class AProjectXHUD;

class UReticleWidget;

class UMaterial;

class UStreamableRenderAsset;

class UAudioComponent;

class UParticleSystem;

class UNiagaraComponent;

class UCameraShakeBase;

class USoundConcurrency;


//How much time leniency we grant to players as the server.

#define MAX_DELTA_TOLERANCE 0.04f

#define DEFAULT_PHYSICS_MATERIAL "DefaultPhysicalMaterial"

#define MAX_DIST_TOLERANCE 400.f


USTRUCT(BlueprintType)

struct FMontageList

{

    GENERATED_USTRUCT_BODY()

public:


    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Perk)

    TArray<UAnimMontage*> AnimationMontages;

};


UENUM(BlueprintType)

enum class ECompressedFlags : uint8

{

    NONE = 0,

    FLAG_JumpPressed = 0x01,    // Jump pressed

    FLAG_WantsToCrouch = 0x02,  // Wants to crouch

    FLAG_Reserved_1 = 0x04, // Reserved for future use

    FLAG_Reserved_2 = 0x08, // Reserved for future use

    // Remaining bit masks are available for custom flags.

    Jetpack = 0x10,

    Dash = 0x20, // Dash movement is limited on the +Z to prevent dashing upwards

    Hookshot = 0x40,

    OmniDash = 0x80, // This dash does not limit vertical movement

};


USTRUCT(Blueprintable)

struct FWeaponAttachment

{

    GENERATED_USTRUCT_BODY()


    UPROPERTY(EditDefaultsOnly, Category = "Attachments")

    FName Socket = NAME_None;

    UPROPERTY(EditDefaultsOnly, Category = "Attachments")

    TSoftObjectPtr<UStaticMesh> StaticMeshAttachment;

    UPROPERTY(EditDefaultsOnly, Category = "Attachments")

    TSoftObjectPtr<USkeletalMesh> SkeletalMeshAttachment;

    UPROPERTY(EditDefaultsOnly, Category = "Attachments")

    TSoftObjectPtr<UParticleSystem> ParticlesAttachment;

};


USTRUCT(Blueprintable)

struct FImpactTableRow : public FTableRowBase

{

    GENERATED_USTRUCT_BODY()


    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    class UPhysicalMaterial* Material = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    TSoftObjectPtr<class UNiagaraSystem> NiagaraParticle = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    TSoftObjectPtr<class UParticleSystem> Particle = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    TSoftObjectPtr<class USoundBase> Sound = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    TSoftObjectPtr<class UMaterial> DecalMaterial = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    TSubclassOf<UCameraShakeBase> CameraShake = nullptr;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    float CameraShakeInnerRadius = 0.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    float CameraShakeOuterRadius = 0.0f;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    FVector DecalSize = FVector(1.25f, 4.f, 4.f);

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    float DecalLifetime = 10.f;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    float DecalMaxDrawDistance = 10000.f;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    float ParticleMaxDrawDistance = 25000.f;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    bool bFrustumCullParticles = true;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    bool bFrustumCullDecals = true;

};


//A loaded version of ImpactTableRow

USTRUCT(Blueprintable)

struct FImpactEffects

{

    GENERATED_USTRUCT_BODY()


    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    UNiagaraSystem* NiagaraParticle = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    UParticleSystem* Particle = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    USoundBase* Sound = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Impact Effects")

    class UMaterial* Decal = NULL;

};


UENUM(BlueprintType)

enum class EWeaponState : uint8

{

    Ready, //Weapon is equipped and idle

    Down, //Weapon is not equipped

    Firing, //Weapon is firing

    Reloading, //Weapon is reloading

    Overheated, //Weapon has overheatead and is cooling down

    Equipping, //Weapon is equipping

    UnEquipping, //Weapon is unequipping

    WaitingToUnequip, //Weapon is waiting for the unequip action to finish

    Custom, //Undefined, usable by child classes.

    None = 255

};


UENUM(BlueprintType, meta = (Bitflags))

enum class EFireMode : uint8

{

    None = 0,

    Primary = 0x00000001,

    Secondary = 0x00000002,

    Tertiary = 0x00000004

};

ENUM_CLASS_FLAGS(EFireMode)


UENUM(BlueprintType)

enum class EFireType : uint8

{

    SemiAutomatic,

    Automatic,

    Charged

};


UENUM(BlueprintType)

enum class EReloadType : uint8

{

    Magazine,

    Individual

};

enum class EWeaponError : uint8;


UENUM(BlueprintType)

enum class ECoolDownType : uint8

{

    Ammo = 0,

    CoolDown = 1,

};


UENUM(BlueprintType)

enum class ECoolDownTrigger : uint8

{

    Fire = 0,

    Unequip = 1,

    ActiveTime = 2,

    Custom = 3,

};


UENUM(BlueprintType)

enum class EDesignatorTeamView : uint8

{

    Everyone,

    Allies,

    Enemies,

    User,

};


USTRUCT(Blueprintable)

struct FFireModeToFloat

{

    GENERATED_USTRUCT_BODY()


    UPROPERTY(EditDefaultsOnly, Category = "Overheat")

    EFireMode FireMode = EFireMode::None;

    UPROPERTY(EditDefaultsOnly, Category = "Overheat")

    float FloatValue = 5.f;

};


DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FChargeEventSignature, float, TotalTime, float, TimeElapsed);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FCoolDownSignature, float, TotalTime, float, TimeElapsed);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponActiveEvent, bool, bActive);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponDesignatorTargetSignature, bool, bValid);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponAmmoChangedSignature, float, CurrentAmmo);

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponCancelledEvent);

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponOverheatEvent);

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponStopActionsSignature);

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponCompleteSignature);

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponEquipStateChangeSignature, UWeaponInstance*, Weapon);


UCLASS(Blueprintable, HideCategories = (Collision, Tags, Activation, ComponentReplication, Cooking))

class PROJECTX_API UWeaponInstance : public UActorComponent, public IReactsToMatchEvents, public IObjectInfoInterface

{

    GENERATED_UCLASS_BODY()


public:

    virtual void BeginPlay() override;

    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

    virtual void Activate(bool bReset = false) override;

    virtual void Deactivate() override;

    virtual void MatchEnded() override;

    virtual bool Fire(uint8 Mode = 0, float WorldTimeOverride = -1.f);

    virtual void CancelFire();

    virtual void InitializeWeapon(bool bFromBatchInitialization = false);

    virtual bool SetupChildWeapon(UWeaponInstance* ParentWeaponToSet);

    virtual void OwnerDied();

    virtual void StopAllActions();

    virtual void StopInputConstrainedActions();

    virtual void UpdateOwningCharacter(AProjectXCharacter* NewCharacter) { OwningCharacter = NewCharacter; }

    virtual bool ImplementsFireMode(uint8 Mode);

    virtual void FireReleased(uint8 Mode = 0);

    virtual bool Reload(float WorldTimeOverride = -1.f);

    virtual void CancelReload();

    virtual bool Equip();

    virtual bool UnEquip(bool bForce = false);

    virtual void UnEquipComplete();

    virtual bool QueueUnEquip();

    virtual void CancelQueuedUnEquip();

    virtual void ActiveTimeComplete();

    virtual void UpdateMeshes1P();

    virtual void UpdateMeshes3P();

    virtual void ApplyWeaponSkins();

    virtual void UpdateWeaponSkin(UMaterialInstance* Material, int MaterialIndex);

    virtual void UpdateWeaponSkinParticleSystem(UParticleSystem* WeaponSkinParticleSystem);

    virtual void SetWeaponState(EWeaponState NewState);

    virtual void LoadImpactEffectTable(UDataTable* ImpactTable);

    virtual void ToggleWeaponPerks(bool bPerksOn);


    virtual void SetMaxMagazineAmmo(float NewMaxAmmo);


    UFUNCTION(BlueprintCallable)

    void SetFireAnimMontage(UAnimMontage* NewFireAnimation1P, UAnimMontage* NewFireAnimation3P) { FireAnimation1P = NewFireAnimation1P ? NewFireAnimation1P : FireAnimation1P; FireAnimation3P = NewFireAnimation3P ? NewFireAnimation3P : FireAnimation3P; }


    /* Fetches the interpolation position 0-1 for ramp-up style fire weapons */

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetFireRatePercentage() const { return FireRateInterp; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsReady() const { return WeaponState == EWeaponState::Ready; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsEquipped() const { return WeaponState != EWeaponState::Down && WeaponState != EWeaponState::UnEquipping && WeaponState != EWeaponState::WaitingToUnequip && WeaponState != EWeaponState::None; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsDown() const { return WeaponState == EWeaponState::Down; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsFiring() const { return WeaponState == EWeaponState::Firing; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsHoldingPrimary() const { return bHoldingFire; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsReloading() const { return WeaponState == EWeaponState::Reloading; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsEquipping() const { return WeaponState == EWeaponState::Equipping; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsUnEquipping() const { return WeaponState == EWeaponState::UnEquipping; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsWaitingToUnEquip() const { return WeaponState == EWeaponState::WaitingToUnequip; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsOverheated() const { return WeaponState == EWeaponState::Overheated || bIsOverheating; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool CanWeaponOverheat() const { return bCanWeaponOverheat; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool CanTightAim() const { return !IsDown() && !IsReloading() && !IsEquipping() && !IsUnEquipping() && !IsOverheated(); }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsTightAiming() const { return bTightAiming; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool HasSwayOnTightAim() const { return bHasSwayOnTightAim; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetSwayIntensityMultiplier() const { return SwayIntensityMultiplier; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetFireRate() const { return FMath::Clamp(FMath::Lerp(FireRate, FireRateMin, FireRateInterp), SMALL_NUMBER, BIG_NUMBER); } //Clamp non zero. Used in division

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetDisplayFireRate() const { return  60.0f/FireRate; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE EFireType GetFireType() const {return WeaponFireType;}

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsSemiAutomatic() const { return WeaponFireType == EFireType::SemiAutomatic; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsAutomatic() const { return WeaponFireType == EFireType::Automatic; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsCharged() const { return WeaponFireType == EFireType::Charged; }

    UFUNCTION(BlueprintCallable, Category = Weapon)

    FORCEINLINE bool IsInitialized() const { return bInitialized; }

    UFUNCTION()

    FORCEINLINE bool IsDebugging() const { return bDebug; }

    FORCEINLINE bool IsChildWeapon() const { return bIsChildWeapon; }

 //Is currently in a first person perspective of this weapon's owner.

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool CanQuickSwitchTo() const { return bCanQuickSwitchTo; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool ShouldUnEquipAfterFire() const { return bUnEquipAfterFire; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool ShouldUnequipOnToggle() const { return bUnequipsOnToggle; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool ShouldUnEquipOnEmpty() const { return bUnEquipOnEmpty; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool CanBePreviousWeapon() const { return bCanBePreviousWeapon; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool IsExclusiveWeapon() const { return bExclusiveWeapon && !IsBeingDestroyed(); }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetDamageForce() const { return DamageForce; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool CanHoldBreathWhileADSing() const { return bCanHoldBreathWhileADSing; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool UsesAmmo() const { return bUsesAmmo; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool UsesGlobalAmmo() const { return bGlobalAmmo; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    bool HasInfiniteReserveAmmo() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    float GetMaxMagAmmo() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetReserveAmmo() const { return HasInfiniteReserveAmmo() ? 0.f : TotalAmmo; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetMaxReserveAmmo() const { return HasInfiniteReserveAmmo() ? 0.f : MaxTotalAmmo; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE FName GetKeyChainSocket() const { return KeyChainSocketName; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    const FText& GetWeaponName() const { return WeaponName; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    const FText& GetWeaponDescription() const{return WeaponDescription;}

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE TAssetPtr<UTexture2D> GetWeaponIcon() const { return WeaponIcon; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE TAssetPtr<UTexture2D> GetWeaponKillFeedIcon() const { return WeaponKillFeedIcon; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool UsesCoolDown() const { return bUsesCoolDown; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetCoolDownDuration() const { return CoolDown; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE float GetChargeValue() const { return ChargeValue; }

    UFUNCTION(BlueprintPure, Category = "Weapon|Overheat")

    FORCEINLINE float GetOverheatThreshold() const { return OverheatThreshold; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE bool DoesWeaponSupportTightAiming() const {return bCanTightAim;}

    UFUNCTION(BlueprintPure,Category = Display)

    FORCEINLINE FName GetDisplaySocketName() const{return DisplaySocketName;}

    UFUNCTION(BlueprintPure, Category = Display)

    FORCEINLINE float GetDisplayCameraFocalDistance() const { return DisplayFocalDistance; }

    FORCEINLINE bool IsAlmostReady() const { return WeaponState == EWeaponState::Ready || IsActionNearlyComplete(WeaponState); }

    FORCEINLINE FName GetSocket1P() const { return SocketAttach1P; }

    FORCEINLINE FName GetSocket3P() const { return SocketAttach3P; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FORCEINLINE EWeaponState GetWeaponState() const { return WeaponState; }

    UFUNCTION(BlueprintPure, Category = Character)

    const TArray<EPerkType>& GetPerkSlots() const { return PerkSlots; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    FTransform GetDesignatorTransform();

    UFUNCTION(BlueprintPure, Category = Weapon)

    const FString& GetWeaponID() const { return WeaponID; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetWeaponSpread() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetMagAmmo() const;

    UFUNCTION(BlueprintPure,Category = Weapon)

    virtual float GetDisplayDamage() const { return GetDamage(FHitResult()); }

    UFUNCTION(BlueprintPure, Category = Weapon)

    UWeaponComponent* GetOwningComponent() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    AProjectXCharacter* GetOwningCharacter() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    AController* GetOwningController() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual AProjectXPlayerController* GetOwningPlayerController() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    UGlobalAmmoComponent* GetGlobalAmmoComponent() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    FVector GetKeyChainScale() const { return KeyChainScale; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    bool IsCurrentViewTarget() const;

    //Returns true if this weapon is owned by the current client

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual bool IsLocallyOwned() const;

    //Returns true if this weapon is the authoritative copy

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual bool IsAuthority() const;

    UFUNCTION(BlueprintPure)

    AProjectXHUD* GetHUD() const;

    UFUNCTION(BlueprintPure)

    UReticleWidget* GetReticle() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetTightAimPercent() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    float GetTightAimSpreadModifier() const { return FMath::Lerp(TightAimSpreadModifier.X, TightAimSpreadModifier.Y, GetTightAimPercent()); }

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetMovementSpreadModifier() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    TSubclassOf<class UUserWidget> GetTightAimWidget() const { return TightAimWidget; }

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetGlobalRestockTime() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetGlobalRestockAmount() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual bool IsProgressiveGlobalAmmoRestock() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual bool IsHeadshot(const FHitResult& HitResult) const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetDamage(const FHitResult& HitResult, float DamageModifer = 1.0f, const UWeaponComponent* WeaponComponent = NULL) const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual float GetDamageMultiplier(const FHitResult& HitResult, float DamageModifer = 1.0f, const UWeaponComponent* WeaponComponent = NULL) const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    virtual TSubclassOf<UDamageType> GetDamageType() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    float GetDamageScalingMultiplier(float Value) const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    bool IsCoolingDown() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    float CoolDownDurationRemaining() const;

    UFUNCTION(BlueprintPure, Category = "Weapon|Overheat")

    float GetCurrentHeat() const;

    UFUNCTION(BlueprintPure, Category = "Weapon|Overheat")

    float GetHeatAsPercentage() const;

    UFUNCTION(BlueprintPure, Category = Weapon)

    UParticleSystem* GetWeaponSkinParticle() const { return WeaponSkinParticle; }

    UFUNCTION()

    virtual bool IsTightAimFireMode(uint8 Mode) const;

    //Returns true if this weapon is owned by the current client but is not the authority (used to determine if RPCs need to be sent)

    UFUNCTION()

    virtual bool IsLocallyOwnedRemote() const;

    //Returns true if this weapon is only a simulated one (skip all validation, we're just a slave)

    UFUNCTION()

    virtual bool IsSimulatedOnly() const;

    //Returns true if this weapon is the authoritative copy and not owned by the current client

    UFUNCTION()

    virtual bool IsNonOwningAuthority() const;

    UFUNCTION(BlueprintCallable, Category = "Weapon")

    virtual void AddAmmo(float InAmmo);


    virtual const FText& GetObjectName() const { return WeaponName; };

    virtual const FString GetOwnerName() const;

    virtual const FText& GetObjectDescription() const { return WeaponDescription; };

    virtual bool IsActionNearlyComplete(EWeaponState State) const;

    virtual bool IsChildWeaponFireMode(uint8 Mode) const;

    virtual float GetReticleSpreadMultiplier() const { return ReticleSpreadMultiplier; };

    virtual bool ShouldReloadCancel(uint8 Mode) const;

    virtual bool CanReload(EWeaponError& ErrorMessage) const;

    virtual bool CanFire(EWeaponError& ErrorMessage, uint8 Mode = 0) const;

    virtual bool IsManagedByWeaponComponent() const { return bIsManagedByWeaponComponent;};

    virtual bool BlocksWeaponComponentWhileEquipped() const { return bBlockWeaponComponentWhileEquipped; };

    virtual bool CancelsCurrentEquippedWeaponActionsWhenEquipped() const { return bCancelCurrentEquippedWeaponActions; };

    virtual bool BlocksUnmanagedWeapons() const { return bBlocksUnmanagedWeapons; };

    virtual bool CanEquip() const;

    virtual bool CanUnEquip(bool bTestOnly = false) const;

    virtual bool CanQueueUnEquip() const;

    virtual bool IsAwaitingUnEquip() const;

    virtual float GetDamageMaterialMultiplier(const FHitResult& HitResult) const;

    virtual bool HasEnoughAmmo(float Amount, uint8 Mode = 0) const;

    float GetWeaponMovementVelocity() const { return WeaponMovementVelocity; }

    TSubclassOf <class UAfflictionInstance> GetWeaponMovementAfflictionClass() const { return WeaponMovementAfflictionClass; }


    TSubclassOf <class UAfflictionInstance> GetWeaponAffliction() const { return WeaponAffliction; }


    virtual FVector GetWeaponMovementDirection() const;

    const FVector GetWeaponPivotOffset() const;

    TSoftObjectPtr<USkeletalMesh> GetMesh1P() const;

    TSoftObjectPtr<USkeletalMesh> GetMesh3P() const;

    ECompressedFlags GetWeaponMovementFlag() const { return WeaponMovementFlag; }

    TArray<FWeaponAttachment>& GetMeshAttachments() { return Attachments; }


    UFUNCTION(BlueprintNativeEvent)

    void OnChargeValueUpdated(float Charge);

    UFUNCTION(BlueprintImplementableEvent)

    void OnWeaponParticleLoaded(UParticleSystem* Particle);

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Fire", ScriptName = "Fire"))

    void K2_Fire(uint8 Mode);

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Fire Released", ScriptName = "FireReleased"))

    void K2_FireReleased(uint8 Mode);

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Fire Complete", ScriptName = "FireComplete"))

    void K2_FireComplete(uint8 Mode);

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Reload", ScriptName = "Reload"))

    void K2_Reload();

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Reload Cancelled", ScriptName = "ReloadCancel"))

    void K2_ReloadCancel();

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Reload Complete", ScriptName = "ReloadComplete"))

    void K2_ReloadComplete();

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Equip", ScriptName = "Equip"))

    void K2_Equip();

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Equip Complete", ScriptName = "EquipComplete"))

    void K2_EquipComplete();

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On UnEquip", ScriptName = "UnEquip"))

    void K2_UnEquip();

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On UnEquip Complete", ScriptName = "UnEquipComplete"))

    void K2_UnEquipComplete();

    UFUNCTION(BlueprintImplementableEvent)

    void K2_ToggleDesignatorMarker(AActor* NewDesignatorMarker);

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Weapon State Changed", ScriptName = "WeaponStateChanged"))

    void K2_WeaponStateChanged(EWeaponState NewWeaponState);

    UFUNCTION(BlueprintImplementableEvent, Category = Weapon, meta = (DisplayName = "On Owner Died", ScriptName = "OwnerDied"))

    void K2_OwnerDied();


    UFUNCTION(BlueprintCallable, Category = Weapon, meta = (DisplayName = "Is Headshot", ScriptName = "IsHeadshot"))

    static bool IsHeadshotStatic(const FHitResult& HitResult, const TSubclassOf<UDamageType> DamageType);

    UFUNCTION(BlueprintCallable, Category = Weapon)

    static bool ShouldDisplayHitConfirm(AActor* Target, AActor* Instigator);

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Mag Capacity", ScriptName = "GetMagCapacity"))

    static float GetMagCapacityFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetMaxMagAmmo() : 0.f; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Global Restock Time", ScriptName = "GetGlobalRestockTime"))

    static float GetGlobalRestockTimeFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetGlobalRestockTime() : 0.f; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Global Restock Amount", ScriptName = "GetGlobalRestockAmount"))

    static float GetGlobalRestockAmountFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetGlobalRestockAmount() : 0.f; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get KeyChain Scale", ScriptName = "GetKeyChainScale"))

    static FVector GetKeyChainScaleStatic(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetKeyChainScale() : FVector::OneVector; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Weapon Name", ScriptName = "GetWeaponName"))

    static FText GetWeaponNameFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetWeaponName() : FText::FromString(""); }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Weapon Name", ScriptName = "GetWeaponDescription"))

    static FText GetWeaponDescriptionFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetWeaponDescription() : FText::FromString(""); }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Weapon ID", ScriptName = "GetWeaponID"))

    static FString GetWeaponIDFromClass(TSubclassOf<UWeaponInstance> Class);

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Weapon Icon", ScriptName = "GetWeaponIcon"))

    static TAssetPtr<UTexture2D> GetWeaponIconFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetWeaponIcon() : NULL; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Weapon KeyChain Socket", ScriptName = "GetWeaponKeyChainSocket"))

    static FName GetWeaponKeyChainSocket(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetKeyChainSocket() : ""; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Weapon Kill Feed Icon", ScriptName = "GetWeaponKillFeedIcon"))

    static TAssetPtr<UTexture2D> GetWeaponKillFeedIconFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetWeaponKillFeedIcon() : NULL; }

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "GetDisplayMesh", ScriptName = "GetDisplayMesh"))

    static TSoftObjectPtr<USkeletalMesh> Get3rdPersonDisplayMeshFromClass(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->DisplayMesh3P : NULL; }

    static void GetAllImpactEffectRows(class UDataTable* DataTable, TArray<struct FImpactTableRow*>& ImpactEffectRows);

    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "GetNumberOfPerkSlots", ScriptName = "GetNumberOfPerkSlots"))

    static uint8 StaticGetNumberOfPerksSlots(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetPerkSlots().Num() : 0; }

    UFUNCTION(BlueprintPure, Category = "Player Class", meta = (DisplayName = "GetPerkSlots", ScriptName = "GetPerkSlots"))

    static TArray<EPerkType> StaticGetPerkSlots(TSubclassOf<UWeaponInstance> Class) { return (Class && Class->GetDefaultObject<UWeaponInstance>()) ? Class->GetDefaultObject<UWeaponInstance>()->GetPerkSlots() : TArray<EPerkType>(); }

    static struct FImpactTableRow* GetImpactEffectByName(class UDataTable* DataTable, FName RowName);

    static struct FImpactTableRow* GetImpactEffectByPhysicsMaterial(class UDataTable* DataTable, const UPhysicalMaterial* Material);

    static void SpawnImpactEffects(UObject* WorldContextObject, class UDataTable* DataTable, const FHitResult& Hit, class UParticleSystemComponent*& ParticleSystem, class UAudioComponent*& AudioComponent, class UDecalComponent*& DecalComponent, UNiagaraComponent*& NiagaraParticleSystem);

    /* Max amount of ammo this weapon can hold in mag */

    UPROPERTY(EditDefaultsOnly, Replicated,Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    float MaxMagazineAmmo = 10.f;

    /*Length of the cooldown*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|CoolDown", meta = (EditCondition = "bUsesCoolDown"))

    float CoolDown = 0.0f;

    /* Base weapon damage. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    float BaseDamage = 10.f;


    UPROPERTY(BlueprintAssignable)

    FChargeEventSignature ChargeStartEvent;

    UPROPERTY(BlueprintAssignable)

    FChargeEventSignature ChargeFinishedEvent;

    UPROPERTY(BlueprintAssignable)

    FWeaponActiveEvent WeaponToggleEvent;

    UPROPERTY(BlueprintAssignable)

    FWeaponCancelledEvent WeaponCancelledEvent;

    UPROPERTY(BlueprintAssignable)

    FWeaponOverheatEvent ONWeaponOverheatStart;

    UPROPERTY(BlueprintAssignable)

    FWeaponOverheatEvent ONWeaponOverheatEnd;

    UPROPERTY(BlueprintAssignable)

    FWeaponEquipStateChangeSignature OnWeaponEquipped;

    UPROPERTY(BlueprintAssignable)

    FWeaponStopActionsSignature OnWeaponStopActions;

    UPROPERTY(BlueprintAssignable)

    FCoolDownSignature OnCoolDownStarted;

    UPROPERTY(BlueprintAssignable)

    FWeaponCompleteSignature OnCoolDownFinished;

    UPROPERTY(BlueprintAssignable)

    FWeaponAmmoChangedSignature OnWeaponAmmoChanged;

    UPROPERTY(BlueprintAssignable)

    FWeaponDesignatorTargetSignature OnValidDesignatorTargetEvent;


    UAnimMontage* GetFireMontage1P() const;

    UAnimMontage* GetFireMontage3P() const;


    virtual void OnHeatCoolDownComplete();

    virtual void FireComplete(uint8 Mode);

    virtual void ChargeStart(uint8 Mode,float StartOverride = 0.0f);

    virtual void EquipComplete();

    virtual void ReloadComplete();

    virtual void SetMagazineAmmo(float NewMagAmmo);

    virtual void StartWeaponMovement(const FVector& Direction);

    virtual void StopWeaponMovement();

    virtual void OnWeaponDown() { if (IsSimulatedOnly()) K2_UnEquip(); }

    virtual void ToggleEquippedAffliction(bool bIsEquipped);

    virtual void CoolDownStart(uint8 Mode);

    virtual bool ConsumeAmmo(float Amount, uint8 Mode = 0);

    virtual bool GenerateHeat(uint8 Mode = 0);

    virtual void ToggleTightAim(bool bEnable);

    virtual void ToggleDesignatorMarker(bool bEnable);

    virtual void UpdateDesignator(float DeltaTime = 0.f);

    virtual bool CanSpawnDesignator() const;

    virtual void PlayFireCounter();

    virtual void PlayWeaponFireEffects(uint8 BurstCounter = 0);

    virtual void PlayWeaponFireEffects1P();

    virtual void PlayWeaponFireEffects3P();

    virtual void PlayWeaponReload();

    virtual void StopWeaponReload();

    virtual void PlayWeaponEquip();

    virtual void PlayWeaponUnEquip();

    virtual void DecayFireRate();

    //This waits Firerate before calling start heat cooldown, so a quick release don't start simulating the heat cooling down in-between shots

    virtual void WaitToStartHeatCooldown();

    virtual void StartHeatCooldown();

    virtual void PredictCurrentHeat();

    virtual void AsyncLoadImpactTableNiagaraParticle(TSoftObjectPtr<UNiagaraSystem> AssetPointer, UPhysicalMaterial* Material);

    virtual void AsyncLoadImpactTableParticle(TSoftObjectPtr<UParticleSystem> AssetPointer, UPhysicalMaterial* Material);

    virtual void AsyncLoadImpactTableSound(TSoftObjectPtr<USoundBase> AssetPointer, UPhysicalMaterial* Material);

    virtual void AsyncLoadImpactTableDecal(TSoftObjectPtr<UMaterial> AssetPointer, UPhysicalMaterial* Material);


    UFUNCTION(BlueprintPure, Category = Weapon, meta = (DisplayName = "Get Target Transform", ScriptName = "GetTargetTransform"))

    virtual bool GetTargetTransform(FTransform& Transform) const;


    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_UnEquip();

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_Fire(uint8 Mode = 0, float WorldTimeOverride = -1.f);

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_CancelFire();

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_ChargeStart(float ChargeStartTime,uint8 Mode = 0, float WorldTimeOverride = -1.f);

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_FireReleased(uint8 Mode);

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_Reload(float WorldTimeSeconds);

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_ReloadCancel();

    UFUNCTION(Server, Reliable, WithValidation)

    void Server_Reliable_TightAim(bool bEnable);

    UFUNCTION(NetMulticast, Reliable)

    void Multicast_ChargeFinished(float ChargeVal);


    UFUNCTION(Client, Reliable)

    void Client_Reliable_BroadcastWeaponError(EWeaponError Error) const;

    UFUNCTION(Client, Reliable)

    void Client_Reliable_ReloadComplete(float ReloadAmount);

    UFUNCTION(Client, Reliable)

    void Client_Reliable_TotalAmmoChanged(float NewTotalAmmo);

    UFUNCTION(Client, Reliable)

    void Client_Reliable_SetMagazineAmmo(float NewMagAmmo);

    UFUNCTION(Client, Reliable)

    void Client_Reliable_HeatCooldownComplete(uint8 Mode);


    UFUNCTION()

    virtual void ChargeTimeComplete(uint8 Mode, bool bExecuteFire = true);

    UFUNCTION()

    virtual void DeferredReload();

    UFUNCTION()

    virtual void CoolDownFinished();


    UFUNCTION()

    void OnRep_ChargeIsReady();

    UFUNCTION()

    void OnRep_IsOverheating();

    UFUNCTION()

    void OnRep_HoldingFire();

    UFUNCTION()

    void OnRep_ParentWeapon();

    UFUNCTION()

    virtual void OnRep_WeaponState(EWeaponState PreviousState);

    UFUNCTION()

    virtual void OnRep_FireCounter();

    UFUNCTION()

    virtual void OnRep_TightAiming();


    void BroadcastWeaponError(EWeaponError Error) const;


    /* If TRUE, this weapon will be managed by the Weapon Component, which means there can only be 1 weapon equipped at a time and all events are managed through the state machine in it.

    If set to FALSE this weapon doesn't have to be equipped on the Weapon Component and will try to manage its own state changes */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon")

    bool bIsManagedByWeaponComponent = true;

    /* If this weapon is managed by the Weapon Component, should we prevent unmanaged weapons to equipping while this weapon is equipped? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "bIsManagedByWeaponComponent"))

    bool bBlocksUnmanagedWeapons = false;

    /* If this weapon is not managed by the Weapon Component, should we prevent the component from running input-based logic while this weapon is equipped? (Switching weapons, firing...) */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bBlockWeaponComponentWhileEquipped = true;

    /* If this weapon is not managed by the Weapon Component, should we still query the weapon component bCanFire state before some of our actions? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bRespectWeaponComponentFireLock = true;

    /* If this weapon is not managed by the Weapon Component, should we cancel any current actions such as ongoing reloads? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bCancelCurrentEquippedWeaponActions = true;

    /* If this weapon is not managed by the Weapon Component, should we be allowed to equip when the current weapon (if any on the weapon component) is equipping? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bCanEquipWhileSharedWeaponIsEquipping = false;

    /* If this weapon is not managed by the Weapon Component, should we be allowed to equip when the current weapon (if any on the weapon component) is unequipping? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bCanEquipWhileSharedWeaponIsUnequipping = false;

    /* If we are not managed by the weapon component, this means we might be shared with an already equipped weapon, which then controls the mesh. What anims should we play per-weapon on 1P when firing?*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged|Animation|First Person", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    TMap<TSubclassOf<UWeaponInstance>, FMontageList> FireAnimsPerWeapon1P;

    /* If we are not managed by the weapon component, this means we might be shared with an already equipped weapon, which then controls the mesh. What anims should we play per-weapon on 3P when firing?*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged|Animation|Third Person", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    TMap<TSubclassOf<UWeaponInstance>, FMontageList> FireAnimsPerWeapon3P;

    /* When querying which animation to play, if we can't find one for the current equipped weapon, should we fallback to the standard "FireAnim"? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged|Animation", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bFallBackToFireAnim = true;

    /* During the equip of this Unmanaged Weapon, should we interpolate to the RelativePositionOffset and RelativeRotationOffset set up for this weapon? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent"))

    bool bInterpolateToUnmanagedOffset = false;

    /* If bInterpolateToUnmanagedOffset is true, how long should it take to interpolate to this weapon's offset? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent && bInterpolateToUnmanagedOffset"))

    float UnmanagedOffsetInterpolateToTime = 0.1f;

    /* If bInterpolateToUnmanagedOffset is true, how long should it take to interpolate from this weapon's offset to the equipped one's? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Unmanaged", meta = (EditCondition = "!bIsManagedByWeaponComponent && bInterpolateToUnmanagedOffset"))

    float UnmanagedOffsetInterpolateFromTime = 0.1f;

    /* toggles whether this uses the cooldown*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|CoolDown")

    bool bUsesCoolDown = false;

    /*What triggers the Cooldown of this weapon? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|CoolDown", meta = (EditCondition = "bUsesCoolDown"))

    ECoolDownTrigger CoolDownTriggerState = ECoolDownTrigger::Fire;

    /* Should this weapon display debugging information? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon")

    bool bDebug = false;

    /*Toggle if the charged shot will fire only on release or if it will auto fire at charge time*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Charge")

    bool bFireChargeOnRelease = false;

    /* Determines the amount of time to charge*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon|Charge")

    float ChargeRate = 1.f;

    /* Duration that it takes for this weapon to fire (delay between shots in seconds)*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    float FireRate = 1.f;

    /* How much force does this weapon invoke upon physics actors that it damages? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon")

    float DamageForce = 200000.f;

    /* Max fire rate if FireRateRampUp is > 0*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    float FireRateMin = 1.f;

    /* Duration that it takes for this weapon to reach its maximum fire rate*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    float FireRateRampUp = 0.0f;

    /* Duration that it takes for this weapon to reload */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    float ReloadRate = 1.f;

    /* Duration you can keep the weapon equiped for*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    float ActiveTime = 0.0f;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    FString WeaponID = "";

    /* At what distance does aim assist start to fall off? Distance is X and falloff value is Y. If you want a gun that has 100% aim assist up to 1500cm, define a key at (0, 1) and a key at (1500, 1) then taper off the curve over time as X gets > 1500 */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")

    UCurveFloat* AimAssistDistanceFalloffCurve = nullptr;

    /* Same as above but for tight aiming. If using 2x zoom, you'll want to double the distance of your falloff curve. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")

    UCurveFloat* TightAimedAimAssistDistanceFalloffCurve = nullptr;

    /* Anything below the first value will be 100% aim assist, the amount of assist will drop off until the player's angle reaches the second value. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")

    FVector2D AimAssistFalloffAngle = FVector2D(3.0f, 6.0f);

    /* Same as above but for tight-aiming. If you have the player on 2x zoom you will want to make the cone 2x tighter. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Aim Assist")

    FVector2D TightAimedAimAssistFalloffAngle = FVector2D(1.0f, 3.0f);

    /* Should this weapon generate head and use overheating features */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Overheat")

    bool bCanWeaponOverheat = false;

    /* Are we allowed to hold our breath while Tight aiming (ADS)? */

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Gameplay|Stats")

    bool bCanHoldBreathWhileADSing = false;

    /* Can this weapon be switched to another one while colling down? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Overheat", meta = (EditCondition = "bCanWeaponOverheat"))

    bool bCanUnequipWhileOverheating = true;

    /* The amount of heat this weapon generates per shot for each Fire Mode */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Overheat", meta = (EditCondition = "bCanWeaponOverheat"))

    TArray<FFireModeToFloat> HeatGeneratedPerShot = TArray<FFireModeToFloat>();

    /* The amount of heat this weapon dissipates per second when not holding the trigger */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Overheat", meta = (EditCondition = "bCanWeaponOverheat"))

    float HeatDissipationRate = 1.f;

    /* How much heat can this weapon hold before overheating and shutting down*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Overheat", meta = (EditCondition = "bCanWeaponOverheat"))

    float OverheatThreshold = 100.f;

    /* How much time does this weapon need to fully cool down in seconds after overheating. A value of 0 means the weapon will never cool down by itself and needs to be manually triggered */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon|Overheat", meta = (EditCondition = "bCanWeaponOverheat"))

    float TimeToFullyCoolDown = 5.f;

    /* Duration that it takes for this weapon to be equipped */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon|Equip")

    float EquipRate = 0.25f;

    /* Duration that it takes for this weapon to be unequipped, if < 0, it will use the EquipRate */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon|Equip")

    float UnequipRate = -1.f;

    /* Can we switch to this weapon using quick switch? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bCanQuickSwitchTo = true;

    /* When trying to equip this weapon again, shoud we toggle its state an unequip it? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bUnequipsOnToggle = false;

    /* Is this weapon a suitable candidate for being considered a previous weapon? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bCanBePreviousWeapon = true;

    /* Should we fire immediately when we've finished equipping? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip", meta = (EditCondition = "!bAltFireOnEquip"))

    bool bFireOnEquip = false;

    /* Should we fire immediately when we've finished equipping? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip", meta = (EditCondition = "!bFireOnEquip"))

    bool bAltFireOnEquip = false;

    /* Should we equip our previous weapon after placing firing this weapon? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bUnEquipAfterFire = false;

    /* Should we equip our previous weapon after emptying this weapon? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bUnEquipOnEmpty = false;

    /* Should we equip our previous weapon after emptying this weapon? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bDropWeaponWhenEmpty = false;

    /* Can we equip this weapon when it's empty? Should be only used on weapons that restock on their own. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bCanEquipWhenEmpty = true;

    /* Can never be switched away from in normal gameplay. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    bool bExclusiveWeapon = false;

    /*The fire mode that this weapon uses */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon", meta = (Bitmask, BitmaskEnum = EFireMode))

    uint8 FireModeFlags = 0;

    /* Affliction applied when the weapon is equipped*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    TSubclassOf<UAfflictionInstance> EquippedAffliction = NULL;

    /* In the event this weapon's attack comes in contact with a physical material in this list, the associative damage multiplier will be applied. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    TMap<class UPhysicalMaterial*, float> DamageMultipliers;

    /*What Perecent do we need to charge to to fire*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    float MinimumChargeValue = 1.0f;

    /* The method with which this weapon fires */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon")

    EFireType WeaponFireType = EFireType::SemiAutomatic;

    /*Is Holding the trigger required for the charge*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Charge")

    bool bHeldToCharge = true;

    /* How Damage will be scaled based on a curve */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Equip")

    UCurveFloat* DamageScalingCurve;

    /* Whether or not this weapon uses ammo */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo")

    bool bUsesAmmo = true;

    /* The method with which this weapon fires */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    EReloadType ReloadType = EReloadType::Magazine;

    /* Whether or not ammo is consumed on fire */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    bool bConsumeOnFire = true;

    /* Whether or not we should reload this gun immediately upon emptying it. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    bool bReloadWhenEmptied = true;

    /* Does this weapon have infinite reserve (total) ammo? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    bool bInfiniteReserveAmmo = true;

    /* Max amount of ammo this weapon can hold in reserve */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    float MaxTotalAmmo = 100.f;

    /* Amount of ammo this weapon consumes per shot */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    float AmmoConsumedPerShot = 1.f;

    /* Should ammo be globally synchronized on this player? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bUsesAmmo"))

    bool bGlobalAmmo = false;

    /* How frequently should the globally synchronized ammo be restocked? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bGlobalAmmo"))

    float RestockTime = 5.f;

    /* How much globally synchronized ammo should be added per restock */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bGlobalAmmo"))

    float RestockAmount = 5.f;

    /* If true will gradually restock RestockAmount over RestockTime, instead of in steps. */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bGlobalAmmo"))

    bool bProgressiveRestock = false;

    /* Reset ammo on Spawn*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Ammo", meta = (EditCondition = "bGlobalAmmo"))

    bool bResetAmmoOnSpawn = false;

    /* Does this weapon support tight-aim? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim")

    bool bCanTightAim = false;

    /* Do we have a sway when tight aiming? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    bool bHasSwayOnTightAim = true;

    /* Do we have a sway when tight aiming? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim && bHasSwayOnTightAim"))

    float SwayIntensityMultiplier = 1.f;

    /* Which action causes tight aim to occur? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    EFireMode TightAimFireMode = EFireMode::Secondary;

    /* How long it takes to get into tight-aim */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    float TightAimRate = 0.25f;

    /* Shift the field of view to this value when tight-aiming */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    float TightAimFOV = 45.f;

    /* Distance of focus, the rest gets blurred out */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    float TightAimFocalDistance = 20.f;

    /* Lower value results in a blurrier depth of field */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    float TightAimFStop = 36.f;

    /*Weapon Offset while tight aiming*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    FVector TightAimRelativeWeaponOffset = FVector::ZeroVector;

    /*Weapon rotation offset while tightaiming*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    FRotator TightAimRelativeWeaponRotationOffset = FRotator::ZeroRotator;

    /* If true, tight aiming is allowed to interrupt reloading */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    bool bTightAimInterruptsReload = false;

    /* Modifies spread of weapons depending on tight aim progress */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    FVector2D TightAimSpreadModifier = FVector2D(1.f, 1.f);

    /* Widget to display when we begin tight aiming */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    TSubclassOf<class UUserWidget> TightAimWidget = NULL;

    /* Post process reticle texture to use while tight aiming */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    UTexture* TightAimReticleTexture = NULL;

    /* Post process reticle texture to use while tight aiming */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    FVector2D TightAimReticleTextureScale = FVector2D(0.05f, 0.05f);

    /* Post process reticle texture to use while tight aiming */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon|Tight Aim", meta = (EditCondition = "bCanTightAim"))

    FLinearColor TightAimReticleTextureTint = FLinearColor::White;

    /* Base weapon damage. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Weapon")

    TSubclassOf<class UDamageType> BaseDamageType = NULL;

    /*Should we allow the weapon to apply movement while firing?*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement")

    bool bEnableWeaponMovement = false;

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement"))

    TSubclassOf <class UAfflictionInstance > WeaponMovementAfflictionClass = NULL;

    /* Force applied when triggered*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement"))

    float WeaponMovementVelocity = 500.f;

    /* The max amount of time the movement logic can run. For any value bigger than 0, (limited by the weapon's fire-rate) the movement logic will be run for that amount of time in seconds */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement"))

    float MaxWeaponMovementDuration = 0.f;

    /*If you have more than one weaponmovement component, use different flags to make sure they dont interfere with each other */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement"))

    ECompressedFlags WeaponMovementFlag = ECompressedFlags::Dash;

    /*If a dash is being used as the movement flag, should we align our camera to the dash direction? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement && WeaponMovementFlag == ECompressedFlags::Dash || WeaponMovementFlag == ECompressedFlags::OmniDash"))

    bool bLooksTowardsDashMovement = false;

    /*If a dash is being used as the movement flag, should we break after dashing ? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement && WeaponMovementFlag == ECompressedFlags::Dash || WeaponMovementFlag == ECompressedFlags::OmniDash"))

    bool bBreakAfterDashing = false;

    /* Which action causes this weapon to activate its movement? */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Movement", meta = (EditCondition = "bEnableWeaponMovement"))

    EFireMode WeaponMovementFireMode = EFireMode::Secondary;

    /*Should we treat this weapon as a child weapon? Children weapons are allowed to be "attached" to other weapons and be controlled by them, useful for alt firemodes */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Child Weapons")

    bool bIsChildWeapon = false;

    /* Weapons this weapon should initialize as children during Initialization */

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Child Weapons", meta = (EditCondition = "!bIsChildWeapon"))

    TSubclassOf<UWeaponInstance> ChildWeaponClass = NULL;

    /* Should we route a fire mode to the Child Weapon?*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Child Weapons", meta = (EditCondition = "!bIsChildWeapon && ChildWeaponClass!= NULL"))

    EFireMode ChildWeaponFireMode = EFireMode::Secondary;

    /*Name of the socket that the keychain attaches too*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | KeyChain")

    FName KeyChainSocketName = "KeyChainSocket";

    /* scale of the keychain*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | KeyChain")

    FVector KeyChainScale = FVector(1.0f, 1.0f, 1.0f);

    /*who will the designator spawn for*/

    UPROPERTY(EditDefaultsOnly, Category = "Designator")

    EDesignatorTeamView DesignatorTeamView;

    /*Designator class to spawn*/

    UPROPERTY(EditDefaultsOnly, Category = "Designator")

    TSubclassOf<class ADesignatorMarker> DesignatorMarkerClass = NULL;

    /* Do you need a target for the designator*/

    UPROPERTY(EditDefaultsOnly, Category = "Designator")

    bool bDesignatorRequiresTarget = true;

    /* Usually this is the fire rate for auto weapons. How long the recoil effect takes. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    float WeaponMeshRecoilTime = 0.5f;

    /* How far the weapon recoils */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    float WeaponMeshRecoilDistance = 0.0f;

    /* How far the weapon recoils while tight aimed */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    float WeaponMeshRecoilDistanceTightAimed = 0.0f;

    /* How the recoil animation plays out. Usually you use a bounce curve so that it pulls back and returns to it's original position 0-1-0 */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UCurveFloat* WeaponMeshRecoilCurve = nullptr;

    /* First person display mesh for this item */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    TSoftObjectPtr<USkeletalMesh> DisplayMesh1P;

    /* Third person display mesh for this item */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|Third Person")

    TSoftObjectPtr<USkeletalMesh> DisplayMesh3P;

    /* First person gun attachments */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    TArray<FWeaponAttachment> Attachments;

    /* Where to attach the 1st person weapon on the skeleton */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    FName SocketAttach1P;

    /* Where to attach the 3rd person weapon on the skeleton */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|Third Person")

    FName SocketAttach3P;

    //The scale to Mesh3P this weapon will apply.

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|Third Person")

    FVector Mesh3PScale = FVector(1.f, 1.f, 1.f);

    /* First person animation class for this weapon */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    TSubclassOf<UAnimInstance> AnimationClass1P;

    /* First Person AnimMontage to play each time we fire */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* FireAnimation1P;

    /* Third Person AnimMontage representing the player's aim down sights fire */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* TightAimFireAnimation1P;

    /* First Person Montage representing the player's reload. Looping animation for single reload */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* ReloadAnimation1P;

    /* For single reload, this would be the animation to start */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* ReloadAnimation1PStart;

    /* For single reload, this would be the ending animation (shotgun pump) */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* ReloadAnimation1PEnd;

    /* Skips ths "SwapWeaponIn" animation, playing the fire immediately instead */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    bool bPlayFireAnimationImmediately = false;

    /* First Person Montage representing the player's swap-in motion */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* SwapWeaponIn1P;

    /* First Person Montage representing the player's swap-out motion */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|First Person")

    UAnimMontage* SwapWeaponOut1P;

    /* First person weapon animation class */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    TSubclassOf<UAnimInstance> WeaponAnimationClass;

    /* Third person weapon animation class */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    TSubclassOf<UAnimInstance> WeaponAnimationClass3P;

    /* Animation to play on the weapon each time we fire. This applies to 1p*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponFireAnimation;

    /* Animation to play on the weapon each time we fire. This applies to 3p*/

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponFireAnimation3P;

    /* First Person Montage representing the weapon's reload */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponReloadAnimation1P;

    /* For single reload, this would be the animation to start it + 1 loop */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponReloadAnimation1PStart;

    /* For single reload, this would be the ending animation + 1 loop */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponReloadAnimation1PEnd;

    /* Animation to play while equipping the weapon */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponEquipAnimation;

    /* Third person display mesh for this weapon */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Third Person")

    TSubclassOf<UAnimInstance> AnimationClass3P;

    /* Third Person AnimMontage to play each time we fire */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Third Person")

    UAnimMontage* FireAnimation3P;

    /* Third Person AnimMontage representing the player's aim down sights fire */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Third Person")

    UAnimMontage* TightAimFireAnimation3P;

    /* Third Person AnimMontage representing the player's reload */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Third Person")

    UAnimMontage* ReloadAnimation3P;

    /* Third Person Montage representing the player's swap-in motion */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Third Person")

    UAnimMontage* SwapWeaponIn3P;

    /* Third Person Montage representing the player's swap-out motion */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Third Person")

    UAnimMontage* SwapWeaponOut3P;

    /* Third Person Montage representing the weapon's reload */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Animation|Weapon")

    UAnimMontage* WeaponReloadAnimation3P;

    /* Sound to play on the first shot */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    USoundBase* FireSingleSound;

    /* Sound to play on every shot after the first shot if the trigger is held and weapon mode is auto. Depending on the weapon firerate, this method could cause inconsistent timings due to frame rate. Use FireAutoLoopSound instead. This could be useful for playing nonspecific sounds such as weapon tails in tandem with a loop. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    USoundBase* FireAutoSound;

    /* Sound to loop while the automatic weapon is firing. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    USoundBase* FireAutoLoopSound;

    /* Sound to play when the weapon has finished firing. This cleans up a loop nicely by giving it a tail. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    USoundBase* FireAutoLoopTail;

    /* Some weapons give a dry-fire style "click" when empty. This sound will play when the last bullet is consumed. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    USoundBase* WeaponMagEmptySound;

    /* The base clip has how many shots per second? This allows us to mathematically sync the clip to the gun's fire rate. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    float AutoFireClipShotsPerSec = 10.0f;

    /* This prevents burst weapons from playing a sound per shot and will only play a sound on the first shot. This is useful if your burst is baked into a single sound. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    bool bPlaySingleSoundForBursts = true;

    /* For all other clients hearing this from a distance - Will play the looping sound and stop the looping sound when the player presses and releases the fire button. If false, the looping sound will start on the second shot (allowing FireSingleSound to play first) */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    bool bStartLoopingSoundOnFirstShotRemote = true;

    /* For the local client - Will play the looping sound and stop the looping sound when the player presses and releases the fire button. If false, the looping sound will start on the second shot (allowing FireSingleSound to play first) */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    bool bStartLoopingSoundOnFirstShotLocal = true;

    /* Will automatically adjust the pitch of the looping sound to match the fire rate. Expects the source audio to have a fire rate of 10 rounds per second. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Sound")

    bool bSyncLoopingSoundToFireRate = true;

    //The scale to Mesh1P this weapon will apply.

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    FVector Mesh1PScale = FVector(1.f, 1.f, 1.f);

    //For easy tweaking of scale without messing with offset data. Will recompute offsets automatically.

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    float Mesh1PScaleMultiplier = 2.0f;

    /* Every gun needs to be held a bit differently so it looks like its pointing at the center of the screen. Tweaks go here. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    FVector RelativePositionOffset = FVector(30.0f, -22.0f, -152.0f);

    /* Every gun needs to be rotated to look like its pointing the center of the screen. Tweaks go here. */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Mesh|First Person")

    FRotator RelativeRotationOffset = FRotator(16.0f, 0.0f, 10.0f);

    // Name of this weapon.

    UPROPERTY(EditDefaultsOnly, Category = "UI")

    FText WeaponName;

    UPROPERTY(EditDefaultsOnly, Category = "UI")

    FText WeaponDescription;

    /* Multiplier that allows a designer to tune how much spread a reticle has (so long as its hooked up in the reticle)*/

    UPROPERTY(EditDefaultsOnly, Category = "Weapon")

    float ReticleSpreadMultiplier = 1.f;

    // Name of this weapon.

    UPROPERTY(EditDefaultsOnly, Category = "UI")

    TSubclassOf<UReticleWidget> ReticleWidget = NULL;

    /* Ammo counter widget */

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "UI")

    TSubclassOf<UUserWidget> AmmoCounterWidget = NULL;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "UI")

    FName AmmoCounterSocket = "CounterAttachmentPoint";

    // Weapon icon used for generic display purposes

    UPROPERTY(EditDefaultsOnly, Category = "UI")

    TAssetPtr<UTexture2D> WeaponIcon = NULL;

    // Weapon icon used for the kill feed.

    UPROPERTY(EditDefaultsOnly, Category = "UI")

    TAssetPtr<UTexture2D> WeaponKillFeedIcon = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Weapon | Equip")

    TSubclassOf <class UAfflictionInstance > WeaponAffliction = NULL;

    UPROPERTY(EditDefaultsOnly, Category = "Loadout")

    TArray<EPerkType> PerkSlots = { EPerkType::WEAPON,EPerkType::WEAPON,EPerkType::WEAPON };

    UPROPERTY(EditDefaultsOnly, Category = "Weapon")

    bool bAppliesUltimateDamageMultiplier = false;


    UPROPERTY(EditDefaultsOnly, Category = "Display")

    FName DisplaySocketName = "DisplaySocket";

    UPROPERTY(EditDefaultsOnly, Category = "Display")

    float DisplayFocalDistance = -1.0f;

    UPROPERTY(ReplicatedUsing = OnRep_WeaponState)

    EWeaponState WeaponState = EWeaponState::Down;

    UPROPERTY(ReplicatedUsing = OnRep_ParentWeapon)

    UWeaponInstance* ParentWeapon = NULL;

    UPROPERTY(ReplicatedUsing = OnRep_FireCounter)

    uint8 FireCounter = 0;

    UPROPERTY(ReplicatedUsing = OnRep_HoldingFire)

    bool bHoldingFire = false;

    UPROPERTY(ReplicatedUsing = OnRep_ChargeIsReady)

    bool bCharging = false;

    UPROPERTY(ReplicatedUsing = OnRep_IsOverheating)

    bool bIsOverheating = false;

    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_TightAiming)

    bool bTightAiming = false;

    UPROPERTY(Replicated)

    UWeaponInstance* ChildWeapon = nullptr;


    UPROPERTY()

    float TotalAmmo = 0.f;

    /* How much ammo we have in our current mag */

    float MagazineAmmo = 0.f;

    UPROPERTY()

    bool bAwaitingUnEquip = false;

    UPROPERTY()

    AProjectXCharacter* OwningCharacter = NULL;

    UPROPERTY()

    UWeaponComponent* OwningComponent = NULL;

    UPROPERTY()

    TMap<uint8, UMaterialInstance*> WeaponSkin;

    UPROPERTY(BlueprintReadOnly)

    UParticleSystem* WeaponSkinParticle = nullptr;


    TWeakObjectPtr<class ADesignatorMarker> DesignatorMarker = NULL;

    float ChargeValue;

    bool bValidDesignator = false;

    bool bInitialized = false;

    float GlobalAmmoRestockMultiplier = 1.0f;


protected:

        float WeaponEquippedTimestamp = 0.f;

private:

    friend class UWeaponComponent;

    friend class UChildWeaponInstanceShotgunMortar;

    friend class UWeaponInstanceMeleeDash;

    friend class UWeaponInstancePowerSword;


    void EndLoopingFireSound();


    UPROPERTY()

    mutable UGlobalAmmoComponent* GlobalAmmoComponent = NULL;

    UPROPERTY()

    TMap<UPhysicalMaterial*, FImpactEffects> ImpactEffectMap;


    float CurrentHeat = 0.f;

    uint8 ClientFireCounter = 0;

    int32 ChargingInterpolatorId;

    uint32 TightAimInterpolationID = INDEX_NONE;

    float LastReloadTime = 0.0f;

    float FireRateInterp = 0.0f;

    int32 FireRateRampInterpID = INDEX_NONE;

    float LastWeaponFireTime = 0.0f;

    float AutoFireAudioDelay = 0.0f;

    float LastDelayedPlayTime = 0.0f;

    UUserWidget* CreatedTightAimWidget = nullptr; //Store scope widget for destruction when tight aim is completed

    uint32 OffsetShiftInterpolationID = INDEX_NONE;


    UPROPERTY()

    UAudioComponent* ActiveLoopingAudioComponent = nullptr;


    FTimerHandle FireTimer = FTimerHandle();

    FTimerHandle WeaponMovementTimer = FTimerHandle();

    FTimerHandle WaitingForHeatCoolDownStartTimer = FTimerHandle();

    FTimerHandle TriggerReleasedHeatCoolDownTimer = FTimerHandle();

    FTimerHandle HeatCoolDownTimer = FTimerHandle();

    FTimerHandle ReloadTimer = FTimerHandle();

    FTimerHandle EquipTimer = FTimerHandle();

    FTimerHandle UnEquipTimer = FTimerHandle();

    FTimerHandle CoolDownTimer = FTimerHandle();

    FTimerHandle FireCounterTimer = FTimerHandle();

    FTimerHandle ActiveTimer = FTimerHandle();

};

CosmeticAssetBase.h

EPerkType
EPerkType
Definition: CosmeticAssetBase.h:61

EPerkType::WEAPON
@ WEAPON

ECosmeticType::KeyChain
@ KeyChain

ECosmeticType::Loadout
@ Loadout

EItemType::Weapon
@ Weapon

EEquipType::Perk
@ Perk

ELogLevel::Error
@ Error

ETurretState::Firing
@ Firing

EInputCategory::Movement
@ Movement

EManagedActorState::On
@ On

ObjectInfoInterface.h

EXPEventType::Assist
@ Assist

EStatClassifier::Class
@ Class

PlayerStructs.h

ECustomMovementType::Dash
@ Dash
Definition: DashComponent.cpp:90

ECustomMovementType::Hookshot
@ Hookshot

ECustomMovementType::OmniDash
@ OmniDash

EStimulusType::None
@ None

EDeathEffectBodyPartsType::Hit
@ Hit

ESortParameter::Mode
@ Mode

EAssaultRole::NONE
@ NONE

EMessageType::Server
@ Server

EObjectiveState::Complete
@ Complete

EAccelerationDirection::Down
@ Down

ReactsToMatchEvents.h

EWeaponError
EWeaponError
Definition: WeaponComponent.h:15

EWeaponError::Overheated
@ Overheated

EWeaponState
EWeaponState
Definition: WeaponInstance.h:132

EWeaponState::Down
@ Down

EWeaponState::Reloading
@ Reloading

EWeaponState::Firing
@ Firing

EWeaponState::Overheated
@ Overheated

EWeaponState::None
@ None

EWeaponState::WaitingToUnequip
@ WaitingToUnequip

EWeaponState::Custom
@ Custom

EWeaponState::Equipping
@ Equipping

EWeaponState::Ready
@ Ready

EWeaponState::UnEquipping
@ UnEquipping

EFireType
EFireType
Definition: WeaponInstance.h:157

EFireType::SemiAutomatic
@ SemiAutomatic

EFireType::Automatic
@ Automatic

EFireType::Charged
@ Charged

EDesignatorTeamView
EDesignatorTeamView
Definition: WeaponInstance.h:189

EDesignatorTeamView::Allies
@ Allies

EDesignatorTeamView::User
@ User

EDesignatorTeamView::Enemies
@ Enemies

EDesignatorTeamView::Everyone
@ Everyone

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FChargeEventSignature, float, TotalTime, float, TimeElapsed)

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FWeaponActiveEvent, bool, bActive)

ECompressedFlags
ECompressedFlags
Definition: WeaponInstance.h:51

ECompressedFlags::FLAG_Reserved_2
@ FLAG_Reserved_2

ECompressedFlags::FLAG_WantsToCrouch
@ FLAG_WantsToCrouch

ECompressedFlags::Jetpack
@ Jetpack

ECompressedFlags::FLAG_Reserved_1
@ FLAG_Reserved_1

ECompressedFlags::FLAG_JumpPressed
@ FLAG_JumpPressed

EReloadType
EReloadType
Definition: WeaponInstance.h:165

EReloadType::Individual
@ Individual

EReloadType::Magazine
@ Magazine

ECoolDownTrigger
ECoolDownTrigger
Definition: WeaponInstance.h:180

ECoolDownTrigger::ActiveTime
@ ActiveTime

ECoolDownTrigger::Unequip
@ Unequip

ECoolDownTrigger::Fire
@ Fire

ECoolDownType
ECoolDownType
Definition: WeaponInstance.h:173

ECoolDownType::CoolDown
@ CoolDown

ECoolDownType::Ammo
@ Ammo

DECLARE_DYNAMIC_MULTICAST_DELEGATE
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWeaponCancelledEvent)

EFireMode
EFireMode
Definition: WeaponInstance.h:147

EFireMode::Tertiary
@ Tertiary

EFireMode::Primary
@ Primary

EFireMode::Secondary
@ Secondary

EToggleTrigger::EquipComplete
@ EquipComplete

ADesignatorMarker
Definition: DesignatorMarker.h:13

AProjectXCharacter
Definition: ProjectXCharacter.h:128

AProjectXHUD
Definition: ProjectXHUD.h:20

AProjectXPlayerController
Definition: ProjectXPlayerController.h:83

IObjectInfoInterface
Definition: ObjectInfoInterface.h:16

IReactsToMatchEvents
Definition: ReactsToMatchEvents.h:16

UChildWeaponInstanceShotgunMortar
Definition: ChildWeaponInstanceShotgunMortar.h:14

UMeleeDashMovementComponent
Definition: MeleeDashMovementComponent.h:13

UReticleWidget
Definition: ReticleWidget.h:13

UWeaponInstance
Definition: WeaponInstance.h:220

UWeaponInstance::BlocksWeaponComponentWhileEquipped
virtual bool BlocksWeaponComponentWhileEquipped() const
Definition: WeaponInstance.h:463

UWeaponInstance::UpdateOwningCharacter
virtual void UpdateOwningCharacter(AProjectXCharacter *NewCharacter)
Definition: WeaponInstance.h:236

UWeaponInstance::CancelsCurrentEquippedWeaponActionsWhenEquipped
virtual bool CancelsCurrentEquippedWeaponActionsWhenEquipped() const
Definition: WeaponInstance.h:464

UWeaponInstance::GetWeaponMovementAfflictionClass
TSubclassOf< class UAfflictionInstance > GetWeaponMovementAfflictionClass() const
Definition: WeaponInstance.h:473

UWeaponInstance::GetWeaponMovementFlag
ECompressedFlags GetWeaponMovementFlag() const
Definition: WeaponInstance.h:481

UWeaponInstance::GetMeshAttachments
TArray< FWeaponAttachment > & GetMeshAttachments()
Definition: WeaponInstance.h:482

UWeaponInstance::IsChildWeapon
FORCEINLINE bool IsChildWeapon() const
Definition: WeaponInstance.h:310

UWeaponInstance::IsAlmostReady
FORCEINLINE bool IsAlmostReady() const
Definition: WeaponInstance.h:364

UWeaponInstance::GetWeaponMovementVelocity
float GetWeaponMovementVelocity() const
Definition: WeaponInstance.h:472

UWeaponInstance::BlocksUnmanagedWeapons
virtual bool BlocksUnmanagedWeapons() const
Definition: WeaponInstance.h:465

UWeaponInstance::GetWeaponAffliction
TSubclassOf< class UAfflictionInstance > GetWeaponAffliction() const
Definition: WeaponInstance.h:475

UWeaponInstance::GetObjectDescription
virtual const FText & GetObjectDescription() const
Definition: WeaponInstance.h:455

UWeaponInstance::GetSocket3P
FORCEINLINE FName GetSocket3P() const
Definition: WeaponInstance.h:366

UWeaponInstance::GetSocket1P
FORCEINLINE FName GetSocket1P() const
Definition: WeaponInstance.h:365

UWeaponInstance::GetReticleSpreadMultiplier
virtual float GetReticleSpreadMultiplier() const
Definition: WeaponInstance.h:458

UWeaponInstance::IsManagedByWeaponComponent
virtual bool IsManagedByWeaponComponent() const
Definition: WeaponInstance.h:462

UWeaponInstanceMeleeDash
Definition: WeaponInstanceMeleeDash.h:13

UWeaponInstancePowerSword
Definition: WeaponInstancePowerSword.h:18

FFireModeToFloat
Definition: WeaponInstance.h:198

FImpactEffects
Definition: WeaponInstance.h:117

FImpactTableRow
Definition: WeaponInstance.h:81

FImpactTableRow::Material
class UPhysicalMaterial * Material
Definition: WeaponInstance.h:85

FImpactTableRow::Sound
TSoftObjectPtr< class USoundBase > Sound
Definition: WeaponInstance.h:91

FMontageList
Definition: WeaponInstance.h:41

FWeaponAttachment
Definition: WeaponInstance.h:66