Please enable JavaScript.

Coggle requires JavaScript to display documents.

FUSION - Coggle Diagram

- - - - keeps track
        
        NetworkObjects
        
        NetworkBehaviours
        
        SimulationBehaviours.
      - manages the connection to the network and controls the simulation
        
        gathering input
        
        merging snapshots
        
        invoking callbacks and life-cycle methods on SimulationBehaviours.
      - only ever one in the scene on each client and server.
    - - All NetworkBehaviours can access the current NetworkRunner via the Runner property, and the Runner itself exposes some important system properties.
        
        IsServer
        
        : true if this runner represent an authoritative server.
        
        Stage
        
        : the current stage of the simulation.
        
        Forward
        
        the simulation is currently predicting the next state
        
        Resimulate
        
        the simulation is re-simulating an old state to reconcile a server update.
        
        Resimulate never occur on the server or in Client-Authority mode where simulation is always Forward.
    - - The NetworkRunner hook into important network related events by INetworkRunnerCallbacks interface and registering the script with the runner by calling NetworkRunner.AddCallbacks().
      - automatically register any SimulationBehaviour implementing the INetworkRunnerCallbacks interface located on the same object as the NetworkRunner a callback target.
      - most important callbacks
        
        OnServerConnected
        
        OnPlayerJoined
        
        which is where the game will spawn initial player objects:
  - - - client:
        
        runs as client, creates a local player, to connect to a client host (cloud-shared) or dedicated (server-based)
      - host:
        
        runs as server, creates a local player (Server + Client)
      - server
        
        : runs as dedicated server, no player
      - shared:
        
        runs as client, creates a local player, to connect to the Fusion Plugin Server
      - single
        
        : runs as "server", creates a local player, no connections allowed (Singleplayer)
  - - - Erratic
    - - Common Behaviour
  - - - In the pre-built NetworkCharacterController, Move() requests the movementPack values from ComputeRawMovement() by passing a reference to the struct to be filled out.
  - - - direction
        
        : Intended movement direction, subject to movement query + acceleration.
      - callback
        
        : Optional custom callbacks object.
      - layerMask
        
        : Optional layermask. If not passed, the default one from Config will be used.
  - - - getting an object
      - returning a used object
  - - - register individual event handlers.
- - - - Package Loss
        
        One time :red_cross:
        
        Continuos change :check:
  - - - parameter which respects the type constraints outlined in Network Object > NetworkBehaviour > Networked State > Constraints entry.
      - RPC_ prefix convention
      - Define
        
        Declare a regular CSharp method of return type void;
        
        Add the [Rpc] attribute in front of the method declaration; and,
        
        Configure the RpcSources and RpcTargets parameters to control where the RPC may be called from and where it gets executed.
    - - ignore the RpcSources and RpcTargets parameters; and
      - require the first parameter of the method to be NetworkRunner.
    - - The [RpcTarget] attribute used within the method the declaration is DIFFERENT from the RpcTargets parameter inside the [Rpc] attribute placed in front of the method declaration.
      - specific player's machine,
      - RPCs and Static RPCs can be turned into targeted RPCs by adding a PlayerRef parameter prefaced by the [RpcTarget] attribute
  - - - All:
        
        can be sent / is executed by all peers in the session (including the server).
      - Proxies
        
        : can be sent / is executed by a peer who does not have either Input Authority or State Authority over the object.
      - InputAuthority:
        
        can be sent / is executed by the peer with Input Authority over the object.
      - StateAuthority
        
        : can be sent / is executed by the peer with State Authority over the object.
      - The RpcSources
        
        define which peer can send :textthe RPC
      - RpcTargets
        
        define on which it is executed.
    - - Channel (default Reliable):
        
        Set to Unreliable if the RPC can be lost in transmission.
      - InvokeLocal (default true):
        
        Set to false if the RPC is not to be invoked on the local client.
      - InvokeResim (default false):
        
        Set to true if the RPC is not to be invoked during re-simulations.
      - RpcInfo.
        
        Source: which player (PlayerRef) sent it.
        
        Channel: was it sent as an Unreliable or Reliable RPC.
        
        IsInvokeLocal: was it the local player who originally invoked this RPC.
        
        Tick: at which tick was it sent.
- - - - inherit from INetworkInput;
      - only primitive types and structs;
      - top-level structs (i.e. cannot be nested in a class)
      - NetworkBool
        
        serialize it as a single bit.
    - - permits the use of different structs for different play modes or different parts of the game.
      - When unwrapping the input, Fusion will only return the available input of the correct type.
    - - There is a special NetworkButtons type which provides a convenient wrapper for saving button presses in a INetworkInput struct.
      - Add buttons
        
        Create an enum for the buttons ( Important: it must be explicitly defined and start at 0)
        
        enum MyButtons {
        
        Forward = 0,
        
        Backward = 1,
        
        Left = 2,
        
        Right = 3,
        
        Add a NetworkButtons variable to the INetworkedInput.
      - assigning and reading values
        
        void Set(int button, bool state): takes the enum value for the button and its state (pressed = true, not pressed = false);
        
        bool IsSet(int button): takes takes the enum value for the button and returns its boolean state.
      - The NetworkButtons type stateles, does not hold any meta data about the previous state of the buttons.
        
        possible to compare the current state of the buttons with their previous state
        
        NetworkButtons GetPressed(NetworkButtons previous): returns a set of values for all buttons which have just been pressed.
        
        NetworkButtons GetReleased(NetworkButtons previous): returns a set of values for all buttons which have just been released.
        
        (NetworkButtons, NetworkButtons) GetPressedOrReleased(NetworkButtons previous): returns a tuple of values for buttons which have been just pressed and released.
        
        evaluate whether the buttons have just been pressed or released.
        
        Only use Input.GetKey() to assign button values.
        
        GetKeyDown() :forbidden:
        
        GetKeyUp() :forbidden:
        
        not synchronised with the Fusion ticks might be missed.
        
        In order to be able to use the next set of methods offered by NetworkButtons, it is necessary to keep track of the previous state of the buttons; this is easily done by creating a [Networked] version of the previous state for each player.
    - - only transmit data changes.
        
        not affect bandwidth usage
      - flags
      - buttons
      - fine to include rarely used fields
  - - - Fusion automatically calls OnInput() on all SimulationBehaviour and NetworkBehaviour components implementing the INetworkRunnerCallbacks interface and over which the client has Input Authority - hence the name.
  - - - Implement INetworkRunnerCallbacks and OnInput(); and,
      - Register the script with the NetworkRunner by calling AddCallbacks() on it.
  - - - It is not possible to read the input one client on another. changes relying on input need to be saved as a [Networked] state to be replicated on other clients.
      - In the HostMode and ServerMode this means the player client and the host / server,
      - in SharedMode this is one and the same client.
    - - GetInput(out T input) in the FixedUpdateNetwork() of on any NetworkBehaviour which has Input Authority
      - The call to GetInput() will return false if:
        
        the client does not have State Authority or Input Authority
        
        the requested type of input does not exist in the simulation
      - The call to GetInput() provides the same input struct that was previously populated in OnInput().
    - - It is possible to read the input from outside a NetworkBehaviour by calling NetworkRunner.TryGetInputForPlayer<T>(PlayerRef playerRef, out var input). In addition to the INetworkInput type, it requires specifying the player for which the input should be retrieved. N.B.: The limitations as for GetInput() apply; i.e. on the client with input authority or Server / Host can get the input for the specified player.
  - - - For instance, the following split would be used for firing a bullet:
        
        OnInput(): Save the value of the firing button for the player.
        
        GetInput(): Check if the firing button was pressed and shot the bullet if it was.
      - Collect input values in OnInput() when populating the input struct
      - The logic based to be executed based on the input should be done completely in the GetInput().
- - - - IterpolationSpace
- - - - NetworkObject component
        
        network-wide unique identifier
        
        synchronize networked state
      - Runner.Spawn() method.
        
        new object instance to the collective network state.
      - NOT use Unity's GameObject.Instantiate() and GameObject.Destroy() :forbidden:
        
        local game object which is completely detached from the Fusion simulation loop with a broken network state.
    - - Parameters
        
        Prefab of type NetworkObject.
        
        Position
        
        Rotation
        
        PlayerRef
        
        client with input authority
        
        NetworkRunner.OnBeforeSpawned
        
        run before replicating the object on the other instances
        
        NetworkObjectPredictionKey
        
        predicted spawn.
        
        Only the prefab is a mandatory parameter, all others are optional.
      - Network topology.
        
        On the server, in hosted or client/server
        
        ownership server, and the object is created and returned immediately.
        
        Clients will receive the object as part of the next snapshot.
        
        On a client in hosted or client/server mode,
        
        nothing will happen and that the call will return null.
        
        "Predictive Spawning".
        
        In shared mode,
        
        State Authority is always assigned to the caller and, again, the instance is returned immediately.
        
        Other clients will receive the object eventually.
        
        Spawn should be called from FixedUpdateNetwork and it is ok to call during both Forward and Re-simulation stages. Fusion will correctly return the same object during re-simulation of predicted local spawns (assuming the prediction key matches), while authoritative spawns only happen in shared mode or on the Host, neither of which does re-simulation.
      - = Instantiate
    - - PlayerRef
        
        Input
      - If the object does not require input or no client has input authority over it, null can be passed instead.
    - - The NetworkRunner.OnBeforeSpawned parameter can take a method or lambda expression matching the delegate signature.
      - invoked after :the object is created but before it gets synchronized across all instances.
        
        initialize custom network properties.
    - - Fusion first learns of the object's existence.
        
        For spawns on a peer with State Authority, Spawned() is called immediately after Runner.Spawn().
        
        For predicted spawns on a peer with Input Authority, Spawned() is called when network state is allocated (i.e. when the spawn is confirmed).
        
        For proxies (i.e. object over which the peer has neither Input Authority nor State Authority), Spawned() is called when Fusion receives a network state with an object that does not exist locally.
        
        In particular a late-joiner will likely receive objects that were spawned a long time ago and the original state from their "birth tick" no longer be relevance.
        
        If a state should be initialized at spawn, use the pre-spawn NetworkRunner.OnBeforeSpawned callback supplied to Runner.Spawn().
        
        Not Tick Aligned
        
        initialize Networked state :forbidden:
        
        Send RPC :forbidden:
      - resetting non-networked variables and sub-systems
      - Object Pooling
        
        reset values to their prefab defaults
    - - Remove a network object, the peer with State Authority over the object may call Runner.Despawn().
      - Despawned
        
        Despawn() will result in the Despawned() method to be called for classes implementing IDespawned.
        
        All NetworkBehaviours imlement IDespawned, whereas SimulationBehaviours have to add it explicitly.
    - - Host / Server Mode
      - non-authoritative client
        
        simulate a local placeholder
        
        Successful :check:
        
        Failed :red_cross:
        
        predict the future existence of an object
      - Need
        
        unique ID
        
        match temporary local object against a future "actual" instance.
        
        upgrade the local object to a first class network object when confirmed.
        
        The client must handle the local object as such until it is either confirmed or cancelled.
      - NetworkObjectPredictionKey
        
        consists 4 bytes. free to invent its own keys considering
        
        same on the client and the authoritative host/server,
        
        Random :red_cross:
        
        Local Data :red_cross:
        
        Unique for the player and the current tick.
        
        Tick :check:
        
        Player ID :check:
        
        multiple networked objects predictively spawned by a client during the same tick,
        
        additional information
        
        shared counter
        
        tell apart
      - IPredictedSpawnBehaviour
        
        IPredictedSpawnBehaviour interface.
        
        predicted state,
        
        Fusion simulation :forbidden:
        
        networked properties :forbidden:
      - Spawned, Update, Render
        
        The three first methods match the Spawned(), FixedUpdateNetwork() and Render() methods found in functional SimulationBehaviour and NetworkBehaviour components. They are called under the same conditions as those methods with the difference that these are exclusively and explicitly called when the object is in its "predicted" state.
        
        In fact, one possible implementation of those methods is to simply call Spawned(), FixedUpdateNetwork() and Render(), respectively, though the application needs to consider that network properties are not available. One solution to that is to wrap the networked properties with a check for predictive spawning and maintain two sets of variables, like this:
    - - Fail :red_cross:
        
        Runner.Despawn()
        
        temporary object return Object Pool
        
        Bool Predicted state
      - Success :check:
        
        Temporary object is simply promoted to a fully networked