Net Cells
Many plugins have things at places that clients near them need: props with their state, Pulse Sim records, building pieces, the changes of a world region. Each of them used to bring its own replicators per cell, its own relevance, its own split of big cells and its own way to keep or drop what a client walked away from. Net Cells does this once in PulseFoundation: a plugin registers a channel and the server writes entries (channel, key, location, value); Net Cells puts them into the cells of a layer, sends each cell to the clients near it and tells the channel on the client what was added, changed or removed, and what the client lost.
- One actor per cell and layer carries the entries of every channel; a cell too big for one packet splits into several actors (pieces), so the first packet of an actor stays below 64 KB.
- The server writes only mark; the bytes of an entry are built once per build interval of its layer, however often it was written. Bytes equal to those the actor already carries are not sent again (no dirty item, a dormant piece stays asleep), and a build allocates nothing per entry once its scratch arrays have grown.
- An entry that moves into another cell keeps living on the clients that have it (no Removed and Added).
- Replication through replicated properties only (push model, no RPCs): it works with classic replication and Iris.
- Not for actors with a relevance of their own (wave events, pickups, resource nodes): they replicate as before.
Compile switch: PULSE_WITH_NETCELLS=1 (PulseFoundation.Build.cs). Code that must also build against an older PulseFoundation tests it as #if defined(PULSE_WITH_NETCELLS) && PULSE_WITH_NETCELLS.
The contract of a plugin
// StartupModule (game thread): the same on server and clients of one build
Pulse::NetCells::FChannel channel;
channel.Tag = MyTags::NetCells_Channel_Crates; // below Pulse.NetCells.Channel
channel.Layer = Pulse::Foundation::Tags::NetCells_Layer_Near;
channel.OnLoss = EPulseNetCellLoss::Keep; // what a client does when it loses the cell
channel.ValueStruct = FMyCrateNetValue::StaticStruct(); // tagged value with an int32 Version; null = raw bytes
Pulse::NetCells::RegisterChannel(channel);
// ShutdownModule
Pulse::NetCells::UnregisterChannel(MyTags::NetCells_Channel_Crates);
// Server: write, move (a new location), remove
UPulseNetCellSubsystem* cells = UPulseNetCellSubsystem::Get(this);
cells->Write(Channel, FPulseNetCellKey(CrateId.A, CrateId.B), GetActorLocation(), Value);
cells->Remove(Channel, Key);
// Every machine: the handler (called only on clients), one call per channel with a batch of events
cells->SetChannelHandler(Channel, FPulseNetCellHandler::CreateUObject(this, &UMyCrates::OnNetCells));
void UMyCrates::OnNetCells(TArrayView<FPulseNetCellEvent> InEvents)
{
for (FPulseNetCellEvent& event : InEvents)
{
FMyCrateNetValue value;
if (event.Kind == EPulseNetCellEventKind::Added && event.Read(value) == EPulseReadResult::Success)
event.Result = ApplyToCrate(event.Key, value) ? EPulseNetCellApply::Applied : EPulseNetCellApply::Waiting;
}
}
- Key: 64 + 32 bits (
FPulseNetCellKey), unique within the channel. Plugins derive it from their own ids;FPulseNetCellKey::FromNamegives the key of a name, the same on every machine (CityHash64 of the lowered plain name, the number in B).ToStringwrites%016llx:%08x,Parsealso readsname:<id>. - Value: three ways to write.
Write<T>/WriteStruct: a USTRUCT with anint32 Version, written tagged without itsNotReplicatedfields (they stay on the server). Tagged values carry names and sizes per property: for channels that write rarely.WriteBytes: raw bytes of a compact codec of the plugin (Pulse::NetCells::FByteWriter/FByteReader). Bytes over the cap of the channel are refused at once.MarkDirty: the writer of the channel (SetChannelWriter) builds the bytes at build time (pull), once per build interval.
- Place: a location (its cell in the channel’s layer),
FPulseNetCellPlace::Global()(the Global layer, every client gets it) orFPulseNetCellPlace::KeepPlace()(the cell and height the entry has, without moving it).FindEntryPlacesays where an entry lives. - Writes run on the server with a network (listen or dedicated); in a standalone world they return false at once, on a client they warn once.
Waiting for the thing of an entry
An entry can arrive before the thing it belongs to (a prop instance whose level streams in later). The handler sets Result = Waiting; the entry stays in the mirror of the client and RetryEntry(Channel, Key) or RetryWaiting(Channel) dispatches it again as Added once the thing is there. RetryEntry runs the handler for that one entry at once and alone: the queued events of other entries and channels wait for the next tick, so registering a thing never runs other handlers (called from inside a handler, it is queued for the next round). GetWaitingEntries lists them. A handler that cannot read an entry calls MarkDecodeFailed, so it is counted and not listed as live.
Reading on any machine
ReadEntry<T>, FindEntryBytes, ForEachEntry, ForEachEntryInCell and GetEntryState read the table of the server or the mirror of a client (kept entries too). GetEntryState says None, Pending, Live, Moving, Kept, Waiting or Refused.
Example: the states of prop instances
Pulse Props sends the states of its prop instances through Net Cells (Many instances):
- Channel
Pulse.NetCells.Channel.Props(Pulse::Visual::Tags::NetCells_Channel_Props), layer Near,OnLoss = Keep, raw bytes, cap 2048; registered inStartupModuleof PulseVisual. - Key: A = the set of the instance, B = its id (
Pulse::Visual::PropNet::MakeKey). - Value: a compact codec (
Pulse::Visual::PropNet::Encode/DecodeonFByteWriter/FByteReader): format byte, state as plain name and number, change time, then per Replicated event its name, count and last start; a newer format reads as TooNew, rest bytes as Corrupt. The server keeps the full value (withExpireTime) in its own map, so it never decodes its own entries. - The server writes with
WriteBytesat the location of the instance, or withKeepPlacewhen a Pulse Sim record changes the state of an instance that is not loaded (the entry keeps its cell and height), and removes the entry in the start state once its events cannot play any more. - The client handler applies Added and Changed to the instance (far, or to its live prop as OnRep) or answers
Waitingwhile the instance is not there;ApplyKnowncallsRetryEntrywhen the instance registers. Removed puts the instance back to its start state. Keep and the vanished cell rule give the old behaviour: kept states when a cell leaves, the start state for entries the server removed while the client was away.
Example: the records of Pulse Sim
Pulse Sim sends its records with a relevancy through Net Cells (Multiplayer):
- Channel
Pulse.NetCells.Channel.Sim(Pulse::Foundation::Tags::NetCells_Channel_Sim), layer Near,OnLoss = Delete, raw bytes, cap 2048,bOwnPieces(records change often: their own actors keep the props of a cell out of the delta); registered inStartupModuleof PulseFoundation. - Key:
Pulse::Sim::Replication::MakeRecordKey(Id)=FPulseNetCellKey::FromName; the id itself travels in the value, because a client cannot get a name back from its hash. The server refuses a second id with a key it has. - Value:
Pulse::Sim::Replication::EncodeRecord/DecodeRecord(format, id, kind hash, kind version, location, times, stalled flag, the state withoutNotReplicatedfields); other kind versions and broken bytes are decode failures (MarkDecodeFailed), a kind that is not loaded yet answersWaitingand reads again when a module loads; each error is warned once. - Pull: the server calls
MarkDirtyfor a changedSpatialrecord at its location and for anAlwaysrecord withFPulseNetCellPlace::Global()(the Global layer, always relevant and dormant while quiet); its writer (SetChannelWriter) encodes the record when the cell builds, once per net update. RelevancyNoneand removed records areRemoved. A change of cell or relevancy moves the entry inside Net Cells, so clients keep the record. - The client handler sets Added and Changed into its store (
Store.Set, nothing runs on clients) and removes the record on Removed and Lost.
Layers
A layer is the size of its cells, the radius within which clients get them, how often they build and update and how long an empty cell keeps its actors. Layers are in Project Settings > Pulse > Foundation > Net Cells; a world may set its own values or a layer the settings do not list with SetWorldLayer on server and clients, before the first write of that layer or after ResetLayer (Changing the world layer). TuneWorldLayer changes the radius, the update rate, the empty cell wait and the dormancy and grace times of a layer that has cells already (the live actors take the new cull distance and rate at once); the cell size, kind, presence, piece budget and actor class cannot change while it has cells. The cheat PulseNetCellsLayer uses it. Nothing sends a layer to other machines: call SetWorldLayer and TuneWorldLayer with the same values on the server and every client, because a client’s vanished-cell check uses its own radius. A Keep channel on a layer with NearSources presence relies on the presence matching where the clients are: a near cell the server holds no actor for counts as removed on the client.
| Layer | Kind | Cell | Radius | Updates | Empty wait | Actors | Dormant |
|---|---|---|---|---|---|---|---|
Pulse.NetCells.Layer.Near | Grid | 10000 cm | 15000 cm | 5 / s | 10 s | with entries | no |
Pulse.NetCells.Layer.Region | Grid | 204800 cm | 25600 cm | 2 / s | 30 s | near sources | no |
Pulse.NetCells.Layer.Global | Global | - | - | 5 / s | 10 s | with entries | after 5 s |
- Grid layers cut the X/Y plane into cells (Grid); a client gets a cell while it is within the radius of any point of it, measured in the plane.
- Global has no cells: one actor every client gets.
- Near Sources (
Presence): only cells near a player view (or whatSetPresenceQuerysays) have actors; the entries stay on the server meanwhile. A cell stops being wanted only when no source is within 1.1 times its cull distance forPresenceHoldSeconds.RefreshPresencechecks at once instead of with the next upkeep. - Dormant: quiet actors go dormant after
DormantAfterSeconds. A client keeps a dormant actor after it walked away, so its entries stay like Keep until the actor really closes: only for always relevant data or data that may stay. Every change wakes the actor first. - Custom layers: add a row with a tag below
Pulse.NetCells.Layer.
Changing the world layer
SetWorldLayer refuses (an error in the log, false) while the layer holds cells, because cells of another size or budget cannot follow. A world whose definition changes in a running session (another region grid, another level of detail) first empties the layer on the server:
// Server, in one frame
UPulseNetCellSubsystem* cells = UPulseNetCellSubsystem::Get(this);
const int32 removed = cells->ResetLayer(Pulse::Foundation::Tags::NetCells_Layer_Region);
cells->SetWorldLayer(NewRegionLayer); // succeeds: the layer is empty
cells->WriteBytes(Channel, Key, Location, Bytes); // lands in the fresh layer
ResetLayer(Layer)(server only) removes every entry of every channel on the layer, pending writes too, destroys its cell actors (split pieces too; a second later, see below) and forgets its tombstones, presence and dormancy, and returns the number of entries removed. Tombstones that entries of the layer left in other layers go too; entries that left the layer stay where they are. On a client it does nothing (logged once) and returns 0.- The layer counts as empty as soon as the call returns: actors that are still being destroyed belong to it no more.
IsLayerEmpty(Layer)says whetherSetWorldLayermay change the layer now (no cells on the server, no open cell actor of the current epoch on a client). - Writes after the call, also in the same frame, go into fresh cells with new actors.
- Every reset raises the reset epoch of the layer (
GetLayerEpoch). The world layer values themselves are not sent: callSetWorldLayerwith the new values on every client too, onceIsLayerEmptyis true there (it is as soon as the client saw the new epoch).
What clients do: a reset is authoritative. Every entry the layer brought goes, also kept ones of Keep channels and entries kept by a client that was away:
OnLoss | On the client after a reset |
|---|---|
Keep, Delete | Removed per entry (no Lost, nothing stays kept). |
ResetCell | One CellReset per cell of the layer it had entries in or an open actor of (the cell’s first batch is held again with bHoldUntilCellComplete). |
Events the client had queued or held for the layer reach the handlers first, so an Added never comes after the reset that took its entry; the entries of the fresh layer come after it as Added.
How the client learns of the reset (replicated properties only, push model, classic replication and Iris alike):
- Every cell actor carries the reset epoch of its layer from its spawn (
LayerEpoch, initial only). - The always relevant state actor
APulseNetCellStateActor(spawned by the server with the first reset, no Iris filter line) carries the epoch of every layer that was reset (FPulseNetCellLayerEpoch), so far clients learn of it too and a late joiner gets it with its first packet. - Whichever comes first, a new cell actor or the state actor, resets the client mirror: actors of older epochs are detached (their close, items and updates change nothing any more; an old actor that opens late is ignored) and every entry of the layer that no actor of the new epoch claimed goes. A newer actor resets the mirror before its own items apply. Without the state actor a client far from every fresh cell would keep its stale Keep entries.
- On a real net driver a destroyed actor closes on the clients at once, while the state actor sends the epoch with its next net update. So the server keeps the cell actors of a reset layer for a second (out of the table: no builds, not in the stats) and destroys them then; the epoch reaches the clients first and
Deletechannels getRemoved. Only when the epoch is that late (heavy packet loss) aDeletechannel whose cell actor closed first getsLostfor those entries;KeepandResetCellchannels end the same in either order.
What clients do when they lose a cell
Each channel says what its entries do when the client loses their cell (out of relevance, or the server removed it):
OnLoss | On the client |
|---|---|
Keep | The entries stay as they were (Kept). When the cell comes again, kept entries its first packet does not carry are Removed; a cell the client stands near for 3 s (VanishedCellSeconds, within SureRelevanceShare of the radius, at least three net updates of the layer) without it coming counts as removed while the client was away. Kept entries of a cell whose pieces are all open but none covers them (their piece has no actor) are Removed after the same wait. |
Delete | One Lost event per entry. |
ResetCell | The entries of the cell go without events of their own; the channel gets one CellReset per cell and dispatch (several pieces closing together merge into one) and rebuilds from ForEachEntryInCell. |
Channel options: bCellEvents sends CellArrived (with bCellComplete once every piece of the cell is open) and CellReset; bHoldUntilCellComplete holds the first batch of a cell until every piece is open (or 3 s) and sends it in one call; bOwnPieces gives the channel its own actors per cell (high churn channels keep the other channels’ items out of their delta); bForceNetUpdateOnWrite builds at once and forces a net update on every write.
Moves without flicker
An entry whose location changes cell moves: in the old cell its item becomes a small tombstone (the destination cell) for the move grace (MoveGraceSeconds, at least three net updates), the new cell gets the item. A client keeps the entry until the new cell claims it, whatever packet comes first, and an entry whose tombstone expired waits while its destination is still coming. An entry that moves back while its tombstone is still there revives it. A move inside a cell is a plain write.
Big cells
A piece splits when its live bytes pass MaxPieceBytes - TombstoneReserveBytes (48 KB - 12 KB) or its live entries pass MaxPieceItems (1024). The split goes by the bits of the key hash (Pulse::NetCells::HashKey): the sibling takes the keys whose next bit is 1, so a client knows from a piece’s prefix and depth which keys it holds. The depth is found in one pass, so a few big entries on one side split once. Each build also keeps the bytes of one update within MaxPieceBytes; the rest goes with the next build. Live bytes and tombstones of a piece together stay within MaxPieceBytes too (what a client gets when the piece becomes relevant): an entry that would join or grow past that waits until tombstones expire, and an entry that leaves a full piece is removed there instead of leaving a tombstone (clients see it go and come again from its new cell). At MaxSplitDepth (6, 64 pieces) new entries of a full piece, and entries that would grow it past the split trigger, are refused (Refused, an error once per cell; a grown entry keeps its old bytes). Entries a split could not move at once (budget) wait in the piece and go to the piece of their hash with the next builds. Every piece of a cell stands at the same place with the same cull distance, so splits never change what a client sees.
Limits
- Entry size: at most the channel’s
MaxEntryBytes(2048 by default),net.MaxRepArraySize, the largest value whose item fits into the layer budget less the tombstone reserve (GetMaxValueBytes), and 65535.RegisterChannelandSetWorldLayerrefuse a channel cap above what its layer allows. - Wire size: budgets, splits and the stats count wire bytes (
GetItemWireBytes): the item overhead (ItemOverhead, 40) plus every value byte with its packed element handle, because the rep layout sends a byte array element by element. A value byte costs two bytes up to the 127th and three bytes after it: a 400 byte value takes about 1.1 KB on the wire, a 2048 byte value about 6 KB. Keep values small; a piece holds about 33 entries of 400 bytes before it splits. -
net.MaxRepArraySize (2048 by default) limits every replicated array on the receiving side too. A project with bigger entries raises it in
DefaultEngine.ini, read by server and clients:[SystemSettings] net.MaxRepArraySize=16384A client whose limit is lower than the server’s warns once; a bigger array would close the connection.
- Values of tagged channels may not hold hard object or class references or replicated instanced structs (
RegisterChannelrefuses them): use soft paths or ids. Values that are not finite are refused on write and read as Corrupt. - Clients drop items with unknown flags, unknown channels or bytes over the cap, and actors of a server with another channel table (another build) with a warning once.
Settings
Project Settings > Pulse > Foundation > Net Cells (UPulseNetCellSettings, DefaultGame.ini, getter Pulse::NetCells::GetSettings()).
| Setting | Default | Description |
|---|---|---|
bEnabled | true | Off: writes return false, no cell actors. |
Layers | Near, Region, Global | The layers (FPulseNetCellLayer); add your own. |
MaxSplitDepth | 6 | Most splits of a cell (2^depth pieces, at most 8; a higher ini value counts as 8). |
VanishedCellSeconds | 3 | A client near a kept cell this long without it coming counts the cell as removed (at least three net updates of the layer plus one upkeep). |
SureRelevanceShare | 0.8 | Part of the radius a client must be within for that. |
MaintainInterval | 1 s | Upkeep: empty cells, tombstones, dormancy, presence, vanished cells. |
Layers is a list of structs (Near, Region and Global by default), so the reference block above has no line for it; edit the layers in the Project Settings.
Per layer (FPulseNetCellLayer): Tag, Kind, CellSize, RelevanceRadius, NetUpdateFrequency, EmptyCellSeconds, Presence, bDormant, DormantAfterSeconds, MaxPieceBytes (49152), TombstoneReserveBytes (12288), MaxPieceItems (1024), MoveGraceSeconds (2), PresenceHoldSeconds (10), ActorClass.
Iris and Replication Graph
- The cell actors (
APulseNetCellActor,APulseNetCellRegionActorfor Region) derive fromAActor, notAInfo, and are listed inConfig/Engine.iniwith the Iris filterSpatial. Iris measures in 3D from the actor location, so a cell actor stands in the middle of the heights of its cell’s entries and adds half their span to its cull distance; classic relevance (IsNetRelevantFor) measures in the plane. UE 5.8’s grid filter has no upper cull distance (an object covers every grid cell within it), so Region uses the same filter; a project may map either class to a filter of its own. - The global actor (
APulseNetCellGlobalActor) and the state actor with the reset epochs (APulseNetCellStateActor) are always relevant and have no filter line. - Replication Graph setups route the classes themselves:
APulseNetCellActorandAPulseNetCellRegionActortoSpatialize_Dynamic(orStaticwith a manual move when the heights change),APulseNetCellGlobalActorandAPulseNetCellStateActortoRelevantAllConnections. They are noAInfo, so rules that send everyAInfoto all connections do not catch them. - Clients open a cell actor after every packet of the frame is applied (
OnPostTickDispatch), from its whole item array, so the result does not depend on the order ofPostNetInitand the fast array callbacks.
Spec test mode
Specs need no net driver:
SetReplicationForced(true)lets a world without network write;PumpLoopback(Seconds)moves the clock of Net Cells, builds, runs the upkeep and delivers.AddLoopbackClient(View)adds a client mirror inside the same world (handlers withSetLoopbackHandler, reads withGetLoopbackEntryState,FindLoopbackEntryBytes,GetLoopbackStats);AddLoopbackReceiver(ClientCells, View)delivers into the Net Cells of a second test world, whose handlers then run as on a client.SetLoopbackViewmoves a client,ClearLoopbackends it.- Delivery uses the same client code as the real actor path (relevance by the cull distance in the plane, dormant actors stay as they were).
Specs: PulseFoundation.NetCells (keys, codec, channels, layers), PulseFoundation.NetCells.Server (writes, split, presence, dormancy, reset layer), PulseFoundation.NetCells.Client (mirror, loopback, reset layer, actor) and PulseFoundation.Debugger.NetCells (the data of the debugger page from a server and a client world).
Debugging
- Pulse Debugger page Net Cells (id
PulseFoundation.NetCells, consolePulse.Debugger NetCells): one column per selected world, so the server and its clients stand side by side. Tiles Cells, Actors, Entries, Bytes, Waiting (on the server: written, not built yet) and Problems (refused entries on the server, unreadable ones on a client; yellow above 0, also the badge of the page); a table per layer (cells, actors, largest piece of its budget, deepest split, tombstones, dormant actors), a table per channel (layer, loss behaviour, entries, bytes, largest entry, waiting or pending, kept, moving, refused, unreadable; writes and builds on the server, added / changed / removed / lost / handoffs on a client) and the first 50 entries a client waits with (channel, key, cell, seconds). The data comes fromPulse::Editor::NetCellsPage::BuildPageData(pure, used by the spec). - Snapshot category
Net Cells(Live page, gameplay debugger, MCP): cells, entries, bytes, actors, waiting and a warning while entries are refused or unreadable; sections per layer and channel. - Timeline (source Foundation, category NetCells): cell actors spawned and destroyed, splits, refused entries, layers tuned.
- Cheats (Console):
PulseNetCellsInfo [Channel]prints the mirror of a client and then the layers and channels of the server; with a channel (Props, or the whole tag) only that one, on a client with its first 10 waiting entries. In debug buildsPulseNetCellsFill Count Bytes [Spacing]writes raw entries on the debug channelPulse.NetCells.Channel.Debug(layer Near, Delete; registered by PulseFoundation only withPULSE_WITH_DEBUG) around the player to test splits and the 64 KB limit over a real net driver (Count 1 to 4096, Bytes up to the cap of the channel, Spacing 0 puts everything into the player’s cell),PulseNetCellsClearremoves them,PulseNetCellsLayer Layer Field ValuechangesRelevanceRadius,NetUpdateFrequencyorEmptyCellSecondsof a layer while the world runs (TuneWorldLayer) andPulseNetCellsReset Layerempties a layer on the server (ResetLayer). GetStats()(Blueprint: Get Net Cell Stats) gives the layers (cells, actors, tombstones, dormant actors, bytes, largest piece, budget, deepest split, reset epoch) and the channels (cells, entries, bytes, largest entry, pending, waiting, kept, moving, refused, decode failures, writes, builds, added, changed, removed, lost, handoffs) of a machine.UPulseNetCellLibraryhas Get Net Cell Channel Stats and Get Net Cell Entry State with names and key text for scripts.
API
| Type / function | Purpose |
|---|---|
Pulse::NetCells::RegisterChannel, UnregisterChannel, FindChannel, GetChannels, FChannel | The channels |
GetChannelTable, GetChannelIndex, GetChannelTableHash, GetChannelDisplayName | The channel table (sorted by name) items refer to |
GetEffectiveCap, GetMaxRepArraySize, ItemOverhead, GetItemWireBytes, GetMaxValueBytes | Size limits |
UPulseNetCellSubsystem | Write<T>, WriteStruct, WriteBytes, MarkDirty, Remove, RemoveAll, FindEntryPlace, SetChannelWriter, SetPresenceQuery, RefreshPresence, SetWorldLayer, TuneWorldLayer, ResetLayer, IsLayerEmpty, GetLayerEpoch, FindLayer; ReadEntry<T>, ReadEntryStruct, FindEntryBytes, GetEntryState, ForEachEntry, ForEachEntryInCell; SetChannelHandler, ClearChannelHandler, RetryEntry, RetryWaiting, MarkDecodeFailed, GetWaitingEntries; GetStats; ShouldReplicate, IsReceiving; spec test mode; snapshot provider (category Net Cells) |
Pulse::Foundation::Tags::NetCells_Channel_Sim | The channel of Pulse Sim (layer Near, Delete, own pieces; registered by PulseFoundation) |
Pulse::Foundation::Tags::NetCells_Channel_Debug | The debug channel of the cheats PulseNetCellsFill / PulseNetCellsClear (only with PULSE_WITH_DEBUG) |
UPulseNetCellCheats | Cheats PulseNetCellsInfo, PulseNetCellsFill, PulseNetCellsClear, PulseNetCellsLayer, PulseNetCellsReset |
SPulseNetCellsPage, Pulse::Editor::NetCellsPage::BuildPageData | The debugger page Net Cells (module PulseFoundationDebugger) and its data |
FPulseNetCellKey, FPulseNetCellPlace, FPulseNetCellEvent, FPulseNetCellLayer | Key, place, client event (Read<T>), layer |
EPulseNetCellLoss, EPulseNetCellLayerKind, EPulseNetCellPresence, EPulseNetCellEventKind, EPulseNetCellApply, EPulseNetCellEntryState | Enums |
FPulseNetCellHandler, FPulseNetCellWriter, FPulseNetCellPresenceQuery | Delegates: client handler, pull writer, presence |
FPulseNetCellStats, FPulseNetCellLayerStats, FPulseNetCellChannelStats, FPulseNetCellWaitingEntry | Stats |
Pulse::NetCells::WriteValue, ReadValue, AreValuesFinite, FByteWriter, FByteReader, HashKey, IsInPiece | Codec helpers |
APulseNetCellActorBase, APulseNetCellActor, APulseNetCellRegionActor, APulseNetCellGlobalActor, FPulseNetCellItem, FPulseNetCellItemArray | The cell actors and their items |
APulseNetCellStateActor, FPulseNetCellLayerEpoch | The always relevant actor with the reset epochs of the layers |
UPulseNetCellSettings, Pulse::NetCells::GetSettings | Settings |
UPulseNetCellLibrary | Get Pulse Net Cells, Get Net Cell Stats, Get Net Cell Channel Stats, Get Net Cell Entry State |