Fish-Networking

https://fish-networking.gitbook.io/docs
Admin
Fish-Networking is a free, versatile, and server-authoritative networking solution for Unity,...
Tokens:113,756
Snippets:1,018
Trust Score:10
Update:10 months ago
Show doc for...
Tokens:
Raw
### Listen for Starting Scene Load Event (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/simple/making-a-custom-player-spawner/on-scene-load

This C# code demonstrates how to subscribe and unsubscribe to the `SceneManager.OnClientLoadedStartScenes` event within the `OnStartServer` and `OnStopServer` methods. This is crucial for correctly spawning players in scenes that are loaded as part of the client's initial setup.

```csharp
public override void OnStartServer()
{
    SceneManager.OnClientLoadedStartScenes += OnClientLoadedStartScenes;
}

public override void OnStopServer()
{
    if (SceneManager != null)
        SceneManager.OnClientLoadedStartScenes -= OnClientLoadedStartScenes;
}
```

--------------------------------

### Initialize SyncStopwatch

Source: https://fish-networking.gitbook.io/docs/guides/features/network-communication/synchronizing/syncstopwatch

Demonstrates the initialization of a private SyncStopwatch variable. This is the basic setup required before using any SyncStopwatch functionalities. No external dependencies are required beyond the Fish-Net library.

```csharp
private readonly SyncStopwatch _timePassed = new()
```

--------------------------------

### Manage FishNet Connections with C#

Source: https://fish-networking.gitbook.io/docs/tutorials/simple/starting-fishnets-connections

This C# script manages FishNet connections, allowing the user to start the server, client, or host (both server and client). It also provides functionality to set the IP address for the client to connect to. This script does not inherit from NetworkBehaviour as it's intended to operate before and after network initialization.

```csharp
using FishNet.Managing;
using UnityEngine;

public class ConnectionManager : MonoBehaviour
{
    [SerializeField] NetworkManager networkManager;

    // A host is simply a server and a client, so start them both.
    public void StartHost()
    {
        StartServer();
        StartClient();
    }

    // The server can be started directly from the ServerManager or Transport
    public void StartServer()
    {
        networkManager.ServerManager.StartConnection();
    }

    // The client can be started directly from the ClientManager or Transport
    public void StartClient()
    {
        networkManager.ClientManager.StartConnection();
    }

    // This is set on the Transport to indicate where the client should connect.
    public void SetIPAddress(string text)
    {
        networkManager.TransportManager.Transport.SetClientAddress(text);
    }
}
```

--------------------------------

### Mirror vs. Fish-Networking: Component Replacement Example

Source: https://fish-networking.gitbook.io/docs/guides/upgrading-to-fish-net

This section highlights the component changes between Mirror and Fish-Networking, specifically focusing on Interest Management and NetworkIdentity. It suggests using the Fish-Networking upgrade tool for efficient component swapping.

```csharp
//Mirror example:
//Interest Management
//NetworkIdentity

//Fish-Networking example:
//ObserverManager see also: NetworkObserver
//NetworkObject

//Notes: Both support multiple conditions.
//Notes: Changing out components can be a tedious task. Save time by using Window -> Fish-Networking -> Upgrading -> From Mirror -> Replace Components. This will swap out most components for you.
//Mirror and Fish-Networking must be within your project to run the operation mentioned. Afterwards you may remove Mirror.
```

--------------------------------

### Implement OnStartNetwork Callback in C#

Source: https://fish-networking.gitbook.io/docs/guides/features/networked-gameobjects-and-scripts/network-behaviour-guides

Shows how to use the OnStartNetwork callback for initialization logic that needs to run on both the server and client. This method is called only once, even in clientHost scenarios, and is useful for shared setup tasks.

```csharp
public override void OnStartNetwork()
{
    /* If you wish to check for ownership inside
    * this method do not use base.IsOwner, use
    * the code below instead. This difference exist
    * to support a clientHost condition. */
    if (base.Owner.IsLocalClient)
        SetupCamera();
}
```

--------------------------------

### Start Server Connections with Fish-Net Multipass

Source: https://fish-networking.gitbook.io/docs/guides/features/transports/multipass

This section provides two methods for starting server connections using Fish-Net's Multipass. The first starts connections on all configured transports if 'GlobalServerActions' is enabled. The second shows how to start a connection on a specific transport by its index. Both require the 'Multipass' component to be attached and configured.

```csharp
//Start all servers transports. This requires GlobalServerActions to be true.
serverManagerReference.StartConnection();
```

```csharp
//Start the connection on index 0.
Multipass mp = TransportManager.GetTransport<Multipass>();
//The true parameter is to indicate you are starting a server.
mp.StartConnection(true, 0);
```

--------------------------------

### Mirror vs. Fish-Networking: NetworkBehaviour Property Renames

Source: https://fish-networking.gitbook.io/docs/guides/upgrading-to-fish-net

This table illustrates the renames for NetworkBehaviour properties when migrating from Mirror to Fish-Networking. It clarifies the distinction between 'Initialized' and 'Started' states, advising the use of 'Initialized' for Mirror conversions.

```csharp
//Mirror example:
hasAuthority
isClient
isClientOnly
isServer
isServerOnly
connectionToClient
connectionToServer
netId

//Fish-Networking example:
IsOwner
IsClientInitialized
IsClientOnlyInitialized
IsServerInitialized
IsServerOnlyInitialized
Owner
LocalConnection
ObjectId

//Notes: isLocalPlayer removed, use IsOwner instead.
//Notes: Can be used on client.
//Notes: When converting from Mirror you will most likely want to use Initialized.
```

--------------------------------

### Fish-Net C# ReplicateState Examples

Source: https://fish-networking.gitbook.io/docs/guides/features/prediction/creating-code/understanding-replicatestate

Demonstrates common combinations of ReplicateState flags in C# for spectated objects. These examples show how to interpret states like 'Replayed', 'Ticked', and 'Created' when combined, indicating whether data is being replayed, processed outside a reconcile, or created by a controller.

```csharp
//You will see this value if the data is being replayed, it previously ran outside the
//reconcile, and data is created by controller.
state = (ReplicateState.Replayed | ReplicateState.Ticked | ReplicateState.Created);
//When the state is only Replayed then the data is not Created, and the tick on data
//has not occurred outside the reconcile yet. This is what we often refer to as a
//future state.
state = ReplicateState.Replayed;
//When a state is Ticked only it indicates that the data is being run outside a
//reconcile, and that the controller has not sent data for this particular tick.
state = ReplicateState.Ticked;
```

--------------------------------

### Loading Scenes into Existing Instances in FishNet

Source: https://fish-networking.gitbook.io/docs/guides/features/scene-management/loading-scenes

This C# code demonstrates how to load a scene for specific network connections using either a scene reference or a scene handle. It utilizes the SceneLoadData class to specify the scene and then calls LoadConnectionScenes on the SceneManager.

```csharp
scene sceneReference;
NetworkConnection[] conns = new() {connA,connB};

// by reference
SceneLoadData sld = new SceneLoadData(sceneReference);
base.SceneManager.LoadConnectionScenes(conns, sld);

// by handle
SceneLoadData sld = new SceneLoadData(sceneReference.handle);
base.SceneManager.LoadConnectionScenes(conns, sld);
```

--------------------------------

### Retrieve and Spawn Pooled NetworkObject (C#)

Source: https://fish-networking.gitbook.io/docs/guides/features/networked-gameobjects-and-scripts/spawning/object-pooling

Shows how to get a NetworkObject from the object pool before spawning it. This ensures that an existing, disabled object is reused rather than creating a new instance. The example also mentions alternative methods for spawning.

```csharp
//There are many overrides which can a variety of information.
//You can use GameObjects, NetworkObjects, PrefabIds, CollectionIds,
//spawn positions, and more.
NetworkObject nob = NetworkManager.GetPooledInstantiated(...);
//Spawn normally.
ServerManager.Spawn(nob);
```

--------------------------------

### Subscribe to SyncTimer Events in C#

Source: https://fish-networking.gitbook.io/docs/guides/features/network-communication/synchronizing/synctimer

Explains how to subscribe to change events for the SyncTimer, including examples for different timer states such as start, pause, unpause, stop, and finish. These events provide notifications about the timer's current state.

```csharp
private void Awake()
{
    _timeRemaining.OnChange += _timeRemaining_OnChange;
}

private void OnDestroy()
{
    _timeRemaining.OnChange -= _timeRemaining_OnChange;
}

private void _timeRemaining_OnChange(SyncTimerOperation op, float prev, float next, bool asServer)
{
    /* Like all SyncType callbacks, asServer is true if the callback
     * is occuring on the server side, false if on the client side. */

    //Operations can be used to be notified of changes to the timer.

    //Timer has been started with initial values.
    if (op == SyncTimerOperation.Start)
        Debug.Log($"The timer was started with {next} seconds.");
    //Timer has been paused.
    else if (op == SyncTimerOperation.Pause)
        Debug.Log($"The timer was paused.");
    //Timer has been paused and latest server values were sent. 
    else if (op == SyncTimerOperation.PauseUpdated)
        Debug.Log($"The timer was paused and remaining time has been updated to {next} seconds.");
    //Timer was unpaused.
    else if (op == SyncTimerOperation.Unpause)
        Debug.Log($"The timer was unpaused.");
    //Timer has been manually stopped.
    else if (op == SyncTimerOperation.Stop)
        Debug.Log($"The timer has been stopped and is no longer running.");
    /* Timer has been manually stopped.
     * 
     * When StopUpdated is called Previous will contain the remaining time
     * prior to being stopped as it is locally. Next will contain the remaining
     * time prior to being stopped as it was on the server. These values
     * often align but the information is provided for your potential needs. 
     *
     * When the server starts a new timer while one is already active, and chooses
     * to also send a stop update using the StartTimer(float,bool) option, a
     * StopUpdated is also sent to know previous timer values before starting a new timer. */
    else if (op == SyncTimerOperation.StopUpdated)
        Debug.Log($"The timer has been stopped and is no longer running. The timer was stopped at value {next} before stopping, and the previous value was {prev}");
    //A timer has reached 0f.
    else if (op == SyncTimerOperation.Finished)
        Debug.Log($"The timer has completed!");
    //Complete occurs after all change events are processed.
    else if (op == SyncTimerOperation.Complete)
        Debug.Log("All timer callbacks have completed for this tick.");
}
```

--------------------------------

### Initialize and Handle SyncDictionary Changes

Source: https://fish-networking.gitbook.io/docs/guides/features/network-communication/synchronizing/syncdictionary

Demonstrates initializing a SyncDictionary and setting up an OnChange callback to handle operations like Add, Remove, Set, and Clear. Changes are applied immediately before the callback occurs.

```csharp
private readonly SyncDictionary<NetworkConnection, string> _playerNames = new();
    
private void Awake()
{
    _playerNames.OnChange += _playerNames_OnChange;
}

//SyncDictionaries also include the asServer parameter.
private void _playerNames_OnChange(SyncDictionaryOperation op,
    NetworkConnection key, string value, bool asServer)
{
    /* Key will be provided for
    * Add, Remove, and Set. */     
    switch (op)
    {
        //Adds key with value.
        case SyncDictionaryOperation.Add:
            break;
        //Removes key.
        case SyncDictionaryOperation.Remove:
            break;
        //Sets key to a new value.
        case SyncDictionaryOperation.Set:
            break;
        //Clears the dictionary.
        case SyncDictionaryOperation.Clear:
            break;
        //Like SyncList, indicates all operations are complete.
        case SyncDictionaryOperation.Complete:
            break;
    }
}
```

--------------------------------

### Prevent Motor Movement During EMP with Replicate

Source: https://fish-networking.gitbook.io/docs/guides/features/lag-compensation/states

This C# code illustrates how to use the [Replicate] attribute in Fish-Net to prevent specific game logic (motor movement in this example) when the current tick falls within a defined EMP duration. It checks the client's or server's LocalTick against the EMP start and end ticks, returning early if within the range to maintain synchronized state during replays.

```csharp
//Tick when to start emp.
private uint _empStartTick = uint.MaxValue;
//Tick when to end emp.
private uint _empEndTick = uint.MaxValue;

/* This is an example of a replicate data excluding the extra
 * parameters, given they have no context in this example. */
[Replicate]
private void Replicate(MotorData md)
{
    uint localTick = base.TimeManager.LocalTick;
    /* If localTick is between EMP range then return.
     * It's important to not reset the emp values because
     * we want these to be the same during replays. If you reset
     * values soon as the condition of exiting emp was satisfied
     * then emp would not be properly set during a replay. 
     *
     * Note that this logic runs on the server and owner,
     * and if using prediction v2 can run on other clients
     * as well. */
    if (localTick >= _empStartTick && localTick <= _empEndTick)
    {
        /* Since under emp exit method early
        * to not process MotorData. In this example
         * we are using an EMP state, therefor the motor
         * will not work. You'll adjust this to whatever
         * your game needs. */
        return;
    }

    //Normal motor logic here.
}
```

--------------------------------

### Implement OnStartServer Callback in C#

Source: https://fish-networking.gitbook.io/docs/guides/features/networked-gameobjects-and-scripts/network-behaviour-guides

Demonstrates how to implement the OnStartServer callback, which is executed when a network object initializes on the server. This is ideal for server-specific initialization tasks and setting synchronized variables that will be delivered to clients upon spawning.

```csharp
public override void OnStartServer()
{
    // This callback is performed first. It occurs
    // when the object is initialized on the server.
    // Owner, ObjectId, and much more are already set.
    // OnStartServer is best used for initializing
    // server aspects of your script, such as getting
    // components only the server would need.
    // It can also be useful for setting values based on
    // the current state of your game. If you change synchronized
    // values within this method, such as SyncTypes,
    // those changes will be delivered to clients
    // when this object spawns for them.
    // Eg: perhaps you want to set a players name, which is
    // a SyncVar. You can do that here and it will be set
    // for clients when the object spawns on their side.
    
    /* When using OnStartServer keep in mind that observers have
    * not yet been built for this object. If you were to send an ObserversRpc
    * for example it would not be delivered to any clients. You can however
    * still use an ObserversRpc and set BufferLast to true if you wish
    * clients to get it when the object is spawned for them. Another option
    * is to use OnSpawnServer, displayed below, and send a TargetRpc to the
    * connection which the object is spawning. */
}
```

--------------------------------

### Instantiate Local Camera with PlayerCamera Script (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/setting-up-a-camera/instantiating-a-local-camera

This C# script, PlayerCamera.cs, is designed to be attached to a player prefab in Unity using Fish-Net. It utilizes the `OnStartClient` method to instantiate a camera prefab and attach it to a designated camera holder on the player object, ensuring the camera is only created for the local player. It requires references to the camera prefab and a transform for the camera holder.

```csharp
using FishNet.Object;
using UnityEngine;

// This script will be a NetworkBehaviour so that we can use the 
// OnStartClient override.
public class PlayerCamera : NetworkBehaviour
{
    [SerializeField] private Camera cameraPrefab;
    [SerializeField] private Transform cameraHolder;

    // This method will run on the client once this object is spawned.
    public override void OnStartClient()
    {
        // Since this will run on all clients that this object spawns for
        // we need to only instantiate the camera for the object we own.
        if (IsOwner)
            Instantiate(cameraPrefab, cameraHolder.position, cameraHolder.rotation, cameraHolder);
    }
}
```

--------------------------------

### Owner-Restricted Movement Example (C#)

Source: https://fish-networking.gitbook.io/docs/guides/features/ownership

This example demonstrates how to restrict movement logic to only the client that owns the game object. It uses `base.IsOwner` to ensure that only the owning client can modify the object's position in the `Update` function.

```csharp
void Update()
{
    // The client's game instance will have several player objects in it if there 
    // are multiple players playing, but he will only own one of them and should
    // should only move that one that he owns.
    if (base.IsOwner)
    {
        float hor = Input.GetAxisRaw("Horizontal");
        float ver = Input.GetAxisRaw("Vertical");
        transform.position += new Vector3(hor, 0f, ver);
    }
}
```

--------------------------------

### Get NetworkManager Reference (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/simple/making-a-custom-player-spawner/set-player-number

Retrieves a reference to the NetworkManager by first attempting to get it from the current object or its parents. If not found, it falls back to using the InstanceFinder. It includes error handling to warn the user if a NetworkManager cannot be found.

```csharp
private void Awake()
{
    networkManager = GetComponentInParent<NetworkManager>();
    if (networkManager == null)
        networkManager = InstanceFinder.NetworkManager;

    if (networkManager == null)
    {
        Debug.LogWarning($"CountBasedPlayerSpawner cannot work as a NetworkManager couldn't be found.");
        return;
    }
}
```

--------------------------------

### Player Movement Script using New Input System (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/moving-your-player-around

This script facilitates client-authoritative movement for a player object utilizing Unity's New Input System. It inherits from Fish-Networking's NetworkBehaviour for network functionalities and uses the `IsOwner` property to ensure input is processed only for the client's own object. Movement input is captured via a callback from the `PlayerInput` component.

```csharp
using FishNet.Object;
using UnityEngine;
using UnityEngine.InputSystem;

// Inherit from NetworkBehaviour instead of MonoBehaviour
public class PlayerMovement : NetworkBehaviour
{
    public float moveSpeed = 5f;
    private Vector2 currentMovementInput;

    public override void OnStartClient()
    {
        if (IsOwner)
            GetComponent<PlayerInput>().enabled = true;
    }

    public void OnMove(InputValue value)
    {
        currentMovementInput = value.Get<Vector2>();
    }

    void Update()
    {
        // Only run this code on the object the local client owns.
        // This prevents us from moving other players' objects.
        if (!IsOwner)
            return;

        Vector3 moveDirection = new Vector3(currentMovementInput.x, 0f, currentMovementInput.y);
        if (moveDirection.magnitude > 1f)
            moveDirection.Normalize();

        transform.position += moveSpeed * Time.deltaTime * moveDirection;
    }
}
```

--------------------------------

### Make SyncType Serializable (C#)

Source: https://fish-networking.gitbook.io/docs/guides/features/network-communication/synchronizing/customizing-behavior

Provides an example of how to make a custom struct type serializable in Unity, which is a prerequisite for showing SyncTypes in the inspector.

```csharp
//SyncTypes can be virtually any data type. This example
//shows a container to demonstrate the serializable attribute.
[System.Serializable]
public struct MyType { }
```

--------------------------------

### PlayerCamera Script for Scene Camera Control (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/setting-up-a-camera/using-the-scene-camera

This C# script, `PlayerCamera.cs`, is designed to be attached to a player prefab in Fish-Networking. It leverages the `OnOwnershipClient` method to control the scene's Main Camera when the local player gains ownership of the player object. It requires a `cameraHolder` transform reference and assumes a camera tagged as 'Main Camera' exists in the scene. If the object is owned by the client, it parents the main camera to the `cameraHolder` and positions it.

```csharp
using FishNet.Connection;
using FishNet.Object;
using UnityEngine;

// This script will be a NetworkBehaviour so that we can use the 
// OnOwnershipClient override.
public class PlayerCamera : NetworkBehaviour
{
    [SerializeField] private Transform cameraHolder;

    // This method is called on the client after gaining or losing ownership of the object.
    // We could have used OnStartClient instead, as we did in the previous example, but using OnOwnershipClient
    // means this will work for a player object we don't initially own but are given ownership to later.
    public override void OnOwnershipClient(NetworkConnection prevOwner)
    {
        if (Camera.main == null)
            return;

        // If we are the new owner of this object, then take control of the camera by parenting it
        // and moving it to our camera holder.
        if (IsOwner)
        {
            Camera.main.transform.SetPositionAndRotation(cameraHolder.position, cameraHolder.rotation);
            Camera.main.transform.SetParent(cameraHolder);
        }
    }
}
```

--------------------------------

### Basic ScenePlayerSpawner Final Script (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/simple/making-a-custom-player-spawner/on-scene-load

This is the complete basic `ScenePlayerSpawner.cs` script in C#. It includes the `NetworkBehaviour` inheritance, player prefab serialization, and the `OnSpawnServer` method utilizing object pooling to spawn players when clients join a scene.

```csharp
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Object;
using UnityEngine;

public class ScenePlayerSpawner : NetworkBehaviour
{
    [SerializeField] private NetworkObject playerPrefab;

    // This method runs on the server when the client is about to spawn this object.
    // Since the player is about to spawn this object, we know he is in this scene.
    public override void OnSpawnServer(NetworkConnection connection)
    {
        NetworkObject obj = NetworkManager.GetPooledInstantiated(playerPrefab, asServer: true);
        Spawn(obj, connection, gameObject.scene);
    }
}
```

--------------------------------

### SyncHashSet Basic Usage and Callbacks (C#)

Source: https://fish-networking.gitbook.io/docs/guides/features/network-communication/synchronizing/synchashset

Demonstrates the basic usage of SyncHashSet for synchronizing integer collections over the network. It includes adding elements, handling change operations (Add, Remove, Clear, Update, Complete), and explains the server/client callback context.

```csharp
private readonly SyncHashSet<int> _myCollection = new SyncHashSet<int>();

private void Awake()
{
    _myCollection.OnChange += _myCollection_OnChange;
}

private void FixedUpdate()
{
    //You can modify a synchashset as you would any other hashset.
    _myCollection.Add(Time.frameCount);
}

/* Like SyncVars the callback offers an asServer option
 * to indicate if the callback is occurring on the server
 * or the client. As SyncVars do, changes have already been
 * made to the collection before the callback occurs. */
private void _myCollection_OnChange(SyncHashSetOperation op, int item, bool asServer)
{
    switch (op)
    {
        /* An object was added to the hashset. Item is
         * is the added object. */
        case SyncHashSetOperation.Add:
            break;
        /* An object has been removed from the hashset. Item
         * is the removed object. */
        case SyncHashSetOperation.Remove:
            break;
        /* The hashset has been cleared. 
         * Item will be default. */
        case SyncHashSetOperation.Clear:
            break;
        /* An entry in the hashset has been updated. 
         * When this occurs the item is removed
         * and added. Item will be the new value.
         * Item will likely need a custom comparer
         * for this to function properly. */
        case SyncHashSetOperation.Update:
            break;
        /* When complete calls all changes have been
        * made to the collection. You may use this
        * to refresh information in relation to
        * the changes, rather than doing so
        * after every entry change. All values are
        * default for this operation. */
        case SyncHashSetOperation.Complete:
            break;
    }
}
```

--------------------------------

### Control SyncTimer Actions in C#

Source: https://fish-networking.gitbook.io/docs/guides/features/network-communication/synchronizing/synctimer

Illustrates the methods available for controlling the SyncTimer from the server-side, including starting, pausing, unpausing, and stopping the timer. These actions are automatically synchronized across the network.

```csharp
//All of the actions below are automatically synchronized.

/* Starts the timer with 5 seconds on it.
 * 
 * The optional boolean argument will also send
 * a stop event before starting a new timer, only if
 * the previous timer is still running.
 * 
 * EG: if a timer was started with 5 seconds and
 * you start a new timer with 2 seconds remaining
 * a StopTimer will be sent with the remaining time
 * of 2 seconds before the timer is started again at
 * 5 seconds. */
_timeRemaining.StartTimer(5f, true);
/* Pauses the timer and optionally sends the current
 * timer value as it is on the server. */
_timeRemaining.PauseTimer(false);
//Unpauses the current timer.
_timeRemaining.UnpauseTimer();
/* Stops the timer early and optionally sends the
* current timer value as it is on the server. */
_timeRemaining.StopTimer(false);
```

--------------------------------

### Player Camera Control Script (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/setting-up-a-camera/basic-setup-with-cinemachine

This C# script, PlayerCamera.cs, enables or disables the Cinemachine Camera component on player objects based on ownership. It leverages the OnStartClient override from FishNet's NetworkBehaviour to manage camera activation for local players. This script requires the FishNet.Object and Unity.Cinemachine namespaces and a serialized field for the CinemachineCamera component.

```csharp
using FishNet.Object;
using Unity.Cinemachine;
using UnityEngine;

// This script will be a NetworkBehaviour so that we can use the OnStartClient override.
public class PlayerCamera : NetworkBehaviour
{
    [SerializeField] private CinemachineCamera cinemachineCamera;

    // This method is called on the client after the object is spawned in.
    public override void OnStartClient()
    {
        // Simply enable our local cinemachine camera on the object if we are the owner.
        cinemachineCamera.enabled = IsOwner;
    }
}
```

--------------------------------

### Override NetworkBehaviour Base Method in C#

Source: https://fish-networking.gitbook.io/docs/guides/features/networked-gameobjects-and-scripts/network-behaviour-guides

Provides an example of overriding a base method within a NetworkBehaviour script. This pattern is used to customize the behavior of network-related actions, such as server initialization.

```csharp
//Example of implementing an override.
public override void OnStartServer()
{
    //This is run when the server initializes the object.
}
```

--------------------------------

### Player Movement Script using Old Input System (C#)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/moving-your-player-around

This script enables client-authoritative movement for a player object using Unity's Old Input System. It inherits from Fish-Networking's NetworkBehaviour to leverage networked object features and restricts movement logic to the owner of the object using the `IsOwner` property. Input is read directly from `Input.GetAxis`.

```csharp
using FishNet.Object;
using UnityEngine;

// Inherit from NetworkBehaviour instead of MonoBehaviour
public class PlayerMovement : NetworkBehaviour
{
    public float moveSpeed = 5f;

    void Update()
    {
        // Only run this code on the object the local client owns.
        // This prevents us from moving other players' objects.
        if (!IsOwner)
            return;

        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 moveDirection = new Vector3(horizontal, 0f, vertical);
        if (moveDirection.magnitude > 1f)
            moveDirection.Normalize();

        transform.position += moveSpeed * Time.deltaTime * moveDirection;
    }
}
```

--------------------------------

### Spawn Cubes with Synced Color (Old Input System)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/using-syncvars-to-sync-colors

This C# script extends `NetworkBehaviour` to spawn cube prefabs. It includes a `ServerRpc` method `SpawnCube` that instantiates a prefab, assigns a random color to its `SyncMaterialColor` component's `color` SyncVar, and then spawns the object across the network. Requires `FishNet.Object` and `UnityEngine` namespaces.

```csharp
using FishNet.Object;
using UnityEngine;

public class PlayerCubeCreator : NetworkBehaviour
{
    public NetworkObject cubePrefab;

    void Update()
    {
        // Only the local player object should perform these actions.
        if (!IsOwner)
            return;

        if (Input.GetButtonDown("Fire1"))
            SpawnCube();
    }

    // We are using a ServerRpc here because the Server needs to do all network object spawning.
    [ServerRpc]
    private void SpawnCube()
    {
        NetworkObject obj = Instantiate(cubePrefab, transform.position, Quaternion.identity);

        obj.GetComponent<SyncMaterialColor>().color.Value = Random.ColorHSV();

        Spawn(obj); // NetworkBehaviour shortcut for ServerManager.Spawn(obj);
    }
}
```

--------------------------------

### Replacing Only Online Scenes in FishNet

Source: https://fish-networking.gitbook.io/docs/guides/features/scene-management/loading-scenes

This C# code demonstrates how to replace only the scenes managed by FishNet's SceneManager, leaving other Unity-loaded scenes untouched. It achieves this by setting the ReplaceScenes property of SceneLoadData to ReplaceOption.OnlineOnly.

```csharp
// Replace Online Only Option.
SceneLoadData sld = new SceneLoadData("DungeonScene");
sld.ReplaceScenes = ReplaceOption.OnlineOnly;

// This will replace only scenes managed by the SceneManager in FishNet.
```

--------------------------------

### Spawn Cube Prefab Script (New Input System)

Source: https://fish-networking.gitbook.io/docs/tutorials/getting-started/spawning-and-despawning-items

This C# script, PlayerCubeCreator, spawns a NetworkObject prefab using the new Input System. It enables the PlayerInput component on the owner client and calls SpawnCube when the 'Fire' action is started. Requires FishNet.Object and UnityEngine namespaces.

```csharp
using FishNet.Object;
using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerCubeCreator : NetworkBehaviour
{
    public NetworkObject cubePrefab;

    public override void OnStartClient()
    {
        if (IsOwner)
            GetComponent<PlayerInput>().enabled = true;
    }

    public void OnFire(InputAction.CallbackContext context)
    {
        if (context.started)
            SpawnCube();
    }

    // We are using a ServerRpc here because the Server needs to do all network object spawning.
    [ServerRpc]
    private void SpawnCube()
    {
        NetworkObject obj = Instantiate(cubePrefab, transform.position, Quaternion.identity);
        Spawn(obj); // NetworkBehaviour shortcut for ServerManager.Spawn(obj);
    }
}
```

--------------------------------

### Replacing All Scenes in FishNet

Source: https://fish-networking.gitbook.io/docs/guides/features/scene-management/loading-scenes

This C# snippet shows how to replace all currently loaded scenes (managed by FishNet or otherwise) with a new scene. It involves setting the ReplaceScenes property of SceneLoadData to ReplaceOption.All and then calling LoadGlobalScenes.

```csharp
// Replace All Option.
SceneLoadData sld = new SceneLoadData("DungeonScene");
sld.ReplaceScenes = ReplaceOption.All;

// This will replace all Scenes loaded by FishNet or outside of FishNet like Unity,
// and load "DungeonScene"
SceneManager.LoadGlobalScenes(sld);
```
Tokens:
Raw