FoodHolder.cpp

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

// Copyright (c) 2025 Doppleddiggong. All rights reserved. Unauthorized copying, modification, or distribution of this file, via any medium is strictly prohibited. Proprietary and confidential.
 
 
#include "FoodHolder.h"
 
#include "ADoor.h"
#include "ALingoGameState.h"
#include "Food.h"
#include "GameLogging.h"
#include "ANetworkBroadcastActor.h"
#include "CityName.h"
#include "FoodCourtManager.h"
#include "OrderKiosk.h"
#include "Popup_Result.h"
#include "UBroadcastManager.h"
#include "UPopupManager.h"
#include "Onepiece/Onepiece.h"
#include "Components/BoxComponent.h"
#include "Components/SkeletalMeshComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Net/UnrealNetwork.h"
 
AFoodHolder::AFoodHolder()
{
    PrimaryActorTick.bCanEverTick = true;
 
    // Replication
    bReplicates = true;
 
    // Root component
    USceneComponent* Root = CreateDefaultSubobject<USceneComponent>(TEXT("DefaultSceneRoot"));
    RootComponent = Root;
 
    // Mesh component
    MeshComponent = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("MeshComponent"));
    MeshComponent->SetupAttachment(RootComponent);
 
    // Box collision component
    BoxCollision = CreateDefaultSubobject<UBoxComponent>(TEXT("BoxCollision"));
    BoxCollision->SetupAttachment(MeshComponent);
    BoxCollision->SetGenerateOverlapEvents(true);
    BoxCollision->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    BoxCollision->SetCollisionResponseToAllChannels(ECR_Overlap);
 
    // HoldPos component
    HoldPos = CreateDefaultSubobject<USceneComponent>(TEXT("HoldPos"));
    HoldPos->SetupAttachment(MeshComponent);
}
 
void AFoodHolder::BeginPlay()
{
    Super::BeginPlay();
 
    BoxCollision->OnComponentBeginOverlap.AddDynamic(this, &AFoodHolder::OnFoodBoxOverlapBegin);
 
    // 머티리얼 파라미터 초기화 (비활성화 상태)
    UpdateActivateState(false);
}
 
void AFoodHolder::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    // CurTarget이 유효하고 활성화된 상태라면 회전
    if (bIsActivated && CurTarget)
    {
        FRotator CurrentRotation = CurTarget->GetActorRotation();
        CurrentRotation.Yaw += RotationSpeed * DeltaTime;
        CurTarget->SetActorRotation(CurrentRotation);
    }
}
 
void AFoodHolder::GetLifetimeReplicatedProps(TArray<class FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(AFoodHolder, bIsActivated);
    DOREPLIFETIME(AFoodHolder, CurTarget);
    DOREPLIFETIME(AFoodHolder, TryIdx);
}
 
void AFoodHolder::OnRep_IsActivated()
{
    // bIsActivated가 복제될 때 머티리얼 업데이트
    UpdateActivateState(bIsActivated);
}
 
void AFoodHolder::OnRep_CurTarget()
{
    // CurTarget이 복제될 때 클라이언트에서도 충돌 비활성화
    if (CurTarget)
    {
        if (AFood* Food = Cast<AFood>(CurTarget))
        {
            if (Food->Mesh)
            {
                Food->Mesh->SetSimulatePhysics(false);
                Food->Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
            }
            PRINTLOG(TEXT("AFoodHolder::OnRep_CurTarget - Disabled collision for Food on client"));
        }
    }
}
 
void AFoodHolder::SetAnswerFoodIndex(int32 InAnswerFoodIndex)
{
    this->AnswerFoodIndex = InAnswerFoodIndex;
}
 
void AFoodHolder::OnFoodBoxOverlapBegin(
    UPrimitiveComponent* OverlappedComponent,
    AActor* OtherActor,
    UPrimitiveComponent* OtherComp,
    int32 OtherBodyIndex,
    bool bFromSweep,
    const FHitResult& SweepResult)
{
    if (!OtherActor)
        return;
 
    if (!HasAuthority())
        return;
 
    if (bIsActivated)
        return;
 
    ALingoGameState* GS = Cast<ALingoGameState>(GetWorld()->GetGameState());
    if (!GS) return;
 
    TryIdx++;
 
    // Food인지 확인
    if (AFood* Food = Cast<AFood>(OtherActor))
    {
        // 정답 판정
        const bool bSuccess = CheckFood(Food);
 
        // 제출 리스트에 제출 데이터 업데이트
        FScenarioTargetData TempData;
        TempData.word1 = Food->CurrentFoodData.word1;
        TempData.word2 = Food->CurrentFoodData.word2;
        GS->TryListenAnswerData.target_data.Add(TempData);
        
        // 블루프린트 이벤트 호출
        OnActivate(bSuccess);
        
        if (bSuccess)
        {
            UE_LOG(LogTemp, Warning, TEXT("[FoodHolder] Correct"));
            
            GS->SetAllCompassVisibility(false);
            GS->SetCompassVisibilityByTag("ListenQuestEnd", true);
            
            // 정답인 경우
            FTimerHandle TimerHandle;
            GetWorldTimerManager().SetTimer(TimerHandle, [this, Food]
            {
                ANetworkBroadcastActor::Get(GetWorld())->SendDoorMessage(DoorGroup::Step2_End, true, this);
 
                // 모든 액터의 글씨 없애기
                AActor* FoodContainerManager = UGameplayStatics::GetActorOfClass(GetWorld(), AFoodCourtManager::StaticClass());
                if (AFoodCourtManager* FCManager = Cast<AFoodCourtManager>(FoodContainerManager))
                {
                    FCManager->DisableAllListenAnswersText();
                }
 
                // Food 캡슐도 텍스트 없애기
                Food->CurrentFoodData.word1.name = TEXT("");
                Food->CurrentFoodData.word2.name = TEXT("");
 
                if (HasAuthority()) Food->UpdateFoodWidget();
                
                // 모든 클라이언트에 정답 인덱스와 함께 결과 팝업 표시
                Multicast_ShowResultPopup(TryIdx);
            }, 0.5f, false);
        }
        else
        {
            UE_LOG(LogTemp, Warning, TEXT("[FoodHolder] Wrong"));
        
            // 오답인 경우
            FTimerHandle TimerHandle;
            GetWorldTimerManager().SetTimer(TimerHandle, [this, Food, GS]
            {
                // 오답 리스트에 추가
                GS->WrongListenAnswerList.Add(TryIdx);
 
                // 모든 클라이언트에 오답 메시지 표시
                Multicast_ShowWrongPopup(Food->CurrentFoodData.word1.name);
 
                // 컨베이어 투입구 텍스트 원상복구
                TArray<AActor*> CityNames;
                UGameplayStatics::GetAllActorsOfClass(GetWorld(), ACityName::StaticClass(), CityNames);
 
                for (AActor* Actor : CityNames)
                {
                    if (ACityName* CN = Cast<ACityName>(Actor))
                    {
                        CN->SetDefaultText();
                    }
                }
 
                // 투입구 상태 초기화
                TArray<AActor*> OrderKiosks;
                UGameplayStatics::GetAllActorsOfClass(GetWorld(), AOrderKiosk::StaticClass(), OrderKiosks);
                for (auto OrderKiosk : OrderKiosks)
                {
                    if (AOrderKiosk* Kiosk = Cast<AOrderKiosk>(OrderKiosk))
                        Kiosk->IsOnceStopped = false;
                }
 
                // 새 Food 캡슐에 부분 정답 데이터 저장
                /* Food 또는 City만 정답일 경우 : 정답인 요소만 저장
                 * 둘 다 오답인 경우 : 완전 초기화 */
                FFoodCapsuleData PrevData = Food->CurrentFoodData;
                Food->Destroy();
                
                // 새 FoodContainer 생성
                AActor* FoodContainerManager = UGameplayStatics::GetActorOfClass(GetWorld(), AFoodCourtManager::StaticClass());
                if (AFoodCourtManager* FCManager = Cast<AFoodCourtManager>(FoodContainerManager))
                {
                    FCManager->SpawnFoodContainer();
                    
                    FTimerHandle PartialAnswerTimer;
                    GetWorldTimerManager().SetTimer(PartialAnswerTimer, [this, PrevData]
                    {
                        AFood* NewFood = Cast<AFood>(UGameplayStatics::GetActorOfClass(GetWorld(), AFood::StaticClass()));
                    if (!NewFood)
                    {
                        UE_LOG(LogTemp, Error, TEXT("[FoodHolder] NewFood is nullptr!"));
                        return;
                    }
 
                    // 부분정답 판정해서 틀리면 공백으로 되돌리기
                        bool bCityCorrect = false;
                        bool bFoodCorrect = false;
                        CheckPartialAnswer(PrevData, bCityCorrect, bFoodCorrect);
 
                        // City만 정답인 경우
                    if (bCityCorrect && !bFoodCorrect)
                    {
                        UE_LOG(LogTemp, Warning, TEXT("[FoodHolder] City Only Correct - Updating City name widget"));
                        NewFood->CurrentFoodData.word1 = PrevData.word1;
                        NewFood->UpdateFoodWidget();
                    }
                    // Food만 정답인 경우
                    else if (!bCityCorrect && bFoodCorrect)
                    {
                        UE_LOG(LogTemp, Warning, TEXT("[FoodHolder] Food Only Correct - Updating Food mesh"));
                        NewFood->CurrentFoodData.word2 = PrevData.word2;
                        NewFood->UpdateFoodWidget();
                        NewFood->UpdateMesh();
                    }
                    // 둘 다 오답: 기본 빈 상태 유지
                    else if (!bCityCorrect && !bFoodCorrect)
                    {
                        UE_LOG(LogTemp, Warning, TEXT("[FoodHolder] Both Wrong - NewFood remains empty"));
                    }
                    }, 1.0f, false);
                }
 
            }, 0.5f, false);
        }
    }
}
 
bool AFoodHolder::CheckFood(AFood* TargetFood)
{
    if (!TargetFood) return false;
 
    // Food의 모든 충돌 비활성화
    if (TargetFood->Mesh)
    {
        TargetFood->Mesh->SetSimulatePhysics(false);
        TargetFood->Mesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    }
 
    // ListenQuest 정답 인덱스 가져오기
    ALingoGameState* GS = Cast<ALingoGameState>(GetWorld()->GetGameState());
    if (!GS) return false;
 
    const int32 CorrectIdx = GS->GetListenScenarioData().correct_answer_index;
    const TArray<FScenarioTargetData>& ScenarioData = GS->GetListenScenarioData().target_data;
    
    FString CorrectCityName = ScenarioData[CorrectIdx].word1.name;
    FString CorrectFoodName = ScenarioData[CorrectIdx].word2.name;
    
    if (CorrectFoodName == TargetFood->CurrentFoodData.word2.name
        && CorrectCityName == TargetFood->CurrentFoodData.word1.name)
    {
        // Success: Food를 HoldPos 위치보다 살짝 위에 배치
        FVector ActivatedLocation = HoldPos->GetComponentLocation();
        ActivatedLocation.Z += ActivatedHeightOffset;
        TargetFood->SetActorLocation(ActivatedLocation);
        TargetFood->SetActorRotation(HoldPos->GetComponentRotation());
    
        // Activate 상태로 전환
        bIsActivated = true;
        CurTarget = TargetFood;
    
        // 서버에서도 머티리얼 업데이트 (클라이언트는 OnRep_IsActivated에서 호출됨)
        UpdateActivateState(true);
    
        return true;
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("[CheckFood] Returning FALSE"));
    
        // Fail: 서버에서 머티리얼 업데이트 (오답)
        bIsActivated = false;
        UpdateActivateState(false);
    
        return false;
    }
}
 
void AFoodHolder::CheckPartialAnswer(const struct FFoodCapsuleData& TargetData, bool& bOutCityCorrect, bool& bOutFoodCorrect)
{
    bOutCityCorrect = false;
    bOutFoodCorrect = false;
    
    // ListenQuest 정답 인덱스 가져오기
    ALingoGameState* GS = Cast<ALingoGameState>(GetWorld()->GetGameState());
    if (!GS) return;
 
    const int32 CorrectIdx = GS->GetListenScenarioData().correct_answer_index;
    const TArray<FScenarioTargetData>& ScenarioData = GS->GetListenScenarioData().target_data;
    
    FString CorrectCityName = ScenarioData[CorrectIdx].word1.name;
    FString CorrectFoodName = ScenarioData[CorrectIdx].word2.name;
    
    // 각각 판정
    bOutCityCorrect = (CorrectCityName == TargetData.word1.name);
    bOutFoodCorrect = (CorrectFoodName == TargetData.word2.name);
}
 
void AFoodHolder::UpdateActivateState(bool State)
{
    // 머티리얼 파라미터 설정
    if (MeshComponent && MeshComponent->GetNumMaterials() > 0)
    {
        UMaterialInstanceDynamic* DynamicMaterial = Cast<UMaterialInstanceDynamic>(MeshComponent->GetMaterial(0));
        if (!DynamicMaterial)
            DynamicMaterial = MeshComponent->CreateDynamicMaterialInstance(0);
 
        if (DynamicMaterial)
            DynamicMaterial->SetScalarParameterValue(FName("Activate"), State ? 1.0f : 0.0f);
    }
}
 
void AFoodHolder::Multicast_ShowResultPopup_Implementation(int32 CorrectAnswerIndex)
{
    // 모든 클라이언트에서 로컬 GameState에 정답 인덱스 추가
    if (ALingoGameState* GS = Cast<ALingoGameState>(GetWorld()->GetGameState()))
    {
        // 중복 체크 후 추가
        if (!GS->WrongListenAnswerList.Contains(CorrectAnswerIndex))
        {
            GS->WrongListenAnswerList.Add(CorrectAnswerIndex);
            PRINTLOG(TEXT("[Multicast_ShowResultPopup] Added correct answer index %d to local GameState"), CorrectAnswerIndex);
        }
    }
 
    // 팝업 표시
    if (auto Popup = UPopupManager::ShowPopupAs<UPopup_Result>(GetWorld(), EPopupType::Result))
    {
        Popup->InitPopup(EQuestType::Listen);
    }
}
 
void AFoodHolder::Multicast_ShowWrongPopup_Implementation(const FString& FoodName)
{
    // 모든 클라이언트(호스트 포함)에서 오답 메시지 표시
    FString Message = FString::Printf(TEXT("Wrong Answer\nThis is not the correct Answer.\n\nFood: %s"),
        *FoodName);
 
    if (auto DM = UBroadcastManager::Get(this))
        DM->SendTutorMessage(FText::FromString(Message));
}