APlayerControl.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 "APlayerControl.h"
 
#include "APlayerActor.h"
#include "IControllable.h"
#include "UMainWidget.h"
#include "UQuestInfoWidget.h"
#include "AWheatly.h"
#include "UKLingoNetworkSystem.h"
 
#include "EnhancedInputSubsystems.h"
#include "EnhancedInputComponent.h"
 
#include "InputMappingContext.h"
#include "InputAction.h"
 
#include "FComponentHelper.h"
#include "UBroadcastManager.h"
#include "UInteractionSystem.h"
#include "UHookSystem.h"
#include "ULingoGameInstanceSubsystem.h"
#include "ULoadingCircleManager.h"
#include "ADropper.h"
#include "ALingoGameState.h"
#include "ANetworkBroadcastActor.h"
#include "EngineUtils.h"
#include "GameLogging.h"
#include "InteractableComponent.h"
#include "MiniOwlBot.h"
#include "QuestOrderWidget.h"
#include "TutorialComponent.h"
#include "UDialogManager.h"
#include "ULingoGameHelper.h"
#include "UPopupManager.h"
#include "UPopup_SpeakQuest.h"
#include "UPopup_SpeakResult.h"
#include "UConfigLibrary.h"
#include "UChatHistorySystem.h"
#include "UPopup_DailyStudy.h"
#include "UPopup_History.h"
#include "UPopup_HowToPlay.h"
#include "Onepiece/Onepiece.h"
 
#define IMC_DEFAULT_PATH            TEXT("/Game/CustomContents/Input/IMC_Game_Player.IMC_Game_Player")
#define IA_MOVE_PATH                TEXT("/Game/CustomContents/Input/IA_Game_Movement.IA_Game_Movement")
#define IA_LOOK_PATH                TEXT("/Game/CustomContents/Input/IA_Game_LookAround.IA_Game_LookAround")
#define IA_JUMP_PATH                TEXT("/Game/CustomContents/Input/IA_Game_Jump.IA_Game_Jump")
#define IA_RECORD_PATH              TEXT("/Game/CustomContents/Input/IA_Game_Record.IA_Game_Record")
#define IA_GRAB_PATH                TEXT("/Game/CustomContents/Input/IA_Game_Grab.IA_Game_Grab")
#define IA_INTERACT_PATH            TEXT("/Game/CustomContents/Input/IA_Game_Interact.IA_Game_Interact")
#define IA_RUN_PATH                 TEXT("/Game/CustomContents/Input/IA_Game_Run.IA_Game_Run")
#define IA_INFO_PATH                TEXT("/Game/CustomContents/Input/IA_Game_Info.IA_Game_Info")
#define IA_HOOK_PATH                TEXT("/Game/CustomContents/Input/IA_Game_Hook.IA_Game_Hook")
#define IA_CHAT_PATH                TEXT("/Game/CustomContents/Input/IA_EnterChat.IA_EnterChat")
#define IA_HISTORY_PATH             TEXT("/Game/CustomContents/Input/IA_Game_History.IA_Game_History")
#define IA_HOWTOCTRL_PATH           TEXT("/Game/CustomContents/Input/IA_Game_HowToCtrl.IA_Game_HowToCtrl")
#define IA_HOWTOPLAY_PATH           TEXT("/Game/CustomContents/Input/IA_Game_HowToPlay.IA_Game_HowToPlay")
 
 
APlayerControl::APlayerControl()
{
    IMC_Default = FComponentHelper::LoadAsset<UInputMappingContext>(IMC_DEFAULT_PATH);
 
    IA_Move = FComponentHelper::LoadAsset<UInputAction>(IA_MOVE_PATH);
    IA_Look = FComponentHelper::LoadAsset<UInputAction>(IA_LOOK_PATH);
    IA_Jump = FComponentHelper::LoadAsset<UInputAction>(IA_JUMP_PATH);
    IA_Record = FComponentHelper::LoadAsset<UInputAction>(IA_RECORD_PATH);
    IA_Grab = FComponentHelper::LoadAsset<UInputAction>(IA_GRAB_PATH);
    IA_Interact = FComponentHelper::LoadAsset<UInputAction>(IA_INTERACT_PATH);
    IA_Run = FComponentHelper::LoadAsset<UInputAction>(IA_RUN_PATH);
    IA_Info = FComponentHelper::LoadAsset<UInputAction>(IA_INFO_PATH);
    IA_Hook = FComponentHelper::LoadAsset<UInputAction>(IA_HOOK_PATH);
    IA_Chat = FComponentHelper::LoadAsset<UInputAction>(IA_CHAT_PATH);
    IA_History = FComponentHelper::LoadAsset<UInputAction>(IA_HISTORY_PATH);
    IA_HowToCtrl  = FComponentHelper::LoadAsset<UInputAction>(IA_HOWTOCTRL_PATH);
    IA_HowToPlay  = FComponentHelper::LoadAsset<UInputAction>(IA_HOWTOPLAY_PATH);
 
    TutorialComponent = CreateDefaultSubobject<UTutorialComponent>(TEXT("TutorialComponent"));
    ChatHistorySystem = CreateDefaultSubobject<UChatHistorySystem>(TEXT("ChatHistorySystem"));
}
 
void APlayerControl::BeginPlay()
{
    Super::BeginPlay();
 
    if (auto LP = GetLocalPlayer())
    {
        if (auto SubSystem = LP->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
        {
            if (IMC_Default)
            {
                SubSystem->ClearAllMappings();
                SubSystem->AddMappingContext(IMC_Default, 0);
            }
        }
    }
    if (IsLocalController())
    {
        UserInfo = ULingoGameInstanceSubsystem::Get(GetWorld())->GetUserInfo();
        Server_SetUserInfo(UserInfo);
 
        // 맵 로딩 완료 시 로딩 서클 숨김
        if (ULoadingCircleManager* LoadingManager = ULoadingCircleManager::Get(GetWorld()))
            LoadingManager->LoadingCircle(false);
    }
 
    // 서버에서만 DoorMessage 구독
    if (HasAuthority())
    {
        UBroadcastManager::Get(GetWorld())->OnDoorMessage.AddDynamic(this, &APlayerControl::OnDoorMessage);
    }
}
 
void APlayerControl::SetupInputComponent()
{
    Super::SetupInputComponent();
 
    if (UEnhancedInputComponent* EIC = Cast<UEnhancedInputComponent>(InputComponent))
    {
        EIC->BindAction(IA_Move, ETriggerEvent::Triggered,  this, &APlayerControl::OnMove);
        EIC->BindAction(IA_Move, ETriggerEvent::Completed,  this, &APlayerControl::OnStopMove);
        EIC->BindAction(IA_Look, ETriggerEvent::Triggered,  this, &APlayerControl::OnLook);
        
        EIC->BindAction(IA_Jump, ETriggerEvent::Started,    this, &APlayerControl::OnJump);
 
        EIC->BindAction(IA_Record, ETriggerEvent::Started, this, &APlayerControl::OnRecordPressed);
        EIC->BindAction(IA_Record, ETriggerEvent::Completed, this, &APlayerControl::OnRecordReleased);
 
        EIC->BindAction(IA_Grab, ETriggerEvent::Started, this, &APlayerControl::OnGrab);
        EIC->BindAction(IA_Grab, ETriggerEvent::Completed, this, &APlayerControl::OnGrabRelease);
 
        EIC->BindAction(IA_Interact, ETriggerEvent::Started, this, &APlayerControl::OnInteract);
        EIC->BindAction(IA_Run, ETriggerEvent::Started, this, &APlayerControl::OnRun);
 
        EIC->BindAction(IA_Info, ETriggerEvent::Started, this, &APlayerControl::OnInfo);
        
        EIC->BindAction(IA_Hook, ETriggerEvent::Started, this, &APlayerControl::OnHook);
 
        EIC->BindAction(IA_Chat, ETriggerEvent::Started, this, &APlayerControl::OnChat);
        EIC->BindAction(IA_History, ETriggerEvent::Started, this, &APlayerControl::OnHistory);
        EIC->BindAction(IA_HowToCtrl, ETriggerEvent::Started, this, &APlayerControl::OnHowToCtrl);
        EIC->BindAction(IA_HowToPlay, ETriggerEvent::Started, this, &APlayerControl::OnHowToPlay);
    }
}
 
void APlayerControl::UpdateQuestRole(EQuestRole QuestRole)
{
    UBroadcastManager::Get(GetWorld())->SendUpdateQuestRole(QuestRole);
}
 
IControllable* APlayerControl::GetControllable() const
{
    APawn* P = GetPawn();
    if (!P)
        return nullptr;
 
    // UObject 기반 UInterface 라면 Cast 가능
    if (IControllable* C = Cast<IControllable>(P))
        return C;
 
    return nullptr;
}
 
bool APlayerControl::ShouldSkipTutorial() const
{
    const int32 UserId = ULingoGameHelper::GetUserId(GetWorld());
 
    if (UConfigLibrary::GetUserBool(UserId, TEXT("TutorialCompleted"), false))
    {
        PRINTLOG(TEXT("[Tutorial] User %d already completed tutorial"), UserId);
        return true;  // 스킵
    }
 
    return false; // 튜토리얼 진행
}
 
void APlayerControl::StartTutorialManually()
{
    if (TutorialComponent)
    {
        TutorialComponent->StartTutorial();
        PRINTLOG(TEXT("[Tutorial] Starting tutorial manually"));
    }
}
 
void APlayerControl::OnTutorialCompleted()
{
    // 세이브 시스템에 여부 저장
    const int32 UserId = ULingoGameHelper::GetUserId(GetWorld());
    UConfigLibrary::SetUserBool(UserId, TEXT("TutorialCompleted"), true);
}
 
void APlayerControl::OnMove(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
        C->Cmd_Move(Value.Get<FVector2D>());
}
 
void APlayerControl::OnLook(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
        C->Cmd_Look(Value.Get<FVector2D>());
}
 
void APlayerControl::OnStopMove(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
    {
        C->Cmd_StopMove();
    }
}
 
void APlayerControl::OnJump(const FInputActionValue&)
{
    if (IControllable* C = GetControllable())
        C->Cmd_Jump();
 
    //this->TEST_DropperDropProcess();
    // this->TEST_AddItemToBoxList();
}
 
 
void APlayerControl::OnRun(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
    {
        C->Cmd_Run();
    }
}
 
void APlayerControl::OnRecordPressed(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
        C->Cmd_RecordStart();
}
 
void APlayerControl::OnRecordReleased(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
        C->Cmd_RecordEnd();
}
 
void APlayerControl::OnInfo(const FInputActionValue& Value)
{
    if (IControllable* C = GetControllable())
    {
        C->Cmd_Info();
    }
}
 
void APlayerControl::OnGrab(const FInputActionValue& Value)
{
    Server_OnGrab();
}
 
void APlayerControl::OnGrabRelease(const FInputActionValue& Value)
{
    Server_OnGrabRelease();
}
 
void APlayerControl::OnInteract(const FInputActionValue& Value)
{
    // 튜토리얼 체크 (로컬 플레이어만, 실제 동작은 서버에서만)
    APlayerActor* MyPlayer = Cast<APlayerActor>(GetPawn());
    if (MyPlayer && MyPlayer->InteractionSystem && MyPlayer->InteractionSystem->CurrentTarget)
    {
        // Button 타입인 경우 튜토리얼 체크
        if (MyPlayer->InteractionSystem->CurrentTarget->InteractionType == EInteractionType::Button)
        {
            AActor* TargetActor = MyPlayer->InteractionSystem->CurrentTarget->GetOwner();
            if (UTutorialComponent* Tutorial = FindComponentByClass<UTutorialComponent>())
            {
                Tutorial->OnObjectInteracted(TargetActor);
            }
        }
    }
 
    Server_OnInteract();
}
 
void APlayerControl::Server_OnGrab_Implementation()
{
    APlayerActor* MyPlayer = Cast<APlayerActor>(GetPawn());
    if (MyPlayer && MyPlayer->InteractionSystem)
    {
        MyPlayer->InteractionSystem->TryPickUp();
    }
}
 
void APlayerControl::Server_OnGrabRelease_Implementation()
{
    APlayerActor* MyPlayer = Cast<APlayerActor>(GetPawn());
    if (MyPlayer && MyPlayer->InteractionSystem)
    {
        MyPlayer->InteractionSystem->TryDrop();
    }
}
 
 
void APlayerControl::Server_OnInteract_Implementation()
{
    APlayerActor* MyPlayer = Cast<APlayerActor>(GetPawn());
    if (MyPlayer && MyPlayer->InteractionSystem)
    {
        MyPlayer->InteractionSystem->TryInteract();
    }
}
 
void APlayerControl::OnHook(const FInputActionValue& Value)
{
    Server_OnHook();
}
 
void APlayerControl::OnChat(const FInputActionValue& Value)
{
    // GameAndUI로??
    FInputModeUIOnly uiInputMode;
    SetInputMode(uiInputMode);
 
    APlayerActor* player = Cast<APlayerActor>(GetPawn());
    player->GetMainWidget()->SetFocusOnChat();
}
 
void APlayerControl::OnHistory(const FInputActionValue& Value)
{
    if (auto Popup = UPopupManager::ShowPopupAs<UPopup_History>(GetWorld(), EPopupType::History))
    {
        Popup->InitPopup();
    }
}
 
 
void APlayerControl::OnHowToCtrl(const FInputActionValue& Value)
{
    this->OpenHowToPlay(EQuestType::None);
}
 
 
void APlayerControl::OnHowToPlay(const FInputActionValue& Value)
{
    // 현재 진행 중인 퀘스트 타입 확인
    if (auto PS = GetPlayerState<ALingoPlayerState>())
    {
        // Read 퀘스트 진행 중
        if (PS->bReadQuestIng && !PS->bReadQuestCompleted)
        {
            this->OpenHowToPlay(EQuestType::Read);
        }
        else if (PS->bListenQuestIng && !PS->bListenQuestCompleted)
        {
            this->OpenHowToPlay(EQuestType::Listen);
        }
        else if (PS->bSpeakQuestIng && !PS->bSpeakQuestCompleted)
        {
            this->OpenHowToPlay(EQuestType::Speak);
        }
        else if (PS->bWriteQuestIng && !PS->bWriteQuestCompleted)
        {
            this->OpenHowToPlay(EQuestType::Write);
        }
    }
}
 
void APlayerControl::OpenHowToPlay(EQuestType QuestType)
{
    if (auto Popup = UPopupManager::ShowPopupAs<UPopup_HowToPlay>(GetWorld(), EPopupType::HowToPlay))
    {
        TArray<EHowToPlayPageType> PageTypes;
 
        if ( QuestType == EQuestType::None )
        {
            PageTypes.Add(EHowToPlayPageType::Control_P1);
            PageTypes.Add(EHowToPlayPageType::Control_P2);
            PageTypes.Add(EHowToPlayPageType::Control_P3);
            PageTypes.Add(EHowToPlayPageType::Control_P4);
            PageTypes.Add(EHowToPlayPageType::Control_P5);
            PageTypes.Add(EHowToPlayPageType::Control_P6);
        }
        else if ( QuestType == EQuestType::Read )
        {
            PageTypes.Add(EHowToPlayPageType::Read_P1);         
            PageTypes.Add(EHowToPlayPageType::Read_P2);
            PageTypes.Add(EHowToPlayPageType::Read_P3);
            PageTypes.Add(EHowToPlayPageType::Read_P4);
        }
        else if ( QuestType == EQuestType::Listen )
        {
            PageTypes.Add(EHowToPlayPageType::Listen_P1);           
            PageTypes.Add(EHowToPlayPageType::Listen_P2);           
            PageTypes.Add(EHowToPlayPageType::Listen_P3);           
            PageTypes.Add(EHowToPlayPageType::Listen_P4);           
        }
        else if ( QuestType == EQuestType::Speak )
        {
            PageTypes.Add(EHowToPlayPageType::Speak_P1);            
            PageTypes.Add(EHowToPlayPageType::Speak_P2);            
            PageTypes.Add(EHowToPlayPageType::Speak_P3);            
        }
        else if ( QuestType == EQuestType::Write )
        {
            PageTypes.Add(EHowToPlayPageType::Write_P1);            
            PageTypes.Add(EHowToPlayPageType::Write_P2);            
            PageTypes.Add(EHowToPlayPageType::Write_P3);            
        }
        
        Popup->InitPopup(PageTypes);
    }
}
 
 
void APlayerControl::Server_OnHook_Implementation()
{
    APlayerActor* MyPlayer = Cast<APlayerActor>(GetPawn());
    if (MyPlayer && MyPlayer->HookSystem)
    {
        MyPlayer->HookSystem->TryHook();
    }
}
 
void APlayerControl::Server_SetUserInfo_Implementation(const FResponseUserMe& InUserInfo)
{
    UserInfo = InUserInfo;
}
 
void APlayerControl::RequestDrop(APlayerControl* Requester)
{
    if (auto World = GetWorld())
    {
        for (TActorIterator<ADropper> It(World); It; ++It)
        {
            ADropper* Dropper = *It;
            if (Dropper)
            {
                if (Dropper->IsBusy() )
                {
                    Requester->Client_ToastMessage( TEXT("Dropper is Busy") );
                    return;
                }
                
                FLuggageData tmpData;
                tmpData.word1 = tmpData.word1.GetRandomAnimal();
                tmpData.word2 = tmpData.word2.GetRandomColor();
            
                Dropper->SetSpawnData(tmpData);
                Dropper->SetSpawnClass( LoadClass<AActor>(nullptr, TEXT("/Game/CustomContents/Blueprints/Interactables/BP_Luggage.BP_Luggage_C")));
                Dropper->RequestSpawn();
                return;
            }
        }
    }
}
 
void APlayerControl::Server_RequestDrop_Implementation()
{
    RequestDrop(this);
}
 
void APlayerControl::Client_ToastMessage_Implementation(const FString& Message)
{
    UDialogManager::Get(GetWorld())->ShowToast(Message);
}
 
void APlayerControl::Client_UpdateSpeakQuest_Implementation(int32 StepIndex)
{
    ALingoPlayerState* PS = GetPlayerState<ALingoPlayerState>();
    if (!PS)
        return;
 
    if (StepIndex == 0)
    {
        // 첫 번째 질문일 경우 MessageBox 표시
        if (auto Popup = UPopupManager::ShowPopupAs<UPopup_SpeakQuest>(GetWorld(), EPopupType::SpeakQuest))
        {
            // MessageBox OK 버튼 클릭 시 질문 표시
            FOnMsgBoxOkDelegate OnOkDelegate;
            
            Popup->InitPopup( FOnMsgBoxOkDelegate().CreateLambda([this, StepIndex]()
            {
                if (APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn()))
                {
                    PlayerActor->PlaySpeakInfo(StepIndex);
                }
                UpdateSpeakWidget(StepIndex);
            }));
        }
    }
    else
    {
        if (APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn()))
            PlayerActor->PlaySpeakInfo(StepIndex);
 
        UpdateSpeakWidget(StepIndex);
    }
}
 
void APlayerControl::Client_EndSpeakQuest_Implementation()
{
    // Quest 완료 시에는 StepIndex를 -1로 전달하여 Widget을 숨김
    UpdateSpeakWidget(-1);
 
    // if (auto PopupManager = UPopupManager::Get(GetWorld()))
    //  PopupManager->ShowMsgBox(TEXT("SpeakQuest"), TEXT("QUEST COMPLETE"), EMsgBoxType::OK, FOnMsgBoxOkDelegate());
    RequestSpeakResult();
}
 
void APlayerControl::Client_InteractKiosk_Implementation()
{
    APlayerActor* MyPlayer = Cast<APlayerActor>(GetPawn());
    UInteractableComponent* component = nullptr;
    if (MyPlayer)
    {
        component = MyPlayer->InteractionSystem->CurrentTarget;
    }
    if (!component->bCanInteract)
        return;
 
    // 델리게이트 브로드캐스트
    component->OnInteractionTriggered.Broadcast(GetPawn());
 
    if (HasAuthority())
    {
        PRINTLOG( TEXT("InteractableComponent::TriggerInteraction server server"));
    }
}
 
void APlayerControl::Client_RequestSpeakScenario_Implementation(AWheatly* Wheatly)
{
    if (!Wheatly)
    {
        PRINTLOG(TEXT("[APlayerControl] Client_RequestSpeakScenario: Wheatly is null"));
        return;
    }
 
    // 현재 조종중인 PlayerActor 획득
    APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn());
    if (!PlayerActor)
    {
        PRINTLOG(TEXT("[APlayerControl] Client_RequestSpeakScenario: PlayerActor is null"));
        return;
    }
 
    // Client에서 네트워크 요청 수행
    if (auto KLingoNetwork = UKLingoNetworkSystem::Get(GetWorld()))
    {
        // Lambda를 사용하여 응답 처리
        // this 캡처: APlayerControl의 Server RPC 호출을 위해
        KLingoNetwork->RequestSpeakScenario( FResponseSpeakScenarioDelegate::CreateLambda(
                [this, Wheatly](FResponseSpeakScenario& ResponseData, bool bWasSuccessful)
                {
                    if (bWasSuccessful && Wheatly)
                    {
                        // 성공 시 자신의 Server RPC 호출 (PlayerControl은 Client 소유!)
                        Server_SyncSpeakScenarioData(Wheatly, ResponseData);
                        PRINTLOG(TEXT("[APlayerControl] Client successfully received scenario data, syncing to server"));
                    }
                    else
                    {
                        // 실패 시 에러는 이미 ShowNetworkErrorPopup으로 표시됨
                        PRINTLOG(TEXT("[APlayerControl] Client failed to receive scenario data"));
                    }
                }
            )
        );
    }
    else
    {
        PRINTLOG(TEXT("[APlayerControl] Client_RequestSpeakScenario: Failed to get KLingoNetworkSystem"));
    }
}
 
void APlayerControl::Server_SyncSpeakScenarioData_Implementation(AWheatly* Wheatly, const FResponseSpeakScenario& Data)
{
    if (!Wheatly)
    {
        PRINTLOG(TEXT("[APlayerControl] Server_SyncSpeakScenarioData: Wheatly is null"));
        return;
    }
 
    // 현재 조종중인 PlayerActor 획득
    APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn());
    if (!PlayerActor)
    {
        PRINTLOG(TEXT("[APlayerControl] Server_SyncSpeakScenarioData: PlayerActor is null"));
        return;
    }
 
    // SpeakQuest 진행 상태 설정
    if (ALingoPlayerState* PS = GetPlayerState<ALingoPlayerState>())
    {
        PS->SetSpeakQuestIng(true);
    }
 
    // Wheatly에 데이터 전달 (Server에서 실행됨)
    Wheatly->SyncSpeakScenarioData(PlayerActor, Data);
 
    PRINTLOG(TEXT("[APlayerControl] Server successfully synced scenario data to Wheatly"));
}
 
void APlayerControl::Server_SendDoorMessage_Implementation(int32 InDoorIndex, bool bOpen)
{
    if (!HasAuthority())
        return;
 
    // Pawn을 EventInstigator로 전달
    if (APawn* MyPawn = GetPawn())
    {
        ANetworkBroadcastActor::Get(GetWorld())->SendDoorMessage(InDoorIndex, bOpen, MyPawn);
        PRINTLOG(TEXT("[APlayerControl] Server sending DoorMessage: Index=%d, Open=%d"), InDoorIndex, bOpen);
    }
}
 
void APlayerControl::UpdateSpeakWidget(int32 StepIndex)
{
    if (APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn()))
    {
        if (UMainWidget* MainWidget = PlayerActor->GetMainWidget())
        {
            MainWidget->UpdateSpeakWidget(StepIndex);
        }
    }
}
 
void APlayerControl::RequestSpeakResult()
{
    if ( auto GS = Cast<ALingoGameState>(GetWorld()->GetGameState()) )
    {
        if (auto KLingoNetwork = UKLingoNetworkSystem::Get(GetWorld()))
        {
            FRequestSpeakResult SpeakRequest;
            SpeakRequest.room_id = GS->GetRoomId();
            SpeakRequest.user_id = GetUserId();
            SpeakRequest.scenario_id = 1;
            SpeakRequest.stage_type = ULingoGameHelper::GetStageTypeIndex(EQuestType::Speak);
            SpeakRequest.state_type = 0;
            KLingoNetwork->RequestSpeakResult(SpeakRequest,
                    FResponseSpeakResultDelegate::CreateUObject(this, &APlayerControl::OnResponseSpeakResult));
        }   
    }
}
 
void APlayerControl::OnResponseSpeakResult(FResponseSpeakResult& ResponseData, bool bWasSuccessful)
{
    if (bWasSuccessful)
    {
        if ( auto PS = GetPlayerState<ALingoPlayerState>() )
        {
            // PS에 결과 데이터를 저장한다
            PS->SpeakResult = ResponseData;
 
            if ( auto Popup = UPopupManager::ShowPopupAs<UPopup_SpeakResult>(GetWorld(), EPopupType::SpeakResult) )
                Popup->InitPopup(ResponseData);
        }
    }
    else
    {
        PRINTLOG(TEXT("[Result] Quest result Failed"));
    }
}
 
void APlayerControl::TEST_DropperDropProcess()
{
    // 테스트 : 맵에 있는 ADropper를 찾아서 ALuggage를 스폰
    if ( HasAuthority())
        RequestDrop(this);
    else
        Server_RequestDrop();
}
 
void APlayerControl::TEST_AddItemToBoxList()
{
    // 테스트: 랜덤 아이템 추가
    if (auto BM = UBroadcastManager::Get(GetWorld()))
    {
        TArray<FResultStatData> TestItems;
 
        // 랜덤하게 1~3개의 아이템 생성
        int32 ItemCount = FMath::RandRange(1, 3);
        for (int32 i = 0; i < ItemCount; ++i)
        {
            FResultStatData Item;
 
            // 랜덤 위젯 타입 선택
            int32 RandomType = FMath::RandRange(0, 3);
            switch (RandomType)
            {
            case 0: // Grade
                Item.WidgetType = EResultItemWidgetType::Grade;
                Item.GradeTextureType = static_cast<EResourceTextureType>(FMath::RandRange(0, 4)); // Rarity_D ~ Rarity_S
                Item.TitleText = FText::FromString(TEXT("등급"));
                break;
 
            case 1: // Score
                Item.WidgetType = EResultItemWidgetType::Score;
                Item.ScoreValue = FMath::RandRange(100, 9999);
                Item.TitleText = FText::FromString(TEXT("점수"));
                break;
 
            case 2: // Rate
                Item.WidgetType = EResultItemWidgetType::Rate;
                Item.RatePercent = FMath::FRandRange(0.0f, 1.0f);
                Item.TitleText = FText::FromString(TEXT("비율"));
                break;
 
            case 3: // Symbol
                Item.WidgetType = EResultItemWidgetType::Symbol;
                Item.SymbolValue = FString::SanitizeFloat( FMath::FRandRange(0.0f, 1.0f) );
                Item.TitleText = FText::FromString(TEXT("심볼"));
                break;
            }
 
            // 랜덤 색상 선택
            Item.ColorType = static_cast<EColorStyleType>(FMath::RandRange(0, 7)); // Green ~ Gray
 
            TestItems.Add(Item);
        }
 
        // BroadcastManager를 통해 전송
        BM->SendAddItemToBoxList(TestItems);
    }
}
 
void APlayerControl::ServerRPC_SendChat_Implementation(const FText& inMessage)
{
    if (auto* GS = GetWorld()->GetGameState<ALingoGameState>())
    {
        // PlayerIndex 찾기
        int32 PlayerIndex = -1;
        if (ALingoPlayerState* PS = GetPlayerState<ALingoPlayerState>())
        {
            PlayerIndex = GS->PlayerArray.IndexOfByKey(PS);
        }
 
        // PRINTLOG(TEXT("[SendChat] APlayerControl::ServerRPC_SendChat: %s"), *inMessage.ToString());
        GS->MulticastRPC_SendChat(UserInfo, inMessage, PlayerIndex);
    }
}
 
void APlayerControl::ServerRPC_SendAIQuestion_Implementation(const FString& Question)
{
    // 서버에서만 실행됩니다.
    if (!HasAuthority())
        return;
 
    // AI에게 질문 전송
    if (UKLingoNetworkSystem* NetworkSystem = UKLingoNetworkSystem::Get(GetWorld()))
    {
        FResponseChatAnswersDelegate Delegate;
        Delegate.BindUObject(this, &APlayerControl::OnChatAnswerReceived);
 
        // Context는 비워둡니다 (필요시 채팅 히스토리 전달 가능)
        NetworkSystem->RequestChatQuestion(TEXT(""), Question, Delegate);
 
        PRINTLOG(TEXT("[AI Chat] Question sent to AI: %s"), *Question);
    }
}
 
void APlayerControl::OnChatAnswerReceived(FResponseChatAnswers& ResponseData, bool bWasSuccessful)
{
    if (!bWasSuccessful || ResponseData.answer.IsEmpty())
    {
        PRINTLOG(TEXT("[AI Chat] Failed to receive AI response"));
        return;
    }
 
    // AI 응답을 Bot 정보로 채팅에 표시
    if (auto* GS = GetWorld()->GetGameState<ALingoGameState>())
    {
        FText AIAnswer = FText::FromString(ResponseData.answer);
        // Bot은 PlayerIndex -1 사용
        GS->MulticastRPC_SendChat(GS->GetBotInfo(), AIAnswer, DefineData::BotID);
 
        // Chat History 저장
        if (ChatHistorySystem)
            ChatHistorySystem->SaveChatHistory(ResponseData.question, ResponseData.answer);
    }
    
    // ai tutor 봇에 메시지 표시
    if (auto playerActor = Cast<APlayerActor>(GetPawn()))
    {
        playerActor->GetMiniOwlBot()->UpdateText(ResponseData.answer);
    }
}
 
void APlayerControl::OnDoorMessage(int32 InDoorIndex, bool bInOpen, AActor* EventInstigator)
{
    // 서버에서만 실행
    if (!HasAuthority())
        return;
 
    // 문이 열릴 때만 처리
    if (!bInOpen)
        return;
 
    // PlayerState 가져오기
    ALingoPlayerState* PS = GetPlayerState<ALingoPlayerState>();
    if (!PS)
        return;
 
    // End DoorIndex에 따라 퀘스트 완료 처리
    if (InDoorIndex == DoorGroup::Step1_End)
    {
        // ReadQuest: 협력 퀘스트, 모든 플레이어 완료
        PS->SetReadQuestCompleted();
    }
    else if (InDoorIndex == DoorGroup::Step2_End)
    {
        // ListenQuest: 협력 퀘스트, 모든 플레이어 완료
        PS->SetListenQuestCompleted();
    }
    else if (InDoorIndex == DoorGroup::Step3_End)
    {
        // SpeakQuest: 개인 퀘스트, EventInstigator 확인
        if (EventInstigator != nullptr && EventInstigator != GetPawn())
            return;
 
        PS->SetSpeakQuestCompleted();
    }
    else if (InDoorIndex == DoorGroup::Step4_End)
    {
        // WriteQuest: 개인 퀘스트, EventInstigator 확인
        if (EventInstigator != nullptr && EventInstigator != GetPawn())
            return;
 
        PS->SetWriteQuestCompleted();
    }
 
    if (InDoorIndex == DoorGroup::Step1_Tutorial)
    {
        Multicast_OpenHowToPlay(EQuestType::Read);
    }
    else if (InDoorIndex == DoorGroup::Step2_Tutorial)
    {
        Multicast_OpenHowToPlay(EQuestType::Listen);
    }
    else if (InDoorIndex == DoorGroup::Step3_Tutorial)
    {
        // 개인 퀘스트: Instigator가 본인인지 확인 후 해당 클라이언트에게만 알림
        if (EventInstigator == GetPawn())
        {
            Client_OpenHowToPlay(EQuestType::Speak);
        }
    }
    else if (InDoorIndex == DoorGroup::Step3_Tutorial)
    {
        // 개인 퀘스트: Instigator가 본인인지 확인 후 해당 클라이언트에게만 알림
        if (EventInstigator == GetPawn())
        {
            Client_OpenHowToPlay(EQuestType::Write);
        }
    }
}
 
// 모든 클라이언트에서 실행될 로직
void APlayerControl::Multicast_OpenHowToPlay_Implementation(EQuestType InType)
{
    // 로컬 플레이어 컨트롤러인지 확인 (UI는 내 화면에만 띄워야 함)
    if (IsLocalController())
    {
        OpenHowToPlay(InType);
    }
}
 
// 특정 클라이언트에서 실행될 로직
void APlayerControl::Client_OpenHowToPlay_Implementation(EQuestType InType)
{
    // Client RPC는 해당 컨트롤러가 소유한 클라이언트에서만 실행됨
    OpenHowToPlay(InType);
}
 
void APlayerControl::UpdateQuestInfoWidget()
{
    // PlayerActor 가져오기
    APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn());
    if (!PlayerActor)
        return;
 
    // MainWidget 가져오기
    UMainWidget* MainWidget = PlayerActor->GetMainWidget();
    if (!MainWidget)
        return;
 
    // QuestInfoWidget 가져오기
    UQuestInfoWidget* QuestWidget = MainWidget->GetQuestInfoWidget();
    if (!QuestWidget)
        return;
 
    // PlayerState 가져오기
    ALingoPlayerState* PS = GetPlayerState<ALingoPlayerState>();
    if (!PS)
        return;
 
    // 퀘스트 상태 확인 및 위젯 업데이트
    FString Title;
    FString Description;
    bool bShouldShow = false;
 
    // ReadQuest 상태 확인
    if (PS->bReadQuestIng && !PS->bReadQuestCompleted)
    {
        Title = TEXT("Mission Goal");
        Description = TEXT("Place the object on the switch to open the gate");
        bShouldShow = true;
    }
    else if (PS->bReadQuestCompleted && !PS->bListenQuestIng)
    {
        Title = TEXT("Move Food Court");
        Description = TEXT("Move Food Court With Friend");
        bShouldShow = true;
    }
    // ListenQuest 상태 확인
    else if (PS->bListenQuestIng && !PS->bListenQuestCompleted)
    {
        Title = TEXT("Move Next Goal");
        Description = TEXT("Place the object on the switch to open the gate");
        bShouldShow = true;
    }
    else if (PS->bListenQuestCompleted && !PS->bSpeakQuestIng)
    {
        Title = TEXT("Move Jugdes");
        Description = TEXT("Move Judes And Talk");
        bShouldShow = true;
    }
    // SpeakQuest 상태 확인
    else if (PS->bSpeakQuestIng && !PS->bSpeakQuestCompleted)
    {
        Title = TEXT("Press V Key And Talk");
        Description = TEXT("Answer Judes Question");
        bShouldShow = true;
    }
    else if (PS->bSpeakQuestCompleted && !PS->bWriteQuestIng)
    {
        // Speak 종료 후 바로 Write로 이어지는 경우 처리
        // 잠시 숨김 처리 (또는 다른 메시지 표시)
        bShouldShow = false;
    }
    // WriteQuest 상태 확인
    else if (PS->bWriteQuestIng && !PS->bWriteQuestCompleted)
    {
        Title = TEXT("Move Paper");
        Description = TEXT("Find Wirte Kiosk And Interaction");
        bShouldShow = true;
    }
    else if (PS->bWriteQuestCompleted)
    {
        Title = TEXT("Move End Point");
        Description = TEXT("Get Evalution");
        bShouldShow = true;
    }
 
    // 위젯 업데이트
    if (bShouldShow)
    {
        QuestWidget->UpdateQuestText(Title, Description);
        QuestWidget->SetVisibility(ESlateVisibility::Visible);
    }
    else
    {
        QuestWidget->SetVisibility(ESlateVisibility::Collapsed);
    }
}
 
void APlayerControl::UpdateQuestOrderWidget(const FString& inQuestOrder)
{
    // PlayerActor 가져오기
    APlayerActor* PlayerActor = Cast<APlayerActor>(GetPawn());
    if (!PlayerActor)
        return;
 
    // MainWidget 가져오기
    UMainWidget* MainWidget = PlayerActor->GetMainWidget();
    if (!MainWidget)
        return;
 
    // QuestInfoWidget 가져오기
    UQuestOrderWidget* QuestOrderWidget = MainWidget->GetQuestOrderWidget();
    if (!QuestOrderWidget)
        return;
 
    // PlayerState 가져오기
    ALingoPlayerState* PS = GetPlayerState<ALingoPlayerState>();
    if (!PS)
        return;
 
    // 위젯 업데이트
    QuestOrderWidget->UpdateQuestOrder(inQuestOrder);
    QuestOrderWidget->SetVisibility(ESlateVisibility::Visible);
}