Reliable 버퍼 상태를 보고 대용량 데이터 나눠 보내기

1
USTRUCT()
2
struct FStreamRecord
3
{
4
  GENERATED_BODY()
5

6
  UPROPERTY()
7
  TArray<uint8> Bytes;
8
};
9

10
class IStreamSocket
11
{
12
  GENERATED_BODY()
13

14
public:
15
  // 이 소켓이 처리하는 태그 목록
16
  virtual const TArray<FGameplayTag>& GetStreamTags() const = 0;
17

18
  // 클라이언트: 레코드 묶음을 받아 자기 상태에 반영한다.
19
  virtual void DecodeRecords(const FGameplayTag& Tag, const TArray<FStreamRecord>& Records) = 0;
20

21
  // 클라이언트: 해당 태그의 전송이 끝났다.
22
  virtual void OnStreamCompleted(const FGameplayTag& Tag) = 0;
23
};

1
struct FStreamRequest
2
{
3
  FGameplayTag Tag;
4
  TArray<FStreamRecord> Records;
5
  int32 ChunksSent = 0;
6

7
  int32 GetNumChunks(int32 ChunkSize) const
8
  {
9
    return FMath::DivideAndRoundUp(Records.Num(), ChunkSize);
10
  }
11
};
12

13
void UStreamRouterComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
14
{
15
  Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
16

17
  if (GetOwnerRole() != ROLE_Authority)
18
  {
19
    return;
20
  }
21

22
  UNetConnection* Connection = GetOwner()->GetNetConnection();
23
  const UActorChannel* Channel = Connection ? Connection->FindActorChannelRef(GetOwner()) : nullptr;
24
  if (Channel == nullptr)
25
  {
26
    return;
27
  }
28

29
  const int32 ChunkSize = 100;
30
  // 같은 채널의 다른 Reliable RPC가 들어올 여유를 남긴다.
31
  const int32 OutRecLimit = RELIABLE_BUFFER / 4;
32

33
  for (FStreamRequest& Request : Requests)
34
  {
35
    const int32 NumChunks = Request.GetNumChunks(ChunkSize);
36
    // NumOutRec은 보냈지만 아직 ACK를 받지 못한 Reliable 번치 수다.
37
    while (Request.ChunksSent < NumChunks && Channel->NumOutRec < OutRecLimit)
38
    {
39
      const int32 Start = Request.ChunksSent * ChunkSize;
40
      const int32 Count = FMath::Min(ChunkSize, Request.Records.Num() - Start);
41

42
      ClientReceiveChunk(Request.Tag, TArray<FStreamRecord>(Request.Records.GetData() + Start, Count));
43
      ++Request.ChunksSent;
44
    }
45
  }
46

47
  // 완료 알림도 Reliable RPC이므로 같은 기준으로 막는다.
48
  for (int32 Index = Requests.Num() - 1; Index >= 0; --Index)
49
  {
50
    if (Channel->NumOutRec >= OutRecLimit)
51
    {
52
      break;
53
    }
54

55
    if (Requests[Index].ChunksSent >= Requests[Index].GetNumChunks(ChunkSize))
56
    {
57
      ClientNotifyCompleted(Requests[Index].Tag);
58
      Requests.RemoveAt(Index);
59
    }
60
  }
61
}

1
TArray<FStreamRecord> UQuestComponent::EncodePendingProgress()
2
{
3
  TArray<FStreamRecord> Records;
4
  Records.Reserve(PendingProgress.Num());
5

6
  for (FQuestProgressNet& Progress : PendingProgress)
7
  {
8
    FStreamRecord& Record = Records.AddDefaulted_GetRef();
9
    FMemoryWriter Writer(Record.Bytes);
10

11
    bool bSuccess = true;
12
    Progress.NetSerialize(Writer, nullptr, bSuccess);
13
  }
14

15
  PendingProgress.Reset();
16
  return Records;
17
}

1
void AMyCharacter::BroadcastHit(const FHitInfoNet& HitInfo)
2
{
3
  const int32 OutRecLimit = RELIABLE_BUFFER / 4;
4
  const double ReliableDistSq = FMath::Square(15000.0); // 150m. 언리얼 단위는 cm다.
5
  const double SkipDistSq = FMath::Square(30000.0); // 300m
6

7
  for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; ++It)
8
  {
9
    APlayerController* PlayerController = It->Get();
10
    AMyCharacter* Receiver = PlayerController ? Cast<AMyCharacter>(PlayerController->GetPawn()) : nullptr;
11
    UNetConnection* Connection = PlayerController ? PlayerController->GetNetConnection() : nullptr;
12
    if (Receiver == nullptr || Connection == nullptr)
13
    {
14
      continue;
15
    }
16

17
    const double DistSq = FVector::DistSquared(Receiver->GetActorLocation(), GetActorLocation());
18
    if (DistSq >= SkipDistSq)
19
    {
20
      continue;
21
    }
22

23
    // RPC가 실제로 쌓이는 수신자 캐릭터의 채널을 확인한다.
24
    const UActorChannel* Channel = Connection->FindActorChannelRef(Receiver);
25
    const bool bHasRoom = Channel && Channel->NumOutRec <= OutRecLimit;
26

27
    if (DistSq < ReliableDistSq && bHasRoom)
28
    {
29
      Receiver->ClientHandleHit_Reliable(this, HitInfo);
30
    }
31
    else
32
    {
33
      Receiver->ClientHandleHit_Unreliable(this, HitInfo);
34
    }
35
  }
36
}