ALingoGameState.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 "ALingoGameState.h"
 
#include "Net/UnrealNetwork.h"
#include "APlayerActor.h"
#include "GameLogging.h"
#include "ULingoGameHelper.h"
#include "ANetworkBroadcastActor.h"
#include "APlayerControl.h"
#include "CompassTargetInterface.h"
#include "EngineUtils.h"
#include "UMainWidget.h"
#include "UPopupManager.h"
#include "Popup_Result.h"
#include "GameFramework/PlayerController.h"
#include "Engine/World.h"
#include "Kismet/GameplayStatics.h"
#include "Onepiece/Onepiece.h"
 
ALingoGameState::ALingoGameState()
{
    RemainMissionTime = 0.f;
    bIsTimerActive = false;
 
    PrimaryActorTick.bCanEverTick = true;
 
    // RoomId, RoomLevel은  Host가 생성합니다
    RoomId = 0;
    RoomLevel = 1;
 
    Bot.id = DefineData::BotID;
    Bot.username = DefineData::BotName;
    Bot.fullname = DefineData::BotName;
    Bot.is_active = true;
 
    Bot.my_avatar = TEXT("[BOT]");
    Bot.my_color = TEXT("[BOT]");
}
 
void ALingoGameState::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(ALingoGameState, RemainMissionTime);
    DOREPLIFETIME(ALingoGameState, bIsTimerActive);
    DOREPLIFETIME(ALingoGameState, QuestType);
    DOREPLIFETIME(ALingoGameState, RoomId);
    DOREPLIFETIME(ALingoGameState, RoomLevel);
 
    DOREPLIFETIME(ALingoGameState, ReadScenarioData);
    DOREPLIFETIME(ALingoGameState, WrongReadAnswerList);
    DOREPLIFETIME(ALingoGameState, ReqReadResult);
    DOREPLIFETIME(ALingoGameState, ReadResult);
 
    DOREPLIFETIME(ALingoGameState, ListenScenarioData);
    DOREPLIFETIME(ALingoGameState, WrongListenAnswerList);
    DOREPLIFETIME(ALingoGameState, ReqListenResult);
    DOREPLIFETIME(ALingoGameState, ListenResult);
    DOREPLIFETIME(ALingoGameState, TryListenAnswerData);
}
 
void ALingoGameState::BeginPlay()
{
    Super::BeginPlay();
 
    // Host(서버)만 RoomId를 생성합니다
    if (HasAuthority() && RoomId == 0)
    {
        this->RoomId = ULingoGameHelper::GetUnixTimestampInt64();
 
        // TODO임시
        this->RoomLevel = 2;
        
        PRINTLOG(TEXT("[LingoGameState] RoomId generated by Host: %lld"), RoomId);
    }
}
 
void ALingoGameState::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
 
    // 서버에서만 타이머 처리
    if (!HasAuthority() || !bIsTimerActive)
        return;
 
    RemainMissionTime -= DeltaSeconds;
 
    if (RemainMissionTime <= 0.f)
    {
        RemainMissionTime = 0.f;
        OnMissionTimerEnd();
    }
}
 
void ALingoGameState::AddWrongReadAnswer(const int32 InValue)
{
    if (!WrongReadAnswerList.Contains(InValue))
    {
        WrongReadAnswerList.Add(InValue);
    }
}
 
void ALingoGameState::AddWrongListenAnswer(const int32 InValue)
{
    if (!WrongListenAnswerList.Contains(InValue))
    {
        WrongListenAnswerList.Add(InValue);
    }
}
 
void ALingoGameState::SetCompassVisibilityByTag(FName Tag, bool bVisible)
{
    if (!HasAuthority()) return;
    
    Multicast_SetCompassVisibilityByTag(Tag, bVisible);
}
 
void ALingoGameState::SetCompassVisibilityByClass(TSubclassOf<AActor> ActorClass, bool bVisible)
{
    if (!HasAuthority()) return;
    
    Multicast_SetCompassVisibilityByClass(ActorClass, bVisible);
}
 
void ALingoGameState::SetAllCompassVisibility(bool bVisible)
{
    if (!HasAuthority()) return;
    
    Multicast_SetAllCompassVisibility(bVisible);
}
 
void ALingoGameState::Multicast_SetAllCompassVisibility_Implementation(bool bVisible)
{
    for (TActorIterator<AActor> It(GetWorld()); It; ++It)
    {
        // 플레이어는 제외 (항상 표시)
        if (It->IsA(APlayerActor::StaticClass()))
            continue;
 
        if (ICompassTargetInterface* Target = Cast<ICompassTargetInterface>(*It))
        {
            Target->SetShowOnCompass(bVisible);
        }
    }
}
 
void ALingoGameState::Multicast_SetCompassVisibilityByClass_Implementation(TSubclassOf<AActor> ActorClass,
                                                                           bool bVisible)
{
    TArray<AActor*> FoundActors;
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), ActorClass, FoundActors);
 
    for (AActor* Actor : FoundActors)
    {
        if (ICompassTargetInterface* Target = Cast<ICompassTargetInterface>(Actor))
        {
            Target->SetShowOnCompass(bVisible);
        }
    }
}
 
void ALingoGameState::Multicast_SetCompassVisibilityByTag_Implementation(FName Tag, bool bVisible)
{
    TArray<AActor*> FoundActors;
    UGameplayStatics::GetAllActorsWithTag(GetWorld(), Tag, FoundActors);
 
    for (AActor* Actor : FoundActors)
    {
        if (ICompassTargetInterface* Target = Cast<ICompassTargetInterface>(Actor))
        {
            Target->SetShowOnCompass(bVisible);
        }
    }
}
 
void ALingoGameState::SetReadScenarioData( const FResponseReadScenario& InResponseData)
{
    // 반드시 서버 전용
    if (!HasAuthority())
        return;
 
    this->QuestType = EQuestType::Read;
    this->ReadScenarioData = InResponseData;
 
    // 미션 타이머 시작
    this->StartMissionTimer( ULingoGameHelper::GetMissionPlayTime() );
 
    // 모든 플레이어의 ReadQuest 진행 상태 설정
    for (APlayerState* PS : PlayerArray)
    {
        if (ALingoPlayerState* LingoPS = Cast<ALingoPlayerState>(PS))
        {
            LingoPS->SetReadQuestIng(true);
        }
    }
 
    if (HasAuthority())
    {
        Multicast_UpdateQuestType(QuestType);
        Multicast_ShowReadQuestPopup(ReadScenarioData);
    }
}
 
void ALingoGameState::SetListenScenarioData( const FResponseListenScenario& InResponseData)
{
    // 반드시 서버 전용
    if (!HasAuthority())
        return;
 
    this->QuestType = EQuestType::Listen;
    this->ListenScenarioData = InResponseData;
 
    // 미션 타이머 시작
    this->StartMissionTimer( ULingoGameHelper::GetMissionPlayTime() );
 
    // 모든 플레이어의 ListenQuest 진행 상태 설정
    for (APlayerState* PS : PlayerArray)
    {
        if (ALingoPlayerState* LingoPS = Cast<ALingoPlayerState>(PS))
        {
            LingoPS->SetListenQuestIng(true);
        }
    }
 
    if (HasAuthority())
    {
        Multicast_UpdateQuestType(QuestType);
        Multicast_ShowListenQuestPopup(ListenScenarioData);
    }
}
 
void ALingoGameState::SetRoomLevel(int32 InRoomLevel)
{
    // 서버에서만 실행
    if (!HasAuthority())
    {
        PRINTLOG(TEXT("[SetRoomLevel] Failed: Not authority"));
        return;
    }
 
    RoomLevel = InRoomLevel;
    PRINTLOG(TEXT("[SetRoomLevel] RoomLevel set to %d"), RoomLevel);
 
    // 서버(Host)는 OnRep가 호출되지 않으므로 직접 델리게이트 브로드캐스트
    // 클라이언트는 Replication으로 인해 OnRep_RoomLevel이 호출되어 델리게이트가 브로드캐스트됨
    OnRoomLevelUpdated.Broadcast(RoomLevel);
}
 
void ALingoGameState::StartMissionTimer(float InTimeLimit)
{
    // 서버에서만 실행
    if (!HasAuthority())
        return;
 
    this->TimeLimit = InTimeLimit;
    this->RemainMissionTime = InTimeLimit;
    this->bIsTimerActive = true;
 
    if (ANetworkBroadcastActor* BroadcastActor = ANetworkBroadcastActor::Get(this))
        BroadcastActor->SendUpdateMissionTimerState(true, InTimeLimit, this);
}
 
void ALingoGameState::StopMissionTimer()
{
    if (!HasAuthority())
        return;
 
    // 이미 타이머가 멈춰있으면 중복 호출 방지
    if (!bIsTimerActive)
        return;
 
    bIsTimerActive = false;
 
    // NetworkBroadcastActor를 통해 모든 클라이언트에 타이머 중지 알림
    if (ANetworkBroadcastActor* BroadcastActor = ANetworkBroadcastActor::Get(this))
    {
        BroadcastActor->SendUpdateMissionTimerState(false, 0.0f, this);
    }
}
 
void ALingoGameState::DecreaseMissionTimer(const float InValue)
{
    this->RemainMissionTime = FMath::Max(0.f, RemainMissionTime - InValue);
}
 
void ALingoGameState::UpdateRemainMissionTime(const float InTimeLimit)
{
    this->TimeLimit = InTimeLimit;
    this->RemainMissionTime = InTimeLimit;
}
 
void ALingoGameState::OnMissionTimerEnd()
{
    if (!HasAuthority())
        return;
 
    bIsTimerActive = false;
 
    // NetworkBroadcastActor를 통해 모든 클라이언트에 타이머 종료 알림
    if (ANetworkBroadcastActor* BroadcastActor = ANetworkBroadcastActor::Get(this))
        BroadcastActor->SendUpdateMissionTimerState(false, 0.0f, this);
 
    auto EndMessage = ULingoGameHelper::GetStageEndMessage(QuestType);
 
    PRINTLOG( TEXT("[GameState] Mission Timer Ended - Sending: %s"), *EndMessage);
 
    // Read, Listen Quest일 때 자동으로 결과 팝업 표시
    if (QuestType == EQuestType::Read || QuestType == EQuestType::Listen)
    {
        if (auto Popup = UPopupManager::ShowPopupAs<UPopup_Result>(GetWorld(), EPopupType::Result))
        {
            Popup->InitPopup(QuestType);
        }
    }
 
    // 모든 플레이어에게 메시지 전송
    if (UWorld* World = GetWorld())
    {
        for (FConstPlayerControllerIterator It = World->GetPlayerControllerIterator(); It; ++It)
        {
            if (APlayerController* PC = It->Get())
            {
                if (APlayerActor* PlayerActor = Cast<APlayerActor>(PC->GetPawn()))
                {
                    PlayerActor->OnGameMessage(EndMessage);
                }
            }
        }
    }
}
 
 
void ALingoGameState::Multicast_UpdateQuestType_Implementation(const EQuestType InQuestType)
{
    // 0.5초 딜레이 후 팝업 표시
    if (UWorld* World = GetWorld())
    {
        FTimerHandle TimerHandle;
        World->GetTimerManager().SetTimer(TimerHandle, [this, InQuestType]()
        {
            OnQuestScenarioDataUpdated.Broadcast();
        }, 0.5f, false);
    }
}
 
 
void ALingoGameState::Multicast_ShowReadQuestPopup_Implementation(const FResponseReadScenario& InScenarioData)
{
    // 서버에서만 실행 (클라이언트는 OnRep_ReadScenarioData에서 처리)
    if (!HasAuthority())
        return;
    
    // 1.0초 딜레이 후 팝업 표시 (플레이어 Role 동기화를 위함)
    if (UWorld* World = GetWorld())
    {
        FTimerHandle TimerHandle;
        World->GetTimerManager().SetTimer(TimerHandle, [this, InScenarioData]()
        {
            for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; ++It)
            {
                if (APlayerController* PC = It->Get())
                {
                    if (APlayerActor* PlayerActor = Cast<APlayerActor>(PC->GetPawn()))
                    {
                        PlayerActor->Cmd_Info();
                    }
                }
            }
            
        }, 1.0f, false);
    }
}
 
void ALingoGameState::Multicast_ShowListenQuestPopup_Implementation(const FResponseListenScenario& InScenarioData)
{
    // 서버에서만 실행 (클라이언트는 OnRep_ListenScenarioData에서 처리)
    if (!HasAuthority())
        return;
    
    // 1.0초 딜레이 후 팝업 표시 (플레이어 Role 동기화를 위함)
    if (UWorld* World = GetWorld())
    {
        FTimerHandle TimerHandle;
        World->GetTimerManager().SetTimer(TimerHandle, [this, InScenarioData]()
        {
            for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; ++It)
            {
                if (APlayerController* PC = It->Get())
                {
                    if (APlayerActor* PlayerActor = Cast<APlayerActor>(PC->GetPawn()))
                    {
                        PlayerActor->Cmd_Info();
                    }
                }
            }
            
        }, 1.0f, false);
    }
}
 
void ALingoGameState::OnRep_ReadScenarioData()
{
    OnQuestScenarioDataUpdated.Broadcast();
    
    // 클라이언트에서 데이터가 복제된 후 팝업 표시
    if (!HasAuthority())
    {
        // 데이터 유효성 확인
        if (ReadScenarioData.target_data.Num() == 0)
        {
            PRINTLOG(TEXT("[OnRep_ReadScenarioData] Data is empty, skipping Cmd_Info"));
            return;
        }
        
        // 1.0초 딜레이 후 Cmd_Info 호출 (플레이어 Role 동기화를 위함)
        if (UWorld* World = GetWorld())
        {
            FTimerHandle TimerHandle;
            World->GetTimerManager().SetTimer(TimerHandle, [this]()
            {
                for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; ++It)
                {
                    if (APlayerController* PC = It->Get())
                    {
                        if (APlayerActor* PlayerActor = Cast<APlayerActor>(PC->GetPawn()))
                        {
                            PlayerActor->Cmd_Info();
                        }
                    }
                }
            }, 1.0f, false);
        }
    }
}
 
void ALingoGameState::OnRep_ReadResult()
{
    OnReadResultUpdated.Broadcast(ReadResult);
}
 
void ALingoGameState::OnRep_ListenScenarioData()
{
    OnQuestScenarioDataUpdated.Broadcast();
    
    // 클라이언트에서 데이터가 복제된 후 팝업 표시
    if (!HasAuthority())
    {
        // 데이터 유효성 확인
        if (ListenScenarioData.full_data.Kor.IsEmpty() && 
            ListenScenarioData.word_data1.Kor.IsEmpty() && 
            ListenScenarioData.word_data2.Kor.IsEmpty())
        {
            PRINTLOG(TEXT("[OnRep_ListenScenarioData] Data is empty, skipping Cmd_Info"));
            return;
        }
        
        // 1.0초 딜레이 후 Cmd_Info 호출 (플레이어 Role 동기화를 위함)
        if (UWorld* World = GetWorld())
        {
            FTimerHandle TimerHandle;
            World->GetTimerManager().SetTimer(TimerHandle, [this]()
            {
                for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; ++It)
                {
                    if (APlayerController* PC = It->Get())
                    {
                        if (APlayerActor* PlayerActor = Cast<APlayerActor>(PC->GetPawn()))
                        {
                            PlayerActor->Cmd_Info();
                        }
                    }
                }
            }, 1.0f, false);
        }
    }
}
 
void ALingoGameState::OnRep_ListenResult()
{
    OnListenResultUpdated.Broadcast(ListenResult);
}
 
void ALingoGameState::OnRep_RoomId()
{
    OnRoomIdUpdated.Broadcast(RoomId);
}
 
void ALingoGameState::OnRep_RoomLevel()
{
    OnRoomLevelUpdated.Broadcast(RoomLevel);
}
 
void ALingoGameState::MulticastRPC_SendChat_Implementation(FResponseUserMe sendUser, const FText& inMessage, int32 PlayerIndex)
{
    // MainWidget의 SendChatMessage() 함수 호출
    if (auto* PC = Cast<APlayerControl>(GetWorld()->GetFirstPlayerController()))
    {
        // PRINTLOG(TEXT("[SendChat] ALingoGameState::MulticastRPC_SendChat - %s"), *inMessage.ToString());
        if (auto* player = Cast<APlayerActor>(PC->GetPawn()))
        {
            player->GetMainWidget()->SendChatMessage(sendUser, inMessage, PlayerIndex);
        }
    }
}