# Helper scripts

Some extra scripts that are part of the Network Playground that you may find useful:

{% tabs %}
{% tab title="Simple Spawn" %}

```
A simple spawn script that Instantiates the Networked Player on a Keypress
```

{% endtab %}

{% tab title="C#" %}

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SpawnCharacter: MonoBehaviour
{
    public KeyCode KeyPress;
    public GameObject NetworkedCharacter;
    
    // Update is called once per frame
    void Update()
    {
        if(Input.GetKeyDown(KeyPress))
        {
            Instantiate(NetworkedCharacter);    
        }
    }
}
```

{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="Simple Input" %}

```
Simple Input to get your Game Objects Moving 
```

{% endtab %}

{% tab title="C#" %}

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SimpleMovement : MonoBehaviour
{
    public float speed = 1f;

    void Update()
    {
        float h = Input.GetAxisRaw("Horizontal");
        float v = Input.GetAxisRaw("Vertical");

        transform.position += transform.forward * (v * speed * Time.deltaTime);
        transform.position += transform.right * (h * speed * Time.deltaTime);
    }
}
```

{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="Coherence Command Handler" %}

```
An Event System you put on the Prefab with coherenceSync
that can handle Network Commands and transfer Authority
```

{% endtab %}

{% tab title="C#" %}

```csharp
using Coherence;
using UnityEngine;
using UnityEngine.Events;
using Coherence.Toolkit;

public class CoherenceCommandHandler : MonoBehaviour
{
    private CoherenceSync sync;

    public UnityEvent onCommandReceived;

    private GameObject fxInstance;

    private void Awake()
    {
        sync = GetComponent<CoherenceSync>();
    }

    public void Adopt()
    {
        if (!sync || sync.HasStateAuthority)
        {
            return;
        }

        sync.RequestAuthority(AuthorityType.Full);
    }

    public void Orphan()
    {
        if (!sync || !sync.HasStateAuthority)
        {
            return;
        }

        sync.AbandonAuthority();
    }

    public void ToggleAuthority()
    {
        if (!sync)
        {
            return;
        }

        if (sync.HasStateAuthority)
        {
            Orphan();
        }
        else
        {
            Adopt();
        }
    }

    public void Command(CoherenceSync sender)
    {
        sync.SendCommand<CoherenceCommandHandler>(nameof(CoherenceCommandHandler.ReceiveCommand), MessageTarget.All);
    }

    public void ReceiveCommand()
    {
        onCommandReceived.Invoke();
    }

    public void InstantiateFX(GameObject fx)
    {
        if (fxInstance)
        {
            Destroy(fxInstance);
        }

        var t = fx.transform;
        fxInstance = Instantiate(fx, transform.position + t.position, transform.rotation);
    }
}
```

{% endtab %}
{% endtabs %}

{% tabs %}
{% tab title="Coherence Connection Events" %}

```
An Event System you put on an empty game object in your 
scene that handles Global Connection/Disconnection
```

{% endtab %}

{% tab title="C#" %}

```csharp
using UnityEngine;
using UnityEngine.Events;
using Coherence.Connection;
using Coherence.Toolkit;

public class CoherenceConnectionEvents : MonoBehaviour
{
    public UnityEvent onConnect;
    public UnityEvent onDisconnect;
    private CoherenceMonoBridge monoBridge;

    private void OnEnable()
    {
        monoBridge = FindObjectOfType<CoherenceMonoBridge>();
        monoBridge.onConnected.AddListener(HandleConnected);
        monoBridge.OnLiveQuerySynced += HandleLiveQuerySynced;
        monoBridge.onDisconnected.AddListener(HandleDisconnected);
    }

    private void OnDisable()
    {
        monoBridge.onConnected.RemoveListener(HandleConnected);
        monoBridge.onDisconnected.RemoveListener(HandleDisconnected);
    }

    private void HandleConnected(CoherenceMonoBridge _)
    {
        onConnect?.Invoke();
    }

    private void HandleLiveQuerySynced(CoherenceMonoBridge _)
    {
        onConnect?.Invoke();
    }

    private void HandleDisconnected(CoherenceMonoBridge _,  ConnectionCloseReason __)
    {
        onDisconnect?.Invoke();
    }
}
```

{% endtab %}
{% endtabs %}