Feature/Anomaly: 귀신 손 이상현상 및 불태우기 나이아가라

Source/Endless_Hotel/Anomaly/EightExit/GhostHand/Anomaly_GhostHand.cpp

@@ -0,0 +1,147 @@
+// Copyright by 2025-2 WAP Game 2 team
+
+
+#include "Anomaly/EightExit/GhostHand/Anomaly_GhostHand.h"
+#include "Components/StaticMeshComponent.h"
+#include "Kismet/GameplayStatics.h"
+#include "GameFramework/Character.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "GameFramework/CharacterMovementComponent.h"
+#include "Player/Controller/EHPlayerController.h"
+#include "TimerManager.h"
+
+#pragma region Base
+
+AAnomaly_GhostHand::AAnomaly_GhostHand(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	PrimaryActorTick.bCanEverTick = false;
+
+	SM_Hand = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("SM_Hand"));
+	SM_Hand->SetupAttachment(RootComponent);
+	SM_Hand->SetVisibility(false);
+	SM_Hand->SetHiddenInGame(true);
+	SM_Hand->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+}
+
+void AAnomaly_GhostHand::BeginPlay()
+{
+	Super::BeginPlay();
+}
+
+void AAnomaly_GhostHand::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	ClearRunLock();
+	Super::EndPlay(EndPlayReason);
+}
+#pragma endregion
+
+#pragma region Activity
+void AAnomaly_GhostHand::ActivateAnomaly(uint8 Anomaly_ID)
+{
+	Super::ActivateAnomaly(Anomaly_ID);
+	ExecuteGhostHand();
+}
+#pragma endregion
+
+#pragma region GhostHand
+void AAnomaly_GhostHand::ExecuteGhostHand()
+{
+	ACharacter* Player = UGameplayStatics::GetPlayerCharacter(GetWorld(), 0);
+	if (!Player)
+	{
+		return;
+	}
+
+	USkeletalMeshComponent* PlayerMesh = Player->GetMesh();
+	if (!PlayerMesh)
+	{
+		return;
+	}
+
+	const FAttachmentTransformRules Rules(EAttachmentRule::SnapToTarget, true);
+	SM_Hand->AttachToComponent(PlayerMesh, Rules, AttachSocketName);
+
+	SM_Hand->SetRelativeLocation(AttachLocationOffset);
+	SM_Hand->SetRelativeRotation(AttachRotationOffset);
+	SM_Hand->SetRelativeScale3D(AttachScale);
+
+	SM_Hand->SetHiddenInGame(false);
+	SM_Hand->SetVisibility(true);
+
+	if(bLockRun)
+	{
+		ApplyRunLock();
+	}
+}
+#pragma endregion
+
+#pragma region RunLock
+void AAnomaly_GhostHand::ApplyRunLock()
+{
+	ACharacter* Player = UGameplayStatics::GetPlayerCharacter(GetWorld(), 0);
+	if (!Player)
+	{
+		return;
+	}
+	if (AEHPlayerController* PC = Cast<AEHPlayerController>(UGameplayStatics::GetPlayerController(GetWorld(),0)))
+	{
+		if (!bSaved)
+		{
+			SavedCanRun = PC->bCanRun;
+		}
+		PC->bCanRun = false;
+	}
+	UCharacterMovementComponent* Move = Player->GetCharacterMovement();
+	if (!Move)
+	{
+		return;
+	}
+	if (!bSaved)
+	{
+		SavedMaxWalkSpeed = Move->MaxWalkSpeed;
+		bSaved = true;
+	}
+
+	Move->MaxWalkSpeed = LockedWalkSpeed;
+
+	GetWorld()->GetTimerManager().ClearTimer(ReapplySpeedHandle);
+	GetWorld()->GetTimerManager().SetTimer(ReapplySpeedHandle, FTimerDelegate::CreateLambda([this]()
+		{
+			ACharacter* P = UGameplayStatics::GetPlayerCharacter(GetWorld(), 0);
+			if (!P)
+			{
+				return;
+			}
+
+			if (UCharacterMovementComponent* M = P->GetCharacterMovement())
+			{
+				M->MaxWalkSpeed = LockedWalkSpeed;
+			}
+		}), ReapplyInterval, true);
+}
+
+void AAnomaly_GhostHand::ClearRunLock()
+{
+	if (GetWorld())
+	{
+		GetWorld()->GetTimerManager().ClearTimer(ReapplySpeedHandle);
+	}
+
+	if (bSaved)
+	{
+		if (ACharacter* Player = UGameplayStatics::GetPlayerCharacter(GetWorld(), 0))
+		{
+			if (UCharacterMovementComponent* Move = Player->GetCharacterMovement())
+			{
+				Move->MaxWalkSpeed = SavedMaxWalkSpeed;
+			}
+		}
+		bSaved = false;
+	}
+	if (AEHPlayerController* PC = Cast<AEHPlayerController>(UGameplayStatics::GetPlayerController(GetWorld(), 0)))
+	{
+		PC->bCanRun = SavedCanRun;
+	}
+}
+#pragma endregion

Source/Endless_Hotel/Anomaly/EightExit/GhostHand/Anomaly_GhostHand.h

@@ -0,0 +1,72 @@
+// Copyright by 2025-2 WAP Game 2 team
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Anomaly/Base/Anomaly_Base_EightExit.h"
+#include "Anomaly_GhostHand.generated.h"
+
+UCLASS()
+class ENDLESS_HOTEL_API AAnomaly_GhostHand : public AAnomaly_Base_EightExit
+{
+	GENERATED_BODY()
+
+#pragma region Base
+public:
+	AAnomaly_GhostHand(const FObjectInitializer& ObjectInitializer);
+
+protected:
+	virtual void BeginPlay() override;
+	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+#pragma endregion
+
+#pragma region Activity
+public:
+	virtual void ActivateAnomaly(uint8 Anomaly_ID) override;
+#pragma endregion
+
+#pragma region GhostHand
+protected:
+	UPROPERTY(VisibleAnywhere, Category="GhostHand|Component")
+	TObjectPtr<class UStaticMeshComponent> SM_Hand;
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|Attach")
+	FName AttachSocketName = TEXT("Hand_Leg");
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|Attach")
+	FVector AttachLocationOffset = FVector::ZeroVector;
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|Attach")
+	FRotator AttachRotationOffset = FRotator::ZeroRotator;
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|Attach")
+	FVector AttachScale = FVector(1.f, 1.f, 1.f);
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|Time")
+	float StartDelay = 0.5f;
+
+	void ExecuteGhostHand();
+
+	FTimerHandle StartDelayHandle;
+#pragma endregion
+
+#pragma region RunLock
+	UPROPERTY(EditAnywhere, Category = "GhostHand|RunLock")
+	bool bLockRun = true;
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|RunLock")
+	float LockedWalkSpeed = 300.f;
+
+	UPROPERTY(EditAnywhere, Category = "GhostHand|RunLock")
+	float ReapplyInterval = 0.05f;
+
+	FTimerHandle ReapplySpeedHandle;
+
+	bool bSaved = false;
+	float SavedMaxWalkSpeed = 0.f;
+	bool SavedCanRun = true;
+
+	void ApplyRunLock();
+	void ClearRunLock();
+#pragma endregion
+};

Source/Endless_Hotel/Anomaly/Neapolitan/Painting/Anomaly_Painting.cpp

@@ -34,6 +34,14 @@ void AAnomaly_Painting::ActivateAnomaly(uint8 Anomaly_ID)
 			});
 		StartImmediate();
 		break;
+
+	case 92:
+		AnomalyAction = ([](AAnomaly_Object_Base* Portrait)
+			{
+				Cast<AAnomaly_Object_Painting>(Portrait)->FrameTilt();
+			});
+		ActiveTrigger();
+		break;
 	}
 }
 

Source/Endless_Hotel/Anomaly/Object/Painting/Anomaly_Object_Painting.cpp

@@ -7,6 +7,8 @@
 #include <Niagara/Public/NiagaraComponent.h>
 #include <Components/WidgetComponent.h>
 #include <Components/BoxComponent.h>
+#include <Components/StaticMeshComponent.h>
+#include <Components/SceneComponent.h>
 #pragma region Base
 
 AAnomaly_Object_Painting::AAnomaly_Object_Painting(const FObjectInitializer& ObjectInitializer)
@@ -99,6 +101,111 @@ void AAnomaly_Object_Painting::BlurPaint()
 
 #pragma endregion
 
+#pragma region FrameTilt
+
+void AAnomaly_Object_Painting::FrameTilt()
+{
+	UE_LOG(LogTemp, Warning, TEXT("[FrameTilt] Called"));
+
+	if (!GetWorld())
+	{
+		return;
+	}
+
+	GetWorld()->GetTimerManager().ClearTimer(FrameTiltDelayHandle);
+	GetWorld()->GetTimerManager().ClearTimer(FrameTiltInterpHandle);
+	FrameInitialRotMap.Empty();
+
+	TArray<AActor*> AllActors;
+	UGameplayStatics::GetAllActorsOfClass(GetWorld(), AActor::StaticClass(), AllActors);
+
+	for (AActor* FrameActor : AllActors)
+	{
+		if (!FrameActor)
+		{
+			continue;
+		}
+		USceneComponent* TargetRoot = nullptr;
+		TArray<USceneComponent*> SceneComps;
+		FrameActor->GetComponents<USceneComponent>(SceneComps);
+
+		for (USceneComponent* SC : SceneComps)
+		{
+			if (SC && SC->ComponentHasTag(FName("FrameRoot")))
+			{
+				TargetRoot = SC;
+				break;
+			}
+		}
+
+		if (!TargetRoot)
+		{
+			TargetRoot = FrameActor->GetRootComponent();
+		}
+
+		if (!TargetRoot)
+		{
+			continue;
+		}
+
+		TargetRoot->SetMobility(EComponentMobility::Movable);
+
+		FrameInitialRotMap.Add(FrameActor, FrameActor->GetActorRotation());
+	}
+	UE_LOG(LogTemp, Warning, TEXT("[FrameTilt] Targets: %d"), FrameInitialRotMap.Num());
+	GetWorld()->GetTimerManager().SetTimer(FrameTiltDelayHandle, FTimerDelegate::CreateWeakLambda(this, [this]()
+		{
+			if (!GetWorld())
+			{
+				return;
+			}
+
+			FrameTiltStartTime = GetWorld()->GetTimeSeconds();
+			FrameTiltDuration = FMath::FRandRange(FrameTiltInterpMin, FrameTiltInterpMax);
+			FrameTiltTargetRoll = FMath::FRandRange(FrameTiltRollMin, FrameTiltRollMax);
+
+			GetWorld()->GetTimerManager().SetTimer(FrameTiltInterpHandle, FTimerDelegate::CreateWeakLambda(this, [this]()
+				{
+					if (!GetWorld())
+					{
+						return;
+					}
+
+					const float Now = GetWorld()->GetTimeSeconds();
+					const float Alpha = FMath::Clamp((Now - FrameTiltStartTime) / FMath::Max(FrameTiltDuration, 0.001f), 0.f, 1.f);
+					for (auto& Pair : FrameInitialRotMap)
+					{
+						AActor* TargetActor = Pair.Key.Get();
+						if (!TargetActor)
+						{
+							continue;
+						}
+
+						const FRotator InitialRot = Pair.Value;
+						const float NewRoll = FMath::Lerp(InitialRot.Roll, InitialRot.Roll + FrameTiltTargetRoll, Alpha);
+						FRotator NewRot = InitialRot;
+						NewRot.Roll = NewRoll;
+						TargetActor->SetActorRotation(NewRot);
+					}
+					if (Alpha >= 1.f)
+					{
+						GetWorld()->GetTimerManager().ClearTimer(FrameTiltInterpHandle);
+					}
+				}), 0.02f, true);
+		}), FrameTiltDelay, false);
+}
+#pragma endregion
+
+void AAnomaly_Object_Painting::Interacted_Implementation()
+{
+	bSolved = !bSolved;
+}
+
+void AAnomaly_Object_Painting::ShowInteractWidget_Implementation(bool bIsShow)
+{
+	UI_Interact->ShowDescription(bIsShow);
+}
+#pragma endregion
 #pragma region Interact
 
 void AAnomaly_Object_Painting::Interacted_Implementation()
@@ -135,4 +242,4 @@ void AAnomaly_Object_Painting::InteractedMoveStep(int32 step)
 		true, true, 0.2f, false, EMoveComponentAction::Type::Move, LatentInfo);
 }
 
-#pragma endregion
+#pragma endregion