ProjectXCharacterMovement.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2017. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "ProjectX.h"
#include "AdvancedCharacterMovement.h"
#include "Components/PrimitiveComponent.h"
#include "Player/PlayerStructs.h"
#include "ProjectXCharacterMovement.generated.h"
 
//Flags that are now used.
#define FLAG_IsUsingJetpack FSavedMove_Character::FLAG_Custom_0
#define FLAG_IsUsingDash FSavedMove_Character::FLAG_Custom_1
#define FLAG_IsUsingOmnidirectionalDash FSavedMove_Character::FLAG_Custom_2
#define FLAG_IsUsingHookshot FSavedMove_Character::FLAG_Custom_3
#define FLAG_IsUsingAutoClamber FSavedMove_Character::FLAG_Reserved_1
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FWaterRunningSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnCustomMovementToggledSignature, ECustomMovementType, CustomMovement, bool, bToggledState);
 
class AProjectXCharacter;
 
/* This component is responsible for the entire replication and prediction of movement, as well as responsible for defining the behavior of our implemented custom movement modes such as: Jetpack, Hookshot and Dashes */
UCLASS()
class PROJECTX_API UProjectXCharacterMovement : public UCharacterMovementComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    virtual float GetMaxSpeed() const override;
    virtual float GetGravityZ() const override;
    virtual void CheckMaximumHeight() override;
    friend class FSavedMove_PXMovement;
    virtual void UpdateFromCompressedFlags(uint8 Flags) override;
    virtual bool ClientUpdatePositionAfterServerUpdate() override;
    virtual class FNetworkPredictionData_Client* GetPredictionData_Client() const override;
    virtual bool ShouldUpdateSimulationVisuals() override;
    virtual bool CanCrouchInCurrentState() const override;
 
    UFUNCTION(BlueprintCallable, Category = "Slope Movement")
    float GetSlopeInstance() const { return CurrentSlopeInstance; }
    UFUNCTION(BlueprintCallable, Category = "Slope Movement")
    virtual float GetSlopeInstanceMultiplier() const;
    UFUNCTION(BlueprintCallable, Category = "Slope Movement")
    void SetSlopeInstanceMultiplierFromSpeed(const float& Speed);
    UFUNCTION(BlueprintCallable, Category = "Slope Movement")
    bool IsRunningOnWater() const { return GetMovementBase() && GetMovementBase()->GetCollisionObjectType() == ECC_WaterBlock; }
    UFUNCTION(BlueprintCallable, Category = "Slope Movement")
    float GetMaxPossibleSpeed() const;
    UFUNCTION(BlueprintCallable)
    float GetHookShotLength() const {return HookshotLength * HookshotLengthMultiplier;}
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetDeltaSlope() const { return DeltaSlope; }
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetCrouchSpeedModifier() const { return CrouchSpeedModifier; }
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetGroundFrictionCache() const { return GroundFrictionCache; }
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetTimeMovementStartedAt() const { return TimeMovementStartedAt; }
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetTimeMovementStoppedAt() const { return TimeMovementStoppedAt; }
 
    /* Returns the slope instance that matches the current velocity we're traveling at. No longer needs current slope instance to be 0 to function */
    virtual float GetCurrentSpeedSlopeInstance(bool bUse2DVelocity = false) const;
    /* Performs the find hookable point logic for the hookshot movement */
    virtual bool PerformHookPointSearch(FHitResult& OutHitResult) const;
    virtual bool CanClamber(const FVector& InVelocity, FHitResult& FoundLedgeHitResult) const;
    /* Returns true if we're hitting a ramp and need to go into falling state. */
    virtual bool CheckForRamp(const FVector& InVelocity, float DeltaTime) const;
    void Crouch(bool bClientSimulation) override;
    void UnCrouch(bool bClientSimulation) override;
    void SetupDash(FVector DesiredVelocity,bool bLookAtDashDirection = true, bool bBreakAfterDashEnds = false);
    /* Sets up the information needed to run the overlaps on the server for the latch point and not rely on RPCs*/
    void SetupHookshot(TArray<float> RangeChecks, float MinDotAllowed);
    void ToggleDash(bool bToggle, bool bIsOmni = false);
    void ToggleJetPack(bool bToggle);
    void ToggleHookshot(bool bToggle);
    void ToggleClamber(bool bToggle);
 
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetMaxHookshotSpeed() const { return MaxHookshotSpeed * HookshotMaxSpeedMultiplier * HookshotSpeedMultiplier ;}
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetHookshotSpeed() const { return HookshotSpeed * HookshotSpeedMultiplier; }
    UFUNCTION(BlueprintPure, Category = Character)
    FORCEINLINE float GetMaxHeight() const { return MaximumHeight * AltitudeLimitMultiplier;    }
 
    /* Only call this function if you can update this from both server and client */
    void UpdateHookShotLengthMultiplier(float NewMultiplier);
    /* Only call this function if you can update this from both server and client */
    void UpdateHookShotSpeedMultiplier(float NewSpeedMultiplier);
    /* Only call this function if you can update this from both server and client */
    void UpdateHookShotMaxSpeedMultiplier(float NewSpeedMultiplier);
    /* Only call this function if you can update this from both server and client */
    void UpdateAltitudeLimitMultiplier(float NewAltitudeLimitMultiplier);
    /* Only call this function if you can update this from both server and client */
    void UpdateGravityMultiplier(float NewGravityMultiplier);
    /* Only call this function if you can update this from both server and client */
    void UpdateGroundSpeedMultiplier(float NewGroundSpeedMultiplier);
 
    /* How much stamina is used by the Jetpack*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Jetpack, meta = (EditCondition = "bHasJetpack"))
    float JetpackEnergyDrainRate = 25.f;
    /* Maximum speed the hookshot is allowed to reach */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float MaxHookshotSpeed = 2800.f;
 
    UPROPERTY(BlueprintAssignable)
    FWaterRunningSignature OnClamberStart;
    UPROPERTY(BlueprintAssignable)
    FWaterRunningSignature OnClamberEnd;
    UPROPERTY(BlueprintAssignable)
    FWaterRunningSignature OnWaterRunningStart;
    UPROPERTY(BlueprintAssignable)
    FWaterRunningSignature OnWaterRunningEnd;
    UPROPERTY(BlueprintAssignable)
    FOnCustomMovementToggledSignature OnCustomMovementToggled;
 
protected:
    /* Responsible for handling our CurrentSlopeInstance as well as checking for any ramping behavior */
    virtual void UpdateSlopeRunning(float DeltaTime, const float& StartingZ);
    virtual bool DoJump(bool bReplayingMoves);
    virtual void BeginPlay() override;
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void PerformMovement(float DeltaTime) override;
    virtual void PhysWalking(float DeltaTime, int32 Iterations) override;
    virtual void PhysFalling(float DeltaTime, int32 Iterations) override;
    virtual void OnMovementModeChanged(EMovementMode PreviousMovementMode, uint8 PreviousCustomMode) override;
 
    UFUNCTION()
    void SettingsUpdate();
 
    UFUNCTION()
    virtual void OnLanded(const FHitResult& HitResult);
    UFUNCTION()
    virtual void OnCharacterInputDisabled();
 
    UFUNCTION(Client, Reliable)
    virtual void Client_Reliable_JetPackShutdown(float WorldTime);
    UFUNCTION(Client, Reliable)
    virtual void Client_Reliable_HookshotShutdown();
 
    /* ----------------------------------------Base Movement------------------------------------------------------------ */
    /* How much slower the character moves while crouched*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = CharacterBase)
    float CrouchSpeedModifier = 0.5f;
    /* The speed at which players fast fall. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Character Movement: Jumping / Falling", meta = (AllowPrivateAccess = true))
    float FastFallSpeed = 1000.f;
 
    /* ------------------------------------------------SLOPES----------------------------------------------------------- */
    /* Current slope we've built up. */
    UPROPERTY(Replicated, BlueprintReadOnly)
    float CurrentSlopeInstance = 0.f;
    /* When going up slopes, how many times more should the current slope instance be reduced by? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float UpwardSlopePenalty = 1.25f;
    /* How much should the current slope instance decay per second? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float SlopeDecay = 100.f;
    /* How much should the current slope instance increase per second if we're running on water? Will still be affected by SlopeDecay. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float WaterRunningSlopeRate = 200.f;
    /* How much should the current slope instance increase per second if we're boosting? Will still be affected by SlopeDecay. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float BoostSlopeRate = 400.f;
    /* Maximum a slope instance be changed per second */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float MaxDeltaSlope = 200.f;
    /* Maximum a slope instance can be */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float MaxSlopeInstance = 2000.f;
    /* How much to divide slope instance by to get our movement speed bonus */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float SlopeSpeedDivisor = 500.f;
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    UCurveFloat* SlopeSpeedCurve = NULL;
    /* How much higher the slope instance can be in comparison to current speed */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float MaxSlopeSpeedDifference = 200.f;
    /* Any speeds below this value will reset the current slope instance */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Slope Movement", meta = (AllowPrivateAccess = true))
    float SlopeResetSpeed = 100.f;
    /* Distance infront of this actor we test for ramps */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Ramp Movement", meta = (AllowPrivateAccess = true))
    float RampPredictionDistance = 32.f;
    /* Distance downward from this actor we test for ramps (not including capsule size). */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Ramp Movement", meta = (AllowPrivateAccess = true))
    float RampDownwardPredictionDistance = 32.f;
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Ramp Movement", meta = (AllowPrivateAccess = true))
    float MinRampAngle = 20.f;
    /* should the angle of the ground affect speed*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Ramp Movement", meta = (AllowPrivateAccess = true))
    bool bUseSlopes = true;
    /* flat boost amount*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Ramp Movement", meta = (AllowPrivateAccess = true))
    float FlatBoostMultiplier = 1.0f;
    /* ----------------------------------------JETPACK-------------------------------------------------------------- */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Jetpack)
    bool bHasJetpack = false;
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Jetpack, meta = (EditCondition = "bHasJetpack"))
    float JetpackForce = 4000.f;
    //Max Z velocity we can achieve with the Jetpack.
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Jetpack, meta = (EditCondition = "bHasJetpack"))
    float JetpackMaxZ = 2000.f;
    /* A curve that can be used to dynamically change the drain rate of this jetpack */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Jetpack, meta = (EditCondition = "bHasJetpack"))
    class UCurveFloat* JetpackIncreaseDrainCurve = NULL;
    
    /* ----------------------------------------DASHES---------------------------------------------------------------- */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Dash)
    bool bCanDash = true;
 
    /* ----------------------------------------HOOKSHOT--------------------------------------------------------------- */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot)
    bool bCanHookshot = true;
    /* How much the does it cost to run the hookshot while it's active? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float HookshotCostPerSecond = 5.f;
    /* How far can the player hookshot */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float HookshotLength = 10000.f;
    /* Incremental speed added to the hookshot each second creating an acceleration. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float HookshotSpeed = 3500.f;
    /* Incremental speed added to the hookshot each second creating an acceleration based on a curve. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    class UCurveFloat* IncreaseSpeedCurve = NULL;
    /* How stiff is the hookshot spring behaviour (K constant) */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float SpringStiffness = .5f;
    /* How stiff is the hookshot spring behaviour (K constant) */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float HookshotLatchTime = .5f;
    /* How much vertical friction is applied during damping? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float SpringFriction = 0.f;
    /* If starting hookshot while above maximum velocity, how quickly to decay the velocity per second */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float HookshotDeceleration = 100.f;
    /* How far from the hooked point to stop pulling the player towards the point */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Hookshot, meta = (EditCondition = "bCanHookshot"))
    float HookshotDisengagementDistance = 200.0f;
 
    /* ----------------------------------------CLAMBER--------------------------------------------------------------- */
    /* How close must the ledge be from the player before they are allowed to clamber? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float ClamberMaxDistance = 300.0f;
    /* Max Angle deviation from our forward acceleration that a wall can be to be considered for the clamber */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float ClamberMaxAccelerationAngleDeviation = 30.f;
    /* Max slope the "Roof" of the surface you're trying to clamber onto can have. Imagine you're approaching a ramp from the side, the "roof" of it will be angled at X degrees, if ClamberSurfaceMaxSlope is 45 and the ramp has a 50 degrees angle, we won't clamber towards it*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float ClamberSurfaceMaxSlope = 45.f;
    /* Max Angle deviation From the direction you're looking at that a ledge can be for it to be considered for the clamber */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float ClamberMaxCameraDirectionAngleDeviation = 15.f;
    /* How high can the ledge be from the player when attempting to clamber? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float ClamberMaxHeight = 400.0f;
    /* Upwardsforce to award the player when they can clamber */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float ClamberForce = 4000.0f;
    /* Upwardsforce to award the player when they can clamber */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Clambering", meta = (AllowPrivateAccess = true))
    float MaxUpwardsClamberForce = 2000.0f;
 
    uint8 bWantsToDash : 1;
    uint8 bWantsToOmniDash : 1;
    uint8 bWantsToJetPack : 1;
    uint8 bWantsToHookshot : 1;
    uint8 bWantsToAutoClamber : 1;
 
    uint8 bWantsToDashCache : 1;
    uint8 bWantsToOmniDashCache : 1;
    uint8 bWantsToJetPackCache : 1;
    uint8 bWantsToHookshotCache : 1;
private:
    /* A cache of this owner as an AProjectXCharacter */
    UPROPERTY()
    AProjectXCharacter* PXCharacterOwner = NULL;
    /* Difference in slope between the previous frame and this one */
    float DeltaSlope = 0.f;
    FVector PreviousRampDirection = FVector(0, 0, 0);
    bool bWaterRunning = false;
    float JetpackLastEnableTime = -1.f;
    float JetpackUsageTime = 0.f;
    FVector DashDesiredVelocity = FVector::ZeroVector;
    float MinDotAllowedOnHook = 0.9f;
    TArray<float> RangeCheckFailsafes;
    float CurrentMaxSpeed = 0.0f;
    float MaxHookshotLength = 0.f;
    float HookshotUsageDuration = 0.f;
    float HookshotDisengagementDistanceSqrd = 0.0f;
    FVector HookshotLocation = FVector::ZeroVector;
    bool bLookTowardsDashMovement = true;
    bool bBreakAfterDashing = false;
    float SpeedBeforeDashing = 0.f;
    int32 CrouchInterpolationID = INDEX_NONE;
    float GroundFrictionCache = INDEX_NONE;
    bool bClambering = false;
    float CrouchSpeed = 0.5f;
    float TimeMovementStartedAt = INDEX_NONE;
    float TimeMovementStoppedAt = INDEX_NONE;
    bool bWasMaximumHeightReached;
 
    //Movement Multipliers:
    float HookshotLengthMultiplier = 1.f;
    float HookshotSpeedMultiplier = 1.f;
    float HookshotMaxSpeedMultiplier = 1.f;
    float AltitudeLimitMultiplier = 1.f;
    float GravityMultiplier = 1.f;
    float GroundSpeedMultiplier = 1.f;
 
};
 
class FSavedMove_PXMovement : public FSavedMove_Character
{
public:
 
    typedef FSavedMove_Character Super;
 
    virtual void SetMoveFor(ACharacter* Character, float InDeltaTime, FVector const& NewAccel, class FNetworkPredictionData_Client_Character& ClientData) override;
 
    virtual uint8 GetCompressedFlags() const override;
 
    virtual void Clear() override;
 
    virtual bool CanCombineWith(const FSavedMovePtr& NewMove, ACharacter* Character, float MaxDelta) const override;
 
    virtual void PrepMoveFor(class ACharacter* Character) override;
 
    uint8 bSavedWantsToDash : 1;
    uint8 bSavedWantsToOmniDash : 1;
    uint8 bSavedWantsToJetPack : 1;
    uint8 bSavedWantsToHookshot : 1;
    uint8 bSavedWantsToAutoClamber : 1;
};
 
class FNetworkPredictionData_Client_PXMovement : public FNetworkPredictionData_Client_Character
{
public:
    FNetworkPredictionData_Client_PXMovement(const UCharacterMovementComponent& ClientMovement);
 
    typedef FNetworkPredictionData_Client_Character Super;
 
    virtual FSavedMovePtr AllocateNewMove() override;
};