Night of the Dead 멀티플레이를 지금 다시 설계한다면

1
void UZombieOptimizeManager::UpdateDistanceRanks()
2
{
3
  const int32 NumZombies = Zombies.Num();
4
  // 프레임당 정해진 수만큼만 거리를 계산한다
5
  const int32 NumToProcess = FMath::Min(MaxDistanceUpdatesPerFrame, NumZombies - Cursor);
6

7
  for (int32 Step = 0; Step < NumToProcess; ++Step)
8
  {
9
    FZombieEntry& Entry = Zombies[Cursor++];
10
    Entry.DistSq = GetMinDistSqToViewers(Entry.Location);
11
  }
12

13
  // 한 바퀴가 끝났을 때만 정렬하고 순위를 기록한다
14
  if (Cursor >= NumZombies)
15
  {
16
    Zombies.Sort([](const FZombieEntry& A, const FZombieEntry& B) { return A.DistSq < B.DistSq; });
17
    for (int32 Rank = 0; Rank < NumZombies; ++Rank)
18
    {
19
      Zombies[Rank].Component->SetDistanceRank(Rank);
20
    }
21
    Cursor = 0;
22
  }
23
}
24

25
int32 UZombieLODComponent::CalcSendRateGrade() const
26
{
27
  int32 Grade = static_cast<int32>(LOD);
28
  // 가까운 30마리는 등급 값을 2 낮춘다
29
  if (DistanceRank <= 30)
30
  {
31
    Grade = FMath::Max(Grade - 2, 0);
32
  }
33
  return Grade;
34
}

1
USTRUCT()
2
struct FZombieSyncFragment : public FMassFragment
3
{
4
  GENERATED_BODY()
5

6
  uint8 SendRateGrade = 0;
7
};
8

9
UZombieSyncGradeProcessor::UZombieSyncGradeProcessor()
10
  : EntityQuery(*this)
11
{
12
  // 서버에서만 실행한다
13
  ExecutionFlags = static_cast<int32>(EProcessorExecutionFlags::Server);
14
}
15

16
void UZombieSyncGradeProcessor::ConfigureQueries(const TSharedRef<FMassEntityManager>& EntityManager)
17
{
18
  // LOD 수집 프로세서가 채운 값을 읽기만 한다
19
  EntityQuery.AddRequirement<FMassViewerInfoFragment>(EMassFragmentAccess::ReadOnly);
20
  EntityQuery.AddRequirement<FZombieSyncFragment>(EMassFragmentAccess::ReadWrite);
21
}
22

23
void UZombieSyncGradeProcessor::Execute(FMassEntityManager& EntityManager, FMassExecutionContext& Context)
24
{
25
  // 요구 조건에 맞는 엔티티를 청크 단위로 받는다
26
  EntityQuery.ForEachEntityChunk(Context, [this](FMassExecutionContext& Context)
27
  {
28
    const TConstArrayView<FMassViewerInfoFragment> ViewerInfos = Context.GetFragmentView<FMassViewerInfoFragment>();
29
    const TArrayView<FZombieSyncFragment> Syncs = Context.GetMutableFragmentView<FZombieSyncFragment>();
30

31
    for (FMassExecutionContext::FEntityIterator EntityIt = Context.CreateEntityIterator(); EntityIt; ++EntityIt)
32
    {
33
      Syncs[EntityIt].SendRateGrade = CalcGradeByDistanceSq(ViewerInfos[EntityIt].ClosestViewerDistanceSq);
34
    }
35
  });
36
}

1
void APlayerBuilding::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
2
{
3
  Super::GetLifetimeReplicatedProps(OutLifetimeProps);
4

5
  // 액터를 검토할 때마다 이 프로퍼티를 이전에 보낸 값과 비교한다
6
  DOREPLIFETIME(APlayerBuilding, CollisionProfile);
7
}
8

9
void APlayerBuilding::ServerSetCollisionProfile_Implementation(const FName& NewProfileName)
10
{
11
  CollisionProfile = NewProfileName;
12
  ApplyCollisionProfile();
13
  // 무엇이 바뀌었는지는 알리지 않고 액터를 바로 검토하게만 한다
14
  ForceNetUpdate();
15
}

1
void APlayerBuilding::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
2
{
3
  Super::GetLifetimeReplicatedProps(OutLifetimeProps);
4

5
  FDoRepLifetimeParams Params;
6
  // 변경을 표시한 프로퍼티만 비교한다
7
  Params.bIsPushBased = true;
8
  DOREPLIFETIME_WITH_PARAMS_FAST(APlayerBuilding, CollisionProfile, Params);
9
}
10

11
void APlayerBuilding::SetCollisionProfile(const FName& NewProfileName)
12
{
13
  if (CollisionProfile != NewProfileName)
14
  {
15
    // 값을 수정하기 전에 휴면을 해제한다
16
    FlushNetDormancy();
17

18
    CollisionProfile = NewProfileName;
19
    // 이 프로퍼티가 바뀌었다고 엔진에 알린다
20
    MARK_PROPERTY_DIRTY_FROM_NAME(APlayerBuilding, CollisionProfile, this);
21
    ApplyCollisionProfile();
22
  }
23
}

1
void UInventoryComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
2
{
3
  Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
4

5
  if (GetOwner()->HasAuthority())
6
  {
7
    // 바뀐 것이 없어도 매 틱 서버에서 배열 전체를 복사한다
8
    ReplicatedItems.SetNum(Items.Num());
9
    for (int32 Index = 0; Index < Items.Num(); ++Index)
10
    {
11
      ReplicatedItems[Index] = FReplicatedItem(Items[Index]);
12
    }
13
  }
14
}
15

16
void UInventoryComponent::OnRep_ReplicatedItems()
17
{
18
  // 어느 칸이 바뀌었는지 전달되지 않아 원본과 수량 집계를 전부 다시 만든다
19
  Items.Reset(ReplicatedItems.Num());
20
  for (const FReplicatedItem& Replicated : ReplicatedItems)
21
  {
22
    Items.Add(FInventoryItem(FindEntityData(Replicated.EntityId), Replicated.Amount, Replicated.ItemId));
23
  }
24

25
  RebuildAmountView();
26
}

1
struct FInventoryList;
2

3
USTRUCT()
4
struct FInventoryEntry : public FFastArraySerializerItem
5
{
6
  GENERATED_BODY()
7

8
  UPROPERTY()
9
  // 클라이언트에서 항목 순서가 보장되지 않으므로 칸 번호를 항목에 둔다
10
  int32 SlotIndex = INDEX_NONE;
11

12
  UPROPERTY()
13
  int32 EntityId = 0;
14

15
  UPROPERTY()
16
  int32 Amount = 0;
17

18
  UPROPERTY()
19
  FGuid ItemId;
20

21
  // 추가, 변경, 삭제된 항목마다 불리는 콜백
22
  void PostReplicatedAdd(const FInventoryList& List);
23
  void PostReplicatedChange(const FInventoryList& List);
24
  void PreReplicatedRemove(const FInventoryList& List);
25
};
26

27
USTRUCT()
28
struct FInventoryList : public FFastArraySerializer
29
{
30
  GENERATED_BODY()
31

32
  UPROPERTY()
33
  TArray<FInventoryEntry> Entries;
34

35
  // 콜백에서 쓰는 참조이며 복제하지 않는다
36
  UPROPERTY(NotReplicated)
37
  TObjectPtr<UInventoryComponent> Owner = nullptr;
38

39
  bool NetDeltaSerialize(FNetDeltaSerializeInfo& DeltaParams)
40
  {
41
    // 항목 단위 델타 직렬화에 맡긴다
42
    return FFastArraySerializer::FastArrayDeltaSerialize<FInventoryEntry, FInventoryList>(Entries, DeltaParams, *this);
43
  }
44
};
45

46
template<>
47
struct TStructOpsTypeTraits<FInventoryList> : public TStructOpsTypeTraitsBase2<FInventoryList>
48
{
49
  enum
50
  {
51
    // 이 구조체가 NetDeltaSerialize를 쓴다고 엔진에 알린다
52
    WithNetDeltaSerializer = true,
53
  };
54
};

1
void UInventoryComponent::SetAmount(int32 EntryIndex, int32 NewAmount)
2
{
3
  FInventoryEntry& Entry = Inventory.Entries[EntryIndex];
4
  if (Entry.Amount != NewAmount)
5
  {
6
    Entry.Amount = NewAmount;
7
    // 바뀐 항목만 복제 대상으로 표시한다
8
    Inventory.MarkItemDirty(Entry);
9
  }
10
}
11

12
void FInventoryEntry::PostReplicatedChange(const FInventoryList& List)
13
{
14
  List.Owner->OnSlotChanged(SlotIndex, EntityId, Amount);
15
}

1
void FItemContainer::RefreshReplicatedItems(const AActor* Owner)
2
{
3
  const IDistanceGatedReplication* Gate = Cast<IDistanceGatedReplication>(Owner);
4
  if (Gate && IsAnyPlayerWithin(Owner->GetActorLocation(), Gate->GetReplicationDistance()) == false)
5
  {
6
    // 근처에 아무도 없으면 비운다. 이 배열은 액터를 복제받는 모든 연결이 공유한다
7
    ReplicatedItems.Empty();
8
    return;
9
  }
10

11
  ReplicatedItems.SetNum(Items.Num());
12
  for (int32 Index = 0; Index < Items.Num(); ++Index)
13
  {
14
    ReplicatedItems[Index] = FReplicatedItem(Items[Index]);
15
  }
16
}

1
void AStorageBuilding::BeginPlay()
2
{
3
  Super::BeginPlay();
4

5
  if (HasAuthority())
6
  {
7
    Contents = NewObject<UStorageContents>(this);
8
    // 그룹에 속한 PlayerController의 연결에만 복제한다
9
    AddReplicatedSubObject(Contents, COND_NetGroup);
10

11
    UNetworkSubsystem* NetSubsystem = GetWorld()->GetSubsystem<UNetworkSubsystem>();
12
    NetSubsystem->GetNetConditionGroupManager().RegisterSubObjectInGroup(Contents, ContentsGroupName);
13
  }
14
}
15

16
void AStorageBuilding::RefreshViewers()
17
{
18
  for (FConstPlayerControllerIterator It = GetWorld()->GetPlayerControllerIterator(); It; ++It)
19
  {
20
    APlayerController* PlayerController = It->Get();
21
    if (PlayerController == nullptr)
22
    {
23
      continue;
24
    }
25

26
    // 가까워지면 그룹에 넣고 멀어지면 뺀다. 내용물 데이터는 건드리지 않는다
27
    const bool bIsNear = IsWithinContentsDistance(PlayerController->GetPawn());
28
    const bool bIsMember = PlayerController->IsMemberOfNetConditionGroup(ContentsGroupName);
29

30
    if (bIsNear && bIsMember == false)
31
    {
32
      PlayerController->IncludeInNetConditionGroup(ContentsGroupName);
33
    }
34
    else if (bIsNear == false && bIsMember)
35
    {
36
      PlayerController->RemoveFromNetConditionGroup(ContentsGroupName);
37
    }
38
  }
39
}

1
void UStreamRouterComponent::SendPendingChunks(const UActorChannel* Channel)
2
{
3
  const int32 ChunkSize = 100;
4
  // 수신 확인을 받지 못한 번치가 이 수보다 적을 때만 다음 조각을 보낸다
5
  const int32 OutRecLimit = RELIABLE_BUFFER / 4;
6

7
  for (FStreamRequest& Request : Requests)
8
  {
9
    const int32 NumChunks = Request.GetNumChunks(ChunkSize);
10
    while (Request.ChunksSent < NumChunks && Channel->NumOutRec < OutRecLimit)
11
    {
12
      const int32 Start = Request.ChunksSent * ChunkSize;
13
      const int32 Count = FMath::Min(ChunkSize, Request.Records.Num() - Start);
14

15
      ClientReceiveChunk(Request.Tag, TArray<FStreamRecord>(Request.Records.GetData() + Start, Count));
16
      ++Request.ChunksSent;
17
    }
18
  }
19
}

1
void UStreamRouterComponent::SendPendingChunks()
2
{
3
  // 확인받지 못한 조각이 한도에 닿으면 멈춘다
4
  while (Requests.IsEmpty() == false && NextChunkId - LastAckedChunkId < MaxUnackedChunks)
5
  {
6
    FStreamRequest& Request = Requests[0];
7

8
    TArray<FStreamRecord> Chunk;
9
    int32 ChunkBytes = 0;
10
    while (Request.NextRecord < Request.Records.Num())
11
    {
12
      const FStreamRecord& Record = Request.Records[Request.NextRecord];
13
      // 바이트 한도를 넘기기 직전까지 담는다. 첫 레코드는 한도를 넘어도 담는다
14
      if (Chunk.Num() > 0 && ChunkBytes + Record.Bytes.Num() > MaxChunkBytes)
15
      {
16
        break;
17
      }
18

19
      ChunkBytes += Record.Bytes.Num();
20
      Chunk.Add(Record);
21
      ++Request.NextRecord;
22
    }
23

24
    const bool bIsLastChunk = Request.NextRecord >= Request.Records.Num();
25
    ClientReceiveChunk(NextChunkId++, Request.Tag, Chunk, bIsLastChunk);
26

27
    if (bIsLastChunk)
28
    {
29
      Requests.RemoveAt(0);
30
    }
31
  }
32
}
33

34
void UStreamRouterComponent::ServerAckChunk_Implementation(uint32 ChunkId)
35
{
36
  // 클라이언트가 조각을 처리한 뒤 호출한다
37
  LastAckedChunkId = FMath::Max(LastAckedChunkId, ChunkId);
38
}