ProjectileBase.h

이 파일의 문서화 페이지로 가기

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CK_UE.h"
#include "GameFramework/Actor.h"
#include "Interface/ObjectPoolingInterface.h"
#include "Interface/Combat/TargetableInterface.h"
#include "ProjectileBase.generated.h"
 
class UNiagaraComponent;
class UNiagaraSystem;
class UProjectilePilotComponent;
class ULevelSequence;
class ULevelSequencePlayer;
 
 
UENUM(BlueprintType)
enum class EProjectileState : uint8
{
    Uninitialized,
    Initialized,
    Launched,
    InFlight,
    Collided,
    Finished
};
 
UENUM(BlueprintType)
enum class EProjectileFinishReason : uint8
{
    Timeout,
    Collision,
    ExternalTermination,
    DestinationReached,
};
 
UENUM(BlueprintType)
enum class EProjectileDeactivationOption : uint8
{
    Immediate,
    Manual,
    Delay,
    Sequencer
};
 
UENUM()
enum class EProjectileMeshRotationMode : uint8
{
    None UMETA(DisplayName = "회전 안 함"),
    RotationRate UMETA(DisplayName = "회전 속도"),
    FaceVelocity UMETA(DisplayName = "진행 방향 바라보기")
};
 
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FProjectileFinishedDelegate, const AProjectileBase*, Projectile, const EProjectileFinishReason, FinishReason, const AActor*, Terminator);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FProjectileCollidedDelegate, AActor*, SelfActor, AActor*, OtherActor, FVector, NormalImpulse, const FHitResult&, Hit);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FProjectileDeactivatedDelegate, AProjectileBase*, Projectile, const EProjectileDeactivationOption, Option);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FProjectileLaunchedDelegate, const AProjectileBase*, Projectile);
 
 
UCLASS() 
class CK_UE_API UCollisionUserData : public UAssetUserData
{
    GENERATED_BODY()
    
public:
    UPROPERTY(Transient)
    TWeakObjectPtr<AActor> CachedTerminator;
    
    UPROPERTY(Transient)
    FVector CachedImpactPoint = FVector::ZeroVector;
};
 
 
UCLASS(Abstract, BlueprintType)
class CK_UE_API AProjectileBase : public AActor, public IObjectPoolingInterface
{
    GENERATED_BODY()
 
public:
    AProjectileBase();
 
public:
    virtual void ForceEarlyFinish(const AActor* Terminator, const EProjectileFinishReason FinishReason);
    virtual void OnLaunched(AActor* LauncherOwner, const FVector& InStart, const FVector& InDirectionOrTarget);
    bool OverridePendingLaunchPath(const FVector& InStart, const FVector& InDirectionOrTarget);
    void SetMeshWorldRotation(const FRotator& WorldRotation);
 
    virtual void OnFinished(const FVector TerminatedPosition, const AActor* Terminator, EProjectileFinishReason FinishReason) { }
    virtual void OnCollided(const AActor* HitTarget, const FHitResult& Hit) { }
    virtual void OnInFlight(const float DeltaTime) { }
    virtual void Tick(float DeltaSeconds) override;
 
public:
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE EProjectileState GetProjectileState() const
    {
        return CurrentProjectileState;
    }
 
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE float GetElapsedTimeSinceLaunch() const
    {
        return GetWorld()->GetTimeSeconds() - LaunchTime;
    }
 
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE float GetFinishTime() const
    {
        return GetWorld()->GetTimeSeconds() - FinishTime;
    }
 
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE UProjectilePilotComponent* GetProjectilePilotComponent() const
    {
        return ProjectilePilotComponent;
    }
 
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE AActor* GetShootOwner() const
    {
        return ShootOwner;
    }
 
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE bool IsLaunched() const
    {
        return CurrentProjectileState == EProjectileState::Launched;
    }
 
    UFUNCTION(BlueprintPure, Category = "Projectile")
    FORCEINLINE bool ShootOwnerIsValid() const
    {
        return ShootOwner.Get() != nullptr;
    }
 
protected:
    virtual void BeginPlay() override;
    virtual void OnSpawnFromPool_Implementation() override;
    virtual void OnReturnToPool_Implementation() override;
    void ApplyPawnCollisionResponse() const;
 
protected:
    UFUNCTION(BlueprintPure, Category="Projectile")
    virtual FTransform GetCollisionParticleTransform(const AActor* OtherActor, const FHitResult& Hit) const
    {
        return FTransform(Hit.ImpactNormal.Rotation(), Hit.ImpactPoint);
    }
 
private:
    UFUNCTION()
    void OnProcessCollision(AActor* SelfActor, AActor* OtherActor, FVector NormalImpulse, const FHitResult& Hit);
 
    UFUNCTION()
    void OnExplosionEffectFinished(UNiagaraComponent* NiagaraComponent);
 
    UFUNCTION()
    void OnDeactivationProcessingFinished();
 
    UFUNCTION()
    void FinalizeProjectileState(const FVector ImpactPoint, const AActor* Terminator, EProjectileFinishReason FinishReason);
 
    void ResetMeshRotation();
 
    void UpdateProjectileRotation(float DeltaTime);
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile|Deactivation")
    EProjectileDeactivationOption DeactivationOption = EProjectileDeactivationOption::Immediate;
    
    UPROPERTY(BlueprintAssignable, Category = "Projectile")
    FProjectileLaunchedDelegate OnProjectileLaunchedDelegate;
 
    UPROPERTY(BlueprintAssignable, Category = "Projectile")
    FProjectileFinishedDelegate OnProjectileFinishedDelegate;
 
    UPROPERTY(BlueprintAssignable, Category = "Projectile")
    FProjectileCollidedDelegate OnProjectileCollidedDelegate;
 
    UPROPERTY(BlueprintAssignable, Category = "Projectile")
    FProjectileDeactivatedDelegate OnProjectileDeactivatedDelegate;
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile|Deactivation", meta = (EditCondition = "DeactivationOption == EProjectileDeactivationOption::Delay", EditConditionHides))
    float DeactivationDelay = 0.0f;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile|Deactivation", meta = (EditCondition = "DeactivationOption == EProjectileDeactivationOption::Sequencer", EditConditionHides))
    TObjectPtr<ULevelSequence> DeactivationSequencer;
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile")
    TObjectPtr<UProjectilePilotComponent> ProjectilePilotComponent;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile")
    TObjectPtr<UStaticMeshComponent> MeshComponent;
 
    UPROPERTY(EditDefaultsOnly, Category = "Projectile|Visual")
    EProjectileMeshRotationMode MeshRotationMode = EProjectileMeshRotationMode::FaceVelocity;
 
    UPROPERTY(EditDefaultsOnly, Category = "Projectile|Visual", meta = (EditCondition = "MeshRotationMode == EProjectileMeshRotationMode::RotationRate", EditConditionHides))
    FRotator MeshRotationRate = FRotator::ZeroRotator;
 
    // true: Pawn과 충돌, false: Pawn을 무시하고 월드 지오메트리와 충돌
    UPROPERTY(EditDefaultsOnly, Category = "Projectile|Collision")
    bool bCollideWithPawn = false;
    
protected:
    UPROPERTY(Transient, BlueprintReadOnly, Category = "Projectile")
    TObjectPtr<AActor> ShootOwner;
 
private:
    UPROPERTY(BlueprintReadOnly, Category = "Projectile", meta = (AllowPrivateAccess = "true"))
    EProjectileState CurrentProjectileState = EProjectileState::Uninitialized;
 
    UPROPERTY(BlueprintReadOnly, Category = "Projectile", meta = (AllowPrivateAccess = "true"))
    float LaunchTime = 0.0f;
 
    UPROPERTY(BlueprintReadOnly, Category = "Projectile", meta = (AllowPrivateAccess = "true"))
    float FinishTime = 0.0f;
 
private:
    FRotator InitialMeshRotation = FRotator::ZeroRotator;
    FVector PendingLaunchStart = FVector::ZeroVector;
    FVector PendingLaunchDirectionOrTarget = FVector::ZeroVector;
    bool bHasPendingLaunchPath = false;
 
    FTimerHandle DeactivationTimerHandle;
};