#pragma once#include "CoreMinimal.h"#include "WW3AmmoType.h"#include "Components/ActorComponent.h"#include "WW3Projectile.h"#include "WW3AmmoTypeVehicle.h"#include "WW3AmmoTypeCharacterMissile.h"#include "WW3FireType.generated.h"#define PROJECTILES_ARRAY_SIZE 60class UWW3FireTypeManager;UENUM()enum class EWW3FireTypeState : uint8{None,Idle,Firing,Reloading,Busy,MAX};UENUM()enum class EWW3WeaponReloadState : uint8{NoneUMETA(Hidden),ReloadStartUMETA(Hidden),Filler1,Filler2,Filler3,Filler4,//Hides magazine on reload cancelFillerHideMag1,//Hides magazine on reload cancelFillerHideMag2,//Hides magazine on reload cancelFillerHideMag3,//Hides magazine on reload cancelFillerHideMag4,//Hides magazine on reload cancel, Doesn't unhide after resumeKeepHidenMag1,//Hides magazine on reload cancel, Doesn't unhide after resumeKeepHidenMag2,//Hides magazine on reload cancel, Doesn't unhide after resumeKeepHidenMag3,//Hides magazine on reload cancel, Doesn't unhide after resumeKeepHidenMag4,BoltReleasing,ChamberEmptying,BoltPull,CoverPull,//Unlocks boltBoltLock,//Unlocks boltCoverLock,ReloadUnequipMagazine,SwitchMagazine,//Hides magazine on reload cancelWaitingMagazine,//Hides magazine on reload cancelEquipMagazine,//Refills clip ammoAttachingMagazine,RELOADFINISHEDUMETA(Hidden),//Refills clip ammoLoopShell,//Unlocks bolt and finishes reloadBoltReloadEnd,//Refills clip ammo and finishes reloadRefillReloadEnd,//Finishes reloadReloadEnd,MAXUMETA(Hidden)};//For UKM ://-bolt pull and cover unlock//- detach magazine//- insert magazine//- cover lock//For M4, MPX ://-detach magazine//- insert magazine//- additional action(like bolt release)//For G29 ://-bolt pull//- detach magazine//- insert magazine//- bolt lockUENUM()enum class EWW3MagazineSkelMeshType : uint8{NoneUMETA(Hidden),PrimarySkelMesh,SecondarySkelMesh,EmptySkelMesh,MAXUMETA(Hidden)};struct FWW3CollectionOfActorsBeignHit{TArray<TWeakObjectPtr<AActor>> HitActors;int32 IndexInArray = -1;void Clear();};#define FIRE_RATE_TRESHOLD_PERCENT 0.5fDECLARE_MULTICAST_DELEGATE(FVoidDelegate);DECLARE_MULTICAST_DELEGATE_OneParam(FVoidFireTypeDelegate, UWW3FireType*);DECLARE_MULTICAST_DELEGATE_OneParam(FVoidBoolDelegate, bool);DECLARE_MULTICAST_DELEGATE_OneParam(FVoidIntDelegate, int32);DECLARE_MULTICAST_DELEGATE_OneParam(FOnCreateProjectile, AWW3Projectile*);DECLARE_MULTICAST_DELEGATE_OneParam(FAmmoTypeTSubclasDelegate, TSubclassOf<UWW3AmmoType>);DECLARE_MULTICAST_DELEGATE_ThreeParams(FPlayShootEffectsDelegate, bool, const FVector&, const FVector&);extern TArray<TSharedPtr<FWW3CollectionOfActorsBeignHit>> g_PoolOfFreeCollectionsOfActorsBeignHit;UCLASS(ClassGroup = (Custom), Blueprintable , meta = (BlueprintSpawnableComponent))class UWW3FireType : public UActorComponent{GENERATED_BODY()public:/** DELEGATES *//** [ALL] Called form OnFireTypeInitialized() after component initialization. */FVoidFireTypeDelegate DelegateOnFireTypeInitialized;/** [ALL] Called after shooting on all clients. Should create effect here */FPlayShootEffectsDelegate EventOnPlayShootEffects;/** [ALL] Called each time shot is fired when shooting mode = Single */FVoidDelegate EventOnFireShotInSingleMode;/** [ALL] Called when Fire Type start firing in Auto Mode */FVoidDelegate EventOnStartFiringInAutoMode;/** [ALL] Called when Fire Type stop firing in Auto Mode */FVoidDelegate EventOnStopFiringInAutoMode;/** [OWNER + SERVER] Called after single shoot. Bool param is for bIsBallisticProjectile */FVoidBoolDelegate DelegateOnFireSingleShot; /** bool = bIsBallisticProjectile *//** [OWNER + SERVER] Called when projectile was created. Reference to projectile passed via variable. */FOnCreateProjectile EventOnCreateProjectile;/** [OWNER + SERVER] Called after shooting mode changed (ShootingMode is Auto, Single, Burst ...) */FVoidDelegate EventOnShootingModeChanged;/** [OWNER + SERVER] Called each time ammo amount in clip change */FVoidIntDelegate EventOnAmmoAmountChanged;/** [OWNER + SERVER] Called each time ammo type in clip change */FVoidDelegate EventOnAmmoTypeInClipChanged;/** [OWNER + SERVER] CalledEachtime reload state ended */FVoidDelegate EventOnReloadingStateEnded;FVoidDelegate EventOnFireTypeUIAmountChanged;/** [ALL] Called when ammo type in clip changed. Pass new type in parameter*/FAmmoTypeTSubclasDelegate EventOnAmmoTypeInClipChangedTypeInParameter;FVoidDelegate EventOnSoundsDataLoaded;/** Store reload state. Start reload animation from different section based on CurrentReloadState */EWW3WeaponReloadState CurrentReloadState;/** Last reload type. Used when we resume reload. Clears after reload is finished. */EWW3ReloadType LastReloadType;/** Ammo amount that should be loaded with looped reload animation (load single ammo) */uint8 MissingAmmoToLoad;/** Ammo amount that should be unloaded with looped change ammo type animation (load single ammo) */uint8 AmmoToUnload;/** Time of last reload time */float LastReloadTime;/** Time of last pose change time */float LastPoseChangeTime;bool bIsInitialized;UPROPERTY(Transient)const class UWW3FireTypeSounds* SoundsData;protected:int32 PrevClientRandomStreamSeed = 0;//uint16 PrevClientShootTimestamp;float PrevServerShootTimestamp;float PrevClientShootTimestamp;/** Percentage of recoil compensation (represented by values in range 0.0 - 1.0) */float SpreadCompensation = 0.0f;/** On StartFire() store here postion form shooting */FVector_NetQuantize ShootPosition;/** On StartFire() store here direction form shooting */FVector_NetQuantizeNormal ShootDirection;/** Current state of this fire type */EWW3FireTypeState CurrentState;/** Current state of this fire type */EWW3FireTypeState LastState;/** Current shooting mode of this FireType (e.g. Auto, Single, Burst) */UPROPERTY(ReplicatedUsing = OnRep_CurrentShootingMode)EWW3ShootingMode CurrentShootingMode;/** FireType wants to fire */uint8 bWantsToFire : 1;/** FireType wants to fire */uint8 bWantsToReload : 1;/** [REPLICATED SKIP OWNER] Is weapon shooting right now */UPROPERTY(ReplicatedUsing = OnRep_IsFiring)uint8 bIsFiring : 1;uint8 bIsInitializetionSynchronizedToVehicle : 1;/** This fire type manager. Its an owner of this FireType. Since both are ActorComponents the FireTypeManager pass reference in InitializeFireType function */UPROPERTY(Transient)class UWW3FireTypeManager* ThisFireTypeManager;/** Pointer to FireTypeRow in FireTypeTable. This row contain all the variables and settings. */FWW3WeaponFireTypeRow* FireTypeRow = nullptr;/** Pointer to FWW3BallisticBehaviour in BallisticProjectilesBehaviourTable. */FWW3BallisticBehaviour* CurrentAmmoBallisticBehaviour = nullptr;/** Current ammo inside clip. */UPROPERTY(Transient/*, ReplicatedUsing = OnRep_CurrentAmmoInClip*/)int16 CurrentAmmoInClip;/** Current ammo that should be resented on ui*/int16 CurrentAmmoInClipUiVisible;/** Current ammo inside clip with second ammo. */UPROPERTY(Transient)int16 CurrentAmmoTypeAmountInClip[2];UPROPERTY(Transient)EWW3VehicleAmmoSlot CurrentVehicleAmmoSlotInClip = EWW3VehicleAmmoSlot::None;/** Override of default clip size from DataRow */int32 ClipSizeOverride;uint8 BulletCounter = 0;bool bWantsToFireWhileInBurst = false;uint8 LastBulletCounter = 0;/** Timer for handling automated fire */FTimerHandle AutoFireTimerHandle_T;/** Timer for for handling next shoot on server when client send shoot request too early */FTimerHandle ServerNextShotTimerHandle_T;/** This shot random stream for spread (Generated form Time Stamp) */FRandomStream SpreadRandomStream;/** [REPLICATED TO OWNER] Currently loaded Ammo Type in clip */UPROPERTY(Transient, ReplicatedUsing = OnRep_CurrentAmmoTypeInClip)TSubclassOf<UWW3AmmoType> CurrentAmmoTypeInClip;/** Ammo Type next to load*/UPROPERTY(Transient)TSubclassOf<UWW3AmmoType> AmmoTypePendingLoad;TArray<EWW3ShootingMode> AvaliableShootingModes;UPROPERTY(Transient)mutable USceneComponent* MuzzleOwnerComponent;UPROPERTY(Transient)USceneComponent* ShellOwnerComponent;/** spawned component for muzzle FX */UPROPERTY(EditAnywhere, Transient)UParticleSystemComponent* MuzzlePSC;/** spawned component for second muzzle FX (Needed for split screen) */UPROPERTY(EditAnywhere, Transient)UParticleSystemComponent* MuzzlePSCSecondary;/** spawned component for falling shells FX */UPROPERTY(EditAnywhere, Transient)UParticleSystemComponent* FallingShellsPSC;/** spawned component for aftershot FX */UPROPERTY(EditAnywhere, Transient)UParticleSystemComponent* SmokePSC = nullptr;/** spawned component for aftershot for long serie FX */UPROPERTY(EditAnywhere, Transient)UParticleSystemComponent* HeavySmokePSC = nullptr;/** time of last successful weapon fire */float LastFireTime;/** current spread from continuous firing */float CurrentFiringSpread;//uint8 NextProjectileIndex;uint32 NextProjectileID;//UPROPERTY(Transient)//TArray<AWW3Projectile*> StoredProjectiles;UPROPERTY(Transient)TMap<uint32, AWW3Projectile*> StoredProjectilesMap;FTimerHandle FinishShootEffects_TimerHandle;FTimerHandle FinishMuzzleSmokeEffects_TimerHandle;TSharedPtr<FWW3LoadingAssetHandle> SoundsLoadingHandle;TSharedPtr<FWW3LoadingAssetHandle> FPPMuzzleLoadingHandle;TSharedPtr<FWW3LoadingAssetHandle> TPPMuzzleLoadingHandle;TSharedPtr<FWW3LoadingAssetHandle> ShellsLoadingHandle;TSharedPtr<FWW3LoadingAssetHandle> FPPSmokeLoadingHandle;TSharedPtr<FWW3LoadingAssetHandle> FPPHeavySmokeLoadingHandle;FDelegateHandle OnFireTypeShootInSingleMode;FDelegateHandle OnFireTypeStartFiringInAutoMode;FDelegateHandle OnFireTypeStopFiringInAutoMode;FDelegateHandle OnShootingModeChangedInFireType;FDelegateHandle OnAmmoAmountChanged;UPROPERTY(EditAnywhere)bool SwitchWhenAdded = false;bool bSphereMaskEnabled = false;TArray<TSharedPtr<FWW3CollectionOfActorsBeignHit>> PerShotActorsBeignHit;// Vehicle OnlyUPROPERTY(Transient, Replicated)bool bVehicleChangingPose = false;public:FDelegateHandle OnFireTypeShoot;UWW3FireType();// +++ INITIALIZATION +++virtual void BeginPlay() override;virtual void BeginDestroy() override;virtual bool FindFireTypeManager();FORCEINLINE FRandomStream& GetSpreadRandomStream() { return SpreadRandomStream; }FORCEINLINE int32 GetPrevSpreadRandomStreamSeed() const { return PrevClientRandomStreamSeed; }/** [ALL] First called, initialize this fire type here */void InitializeFireType();virtual void InitializeOnAttachmentSynchronized();void InitializeRow();void InitializeFireTypeManagerDelegates(UWW3FireTypeManager* Manager);/** Reset all variables to default values */void ResetToDefault();/** Bring this fire type to default values */void RestoreLocally();FORCEINLINE uint32 GetNextProjectileID() const { return NextProjectileID; }void SetNextProjectileID(uint32 const InNextProjectileID);void SetCurrentAmmoTypeAndAmmoAmount(TSubclassOf<UWW3AmmoType> InAmmoType, int InAmmoAmount);/** Function used to validate ammo in clip after initialization on server */UFUNCTION(Reliable, Client, Category = "Network")void Client_CheckLoadedAmmoInClip(int32 ServerAmmoInClip);/** Function used to send ammo amount to client after reload on server */UFUNCTION(Reliable, Client, Category = "Network")void Client_SetAmmoAfterReloadOnServer(int32 ServerAmmoInClip);virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;EWW3FireTypeState GetCurrentState() const { return CurrentState; }bool GetSwitchWhenAdded() const;// +++ SHOOTING +++/** [OWNER + SERVER] First called */void OnWantsToFire();/** [OWNER + SERVER] When wants to stop fire */void OnWantsToStopFire(bool bForced = false);/** [SERVER] Pass information about client wantsToFire flag */UFUNCTION(Reliable, Server , WithValidation , Category = "Networking")void Server_OnClientWantsToFire();/** [SERVER] Pass information about client wantsToFire flag */UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_OnClientWantsToStopFire();/** [OWNER] Called only on client owning weapon. When automatic fire is on, call this function in timer */void StartFire();/** Broadcasts OnPostShoot events existing in UWW3GameEventsContainer **/void BroadcastOnPostShootEvent(AWW3PlayerController* InShooterPlayerController, AWW3PlayerController* InMyPlayerController);// +++ RELOADING/** Load ammo to clip - USE THIS TO LOAD UP AMMO TO MAGAZINE*/void LoadAmmoToClip(int32 AmmoAmountToLoad);/** Unload ammo from clip into a backpack */void UnloadAmmoFromClip(int32 AmmoAmountToUnload);/** Clear [Destroy] ammmo that is currently in clip */void ClearAmmoFromClip();// Reset ammo in clip to default valuevoid ResetAmmoInClip();// +++ INPUTS FROM CLIENT +++void StartReload();void InterruptReload();void CompleteReload();void ChangeShootingMode();void ChangeToPreviousShootingMode();void ChangeShootingMode(EWW3ShootingMode NewShootingMode);FORCEINLINE uint32 GetShootingModesNumber() const{return AvaliableShootingModes.Num();}// +++ VEHICLE ONLY START +++void StartVehicleEnterReadyPose();void CompleteVehicleEnterReadyPose();void StartVehicleEnterIdlePose();void CompleteVehicleEnterIdlePose();/** Return pose change progress in percent. */float GetPoseChangeProgressInPercent();float GetPoseChangeProgressInPercentForNextTick();FORCEINLINE bool GetVehicleChangingPose() const{return bVehicleChangingPose;}void DelayedChangeVehiclePoseToIdle();void DelayedChangeVehiclePoseToReady();// +++ VEHICLE ONLY END +++/** [SERVER] Pass information about client wantsToFire flag */UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_OnClientChangeShootingMode(EWW3ShootingMode ClientShootingMode);/** [ALL] Called on projectile shoot e.g. Muzzle effect */void PlayShootEffects(bool bInWorldLocationAvailable = false, const FVector& InWorldLocation = FVector::ZeroVector, const FVector& InShootDirection = FVector::ForwardVector);void StartShootEffects();void StopShootEffects();/** +++ SETTERS AND GETTERS +++ *//** Set Ammo Type That will load up in next reload and will replace Current Ammo Type in clip */void SetAmmoTypePendingLoad(TSubclassOf<UWW3AmmoType> NewAmmoPendingLoad);/** Set clip size overridden by attachment or something else and put missing ammo inside the clip*/void SetClipSizeOverride(int32 InOverrideClipSize, bool UpdateAmmoInClip = true);void UnloadMagazine();void SetMuzzlePSC(UParticleSystemComponent* NewParticleSystem);void SetMuzzlePSCSecondary(UParticleSystemComponent* NewParticleSystem);void SetFallingShellsPSC(UParticleSystemComponent* NewParticleSystem);void SetSmokePSC(UParticleSystemComponent* NewParticleSystem);void SetHeavySmokePSC(UParticleSystemComponent* NewParticleSystem);/** [ALL] Bind projectile to interested objects*/void BindCreatedProjectile(AWW3Projectile* CreatedProjectile);void OnProjectileHit(uint32 ProjectileID, FVector const& InImpactPoint, AActor* HitActor, UPrimitiveComponent* HitComponent, const FName& HitBone, EWW3ProjectileBehavior HitBehaviour, float PenetrationAlpha);void CreateMuzzleFPP();void CreateMuzzleTPP();void CreateShellPSC();void UpdateShellPSCEmitter();bool ActivateShellPSC();void CreateSmokeFPP();void CreateHeavySmokeFPP();FVector_NetQuantize GetShootPosition() const;FVector_NetQuantizeNormal GetShootDirection() const;/** Return my pawn casted to AWW3Character (Reference taken from FireTypeManager) */APawn* GetMyPawn() const;UWW3FireTypeManager* GetFireTypeManager();/** Returns current ammo type in clip */TSubclassOf<UWW3AmmoType> GetCurrentAmmoTypeInClip() const;/** Returns ammo type that is pending load */TSubclassOf<UWW3AmmoType> GetAmmoTypePendingLoad() const;/** Get ammo type used by this firetype */TSubclassOf<UWW3AmmoType> GetAllowedAmmoType();/** Get damage type of this fire type */TSubclassOf<class UDamageType> GetPenetratingDamageType();/** Get damage type of this fire type */TSubclassOf<class UDamageType> GetExplosiveDamageType();TSubclassOf<UCameraShake> GetFireCameraShake();FORCEINLINE bool GetAdditionalFppFireCameraShakes(TArray<TSubclassOf<UCameraShake>>& OutShakes) const;/** GetCurrentAmmmoInClip */int32 GetCurrentAmmoAmountInClip() const;int32 GetCurrentAmmoAmountInClipForUi() const;int32 GetCurrentAmmoTypeAmountInClip();void SetCurrentAmmoTypeAmountInClip(int16 Amount, EWW3VehicleAmmoSlot Type);/** Return missing ammo amount in clip */int32 GetMissingAmmoAmountInClip();/** Return clip size of this fire type */int32 GetClipSize();/** Return maximum (If weapon can have ammo in chamber this is ClipSize+1) ammo capacity*/int32 GetMaximalClipSize();/** Get bullets fired in current series */uint8 GetBulletCounter() const;/** Is clip in this weapon empty */bool IsClipEmpty();/** Should try deal damage to Actor */bool ShouldDealDamage(AActor* TestActor) const;/** Can deal damage to actor */bool CanDealDamage(AActor* TestActor) const;/** Can this FireType shoot at this moment */bool CanFire(bool bIsClient) const;bool IsAmmoValid() const;/** Can this fire type play shell particle after shoot (for example for shotgun shell should spawn while reload after shoot) */bool CanPlayShellPSCAfterShoot() const;/** Is this fire type in firing state */bool IsFiringInAutoMode() const;/** Is this fire type in reloading state */bool IsReloading() const;/** Is this fire type reload canceled in middle */bool IsReloadInProgress() const;EWW3FireTypeReloadType GetReloadType() const;/** Is owner targeting? */bool IsTargeting() const;/** Check if weapons is shooting single bluets */bool IsSingleShootingMode() const;/** Check if weapons is in burst shooting mode */bool IsBurstShootingMode() const;bool IsBurstCooldownReady() const;/** Can shoot if shooting mode isn't single */bool CanShootInNonSingleMode() const;/** If time since last shot is greater than time between shots */bool IsFireCooldownReady() const;/** Is this fire type loading single ammo to clip while reloading (for example shotguns) */bool IsLoadingSingleAmmo() const;bool ShouldLoadAudioBanks() const;bool IsFPPSoundBankLoaded() const;bool IsTPPSoundBankLoaded() const;/** Get damage multilayer for bone hit, if pawn */float DamageMultiplierIfPawn(const FHitResult& Impact);/** Get damage form damage curve */float GetDamageFromRangeCurve(const FHitResult& Impact);/** Get damage form damage curve */virtual float GetDamageFromRangeCurve(float Distance);/** Returns time in seconds between shots */float GetTimeBetweenShots() const;/** Return cooldown progress between shots in percent. */float GetCooldownBetweenShotsProgressInPercent();float GetTargetingFovWithoutScope();float GetCurrentSpread();float GetBaseSpread(bool bIncludeMovementSpreadMulti = true, bool bIncludeSpreadModifiers = true);float GetSpreadMovementTypeMultiplier();float GetSpreadDecreaseForTick() const;float GetFireRateMultiplierFromAmmo() const;/** Get curve for damage in this fire type */virtual UCurveFloat* GetDamageCurve();virtual UCurveFloat* GetVehicleDamageOverDistCurve();virtual UCurveFloat* GetVehicleExplosionDamageOverDistCurve();FWW3WeaponFireTypeRow* GetFireTypeRow() const;FWW3BallisticBehaviour* GetBallisticBehaviour() const;EWW3ShootingMode GetCurrentShootingMode();EWW3ImpactEffectType GetImpactEffectType() const;EWW3AmmoTypeForPassingByBulletSound GetPasingByBulletSound() const;void GetRecoilData(FWW3RecoilData* &OutHipsRecoilData, FWW3RecoilData* &OutAimRecoilData) const;void SetMuzzleOwnerComponent(USceneComponent* MuzzleComponent);void SetShellsOwnerComponent(USceneComponent* ShellsComponent);void UpdateShootingModeInPlayerProfile();USceneComponent* GetMuzzleOwnerComponent() const;USceneComponent* GetShellOwnerComponent();UParticleSystemComponent* GetMuzzlePSC();UParticleSystemComponent* GetMuzzlePSCSecondary();UParticleSystemComponent* GetFallingShellsPSC();UParticleSystemComponent* GetSmokePSC();UParticleSystemComponent* GetHeavySmokePSC();bool GetStartedAimingSounds(FWW3SoundEffect& OutSounds) const;bool GetFinishedAimingSounds(FWW3SoundEffect& OutSounds) const;void GetMuzzleEffectAttachPoint(FName& OutPoint);void GetMuzzleProjectileSpawnPoint(FName& OutPoint);void GetShellsAttachPoint(FName& OutPoint);UAkAudioEvent* GetFireSound(EWW3SoundType SoundType, bool bIsInterior) const;UAkAudioEvent* GetHeavySmokeSoundStart(EWW3SoundType SoundType) const;UAkAudioEvent* GetHeavySmokeSoundStop(EWW3SoundType SoundType) const;UAkAudioEvent* GetSilenceFireSound(EWW3SoundType SoundType, bool bIsInterior) const;UAkAudioEvent* GetFireTailSound(EWW3SoundType SoundType, EWW3ReverbZoneType ReverbZone) const;UAkAudioEvent* GetSilenceTailSound(EWW3SoundType SoundType, EWW3ReverbZoneType ReverbZone) const;UAkAudioEvent* GetFireFinishSound(EWW3SoundType SoundType) const;UAkAudioEvent* GetOutOfAmmoSound(EWW3SoundType SoundType) const;UAkAudioEvent* GetReloadSound(EWW3SoundType SoundType) const;// SOUNDS GETTERS/** When player shots he will get that amount of adrenaline. The maximumadrenaline amount received will be limited to LimitOfAdrenalineAmount.<0, 100>**/float GetAmountOfAdrenalineAppliedOnShot() const;/** Upper limit of adrenaline, when player already has more adrenaline,than this limit then no adrenaline will be gained anymore.<0, 100>**/float GetLimitOfAdrenalineAmount() const;//#if !UE_BUILD_SHIPPING // CHEATS/** [SERVER] Check if one hit kill cheat is active. Checked when dealing damage to targets. */bool CHEAT_GetCheatOneHitKill();//#endifint32 GetClipSizeOverride() const;void FireSingleShotOnServer(int32 InClientRandomStreamSeed);bool IsLastShootingMode() const;bool IsFirstShootingMode() const;EWW3ShootingMode GetDefaultShootingMode() const;EWW3ShootingMode GetAlternativeShootingMode() const;float GetPrevServerShootTimestamp() const;void OnSetWeaponOwner();void InitScopeGlareComponent();void SetSpreadCompensation(float InSpreadCompensation);virtual void OnBeforeAttachmentsBecameInactive();virtual void OnAfterAttachmentsBecameActive();/** [OWNER] Called from StartFire() before sanding information to server. Get Pos and Dir from weapon owner. */void UpdateShootingPositionAndDirection();void SetSphereMaskEnabled(bool bInEnabled);virtual void DealDamage_OnHitEnemyActor(APawn* PawnInstigator, AActor* const DamagedActor, AActor* DamageCauser, UWW3PlayerStatisticsManager* InPlayerStatistics, FWW3ShotHitData const& InShotHitData);TSharedPtr<FWW3CollectionOfActorsBeignHit> GetLastCollectionOfActorsBeignHit();protected:TSharedPtr<FWW3CollectionOfActorsBeignHit> CreateCollectionOfActorsBeignHit();#if STATISTICS_USE_NEW_DATAvoid SvOnShotPerformed();#endif // #if STATISTICS_USE_NEW_DATA/** STATE METHODS *//** Check and update current state */void DetermineState();void PlayBarkForAmmoChanged();/** Set new state */void SetNewState(EWW3FireTypeState NewState, bool bFromReplication = false);/** Call right OnStateStop function below */void FinishOldState(EWW3FireTypeState OldState, bool bFromReplication);/** Call right OnStateStart function below */void StartNewState(EWW3FireTypeState NewState, bool bFromReplication);void OnStateStart_Idle(bool bFromReplication);void OnStateStop_Idle(bool bFromReplication);void OnStateStart_Firing(bool bFromReplication);void OnStateStop_Firing(bool bFromReplication);void OnStateStart_Reloading(bool bFromReplication);void OnStateStop_Reloading(bool bFromReplication);void OnStateStart_Busy(bool bFromReplication);void OnStateStop_Busy(bool bFromReplication);void OnFireTypeSoundsLoaded();void OnFinishShootEffects_T();void OnFinishMuzzleSmokeEffects_T();void FovPositionCorrection(const FVector& Location, float CorrectionAlpha, FVector& OutPosition);virtual int32 GetPelletAmount() const { return 1; }/** SHOOTING METHODS *//** [SERVER] Call FireSingeShot, send to server all needed data */UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_FireSingleShot(int32 InClientRandomStreamSeed, const FVector& ClientShootPosition, const FVector& ClientShootDirection);UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_FireSingleProjectile(int32 InClientRandomStreamSeed, const FVector& ClientShootPosition, const FVector& ClientShootDirection, uint32 ProjectileID);UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_FireSingleShotWithCharacterHit(int32 InClientRandomStreamSeed, const FVector& ClientShootPosition, const FVector& ClientShootDirection, const FVector_NetQuantize& HitActorPosition, UPrimitiveComponent* HitComponent, EWW3BoneType HitBoneType);UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_UpdateShootingModeInPlayerProfile(const EWW3ShootingMode& NewShootingMode);UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_OnHitPlayerCharacter(uint32 ProjectileID, const FVector_NetQuantize& HitActorPosition, UPrimitiveComponent* HitComponent, EWW3BoneType HitBoneType, EWW3ProjectileBehavior HitBehaviour, uint8 PackedPenetrationAlpha);UFUNCTION(Reliable, Server, WithValidation, Category = "Networking")void Server_OnHitPlayerVehicle(uint32 ProjectileID, const FVector_NetQuantize& HitActorPosition, UPrimitiveComponent* HitComponent, EWW3BoneType HitBoneType, EWW3ProjectileBehavior HitBehaviour, uint8 PackedPenetrationAlpha);/** Server can throw out client's bullet. In those cases we refund it to avoid desync. */UFUNCTION(Reliable, Client, Category = "Network")void Client_RefundBullet();void SvOnHitPlayerCharacter(uint32 ProjectileID, const FVector_NetQuantize& HitActorPosition, UPrimitiveComponent* HitComponent, EWW3BoneType HitBoneType, EWW3ProjectileBehavior HitBehaviour, uint8 PackedPenetrationAlpha);void SvOnHitPlayerVehicle(uint32 ProjectileID, const FVector_NetQuantize& HitActorPosition, UPrimitiveComponent* HitComponent, EWW3BoneType HitBoneType, EWW3ProjectileBehavior HitBehaviour, uint8 PackedPenetrationAlpha);/** [OWNER + SERVER] Called localy and form server */virtual void FireSingleShot();/** [OWNER + SERVER] Called localy and form serverReturn true when projectile should be created */virtual bool FireSingleShot_Internal(TArray<FWW3ShotHitData>& HitsData, AWW3Projectile* &OutProjectile);/** [OWNER + SERVER] Appply spread on shoot dir */virtual void ApplySpreadOnShootDirection(const FVector& OriginShootDirection);/** [OWNER + SERVER] Update Current Spread - add value for single shot */float UpdateCurrentSpread();/** [OWNER + SERVER] Perform shot from trace */virtual void PerformShotTrace(TArray<FWW3ShotHitData>& Impacts);void CalculateTrace(TArray<FHitResult>& Impact , bool bOnlyFirstHit = false, const FVector_NetQuantize& OverrideShootingPosition = FVector_NetQuantize::ZeroVector, const FVector_NetQuantizeNormal& OverrideShootingDirection = FVector_NetQuantizeNormal::ZeroVector) const;/** [OWNER + SERVER] Spawn projectile actor that handle by himself replication */bool SpawnProjectileActor(const FVector& PositionToSpawn, AWW3Projectile* &OutProjectile, bool bIsMirrorOfClientProjectile = true);/** [SERVER] Hit target, create impact effect and damage actor */void HitTarget(const TArray<FWW3ShotHitData>& Impact);/** [OWNER + SERVER] Called after success shooting a projectile/trace */void OnPostShoot(); /** [OWNER] Called XXX, spawns all necessary FPP VFX and 2D SFX */ virtual void PlayOwnerShootEffects();/** [OWNER] Called XXX, spawns all necessary FPP VFX and 2D SFX */void PlayOwnerEndShootEffects();/** [OWNER] Called XXX, spawns all necessary FPP VFX and 2D SFX */void StartOwnerShootEffects(); /** [SERVER + OTHERS] Called XXX, spawns all necessary TPP VFX and 3D SFX */ void PlaySimulatedClientShootEffects(bool bInWorldLocationAvailable = false, const FVector& InWorldLocation = FVector::ZeroVector, const FVector& InShootDirection = FVector::ForwardVector);/** [SERVER + OTHERS] Called XXX, spawns all necessary TPP VFX and 3D SFX */void StartSimulatedClientShootEffects();/** [OWNER + SERVER] Add first shot spread if this was a first shot in series. Only in AUTO Shooting Mode */void AddFirstShotSpread();/** [OWNER + SERVER] Create impact effect using HitInfo form trace shot */void CreateImpactEffect(TArray<FWW3ShotHitData>& Impacts);/** [OWNER + SERVER] Change shooting mode */void SetCurrentShootingMode(EWW3ShootingMode NewShootingMode);bool UpdateShootPositionAndDirectionFromClient(const FVector& ClientPosition, const FVector& ClientDirection, const FVector& ServerPosition, const FVector& ServerDirection);/** Timers */void OnFireSingleShot_T(int32 InClientRandomStreamSeed, const FVector Position, const FVector Direction, float ShotSpread);void OnFireSingleProjectile_T(int32 InClientRandomStreamSeed, const FVector ClientShootPosition, const FVector ClientShootDirection, uint32 ProjectileID, float ShotSpread);void OnFireSingleShotWithCharacterHit_T(int32 InClientRandomStreamSeed, const FVector ClientShootPosition, const FVector ClientShootDirection, const FVector_NetQuantize HitActorPosition, UPrimitiveComponent* HitComponent, EWW3BoneType HitBoneType, float ShotSpread);/** +++ ON REP FUNCTIONS */UFUNCTION()void OnRep_IsFiring();UFUNCTION()void OnRep_CurrentAmmoTypeInClip();UFUNCTION()void OnRep_CurrentAmmoInClip(int16 OldValue);UFUNCTION()void OnRep_CurrentShootingMode(EWW3ShootingMode OldShootingMode);/** +++ PROTECTED GETTERS AND SETTERS */void SetCurrentAmmoAmountInClip(int32 NewAmmoAmount);void SetCurrentVisibleAmountInClip(bool bFromServer);void SetBulletCounter(const uint8& NewBulletCounter);/** Check if fire type should create ballistic bullet or trace */bool ShouldFireBalistics(const FVector& FirstImpactPosition) const;EWW3ShootingMode GetNextShootingMode() const;EWW3ShootingMode GetPreviousShootingMode() const;/** +++ LIFETIME REPLICATED PROPS */void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;virtual bool UseSilencer() const;void TryToDetachCompletedParticleSystems();void PlayAutonomousForceFeedbackShootEffect();void OnProjectileDestroyed(AWW3Projectile *const InSender);private:bool IsAttachmentManagerSynchronized();bool ShouldShowVisualFX(UWorld* WorldInstace, bool bInWorldLocationAvailable);void UpdateRadiusReductionWhenTargeting(float &RadiusReductionFromCurve);bool UpdateRadiusReductionWhenNotTargeting(float &RadiusReductionFromCurve);void UpdateFireRateMultiplierFromAmmoCache() const;void OnAmmoTypeChanged();float GetShotsPerMinute() const;AWW3PlayerController* GetPlayerController();void FinishSmokeSound();void InitTargetingEvents(AWW3InventoryWeapon* OwnerWeapon);void ShowScopeGlare();void HideScopeGlare();void OnScopeGlareMeshLoaded();void UpdateWeaponGlare();void UpdateWeaponGlareScale(AWW3InventoryWeapon* OwnerWeapon, class UWW3WAUpper* UpperAttachment);AWW3InventoryWeapon* GetCurrentWeapon() const;bool IsLocalPlayer() const;void UpdateScopeGlareVisibility(const FVector& StartTrace, const FVector& EndTrace, AWW3PlayerController* WW3PlayerController, AWW3InventoryWeapon* OwnerWeapon);void OnStartTargetingEvent();void OnStopTargetingEvent();bool ShowSmokeFX = false;mutable float FireRateMultiplierFromAmmoCache = -1.0f;TWeakObjectPtr<UParticleSystemComponent> UsedSmokePSC;TWeakObjectPtr<AWW3PlayerController> PlayerControllerInstance;bool PostSmokeStopSound = false;UPROPERTY(Transient)UStaticMeshComponent* ScopeGlareComponent = nullptr;TSharedPtr<FWW3LoadingAssetHandle> ScopeGlareLoadHandle;FTraceHandle AsyncGlowTraceHandle;bool TraceGlowVisibility = true;bool IsUsingGlare = false;protected:bool bMaterialForegroundEnabled = false;public://virtual void ApplyFOVCorrectionState(bool bInEnabled);virtual void ApplyMaterialForegoundState(bool bInEnabled);virtual bool IsMaterialForegroundEnabled() const;};//////////////////////////////////////////////////////////////////////////FORCEINLINE bool UWW3FireType::IsMaterialForegroundEnabled() const{return bMaterialForegroundEnabled;}FORCEINLINE FVector_NetQuantize UWW3FireType::GetShootPosition() const{return ShootPosition;}FORCEINLINE FVector_NetQuantizeNormal UWW3FireType::GetShootDirection() const{return ShootDirection;}FORCEINLINE UWW3FireTypeManager* UWW3FireType::GetFireTypeManager(){return ThisFireTypeManager;}FORCEINLINE TSubclassOf<UWW3AmmoType> UWW3FireType::GetCurrentAmmoTypeInClip() const{return CurrentAmmoTypeInClip;}FORCEINLINE TSubclassOf<UWW3AmmoType> UWW3FireType::GetAmmoTypePendingLoad() const{return AmmoTypePendingLoad;}FORCEINLINE TSubclassOf<UCameraShake> UWW3FireType::GetFireCameraShake(){return FireTypeRow ? FireTypeRow->FireCameraShake : nullptr;}FORCEINLINE bool UWW3FireType::GetAdditionalFppFireCameraShakes(TArray<TSubclassOf<UCameraShake>>& OutShakes) const{if (FireTypeRow != nullptr){OutShakes = FireTypeRow->AdditionalFppFireCameraShakes;return OutShakes.Num() > 0;}return false;}FORCEINLINE int32 UWW3FireType::GetCurrentAmmoAmountInClip() const{return CurrentAmmoInClip;}FORCEINLINE int32 UWW3FireType::GetCurrentAmmoAmountInClipForUi() const{return CurrentAmmoInClipUiVisible;}FORCEINLINE uint8 UWW3FireType::GetBulletCounter() const{return BulletCounter;}FORCEINLINE bool UWW3FireType::IsClipEmpty(){return GetCurrentAmmoAmountInClip() <= 0;}FORCEINLINE bool UWW3FireType::IsFiringInAutoMode() const{return bIsFiring;}FORCEINLINE bool UWW3FireType::IsReloading() const{return CurrentState == EWW3FireTypeState::Reloading;}FORCEINLINE bool UWW3FireType::IsReloadInProgress() const{return (CurrentReloadState != EWW3WeaponReloadState::None && CurrentReloadState < EWW3WeaponReloadState::RELOADFINISHED);}FORCEINLINE EWW3FireTypeReloadType UWW3FireType::GetReloadType() const{return FireTypeRow != nullptr ? FireTypeRow->ReloadType : EWW3FireTypeReloadType::Normal;}FORCEINLINE FWW3WeaponFireTypeRow* UWW3FireType::GetFireTypeRow() const{return FireTypeRow;}FORCEINLINE EWW3ShootingMode UWW3FireType::GetCurrentShootingMode(){return CurrentShootingMode;}FORCEINLINE USceneComponent* UWW3FireType::GetShellOwnerComponent(){return ShellOwnerComponent;}FORCEINLINE UParticleSystemComponent* UWW3FireType::GetMuzzlePSC(){return MuzzlePSC;}FORCEINLINE UParticleSystemComponent* UWW3FireType::GetMuzzlePSCSecondary(){return MuzzlePSCSecondary;}FORCEINLINE UParticleSystemComponent* UWW3FireType::GetSmokePSC(){return SmokePSC;}FORCEINLINE UParticleSystemComponent* UWW3FireType::GetHeavySmokePSC(){return HeavySmokePSC;}FORCEINLINE UParticleSystemComponent* UWW3FireType::GetFallingShellsPSC(){return FallingShellsPSC;}FORCEINLINE int32 UWW3FireType::GetClipSizeOverride() const{return ClipSizeOverride;}FORCEINLINE void UWW3FireType::SetMuzzlePSC(UParticleSystemComponent* NewParticleSystem){MuzzlePSC = NewParticleSystem;}FORCEINLINE void UWW3FireType::SetMuzzlePSCSecondary(UParticleSystemComponent* NewParticleSystem){MuzzlePSCSecondary = NewParticleSystem;}FORCEINLINE void UWW3FireType::SetFallingShellsPSC(UParticleSystemComponent* NewParticleSystem){FallingShellsPSC = NewParticleSystem;}FORCEINLINE void UWW3FireType::SetSmokePSC(UParticleSystemComponent* NewParticleSystem){SmokePSC = NewParticleSystem;}FORCEINLINE void UWW3FireType::SetHeavySmokePSC(UParticleSystemComponent* NewParticleSystem){HeavySmokePSC = NewParticleSystem;}FORCEINLINE bool UWW3FireType::GetSwitchWhenAdded() const{return SwitchWhenAdded;}FORCEINLINE float UWW3FireType::GetPrevServerShootTimestamp() const{return PrevServerShootTimestamp;}Mateusz SzlechtMateusz Szlecht22023-12-15T09:57:00Z2023-12-15T09:57:00Z124542332540Microsoft Office Word027175falsefalse37888falsefalse16.0000