RecoilAnimationComponent.h

Go to the documentation of this file.

// Designed by Hitman's Store, 2023
 
#pragma once
 
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "Components/TimelineComponent.h"
#include "Net/UnrealNetwork.h"
#include "Kismet/KismetMathLibrary.h"
#include "RecoilData.h"
#include "RecoilAnimationComponent.generated.h"
 
class UStoredData;
class UUserWidget;
 
DECLARE_LOG_CATEGORY_EXTERN(LogRecoilAnimation, Log, All);
 
// DECLARE_DELEGATE(FDoTransition);
// DECLARE_DELEGATE_RetVal(bool, FCheckCondition);
 
 
UCLASS(ClassGroup=(RecoilAnimation), meta=(BlueprintSpawnableComponent))
class RECOILANIMATION_API URecoilAnimationComponent : public UActorComponent
{
    GENERATED_BODY()
 
public:
    URecoilAnimationComponent();
    
    virtual void TickComponent(float DeltaTime, ELevelTick TickType,
                               FActorComponentTickFunction* ThisTickFunction) override;
    
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void Init(const FRecoilAnimData Data, const float Rate = 0.0f, const int Bursts = 0);
    
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void Play();
    
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void Stop();
    
    FORCEINLINE FTransform GetOutput() const { return FTransform(OutRot, OutLoc); };
    
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void SetFireMode(EFireMode_PRAS NewMode);
 
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void SetAimingStatus(bool bStatus);
 
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void SaveData();
 
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void ScaleInput(FInputScale_PRAS NewScale);
 
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void UnscaleInput(FInputScale_PRAS NewScale);
 
    UFUNCTION(BlueprintCallable, Category = "Essentials")
    void ResetInputScale();
    
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Debug", meta=(DevelopmentOnly))
    FORCEINLINE EFireMode_PRAS GetFireMode() const { return FireMode; };
    
    UFUNCTION(BlueprintCallable, Category = "Debug")
    float GetDelta() const;
    
    UFUNCTION(BlueprintCallable, Category = "Debug", meta=(DevelopmentOnly))
    void Simulate(bool bStartSim);
    
    UFUNCTION(BlueprintCallable, Category = "Debug", meta=(DevelopmentOnly))
    void ShowUI();
    
    UFUNCTION(BlueprintCallable, Category = "Debug", meta=(DevelopmentOnly))
    void HideUI();
    
    void AddEvent(float Time, FOnTimelineEvent Event);
 
    UPROPERTY(BlueprintReadWrite, Category = "UI")
    FMuteAxis MuteRot;
 
    UPROPERTY(BlueprintReadWrite, Category = "UI")
    FMuteAxis MuteLoc;
    
    UPROPERTY(BlueprintReadWrite, Replicated, Category = "Recoil Animation")
    FRecoilAnimData AnimData;
 
    UPROPERTY(BlueprintReadWrite, Replicated, Category = "Recoil Animation")
    FInputScale_PRAS InputScale;
 
protected:
    virtual void BeginPlay() override;
 
private:
    UFUNCTION()
    void AnimationUpdate(FVector VectorAlpha);
 
    UFUNCTION()
    void CalculateTargetData();
 
    double CorrectStart(double& Last, const double Current, bool& bStartRest, double& StartVal);
 
    FORCEINLINE double GLerp(double A, double B, double Alpha, double DeltaTime)
    {
        return FMath::Lerp(A, B, 1 - FMath::Exp(-Alpha * DeltaTime));
    };
 
    FVector GLerp(FVector A, FVector B, FVector Alpha, float DeltaTime);
 
    FRotator GLerp(FRotator A, FRotator B, FVector Alpha, float DeltaTime);
    
    void SetupStateMachine();
 
    void SetSimulationTimer(float SemiDelay);
    
    double GetAngularRecoil(const FVector4 RecoilProfile);
 
    void CorrectAlpha(const UCurveVector* Rotation, const UCurveVector* Location, const float TimeCorrection);
 
    void SetupTransition(FRotator StartRot, FVector StartLoc, UCurveVector* Rot, UCurveVector* Loc);
    
    void SetupComponent();
 
    void TickAdvancedSolver(float DeltaTime);
 
    float DampSpring(float Current, FFloatSpringState& SpringState, float Stiffness, float Damping, float DeltaTime);
 
    void ApplySmoothing(float DeltaTime);
    void ApplyNoise(FTransform& Finalized, float DeltaTime);
    void ApplyPushback(FTransform& Finalized, float DeltaTime);
    void ApplyProgression(FTransform& Finalized, float DeltaTime);
 
    double GetNonZero(double OldValue, double NewValue) const
    {
        if(FMath::IsNearlyZero(NewValue))
        {
            return OldValue;
        }
 
        return NewValue;
    }
    
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Recoil Animation Output", meta=(AllowPrivateAccess=true))
    FRotator OutRot;
    
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Recoil Animation Output", meta=(AllowPrivateAccess=true))
    FVector OutLoc;
    
    UPROPERTY(EditDefaultsOnly, Category = "UI")
    TSubclassOf<UUserWidget> WidgetClass;
 
    UPROPERTY()
    UCurveVector* TempRot;
 
    UPROPERTY()
    UCurveVector* TempLoc;
    
    UPROPERTY()
    class UHelperWidget* Widget;
    
    UPROPERTY(BlueprintReadOnly, meta=(AllowPrivateAccess=true), Category = "Essentials")
    bool bIsAiming = false;
 
    float LastShotTime = 0.f;
 
    FTimerHandle TimerHandle;
    FTimeline AnimTimeline;
 
    /* Important
     * 0 = X
     * 1 = Y
     * 2 = Z
     */
    FStartRest CanRestRot;
    FStartRest CanRestLoc;
 
    FRotator StartValRot;
    FVector StartValLoc;
 
    FRotator TargetRot;
    FVector TargetLoc;
 
    FFloatSpringState PitchState;
    FFloatSpringState RollState;
    FFloatSpringState KickState;
 
    FOnTimelineVector ProgressFunction;
 
    bool bSim;
 
    TEnumAsByte<EFireMode_PRAS> FireMode;
 
    float FireRate;
 
    int BurstAmount;
 
    int BurstCounter;
 
    TArray<FAnimState_PRAS> StateMachine;
    uint8 CurrentStateIndex = 0;
 
    FRotator RawOutRot;
    FVector RawOutLoc;
 
    bool bEnableSmoothing = false;
 
    bool bAnimActive = true;
 
    FVector2D Noise2DTarget = FVector2D::ZeroVector;
    FVector2D Noise2DCurrent = FVector2D::ZeroVector;
    FVector2D NoiseSpeed = FVector2D::ZeroVector;
 
    double PushbackTarget = 0;
    double PushbackCurrent = 0;
    double PushbackOut = 0;
    double PushbackSpeed = 0;
 
    FRotator LerpedRot;
    FVector LerpedLoc;
    
    FVector2D PitchProgress = FVector2D::ZeroVector;
    FVector2D ZProgress = FVector2D::ZeroVector;
    double PitchProgressSpeed = 0;
    double ZProgressSpeed = 0;
};