언리얼 네트워킹 기본 개념

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "MyReplicatedActor.generated.h"

UCLASS()
class MYPROJECT_API AMyReplicatedActor : public AActor
{
    GENERATED_BODY()

public:    
    AMyReplicatedActor();

protected:
    virtual void BeginPlay() override;

    // 액터가 네트워크를 통해 복제될 수 있도록 설정
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
};

#include "MyReplicatedActor.h"
#include "Net/UnrealNetwork.h" // DOREPLIFETIME 매크로를 위해 포함

AMyReplicatedActor::AMyReplicatedActor()
{
    // 이 액터가 네트워크를 통해 복제될 것임을 명시
    bReplicates = true;

    // 액터의 움직임도 복제될 것임을 명시 (Actor Movement Component가 있어야 효과 있음)
    SetReplicateMovement(true);
}

void AMyReplicatedActor::BeginPlay()
{
    Super::BeginPlay();
    
    // 서버에서만 특정 로직 실행
    if (HasAuthority())
    {
        UE_LOG(LogTemp, Warning, TEXT("AMyReplicatedActor: This is the Server!"));
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("AMyReplicatedActor: This is a Client!"));
    }
}

// 이 함수를 오버라이드하여 복제할 변수들을 정의합니다.
void AMyReplicatedActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    // DOREPLIFETIME(클래스명, 변수명): 해당 변수가 네트워크를 통해 복제되도록 선언
    // DOREPLIFETIME(AMyReplicatedActor, MyReplicatedVariable); // 아래에서 예시 변수 추가 예정
}

#pragma once

// ...
#include "GameFramework/Actor.h"
#include "MyReplicatedActor.generated.h"

UCLASS()
class MYPROJECT_API AMyReplicatedActor : public AActor
{
    GENERATED_BODY()

public:    
    // ...

protected:
    // 서버에서만 값을 변경하고 클라이언트로 복제할 변수
    UPROPERTY(Replicated, BlueprintReadOnly, Category = "Replication")
    int32 ReplicatedInteger;

    // 값이 변경될 때마다 클라이언트에서 특정 함수를 호출할 변수
    UPROPERTY(ReplicatedUsing = OnRep_ReplicatedFloat, BlueprintReadOnly, Category = "Replication")
    float ReplicatedFloat;

    // ReplicatedUsing에 지정된 함수 (OnRep_ 접두사 권장)
    UFUNCTION()
    void OnRep_ReplicatedFloat();

public:
    // 복제된 변수 값을 변경하는 서버 전용 함수 (블루프린트 호출 가능)
    UFUNCTION(BlueprintCallable, Category = "Replication")
    void Server_SetReplicatedValues(int32 NewInt, float NewFloat);
};

#include "MyReplicatedActor.h"
#include "Net/UnrealNetwork.h"

// ... 생성자 및 BeginPlay ...

void AMyReplicatedActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    // Replicated 지정된 변수 복제
    DOREPLIFETIME(AMyReplicatedActor, ReplicatedInteger);

    // ReplicatedUsing 지정된 변수 복제 (OnRep_ 함수와 연결)
    DOREPLIFETIME(AMyReplicatedActor, ReplicatedFloat);
}

void AMyReplicatedActor::OnRep_ReplicatedFloat()
{
    // 이 함수는 ReplicatedFloat 변수의 값이 클라이언트로 복제될 때 클라이언트에서 호출됩니다.
    // 서버에서는 호출되지 않습니다.
    UE_LOG(LogTemp, Warning, TEXT("Client: ReplicatedFloat changed to: %f"), ReplicatedFloat);
    // 여기에 클라이언트에서만 필요한 시각적 효과나 사운드 재생 등을 구현할 수 있습니다.
}

void AMyReplicatedActor::Server_SetReplicatedValues(int32 NewInt, float NewFloat)
{
    // 이 함수는 서버에서만 실행되어야 합니다.
    // HasAuthority()는 현재 코드가 서버에서 실행되고 있는지 확인하는 데 사용됩니다.
    if (HasAuthority())
    {
        ReplicatedInteger = NewInt;
        ReplicatedFloat = NewFloat; // 이 값을 변경하면 클라이언트로 복제되고 OnRep_ReplicatedFloat가 호출됩니다.
        UE_LOG(LogTemp, Warning, TEXT("Server: Replicated values set to Int: %d, Float: %f"), ReplicatedInteger, ReplicatedFloat);
    }
}

#pragma once

// ...

UCLASS()
class MYPROJECT_API AMyReplicatedActor : public AActor
{
    GENERATED_BODY()

public:    
    // ...

protected:
    // 서버에서만 실행될 RPC (클라이언트 -> 서버)
    // Validate: Optional, 클라이언트에서 보낸 인자가 유효한지 서버에서 검증하는 함수
    // Reliable: Guaranteed delivery, 신뢰할 수 있는 전송 (패킷 손실 시 재전송)
    UFUNCTION(Server, Reliable, WithValidation)
    void Server_DoSomething(int32 Value);
    bool Server_DoSomething_Validate(int32 Value); // Validate 함수는 _Validate 접미사 필수
    void Server_DoSomething_Implementation(int32 Value); // Implementation 함수는 _Implementation 접미사 필수

    // 클라이언트에서 실행될 RPC (서버 -> 클라이언트)
    // Client: 해당 액터를 소유한 클라이언트에서만 실행
    UFUNCTION(Client, Reliable)
    void Client_NotifySomethingHappened(const FString& Message);

    // 모든 클라이언트에서 실행될 RPC (서버 -> 모든 클라이언트)
    // NetMulticast: 모든 클라이언트 (호출한 서버 포함)에서 실행
    UFUNCTION(NetMulticast, Unreliable) // Unreliable: Non-guaranteed delivery (패킷 손실 무시, 빠름)
    void Multicast_PlayEffectAtLocation(FVector Location);

public:
    // 클라이언트에서 호출하여 서버 RPC를 트리거하는 함수 (블루프린트 호출 가능)
    UFUNCTION(BlueprintCallable, Category = "Replication")
    void TriggerServerFunction(int32 MyValue);

    // 서버에서 호출하여 클라이언트 RPC를 트리거하는 함수 (블루프린트 호출 가능)
    UFUNCTION(BlueprintCallable, Category = "Replication")
    void TriggerClientFunction(const FString& NotificationMessage, bool bTriggerMulticast, FVector EffectLoc);
};

#include "MyReplicatedActor.h"

// ...

// Server RPC 구현
bool AMyReplicatedActor::Server_DoSomething_Validate(int32 Value)
{
    // 입력 값 유효성 검사 (예: Value가 허용 범위 내에 있는지 확인)
    if (Value < 0 || Value > 100)
    {
        UE_LOG(LogTemp, Warning, TEXT("Server_DoSomething_Validate: Invalid Value %d from client!"), Value);
        return false; // 유효하지 않으면 함수 실행 중단
    }
    return true; // 유효하면 실행 허용
}

void AMyReplicatedActor::Server_DoSomething_Implementation(int32 Value)
{
    // 이 로직은 서버에서만 실행됩니다.
    UE_LOG(LogTemp, Warning, TEXT("Server: Received RPC Server_DoSomething with Value: %d"), Value);
    // 여기서 게임 로직(예: 데미지 계산, 아이템 사용 등)을 처리합니다.

    // 서버가 다시 클라이언트에게 알림을 보낼 수도 있습니다.
    Client_NotifySomethingHappened(FString::Printf(TEXT("Server processed your request with value: %d"), Value));
}

// Client RPC 구현
void AMyReplicatedActor::Client_NotifySomethingHappened_Implementation(const FString& Message)
{
    // 이 로직은 해당 액터를 소유한 클라이언트에서만 실행됩니다.
    // 서버에서는 이 함수가 호출되지 않습니다.
    if (!HasAuthority()) // 클라이언트임을 다시 확인
    {
        UE_LOG(LogTemp, Warning, TEXT("Client: Received RPC Client_NotifySomethingHappened: %s"), *Message);
        // 여기에 UI 업데이트, 로컬 이펙트 재생 등을 구현합니다.
    }
}

// NetMulticast RPC 구현
void AMyReplicatedActor::Multicast_PlayEffectAtLocation_Implementation(FVector Location)
{
    // 이 로직은 서버를 포함하여 모든 클라이언트에서 실행됩니다.
    UE_LOG(LogTemp, Warning, TEXT("All: Received RPC Multicast_PlayEffectAtLocation at %s"), *Location.ToString());
    // 여기에 시각/청각 효과(파티클, 사운드 등) 재생을 구현하여 모든 플레이어가 볼 수 있도록 합니다.
}

// 클라이언트에서 호출할 함수 (RPC 트리거)
void AMyReplicatedActor::TriggerServerFunction(int32 MyValue)
{
    // 이 함수는 클라이언트에서 호출될 수 있습니다.
    // 클라이언트에서 호출되면 Server_DoSomething_Implementation을 서버에서 실행하도록 요청합니다.
    Server_DoSomething(MyValue);
}

// 서버에서 호출할 함수 (RPC 트리거)
void AMyReplicatedActor::TriggerClientFunction(const FString& NotificationMessage, bool bTriggerMulticast, FVector EffectLoc)
{
    // 이 함수는 서버에서 호출되어야 합니다.
    if (HasAuthority())
    {
        Client_NotifySomethingHappened(NotificationMessage); // 특정 클라이언트에게만 알림

        if (bTriggerMulticast)
        {
            Multicast_PlayEffectAtLocation(EffectLoc); // 모든 클라이언트에게 효과 재생 명령
        }
    }
}