Peer-to-Peer Networking (Deprecated)

using UnityEngine;
using System;
using Oculus.Platform;
using Oculus.Platform.Models;

// Helper class to manage a Peer-to-Peer connection to the other user.
// The connection is used to send and received the Transforms for the
// Avatars.  The Transforms are sent via unreliable UDP at a fixed
// frequency.
public class P2PManager
{
    // number of seconds to delay between transform updates
    private static readonly float UPDATE_DELAY = 0.1f;

    // the ID of the remote player we expect to be connected to
    private ulong m_remoteID;

    // the result of the last connection state update message
    private PeerConnectionState m_state = PeerConnectionState.Unknown;

    // the next time to send an updated transform to the remote User
    private float m_timeForNextUpdate;

    // the size of the packet we are sending and receiving
    private static readonly byte PACKET_SIZE = 29;

    // packet format type just in case we want to add new future packet types
    private static readonly byte PACKET_FORMAT = 0;

    // reusable buffer to serialize the Transform into
    private readonly byte[] sendTransformBuffer = new byte[PACKET_SIZE];

    // reusable buffer to deserialize the Transform into
    private readonly byte[] receiveTransformBuffer = new byte[PACKET_SIZE];

    // the last received position update
    private Vector3 receivedPosition;

    // the previous received position to interpolate from
    private Vector3 receivedPositionPrior;

    // the last received rotation update
    private Quaternion receivedRotation;

    // the previous received rotation to interpolate from
    private Quaternion receivedRotationPrior;

    // when the last transform was received
    private float receivedTime;

    public P2PManager(Transform initialHeadTransform)
    {
        receivedPositionPrior = receivedPosition = initialHeadTransform.localPosition;
        receivedRotationPrior = receivedRotation = initialHeadTransform.localRotation;

        Net.SetPeerConnectRequestCallback(PeerConnectRequestCallback);
        Net.SetConnectionStateChangedCallback(ConnectionStateChangedCallback);
    }

    #region Connection Management

    public void ConnectTo(ulong userID)
    {
        m_remoteID = userID;

        // ID comparison is used to decide who calls Connect and who calls Accept
        if (PlatformManager.MyID < userID)
        {
            Net.Connect(userID);
        }
    }

    public void Disconnect()
    {
        if (m_remoteID != 0)
        {
            Net.Close(m_remoteID);
            m_remoteID = 0;
            m_state = PeerConnectionState.Unknown;
        }
    }

    public bool Connected
    {
        get
        {
            return m_state == PeerConnectionState.Connected;
        }
    }

    void PeerConnectRequestCallback(Message<NetworkingPeer> msg)
    {
        Debug.LogFormat("Connection request from {0}, authorized is {1}", msg.Data.ID, m_remoteID);

        if (msg.Data.ID == m_remoteID)
        {
            Net.Accept(msg.Data.ID);
        }
    }

    void ConnectionStateChangedCallback(Message<NetworkingPeer> msg)
    {
        Debug.LogFormat("Connection state to {0} changed to {1}", msg.Data.ID, msg.Data.State);

        if (msg.Data.ID == m_remoteID)
        {
            m_state = msg.Data.State;

            if (m_state == PeerConnectionState.Timeout &&
                // ID comparison is used to decide who calls Connect and who calls Accept
                PlatformManager.MyID < m_remoteID)
            {
                // keep trying until hangup!
                Net.Connect(m_remoteID);
            }
        }

        PlatformManager.SetBackgroundColorForState();
    }

    #endregion

    #region Send Update

    public bool ShouldSendHeadUpdate
    {
        get
        {
            return Time.time >= m_timeForNextUpdate && m_state == PeerConnectionState.Connected;
        }
    }

    public void SendHeadTransform(Transform headTransform)
    {
        m_timeForNextUpdate = Time.time + UPDATE_DELAY;

        sendTransformBuffer[0] = PACKET_FORMAT;
        int offset = 1;

        PackFloat(headTransform.localPosition.x, sendTransformBuffer, ref offset);
        PackFloat(headTransform.localPosition.y, sendTransformBuffer, ref offset);
        PackFloat(headTransform.localPosition.z, sendTransformBuffer, ref offset);
        PackFloat(headTransform.localRotation.x, sendTransformBuffer, ref offset);
        PackFloat(headTransform.localRotation.y, sendTransformBuffer, ref offset);
        PackFloat(headTransform.localRotation.z, sendTransformBuffer, ref offset);
        PackFloat(headTransform.localRotation.w, sendTransformBuffer, ref offset);

        Net.SendPacket(m_remoteID, sendTransformBuffer, SendPolicy.Unreliable);
    }

    void PackFloat(float f, byte[] buf, ref int offset)
    {
        Buffer.BlockCopy(BitConverter.GetBytes(f), 0, buf, offset, 4);
        offset = offset + 4;
    }

    #endregion

    #region Receive Update

    public void GetRemoteHeadTransform(Transform headTransform)
    {
        bool hasNewTransform = false;

        Packet packet;
        while ((packet = Net.ReadPacket()) != null)
        {
            if (packet.Size != PACKET_SIZE)
            {
                Debug.Log("Invalid packet size: " + packet.Size);
                continue;
            }

            packet.ReadBytes(receiveTransformBuffer);

            if (receiveTransformBuffer[0] != PACKET_FORMAT)
            {
                Debug.Log("Invalid packet type: " + packet.Size);
                continue;
            }
            hasNewTransform = true;
        }

        if (hasNewTransform)
        {
            receivedPositionPrior = receivedPosition;
            receivedPosition.x = BitConverter.ToSingle(receiveTransformBuffer, 1);
            receivedPosition.y = BitConverter.ToSingle(receiveTransformBuffer, 5);
            receivedPosition.z = BitConverter.ToSingle(receiveTransformBuffer, 9);

            receivedRotationPrior = receivedRotation;
            receivedRotation.x = BitConverter.ToSingle(receiveTransformBuffer, 13);
            receivedRotation.y = BitConverter.ToSingle(receiveTransformBuffer, 17) * -1.0f;
            receivedRotation.z = BitConverter.ToSingle(receiveTransformBuffer, 21);
            receivedRotation.w = BitConverter.ToSingle(receiveTransformBuffer, 25) * -1.0f;

            receivedTime = Time.time;
        }

        // since we're receiving updates at a slower rate than we render,
        // interpolate to make the motion look smoother
        float completed = Math.Min(Time.time - receivedTime, UPDATE_DELAY) / UPDATE_DELAY;
        headTransform.localPosition =
            Vector3.Lerp(receivedPositionPrior, receivedPosition, completed);
        headTransform.localRotation =
            Quaternion.Slerp(receivedRotationPrior, receivedRotation, completed);
    }

    #endregion
}