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::FromName gives the key of a name, the same on every machine (CityHash64 of the lowered plain name, the number in B). ToString writes %016llx:%08x, Parse also reads name:<id>.
  • Value: three ways to write.
    • Write<T> / WriteStruct: a USTRUCT with an int32 Version, written tagged without its NotReplicated fields (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) or FPulseNetCellPlace::KeepPlace() (the cell and height the entry has, without moving it). FindEntryPlace says 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 in StartupModule of PulseVisual.
  • Key: A = the set of the instance, B = its id (Pulse::Visual::PropNet::MakeKey).
  • Value: a compact codec (Pulse::Visual::PropNet::Encode / Decode on FByteWriter / 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 (with ExpireTime) in its own map, so it never decodes its own entries.
  • The server writes with WriteBytes at the location of the instance, or with KeepPlace when 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 Waiting while the instance is not there; ApplyKnown calls RetryEntry when 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 in StartupModule of 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 without NotReplicated fields); other kind versions and broken bytes are decode failures (MarkDecodeFailed), a kind that is not loaded yet answers Waiting and reads again when a module loads; each error is warned once.
  • Pull: the server calls MarkDirty for a changed Spatial record at its location and for an Always record with FPulseNetCellPlace::Global() (the Global layer, always relevant and dormant while quiet); its writer (SetChannelWriter) encodes the record when the cell builds, once per net update. Relevancy None and removed records are Removed. 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 what SetPresenceQuery says) 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 for PresenceHoldSeconds. RefreshPresence checks 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 whether SetWorldLayer may 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: call SetWorldLayer with the new values on every client too, once IsLayerEmpty is 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 Delete channels get Removed. Only when the epoch is that late (heavy packet loss) a Delete channel whose cell actor closed first gets Lost for those entries; Keep and ResetCell channels 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. RegisterChannel and SetWorldLayer refuse 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=16384
    

    A 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 (RegisterChannel refuses 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, APulseNetCellRegionActor for Region) derive from AActor, not AInfo, and are listed in Config/Engine.ini with the Iris filter Spatial. 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: APulseNetCellActor and APulseNetCellRegionActor to Spatialize_Dynamic (or Static with a manual move when the heights change), APulseNetCellGlobalActor and APulseNetCellStateActor to RelevantAllConnections. They are no AInfo, so rules that send every AInfo to 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 of PostNetInit and 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 with SetLoopbackHandler, reads with GetLoopbackEntryState, FindLoopbackEntryBytes, GetLoopbackStats); AddLoopbackReceiver(ClientCells, View) delivers into the Net Cells of a second test world, whose handlers then run as on a client. SetLoopbackView moves a client, ClearLoopback ends 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, console Pulse.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 from Pulse::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 builds PulseNetCellsFill Count Bytes [Spacing] writes raw entries on the debug channel Pulse.NetCells.Channel.Debug (layer Near, Delete; registered by PulseFoundation only with PULSE_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), PulseNetCellsClear removes them, PulseNetCellsLayer Layer Field Value changes RelevanceRadius, NetUpdateFrequency or EmptyCellSeconds of a layer while the world runs (TuneWorldLayer) and PulseNetCellsReset Layer empties 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. UPulseNetCellLibrary has 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

PulseFoundation plugin documentation.

This site uses Just the Docs, a documentation theme for Jekyll.