[UE] Around 스킬 구현하기

#pragma once
#include "CoreMinimal.h"
#include "Weapons/CSubAction.h"
#include "Weapons/CWeaponStructures.h"
#include "CSubAction_Around.generated.h"
 
UCLASS(Blueprintable)
class U2212_06_API UCSubAction_Around : public UCSubAction
{
	GENERATED_BODY()
 
private:
	UPROPERTY(EditDefaultsOnly, Category = "FallObject")
		TSubclassOf<class ACThornObject> ObjectClass;
 
	UPROPERTY(EditDefaultsOnly, Category = "FallObject")
		FVector ObjectLocation;//Spawn시킬 위치
 
private:
	UPROPERTY(EditDefaultsOnly, Category = "Action")
		FDoActionData ActionData;
 
public:
	UCSubAction_Around();
 
public:
	virtual void Pressed() override;
 
	virtual void Begin_SubAction_Implementation() override;
	virtual void End_SubAction_Implementation() override;
};

#include "Weapons/SubActions/CSubAction_Around.h"
#include "Global.h"
#include "GameFramework/Character.h"
#include "Components/CStateComponent.h"
#include "Components/CMovementComponent.h"
#include "Weapons/AddOns/CThornObject.h"
 
UCSubAction_Around::UCSubAction_Around()
{
 
}
 
void UCSubAction_Around::Pressed()
{
	Super::Pressed();
 
	CheckTrue(State->IsSubActionMode());
	State->OnSubActionMode();
 
	ActionData.DoAction(Owner);
}
 
void UCSubAction_Around::Begin_SubAction_Implementation()
{
	Super::Begin_SubAction_Implementation();
 
	FActorSpawnParameters params;
	params.Owner = Owner;
	params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
 
	FTransform transform;
 
	FVector ownerLocation = Owner->GetActorLocation();
	ownerLocation += Owner->GetActorRotation().RotateVector(ObjectLocation);
 
	transform.SetLocation(ownerLocation);
 
	Owner->GetWorld()->SpawnActor<ACThornObject>(ObjectClass, transform, params);
}
 
void UCSubAction_Around::End_SubAction_Implementation()
{
	Super::End_SubAction_Implementation();
 
	State->OffSubActionMode();
	State->SetIdleMode();
	Movement->Move();
}

#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "NiagaraDataInterfaceExport.h"
#include "Weapons/CWeaponStructures.h"
#include "CThornObject.generated.h"
 
UCLASS()
class U2212_06_API ACThornObject
	: public AActor, public INiagaraParticleCallbackHandler
{
	GENERATED_BODY()
 
private:
	UPROPERTY(EditDefaultsOnly, Category = "Hit")
		FHitData HitData;
 
	UPROPERTY(EditDefaultsOnly, Category = "Niagara")
		class UStaticMesh* NiagaraMesh;//나이아가라 매쉬
 
	UPROPERTY(EditDefaultsOnly, Category = "Niagara")
		FRotator NiagaraMeshRotation;//회전값
 
	UPROPERTY(EditDefaultsOnly, Category = "Collision")
		class UFXSystemAsset* CollisionEffect;//충돌 했을때 이펙트
 
	UPROPERTY(EditDefaultsOnly, Category = "Collision")
		FTransform CollisionEffectTransform;//충돌했을때 보정 위치값
 
private:
	UPROPERTY(VisibleDefaultsOnly)
		class USceneComponent* Root;
 
	UPROPERTY(VisibleDefaultsOnly)
		class UNiagaraComponent* Niagara;
 
public:	
	ACThornObject();
 
protected:
	virtual void BeginPlay() override;
 
public:
	void ReceiveParticleData_Implementation(const TArray<FBasicParticleData>& Data, UNiagaraSystem* NiagaraSystem);
 
private:
	UFUNCTION()
		void OnSystemFinished(class UNiagaraComponent* PSystem);
 
private:
	FVector BoxExtent;//Finished 되었을 때 계산할 Box
};

#include "Weapons/AddOns/CThornObject.h"
#include "Global.h"
#include "NiagaraComponent.h"
#include "GameFramework/Character.h"
 
ACThornObject::ACThornObject()
{
	CHelpers::CreateComponent<USceneComponent>(this, &Root, "Root");//Root 생성
	CHelpers::CreateComponent<UNiagaraComponent>(this, &Niagara, "Niagara", Root);//나이아가라 컴포넌트 생성
}
 
void ACThornObject::BeginPlay()
{
	Super::BeginPlay();
 
	Niagara->SetNiagaraVariableObject("Collision", this);
	Niagara->OnSystemFinished.AddDynamic(this, &ACThornObject::OnSystemFinished);
 
	if (!!NiagaraMesh)//NiagaraMesh가 있다면
	{
		FBox box = NiagaraMesh->GetBoundingBox();//NiagaraMesh 충돌체 사이즈
		BoxExtent = (box.Min - box.Max).GetAbs() * 0.5f;//부피로 전환해서 사용.
	}
}
 
void ACThornObject::ReceiveParticleData_Implementation(const TArray<FBasicParticleData>& Data, UNiagaraSystem* NiagaraSystem)
{
	CheckFalse(Data.Num() > 0);
 
	//박스 추적 //static을 사용하는이유?
	//매 프레임 마다 Tick 결과 데이터가 매번 할당되고 지워져서 stack으로 계속 쌓인다. stack 데이터가 커지는걸 방지하기 위해 static으로 사용한다. static은 한 번 할당하면 제거가 일어나지 않기 때문에 유리하다. 계속 반복 할당되어야 되는것들은 static으로 사용하면 좋다.
	static TArray<AActor*> ignores;
	ignores.AddUnique(GetOwner());
 
	static FHitResult hitResult;
	for(int32 i = Data.Num() - 1; i >= 0; i--)//거꾸로 사용한 이유? 중간에 먼저 삭제되는 경우 TArray가 땡겨져서 문제가 발생할 수 있으므로 거꾸로 처리한다.
	{
		FVector position = Data[i].Position + GetActorLocation();
		FVector scale = Data[i].Velocity * BoxExtent;
 
		UKismetSystemLibrary::BoxTraceSingleByProfile(GetWorld(), position, position, scale, NiagaraMeshRotation, "Pawn", false, ignores, EDrawDebugTrace::ForOneFrame, hitResult, true);//Pawn 추적, 복합충돌 false,
 
		if (hitResult.bBlockingHit)
		{
			if (!!CollisionEffect)
			{
				FTransform transform = CollisionEffectTransform;
				transform.AddToTranslation(hitResult.Location);
 
				CHelpers::PlayEffect(GetWorld(), CollisionEffect, transform);
			}
 
			ACharacter* character = Cast<ACharacter>(hitResult.GetActor());
			if (!!character)
				HitData.SendDamage(Cast<ACharacter>(GetOwner()), this, character);
		}
	}
 
}
 
void ACThornObject::OnSystemFinished(UNiagaraComponent* PSystem)
{
	Destroy();//나이아가라를 제거한다.
}