ANetworkBroadcastActor.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 "ANetworkBroadcastActor.h"
#include "UBroadcastManager.h"
#include "GameLogging.h"
#include "Net/UnrealNetwork.h"
#include "Engine/World.h"
 
TMap<UWorld*, ANetworkBroadcastActor*> ANetworkBroadcastActor::Instances;
 
ANetworkBroadcastActor::ANetworkBroadcastActor()
{
    PrimaryActorTick.bCanEverTick = false;
 
    // 네트워크 복제 설정
    bReplicates = true;
    bAlwaysRelevant = true;  // 모든 클라이언트에게 항상 복제
 
    // Root component
    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
}
 
ANetworkBroadcastActor* ANetworkBroadcastActor::Get(const UObject* WorldContextObject)
{
    if (!WorldContextObject)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor::Get - WorldContextObject is null"));
        return nullptr;
    }
 
    UWorld* World = WorldContextObject->GetWorld();
    if (!World)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor::Get - World is null"));
        return nullptr;
    }
 
    // 이미 존재하는 인스턴스 확인
    if (Instances.Contains(World))
    {
        ANetworkBroadcastActor* Instance = Instances[World];
        if (IsValid(Instance))
        {
            return Instance;
        }
        else
        {
            // 유효하지 않은 인스턴스 제거
            Instances.Remove(World);
        }
    }
 
    // 새 인스턴스 생성 (Server에서만)
    if (World->GetAuthGameMode())
    {
        FActorSpawnParameters SpawnParams;
        SpawnParams.Owner = nullptr;
        SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
 
        ANetworkBroadcastActor* NewInstance = World->SpawnActor<ANetworkBroadcastActor>(
            ANetworkBroadcastActor::StaticClass(),
            FVector::ZeroVector,
            FRotator::ZeroRotator,
            SpawnParams
        );
 
        if (NewInstance)
        {
            Instances.Add(World, NewInstance);
            PRINTLOG(TEXT("NetworkBroadcastActor: Created new instance"));
            return NewInstance;
        }
        else
        {
            PRINTLOG(TEXT("NetworkBroadcastActor: Failed to spawn actor"));
        }
    }
    else
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Not on server, cannot create instance"));
    }
 
    return nullptr;
}
 
// ========================================
// Door Message
// ========================================
 
void ANetworkBroadcastActor::SendDoorMessage(int InDoorIndex, bool bOpen, AActor* EventInstigator)
{
    if (!EventInstigator)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendDoorMessage - EventInstigator is null"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: SendDoorMessage called - Index: %d, Open: %d, EventInstigator: %s"),
        InDoorIndex, bOpen, *EventInstigator->GetName());
 
    Server_SendDoorMessage(InDoorIndex, bOpen, EventInstigator);
}
 
void ANetworkBroadcastActor::Server_SendDoorMessage_Implementation(int InDoorIndex, bool bOpen, AActor* EventInstigator)
{
    if (!ValidateInstigator(EventInstigator))
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid instigator for DoorMessage"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: Server received DoorMessage - Index: %d, Open: %d"), InDoorIndex, bOpen);
 
    // Multicast로 모든 클라이언트에게 전파
    Multicast_SendDoorMessage(InDoorIndex, bOpen, EventInstigator);
}
 
void ANetworkBroadcastActor::Multicast_SendDoorMessage_Implementation(int InDoorIndex, bool bOpen, AActor* EventInstigator)
{
    PRINTLOG(TEXT("NetworkBroadcastActor: Multicast DoorMessage - Index: %d, Open: %d, Role: %s"),
        InDoorIndex, bOpen, GetLocalRole() == ROLE_Authority ? TEXT("Server") : TEXT("Client"));
 
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast)
    {
        LocalBroadcast->SendDoorMessage(InDoorIndex, bOpen, EventInstigator);
        PRINTLOG(TEXT("NetworkBroadcastActor: Local BroadcastManager triggered for DoorMessage"));
    }
    else
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Failed to get local BroadcastManager"));
    }
}
 
// ========================================
// Weight Switch
// ========================================
 
void ANetworkBroadcastActor::SendWeightSwitch(int InButtonIndex, bool bActive, AActor* EventInstigator)
{
    if (!EventInstigator)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendWeightSwitch - EventInstigator is null"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: SendWeightSwitch called - Index: %d, Active: %d"), InButtonIndex, bActive);
 
    Server_SendWeightSwitch(InButtonIndex, bActive, EventInstigator);
}
 
void ANetworkBroadcastActor::Server_SendWeightSwitch_Implementation(int InButtonIndex, bool bActive, AActor* EventInstigator)
{
    if (!ValidateInstigator(EventInstigator))
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid instigator for WeightSwitch"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: Server received WeightSwitch - Index: %d, Active: %d"), InButtonIndex, bActive);
 
    Multicast_SendWeightSwitch(InButtonIndex, bActive);
}
 
void ANetworkBroadcastActor::Multicast_SendWeightSwitch_Implementation(int InButtonIndex, bool bActive)
{
    PRINTLOG(TEXT("NetworkBroadcastActor: Multicast WeightSwitch - Index: %d, Active: %d, Role: %s"),
        InButtonIndex, bActive, GetLocalRole() == ROLE_Authority ? TEXT("Server") : TEXT("Client"));
 
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast)
    {
        LocalBroadcast->SendWeightSwitch(InButtonIndex, bActive);
        PRINTLOG(TEXT("NetworkBroadcastActor: Local BroadcastManager triggered for WeightSwitch"));
    }
}
 
// ========================================
// HitStop
// ========================================
 
void ANetworkBroadcastActor::SendHitStop(AActor* Target, EDamageType Type, AActor* EventInstigator)
{
    if (!EventInstigator || !Target)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendHitStop - Invalid parameters"));
        return;
    }
 
    Server_SendHitStop(Target, Type, EventInstigator);
}
 
void ANetworkBroadcastActor::Server_SendHitStop_Implementation(AActor* Target, EDamageType Type, AActor* EventInstigator)
{
    if (!ValidateInstigator(EventInstigator) || !Target)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid parameters for HitStop"));
        return;
    }
 
    Multicast_SendHitStop(Target, Type);
}
 
void ANetworkBroadcastActor::Multicast_SendHitStop_Implementation(AActor* Target, EDamageType Type)
{
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast && Target)
    {
        LocalBroadcast->SendHitStop(Target, Type);
    }
}
 
// ========================================
// Knockback
// ========================================
 
void ANetworkBroadcastActor::SendKnockback(AActor* Target, AActor* KnockbackInstigator, EDamageType Type, float Resistance, AActor* CallInstigator)
{
    if (!CallInstigator || !Target)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendKnockback - Invalid parameters"));
        return;
    }
 
    Server_SendKnockback(Target, KnockbackInstigator, Type, Resistance, CallInstigator);
}
 
void ANetworkBroadcastActor::Server_SendKnockback_Implementation(AActor* Target, AActor* KnockbackInstigator, EDamageType Type, float Resistance, AActor* CallInstigator)
{
    if (!ValidateInstigator(CallInstigator) || !Target)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid parameters for Knockback"));
        return;
    }
 
    Multicast_SendKnockback(Target, KnockbackInstigator, Type, Resistance);
}
 
void ANetworkBroadcastActor::Multicast_SendKnockback_Implementation(AActor* Target, AActor* KnockbackInstigator, EDamageType Type, float Resistance)
{
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast && Target)
    {
        LocalBroadcast->SendKnockback(Target, KnockbackInstigator, Type, Resistance);
    }
}
 
// ========================================
// Mission Timer State
// ========================================
 
void ANetworkBroadcastActor::SendUpdateMissionTimerState(bool bIsActive, float TimeLimit, AActor* EventInstigator)
{
    if (!EventInstigator)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendUpdateMissionTimerState - EventInstigator is null"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: SendUpdateMissionTimerState called - bIsActive: %s, TimeLimit: %.1f"),
        bIsActive ? TEXT("true") : TEXT("false"), TimeLimit);
 
    Server_SendUpdateMissionTimerState(bIsActive, TimeLimit, EventInstigator);
}
 
void ANetworkBroadcastActor::Server_SendUpdateMissionTimerState_Implementation(bool bIsActive, float TimeLimit, AActor* EventInstigator)
{
    if (!ValidateInstigator(EventInstigator))
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid instigator for SendUpdateMissionTimerState"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: Server received SendUpdateMissionTimerState - bIsActive: %s, TimeLimit: %.1f"),
        bIsActive ? TEXT("true") : TEXT("false"), TimeLimit);
 
    Multicast_SendUpdateMissionTimerState(bIsActive, TimeLimit);
}
 
void ANetworkBroadcastActor::Multicast_SendUpdateMissionTimerState_Implementation(bool bIsActive, float TimeLimit)
{
    PRINTLOG(TEXT("NetworkBroadcastActor: Multicast SendUpdateMissionTimerState - bIsActive: %s, TimeLimit: %.1f, Role: %s"),
        bIsActive ? TEXT("true") : TEXT("false"),
        TimeLimit,
        GetLocalRole() == ROLE_Authority ? TEXT("Server") : TEXT("Client"));
 
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast)
    {
        LocalBroadcast->SendUpdateMissionTimerState(bIsActive, TimeLimit);
        PRINTLOG(TEXT("NetworkBroadcastActor: Local BroadcastManager triggered for SendUpdateMissionTimerState"));
    }
}
 
// ========================================
// Tutor Message
// ========================================
 
void ANetworkBroadcastActor::SendTutorMessage(const FText& Message, AActor* EventInstigator)
{
    if (!EventInstigator)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendTutorMessage - EventInstigator is null"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: SendTutorMessage called - Message: %s, EventInstigator: %s"),
        *Message.ToString(), *EventInstigator->GetName());
 
    Server_SendTutorMessage(Message, EventInstigator);
}
 
void ANetworkBroadcastActor::Server_SendTutorMessage_Implementation(const FText& Message, AActor* EventInstigator)
{
    if (!ValidateInstigator(EventInstigator))
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid instigator for TutorMessage"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: Server received TutorMessage - Message: %s"), *Message.ToString());
 
    Multicast_SendTutorMessage(Message);
}
 
void ANetworkBroadcastActor::Multicast_SendTutorMessage_Implementation(const FText& Message)
{
    PRINTLOG(TEXT("NetworkBroadcastActor: Multicast TutorMessage - Message: %s, Role: %s"),
        *Message.ToString(), GetLocalRole() == ROLE_Authority ? TEXT("Server") : TEXT("Client"));
 
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast)
    {
        LocalBroadcast->SendTutorMessage(Message);
        PRINTLOG(TEXT("NetworkBroadcastActor: Local BroadcastManager triggered for TutorMessage"));
    }
}
 
// ========================================
// Teleport All Players
// ========================================
 
void ANetworkBroadcastActor::SendTeleportAllPlayers(const FTransform& TargetTransform, AActor* EventInstigator)
{
    if (!EventInstigator)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: SendTeleportAllPlayers - EventInstigator is null"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: SendTeleportAllPlayers called - Location: %s, EventInstigator: %s"),
        *TargetTransform.ToString(), *EventInstigator->GetName());
 
    Server_SendTeleportAllPlayers(TargetTransform, EventInstigator);
}
 
void ANetworkBroadcastActor::Server_SendTeleportAllPlayers_Implementation(const FTransform& TargetTransform, AActor* EventInstigator)
{
    if (!ValidateInstigator(EventInstigator))
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Invalid instigator for TeleportAllPlayers"));
        return;
    }
 
    PRINTLOG(TEXT("NetworkBroadcastActor: Server received TeleportAllPlayers - Location: %s"), *TargetTransform.ToString());
 
    Multicast_SendTeleportAllPlayers(TargetTransform);
}
 
void ANetworkBroadcastActor::Multicast_SendTeleportAllPlayers_Implementation(const FTransform& TargetTransform)
{
    PRINTLOG(TEXT("NetworkBroadcastActor: Multicast TeleportAllPlayers - Transform: %s, Role: %s"),
        *TargetTransform.ToString(), GetLocalRole() == ROLE_Authority ? TEXT("Server") : TEXT("Client"));
 
    UBroadcastManager* LocalBroadcast = GetLocalBroadcastManager();
    if (LocalBroadcast)
    {
        LocalBroadcast->SendTeleport(TargetTransform);
        PRINTLOG(TEXT("NetworkBroadcastActor: Local BroadcastManager triggered for TeleportAllPlayers"));
    }
}
 
// ========================================
// Utility Functions
// ========================================
 
UBroadcastManager* ANetworkBroadcastActor::GetLocalBroadcastManager() const
{
    if (!GetWorld())
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: GetWorld() returned nullptr"));
        return nullptr;
    }
 
    UBroadcastManager* LocalBroadcast = UBroadcastManager::Get(GetWorld());
    if (!LocalBroadcast)
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: Failed to get UBroadcastManager"));
    }
 
    return LocalBroadcast;
}
 
bool ANetworkBroadcastActor::ValidateInstigator(AActor* EventInstigator) const
{
    if (!EventInstigator || !IsValid(EventInstigator))
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: EventInstigator is null or invalid"));
        return false;
    }
 
    if (!EventInstigator->GetWorld())
    {
        PRINTLOG(TEXT("NetworkBroadcastActor: EventInstigator not in world"));
        return false;
    }
 
    return true;
}