CustomCharacterBase.h

Go to the documentation of this file.

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Character/ALSCharacter.h"
#include "Data/HealthData.h"
#include "Data/MenuData.h"
#include "Interfaces/BaseInterface.h"
#include "Interfaces/BaseServer.h"
#include "Interfaces/CharacterInterface.h"
#include "Interfaces/CharacterWeaponPickups.h"
#include "Interfaces/InteractionInterface.h"
#include "CustomCharacterBase.generated.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogCustomCharacters, Display, All);
 
 
// DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnCharacterDeath, FPlayerDeath&, PlayerDeath, APawn*, OwnerPawn);
 
 
UCLASS()
class CUSTOMALS_API ACustomCharacterBase : public AALSCharacter, public ICharacterWeaponPickups, public ICharacterInterface, public IBaseInterface, public IBaseServer
{
    GENERATED_BODY()
    
public:
    ACustomCharacterBase(const FObjectInitializer& ObjectInitializer);
 
    // UPROPERTY(BlueprintAssignable)
    // FOnCharacterDeath OnCharacterDeath;
 
    //? Move To ALS?    //
    // Helper Functions
    UFUNCTION(BlueprintPure, Category = "Player")
    bool IsCrouching() const{return Stance == EALSStance::Crouching;};
 
    virtual void NotifyHit(UPrimitiveComponent* MyComp, AActor* Other, UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult& Hit) override;
        
    
    //-  Character Interface    //
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual ECharacterType GetCharacterType() const override;
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual EFactionType GetCharacterFaction() const override;
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual bool GetIsDead() const override{return bIsDead;};
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual void StartThreatIndication(AActor* PawnThreat) override;
    UFUNCTION(BlueprintImplementableEvent, Category = "Custom ALS")
    void OnStartThreatIndication(AActor* PawnThreat);
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual void StopThreatIndication() override;
    UFUNCTION(BlueprintImplementableEvent, Category = "Custom ALS")
    void OnStopThreatIndication();
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual void UpdateThreatIndication(const FVector& Location, const float DetectionAmount) override;
    UFUNCTION(BlueprintImplementableEvent, Category = "Custom ALS")
    void OnUpdateThreatIndication(const FVector& Location, const float DetectionAmount);
    // UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    // virtual USkeletalMeshComponent* GetCharacterMesh() const override {return GetMesh();};
    UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual USkeletalMeshComponent* GetCharacterSecondaryMesh() const override {return GetCustomMesh();};
    // UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    virtual void SetCharacterVehicleMode(const EVehicleMode Mode) override;
 
 
    virtual bool GetCharacterHealth(float& Health, float& MaxHealth) const override;
 
    UFUNCTION(BlueprintImplementableEvent, Category="Custom ALS")
    void OnCharacterVehicleModeChanged(const EVehicleMode Mode);
 
    //- @TODO Add to Character Interface
    UFUNCTION(BlueprintCallable, Category = "Interaction")
    virtual void ForceWakeUp();
 
    
    virtual void ReceiveStartFocus_Implementation(AActor* Caller) override;
    virtual void ReceiveEndFocus_Implementation(AActor* Caller) override;
 
    //-     Interaction Interface       //
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual void OnInteract(AActor* Caller, const int32 InteractionType = 0) override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual void OnEndInteract(AActor* Caller) override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual bool OnOverlap(AActor* Caller) override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual void OnEndOverlap(AActor* Caller) override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual void StartFocus() override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual void EndFocus() override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual void ToggleSwitch(AActor* Caller, bool bOn) override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual FVector GetInteractionLocation() const override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual UPrimitiveComponent* GetGrabComponent() const override;
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual float GetAimAssistInfluence() const override {return AimAssistInfluence;};
 
    // UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Aim Assist")
    // float AimAssistInfluence = 1.0f;
 
 
    
    //-     Base Interface  //
    UFUNCTION(BlueprintCallable, Category = "Base Helpers")
    virtual void SetGravityEnabled(const bool bValue) override;
    UFUNCTION(BlueprintCallable, Category = "Interaction")
    virtual FString GetObjectDisplayName() const override {return DisplayName;};
    UFUNCTION(Server, Reliable)
    virtual void DestroyActor(AActor* ActorToDestroy) override;
    UFUNCTION(NetMulticast, Reliable)
    virtual void DestroyActorOnClient(AActor* ActorToDestroy) override;
    UFUNCTION(BlueprintCallable, Category = "Base Helpers")
    virtual bool GetIsCharacter() const override {return true;};
 
    // virtual void OnFinishSpawning() override;
    
 
    //- Setters //
    UFUNCTION(BlueprintCallable, Category = "Interaction")
    void SetPlayerName(FString Username){DisplayName = Username;};
 
    //- Character Weapons Interface //
    UFUNCTION(BlueprintCallable, Category = "Pickups")
    virtual int32 PickupGunEvent(const FWeaponData_T In_WeaponData) override;
    UFUNCTION(BlueprintCallable, Category = "Pickups")
    virtual bool PickupGunCheck(const FWeaponData_T& In_WeaponData) override;
    UFUNCTION(BlueprintCallable, Category = "Pickups")
    virtual bool PickupAttachmentCheck(const FWeaponAttachment& In_WeaponAttachmentData) override;
    UFUNCTION(BlueprintCallable, Category = "Pickups")
    virtual void PickupAttachmentEvent(const FString& WeaponAttachmentID) override;
 
    //- Shooting Component Bind //
    UFUNCTION()
    virtual void WeaponEquipped(const TArray<FWeaponData_T>& Weapons, const int32 CurrentWeaponIndex);
    UFUNCTION()
    virtual void WeaponStateChanged(const struct FPlayerWeaponState& PlayerWeaponState);
 
    //- ALS overridden Functions    // 
    virtual void ForwardMovementAction(float Value) override;
    virtual void RightMovementAction(float Value) override;
 
    virtual void RagdollStart() override;
    virtual void RagdollEnd() override;
    virtual void Landed(const FHitResult& Hit) override;
    virtual EALSGait GetAllowedGait() const override;
    virtual bool CanSprint() const override;
    virtual void SprintAction(bool bValue) override;
    virtual void JumpAction(bool bValue) override;
    virtual bool CanJumpInternal_Implementation() const override;
    virtual void StanceAction() override;
    virtual void OnJumped_Implementation() override;
 
    void FlyUp();
    void FlyDown();
 
    //@ TODO Remove This and Replace with OnPawnSpawned //
    //-     Use for multiplayer instead of Begin Play   //
    UFUNCTION(Server, Reliable)
    void Server_OnPawnSpawn();
    // virtual void OnPawnSpawn();
    virtual void OnPawnSpawned() override;
    UFUNCTION(BlueprintImplementableEvent, Category="Player", meta=(DisplayName = "On Pawn Spawn"))
    void ReceiveOnPawnSpawn();
 
protected:
    virtual void BeginPlay() override;
    virtual void Tick(const float DeltaTime) override;
    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
 
 
    // UFUNCTION(BlueprintCallable, Category = "Custom ALS")
    // void ShowMeshOutline(const bool bOn) const;
 
    
    //-     Components      //
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Health")
    class UCharacterHealthComponent* CharacterHealthComponent;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Health")
    class UHealthBarWidgetComponent* HealthBarComponent;
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Interaction")
    // class UInteractionComponent* InteractionComponent;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Hit Reactions")
    class UPhysicalAnimationComponent* PhysicalAnimationComponent;
    
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Hit Reactions")
    // class UAudioReactionComponent* AudioReactionComponent;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Hit Reactions")
    class UPhysicalHitReactionsComponent* PhysicalHitReactionComponent;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Melee")
    class UMeleeComponent* MeleeComponent;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Footsteps")
    class UFootstepFXHandler* FootstepsComponent; 
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Aim Assist")
    class USphereComponent* AimAssistSphereComponent;
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Shooting")
    class URecoilAnimationComponent* RecoilAnimationComponent;
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Shooting")
    // class UCharacterShootingComponent* ShootingComponent;
 
    
    UPROPERTY(BlueprintReadOnly, Category="Mantle")
    class UALSMantleComponent* MantleComponentReference;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Custom ALS")
    USkeletalMeshComponent* CustomSkeletalMesh;
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Pickups")
    // USceneComponent* ThrowPoint;
    // UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Weapon")
    // UChildActorComponent* CurrentWeapon;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Custom ALS|Debugging")
    float MultiplayerStartDelay = 0.5f;
 
 
    //- Velocity of a regular jump ~420 so remove that first
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Custom ALS|Character")
    float FallDamageOffset = 550.0f;
    //- At the fall height, eg. 1000.f divide by x 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Custom ALS|Character")
    float FallDamageDivisor = 5.0f;
 
    // UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Interaction")
    // bool bShouldPickupOnOverlap = false;
    
    // UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "Player|Material")
    // bool bAlwaysShowOutline = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Custom ALS")
    ECharacterType CharacterType = ECharacterType::Human;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Name")
    FString DisplayName = "Default Name";
 
    
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Custom ALS|Stamina")
    bool bForceWalkWhileAiming = true;
 
 
    
    //@TODO Move these to a PhysicalStateComponent  //
    //-         Stamina         //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    bool bToggleSprint = true;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Custom ALS|Stamina")
    bool bSprinting = true;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float SprintDeadZone = 0.5f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Flying")
    float FlyingScaleValue = 1.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Custom ALS|Flying")
    bool bIsFlyingUp = false;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Custom ALS|Flying")
    bool bIsFlyingDown = false;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Custom ALS|Stamina")
    float Stamina = 100.0f;
    //- Minimum required before an action is available, Percent of Max Stamina (0.2 = 20% of MaxStamina)    //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float MinRequiredStamina = 0.2f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float MaxStamina = 60.0f;
    float MaxStaminaDefault = 60.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float MaxPossibleStamina = 150.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float MinStamina = 10.0f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float StaminaDepletionRate = 0.05f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float StaminaDepletionIncrement = 0.5f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float StaminaRechargeRate = 0.05f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float StaminaRechargeIncrement = 0.5f;
 
    //-     How long before it starts recharging    //
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float StaminaRechargeDelayTime = 2.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Stamina")
    float StaminaJumpAmount = 10.0f;
 
    //-     Hit/Pushing     //
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // bool bCanBePushed = true; 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // float HitVelocityThreshold = 50.0f; 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // float HitVelocityMultiplier = 5.0f; 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // float HitReactionMultiplier = 0.01f; 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // bool bPushHitReaction = true;
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // bool bAddMovementInput = true;
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // bool bAddCharacterMovement = true;
    // //- How much Velocity by self to fall over   //
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // float PushFallVelocityThreshold = 200.0f;
    // //- How much Velocity by someone Pushing to fall over    //
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // float PushedFallVelocityThreshold = 500.0f; 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS|Pushing")
    // float PushedFallOverWaitTime = 2.0f; 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS")
    float ThrowStrength = 500.0f;
 
    UFUNCTION(BlueprintCallable, Category="Custom ALS")
    bool GetHandsTied() const {return bHandsTied;}
    UFUNCTION(BlueprintCallable, Category="Custom ALS")
    virtual void SetHandsTied(const bool bValue = true);
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category= "Custom ALS")
    bool bHandsTied = false;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS")
    float AimAssistRadius = 160.0f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "Custom ALS")
    float AimAssistShrinkTime = 3.0f;
    
    // void TakePointDamage(AActor* DamagedActor, float Damage, class AController* InstigatedBy, FVector HitLocation, class UPrimitiveComponent* FHitComponent, FName BoneName, FVector ShotFromDirection, const class UDamageType* DamageType, AActor* DamageCauser);
    UFUNCTION()
    virtual void AimAssistOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, const int32 OtherBodyIndex, const bool bFromSweep, const FHitResult& SweepResult);
    UFUNCTION(BlueprintImplementableEvent, Category="Aim Assist")
    void OnAimAssistOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, const int32 OtherBodyIndex, const bool bFromSweep, const FHitResult& SweepResult);
    UFUNCTION()
    virtual void AimAssistRevertSize();
 
    // /Delegate 
    // UFUNCTION(BlueprintCallable, Category="Player")
    // virtual void FallOver(const float WaitTime);
    // UFUNCTION(BlueprintImplementableEvent, Category="Player")
    // void OnFallOver(const float WaitTime);
    //
    // UFUNCTION(BlueprintCallable, Category="Player")
    // virtual void GetUpFromFall();
    // UFUNCTION(BlueprintImplementableEvent, Category="Player")
    // void OnGetUpFromFall();
 
 
 
    
    //-  Health Component Functions //
    UFUNCTION()
    virtual void OnHealthAndShieldChanged(float Health, float MaxHealth, float ShieldHealth, float MaxShieldHealth, const class UDamageType* DamageType);
    UFUNCTION()
    virtual void OnInjuredBodyPart(const EBodyPartName InjuredBodyPart, const FVector& HitLocation, const TArray<FBodyPart>& AllBodyParts);
    UFUNCTION()
    virtual void OnShieldBreak();
    UFUNCTION()
    virtual void OnKnockedOut(const class UDamageType* DamageType, const float WaitTime);
    UFUNCTION()
    virtual void OnWakeUp();
    UFUNCTION()
    virtual void OnDeath(AActor* OwningActor, const EDeathType DeathType, AActor* DeathCauser, AController* DeathInstigator);
    UFUNCTION()
    virtual void OnFullDamageHit(AController* InstigatedBy, const float TotalDamage, const UDamageType* DamageType, const FName& HitBone, const FVector& HitLocation, const bool bKillingHit, const bool bInjuredPart);
 
    FPlayerDeath GetPlayerDeathInfo(const EDeathType DeathType, AActor* DeathCauser, const AController* DeathInstigator) const;
    
    UFUNCTION(BlueprintPure, BlueprintCallable, Category = "Custom ALS")
    USkeletalMeshComponent* GetCustomMesh() const{return CustomSkeletalMesh;}
    
    bool bIsNPC = false;
    UPROPERTY(ReplicatedUsing=OnDeathReplicated)
    bool bIsDead = false;
    
    UFUNCTION()
    virtual void OnDeathReplicated();
 
    virtual void FirePressedAction();
    virtual void SetupComponents(AController* ControllerReference = nullptr, AActor* HUDReference = nullptr, bool bIsLocallyControlled = false);
 
    //-     Save Load Game      //
    UFUNCTION(BlueprintCallable, Category = "Save Game")
    virtual void SaveGameData();
    UFUNCTION(BlueprintCallable, Category = "Save Game")
    virtual void LoadGameData();
 
    virtual bool SaveCharacterData();
    virtual bool LoadCharacterData();
 
    
    virtual void LoadComponentsSaveData();
    virtual void SaveComponentsData();
    
    
    //-  Stamina    //
    virtual void UpdateStaminaHUD();
    virtual void Sprinting();
    virtual void StopSprinting();
    virtual void RechargeStamina();
    virtual void SetMaxStamina(const float AmountToAdd);
 
    
    // UFUNCTION(BlueprintCallable, Category = "Interaction")
    // virtual FInteractionData GetInteractionData() const override{return InteractionData;};
    // UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
    // FInteractionData InteractionData = FInteractionData(EInteractionType::Talk, EAIStimuliType::Character);
    //
    // /** Interaction Data Manipulation, so Actors can change there Interaction Data struct from BP */
    // //~          Interaction Data Manipulation               ~//
    // virtual bool SetInteractionHidden(const EInteractionType Interaction, const bool bValue) override
    // {return InteractionData.SetInteractionHidden(Interaction, bValue);};
    // virtual void SetOnlyInteractionVisible(const EInteractionType Interaction) override
    // {InteractionData.SetOnlyInteractionVisible(Interaction);}
    //
    // virtual bool SetInteractionAvailable(const EInteractionType Interaction, const bool bValue) override
    // {return InteractionData.SetInteractionAvailable(Interaction, bValue);}
    //
    // virtual bool SetInteractionHold(const EInteractionType Interaction, const bool bValue) override
    // {return InteractionData.SetInteractionHold(Interaction, bValue);}
    //
    // virtual TArray<FInteractionType> GetVisibleInteractions() const override
    // {return InteractionData.GetVisibleInteractions();}
    // virtual bool GetInteraction(FInteractionType& Type, const EInteractionType Interaction) const override
    // {return InteractionData.GetInteraction(Type, Interaction);}
    // virtual bool GetDefaultInteraction(FInteractionType& Type) const override
    // {return InteractionData.GetDefaultInteraction(Type);}
 
    //~         Interaction Data Manipulation               ~//
 
 
    UPROPERTY(ReplicatedUsing=OnCharacterReadyReplicated, VisibleAnywhere, BlueprintReadOnly, Category="Character|Replication")
    bool bCharacterReady = false;
    
    UFUNCTION()
    void OnCharacterReadyReplicated();
 
private:
 
    FTimerHandle StaminaTimerHandle;
    FTimerHandle StaminaRechargeTimerHandle;
    FTimerHandle FallOverTimerHandle;
    FTimerHandle FlyingTimerHandle;
 
 
    FTimerHandle AimAssistOverlapTimerHandle;
    
};