Telepathy Networking Library

When using Telepathy in Unity, follow these steps for proper integration:

1. Enable Background Running: Set Application.runInBackground = true in Awake to ensure networking continues when the window loses focus.
2. Configure Logging: Redirect Telepathy's internal logging to Unity's console by assigning Debug.Log, Debug.LogWarning, and Debug.LogError to Telepathy.Logger.
3. Update Loop: Call client.Tick(limit) and server.Tick(limit) inside the Unity Update() method. Even if the client/server is not currently connected/active, calling Tick is necessary to process disconnection messages.
4. Cleanup: Call client.Disconnect() and server.Stop() in OnApplicationQuit() to ensure threads are shut down correctly when exiting the Editor or the build.

using System;
using UnityEngine;

public class SimpleExample : MonoBehaviour
{
    Telepathy.Client client = new Telepathy.Client(1024);
    Telepathy.Server server = new Telepathy.Server(1024);

    void Awake()
    {
        // update even if window isn't focused, otherwise we don't receive.
        Application.runInBackground = true;

        // use Debug.Log functions for Telepathy so we can see it in the console
        Telepathy.Logger.Log = Debug.Log;
        Telepathy.Logger.LogWarning = Debug.LogWarning;
        Telepathy.Logger.LogError = Debug.LogError;

        // hook up events
        client.OnConnected = () => Debug.Log("Client Connected");
        client.OnData = (message) => Debug.Log("Client Data: " + BitConverter.ToString(message.Array, message.Offset, message.Count));
        client.OnDisconnected = () => Debug.Log("Client Disconnected");

        server.OnConnected = (connectionId) => Debug.Log(connectionId + " Connected");
        server.OnData = (connectionId, message) => Debug.Log(connectionId + " Data: " + BitConverter.ToString(message.Array, message.Offset, message.Count));
        server.OnDisconnected = (connectionId) => Debug.Log(connectionId + " Disconnected");
    }

    void Update()
    {
        // client
        if (client.Connected)
        {
            // send message on key press
            if (Input.GetKeyDown(KeyCode.Space))
                client.Send(new ArraySegment<byte>(new byte[]{0x1}));
        }

        // tick to process messages
        // (even if not connected so we still process disconnect messages)
        client.Tick(100);

        // server
        if (server.Active)
        {
            if (Input.GetKeyDown(KeyCode.Space))
                server.Send(0, new ArraySegment<byte>(new byte[]{0x2}));

        }

        // tick to process messages
        server.Tick(100);
    }

    void OnGUI()
    {
        // client
        GUI.enabled = !client.Connected;
        if (GUI.Button(new Rect(0, 0, 120, 20), "Connect Client"))
            client.Connect("localhost", 1337);

        GUI.enabled = client.Connected;
        if (GUI.Button(new Rect(130, 0, 120, 20), "Disconnect Client"))
            client.Disconnect();

        // server
        GUI.enabled = !server.Active;
        if (GUI.Button(new Rect(0, 25, 120, 20), "Start Server"))
            server.Start(1337);

        GUI.enabled = server.Active;
        if (GUI.Button(new Rect(130, 25, 120, 20), "Stop Server"))
            server.Stop();

        GUI.enabled = true;
    }

    void OnApplicationQuit()
    {
        client.Disconnect();
        server.Stop();
    }
}

To implement a server, instantiate Telepathy.Server with a buffer size. You must hook up event handlers for OnConnected, OnData, and OnDisconnected.

Important: The ArraySegment<byte> provided in the OnData event is only valid until the event handler returns. To avoid issues, do not store this segment for later use; copy the data if you need it beyond the scope of the callback.

To process incoming messages, you must call Tick(limit) within your application's main update loop. The limit parameter helps prevent deadlocks.

// create server & hook up events
// note that the message ArraySegment<byte> is only valid until returning (allocation free)
Telepathy.Server server = new Telepathy.Server(1024);
server.OnConnected = (connectionId) => Console.WriteLine(connectionId + " Connected");
server.OnData = (connectionId, message) => Console.WriteLine(connectionId + " Data: " + BitConverter.ToString(message.Array, message.Offset, message.Count));
server.OnDisconnected = (connectionId) => Console.WriteLine(connectionId + " Disconnected");

// start
server.Start(1337);

// tick to process incoming messages (do this in your update loop)
// => limit parameter to avoid deadlocks!
server.Tick(100);

// send a message to client with connectionId = 0 (first one)
byte[] message = new byte[]{0x42, 0x13, 0x37};
server.Send(0, new ArraySegment<byte>(message));

// stop the server when you don't need it anymore
server.Stop();