NetworkIdentity

[DisallowMultipleComponent]
public sealed class NetworkIdentity : MonoBehaviour

Marks a GameObject as a networked entity. Holds the entity's network identity (a 64-bit ID created by the worker that spawned it, never by a central allocator), its current container, its authority epoch and which worker/client owns it. Every NetworkBehaviour on the object hangs off this. Add NetworkTransform for ongoing transform replication and NetworkRigidbody for worker-simulated physics. An identity alone only synchronizes placement at spawn and container changes.

Fields

PrefabId

public ushort PrefabId = ushort.MaxValue;

Set automatically from the NebulaConfig prefab list at spawn time.

SceneId

public uint SceneId;

Non-zero for an entity authored into a scene (assigned when the scene is saved). The worker owning its container spawns it; clients and neighbours bind to their own copy of the scene object. Leave 0 on prefabs.

RelevanceRadius

public float RelevanceRadius = 0f;

How far clients hear about this entity, in metres. 0 uses NebulaConfig.InterestRadius. Raise it for something players should see from far away (a dropship, a boss); the gateway clamps it to InterestMaxRadius. A radius above the mesh default costs more to evaluate, so use it sparingly.

AlwaysRelevant

public bool AlwaysRelevant;

Send this entity to every client whatever the distance. For the few objects a game cannot cull: a match timer, a world boss, a weather driver.

InterestGroup

public byte InterestGroup;

A number your interest policy can filter on (team markers, quest objects). Nebula only carries it; 0 means no group.

FarRelevanceRadius

[Min(0f)]
public float FarRelevanceRadius = 0f;

Far relevance tier, in metres (0, the default, is off). Clients whose focus is beyond this entity's normal radius but within this one see it as a marker: its pose at FarUpdateRate and its spawn facts, nothing else (no variables, no RPCs), through NebulaClient.FarEntities. Not clamped by InterestMaxRadius; each client holds at most InterestFarMaxEntities, nearest first. For what players must see from far away: ships in orbit, outposts. See docs/interest-management.md section 16.

FarUpdateRate

[Min(0f)]
public float FarUpdateRate = 1f;

Far-tier pose updates per second (default 1). Only used when FarRelevanceRadius is set; clamped to 0.1..30.

MaxUpdateInterval

public const int MaxUpdateInterval = 255;

The longest UpdateInterval: 255 ticks, a little over four seconds.

CostWeight

public float CostWeight = 1f;

What this entity costs to simulate, as a multiplier on its category weight in NebulaConfig.CostWeights. 1 (the default) leaves balancing exactly as it was; 8 on a raid boss and 0.25 on an ambient critter tell the planner and the scaler that they are not the same machine. NebulaCost.EntityWeight can override it at spawn; NetworkIdentity.SetCostWeight overrides both.

ColliderExtentRefreshTicks

public const int ColliderExtentRefreshTicks = 60;

With EntityExtentSource.Colliders, the box is computed again at least this often, in ticks of the worker that holds authority. Nothing tells Nebula that a collider deeper than a direct child changed; call RefreshExtent when a change must count sooner.

SyncKeyframeInterval

public const uint SyncKeyframeInterval = 30;

Every this many ticks a dirty sync behavior writes a keyframe instead of a delta, and an unreliable one writes a keyframe whether it is dirty or not. Keyframes heal lost packets and are what the gateway hands to late joiners.

SyncSettleTicks

public const uint SyncSettleTicks = SyncKeyframeInterval;

Ticks a distance-rated sync behavior (NetworkBehaviour.SyncDistanceRating) must go without a change before it sends the reliable keyframe every client that holds the entity is given, near or far.

Properties

EffectiveFarUpdateRate

public float EffectiveFarUpdateRate { get; }

FarUpdateRate clamped to FarRelevance.MinRate..FarRelevance.MaxRate.

UpdateInterval

public int UpdateInterval { get; set; }

Ticks between two updates of this entity on the worker that has authority over it: 1 (the default) is every tick. On the other ticks Nebula leaves the entity alone: its behaviours' NetworkBehaviour.NetworkTick is not called, its container, handover and ghost band are not checked, and no transform entry is sent for it. On its update ticks NetworkTick gets the time since the previous one as its deltaTime. Entities with the same interval are spread over the ticks of the interval by net id, so a crowd does not update all at once.

Variables, maps, RPCs and sync-channel behaviours are still sent when they change, and a teleport or a change of container is sent at once. Set it on the authority, at spawn or at any time after; it travels with a handover. Clamped to 1..MaxUpdateInterval. See docs/server-owned-entities.md D1.

RelevancePriority

public RelevancePriority RelevancePriority { get; set; }

How much this entity's transform updates matter to the clients that hold it, relative to its distance from each of them (Nebula.RelevancePriority). The gateway uses it to pick each client's update rate; it never changes who holds the entity. It travels with the entity's spawn, so a change on the authority re-announces the entity to the gateways that have it: change it when the entity's role changes, not every tick.

IsDormant

public bool IsDormant { get; }

True on the worker that has authority while the entity is dormant: asleep. A dormant entity keeps its authority, its state and its replicas, but the worker does not tick it (no NetworkBehaviour.NetworkTick), does not check its container or ghost band, and sends no transform updates for it. It is still handed to another worker when the lease of its container moves there, and stays dormant. False on ghosts and clients.

WakesOnInterest

public bool WakesOnInterest { get; }

Whether this dormant entity wakes by itself as soon as a gateway watches it (see Sleep).

SleepWhenUnobserved

public float SleepWhenUnobserved { get; set; }

Seconds without any gateway watching this entity (no client near enough for a gateway to subscribe its region) after which the worker puts it to sleep, waking on interest. 0 (the default) never does. Server-owned entities only; set it on the prefab or on the authority. It travels with a handover.

EffectiveCostWeight

public float EffectiveCostWeight { get; } = 1f;

The multiplier this entity actually carries right now (see NebulaCost for how it is chosen). It is computed at spawn, travels with the entity through ghosting and handover, and only changes when the game calls SetCostWeight: never per tick. Multiply it by the entity's category weight in CostWeights to get what the mesh thinks it costs.

ExtentSource

public EntityExtentSource ExtentSource { get; }

Where this entity's extent comes from (docs/entity-extents.md). With EntityExtentSource.None, the default, the ghost band measures from the entity's root position, as it always has. With an extent it measures from the extent's box, so the entity is ghosted to every worker whose container the box comes within NebulaConfig.GhostBandMargin of. An extent never changes which worker has authority: that still follows the root position.

ExtentChangedAtRuntime

public bool ExtentChangedAtRuntime { get; }

The extent was set at runtime (SetExtent, UseColliderExtent, ClearExtent, or received with a handover or a restore) rather than authored. Only such an extent is carried by a handover and saved by a PersistentEntity; an authored one comes with the prefab on every process.

Extent

public Bounds Extent { get; }

The extent box in the entity's local space: the authored or set box for EntityExtentSource.Explicit, the box around the colliders for EntityExtentSource.Colliders (computed now if it never was), and an empty box at the origin when there is none. Use TryGetExtent to tell "no extent" apart.

IsSceneEntity

public bool IsSceneEntity { get; }

Authored into a scene rather than spawned from a prefab: the object belongs to its scene and is bound, never instantiated or destroyed, by the network (see SceneEntities).

IsPortalGhost

public bool IsPortalGhost { get; }

A worker holds this ghost only to pose a proxy of it through a portal (docs/portals.md D29): its colliders are off, so it is no body in its scope's physics scene on this worker, and PortalProxys of it stand in the scene of the side the worker holds.

NetId

public ulong NetId { get; }

OwnerClientId

public ulong OwnerClientId { get; }

OwnerIdentity

public string OwnerIdentity { get; } = "";

The owning player's identity across sessions (PlayerIdentity): the same string every time that player connects, on every worker and client. Empty for entities no player owns. Key player records on it (for example a PersistentEntity.Key); OwnerClientId changes every session.

OwnerClaims

public IReadOnlyDictionary<string, string> OwnerClaims { get; } = PlayerClaims.Empty;

Workers only: the claims of the owning player's verified sign-in token that the mesh forwards (NebulaConfig.ForwardedClaims), by claim name, with every value as a string ("true", "42", "alice"). Gate game features on them, for example an admin role: entity.OwnerClaims.TryGetValue("is_admin", out var v) && v == "true".

Empty, never null, for entities no player owns, for anonymous players, for claims the token lacks and on clients, which are never sent claims. Like OwnerIdentity it travels with the entity through ghosting and handover, and it is refreshed when the player reconnects with a newer token. Only claims from a token the gateway verified are ever here, so a client cannot forge them.

OwnerIsBot

public bool OwnerIsBot { get; }

The owning client is a headless bot. Informational (dashboard/overlay); carried through handover.

IsServerDriven

public bool IsServerDriven { get; }

No client owns this entity: whichever worker is authoritative drives it (a PredictedBehaviour<TInput> gets its input from GatherServerInput). What the game calls it (NPC, monster, vehicle) is up to the game; it costs no client process and no gateway connection. Carried through ghosting and handover.

IsOwnerConnected

public bool IsOwnerConnected { get; } = true;

For a player's pawn: whether the player who owns it is connected. False from the moment the player's link drops, or the gateway's link to the worker does, while the worker keeps the pawn for NebulaConfig.SessionReclaimSeconds; true again when the player reconnects within that time. Always true for an entity no client owns. Replicated: the worker that owns the pawn, every worker holding a ghost of it and every client holding it see the same value, and it travels with the pawn in a handover. Use it to mark players who are away; OwnerConnectedChanged says when it changes. The worker's own hooks are NebulaGameMode.OnPlayerDisconnected and NebulaGameMode.OnPlayerReconnected.

Epoch

public uint Epoch { get; }

Monotonic authority epoch; bumped on every authority change. Stale-epoch messages are dropped everywhere.

CohesionGroup

public uint CohesionGroup { get; }

The cohesion group this entity belongs to, or 0 for none: the game's promise that every member is simulated by one worker and moves between workers as a unit (CohesionGroups, docs/cohesion-hints.md). Authored in the inspector or set at runtime with JoinCohesionGroup; it travels with the entity in the spawn, ghost and handover messages, so every worker holding a copy knows it. The ids are the game's own - any non-zero number both sides of an interaction agree on.

Container

public Container Container { get; }

InstanceId

public ulong InstanceId { get; }

The entity's simulation scope. Zero is the public world.

ScopeKey

public string ScopeKey { get; }

The opaque scope key of the entity's simulation scope (Container.ScopeKey of the current container): EntityLocation.PublicScope (empty) in the public world or in no container, the instance key inside an instance. Never null.

Location

public EntityLocation Location { get; }

Where the entity durably is right now (EntityLocation): its scope key, its container's id and its pose in that container's local space (LocalPosition, LocalRotation). The same value on every process that holds the entity, and the value PersistedEntityRecord.Location saves for a persistent entity in a static or runtime container; it does not change on a handover.

PhysicsScene

public PhysicsScene PhysicsScene { get; }

Use this scene for raycasts and overlap tests to exclude entities in other instances.

Space

public Container Space { get; }

The physics frame this entity lives in (Nebula.Container.InnerSpace of its container), or null in its scope's own space. Inside a frame its transform reads frame-local coordinates in simulation space (docs/container-tree.md D11).

ScopePositionPrecise

public Double3 ScopePositionPrecise { get; }

Where the entity stands in its scope's own space, composed in double from its pose in its frame and the frames' poses (PhysicsFrames.ConvertLocal): ToScope of its position without the float rounding of a frame far from the scope's origin. What a translation between two scopes is worked out from (NebulaWorker.TryCommitTransfers).

ContainerIndex

public ushort ContainerIndex { get; }

Wire index of the current container (ContainerRef.DynamicIndex inside a dynamic one, ushort.MaxValue in none). Prefer ContainerRef.

ContainerRef

public ContainerRef ContainerRef { get; }

How the current container is named on the wire (see Nebula.ContainerRef).

Carried

public Container Carried { get; }

The container this entity carries: the Nebula.Container on its root, which registers when the entity spawns on this process and unregisters when it despawns (a ship's interior, a lift). Null when the root has none. Not to be confused with Container, the container this entity is in.

IsSpawned

public bool IsSpawned { get; }

HasAuthority

public bool HasAuthority { get; }

Worker side: this process is authoritative. Client side: always false.

IsLocalPlayer

public bool IsLocalPlayer { get; }

Client side: owned by the local client.

DriverClientId

public ulong DriverClientId { get; }

The client whose input drives this server-owned entity, 0 when nobody does. Set it on the worker with SetDriver. While it is set the entity's PredictedBehaviour<TInput> runs on that client's input instead of GatherServerInput, and the driver's client predicts it the way it predicts its own pawn. Every copy knows it: the worker's, its ghosts' (after a handover), and every client's, so a game can show who is at the wheel.

IsLocallyDriven

public bool IsLocallyDriven { get; }

Client side: this client drives the entity and predicts it (DriverClientId is this client).

OwnerWorkerIndex

public ushort OwnerWorkerIndex { get; }

Index of the worker currently authoritative (as last heard). Debug/overlay only.

Velocity

[Obsolete("Use Motion.Velocity, NetworkTransform.Velocity, or NetworkRigidbody.SetVelocity instead.")]
public Vector3 Velocity { get; set; }

Velocity as reported by the authority; used for extrapolation and carried through handover.

Motion

public NetworkMotionState Motion { get; } = new NetworkMotionState();

RootTransform

public NetworkTransform RootTransform { get; }

UpdateGap

public UpdateGapDelay UpdateGap { get; } = new UpdateGapDelay();

On a client, how far apart this entity's state arrives and the extra render delay that buys it (NebulaConfig.SlowUpdateMaxDelayTicks): an entity sent slower than the render delay is drawn that much further behind, so it interpolates across its own gap. UpdateGapDelay.DelayTicks is 0 for an entity sent every tick or two.

Behaviours

public NetworkBehaviour[] Behaviours { get; } = Array.Empty<NetworkBehaviour>();

Predicted

public PredictedBehaviourBase Predicted { get; }

Interpolator

public RemoteInterpolator Interpolator { get; }

Persistent

public PersistentEntity Persistent { get; }

The PersistentEntity on this entity, or null when it is transient. Cached during initialization; see NebulaPersistence for checkpoint and restore behavior.

History

public StateHistory History { get; }

The recorded ticks of this entity on this process, or null when nothing has been recorded (recording is off, this is a client, or the entity is too young). See StateAt.

OldestAvailableTick

public uint OldestAvailableTick { get; }

The oldest tick StateAt can answer for, or 0 when nothing is recorded.

NewestAvailableTick

public uint NewestAvailableTick { get; }

The newest tick StateAt can answer for, or 0 when nothing is recorded.

HasMaps

public bool HasMaps { get; }

The entity declares at least one NetworkMap<TKey, TValue>.

HasSyncState

public bool HasSyncState { get; }

ReceivingHandover

public bool ReceivingHandover { get; }

Each behavior reads from a reader bounded to its own chunk, so one that reads too much throws (and is logged) instead of eating the next behavior's bytes, and one that reads too little leaves no residue.

SyncAudienceGeneration

public uint SyncAudienceGeneration { get; }

Raised every time the member set of one of this entity's SyncAudience.Custom behaviors changes on its authority. It travels with the entity through ghosting and handover, so it only ever goes up, and it stamps every sync message (EntitySyncMsg.AudienceGeneration) so a gateway can tell a chunk written under member sets it has not received yet (docs/sync-audience.md D6).

HasCustomAudience

public bool HasCustomAudience { get; }

At least one sync behavior has the SyncAudience.Custom audience.

HasRestrictedAudience

public bool HasRestrictedAudience { get; }

At least one sync behavior has an audience other than SyncAudience.Everyone.

SyncContainer

public Container SyncContainer { get; }

The container the sync chunks currently being read were expressed in (world-space NetworkTransform values are container-local on the wire). Valid only inside NetworkBehaviour.ReadSyncState.

LocalPosition

public Vector3 LocalPosition { get; }

Position in the current container's local space (what goes on the wire). An entity parented under its container reads its local transform directly, which is exact even when the container moved this tick.

LocalRotation

public Quaternion LocalRotation { get; }

Events

OwnerConnectedChanged

public event Action<bool> OwnerConnectedChanged;

IsOwnerConnected changed on this copy; the argument is the new value. Raised on the owning worker, on workers holding a ghost, and on clients, each when its copy learns of the change.

ContainerChanged

public event Action<Container, Container> ContainerChanged;

Methods

SetUpdateRate

public void SetUpdateRate(float updatesPerSecond);

Set UpdateInterval from a rate in updates per second: 60 is every tick, 10 every 6th tick, 0.5 every 120th. Rounded to whole ticks and clamped as UpdateInterval is.

Sleep

public void Sleep(bool wakeOnInterest = true);

Put this server-owned entity to sleep from the next tick (IsDormant). On that tick the worker sends one reliable transform entry with its pose and no velocity, so every client holds it where it rests, and calls NetworkBehaviour.OnSleep. With wakeOnInterest it wakes by itself when a gateway starts to watch it; otherwise only Wake wakes it. Call it on the worker that has authority. An entity a client owns cannot sleep: the call is ignored with a warning.

Wake

public void Wake();

Wake this entity from the next tick: it is ticked, checked and sent again, from where it slept, and NetworkBehaviour.OnWake is called. Does nothing to an entity that is not asleep.

SetCostWeight

public void SetCostWeight(float weight);

Say what this entity costs from now on, overruling both CostWeight and NebulaCost.EntityWeight. The value is clamped to [0, NebulaCost.MaxWeight] and travels with the entity: the worker it hands over to reports the same cost for it.

TryGetExtent

public bool TryGetExtent(out Bounds localBounds);

The extent box in the entity's local space, if the entity has one: always for EntityExtentSource.Explicit, and for EntityExtentSource.Colliders when at least one collider counts (enabled, not a trigger, and not under another NetworkIdentity).

SetExtent

public void SetExtent(Bounds localBounds);

Give the entity an explicit extent: a box in its local space (the root's rotation and scale apply to it). Call it on the authority when the entity's shape changes, for example after a structure is edited; the next tick's ghost band uses it. The box travels with a handover and is saved by a PersistentEntity. A negative size is taken as its absolute value.

UseColliderExtent

public void UseColliderExtent();

Measure the entity by its own colliders from now on: every enabled, non-trigger collider on an active object under it whose nearest NetworkIdentity is this one. The box is computed when it is next needed, then again every ColliderExtentRefreshTicks ticks, when a direct child is added or removed, and after RefreshExtent is called.

ClearExtent

public void ClearExtent();

Remove the entity's extent: the ghost band measures from its root position again, as for any entity.

RefreshExtent

public void RefreshExtent();

Compute a EntityExtentSource.Colliders extent again now, after the game added, removed, resized or switched a collider. Does nothing for another source.

TryGetOwnerClaim

public bool TryGetOwnerClaim(string name, out string value);

The owning player's forwarded claim name (OwnerClaims); false when there is none.

JoinCohesionGroup

public void JoinCohesionGroup(uint group);

Put this entity in a cohesion group, leaving the one it was in. The authority's value is the one that counts: it is what a handover expands and what the worker reports to the orchestrator. Ghosts and client replicas learn the new value with the next spawn, ghost spawn or handover of the entity, so join before the interaction that needs the group rather than in the middle of it (docs/cohesion-hints.md, D3).

LeaveCohesionGroup

public void LeaveCohesionGroup();

Leave the cohesion group this entity is in, if any. Nothing else about the entity changes.

ToScope

public Vector3 ToScope(Vector3 position);

A position in this entity's space as a position in its scope's own space (PhysicsFrames.ToScope).

FromScope

public Vector3 FromScope(Vector3 position);

A position in the scope's own space (a part of a ship, a door, a quest giver) in this entity's space.

PlaceInScope

public void PlaceInScope(Vector3 position, Quaternion rotation);

Authority: put the entity at a pose given in its scope's own space (a respawn point, a warp target), leaving any physics frame it is in first. Writing such a pose straight onto the transform of an entity inside a frame would put it at those numbers in the frame's coordinates. When the target is inside a frame (a ship's interior), the entity lands in that frame at the matching frame-local pose. Outside frames this is a plain assignment; the next tick resolves the container as usual.

PlaceInFrame

public void PlaceInFrame(Container frame, Double3 localPosition, Quaternion localRotation);
public void PlaceInFrame(Container frame, Vector3 localPosition, Quaternion localRotation);

Authority: put the entity at a pose given in frame's frame-local coordinates (a pad on a planet whose carrier is a framed container, a seat in a ship's interior), in the deepest container of that frame holding the point: one of the frame's own fixed or carried boxes (a ship's interior in it is entered as ContainerRegistry.Resolve enters it), or the framed container itself. The pose goes from the frame to the container the entity lands in composed in double (PhysicsFrames.ConvertLocal), never through the scope's own space, so it is exact however far the frame's carrier stands from the scope's origin; PlaceInScope rounds a pose there to a float's spacing at that distance (32 m at 300,000 km). What clients receive is the container-local pose this leaves on the entity.

frame must have a physics frame of its own on this process and be in the entity's scope; to move it into another scope, prepare a transfer and commit it with NebulaWorker.TryCommitTransfer. Null is the scope's own space: the same as PlaceInScope. On a client, where frames are drawn rather than simulated, the container is left as it is and only the pose is written.

SetDriver

public bool SetDriver(ulong clientId);

Hand the controls of this server-owned entity to a client (a player sits in a vehicle's driving seat), or take them back with 0. Call it on the worker that has authority. From the next tick the entity's PredictedBehaviour<TInput> simulates that client's input, and the client predicts it and is reconciled to the worker's state, as it is for its own pawn; with 0 it goes back to PredictedBehaviour<TInput>.GatherServerInput. The change is announced to the gateways and travels with a handover. PredictedBehaviourBase.OnDriverChanged is called on the worker and on every client that holds the entity.

Only an entity with a PredictedBehaviour<TInput> that no client owns can be driven; the call is refused with a warning otherwise, and returns false. A driven entity is updated every tick whatever its UpdateInterval, and it cannot sleep: a sleeping one is woken.

ClearDriver

public bool ClearDriver();

Take the controls back from whoever drives this entity: SetDriver with 0.

StateAt

public HistoricalState StateAt(uint tick);

What this entity looked like at server tick tick: its world pose, velocity, container, epoch and the SyncHistoryAttribute variables. Answered on the worker that has authority and on any worker holding a ghost of it; a ghost's newest tick is one behind the owner's (the tick the owner's stream was built on). Outside the recorded window the result's HistoricalState.Available is false and nothing is extrapolated.

TryGetStateAt

public bool TryGetStateAt(uint tick, out HistoricalState state);

As StateAt, in the try-pattern.

TryGetPoseAt

public bool TryGetPoseAt(uint tick, out Vector3 position, out Quaternion rotation);

The pose recorded for tick, or the nearest one within StateHistory.GapToleranceTicks. False (with the entity's current pose) when nothing usable was recorded. A thin wrapper over StateAt.

WriteVars

public void WriteVars(NetworkWriter writer);

ReadVars

public void ReadVars(NetworkReader reader);

WriteMapsFull

public void WriteMapsFull(NetworkWriter writer);

Every map in full, as a NetworkMapCodec section: what rides a spawn. Nothing when the entity has none.

WriteMapsDelta

public int WriteMapsDelta(NetworkWriter writer);

The keys changed since the last send, of every map that has any, as a section. Returns the number of maps written; when zero the writer has been left untouched.

ReadMaps

public void ReadMaps(byte[] section);

Apply a section (full or delta) from the authority. Maps this build does not have are skipped.

WriteHandoverState

public void WriteHandoverState(NetworkWriter writer);

Handover-only state from every behavior (see NetworkBehaviour.WriteHandoverState).

ReadHandoverState

public void ReadHandoverState(NetworkReader reader);

ClearDirty

public void ClearDirty();

WriteSyncSnapshot

public void WriteSyncSnapshot(NetworkWriter writer);
public void WriteSyncSnapshot(NetworkWriter writer, bool forGateway);

A keyframe from every sync behavior: what rides the spawn/handover message.

WriteSyncState

public int WriteSyncState(NetworkWriter writer, uint tick, Delivery delivery);
public int WriteSyncState(NetworkWriter writer, uint tick, Delivery delivery, bool forGateway);

Authority, once per tick per delivery class and per destination: the chunks due this tick. A behavior is written when it is dirty, or (unreliable only) when a keyframe is due. The keyframe decision depends only on the tick and on state that ClearDirty advances, so every destination written in the same tick gets identical chunks: the first tick after gaining authority is a keyframe for all of them. Returns the number of chunks written; when zero the writer has been left untouched.

ReadSyncState

public void ReadSyncState(NetworkReader reader, uint tick, Container container);
public void ReadSyncState(NetworkReader reader, uint tick, Container container, bool reliable);

Non-authoritative copies: hand each chunk to its behavior. Chunks for unknown indices are skipped.

RemoteTick

public void RemoteTick(double renderTick);

Present the tick renderTick on every behavior (ghosts and remote client copies).

SetLocalPose

public void SetLocalPose(Container container, Vector3 localPosition, Quaternion localRotation);

Place the entity at a pose expressed in container's space (world space when null). An entity parented under the container's transform is moved through its local pose, so where it ends up this frame follows wherever the container is this frame, whichever of the two is updated first: this is what keeps passengers glued to a moving ship on every process.

ToString

public override string ToString();