Fusion.Runtime
Page Bit Shift Lookup Table
Additional companion attribute to NetworkedAttribute, which indicates how floats should be compressed.
Constructor new accuracy.
Constructor new accuracy.
Constructor that takes a named constant.
Accuracy for this property will be acquired from the settings.
Allows for a specific slider range on Accuracy types to be displayed. Without this Accuracy values use a default slider range.
Allows for a specific slider range on Accuracy types to be displayed. Without this Accuracy values use a default slider range.
Attribute for use on Fusion.Behaviour classes.
Automatically runs this method when the inspector refreshes. GUILayout calls be in the method and will render into the inspector.
Allows for editor code to be added to a component, without requiring a custom Editor script.
Conditions flags for when this action should run.
Run this action when playing.
Run this action when not playing.
Always run this action, regardless of play mode.
Tells the editor to dirty the class instance after executing a button action.
Specific flags for when this element should be displayed.
Define a BehaviourAction.
The name of the method to execute. If excluded, this will be the method this attribute is on.
The name of the member (in the same class) to evaluate, to determine if the action should be performed.
Typically null, as the action method can have its own logic.
Specific conditions for when the action should occur.
Define a BehaviourAction, with the action being the method this attribute is attached to.
The name of the member (in the same class) to evaluate, to determine if the action should be performed.
Typically null, as the action method can have its own logic.
Specific conditions for when the action should occur.
Attribute for use on Fusion.Behaviour classes.
Automatically creates a button in the inspector of derived classes.
Can be used on Fields or Method member types.
For fields, the name of the method the button will execute must be supplied.
When used on methods, that method will be called.
Define a ButtonBehaviourAction.
The name that will be displayed on the button.
The name of the method to execute. If excluded, this will be the method this attribute is on.
The name of the member (in the same class) to evaluate, to determine if the action should be performed.
Typically null, as the action method can have its own logic.
Define a ButtonBehaviourAction.
The name that will be displayed on the button.
Indicates if this button should appear while playing.
Indicates if this button should appear while not playing.
The name of the method to execute. If excluded, this will be the method this attribute is on.
The name of the member (in the same class) to evaluate, to determine if the action should be performed.
Typically null, as the action method can have its own logic.
Define a ButtonBehaviourAction.
The name that will be displayed on the button.
Indicates if this button should appear while playing.
Indicates if this button should appear while not playing.
The name of the member (in the same class) to evaluate, to determine if the action should be performed.
Typically null, as the action method can have its own logic. This member can be a property, field or method.
The return value of any of these is converted into a double. True = 1, False = 0. Null = 0.
Attribute for use on Fusion.Behaviour classes.
Automatically draws a warning box in the inspector if the conditions are met.
Define a ButtonBehaviourAction.
The text that will be shown in the warning box.
The name of the member (in the same class) to evaluate, to determine if the action should be performed.
Typically null, as the action method can have its own logic. This member can be a property, field or method.
The return value of any of these is converted into a double. True = 1, False = 0. Null = 0.
Casts an enum or int value in the inspector to specific enum type for rendering of its popup list.
Supplying a method name rather than a type allows a property with the type Type to be used to dynamically get the enum type.
Options for hiding a field.
Field will be disabled, but still visible.
Field will be hidden.
Fusion editor attribute for selectively drawing/hiding fields. Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The value to compare the member value against.
How the field should be hidden (disabled or removed)
How the condition member value and compareToValye will be evaluated.
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The value to compare the member value against.
How the field should be hidden (disabled or removed)
How the condition member value and compareToValye will be evaluated.
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The value to compare the member value against.
How the condition member value and compareToValye will be evaluated.
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The value to compare the member value against.
How the condition member value and compareToValye will be evaluated.
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
How the field should be hidden (disabled or removed)
How the condition member value and compareToValye will be evaluated.
Fusion editor attribute for disabling fields.
Constructor.
If using the release version of the fusion.runtime.dll, field will be hidden, rather than just disabled.
Attribute that indicates an enum should render as multi-select mask drop list in the inspector
Defines the target authority mask for OnChanged callbacks
Receive callback if you have state authority over the object
Receive callback if you have input authority over the object
Receive callback if you have neither input or state authority over the object
Shorthand for StateAuthority|InputAuthority|Proxies
Flags a property of for network state synchronization.
The property should have empty get and set defines, which will automatically be replaced with networking code via IL Weaving.
OnChanged can be assigned with the name of a method in the same NetworkBehaviour.
The named method will get called whenever this property value has been changed by the State Authority.
| [Networked(OnChanged = nameof(MyCallbackMethod)]
| public int MyProperty { get; set; }
|
| protected static void MyCallbackMethod(Changed<ChangedCallbackParent> changed) {
| changed.LoadNew();
| var newval = changed.Behaviour.MyProperty;
| changed.LoadOld();
| var oldval = changed.Behaviour.MyProperty;
| Debug.Log($"Changed from {oldval} to {newval}");
| }
Inside of INetworkStruct, do not use AutoProperties (get; set;), as these will introduce managed types into the struct, which are not allowed. Instead use '=> default'.
| [Networked]
| public string StringProp { get => default; set { } }
Signature for the callback is:
static void OnChanged(Changed<MyClass> changed){}
Which targets should receive the OnChanged callback.
Name of the field that holds the default value for this networked property.
Interest group for this property
Default constructor for NetworkedAttribute
Group constructor
The interest group this property belongs to
If set, this changes expected Wrap method signature to int Name(NetworkRunner, T, byte*) and Unwrap to int Name(NetworkRunner, byte*, ref T).
In both cases, the result is the number of bytes written/read and can not be greater than what's declared here.
Describes the total number of WORDs a uses.
Enables a special inspector drawer for Unity Rect type, specially designed for editing RectTransforms using normalized values.
Constructor for . InvertY inverts Y handling, for RectTransforms which treat lowerRight as origin, rather than upper left.
Expressed as Width/Height, this defines the ratio of the box shown in the inspector. Value of 0 indicates game window resolution will be used.
Attribute used to mark a field that needs to change based on an exponent
via a UI slider
Determines if a slider power of 0 results in an actual value of one, or zero.
Color of the inspector header for this component type. None indicates no header graphic should be used.
Icon used for the inspector header for this component type. None indicates no header graphic should be used.
Unit Type for a certain field.
This helps to identify the unit that a certain value represents, like Seconds or Percentage
Unit Attribute class.
Used to mark a field with the respective
The rounding used by the value slider.
The rounding used by the inverse slider (if is enabled).
Specify the field type, without Min and Max values
Unit type
Specify the field type, and its Min and Max values.
Unit type
Min value for this field
Max value for this field
If values outside of the min/max range will get clamped, or be allowed.
Specify the field type, and its Min and Max values.
Unit type
Min value for this field
Max value for this field
If values outside of the min/max range will get clamped, or be allowed.
Comparison method for evaluating condition member value against compareToValues.
True if condition member value equals compareToValue.
True if condition member value is not equal to compareToValue.
True if condition member value is less than compareToValue.
True if condition member value is less than or equal to compareToValue.
True if condition member value is greater than or equal to compareToValue.
True if condition member value is greater than compareToValue.
Fusion editor attribute for selective editor rendering. Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
Base Constructor.
Base Constructor.
Base Constructor.
Fusion editor attribute for selective editor rendering of warnings/info boxes in the inspector.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The value to compare the member value against.
The text of the info box.
The icon of the message box. Use (int)UnityEditor.MessageType
How the condition member value and compareToValye will be evaluated.
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The value to compare the member value against.
The text of the info box.
The icon of the message box. Use (int)UnityEditor.MessageType
How the condition member value and compareToValye will be evaluated.
Constructor.
Condition member can be a property, field or method (with a return value).
Value of condition method is converted to a long. Null = 0, False = 0, True = 1, Unity Object = InstanceId
The text of the info box.
The icon of the message box. Use (int)UnityEditor.MessageType
How the condition member value and compareToValye will be evaluated.
Wrapper around the Fusion LBC Implementation
It will control and manage the communication between Fusion and the Photon Cloud
Fusion LBC Client Reference
ID of this Communicator. This reflects the Actor Number of the Peer inside the Room
Flag to signal if this Communicator was extracted and will be reused
Responsible to deal with LoadBalancingClient Events
Responsible for dealing and managing the API used to communicate with the Photon Cloud.
This also includes:
- Send/Reply to Protocol Messages
- Query for Reflexive Information
- Perform NAT Punchthrough
- Manage the Realtime client
- Respond to/deal with Photon Cloud events
Signal if the local peer is connected to the Photon Cloud and can perform extra actions, like creating/joining a Room.
Photon Client UserID
Signal if the local peer is already inside a Room
Signal if the local peer is also the Master Client of the Current Room
Get the internal used by the Client to perform the authentication
Reference to the current active communicator
Signal if the local peer will try or accept connections using NAT Punch
Custom STUN Server
Exposes the current NAT Type from the local Peer
Builds a new CloudService reference
Reference to the current active Runner
Opitional external Communicator
Extract the internal Communicator for later re-use
Current used by this instance with all resetted settings
Update and perform all pending actions related to the Photon Cloud communication
Connect the local peer to Photon Cloud using an async process.
Custom Authentication Values used to Auth the local peer
Custom Photon App Settings
Async Task of the connect to Photon Cloud process. Can be used to wait for the process to be finished
Join the Peer to a specific Lobby, either a prebuild or a custom one
Lobby Type to Join
Lobby ID
True if the operation could be completed.
Make the local Peer Create/Join a Room based on Start Game Arguments
--------------------->Yes--->CreateOrJoin
SharedMode--->| Valid Room Name |
--------------------->No---->[RandomRoomName]-->JoinRandomOrCreate
--------------------->Yes--->CreateOrJoin
ClientMode--->| Valid Room Name |
--------------------->No---->[RandomRoomName]-->JoinRandom
ServerMode-- --------------------->Yes----------------------------|
|->| Valid Room Name | v
HostMode---- --------------------->No---->[RandomRoomName]-->CreateOrJoin
Start Game Args ref
Task of the Join Room process
Disconnect the Local Peer from the Photon Cloud.
Async Task of the disconnect from Photon Cloud process. Can be used to wait for the process to be finished
Get the UserID of another Player Actor in the Room
ActorID of a Player inside the Room
Player UserID
Callback fire on every connection attempt with a remote Server.
It is used while trying to hole-punch the remote server and enables the manager to swap the target endpoint in between attempts.
This is necessary to maintain a flow of attempts even if we exchange the local/public/relay endpoints
Current attempt number
Max number of attempts
Flag if target EndPoint should change
New target EndPoint
Start the connection process with a Remote Server
Starting NAT Punch state, see for more info
Remote Server EndPoint to connect to
Disposes the current
Update the data based on the current LBC Information after the peer enters a Room
Callback invoked when any Room Property has changed
Callback invoked when the Room list is updated with data from the Cloud
New List of
Send a Protocol Message to Fusion Plugin
Send a Protocol Message to the Fusion Plugin
Reference to the Project Config to be sent
Send a Protocol Message to the Fusion Plugin
Reference to StunResult used to build the Protocol Message
Build and send the latest Server Snapshot to the Fusion Plugin
Handles a Confirmation Protocol Message sent by the Fusion Plugin
Sender Actor Number
Join Protocol Message
Handles a Protocol Message sent by the Fusion Plugin
Sender Actor Number
Start Protocol Message
Handles a Protocol Message sent by the Fusion Plugin
Sender Actor Number
Disconnect Protocol Message
Handles a Protocol Message sent by the Fusion Plugin
Sender Actor Number
NetworkConfigSync Protocol Message
Handles a Protocol Message sent by the Fusion Plugin
Sender Actor Number
ReflexiveInfo Protocol Message
Check for scheduled requests
Confirms or waits for confirmation from the Plugin of the Join Message
True if the Join Confirmation was received, false otherwise
Run the STUN Service to retrieve the current Reflexive Addresses of the local peer
Running Task of the STUN Query Procedure
Update the internal used to start the Fusion Runner
New arguments
Reverse ping will send Empty UDP Packets to the RemoteAddr in order to setup the Routing Table
on the current NAT of the Server, forcing it to allow packages from the remote client to be received
Remove EndPoint to ping
CancellationToken
Send a "ping" to an EndPoint
EndPoint to send the ping
True if the Ping was sent, false otherwise
Try to send Server Snapshot to Plugin
Check if Remote Private EndPoint appears to be in the same Subnet
True if in same Subnet
Initilize the Log system from the Realtime SDK to use the Fusion Log System
Converts a to a
ref
ref
Holds information about the local peer used to Join/Start/Connect to a remote Peer
using the Photon Cloud as backend
Timeout between sending a Request and receive a Join Confirmation
Client Server Lobby
Shared Lobby
Reference to the initialization arguments set by the user.
They are used to start the Fusion Runner
Connection Stage related to the current EndPoint Type used by the client to connect a remote server
Describes the current state of the Join process
Describe the current protocol version we are using to communicate with the Plugin
Remote Server Reflexive Info. Stores private and public EndPoint of the remote server.
Local Reflexive Info. Stores private and public EndPoint of the local peer.
Stores requests sent by the plugin
Last Disconnect Msg Received from the Plugin
Define a list of Requests that may be asked by the Plugin Server
No Request
Request for the Local Reflexive Info
Describes the current Target Address Type used in the NAT Punch procedure
No connection procedure is running
Trying to Connect to LAN EndPoint
Trying to Connect to WAN EndPoint
Trying to Connect to Relay EndPoint
Stage of the Join Process.
When starting the peer, the first thing we need to make sure is to have Joined the Room
with a confirmation from the Plugin, this will signal the current stage of this
Join Request not sent yet
Join Request Sent, waiting for confirmation
Join Confirmation Received, all good
Failed to receive Join Confirmation after a timeout ()
Stores the data of a "Request to Ping" used by the Server in Client-Server Mode
to send arbitrary "pings" to a connecting Client.
This allows the local NAT Table to be updated with the right mapping information
from the remote client, increasing the chance of the local Server to receive any
connect request from the remote peer.
Delay between pings
Total number of pings to send
Countdown for the next ping
Remote Client Reflexive Info, used to getter the Public EndPoint to send the ping
Extension methods to
Interface for callback.
Called after the resimulation loop (when applicable), and also after the forward simulation loop.
Implement this interface on and classes.
Called after the resimulation loop (when applicable), and also after the forward simulation loop.
Only called on Updates where resimulation or forward ticks are processed.
True if this is being called during the resimulation loop. False if during the forward simulation loop.
How many resimulation or forward ticks are going to be processed.
Callback interface for .
Called at the very start of the resimulation loop (on clients with prediction enabled),
immediately after state is set to the latest server snapshot.
Implement this interface on and classes.
Called at the very start of the resimulation loop (on clients with prediction enabled),
immediately after state is set to the latest server snapshot.
Interface for callback. Called immediately after Physics.Simulate().
Implement this interface on and classes.
Called immediately after Physics.Simulate().
Interface for callback.
Called after each tick simulation completes.
Implement this interface on and classes.
Called after each tick simulation completes.
Interface for the callback, which is called at the end of each Fusion Update segment.
Implement this interface on and classes.
Called at the end of the Fusion Update loop, before all Unity MonoBehaviour.Update() callbacks.
Interface for callback.
Called before the resimulation loop (when applicable), and also before the forward simulation loop.
Implement this interface on and classes.
Called before the resimulation loop (when applicable), and also before the forward simulation loop.
Only called on Updates where resimulation or forward ticks are processed.
True if this is being called during the resimulation loop. False if during the forward simulation loop.
How many resimulation or forward ticks are going to be processed.
Callback interface for .
Called at the very start of the resimulation loop (on clients with prediction enabled),
before state is set to the latest server snapshot.
Implement this interface on and classes.
Called at the very start of the resimulation loop (on clients with prediction enabled),
before state is set to the latest server snapshot.
Interface for callback. Called immediately before Physics.Simulate().
Implement this interface on and classes.
Called immediately before Physics.Simulate().
Interface for callback.
Called before each tick is simulated.
Implement this interface on and classes.
Called before each tick is simulated.
Interface for the callback, which is called at the beginning of each Fusion Update segment.
Implement this interface on and classes.
Called at the start of the Fusion Update loop, before the Fusion simulation loop.
Interface for predicted spawn callbacks.
Implement this interface on and classes.
Called in place of Spawned(), when the predicted object is initially created locally on the client.
Called every tick in place of FixedUpdateNetwork(), until or occur.
Called every tick in place of Render(), until or occur.
Called when Server does not produce the spawn that has been predicted.
The spawn did not actually happen, and this callback may be used to clean up after the missed prediction.
Called when Server spawn was has been confirmed, and the predicted spawn object has been added to the simulation.
Interface for callback.
Called when the joins AreaOfInterest.
Implement this interface on and classes.
Only applicable to .
Called when the joins AreaOfInterest.
Object is now receiving snapshot updates.
Object will execute FixedUpdateNetwork() and Render() methods until the object leaves simulation.
Interface for the callback.
Called when the leaves AreaOfInterest.
Implement this interface on and classes.
Only applicable to .
Called when the leaves AreaOfInterest.
Object is no longer receiving snapshot updates.
Object will stop executing FixedUpdateNetwork() and Render() methods until the object rejoins simulation.
Float compression value, used when writing to the fusion allocator.
Float decompression value, used when reading from the fusion allocator.
Indicates the rounding factor of compressed values.
All values will be truncated to the nearest multiple of this.
For example; A value of 0.012345f compressed with an Accuracy of 0.001, becomes 0.012f
An Accuracy setting of 0 is uncompressed.
The accuracy value that is used as a rounding factor for Fusion's compression. All values will be truncated to the nearest multiple of this.
The inverse of the Accuracy value, used in decompression.
Sets the Accuracy value.Inverse is determined and set as well.
Sets the accuracy to a global accuracy, which are defined in Fusion's .
The name of the Accuracy Default (can be found in 's settings.
Gets the value used for float compression.
Reference to the project Config file, which is needed to look up the global values.
Typically this is Runner.Config is used for this value.
Gets the value used for float decompression.
Reference to the project file, which is needed to look up the global values.
Accuracy constructor. The provided float value is used to determine the rounding.
For example, an accuracy of .01f would result in the value .02345 being rounded to .02f.
Accuracy constructor that binds this accuracy to a named setting.
This can be a built-in constant, like AccuracyDefaults.POSITION -
or your own custom name (provided you have defined it in .
The string name of the tag. Can be an constant, or your own defined default.
The value that will be used if the AccuracyDefaults toggle is deselected in the inspector.
Implicit operator to convert floats into accuracy.
Summary text for this accuracy.
Base class for network behaviours which provide a position offset for area of interest.
A is required on this GameObject or a parent of this GameObject.
The int* offset for the Ptr, for the memory location of the position data.
Base class for Fusion network components, which are associated with a .
Derived from , components derived from this class are associated with a and .
Components derived from this class are associated with a parent .
and can use the on properties to automate state synchronization,
and can use the on methods, to automate messaging.
Options for which time frame this object will render in.
Selects the most likely suitable time frame.
Renders the object in the remote time frame, using the most recently consumed remote state tick.
Render the object in the local players time frame, interpolating between the most recent tick simulation result and the previous.
Interpolation will not be calculated nor applied.
Pointer to the allocated memory associated with this Object.
The index of this , in the array.
Indicates whether the state authority snapshot tick data, or prediction tick data (if available in the current mode for the current peer) should be used for interpolation.
Gives access to the offset (in 32 bit words) and count (in 32 bit words) of this behaviour backing data
Get/Set the time frame this object is rendered in.
The unique identifier for this network behaviour.
Override this value for custom memory allocations.
This is for advanced use cases only, and cannot be used if is used in the derived class.
Copies entire state of passed in source
Source to copy data from
Override this property to change whether initial non-zero values assigned
to [Networked] properties invoke OnChanged callbacks. For clients
the initial value comes from the simulation snapshot, not from what has
been set locally in the inspector.
Returns "true" by default.
Post spawn callback.
Called before the network object is despawned
If the state of the behaviour is still accessible
Get 'To' and 'From' states, and the Alpha (t) values needed for lerping.
The returned values.
Force interpolation to the current s time frame
True valid state data was returned.
Get 'To' and 'From' states, and the Alpha (t) values needed for interpolation.
The returned values.
If the interpolation data is in the predicted time frame (true) or between snapshots (false),
according to the .
True valid state data was returned.
If the behaviour data should be interpolated between latest predicted states or between snapshots.
Clear all dynamic OnChange callbacks from this behaviour
Removes a specific OnChange callback from this behaviour
The reference returned by OnChangeAdd
Removal succeeded
Adds a OnChange callback to this behaviour which is bound to a specific word offset and word count
Word offset to monitor for changes
How many words to monitor for changes, from offset and up
Callback to invoke
Type of the behaviour
Reference struct that can be used to remove this callback later
Adds a OnChange callback to this behaviour which is bound to a specific weaved property
Name of the property to monitor for changes
Callback to invoke
Type of the behaviour
Reference struct that can be used to remove this callback later
Returns true if it a valid can be found for the current simulation tick (Typically this is used in ).
The returned input struct originates from the ,
and if valid contains the inputs supplied by that for the current simulation tick.
RawInterpolator provides a set of methods to get the "from" and "to" ticks of the associated [Networked] property,
as well as the current interpolation value for the two.
All methods return raw memory pointers and expects the caller to be able to convert the data to the proper types.
Interpolator provides a set of methods to get the "from" and "to" ticks of the associated [Networked] property,
as well as the current interpolation value for the two, but it also provides a Value property as a shortcut to
get the actual interpolated value for those parameters.
Get the current interpolation value for this Interpolator. This method will silently ignore missing interpolation data and just return the default value for `T`
Get the current interpolation value for this Interpolator. Similar to the `Value` property, but will return null if interpolation data is not available.
Try and get 'To' and 'From' states, and the Alpha (t) values needed for interpolation.
Value on the state the interpolation is going from.
Value on the state the interpolation is going to.
Interpolant factor between the two states.
Force interpolation to the current s time frame (as opposed to between snapshots).
If no value is forced, interpolation data will be retrieved according to the .
True if the interpolation data is available, false otherwise.
Get 'To' and 'From' states, and the Alpha (t) values needed for interpolation.
Force interpolation to the current s time frame (as opposed to between snapshots).
If no value is forced, interpolation data will be retrieved according to the .
A tuple containing the values. Null if interpolation data is not available.
Get a raw interpolator for a networked property.
The returned `RawInterpolator` provides a way to calculate the "between-ticks" value of the named [Networked] property.
Name of the [Networked] property
`RawInterpolator` for the networked property
Get an interpolator for a networked property.
The returned `Interpolator` provides a way to calculate the "between-ticks" value of the named [Networked] property with the specified type `T`.
The value is a linear interpolation between the "from" and the "to" ticks and is available via the `Value` property on the `Interpolator`.
Name of the [Networked] property
Type of the [Networked] property
`Interpolator` for the networked property
This is a special method that is meant to be used only for [Networked] properties inline initialization.
This is a special method that is meant to be used only for [Networked] properties inline initialization.
Converts NetworkBehaviour to NetworkBehaviourId
This method needs to be invoked in user overrides of:
Reference to an OnChange callback added to a NetworkBehaviour
If this callback reference is valid or not
A component for synchronizing the Animator controller state from the State Authority to network proxies.
Requires a Unity Animator component, and a component.
NOTE: Animator Root Motion is not compatible with re-simulation and prediction.
The Animator being synced.
Flags controlling which Mecanim data will be synced.
Accuracy used for parameter float values.
Accuracy used for animator state normalized time values.
Accuracy used for layer weight values.
Queues a trigger with this animator. Call this instead of Animator.SetTrigger for the State Authority.
Triggers are prone to getting lost by animation syncs, as they may get reset before the value is synced. Setting triggers with this method ensures they get captured.
Queues a trigger with this animator. Call this instead of Animator.SetTrigger for the State Authority.
Triggers are prone to getting lost by animation syncs, as they may get reset before the value is synced. Setting triggers with this method ensures they get captured.
Fusion component for handling Physics2D.SyncTransforms() and Physics2D.Simulate().
Only used when == true.
Fusion component for handling Physics.SyncTransforms() and Physics.Simulate().
Only used when == true.
Replicates a Unity Transform's position and rotation states from the to all other peers.
Add this component to a GameObject to sync the position and rotation.
A is required on this GameObject or a parent of this GameObject.
This component does not interpolate visuals. In order to do that, use a .
Cached GameObject.transform reference.
Implements Unity's Awake event function.
If overriding this method in an inheritor, the base method should be called.
Implements Unity's OnEnable event function.
If overriding this method in an inheritor, the base method should be called.
Overrides .
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
To extend the functionality of copying data from the networked buffer to the engine,
override and extend instead.
Implements .
If overriding this method in an inheritor, the base method should be called.
To extend the functionality of copying data from the engine to the networked buffer,
override and extend instead.
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Sets the values retrieved from the networked data to the respective engine (Unity) fields.
If overriding this method in an inheritor, the base method should be called.
Sets the values retrieved from the engine (Unity) to the respective networked fields.
If overriding this method in an inheritor, the base method should be called.
Gets the position value from the engine. By default, the world position is set to be the output.
Gets the rotation value from the engine. By default, the world rotation is set to be the output.
Sets a position value to the engine. By default, the value is set to the transform's world position field.
Sets a rotation value to the engine. By default, the value is set to the transform's world rotation field.
Number of words used by a instance on its networked data,
including all inherited fields.
Number of words used by this class on the networked data buffer, including all inherited fields,
to serve for reference to inheritors.
Implements by defining the word offset from the base pointer to the field that carries the position data used for Area of Interest management.
Reads from the position field on this object's networked data
with the default Runner position read accuracy.
Reads from a position field on the networked data pointed by
with the default Runner position read accuracy.
Reads from a position field on the networked data pointed by
with the defined .
Reads from the rotation field on this object's networked data
with the default Runner position read accuracy.
Reads from a rotation field on the networked data pointed by
with the default Runner position read accuracy.
Reads from a rotation field on the networked data pointed by
with the defined .
Writes to a position field on this object's networked data
with the default Runner position write accuracy.
Writes to a position field on the networked data pointed by
with the default Runner position write accuracy.
Writes to a position field on the networked data pointed by
with the defined .
Writes to a rotation field on this object's networked data
with the default Runner position write accuracy.
Writes to a rotation field on the networked data pointed by
with the default Runner position write accuracy.
Writes to a rotation field on the networked data pointed by
with the defined .
Replicates a Unity Rigidbody state from the to all other peers.
Add this component to a GameObject with a Rigidbody component.
A is required on this GameObject or a parent of this GameObject.
Cached reference of this object's component.
Sets the field to .
Sets the default teleport interpolation velocity to be the rigidbody velocity.
For more details on how this field is used, see .
Sets the default teleport interpolation angular velocity to be the rigidbody angular velocity.
For more details on how this field is used, see .
Implements Unity's Awake event function.
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Number of words used by a instance on its networked data,
including all inherited fields.
Reads from the field reserved to store the rigidbody position on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody position on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody position on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody rotation on this object's
networked data using the default Runner rotation read accuracy.
Reads from the field reserved to store the rigidbody rotation on the networked data pointed
by using the default Runner rotation read accuracy.
Reads from the field reserved to store the rigidbody rotation on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody velocity on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody velocity on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody velocity on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody angular velocity on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the defined .
Reads from a field reserved to store the rigidbody flags and constraints
on this object's networked data.
Reads from a field reserved to store the rigidbody flags and constraints
on the networked data pointed by .
Writes to the field reserved to store the rigidbody position on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody position on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody position on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody rotation on this object's
networked data using the default Runner rotation write accuracy.
Writes to the field reserved to store the rigidbody rotation on the networked data pointed
by using the default Runner rotation write accuracy.
Writes to the field reserved to store the rigidbody rotation on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody velocity on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody velocity on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody velocity on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody angular velocity on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the defined .
Writes to a field reserved to store the rigidbody flags and constraints on this object's networked data.
Writes a field reserved to store the rigidbody flags and constraints on the networked data pointed by .
Replicates a Unity Rigidbody state from the to all other peers.
Add this component to a GameObject with a Rigidbody component.
A is required on this GameObject or a parent of this GameObject.
Cached reference of this object's component.
Sets the field to .
Sets the default teleport interpolation velocity to be the rigidbody velocity.
For more details on how this field is used, see .
Sets the default teleport interpolation angular velocity to be the rigidbody angular velocity, around the Z axis.
For more details on how this field is used, see .
Implements Unity's Awake event function.
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Number of words used by a instance on its networked data,
including all inherited fields.
Reads from the field reserved to store the rigidbody position on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody position on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody position on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody rotation on this object's
networked data using the default Runner rotation read accuracy.
Reads from the field reserved to store the rigidbody rotation on the networked data pointed
by using the default Runner rotation read accuracy.
Reads from the field reserved to store the rigidbody rotation on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody velocity on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody velocity on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody velocity on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody angular velocity on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody gravity scale on this object's
networked data using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody gravity scale on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody gravity scale on the networked data pointed
by using the defined .
Reads from a field reserved to store the rigidbody flags and constraints
on this object's networked data.
Reads from a field reserved to store the rigidbody flags and constraints
on the networked data pointed by .
Writes to the field reserved to store the rigidbody position on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody position on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody position on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody rotation on this object's
networked data using the default Runner rotation write accuracy.
Writes to the field reserved to store the rigidbody rotation on the networked data pointed
by using the default Runner rotation write accuracy.
Writes to the field reserved to store the rigidbody rotation on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody velocity on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody velocity on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody velocity on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody angular velocity on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody angular velocity on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody gravity scale on this object's
networked data using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody gravity scale on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody gravity scale on the networked data pointed
by using the defined .
Writes to a field reserved to store the rigidbody flags and constraints on this object's networked data.
Writes a field reserved to store the rigidbody flags and constraints on the networked data pointed by .
Base class for 2D and 3D networked rigid body behaviours:
see and , respectively.
This class handles some of the data and logic shared between the two versions.
Sets a 2D or 3D rigid body kinematic field to ,
according to the explicit implementation.
If the rigid body state is not predicted, but just interpolated between snapshots.
If was called at least once on this instance.
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
To extend the functionality of copying data from the networked buffer to the engine,
override and extend instead.
Implements .
If overriding this method in an inheritor, the base method should be called.
To extend the functionality of copying data from the engine to the networked buffer,
override and extend instead.
Implements .
If overriding this method in an inheritor, the base method should be called.
Networked flags representing a 2D or 3D rigid body state and characteristics.
Networked kinematic state.
See also or .
Networked state. Not used with 2D rigid bodies.
Networked sleeping state.
See also or .
Number of words used by a instance on its networked data,
including all inherited fields.
Reads from the field reserved to store the rigidbody drag on this object's networked data
using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody drag on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody drag on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody angular drag on this object's networked data
using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody angular drag on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody angular drag on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody mass on this object's networked data
using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody mass on the networked data pointed
by using the default Runner position read accuracy.
Reads from the field reserved to store the rigidbody mass on the networked data pointed
by using the defined .
Reads from the field reserved to store the rigidbody flags on this object's networked data.
Reads from the field reserved to store the rigidbody flags on the networked data pointed by .
Reads from the field reserved to store the rigid body flags on this object's networked data
and returns the raw word value that might also carry flags specific to 2D or 3D rigid bodies.
See also
NetworkRigidbody.ReadNetworkRigidbodyFlags or
NetworkRigidbody2D.ReadNetworkRigidbodyFlags.
Reads from a field reserved to store the rigid body flags on the networked data pointed by
and returns the raw word value that might also carry flags specific to 2D or 3D rigid bodies.
See also
NetworkRigidbody.ReadNetworkRigidbodyFlags or
NetworkRigidbody2D.ReadNetworkRigidbodyFlags.
Reads the values of a rigidbody drag, angular drag and mass field on this object's networked data
using the default Runner position read accuracy.
The values are returned as the x, y and z values of a Vector3, respectively.
Reads the values of a rigidbody drag, angular drag and mass field on the networked data pointed
by using the default Runner position read accuracy.
The values are returned as the x, y and z values of a Vector3, respectively.
Reads the values of a rigidbody drag, angular drag and mass field on the networked data pointed
by using the defined .
The values are returned as the x, y and z values of a Vector3, respectively.
Writes the field reserved to store the rigidbody drag on this object's networked data
using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody drag on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody drag on the networked data pointed
by using the defined .
Writes the field reserved to store the rigidbody angular drag on this object's networked data
using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody angular drag on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody angular drag on the networked data pointed
by using the defined .
Writes the field reserved to store the rigidbody mass on this object's networked data
using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody mass on the networked data pointed
by using the default Runner position write accuracy.
Writes to the field reserved to store the rigidbody mass on the networked data pointed
by using the defined .
Writes to the field reserved to store the rigidbody flags on this object's networked data.
Reads from the field reserved to store the rigidbody flags on the networked data pointed by .
Writes to the field reserved to store the on this object's networked data.
See also
NetworkRigidbody.ReadNetworkRigidbodyFlags or
NetworkRigidbody2D.ReadNetworkRigidbodyFlags.
Writes to the field reserved to store the on this object's networked data.
See also
NetworkRigidbody.ReadNetworkRigidbodyFlags or
NetworkRigidbody2D.ReadNetworkRigidbodyFlags.
Writes the values of a rigidbody drag, angular drag and mass field on this object's networked data
using the default Runner position read accuracy.
The values must be provided as the x, y and z values of a Vector3, respectively.
Reads the values of a rigidbody drag, angular drag and mass field on the networked data pointed
by using the default Runner position read accuracy.
The values must be provided as the x, y and z values of a Vector3, respectively.
Reads the values of a rigidbody drag, angular drag and mass field on the networked data pointed
by using the defined .
The values must be provided as the x, y and z values of a Vector3, respectively.
Replicates a Unity Transform's position and rotation states from the to all other peers.
Add this component to a GameObject to sync the position and rotation data.
A is required on this GameObject or a parent of this GameObject.
Besides handling smooth interpolation of a target view transform, this behaviour also provides
interpolated prediction error correction and special handling logic for teleports with controlled interpolation.
The interpolation velocity used when calling and not specifying a value.
By default, this value is .
Some behaviours like and override
this property to provide better default values, like the latest known velocity of the rigid body.
The interpolation angular velocity used when calling and not specifying a value.
By default, this value is .
Some behaviours like and override
this property to provide better default values, like the latest known angular velocity of the rigid body.
Teleports the object to the provided position while making the networked state aware
that the object was teleported and the view interpolation needs special handling.
The is immediately set to the transform's position field
and additional data is stored in order to interpolate the view object between the ticks.
While interpolating the visual representation of the networked object TO a tick where a teleport happened,
the object's latest state (tick when the teleport is performed) will not be used, as doing so would cause
the interpolation target to visually interpolate along the teleported distance. Instead, the view will be
interpolated between the FROM state (tick before the teleport) and an artificial position
computed based on this FROM state and an interpolation velocity (see ),
in order to emulate how the object would behave if the teleport had not been performed.
The position which the object is being teleported to.
The emulated velocity of the interpolation target while interpolating to a tick where a teleport happened.
If null, the will be used.
If the artificial position for teleport interpolation should be computed backwards (artificial From, based on the
To state - the interpolation velocity) or forward (artificial To, based on the From state + interpolation velocity).
Teleports the object to the provided rotation while making the networked state aware
that the object was teleported and the view interpolation needs special handling.
The is immediately set to the transform's rotation field
and additional data is stored in order to interpolate the view object between the ticks.
While interpolating the visual representation of the networked object TO a tick where a teleport happened,
the object's latest state (tick when the teleport is performed) will not be used, as doing so would cause
the interpolation target to visually interpolate along the teleported rotation. Instead, the view will be
interpolated between the FROM state (tick before the teleport) and an artificial rotation
computed based on this FROM state and an interpolation angular velocity (see ),
in order to emulate how the object would behave if the teleport had not been performed.
The rotation which the object is being teleported to.
The emulated angular velocity of the interpolation target while interpolating to a tick where a teleport happened.
If null, the will be used.
If the artificial position for teleport interpolation should be computed backwards (artificial From, based on the
To state - the interpolation velocity) or forward (artificial To, based on the From state + interpolation velocity).
Teleports the object to the provided position and rotation while making the networked state aware
that the object was teleported and the view interpolation needs special handling.
The is immediately set to the transform's rotation field
and additional data is stored in order to interpolate the view object between the ticks.
See and for more details about why and how
the special interpolation handling is performed.
The position which the object is being teleported to.
The rotation which the object is being teleported to.
The emulated velocity of the interpolation target while interpolating to a tick where a teleport happened.
If null, the will be used.
The emulated angular velocity of the interpolation target while interpolating to a tick where a teleport happened.
If null, the will be used.
If the artificial position for teleport interpolation should be computed backwards (artificial From, based on the
To state - the interpolation velocity) or forward (artificial To, based on the From state + interpolation velocity).
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements and, by default, calls
.
Behaviours that change the Transform state of this predict-spawned object should either be ordered
before NetworkTransform or call after doing so.
If overriding this method in an inheritor, the base method should be called.
Implements .
If overriding this method in an inheritor, the base method should be called.
Implements and, by default, calls Destroy on this GameObject.
Implements and does nothing by default.
If this object is a predicted spawn, caches the current transform
state for interpolated rendering and prediction error correction.
Number of words used by a instance on its networked data,
including all inherited fields.
Reads from this object's networked data field holding the interpolation velocity
(used on position teleports) using the default Runner position read accuracy.
See for more information on how this value is used.
Reads from a field holding the interpolation velocity (used on position teleports)
from the networked data pointed by using the default Runner position read accuracy.
See for more information on how this value is used.
Reads from a field holding the interpolation velocity (used on position teleports)
from the networked data pointed by with the defined .
See for more information on how this value is used.
Reads from this object's networked data field holding the interpolation angular velocity
(used on position teleports) using the default Runner position read accuracy.
See for more information on how this value is used.
Reads from a field holding the interpolation angular velocity (used on position teleports)
from the networked data pointed by using the default Runner position read accuracy.
See for more information on how this value is used.
Reads from a field holding the interpolation angular velocity (used on position teleports)
on the networked data pointed by with the defined .
See for more information on how this value is used.
Reads from this object's field holding the tick number where was last called.
Reads from the networked data pointer by
a field holding the tick number where was last called.
Reads from this object's field holding the tick number where was last called.
Reads from the networked data pointer by
a field holding the tick number where was last called.
Reads from this object's field holding information about the last call
and if should be interpolated forward (emulated To based on From state + interpolation) or backwards
(Emulated From based on To state - interpolation).
Reads from the networked data pointer by a field holding information about the last
call and if should be interpolated forward (emulated To based on From state + interpolation)
or backwards (Emulated From based on To state - interpolation).
Reads from this object's field holding information about the last call
and if should be interpolated forward (emulated To based on From state + interpolation) or backwards
(Emulated From based on To state - interpolation).
Reads from the networked data pointer by a field holding information about the last
call and if should be interpolated forward (emulated To based on From state + interpolation)
or backwards (Emulated From based on To state - interpolation).
Writes to this object's networked data field holding the interpolation velocity
(used on position teleports) using the default Runner position write accuracy.
See for more information on how this value is used.
Writes to a field holding the interpolation velocity (used on position teleports)
on the networked data pointed by using the default Runner position write accuracy.
See for more information on how this value is used.
Writes to a field holding the interpolation velocity (used on position teleports)
from the networked data pointed by with the defined .
See for more information on how this value is used.
Writes to this object's networked data field holding the interpolation angular velocity
(used on position teleports) using the default Runner position write accuracy.
See for more information on how this value is used.
Writes to a field holding the interpolation angular velocity (used on position teleports)
on the networked data pointed by using the default Runner position write accuracy.
See for more information on how this value is used.
Writes to a field holding the interpolation angular velocity (used on position teleports)
from the networked data pointed by with the defined .
See for more information on how this value is used.
Writes this object's field holding the tick number where was last called.
Writes to the networked data pointer by
a field holding the tick number where was last called.
Writes this object's field holding the tick number where was last called.
Writes to the networked data pointer by
a field holding the tick number where was last called.
Writes to this object's field holding information about the last call
and if should be interpolated forward (emulated To based on From state + interpolation) or backwards
(Emulated From based on To state - interpolation).
Writes the networked data pointer by , on a field holding information about the last
call and if should be interpolated forward (emulated To based on From state + interpolation)
or backwards (Emulated From based on To state - interpolation).
Writes to this object's field holding information about the last call
and if should be interpolated forward (emulated To based on From state + interpolation) or backwards
(Emulated From based on To state - interpolation).
Writes to this object's field holding information about the last call
and if should be interpolated forward (emulated To based on From state + interpolation) or backwards
(Emulated From based on To state - interpolation).
Struct that provides relevant parameters when interpolating a
view representation with position and rotation data between two
known states, referred as 'From' and 'To'.
Normalized factor that represents the exact point between From and To states
at which the view should be displayed.
Position value at the From state.
Position value at the To state.
Position value interpolated between From ()
and To () with factor .
Computed value for smooth correction of prediction error.
In order to apply it, add its value to the
before setting the result to the view transform.
The value will be if there is no prediction error
or is disabled.
Rotation value at the From state.
Rotation value at the To state.
Rotation value interpolated between From ()
and To () with factor .
Computed value for smooth correction of prediction error.
In order to apply it, multiply its value by the
before setting the result to the view transform.
The value will be if there is no prediction error
or is disabled.
If the Interpolation Target should be interpolated in world space or in the local space of a networked parent.
Interpolating in local space requires more computations, but gives more accurate visuals if/when a parent rotates.
The Transform object used for smooth view interpolation.
Should be a non-physics GameObject, typically a child of this GameObject or a separate object without colliders.
Overrides .
If overriding this method in an inheritor, the base method should be called.
Overrides .
If overriding this method in an inheritor, the base method should be called.
Overrides , computing the interpolated position and rotation values
according to the , updating the prediction error correction
and calling to apply the results to the .
Applies the interpolated position and rotation values and prediction error corrections
computed on to the .
Retrieves the world position values from the From and To states made
available in the interpolation , setting them
to and , respectively.
Retrieves the world rotation values from the From and To states made
available in the interpolation , setting them
to and , respectively.
Computes the interpolated transform parameters based on the interpolation data provided.
If the computed prediction error should be smoothly corrected on
the InterpolationTarget according to
the InterpolatedErrorCorrectionSettings.
A set of parameters to tune the interpolated correction of prediction
error to be applied on the InterpolationTarget.
Implements .
If overriding this method in an inheritor, the base method should be called.
Provides custom API and state replication for collider-based character controller movement (not related to Unity's CharacterController type).
Replicates both the internal state (Velocity, MaxSpeed, etc) and the Unity Transform data from the to all other peers.
Add this component to a GameObject to control movement and sync the position and/or rotation accurately, including client-side prediction.
Usage - For basic prototyping call the following methods:
NetworkCharacterController.Move()
NetworkCharacterController.Jump()
For more advanced uses, call only the movement query to get full surface movement data (),
and implement bespoke Move/Steering:
NetworkCharacterController.Jump()
A is required.
Not to be combined with either nor . These are mutually-exclusive options.
Collision and trigger callback interface that can optionally be passed to the movement query.
Common uses: bypass a contact, apply a contact force to the target (can also be achieved just by adding a kinematic Rigidbody to the Character Controller.
Called for all contacts with a non-trigger collider that penetrates more than .
data about the collision
Called for all contacts with a trigger collider. Not affected by .
data about the trigger collision
Hit data passed as parameters to methods.
The other game object collider in touch with the Character Controller.
The normal direction of the collision.
The penetration magnitude.
True in case this collision is considered a bump ().
What to do with collisions that are considered a bump.
Collision always affects this Character Controller, no matter the movement situation.
Automatically ignore collisions when character is standing.
(the Other NetworkCharacterController will still be affected and not allowed penetrate)
(Not implemented yet!)
Automatically ignore collisions when collision is from sides or back.
(the Other NetworkCharacterController will still be affected and not allowed penetrate)
Movement type computed by the movement query based on collisions and surface tangents.
No desired movement, and standing on a ground.
No ground or slope collisions (there may be a collision on the upper part).
No collision qualifies as grounded (angle between up and normal is smaller or equals to max slope).
At least one collision that qualifies as slope (angle between up and surface normal is larger than max slope).
There's a desired movement direction.
At least one collision qualifies as grounded (angle between up and normal is smaller or equals to max slope).
Configuration data used both by ComputeRawMovement and the prototype-grade Move and ComputeRawSteering methods.
Helps stabilize grounded state when walking over slightly bumpy geometry. Influences collision and trigger callbacks.
How much penetration to correct each frame (used only by Move and ComputeRawSteering)
for collisions with this Character Controller.
Only colliders in this layermask will be considered by the movement query.
Whereas to also compute triggers or not.
Should player keep control when in FreeFall (used only by Move and ComputeRawSteering).
When moving, velocity is incremented by this factor over time (used only by Move and ComputeRawSteering).
When stopped moving, velocity is decremented by this factor over time (used only by Move and ComputeRawSteering).
Vertical impulse applied when Jump() is called without an overhauling impulse passed (used only by Jump()).
Horizontal velocity is clamped by this magnitude (used only by Move and ComputeRawSteering).
This will only be used to initialize the corresponding MaxSpeed networked property, which can be changed in runtime.
Horizontal velocity is clamped by this magnitude (used only by Move and ComputeRawSteering).
Slope-fall velocity is clamped by this magnitude (used only by Move and ComputeRawSteering).
Non-networked gravity (used only by Move and ComputeRawSteering).
In case variable gravity is required, the recommendation is to implement custom Move and RawSteering methods.
Non-networked gravity (used only by Move and ComputeRawSteering).
In case variable gravity is required, the recommendation is to implement custom Move and RawSteering methods.
Result of a movement query.
Recommended type of movement based on found collisions.
Surface normal of the nearest collision.
Average normal of all collisions.
Surface normal of the closest collision that qualifies as ground, if any.
Surface tangent (recommended movement direction) in case there's a desired direction passed.
Surface tangent (recommended movement direction) in case of a slope (based on gravity).
Full correction vector to move out of collisions.
Magnitude of the penetration over the nearest normal.
True if at least one collision (not necessarily closest) qualifies as ground.
Total number of collisions found in this execution of the movement query.
The Collider object used for the movement query (to grab surface normals, penetration correction, etc).
Recommended to be a child of this Character Controller.
Internal use for automatic Area-of-Interest management.
Networked current grounded state (used only by Move and COmputeRawSteering)
Networked current jumped state (used only by Move and ComputeRawSteering to avoid clamping a jump speed when on the first subsequent query the collider still touches the ground)
Networked current max speed (used only by Move and ComputeRawSteering to clamp horizontal components of Velocity)
Networked current velocity (used only by Move and ComputeRawSteering to move the Character Controller)
.
Basic implementation of a jump impulse (immediately integrates a vertical component to Velocity).
Jump even if not in a grounded state.
Optional, if null Config.BaseImpulse will be used.
Basic implementation of a full Move.
Performs a movement query, uses its result to compute new Velocity, then applies penetration corrections + velocity integration into the transform position.
Does not change Rotation.
Intended movement direction, subject to movement query + acceleration.
Optional custom callbacks object.
Optional layermask. If not passed, the default one from Config will be used
Static query for surface movement data.
Does not modify any data on state (neither transform, nor self).
Intended movement direction. WIll be used to compute surface tangents.
Optional custom callbacks object.
Optional layermask. If not passed, the default one from Config will be used
The results
Enables syncing of Drag, AngularDrag and Mass values.
Replicates a Unity Rigidbody state from the to all other peers.
Add this component to a GameObject with a Rigidbody component.
A is required on this GameObject or a parent of this GameObject.
Reference of the Rigidbody associated with this .
Reads the TRS values from state buffer for this tick, and converts them to world space if using .
Replicates a Unity Rigidbody state from the to all other peers.
Add this component to a GameObject with a Rigidbody component.
A is required on this GameObject or a parent of this GameObject.
Reference of the Rigidbody associated with this .
Reads the TRS values from state buffer for this tick, and converts them to world space if using .
Replicates Unity parenting. To network parent changes, the new parent must either be null or have a or class derived from that on the GameObject,
and the GameObject being re-parented also requires a based Component.
A is required on this GameObject or a parent of this GameObject.
The Ptr offset for the memory position of the Parent info. The parenting info is 2 words (8 bytes).
The Ptr offset for the secondary teleport parent information. This parent is used by the lerp TO target leading up to the teleport.
Technically, an Anchor does NOT hold position data.
However, NetworkAreaOfInterestBehaviour used to inherit from this class and this was problematic.
Now, instead, it inherits from NetworkAreaOfInterestBehaviour, so we need to have a PositionWordOffset
and leave space for a position field, even though it does not use it.
It is possible for inheritors of this class (like NetworkTransform) to have a "negative" initial offset
and overlap with this position field.
This whole thing was necessary to not break backwards compatibility while the transform-related behaviors are refactored.
Gets the Ptr offset of the Position values in allocated memory.
The total number of words used by . Derived classes using allocated memory should start their Ptr offsets using this value.
The Transform object used for interpolation.
Should be a non-physics GameObject. Typically a child of this Rigidbody, or a separate object without colliders.
The runner/simulation with State Authority will not interpolate if target is null or the same GameObject as the Rigidbody,
as this will conflict with the PhysX simulation.
Used by the inspector gui to determine if the supplied transform is acceptable. If false will show a warning box.
The Transform object used for interpolation.
Should be a non-physics GameObject. Typically a child of this GameObject without colliders, or a separate GameObject without colliders.
EXPERIMENTAL: To improve interpolation of scaling, the interpolation target is detached from its .
Only check this if you are syncing scaling.
When re-parenting, this component's will re-parent to the parent's .
Indicates if Transform.parent will be synced. Parent syncing requires the parent of this object either be null or have a component.
Cached GameObject.transform reference.
Returns true if the parent has changed.
If using local space, tries to get the To and From parents.
If valid parents are found, they are forced to run Render() - as parents should always interpolate before children.
If a parent value has been serialized. Invalid means unknown parent.
If a parent value has been serialized. Invalid means unknown parent.
(From Parent, To Parent)
Replicates a Unity Transform state from the to all other peers.
Add this component to a GameObject to sync the position and/or rotation.
A is required on this GameObject or a parent of this GameObject.
The Ptr offset location of the position values in allocated memory.
The Ptr offset location of the rotation values in allocated memory.
The Ptr offset location of the local scale values in allocated memory.
The Ptr offset for the secondary teleport position information. This position is used as the lerp TO target leading up to the teleport.
The Ptr offset for the secondary teleport rotation information. This rotation is used as the lerp TO target leading up to the teleport.
The Ptr offset for the secondary teleport scale information. This scale is used as the lerp TO target leading up to the teleport.
The Ptr offset of the teleport increment value. Increases by one every tick a teleport occurs.
The total number of words used by . Derived classes using allocated memory should start their Ptr offsets using this value.
Gets the Ptr offset of the Position values in allocated memory.
Indicates if Scale should be included in Transform sync and interpolation (when enabled).
Select if the synced state uses World or Local position and rotation values.
The frame of the next Teleport action.
Stores the last UnityEngine.Time.time when interpolation was run for this component. Used to ensure interpolation is only run once per screen refresh.
Emulates the accuracy loss when writing and reading a Vector3 to/from a buffer, according to the given accuracies.
Emulates the accuracy loss when writing and reading a Quaternion to/from a buffer, according to the given accuracies.
Most recent unconsumed Teleport() command.
Teleport indicates that objects should not interpolate from the previous state to this new state.
Sets the position or rigidbody.position to this value prior to state sync.
If not null, Sets the position or rigidbody.rotation to this value prior to state sync.
If not null, Sets the localScale to this value prior to state sync.
Accepts a Quaternion, Euler (Vector3), or 2d Z value (float)
Resets velocity, angular velocity, and controller states to default if applicable.
Typically set to true if teleport is used for a respawn.
Sets the velocity after teleport. Ignored if this is not a Rigidbody or CharacterController. Overrides reset.
Sets the angular velocity after teleport. Ignored if this is not a Rigidbody. Overrides reset.
Captures the current state as the interpolation lerp TO target leading up to a teleport, and flags the next tick as a teleport.
Call this BEFORE making any TRS changes to the synced transform which represent the teleport.
For continuously moving rigidbodies, it is preferable to call the explicit Teleport() method.
Applies the latest unconsumed Teleport() call after the Forward simulation is complete, and before the TRS state is captured.
Base class for OrderBefore and OrderAfter attributes.
Fusion attribute used to indicate relative execution order of and derived scripts.
Any number of scripts can be specified.
Usage:
[OrderAfter(typeof(MySimulationBehaviour), typeof(MyNetworkBehaviour), etc)]
The array of scripts the attributed script should run before.
Fusion attribute that defines execution order of this script relative to specified other scripts.
The and scripts this attributed script should execute AFTER.
Fusion attribute used to indicate relative execution order of and derived scripts.
Any number of scripts can be specified.
Usage:
[OrderBefore(typeof(MySimulationBehaviour), typeof(MyNetworkBehaviour), etc)]
The array of scripts the attributed script should run before.
Fusion attribute that defines execution order of this script relative to specified other scripts.
The and scripts this attributed script should execute BEFORE.
This sorting class is meant to be released and garbage collected after use.
Returns sorted list of Types.
Locate all SimulationBehaviours, and add them to this system.
Alphabetize the initial list to create determinism in all following steps.
Create the node without searching for attributes yet.
Merge Before and Afters based on the logic: If A is Before B, and B is Before C, then A is Before C... etc
This allows obvious conflicts to be quickly spotted.
Converts linked OrderNode list to Type[]
Flags a Unity component class as a RunnerVisibilityNodes recognized type.
Will be included in handling, and will be found by component finds.
Flag component which indicates a NetworkObject has already been factored into a Runner's VisibilityNode list.
Identifies visible/audible components (such as renderers, canvases, lights) that should be enabled/disabled by .
Automatically added to scene objects and spawned objects during play if running in .
Additionally this component can be added manually at development time to identify specific Behaviours or Renderers you would like to restrict to one enabled copy at a time.
Types that fusion.runtime isn't aware of, which need to be found using names instead.
The peer runner that will be used if more than one runner is visible, and this node was manually added by developer (indicating only one instance should be visible at a time).
The peer/runner with input authority will be used if visible.
The server peer/runner will be used if visible.
The first client peer/runner will be used if visible.
If more than one runner instance is visible, this indicates which peer's clone of this entity should be visible.
The associated component with this node. This Behaviour or Renderer will be enabled/disabled when its parent is changed.
Guid is used for common objects (user flagged nodes that should only run in one instance), to identify matching clones.
Set to false to indicate that this object should remain disabled even when is set to true.
Sets the visibility state of this node.
Dictionary lookup for manually added visibility nodes (which indicates only one instance should be visible at a time),
which returns a list of nodes for a given LocalIdentifierInFile.
Find all component types that contribute to a scene rendering, and associate them with a component,
and add them to the runner's list of visibility nodes.
Force a complete visibility refresh on all runners. Typically used if a runner is destroyed/shutdown.
Reapplies a runner's IsVisibile setting to all of its registered visibility nodes.
Automatically adds a for each indicated component.
These indicated components will be limited to no more than one enabled instance when running in Multi-Peer mode.
If more than one runner instance is visible, this indicates which peer's clone of this entity should be visible.
Collection of components that will be marked for Multi-Peer mode as objects that should only have one enabled instance.
Prefix for the GUIDs of components which are added at runtime.
At runtime startup, this adds a for each component reference to this GameObject.
Finds visual/audio components on this GameObject, and adds them to the Components collection.
Finds visual/audio nested components on this GameObject and its children, and adds them to the Components collection.
Base class for a Fusion aware Behaviour (derived from UnityEngine.MonoBehavour).
Objects derived from this object can be associated with a and .
If a parent is found, this component will also be associated with that network entity.
The this component is associated with.
The this component is associated with. May be null if this GameObject does not have a .
Fusion FixedUpdate timing callback.
Post simulation frame rendering callback. Runs after all simulations have finished. Use in place of Unity's Update when Fusion is handling Physics.
Attribute for specifying which and this will execute in.
Can be used to limit execution to only Host, Server or Client peers, or to only execute on Resimulation or Forward ticks.
Usage:
[SimulationBehaviour(Stages = SimulationStages.Forward, Modes = SimulationModes.Server | SimulationModes.Host)]
Flag for which stages of the simulation loop this component will execute this script.
Flag for which indicated peers in will execute this script.
The default behaviour interfaces
Tools to replace GetComponent variants that respects nested objects.
These are used to find components of a NetworkedObjects without also finding components that belong to parent or child NetworkedObjects.
Find T on supplied transform or any parent. Unlike GetComponentInParent, GameObjects do not need to be active to be found.
Returns all T found between the child transform and its root. Order in List from child to parent, with the root/parent most being last.
Same as GetComponentInParent, but will always include inactive objects in search.
Will also stop recursing up the hierarchy when the StopOnT is found.
UNTESTED
Finds components of type T on supplied transform, and every parent above that node, inclusively stopping on node StopT component.
Same as GetComponentsInChildren, but will not recurse into children with component of the StopT type.
Same as GetComponentsInChildren, but will not recurse into children with any component of the types in the stopOn array.
Same as GetComponentsInChildren, but will not recurse into children with component of the StopT type.
Cast found components to this type. Typically Component, but any other class/interface will work as long as they are assignable from SearchT.
Find components of this class or interface type.
When this component is found, no further recursing will be performed on that node.
Find All instances of Component type in a scene. Attempts to respect the hierarchy of the scene objects to produce a more deterministic order.
This is a slower operation, and does produce garbage collection.
Find All instances of Component type in a scene. Attempts to respect the hierarchy of the scene objects to produce a more deterministic order.
This is a slower operation which should not be run every update.
Supplied list that will be populated by this find.
Whether results should include inactive components.
Find All instances of Component type in a scene. Attempts to respect the hierarchy of the scene objects to produce a more deterministic order.
This is a slow operation, and does produce garbage collection.
The type being searched for.
Casts all found objects to this type, and returns collection of this type. Objects that fail cast are excluded.
Whether results should include inactive components.
Find All instances of Component type in a scene. Attempts to respect the hierarchy of the scene objects to produce a more deterministic order.
This is a slower operation and should not be run every update.
Supplied list that will be filled with found objects.
Whether results should include inactive components.
Flag interface for custom NetworkInput structs.
Translates structs and represents them in Fusions's unsafe allocated memory.
Returns pointer to the struct data in memory.
Tries to export data as the indicated T struct.
Tries to import data from a struct.
Call this to batch-optimize any object-changes notified through
ssBVHNode.refit_ObjectChanged(..). For example, in a game-loop,
call this once per frame.
Call this when you wish to update an object. This does not update straight away, but marks it for update when Optimize() is called
initializes a BVH with a given nodeAdaptor, and object list.
tryRotate looks at all candidate rotations, and executes the rotation with the best resulting SAH (if any)
Represents a single lag-compensated collider.
Multiple component instances can be added anywhere in the hierarchy of a which includes a .
The collision geometry type for this .
When is set to , this defines the local-space geometry for narrow-phase checks.
When is set to , this defines the local-space geometry for narrow-phase checks.
This 's local-space offset from its GameObject position.
Reference to the top-level component for this .
The index of this hitbox in the array on .
The value is set by the root when initializing the nested hitboxes with .
Mask to access the state of this hitbox on the root.
Get or set the state of this Hitbox.
If a hitbox or its HitboxRoot are not active, it will not be hit by lag-compensated queries.
World-space position (includes Offset) of this .
Draws this hitbox gizmo on Unity editor.
Per-query options for lag compensation (both raycast and overlap).
Default, no extra options.
Add this to include checks against PhysX colliders.
Subtick accuracy query (exactly like seen by player).
Compute surface normal and distance of raycast hit.
Settings for lag compensation history.
Hitbox snapshot history size in ticks.
Broadphase BVH node expansion factor (default 20%) for leaf nodes, so updates are not too frequent.
Optional: tries to optimize broadphase BVH every update. May be removed in the future.
Enable gizmos for current BVH nodes.
Enable gizmos for hitbox history.
Server editor gizmo color for BVH nodes.
Client editor gizmo color for BVH nodes.
Editor gizmo color for history representations.
Entry point for lag compensated queries, which
maintains a history buffer, and provides lag compensated raycast and overlap methods.
Singleton instance is accessible through the property Runner.LagCompensation.
Usage - Call any of the following methods:
HitboxManager.Raycast()
HitboxManager.RaycastAll()
HitboxManager.PositionRotation()
HitboxManager.OverlapSphere()
These methods use the history buffer to perform a query against a state consistent with how the indicated perceived them locally.
Debug data from Broadphase BVH (tree depth).
Debug data from Broadphase BVH (total nodes count).
Debug data from lag compensation history (registered count).
Performs a lag-compensated raycast query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Raycast origin, in world-space
Raycast direction, in world-space
Raycast length
Player who "owns" this raycast. Used by the server to find the exact hitbox snapshots to check against.
Raycast results will be filled in here.
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Trigger interaction behavior when also querying PhysX.
true is something is hit
Performs a lag-compensated raycast query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Raycast origin, in world-space
Raycast direction, in world-space
Raycast length
Simulation tick number to use as the time reference for the lag compensation (use this for server AI, and similar).
Simulation tick number to use as the time reference for the lag compensation.
If provided, must be combined with the parameter for interpolation between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded value of .
Interpolation value when querying between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded alpha value.
Raycast results will be filled in here.
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Trigger interaction behavior when also querying PhysX.
true is something is hit
Performs a lag-compensated raycast query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Important: results are NOT sorted by distance.
Raycast origin, in world-space
Raycast direction, in world-space
Raycast length
Player who "owns" this raycast. Used by the server to find the exact hitbox snapshots to check against.
List to be filled with hits (both hitboxes and/or PhysX colliders, if included).
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Clear list of hits before filling with new ones (defaults to true).
Trigger interaction behavior when also querying PhysX.
total number of hits
Performs a lag-compensated raycast query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Important: results are NOT sorted by distance.
Raycast origin, in world-space
Raycast direction, in world-space
Raycast length
Simulation tick number to use as the time reference for the lag compensation (use this for server AI, and similar).
Simulation tick number to use as the time reference for the lag compensation.
If provided, must be combined with the parameter for interpolation between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded value of .
Interpolation value when querying between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded alpha value.
List to be filled with hits (both hitboxes and/or PhysX colliders, if included).
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Clear list of hits before filling with new ones (defaults to true).
Trigger interaction behavior when also querying PhysX.
total number of hits
Performs a lag-compensated overlap sphere query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Sphere center, in world-space
Sphere radius
Player who "owns" this overlap. Used by the server to find the exact hitbox snapshots to check against.
List to be filled with hits (both hitboxes and/or PhysX colliders, if included).
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Clear list of hits before filling with new ones (defaults to true).
Trigger interaction behavior when also querying PhysX.
total number of hits
Performs a lag-compensated overlap sphere query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Sphere center, in world-space
Sphere radius
The tick to be queried
Simulation tick number to use as the time reference for the lag compensation.
If provided, must be combined with the parameter for interpolation between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded value of .
Interpolation value when querying between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded alpha value.
List to be filled with hits (both hitboxes and/or PhysX colliders, if included).
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Clear list of hits before filling with new ones (defaults to true).
Trigger interaction behavior when also querying PhysX.
total number of hits
Performs a lag-compensated box overlap query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Center of the box in world space.
Half of the size of the box in each dimension.
Rotation of the box.
Player who "owns" this overlap. Used by the server to find the exact hitbox snapshots to check against.
List to be filled with hits (both hitboxes and/or PhysX colliders, if included).
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Clear list of hits before filling with new ones (defaults to true).
Trigger interaction behavior when also querying PhysX.
The total number of hits found.
Performs a lag-compensated box overlap query against all registered hitboxes.
If the flag is indicated, query will also include PhysX colliders,
PhysX colliders are recommended for static geometry, rather than Hitboxes.
Center of the box in world space.
Half of the size of the box in each dimension.
Rotation of the box.
The exact tick to be queried
Simulation tick number to use as the time reference for the lag compensation.
If provided, must be combined with the parameter for interpolation between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded value of .
Interpolation value when querying between and .
If is included on , this query will be resolved against hitbox colliders interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded alpha value.
List to be filled with hits (both hitboxes and/or PhysX colliders, if included).
Only objects with matching layers will be checked against.
Opt-in flags to compute with sub-tick accuracy () and/or to include PhysX ().
Clear list of hits before filling with new ones (defaults to true).
Trigger interaction behavior when also querying PhysX.
The total number of hits found.
Performs a lag-compensated query for a specific Hitbox position and rotation.
The target hitbox to be queried in the past
The tick to be queried
Simulation tick number to use as the time reference for the lag compensation.
If provided, must be combined with the parameter for interpolation between and .
If is requested, the query will return the hitbox state interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded value of .
Interpolation value when querying between and .
If is requested, the query will return the hitbox state interpolated between the specified ticks.
Otherwise, only one of the two ticks will be considered, according to the rounded alpha value.
Will be filled with the hitbox position at the time of the tick
Will be filled with the hitbox rotation at the time of the tick
If the query should interpolate between ticks to reflect exactly what was seen on the client.
Performs a lag-compensated query for a specific Hitbox position and rotation.
The target hitbox to be queried in the past
Player who "owns" this overlap. Used by the server to find the exact hitbox snapshots to check against.
Will be filled with the hitbox position at the time of the tick
Will be filled with the hitbox rotation at the time of the tick
If the query should interpolate between ticks to reflect exactly what was seen on the client.
Internal use. Inserts (new ones) and updates all registered hitboxes into lag compensation history.
Unity Gizmos.
Root group container. Manages registering/unregistering hitboxes with the group, and defines the broadphase geometry for the group.
Broadphase is the initial rough query used by raycasts/overlaps/etc to find potential hit candidates,
which are then used in the final narrowphase query.
Get or set the state of this HitboxRoot.
For a hitbox to be hit by lag-compensated queries, both it and its HitboxRoot must be active.
The max number of hitboxes allowed under the same root.
The radius of the broadphase bounding sphere for this group.
Used by to insert/update lag compensated NetworkObjects into its BVH (bounding volume hierarchy) data structure.
Be sure this radius encompasses all children components (including their full ranges of animation motion).
We plan to offer an option to dynamically compute the bounding volume, but the performance trade of will still favor a hand-crafted radius.
Broadphase is the initial rough query used by raycasts/overlaps/etc to find potential hit candidates,
which are then used in the final narrowphase query.
Local-space offset of the broadphase bounding sphere from its transform position.
Adjust the and until the sphere gizmo (shown in the Unity Scene window)
encompasses all children components (including their full ranges of animation motion).
Broadphase is the initial rough query used by raycasts/overlaps/etc to find potential hit candidates,
which are then used in the final narrowphase query.
All Hitbox instances in hierarchy. Auto-filled at Spawned.
Reference to associated hitbox manager (from which lag compensated queries can be performed).
Finds child components, and adds them to the collection.
Sets to a rough value which encompasses all in their current positions.
Sets the state of a Hitbox instance under this root.
Both the hitbox and its root must be active in order for it to be hit by lag-compensated queries.
A hitbox instance under the hierarchy of this root.
If the hitbox should be activated or deactivated.
If the of the is outside the valid range.
In Debug configuration, if the is not part of this root.
Checks the state of a Hitbox instance under this root.
Both the hitbox and its root must be active in order for it to be hit by lag-compensated queries.
A hitbox instance under the hierarchy of this root.
True if the is part of this root and is active.
If the of the is outside the valid range.
In Debug configuration, if the is not part of this root.
Queries can hit either fusion's custom or Unity's standard Physx colliders.
Used when a raycast does not hit anything. Not used on overlaps.
is a Fusion .
is a Unity PhysX Collider.
Defines the collision geometry type of a .
[Future Use] to represent a disabled .
Geometry is a box, fill in Extents and (optional) Offset.
Geometry is a sphere, fill in Radius and (optional) Offset.
Defines a lag compensated query hit result.
Hit object source (PhysX or Fusion Hitboxes).
The Unity Game Object that was hit. Its data is not lag compensated.
This is either the 's or the 's gameObject,
depending on the object hit being a lag-compensated Hitbox or a regular Unity collider, respectively.
Surface normal (if requested) of the hit, at the lag compensated time.
Point of impact of the hit, at the lag compensated time.
Distance (if requested) to hit, at the lag compensated time.
Fusion's . Null in case the hit was on PhysX.
PhysX collider hit. Null in case hit is a Fusion .
HitboxBuffer will store all snapshots of the colliders into a circular buffer
HitboxContainer represents 1 snapshot of all containers in a given Tick
A Networked fusion type for degrees. This can be used with the , in RPCs, or in structs.
Clamps the current value to the supplied min-max range.
Returns the smaller of two supplied angles.
Returns the larger of two supplied angles.
Lerps between two angle values.
Returns a the value, clamped to the min-max range.
Alternative base class to Unity's MonoBehaviour.
This allows for components that work both in Unity, as well as the Photon relays.
Wrapper for Unity's GameObject.AddComponent()
Wrapper for Unity's GameObject.TryGetComponent()
Wrapper for Unity's GameObject.GetComponentInChildren()
Wrapper for Unity's GameObject.Destroy()
Delegate definition for changed callbacks.
Wrapping struct around changed behaviours which allows you to load old and new values.
The wrapped changed behaviour instance. The behaviour will have the new networked values.
Previous values can be obtained by calling changed.Behaviour.LoadOld(), then accessing the networked properties of changed.behaviour.
Tells the OnChanged callback system that this object needs to be re-scanned for changes after the current change scan is completed.
Call this is you are changing data inside an OnChange callback and can't wait for the next tick to execute until the callback is triggered.
Sets the changed behaviour to represent the previous state before the triggering change occurred.
To get previous values, call this before getting networked properties of .
Sets the to represent the changed state after the triggering change occurred.
This is the already default state of the behaviour when an OnChanged callback occurs,
and only needs to be called to undo a previous call in your callback handler.
Icon to be rendered on the component graphic header in the Unity inspector.
Color of the component graphic header in the Unity inspector. None indicates no header graphic should be used.
This may only be deterministic on 64 bit systems.
A set of parameters that tune the interpolated correction of prediction error on transform data.
A factor with dimension of 1/s (Hz) that works as a lower limit for how much
of the accumulated prediction error is corrected every frame.
This factor affects both the position and the rotation correction.
Suggested values are greater than zero and smaller than MaxRate.
E.g.: MinRate = 3, rendering delta time = (1/60)s: at least 5% (3 * 1/60) of the accumulated error
will be corrected on this rendered frame.
This threshold might not be respected if the resultant correction magnitude is
below the PosMinCorrection
or above the PosTeleportDistance, for the position error,
or above the RotTeleportRadians, for the rotation error.
A factor with dimension of 1/s (Hz) that works as a upper limit for how much
of the accumulated prediction error is corrected every frame.
This factor affects both the position and the rotation correction.
Suggested values are greater than MinRate
and smaller than half of a target rendering rate.
E.g.: MaxRate = 15, rendering delta time = (1/60)s: at maximum 25% (15 * 1/60) of the accumulated error
will be corrected on this rendered frame.
This threshold might not be respected if the resultant correction magnitude is
below the PosMinCorrection or
above the PosTeleportDistance, for the position error,
or above the RotTeleportRadians, for the rotation error.
The reference for the magnitude of the accumulated position error, in meters,
at which the position error will be corrected at the MinRate.
Suggested values are greater than PosMinCorrection
and smaller than PosBlendEnd.
In other words, if the magnitude of the accumulated error is equal to or smaller than this threshold,
it will be corrected at the MinRate.
If, instead, the magnitude is between this threshold and PosBlendEnd,
the error is corrected at a rate between MinRate
and MaxRate, proportionally.
If it is equal to or greater than PosBlendEnd,
it will be corrected at the MaxRate.
Note: as the factor is expressed in distance units (meters), it might need to be scaled
proportionally to the overall scale of objects in the scene and speeds at which they move,
which are factors that affect the expected magnitude of prediction errors.
The reference for the magnitude of the accumulated position error, in meters,
at which the position error will be corrected at the MaxRate.
Suggested values are greater than PosBlendStart
and smaller than PosTeleportDistance.
In other words, if the magnitude of the accumulated error is equal to or greater than this threshold,
it will be corrected at the MaxRate.
If, instead, the magnitude is between PosBlendStart and this threshold,
the error is corrected at a rate between MinRate
and MaxRate, proportionally.
If it is equal to or smaller than PosBlendStart,
it will be corrected at the MinRate.
Note: as the factor is expressed in distance units (meters), it might need to be scaled
proportionally to the overall scale of objects in the scene and speeds at which they move,
which are factors that affect the expected magnitude of prediction errors.
The value, in meters, that represents the minimum magnitude of the accumulated position error
that will be corrected in a single frame, until it is fully corrected.
This setting has priority over the resultant correction rate, i.e. the restriction
will be respected even if it makes the effective correction rate be different than
the one computed according to the min/max rates and start/end blend values.
Suggested values are greater than zero and smaller than PosBlendStart.
Note: as the factor is expressed in distance units (meters), it might need to be scaled
proportionally to the overall scale of objects in the scene and speeds at which they move,
which are factors that affect the expected magnitude of prediction errors.
The value, in meters, that represents the magnitude of the accumulated
position error above which the error will be instantaneously corrected,
effectively teleporting the rendered object to its correct position.
Suggested values are greater than PosBlendEnd.
This setting has priority over the resultant correction rate, i.e. the restriction
will be respected even if it makes the effective correction rate be different than
the one computed according to the min/max rates and start/end blend values.
Note: as the factor is expressed in distance units (meters), it might need to be scaled
proportionally to the overall scale of objects in the scene and speeds at which they move,
which are factors that affect the expected magnitude of prediction errors.
The reference for the magnitude of the accumulated rotation error, in radians,
at which the rotation error will be corrected at the MinRate.
Suggested values are smaller than RotBlendEnd.
In other words, if the magnitude of the accumulated error is equal to or smaller than this threshold,
it will be corrected at the MinRate.
If, instead, the magnitude is between this threshold and RotBlendEnd,
the error is corrected at a rate between MinRate
and MaxRate, proportionally.
If it is equal to or greater than RotBlendEnd,
it will be corrected at the MaxRate.
The reference for the magnitude of the accumulated rotation error, in radians,
at which the rotation error will be corrected at the MaxRate.
Suggested values are greater than RotBlendStart
and smaller than RotTeleportRadians.
In other words, if the magnitude of the accumulated error is equal to or greater than this threshold,
it will be corrected at the MaxRate.
If, instead, the magnitude is between RotBlendStart and this threshold,
the error is corrected at a rate between MinRate
and MaxRate, proportionally.
If it is equal to or smaller than RotBlendStart,
it will be corrected at the MinRate.
The value, in radians, that represents the magnitude of the accumulated
rotation error above which the error will be instantaneously corrected,
effectively teleporting the rendered object to its correct orientation.
Suggested values are greater than RotBlendEnd.
This setting has priority over the resultant correction rate, i.e. the restriction
will be respected even if it makes the effective correction rate be different than
the one computed according to the min/max rates and start/end blend values.
Fusion type for networking arrays. Capacity is fixed, and needs to be set the maximum possible number of entries.
Typical Usage:
[Networked, Capacity(4)]
NetworkArray<float> syncedArray => default;
Optional usage (for NetworkBehaviours ONLY - this is not legal in INetworkStructs):
[Networked, Capacity(4)]
NetworkArray<int> syncedArray { get; } = MakeInitializer(new int[] { 1, 2, 3, 4 });
Usage for modifying data:
var array = syncedArray;
array.Set(123);
array[0] = 456;
T can be a primitive, or an INetworkStruct.
The fixed size of the array.
Indexer of array elements.
NetworkArray constructor.
Returns the array value at supplied index.
Sets the array value at the supplied index.
Allocates a new array and copies values from this array. For a non-alloc alternative use .
Adds each value to the supplied List. This does not clear the list, so values will be appended to the existing list.
Copies values to the supplied array.
If true, this method will throw an error if the supplied array is smaller than this . If false, will only copy as many elements as the target array can hold.
Copies a range of values in from a supplied source array.
Starting index of elements in source.
Number of sequential source elements to copy in.
Copies a range of values in from a supplied source list.
Starting index of elements in source.
Number of sequential source elements to copy in.
Returns the elements of this array as a string, with value separated by \n characters. Specifically for use in the Unity inspector.
This is private and only is found by NetworkBehaviourEditor using reflection, so do not rename this method.
Fusion type for networking Dictionaries. Capacity is fixed, and needs to be set the maximum possible number of entries.
Typical Usage:
[Networked, Capacity(10)]
NetworkDictionary<int, float> syncedDict => default;
Usage for modifying data:
var dict = syncedDict;
dict.Add(5, 123);
dict[5] = 456;
dict.Remove(5);
Key can be a primitive, or an INetworkStruct.
Value can be a primitive, or an INetworkStruct.
Current number of key/value entries in the Dictionary.
The maximum number of entries this dictionary may contain.
Key indexer. Gets/Sets value for specified key.
Remove all entries from the Dictionary, and clear backing memory.
Returns true if the Dictionary contains an entry for the given key.
Returns true if the Dictionary contains an entry value which compares as equal to given value.
The value to compare against.
Specify custom IEqualityComparer to be used for compare.
Returns the value for the given key. Will throw an error if the key is not found.
Sets the value for the given key. Will add a new key if the key does not already exist.
Adds a new key value pair to the Dictionary. If the key already exists, will return false.
Attempts to get the value for a given key. If found, returns true.
The key to remove.
Returns value of removed item. Returns default value if key did not exist.
Returns true if key was found.
Remove entry from Dictionary.
Returns true if key was found.
Removes entry from Dictionary. If successful (key existed), returns true and the value of removed item.
The key to remove.
Returns value of removed item. Returns default value if key did not exist.
Returns true if key was found.
Fusion type for networking LinkedLists. Capacity is fixed, and needs to be set the maximum possible number of entries.
Typical Usage:
[Networked, Capacity(10)]
NetworkLinkedList<int> syncedLinkedList => default;
Optional usage (for NetworkBehaviours ONLY - this is not legal in INetworkStructs):
[Networked, Capacity(4)]
NetworkLinkedList<int> syncedLinkedList { get; } = MakeInitializer(new int[] { 1, 2, 3, 4 });
Usage for modifying data:
var list = syncedLinkedList;
list.Add(123);
list[0] = 456;
list.Remove(0);
T can be a primitive, or an INetworkStruct.
Returns the current element count.
Returns the max element count.
Element indexer.
Removes and clears all list elements.
Returns true if the value already exists in the list.
Returns true if the value already exists in the list.
Sets the value at supplied index.
Returns the value at supplied index.
Returns the index with this value. Returns -1 if not found.
Returns the index with this value. Returns -1 if not found.
Specify custom IEqualityComparer to be used for compare.
Removes the first found element with indicated value.
Removes the first found element with indicated value.
Adds a value to the end of the list.
PCG32 random generator, 16 bytes in size.
http://www.pcg-random.org
0x1.00000001p-32 aka 0x3df0000000100000
0x1p-32 aka 0x3df0000000000000
0x1.000002p-24 aka 0x33800001
0x1p-24 aka 0x33800000
Returns a random Double within [0, 1] (range is inclusive).
Returns a random Double within [0, 1) (range is exclusive).
Returns a random Single within [0, 1] (range is inclusive).
[0, 1)
Returns a random Single within [0, 1) (range is exclusive).
[int.MinValue, int.MaxValue]
[0, uint.MaxValue]
Returns a random Double within [minInclusive, maxInclusive] (range is inclusive).
If minInclusive is greater than maxInclusive, then the numbers are automatically swapped.
Returns a random Single within [minInclusive, maxInclusive] (range is inclusive).
If minInclusive is greater than maxInclusive, then the numbers are automatically swapped.
Returns a random Int32 within [minInclusive, maxExclusive) (range is exclusive).
If minInclusive and maxExclusive are equal, then the "exclusive rule" is ignored and minInclusive will be returned.
If minInclusive is greater than maxExclusive, then the numbers are automatically swapped.
Returns a random Int32 within [minInclusive, maxInclusive] (range is inclusive).
If minInclusive is greater than maxInclusive, then the numbers are automatically swapped.
Returns a random UInt32 within [minInclusive, maxExclusive) (range is exclusive).
If minInclusive and maxExclusive are equal, then the "exclusive rule" is ignored and minInclusive will be returned.
If minInclusive is greater than maxExclusive, then the numbers are automatically swapped.
Returns a random UInt32 within [minInclusive, maxInclusive] (range is inclusive).
If minInclusive is greater than maxInclusive, then the numbers are automatically swapped.
Fixed-size UTF32 string. All operations are alloc-free, except for converting to .
Maximum UTF32 string length.
Converts to/from regular UTF16 string. Setter is alloc-free. Use
to get possibly alloc-free conversion.
Number of UTF32 scalars. It is equal or less than or the length
of , because those use UTF16 encoding, which needs two characters to encode
some values.
Returns UTF32 scalar at position. To iterate over characters,
use .
Checks if is equivalent and if not converts to UTF16 and
stores the result in .
False if no conversion was performed, true otherwise.
Converts to UTF32 string and stores it internally.
False if was too long to fit and had to be trimmed.
Calculates the length of the equivalent UTF16 string.
Represents a Fusion player.
The PlayerRef, in contrast to the player index, is 1-based. The reason is that default(PlayerRef) will return a "null/invalid" player ref struct for convenience. There are automatic cast operators that can cast an int into a PlayerRef.
default(PlayerRef), internally a 0, means NOBODY
PlayerRef, internally 1, is the same as player index 0
PlayerRef, internally 2, is the same as player index 1
None player
If this player index is valid
Raw encoded value
Player id this player ref represents
Note: You are passing the bitcount of the length, not the length. Normal values will be in the 5-8 range (32 - 256).
This RingArray is meant to be fast, so it only uses counts of 2^x.
Element count will be 2 to this power.
Indexer. Runs a fast mod on the frameId to make it conform to the ring array.
Wrapper class which unifies rotation handling of Quaternion, Euler or Z-only (used by 2D).
Can store a Quaternion, Euler or Z-axis (for 2d rotation), and implicitly casts between those types.
Indicates of the stored rotation is a Quaternion or Euler type.
Returns the rotation as a Quaternion. If original type was a Euler or Rotation Z-axis only, that is converted to a Quaternion.
Returns the rotation as a Euler. If original type was Quaternion, that is converted to a Euler.
Returns the z-axis value of the rotation. If original type was Quaternion, first converts to a Euler then returns the z value of that Euler.
None scene
If this scene index is valid
The unique identifier for a network entity.
Offset for the bitflag that indicates of this tick is predicted or final.
String conversion specifically for use in prefixing names of GameObjects.
The primary Fusion component for networked GameObject entities.
This stores the object's network identity and manages the object's state and input authority.
The unique identifier for this network entity.
Signal that this comes from a Resume Spawn
The this entity is associated with.
How Object Interest is determined for this object.
Only applicable to mode, and if is enabled.
All players will start with these Interest Groups explicitly enabled for this object.
Use on the server
to explicitly add or remove a player's interest in groups for this .
If the player with State Authority for this Object leaves the room, this Object will automatically be destroyed on the network.
Only applicable to Shared Mode.
When enabled, State Authority over this Object can be taken by a player, without the current State Authority player first releasing authority.
If disabled, will fail if another player currently has State Authority, and has not called .
Only applicable to Shared Mode.
Specifies the component to used to determine this players position for Area Of Interest checks.
If left null, will use the first found root/child instance of on the Object.
Last tick this object received an update. Only available for .
Flags used for network object prefabs and similar
The GUID for this prefab or scene object, which is set at development time. Used to reference this as a spawnable object.
All spawned instances of this object will retain this GUID. Use for the unique ID of network entries.
Array of initial child nested entities, that are children of this Object.
Array of all s associated with this network entity.
Array of all s associated with this network entity.
This does not include derived classes, as they are stored in .
The ID + Unity GameObject name for this entity.
Returns if this network entity existed as part of a scene, rather than having been dynamically spawned.
Returns if this network entity is associated with its , and that runner is not null.
If this is a predicted spawned object
If this is a predicted spawned object
If this object is inserted into the simulation
Returns the that has Input Authority over this network entity.
PlayerRefs are assigned in order from 0 to MaxPlayers-1 and are re-used as players join and leave.
The only caveat is that the server player (if one exists), always gets the last index no matter how many clients are connected.
Returns the that has State Authority over this network entity.
PlayerRefs are assigned in order from 0 to MaxPlayers-1 and are re-used as players join and leave.
The only caveat is that the server player (if one exists), always gets the last index no matter how many clients are connected.
The layers this object exists in for area of interest queries. This is an integer bitmask not a layer index.
Returns if is the designated Input Authority for this network entity.
Returns if is the designated State Authority for this network entity.
Returns if is neither the Input nor State Authority for this network entity.
Toggles if this NetworkObject is included in the , which will include the prefab in builds as a Spawnable object.
Gets a bitmask of flags, representing the current local authority over this .
Gets a bitmask of flags, representing the supplied RPC authority for this .
Sets which has Input Authority for this Object.
Removes input authority from whichever player has it for this object. Only valid when called on a Host or Server peer.
Add or remove specific player interest in this NetworkObject.
must be set to .
Copies the entire State from another
NetworkObject to copy the State from
Add or remove Player's interest in a specific named Interest Group for this .
must be set to .
A decoupled prefab reference. Internally stored as a GUID.
Network meta information for a .
The id of the root most , if this is nested.
Represents a base class for "prefab assets" - assets that point to a prefab and provide a way to load them.
Actual Unity prefab guid. If out of sync with the prefab's, it will be updated at first opportunity.
Placeholder kept after a prefab is removed or made not spawnable. If the prefab is restored/made spawnable again,
the type of this asset will change to .
Header data for this object
If we have a header or not
Data pointer to the first word of this objects data block
Adds prefab to the table and assigns it an id.
The id assigned to the prefab (if returns true) or id of the prefab with the same guid that has already been added.
True if the prefab prefab had unique guid and was added.
Flag constants for input and state authority.
Flags a method as being a networked Remote Procedure Call.
Only usable in a NetworkBehaviour.
Calls to this method (from the indicated allowed ) will generate a network message,
which will execute the method remotely on the indicated .
The RPC method can include an empty argument, that will include meta information about the RPC on the receiving peer.
Example:
| [Rpc(RpcSources.All, RpcTargets.All, InvokeLocal = false, InvokeResim = false, Channel = RpcChannel.Reliable, TickAligned = true)]
| public void RPC_Configure(NetworkObject no, string name, Color color, RpcInfo info = default) { }
To target a specific Player, use the :
| [Rpc]
| public void RpcFoo([RpcTarget] PlayerRef targetPlayer) {}
Use as a return value to access meta information about the RPC send attempt, such as failure to send reasons, message size, etc.
Non-static RPCs are only valid on a .
Static RPCs can be implemented on s, and do not require a instance.
Static RPC require the first argument to be NetworkRunner.
Static RPC Example:
| [Rpc]
| public static void RPC_Configure(NetworkRunner runner) { }
The legal types that can trigger this Rpc. Cast to int.
The types that will receive and invoke this method. Cast to int.
Indicates if the method should be called locally (on the RPC caller). This happens immediately.
Indicates if this RPC will execute during resims, or only once on the first execution of the associated tick.
Specifies which RpcChannel to use.
Indicates if this RPC's execution will be postponed until the local simulation catches up with the sender's Tick number.
Even if set to false, the order of Rpcs is always preserved. Rpcs are deferred until all preceding Rpcs have
executed.
Options for when the game is run in mode and RPC is invoked by the host.
The legal types that can trigger this Rpc
The types that will receive and invoke this method
Rpc order preserved, delivery verified, resend in case of a failed delivery.
Rpc order preserved, delivery not verified, no resend attempts.
Options for when the game is run in mode and RPC is invoked by the host.
If host invokes RPC will be set to (default).
If host invokes RPC will be set to the host's local player.
May be used as an optional return value. Contains meta data about the RPC send, such as failure to send reasons, culling, message size, etc.
Example:
| [Rpc]
| public RpcInvokeInfo RpcFoo(int value) {
| return default;
| }
|
| public override void FixedUpdateNetwork() {
| var info = RpcFoo();
| Debug.Log(info);
| }
Results for the local RPC Invocation of the RPC method.
RPC has been invoked locally.
Not invoked locally because is false.
Not invoked locally because is false and simulation stage is
Not invoked because source current authority does not match flags set in
Not invoked because target player is local and this current authority does not match flags set in
Not invoked because target player is not local.
Results for the RPC message send operation. Note: Some individual targets may be culled even if the send operation succeeds.
Information about culled targets can be found in .
RPC has been sent. Check for details.
Send culled because is false.
Send culled because source current authority does not match flags set in
Send culled because there are no active connections.
Send culled because target player does not exist.
Send culled because target player is local and is false.
RPC send operation result information.
Result flags for the RPC send operation.
The size of the RPC message.
Collection of the targets which were sent this RPC message.
Collection of the targets which were failed to be sent this RPC message.
Reason for failure can be found in the flags.
RPC attribute used to indicate a specific target player for an RPC when sending from one player to another.
RPC is sent to the server, and then is forwarded to the specified player.
Usage:
| [Rpc]
| public void RpcFoo([RpcTarget] PlayerRef targetPlayer) { }
Companion component for . Exposes as UnityEvents,
which can be wired up to other components in the inspector.
The core Fusion config file that is shared with all peers at startup.
Options for running one or multiple peers in one Unity instance.
Multiple is useful for testing multiple players/clients inside of the Unity editor without needing to build executables.
Each peer is assigned its own independent physics scene and instance.
This is the normal use case, where every build and the editor run a single server, host or client peer.
This is the optional use case, which allows running multiple peers in the Unity editor, or in a build.
Options for which Physics engines Fusion will use for simulations.
The Unity PhysX simulation is used, but auto-simulation is disabled and simulations are controlled by Fusion.
The Unity PhysX2D simulation is used, but auto-simulation is disabled and simulations are controlled by Fusion.
Fusion preforms no simulation calls.
Options for how physics is simulated on clients.
- Clients do not predict remote objects, and render in their remote time frame (relative past).
- Clients predict remote objects and have options for rendering them in local and/or remote time frames.
The server simulates and sends states to all clients. Clients do not attempt prediction and will render remote objects in the server (relative past) time frame.
The server simulates and sends states to all clients. Clients simulate remote states forward into the local time frame (prediction).
Spawn Modes while Scene is being loaded
Block all Spawns
Allow all Spawns
Queue spawn for when Scene is fully loaded
Delta Compression Implementations
Default Implementation
Burst Implementation
Debug Implementation
Default file name for the asset
Reference for the default
Current Type ID
Current version
Current version
Current Type ID
Setting for whether multiple peers can run per Unity instance (typically to allow easy testing of multiple peers inside of the editor).
Setting for which physics engine Fusion will simulate with.
Setting for which Fusion will use in server or host mode. Not used in shared mode.
Use lag compensation. Not used in shared mode.
Advanced lag compensation buffer settings.
Current
Current type
Signal if the callbacks should be invoked in Batch Mode
Max number of allowed
Signal if the of the should be included on the name of the
Enable the Support for Host Migration
Delay in seconds between each time the Host sends a Snapshot
of the current Simulation State to be used in the Host Migration
Reference for the current
Simulation Settings
Interpolation Settings
Network Settings
Settings for simulating network conditions of latency and loss.
Heap Settings
The named global accuracies used by this project.
Names of assemblies Fusion is going to weave. Not case sensetive.
Use Fusion.SerializableDictionary to store [Networked] dictionary properties initial value. If unchecked,
the weaver will emit System.Generic.Dictionary instead - a type that's not Unity-serializable, but custom
serializers (e.g. Odin) may support it.
If set, the weaver will add a check to all [Networked] properties on each
to verify if owing has been attached to.
Make a copy of the
ToString
Serialize the a NetworkProjectConfig into a JSON
NetworkProjectConfig reference
JSON String
Deserialize the NetworkProjectConfig based on the JSON Serialized version sent by the Room's Creator
JSON with a serialized NetworkProjectConfig
NetworkProjectConfig reference deserialized
Remove un-unecessary data from serialized version of
Get the version information for the Fusion.Runntime.dll.
Convert between to
Manages and references the current instance of
Get the version information for the Fusion.Runntime.dll.
Path to asset (created on demand if non-existent), which will serve as a host
for lightweight assets. They can be used to reference prefabs
alternatively to and regular references,
offering the best of two worlds: decoupling and Find References support.
Suggested path: Assets/Photon/Fusion/User/NetworkPrefabAssetCollection.asset
An auto-generated list containing source information (e.g. Resource path, address, static reference) for all the prefabs that can be spawned, i.e. the ones with
component and enabled.
Additional prefabs can registered at runtime with .
Represents a Server or Client Simulation.
Host Migration related code in order to get a copy of the Simulation State
All Scene related API and fields
Enumeration of Fusion.Runtime.dll options.
Use the Debug version of the Fusion.Runntime.dll.
Use the Debug version of the Fusion.Runntime.dll.
Initialization stages of Fusion
Runner is about to start
Runner is running
Runner is shutdown
Get Fusion.Runtime.dll build type.
Delegate type for on before spawned callback
Stores the Shutdown parameters used when requesting a Shutdown from inside a Runner Callback
Get enumerator for the collection of all s.
Completion Source for the startup Photon Cloud Operations
Change the visibility of this NetworkRunner when running in Multiple Peer Mode
Indicates if this is collecting .
The current topology used
Returns the for this .
Returns the flags for The type of network peer the associated represents.
Returns the current stage of this .
Returns the fixed tick time interval. Derived from the .
The time the current State represents (the most recent FixedUpdateNetwork simulation).
Use as an equivalent to Unity's Time.fixedTime.
Time is relative to Tick 0 (which represents Time 0f).
The current time (current State.Time + Simulation.DeltaTime) for predicted objects (objects in the local time frame).
Use as an equivalent to Unity's Time.time.
Time is relative to Tick 0 (which represents Time 0f).
The current time (current State.Time + Simulation.DeltaTime) for non-predicted objects (objects in a remote time frame).
Use as an equivalent to Unity's Time.time.
Time is relative to Tick 0 (which represents Time 0f).
Returns if this is valid and running.
If the runner is shutdown
Are we dealing with a regular, planned shutdown.
If the runner is pending to start
Returns if this represents a Client connection.
Returns if this Client is currently connected to a Remote Server
Returns if this represents a Server connection.
Returns true if this runner represents a Client or Host. Dedicated servers have no local player and will return false.
Returns true if this runner was started as single player (Started as with = 1).
If this is the last tick that is being executed this update
If this is the first tick that executes this update or re-simulation
If this is not a re-simulation but a new forward tick
If we are currently executing a client side prediction re-simulation.
The current state of the runner, if it's Starting, Running, Shutdown
Returns a for the local simulation. For a dedicated server will equal false.
PlayerRefs are assigned in order from 0 to MaxPlayers-1 and are re-used as players join and leave.
The only caveat is that the server player (if one exists), always gets the last index no matter how many clients are connected.
Returns the reference.
Returns how many ticks we executed last update.
Returns the collection of objects for this NetworkRunner's .
Returns the global instance of a lag compensation buffer .
Disconnect a player from the server
Player to disconnect
Connect this as a client to a Server.
Initiates a .
Starts using the supplied arguments.
Pauses the game in single player
Continues a paused game in single player
Sets the paused state in a single player
Add or remove Player's interest in a specific named Interest Group for a specific .
must be set to .
Gets Player's Actor Number (ID). Only usable in shared mode.
PlayerRef to get the Actor Number (ID)
Actor Number associated with the PlayerRef, otherwise null.
Gets Player's UserID. Only usable in shared mode.
PlayerRef to get the UserID
UserID if valid player found, otherwise null.
Sets the network object associated with this player
Gets the network object associated with a specific player
Network object if one is associated with the player
Returns the player round trip time (ping) in seconds
The player you want the round trip time for
Sends RPC message. Not meant to be used directly, ILWeaver calls this.
Sends RPC message. Not meant to be used directly, ILWeaver calls this.
Returns array of all registered with this .
Register an instance for callbacks from this .
Unregister an instance for callbacks from this .
Send an arbitrary data buffer to a target Player
Player that should receive the buffer
Buffer to be sent
Send an arbitrary data buffer to the Server
Buffer to be sent
Flags this player as always interested in this object. Means it does not have to be in a players area of interest to be replicated.
The player
The object
If he's always interested, or not.
Adds a area of interest radius for a specific player at a position. A player can have several areas of interests added. Needs to be called every frame.
The player
Center position of the area of interest
Radius of the area of interest
Returns the data from player, converted to the indicated .
Returns the unconverted unsafe for the indicated player.
Outputs the from player, translated to the indicated .
Get the instance for this from a .
null if object cannot be found.
Get the instance for this from a .
True if object was found.
Get the instance for this from a .
True if object was found.
Gets the for the current stage. For use in the .Render() callback.
Indicate if the start and end ticks should represent predicted, or state snapshots.
Tries to return the first instance of T found on the root of a .
Returns the found component. Null if the cannot be found, or if T cannot be found on the GameObject.
Returns if the contains a reference to a in the current State .
Returns if the contains a with given in the current State .
Returns if the contains a reference to a in the specified State .
Attempts to network instantiate a using a Component type that is part of a
Must be a Type derived from
used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Attempts to network instantiate a using a prefab.
Note: position and rotation values are only used locally for the instantiation of the object, and are not inherently networked.
Use , or any of its derived classes such as to replicate the initial transform state.
Prefab used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Attempts to network instantiate a using a .
Note: position and rotation values are only used locally for the instantiation of the object, and are not inherently networked.
Use , or any of its derived classes such as to replicate the initial transform state.
Prefab Ref used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Attempts to network instantiate a using a
Note: position and rotation values are only used locally for the instantiation of the object, and are not inherently networked.
Use , or any of its derived classes such as to replicate the initial transform state.
Prefab Asset used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Attempts to network instantiate a using a
Note: position and rotation values are only used locally for the instantiation of the object, and are not inherently networked.
Use , or any of its derived classes such as to replicate the initial transform state.
Object Guid used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Attempts to network instantiate a using a
Note: position and rotation values are only used locally for the instantiation of the object, and are not inherently networked.
Use , or any of its derived classes such as to replicate the initial transform state.
Prefab ID used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Destroys a .
Ensures that a specific component exists on this gameobject.
Removes a specific from this gameobject, if it exists.
Register a instance with the .
Unregister a instance from the callbacks.
Attaches a user created network object to the network
The object to attach
If assigned who is the default input authority for this object
Attempts to network instantiate a using a
Note: position and rotation values are only used locally for the instantiation of the object, and are not inherently networked.
Use , or any of its derived classes such as to replicate the initial transform state.
Prefab ID used to spawn the
Spawn Position
Spawn Rotation
Player Input Authority
reference
reference
reference, or null if it was not able to spawn the object
Signal if Fusion was initilized with Host Migration system enabled
if this instance is a resume (host migration)
Iterate over the old NetworkObjects from the Resume Snapshot
Iterable list of
Get the next NetworkID used while resuming the simulation
Gets a temporary representation of a from the old Server Snapshot
Setup Host Migration information
Start the Host Migration process
Base Snapshot to be used when restarting the Host
Recurring Service method that will check if the Job responsible for computing
the Server Snapshot has finished the process and will push the result for later use
Start the Snapshot build using an async process
This will return a Task that can be awaited witht the result of the operation
Await Task that will complete with the Snapshot computation
Creates a Job to build the Server Simulation Snapshot
Ready to use
Signal the Host Migration process has started
Unity Job responsible for computing a Server Snapshot
Signal if the Local Peer is connected to Photon Cloud and is able to Create/Join Room but also receive Lobby Updates
Photon Client UserID
Returns null if Peer is not connected to Photon Cloud
used by this Runner to Authenticate the local peer.
Current Game Mode active on the Fusion Simulation
Stores information about the current running session
Check the current Connection Type with the Remote Server
Exposes the current NAT Type from the local Peer
Signal if the Local Peer is in a Room and is the Room Master Client
Completion Source for the startup Photon Cloud Operations
Responsible to manage the Photon Cloud related Services
Join the Peer to a specific Lobby, either a prebuild or a custom one
Lobby Type to Join
Lobby ID
Authentication Values used to authenticate this peer
Custom Photon Application Settings
Async Task to Join a Session Lobby. Can be used to wait for the process to be finished.
Starts the local Fusion Runner and takes care of all major setup necessary
Custom arguments used to setup the Fusion Simulation
Task that can be awaited to chain actions
Connect the local peer to Photon Cloud using an async process.
Authentication Values used to authenticate this peer
Custom Photon Application Settings
External Communicator that will be reused on restart
Async Task of the connect to Photon Cloud process. Can be used to wait for the process to be finished.
Disconnect the Peer from Photon Cloud
If the Cloud Services were not initialized, it just returns immediately
Start Fusion in Single Player Mode
Initialization Arguments
A running Task of the initialization process
Start Fusion in one of the Cloud Game Modes
Initialization Arguments
A running Task of the initialization process
Shutdown the Fusion Runner based on a arbitrary Exception
Exception used as base for the Shutdown procedure
Awaitable Task of the Shutdown procedure
Signal an update on the list of
New Session Info
Signal an update on the list of
Custom Authentication Response
Returns the current loaded network scene.
Returns the Unity scene for this . With , multiple physics scenes may exist, and this getter should be used in place of SceneManager.GetActiveScene().
A scene used when run in mode.
Signal if this Runner is already in a Temp Physics Scene
Update the current Active Scene
to be activated
Invoke on all implementations
Invoke on all implementations
Get the a GameObject instance belongs to.
GameObject to check for a
reference, or null if not found
Get the from a specific Scene
Scene to check for a
reference, or null if not found
Try to create a temp empty scene for PhysicsScene
false if the runner was on the temp scene already, true otherwise.
Get the 3D Physics scene being used by this Runner.
Get the 2D Physics scene being used by this Runner.
Instantiates an object in the scene of this runner
Instantiates an object in the scene of this runner
Instantiates an object in the scene of this runner
Instantiates an object in the scene of this runner
Moves an object to the scene of this runner
Component of object to move
Moves an object to the scene of this runner
Object to move
If running in peer mode and the current active
scene is different than , switches active scene to ,
stores the previous active scene in and returns true.
Returns false otherwise.
True if an actual change occurred.
Retrieve the associated with an specific Scene
Scene handler to check
reference, or null if not found
Transitory Holder with all necessary information to restart the Fusion Runner
after the Host Migration has completed
New GameMode the local peer will assume after the Host Migration
Fusion Start Arguments, used to configure the
simulation mode and other settings
Game Mode in which this peer will start
Photon Cloud Session Name used either to Create or Join a Session
Binding Address
Object pool to use
Custom reference
Custom used to start the simulation
Number of players allowed to connect to this peer, when running in Server Mode
Scene that will be set as the starting Scene when running in Server Mode
Callback that is invoked when the Fusion has fully started
Flag to disable the NAT Punchthrough implementation and connect only via Relay
User defined callback interfaces we will provide O(1) constant time lookup for
Connection token sent by client to server. Not used in shared mode.
Custom Session Properties.
This dictionary can be used to either setup the initial Session Properties when creating a Session
but also to set the matchmaking filters when joining a Random Session.
Session Custom Lobby to be published in
Specify a Custom STUN Server used to Resolve the peer Reflexive Addresses
Custom Authentication Data
Custom Photon Application Settings
Disables the Session creation when starting a Client with an specific Session Name
Host Migration Token used when restarting the Fusion Simulation
Callback invoked when the new Host is migrating from the old Host state
Fusion Game Mode.
Used to select how the local simulation will act.
Single Player Mode: it works very similar to Mode, but don't accept any connections.
Shared Mode: starts a Game Client, which will connect to a Game Server running in the Photon Cloud using the Fusion Plugin.
Server Mode: starts a Dedicated Game Server with no local player.
Host Mode: starts a Game Server and allows a local player.
Client Mode: starts a Game Client, which will connect to a peer in either or Modes.
Automatically start as Host or Client. The first peer to connect to a room will be started as a Host, all others will connect as clients.
Defines the type of the current connection with the Remote Peer,
either the Server or a Client
No connection is currently active
Connection was accomplished using the Photon Relay Services
Connection was accomplished directly with the remote peer
Session Lobby Type
Invalid Session Lobby Type
ClientServer Lobby
Shared Lobby
Custom Lobby - works in conjuction with a Lobby Name/ID
Holds information about the Game Session
Flag to signal if the is ready for use
Stores the current Room Name
Stores the current connected Region
Signal if the current connected Room is visible
Signal if the current connected Room is open
Room Custom Properties
Current number of peers inside this Session, this includes the Server/Host and Clients
Max number of peer that can join this Session, this value always include an extra slot for the Server/Host
Check if the reference is not Null and is Valid.
Update or change the Custom Properties of the current joined Room
New custom properties
String representation of a
Formatted
Represents the result of starting the Fusion Simulation
Signal if the Start was OK
Start Game Shutdown Reason
StartGameResult to String
Describe an Exception that Occurred while starting the Fusion Simulation
ShutdownReason that caused this exception
StartGameException to String
Convert arbitrary Exceptions into a StartGameException to public use
Exception to be converted
Reference to a StartGameException holding a ShutdownReason
Stores data types used on the interface
Data holder of a Connection Request from a remote client
Address of the remote client
Accepts the Request
Refuses the Request
Describes a list of Reason why the Fusion Runner was Shutdown
OK Reason means Fusion was Shutdown by request
Shutdown was caused by some internal error
Raised when the peer tries to Join a Room with a mismatching type between ClientServer Mode and Shared Mode.
Raised when the local peer started as a Server and tried to join a Room that already has a Server peer.
Raised when the Peer is disconnected or kicked by a Plugin Logic.
Raised when the Game the Peer is trying to Join is Closed
Raised when the Game the Peer is trying to Join does not exist
Raised when all CCU available for the Photon Application are in use
Raised when the peer is trying to connect to an unavailable or non-existent Region
Raised when a Session with the same name was already created
Raised when a peer is trying to join a Room with already the max capacity of players
Raised when the Authentication Values are invalid
Raised when the Custom Authentication has failed for some other reason
Raised when the Authentication Ticket has expired
Timeout on the Connection with the Photon Cloud
Raised when Fusion is already running and the StartGame is invoked again
Raised when any of the StartGame arguments does not meet the requirements
Signal this Runner is shutting down because of a Host Migration is about to happen
Interface for callbacks.
Register a class/struct instance which implements this interface with .
Callback from a when a new player has joined.
Callback from a when a player has disconnected.
Callback from that polls for user inputs.
The that is supplied expects:
input.Set(new CustomINetworkInput() { /* your values */ });
Called when the runner is shutdown
The runner being shutdown
Describes the reason Fusion was Shutdown
Callback when successfully connects to a server or host.
Callback when disconnects from a server or host.
Callback when receives a Connection Request from a Remote Client
Local NetworkRunner
Request information
Request Token
Callback when fails to connect to a server or host.
This callback is invoked when a manually dispatched simulation message is received from a remote peer
The runner this message is for
The message pointer
This callback is invoked when a new List of Sessions is received from Photon Cloud
The runner this object exists on
Updated list of Session
Callback is invoked when the Authentication procedure returns a response from the Authentication Server
The runner this object exists on
Custom Authentication Reply Values
Callback is invoked when the Host Migration process has started
The runner this object exists on
Migration Token that stores all necessary information to restart the Fusion Runner
Class that contains global accuracy information.
Built-in named defaults can be edited, or custom named defaults can be created.
These defaults allow you to change accuracy settings across an entire project.
These values can be changed in the .
The named built-in default for Uncompressed. This cannot be changed and will always have a value of 0.
The named built-in general default.
The named built-in default for Position.
This value is used by built-in components like and ,
but may be used for your own components as well.
The named built-in default for Rotation.
This value is used by built-in components like and ,
but may be used for your own components as well.
The named built-in default for NormalizedTime.
This value is used by built-in components like ,
but may be used for your own components as well.
The standard default fall back value for Accuracy.
The fixed value that represents uncompressed.
Which hash should a hash value of zero (the struct default value) remap to.
Which tag name should a zero hash (the struct default value) remap to.
Which accuracy value should a zero hash (the struct default value) remap to.
Attempts to get an accuracy from a hash value.
Returns false if the hash is invalid (hash 0 is considered valid, and remaps to )
Main simulation class
Use inside of FixedUpdateNetwork to determine if the tick currently being simulated has previously been simulated locally.
Resimulation occurs in client prediction when new states arrive from the StateAuthority.
Networked objects are set to the most current authority state tick, and simulations are repeated from that tick to the local current tick.
Use in conjunction with IsResimulation/IsForward inside of FixedUpdateNetwork to determine if the current tick being simulated
is the last tick of the resimulation or forward phase of the simulation loop.
'Resimulation' describes simulating a tick that has been previously been simulated.
'Forward' describes simulating a tick that is being simulated for the first time locally.
'Prediction' describes simulating ticks higher than the most current known StateAuthority snapshot tick.
Use in conjunction with IsResimulation/IsForward inside of FixedUpdateNetwork to determine if the current tick being simulated
is the first tick of the resimulation or forward phase of the simulation loop.
'Resimulation' describes simulating a tick that has been previously been simulated.
'Forward' describes simulating a tick that is being simulated for the first time locally.
'Prediction' describes simulating ticks higher than the most current known StateAuthority snapshot tick.
Use inside of FixedUpdateNetwork to determine if the tick currently being simulated has NOT previously been simulated locally.
True if the current stage of the simulation loop is Forward. False during resimulations.
'Resimulation' describes simulating a tick that has been previously been simulated.
'Forward' describes simulating a tick that is being simulated for the first time locally.
'Prediction' describes simulating ticks higher than the most current known StateAuthority snapshot tick.
The tick associated with the current state of networked objects.
Indicates if a Server/Client or Shared Mode (relay server) topology is being used.
Gets the flags for The type of network peer this simulation represents.
Gets the current value.
The file used by this .
The file used by this .
Gets the fixed tick time interval. Derived from the .
If this peer is a client. True for client peers in Server/Client topologies, and true for all peers in Shared Mode.
If this peer is the server. True for the Server or Host peer in Server/Client topologies, and always false for all peers in Shared Mode (the relay is the server).
True for any peer that represents a human player. This is true for all peers except a dedicated server.
Indicates that this simulation is operating in Single Player mode, which is a Host that accepts no connections.
Only valid in Shared Mode. Indicates if this peer is flagged as the MasterClient, which means it is default StateAuthority
Signal if the Simulation is currently running
Bound Address of the internal socket
Add or remove specific player interest in a NetworkObject.
must be set to .
Forwards the Simulation based on the Delta Time
Delta Time used to forward the simulation
How many Ticks executed on this Update
Engine sources for statistics.
telemetry available for the sockets layer.
as Flags.
telemetry available for a .
as Flags.
telemetry available for .
as Flags.
Returns the requested associated with this .
Returns the requested associated with this .
Result flags for the RPC message send operation.
Client sent to the server, server will send to the target client.
Server sent to a specific client (a targeted message).
Server attempted to send to all the clients and at least one succeeded.
Target object not confirmed on the client.
Target object not in client's interest. Likely due to being outside of player's AOI region, or needs to be explicitly set as always interested.
Target client not connected (a targeted message).
Server attempted to send to all the clients, but none was connected.
Server attempted to send to all the clients, but the target object is not confirmed/not in Object Interest for all target clients.
Project configuration settings specific to how the Simulation class behaves.
Classic server and client model
Relay based shared world model
Enumerates the types of state replication available.
Server Authoritative, Delta Snapshots send the complete world state from every network tick. This produces the highest accuracy simulation replication,
but may not be suitable for higher object and player counts.
Server Authoritative, Eventual Consistency allows for partial/culled state transmission, which may be necessary for implementing Area of Interest,
high networked object counts, or high player counts.
The update rate of the simulation in Hz (ticks per second).
The default number of players allowed to join a game instance. Can also be changed in code when starting Fusion.
Determines which mode will be used.
The topology used
If, in host mode, we should allow host migration if the current host leaves.
Selects if Object Interest should be used when running in mode.
When enabled, clients will only receive updates for objects which they have interest in.
How interest is determined for each is based on its mode setting.
Uses area of interest queries to cull execution of Fixed Update Network for objects outside of any players area of interest.
Returns the inverse of TickRate. The time (in seconds) between simulation ticks.
Returns ( * ).
This value times TickRate determines the network send rate for the server.
A value of 1 instructs the server to send state updates to clients every simulation tick.
Values greater than 1 will send a input/state updates every N ticks.
Higher values reduce data usage, in exchange for increased latency and reduced state sync accuracy.
This value times TickRate determines the network send rate for clients.
A value of 1 instructs clients to send input/state updates to the server every simulation tick.
Values greater than 1 will send an update every N ticks.
Higher values reduce data usage, in exchange for increased latency and reduced state sync accuracy.
Returns ( * ). This is the effective time interval (in seconds) between server tick updates to clients.
Returns ( * ). This is the effective time interval (in seconds) between client input/state updates from the client.
Memory Heap Settings
Default size of each Heap Page
Default number of Heap Pages
Heap Global Size
Initializes and creates a new based on the Global Size
ToString
How much the delta time is modulated up/down to adjust interpolation time
when the client has ended up behind or ahead of the server. Common values
are 1% to 3%, the lower the tick rate the higher this should be.
Default value is 1%.
How much the actual interpolation time is allowed to drift up/down from the calculated optimal time
before adjustments to the interpolation time is made. Defined in % of optimal interpolation time.
For example with a 25% value and an optimal interpolation time of 0.1 seconds, the actual interpolation time
is allowed to very between 0.75-0.125 before adjustments are made to it.
Default value is 25%.
How much actual interpolation time is allowed to drift up/down from calculated optimal time
before the time calculations are reset and snapped to the optimal value.
Defined in % of optimal time. Common values are 200% to 500%.
Default value is 200%.
The minimum multiplier that is used to compensate for jitter and uncertainty when calculating optimal interpolation offset.
This multiplier is used to give some extra interpolation offset from the absolutely optimal time.
Same as the Multiplier Min, just the max value instead.
Main network configuration class.
Flag for allowed Reliable Data transfer modes.
Allow Client to Server.
Allow Client to Client using Server as Proxy.
Size in Kilobytes of the underlying socket send buffer.
Size in Kilobytes of the underlying socket receive buffer.
Max number of connection attempts that a Client will run when trying to connect to a remote Server.
Interval in seconds between each connection attempt from a Client.
Default assumed RTT in seconds for new connections (before actual RTT has been determined). The real RTT is calculated over time once the connection is established.
Max allowed time in seconds that the local peer can run without receiving any update from a remote peer.
If a client does not receive any update from the server within this period, it will disconnect itself.
If a server does not receive any update from a remote client within this period, it will disconnect that particular client.
Interval in seconds between PING messages sent to a remote connection, in order to keep that connection alive.
Currently unused.
Default delay between connection changes status to Shutdown (disconnected/invalid), and it actually being released (freeing all references to that particular connection).
Max number of bytes that can be used by Fusion to fill up a UDP package.
Current mode.
Initializes and creates a copy of this .
Convert this into a using the as reference.
Configuration for network conditions simulation (induced latency and loss).
If adverse network conditions are being simulated.
The pattern used to oscillate between and values.
The lowest packet delay value returned from the oscillator.
The highest packet delay value returned from the oscillator.
The period of the oscillator (the rate at which delay oscillates between and ).
The oscillates between 0 and 1. Values below this threshold are reduced to zero, resulting in a value equal to .
After the delay value from the oscillator is determined, random 0 to this value of additional seconds be added to the packet latency.
The pattern used to oscillate between and values.
The lowest loss chance value the oscillator will produce. 0 = 0% chance of being lost. 1 = 100% chance of being lost.
The highest loss chance value the oscillator will produce. 0 = 0% chance of being lost. 1 = 100% chance of being lost.
The wave oscillates between 0 and 1. Values below this threshold are reduced to zero, resulting in a value equal to .
The period of the oscillator (the rate at which delay oscillates between and ).
After the oscillation loss calculated, an additional 0 to this (normalized) percentage of loss chance is added.
Stores the global state of a simulation
Total size of the Global State in 4 byte words
Total size of the Global State
Current Scene Ref
Current Simulation Mode
Current player count
Flags for The type of network peer a simulation represents.
Simulation represents a server peer, with no local player.
Simulation represents a server peer, with a local player.
Simulation represents a client peer, with a local player.
Represents a snapshot of the simulation state
The absolute tick index this snapshot represents.
The time in seconds this represents.
Time is relative to 0, with Tick 0 representing Time 0f.
Flags for which stage the simulation currently running. Forward is when a tick is being simulated for the first time.
Resimulate is when a tick is being simulated again with corrections.
Currently simulating a tick for the first time.
Currently simulating a previously simulated tick again, with state corrections.