1251 lines
41 KiB
C#
1251 lines
41 KiB
C#
using Newtonsoft.Json.Linq;
|
|
using System;
|
|
using System.Numerics;
|
|
using System.Text;
|
|
using TMPro;
|
|
using UdonSharp;
|
|
using UnityEngine;
|
|
using VRC.SDK3.UdonNetworkCalling;
|
|
using VRC.SDKBase;
|
|
using VRC.Udon.Common;
|
|
|
|
namespace Marro.PacManUdon
|
|
{
|
|
public enum NetworkEventType
|
|
{
|
|
FullSyncForced = 0,
|
|
FullSync = 1,
|
|
PacManTurn = 2,
|
|
StartGameButtonPressed = 3,
|
|
SyncPellets = 4,
|
|
GhostUpdate = 5,
|
|
TimeSequenceSync = 6,
|
|
Pause = 7,
|
|
Resume = 8,
|
|
Step = 9,
|
|
}
|
|
|
|
public class NetworkManager : SyncedObject
|
|
{
|
|
// The network manager works by serializing event and state data into a byte array, including a timestamp for each event.
|
|
// If user is owner, this data is created and stored in a buffer which is cleared upon transmission.
|
|
// If user is not owner, this data is read into the same buffer and replayed based on the included timestamp.
|
|
// Data replay is delayed with an offset on the timestamp to hide inconsistency in latency.
|
|
|
|
// Each event contains a header. The first part contains the size of the event as a ushort, allowing a maximum size of 65,536 bytes.
|
|
// After that timestamp is transferred in seconds since the owner started the game as a float, matching Unity's time representation.
|
|
// Afterwards is a message id, a single byte which increments (with overflow) for every event to confirm data completeness.
|
|
// Lastly, a single byte indicates the type of event. 0 is a full sync, which is reserved for syncing up from any unknown state.
|
|
|
|
// A byte array is used as a DataList or DataDictionary can only be transmitted as JSON which is much less efficient.
|
|
// As Udon does not support instantiating objects, I have not created classes to represent the data being sent.
|
|
// Correct parsing is dependend upon everything being read out identially to how it was created.
|
|
|
|
// An event has the following structure:
|
|
// [0-1]: (ushort) Size of event.
|
|
// [2-5]: (float) Time in seconds at which event occured.
|
|
// [6]: (byte) Message id, increments by one for each message with the same timestamp.
|
|
// [7]: (byte) Type of event. 0 = Full Sync, which is used to sync up from an undefinted state.
|
|
// [+]: Event-specific data.
|
|
|
|
#region Settings
|
|
/// <summary>
|
|
/// The root from which this <see cref="NetworkManager"/> will look for <see cref="SyncedObject"/> to control.
|
|
/// </summary>
|
|
[SerializeField] private GameObject root;
|
|
/// <summary>
|
|
/// The delay in ticks at which the receiving side replays events.
|
|
/// </summary>
|
|
[SerializeField] private int delay = 50;
|
|
/// <summary>
|
|
/// The maximum amount of times a message is sent.
|
|
/// </summary>
|
|
[SerializeField] private int maxEventSendTries = 3;
|
|
/// <summary>
|
|
/// How long to wait since last message to send next ping.
|
|
/// </summary>
|
|
[SerializeField] private int pingDelay = 15;
|
|
/// <summary>
|
|
/// The time delta at which updates occur.
|
|
/// </summary>
|
|
[SerializeField] private float tickDelta = 0.0166666667f;
|
|
#endregion
|
|
|
|
#region Constants
|
|
/// <summary>
|
|
/// The maximum amount of events in the buffer.
|
|
/// </summary>
|
|
private const int BufferMaxTotalEvents = 255;
|
|
/// <summary>
|
|
/// The maximum amount of events in the buffer.
|
|
/// </summary>
|
|
private const int MaxEventSize = ushort.MaxValue;
|
|
|
|
/// <summary>
|
|
/// The index in an event where the event size is stored.
|
|
/// </summary>
|
|
private const ushort HeaderEventSizeIndex = 0;
|
|
/// <summary>
|
|
/// The index in an event where the timestamp is stored.
|
|
/// </summary>
|
|
private const ushort HeaderTimestampIndex = 2;
|
|
/// <summary>
|
|
/// The index in an event where the event id is stored.
|
|
/// </summary>
|
|
private const ushort HeaderEventIdIndex = 6;
|
|
/// <summary>
|
|
/// The index in an event where the event type is stored.
|
|
/// </summary>
|
|
private const ushort HeaderEventTypeIndex = 7;
|
|
/// <summary>
|
|
/// The total length of the header of an event, in bytes.
|
|
/// </summary>
|
|
private const ushort HeaderLength = 8;
|
|
#endregion
|
|
|
|
#region Private attributes
|
|
/// <summary>
|
|
/// Whether <see cref="Initialize"/> has been called successfully.
|
|
/// </summary>
|
|
private bool initialized = false;
|
|
|
|
/// <summary>
|
|
/// Subscribers to each <see cref="NetworkEventType"/>.
|
|
/// </summary>
|
|
private SyncedObject[][] networkEventSubscribers;
|
|
|
|
/// <summary>
|
|
/// Indices for <see cref="networkEventSubscribers"/>.
|
|
/// </summary>
|
|
private int[] networkEventSubscribersIndices;
|
|
|
|
/// <summary>
|
|
/// Subscribers for <see cref="SyncedObject.SyncedUpdate"/>.
|
|
/// </summary>
|
|
private SyncedObject[] syncedUpdateSubscribers;
|
|
|
|
/// <summary>
|
|
/// The <see cref="Time.fixedTime"/> that corresponds to tick 0.
|
|
/// </summary>
|
|
private float startTime;
|
|
|
|
/// <summary>
|
|
/// Time in ticks since start of game.
|
|
/// </summary>
|
|
private int targetTicks;
|
|
|
|
/// <summary>
|
|
/// True if time is paused
|
|
/// </summary>
|
|
private bool paused;
|
|
|
|
/// <summary>
|
|
/// True if a step should happen next update
|
|
/// </summary>
|
|
private bool stepNext;
|
|
|
|
/// <summary>
|
|
/// Time at which next received event occured, in ticks.
|
|
/// </summary>
|
|
private int nextEventTime;
|
|
|
|
/// <summary>
|
|
/// Amounot of retries in a row without a successful sync.
|
|
/// </summary>
|
|
private int retriesWithoutSuccess;
|
|
|
|
/// <summary>
|
|
/// For receiver: True if there's a full sync in the queue and we are not synced, otherwise false.
|
|
/// For transmitter: True if there's a full sync in the queue which has not yet been transmitted, otherwise false.
|
|
/// </summary>
|
|
private bool hasFullSyncReady;
|
|
/// <summary>
|
|
/// True if serialization has been requestsed
|
|
/// </summary>
|
|
private bool serializationRequested;
|
|
|
|
/// <summary>
|
|
/// Events to send at the end of SyncedUpdate cycle
|
|
/// </summary>
|
|
private NetworkEventType[] eventsToSend;
|
|
/// <summary>
|
|
/// Index for <see cref="eventsToSend"/>
|
|
/// </summary>
|
|
private int eventsToSendIndex;
|
|
|
|
/// <summary>
|
|
/// Queue of events to be transmitted or processed.
|
|
/// </summary>
|
|
private byte[][] eventsQueue;
|
|
/// <summary>
|
|
/// Index of <see cref="eventsQueue"/>.
|
|
/// </summary>
|
|
private int eventsQueueIndex;
|
|
|
|
/// <summary>
|
|
/// The value of <see cref="eventsQueueIndex"/> at the last transmission.
|
|
/// </summary>
|
|
private int eventsQueueIndexAtLastTransmission;
|
|
/// <summary>
|
|
/// Counts of new events at recent transmissions.
|
|
/// </summary>
|
|
private int[] eventTransmissionHistory;
|
|
/// <summary>
|
|
/// Index of <see cref="eventTransmissionHistoryIndex"/>.
|
|
/// </summary>
|
|
private int eventTransmissionHistoryIndex;
|
|
/// <summary>
|
|
/// Time of last event transmission, in ticks.
|
|
/// </summary>
|
|
private int lastEventTransmissionTime;
|
|
|
|
|
|
/// <summary>
|
|
/// The message id of the most recent event created or received.
|
|
/// </summary>
|
|
private byte lastEventId;
|
|
|
|
|
|
/// <summary>
|
|
/// Data which is currently available on the network.
|
|
/// </summary>
|
|
[UdonSynced] private byte[] networkedData = new byte[0];
|
|
#endregion
|
|
|
|
#region Public fields
|
|
private bool ready = false;
|
|
/// <summary>
|
|
/// Whether this <see cref="NetworkManager"/> is ready to transmit or receive data.
|
|
/// If false, networking is disabled and this <see cref="NetworkManager"/> acts as a pass-through.
|
|
/// </summary>
|
|
public bool Ready
|
|
{
|
|
get => ready;
|
|
private set
|
|
{
|
|
ready = value;
|
|
if (DebugImageToIndicateReady != null)
|
|
{
|
|
DebugImageToIndicateReady.SetFloat("Color", value ? 1 : 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Whether the current perspective is synced with the owner. (Always true if current perspective is owner.)
|
|
/// </summary>
|
|
public bool Synced
|
|
{
|
|
get => synced;
|
|
private set
|
|
{
|
|
synced = value;
|
|
if (DebugImageToIndicateSynced != null)
|
|
{
|
|
DebugImageToIndicateSynced.SetFloat("Color", value ? 1 : 0);
|
|
}
|
|
}
|
|
}
|
|
private bool synced = false;
|
|
|
|
/// <summary>
|
|
/// The time since start of game, in ticks.
|
|
/// </summary>
|
|
public int SyncedTimeTicks { get; private set; }
|
|
/// <summary>
|
|
/// The time since start of game which is currently being simulated.
|
|
/// </summary>
|
|
public float SyncedTime { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Time since the last simulation, in seconds.
|
|
/// </summary>
|
|
public float SyncedDeltaTime => tickDelta;
|
|
|
|
/// <summary>
|
|
/// Is the current simulation to prepare for applying a network event?
|
|
/// True = Yes, This update is preparing for a network update.
|
|
/// False = No, this update is after the network update or there was no network update this cycle.
|
|
/// </summary>
|
|
public bool IsEventUpdate { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Is the local user owner?
|
|
/// </summary>
|
|
public bool IsOwner
|
|
{
|
|
get => isOwner;
|
|
private set
|
|
{
|
|
isOwner = value;
|
|
if (DebugImageToIndicateOwner != null)
|
|
{
|
|
DebugImageToIndicateOwner.SetFloat("Color", value ? 1 : 0);
|
|
}
|
|
}
|
|
}
|
|
private bool isOwner = false;
|
|
#endregion
|
|
|
|
#region General
|
|
/// <summary>
|
|
/// Initializes the <see cref="NetworkManager"/>. Call <see cref="Reset"/> afterwards to activate networking.
|
|
/// </summary>
|
|
public void Initialize()
|
|
{
|
|
if (initialized)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Tried to call {nameof(Initialize)} when already initialized!");
|
|
return;
|
|
}
|
|
|
|
if (!BitConverter.IsLittleEndian)
|
|
{
|
|
Debug.LogError($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Fatal: NetworkManager only supports little endian! Network sync will not be possible.");
|
|
return;
|
|
}
|
|
|
|
if (root == null)
|
|
{
|
|
root = transform.parent.gameObject;
|
|
}
|
|
|
|
InitializeSubscribers();
|
|
|
|
initialized = true;
|
|
|
|
Reset();
|
|
}
|
|
|
|
private void InitializeSubscribers()
|
|
{
|
|
syncedUpdateSubscribers = root.GetComponentsInChildren<SyncedObject>(includeInactive: true);
|
|
|
|
foreach (var obj in syncedUpdateSubscribers)
|
|
{
|
|
obj.networkManager = this;
|
|
}
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Found {syncedUpdateSubscribers.Length} {nameof(SyncedObject)} in children of {root.name}.");
|
|
|
|
const int eventTypeCount = byte.MaxValue + 1;
|
|
|
|
networkEventSubscribers = new SyncedObject[eventTypeCount][];
|
|
networkEventSubscribersIndices = new int[eventTypeCount];
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
if (!initialized)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Tried to call {nameof(Reset)} while not initialized. Call {nameof(Initialize)} first.");
|
|
return;
|
|
}
|
|
|
|
if (tester == null)
|
|
{
|
|
IsOwner = Networking.IsOwner(gameObject);
|
|
}
|
|
else
|
|
{
|
|
IsOwner = tester.ShouldBeOwner(this);
|
|
}
|
|
|
|
ClearBuffer();
|
|
|
|
Synced = IsOwner; // Owner is always synced
|
|
retriesWithoutSuccess = 0;
|
|
hasFullSyncReady = false;
|
|
|
|
targetTicks = 0;
|
|
startTime = Time.fixedTime;
|
|
SyncedTime = 0;
|
|
SyncedTimeTicks = 0;
|
|
|
|
Ready = true;
|
|
|
|
// Sync up
|
|
if (IsOwner)
|
|
{
|
|
SendEventSoon(NetworkEventType.FullSyncForced);
|
|
}
|
|
else
|
|
{
|
|
RequestEvent(NetworkEventType.FullSync);
|
|
}
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Initialized");
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
if (debugOutput != null)
|
|
{
|
|
WriteDebugOutput(debugOutput);
|
|
}
|
|
|
|
if (!initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get our target time
|
|
UpdateInternalTime();
|
|
|
|
// Forwards simulated time by updateDelta until we're caught up
|
|
while (SyncedTimeTicks <= targetTicks)
|
|
{
|
|
PerformFixedSyncedUpdate();
|
|
}
|
|
}
|
|
|
|
private void PerformFixedSyncedUpdate()
|
|
{
|
|
if (Ready)
|
|
{
|
|
if (IsOwner)
|
|
{
|
|
ProcessEventsToSend(); // Prepare events from last cycle
|
|
ProgressPingTime(); // See if we need to send a ping
|
|
}
|
|
else
|
|
{
|
|
ApplyReceivedEvents(); // See if there's events after last update that need to be replayed
|
|
}
|
|
}
|
|
|
|
ProgressSyncedTime();
|
|
CallSyncedUpdate();
|
|
}
|
|
|
|
private void CallSyncedUpdate()
|
|
{
|
|
IsEventUpdate = false;
|
|
|
|
for (int i = 0; i < syncedUpdateSubscribers.Length; i++)
|
|
{
|
|
var obj = syncedUpdateSubscribers[i];
|
|
|
|
if (obj.gameObject.activeInHierarchy)
|
|
{
|
|
obj.SyncedUpdate();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandleError(bool clearBuffer)
|
|
{
|
|
retriesWithoutSuccess++;
|
|
|
|
if (retriesWithoutSuccess > 3)
|
|
{
|
|
Debug.LogError($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Fatal: Retried 3 times without success.");
|
|
Ready = false;
|
|
return;
|
|
}
|
|
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Encountered data error, attempting to recover via full sync.");
|
|
|
|
if (clearBuffer)
|
|
{
|
|
ClearBuffer();
|
|
}
|
|
|
|
Synced = false;
|
|
|
|
if (!IsOwner)
|
|
{
|
|
RequestEvent(NetworkEventType.FullSync);
|
|
}
|
|
else
|
|
{
|
|
SendEventSoon(NetworkEventType.FullSyncForced);
|
|
}
|
|
}
|
|
|
|
private SyncedObject[] GetEventSubscribers(NetworkEventType eventType) => networkEventSubscribers[(int)eventType];
|
|
|
|
public void SubscribeToEvent(SyncedObject syncedObject, NetworkEventType eventType)
|
|
{
|
|
// This is inefficient, but I'd rather initialize slowly than perform bounds checks in often called code
|
|
|
|
var eventTypeIndex = (int)eventType;
|
|
|
|
var subscribers = networkEventSubscribers[eventTypeIndex];
|
|
int subscribersIndex = networkEventSubscribersIndices[eventTypeIndex];
|
|
if (subscribers == null)
|
|
{
|
|
subscribers = new SyncedObject[1];
|
|
}
|
|
else
|
|
{
|
|
subscribers = new SyncedObject[subscribersIndex+1];
|
|
Array.Copy(networkEventSubscribers[eventTypeIndex], subscribers, subscribersIndex);
|
|
}
|
|
|
|
subscribers[subscribersIndex] = syncedObject;
|
|
|
|
networkEventSubscribers[eventTypeIndex] = subscribers;
|
|
networkEventSubscribersIndices[eventTypeIndex] = subscribersIndex;
|
|
}
|
|
#endregion
|
|
|
|
#region Sender
|
|
public void SendEventSoon(NetworkEventType eventType)
|
|
{
|
|
if (!Ready)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!IsOwner)
|
|
{
|
|
//Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Attempted {nameof(SendEventSoon)} while not the owner!");
|
|
return;
|
|
}
|
|
|
|
if (eventsQueueIndex > eventsToSend.Length)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) {nameof(eventsToSend)} overflow!");
|
|
HandleError(false);
|
|
return;
|
|
}
|
|
|
|
eventsToSend[eventsToSendIndex++] = eventType;
|
|
}
|
|
|
|
private void ProcessEventsToSend()
|
|
{
|
|
for (int i = 0; i < eventsToSendIndex; i++)
|
|
{
|
|
SendEventNow(eventsToSend[0]);
|
|
}
|
|
|
|
eventsToSendIndex = 0;
|
|
}
|
|
|
|
public void SendEventNow(NetworkEventType eventType)
|
|
{
|
|
if (!Ready)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!IsOwner)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Attempted {nameof(SendEventNow)} while not the owner!");
|
|
return;
|
|
}
|
|
|
|
var timestamp = SyncedTimeTicks;
|
|
|
|
var eventId = GetNextEventId(lastEventId);
|
|
|
|
InitializeEvent(eventType, timestamp, eventId, out byte[] data, out var index);
|
|
|
|
var subscibers = GetEventSubscribers(eventType);
|
|
|
|
if (subscibers != null)
|
|
{
|
|
foreach (var obj in subscibers)
|
|
{
|
|
obj.CollectSyncedData(data, ref index, eventType);
|
|
}
|
|
}
|
|
|
|
// Validate and fill in event size
|
|
var eventSizeBytes = BitConverter.GetBytes((ushort)index);
|
|
Array.Copy(eventSizeBytes, 0, data, HeaderEventSizeIndex, eventSizeBytes.Length);
|
|
|
|
if (IsFullSync(eventType))
|
|
{
|
|
hasFullSyncReady = true;
|
|
}
|
|
|
|
data = GetArrayPart(data, 0, index);
|
|
|
|
QueueEventInBuffer(data);
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Prepared event of type {eventType} with {data.Length} bytes, timestamp {timestamp} and id {eventId} for serialization.");
|
|
|
|
RequestSerializationForEvents();
|
|
|
|
lastEventId = eventId;
|
|
|
|
retriesWithoutSuccess = 0; // We had success!
|
|
}
|
|
|
|
private static void InitializeEvent(NetworkEventType eventType, int timestamp, byte eventId, out byte[] data, out int index)
|
|
{
|
|
data = new byte[MaxEventSize];
|
|
|
|
// Create header (note: event size is added later)
|
|
var timestampBytes = BitConverter.GetBytes(timestamp);
|
|
Array.Copy(timestampBytes, 0, data, HeaderTimestampIndex, timestampBytes.Length);
|
|
data[HeaderEventIdIndex] = eventId;
|
|
data[HeaderEventTypeIndex] = ((int)eventType).ToByte();
|
|
index = HeaderLength;
|
|
}
|
|
|
|
private void RequestSerializationForEvents()
|
|
{
|
|
RequestSerialization();
|
|
serializationRequested = true;
|
|
if (tester != null)
|
|
{
|
|
tester.RequestSerializationTest();
|
|
}
|
|
}
|
|
|
|
[NetworkCallable]
|
|
public void RequestEventReceived(NetworkEventType eventType)
|
|
{
|
|
if (!Ready)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (IsFullSync(eventType) && hasFullSyncReady)
|
|
{
|
|
return; // Don't send another full sync if we're already preparing to send one
|
|
}
|
|
|
|
if (eventType == NetworkEventType.FullSyncForced)
|
|
{
|
|
SendEventSoon(NetworkEventType.FullSync); // Remote is not allowed to request a forced full sync
|
|
return;
|
|
}
|
|
|
|
SendEventSoon(eventType);
|
|
}
|
|
|
|
private void ProgressPingTime()
|
|
{
|
|
if (eventsQueueIndex > 0 && !serializationRequested
|
|
&& targetTicks - lastEventTransmissionTime >= pingDelay)
|
|
{
|
|
RequestSerializationForEvents();
|
|
}
|
|
}
|
|
|
|
public override void OnPreSerialization()
|
|
{
|
|
if (!Ready || !IsOwner || !serializationRequested || eventsQueue == null || eventsQueueIndex == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
networkedData = Flatten(eventsQueue, 0, eventsQueueIndex);
|
|
|
|
eventTransmissionHistory[eventTransmissionHistoryIndex] = eventsQueueIndex - eventsQueueIndexAtLastTransmission;
|
|
eventTransmissionHistoryIndex += 1;
|
|
if (eventTransmissionHistoryIndex >= eventTransmissionHistory.Length)
|
|
{
|
|
eventTransmissionHistoryIndex = 0;
|
|
}
|
|
|
|
serializationRequested = false;
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Serializing {eventsQueueIndex} event(s), eventTransmissionHistory is now {ArrayToString(eventTransmissionHistory)} with index {eventTransmissionHistoryIndex}");
|
|
}
|
|
|
|
public override void OnPostSerialization(SerializationResult result) => OnPostSerializationInternal(result.success, result.byteCount);
|
|
|
|
// Version of OnPostSerialization which does not require instantiating SerializationResult, so that it can be called for debugging purposes.
|
|
public void OnPostSerializationInternal(bool success, int byteCount)
|
|
{
|
|
if (!Ready || !IsOwner || networkedData.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!success)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Serialization failed! Tried to send {byteCount} bytes.");
|
|
return;
|
|
}
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Serialized with {networkedData.Length} bytes.\nBytes sent:\n{ArrayToString(networkedData)}");
|
|
|
|
// Remove data from the buffer that no longer needs to be (re)transmitted
|
|
DequeueEventsFromBuffer(eventTransmissionHistory[eventTransmissionHistoryIndex]);
|
|
eventTransmissionHistory[eventTransmissionHistoryIndex] = 0; // Prevent trying to remove the same events again
|
|
eventsQueueIndexAtLastTransmission = eventsQueueIndex;
|
|
|
|
networkedData = new byte[0];
|
|
|
|
// If there was a full sync in the queue, it has now been transmitted at least once
|
|
hasFullSyncReady = false;
|
|
|
|
lastEventTransmissionTime = targetTicks;
|
|
}
|
|
#endregion
|
|
|
|
#region Receiver
|
|
public void RequestEvent(NetworkEventType eventType)
|
|
{
|
|
if (!Ready)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (IsOwner)
|
|
{
|
|
Debug.LogError($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Attempted {nameof(RequestEvent)} while we are the owner!");
|
|
return;
|
|
}
|
|
|
|
SendCustomNetworkEvent(VRC.Udon.Common.Interfaces.NetworkEventTarget.Owner, "RequestEventReceived", eventType);
|
|
|
|
if (tester != null)
|
|
{
|
|
tester.RequestEvent(eventType);
|
|
}
|
|
}
|
|
|
|
private void StoreIncomingData()
|
|
{
|
|
if (networkedData == null || networkedData.Length == 0)
|
|
{
|
|
return; // Nothing to store
|
|
}
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Received {networkedData.Length} bytes!\nBytes received:\n{ArrayToString(networkedData)}");
|
|
|
|
var length = networkedData.Length;
|
|
int index = 0;
|
|
int eventSize = 0; // Store event size here so we can increment the index no matter how we increment the loop
|
|
while ((index += eventSize) < length)
|
|
{
|
|
if (length - index < HeaderLength)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) {nameof(StoreIncomingData)}: Remaining data in networkedData is not long enough to form a complete event! remaining: {length - index}.");
|
|
HandleError(false);
|
|
return;
|
|
}
|
|
|
|
eventSize = GetEventSizeFromHeader(networkedData, index);
|
|
|
|
if (length - index < eventSize)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) {nameof(StoreIncomingData)}: Event size is larger than total remaining data! {nameof(eventSize)}: {eventSize}, remaining: {length - index}.");
|
|
HandleError(false);
|
|
return;
|
|
}
|
|
|
|
if (length - index < HeaderLength)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) {nameof(StoreIncomingData)}: Event size is not long enough to form a complete event! {nameof(eventSize)}: {eventSize}, minimum needed: {HeaderLength}.");
|
|
HandleError(false);
|
|
return;
|
|
}
|
|
|
|
var @event = GetArrayPart(networkedData, index, eventSize);
|
|
|
|
var timestamp = GetTimestampFromHeader(@event);
|
|
var eventId = GetEventIdFromHeader(@event);
|
|
var eventType = GetEventTypeFromHeader(@event);
|
|
|
|
if (eventType != NetworkEventType.FullSyncForced && (Synced || hasFullSyncReady))
|
|
{
|
|
// Check if event id is sequential
|
|
if (eventId != GetNextEventId(lastEventId))
|
|
{
|
|
if (index + eventSize >= length // If this is the last event of the batch
|
|
&& eventId != lastEventId) // Unless the eventId is the same, then this is probably just a duplicate
|
|
{
|
|
// The last event of the batch has to be synced up with our current event id count, else we've missed an event
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) EventIds were not sequential! Did we miss an event? Timestamp: {timestamp}, eventId: {eventId}, lastEventId: {lastEventId}.");
|
|
HandleError(false);
|
|
return;
|
|
}
|
|
|
|
// We've likely already processed this event, ignore it
|
|
continue;
|
|
}
|
|
|
|
QueueEventInBuffer(@event);
|
|
|
|
//Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)} Queued event with id {eventId}");
|
|
}
|
|
else
|
|
{
|
|
// If we're not yet synced, we only care about full sync events.
|
|
if (IsFullSync(eventType))
|
|
{
|
|
QueueFullSyncForReplay(@event); // Immediately process full sync
|
|
}
|
|
}
|
|
|
|
lastEventId = eventId;
|
|
}
|
|
|
|
if (Synced)
|
|
{
|
|
UpdateNextEventTime();
|
|
}
|
|
}
|
|
|
|
private void QueueFullSyncForReplay(byte[] @event)
|
|
{
|
|
// Clear buffer and put the full sync into it
|
|
ClearBuffer();
|
|
QueueEventInBuffer(@event);
|
|
|
|
// Set this event to play after the default delay
|
|
nextEventTime = targetTicks + delay;
|
|
|
|
hasFullSyncReady = true;
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Queued full sync in buffer, should execute at {nextEventTime}.");
|
|
}
|
|
|
|
private void ApplyReceivedEvents()
|
|
{
|
|
IsEventUpdate = true;
|
|
|
|
while (eventsQueueIndex > 0 && nextEventTime <= SyncedTimeTicks)
|
|
{
|
|
var success = ApplyEvent(eventsQueue[0]);
|
|
|
|
if (!success)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DequeueEventsFromBuffer(1);
|
|
UpdateNextEventTime();
|
|
}
|
|
}
|
|
|
|
private bool ApplyEvent(byte[] @event)
|
|
{
|
|
var timestamp = GetTimestampFromHeader(@event);
|
|
var eventType = GetEventTypeFromHeader(@event);
|
|
|
|
var isFullSync = IsFullSync(eventType);
|
|
|
|
if (!Synced || eventType == NetworkEventType.FullSyncForced)
|
|
{
|
|
SyncToTimestamp(timestamp);
|
|
}
|
|
else if (timestamp < SyncedTimeTicks)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Next received event is in the past! " +
|
|
$"{nameof(nextEventTime)}: {nextEventTime} < {nameof(SyncedTimeTicks)}: {SyncedTimeTicks}.");
|
|
HandleError(true);
|
|
return false;
|
|
}
|
|
|
|
var index = (int)HeaderLength; // Skip header
|
|
|
|
var subscribers = GetEventSubscribers(eventType);
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) ApplyEvent with dt {SyncedDeltaTime}");
|
|
|
|
if (subscribers != null)
|
|
{
|
|
foreach (var obj in subscribers)
|
|
{
|
|
obj.SyncedUpdate();
|
|
}
|
|
|
|
foreach (var obj in subscribers)
|
|
{
|
|
var success = obj.WriteSyncedData(@event, ref index, eventType);
|
|
|
|
if (!success)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Malformed data reported by {obj.name} during event type {eventType}!");
|
|
HandleError(true);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
var eventSize = GetEventSizeFromHeader(@event);
|
|
if (index != eventSize)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Amount of data read does not match event size! Expected {eventSize}, read {index}.");
|
|
HandleError(true);
|
|
return false;
|
|
}
|
|
|
|
if (!Synced && isFullSync)
|
|
{
|
|
hasFullSyncReady = false;
|
|
Synced = true;
|
|
}
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Performed incoming event of type {eventType}! Total {index} bytes.");
|
|
|
|
retriesWithoutSuccess = 0; // We had success!
|
|
|
|
return true;
|
|
}
|
|
|
|
public override void OnDeserialization()
|
|
{
|
|
if (!Ready || IsOwner)
|
|
{
|
|
return;
|
|
}
|
|
|
|
StoreIncomingData();
|
|
}
|
|
#endregion
|
|
|
|
#region Buffer
|
|
private void ClearBuffer()
|
|
{
|
|
eventsQueue = new byte[BufferMaxTotalEvents][];
|
|
eventsQueueIndex = 0;
|
|
lastEventId = 0;
|
|
hasFullSyncReady = false;
|
|
|
|
eventTransmissionHistory = new int[maxEventSendTries];
|
|
eventTransmissionHistoryIndex = 0;
|
|
eventsQueueIndexAtLastTransmission = 0;
|
|
eventsToSend = new NetworkEventType[BufferMaxTotalEvents];
|
|
eventsToSendIndex = 0;
|
|
}
|
|
|
|
private void DequeueEventsFromBuffer(int eventCount)
|
|
{
|
|
if (eventCount > eventsQueueIndex) // Never remove more events than are in the queue
|
|
{
|
|
eventCount = eventsQueueIndex;
|
|
}
|
|
|
|
var oldBuffer = eventsQueue;
|
|
eventsQueueIndex -= eventCount;
|
|
eventsQueue = new byte[BufferMaxTotalEvents][];
|
|
Array.Copy(oldBuffer, eventCount, eventsQueue, 0, eventsQueueIndex);
|
|
}
|
|
|
|
private bool QueueEventInBuffer(byte[] @event)
|
|
{
|
|
if (eventsQueueIndex >= BufferMaxTotalEvents)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Buffer not large enough to store event! Maximum event count: {BufferMaxTotalEvents}.");
|
|
HandleError(true);
|
|
return false;
|
|
}
|
|
|
|
eventsQueue[eventsQueueIndex++] = @event;
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region Time
|
|
private void UpdateInternalTime()
|
|
{
|
|
if (paused && !stepNext)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (paused && stepNext)
|
|
{
|
|
targetTicks++;
|
|
stepNext = false;
|
|
return;
|
|
}
|
|
|
|
targetTicks = (int)((Time.fixedTime - startTime) / tickDelta);
|
|
}
|
|
|
|
private void ProgressSyncedTime()
|
|
{
|
|
SyncedTimeTicks++;
|
|
SyncedTime = SyncedTimeTicks * tickDelta;
|
|
}
|
|
|
|
private void SyncToTimestamp(int timestamp)
|
|
{
|
|
startTime = Time.fixedTime - timestamp * tickDelta;
|
|
targetTicks = timestamp;
|
|
SyncedTimeTicks = timestamp;
|
|
SyncedTime = SyncedTimeTicks * tickDelta;
|
|
nextEventTime = timestamp;
|
|
|
|
Debug.Log($"({nameof(PacManUdon)} {nameof(NetworkManager)}) Synced to timestamp {timestamp}, internalTime is now {targetTicks}, SyncedTime is now {SyncedTime}, nextEventTime is now {nextEventTime}");
|
|
}
|
|
|
|
private void UpdateNextEventTime()
|
|
{
|
|
if (eventsQueueIndex == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var nextEventTime = GetTimestampFromHeader(eventsQueue[0]);
|
|
|
|
if (nextEventTime < this.nextEventTime)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) New event is earlier than previous event!");
|
|
HandleError(true);
|
|
return;
|
|
}
|
|
|
|
if (nextEventTime < SyncedTimeTicks)
|
|
{
|
|
Debug.LogWarning($"({nameof(PacManUdon)} {nameof(NetworkManager)}) New event timestamp is earlier than our current synced time by {SyncedTime - nextEventTime} seconds! nextEventTime: {nextEventTime} SyncedTime: {SyncedTime}, internalTime: {targetTicks}");
|
|
HandleError(true);
|
|
return;
|
|
}
|
|
|
|
this.nextEventTime = nextEventTime;
|
|
}
|
|
#endregion
|
|
|
|
#region Header
|
|
private static byte GetNextEventId(byte currentEventId)
|
|
{
|
|
if (currentEventId == byte.MaxValue) // Udon forces overflow checks
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
currentEventId += 1;
|
|
|
|
return currentEventId;
|
|
}
|
|
|
|
private static bool IsFullSync(NetworkEventType eventType)
|
|
=> eventType == NetworkEventType.FullSync || eventType == NetworkEventType.FullSyncForced;
|
|
|
|
private static ushort GetEventSizeFromHeader(byte[] @event, int eventIndex = 0)
|
|
=> BitConverter.ToUInt16(@event, eventIndex + HeaderEventSizeIndex);
|
|
|
|
private static NetworkEventType GetEventTypeFromHeader(byte[] @event, int eventIndex = 0) =>
|
|
(NetworkEventType)@event[eventIndex + HeaderEventTypeIndex];
|
|
|
|
private static int GetTimestampFromHeader(byte[] @event, int eventIndex = 0) =>
|
|
BitConverter.ToInt32(@event, eventIndex + HeaderTimestampIndex);
|
|
|
|
private static byte GetEventIdFromHeader(byte[] @event, int eventIndex = 0) =>
|
|
@event[eventIndex + HeaderEventIdIndex];
|
|
#endregion
|
|
|
|
#region VRC events
|
|
public override void OnOwnershipTransferred(VRCPlayerApi newOwner)
|
|
{
|
|
if (!Ready)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool newOwnerIsLocalPlayer = newOwner == Networking.LocalPlayer;
|
|
IsOwner = newOwnerIsLocalPlayer;
|
|
|
|
if (newOwnerIsLocalPlayer)
|
|
{
|
|
SendEventSoon(NetworkEventType.FullSyncForced);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Utils
|
|
public string ArrayToString(byte[] bytes)
|
|
{
|
|
var sb = new StringBuilder("[ ");
|
|
foreach (var b in bytes)
|
|
{
|
|
sb.Append(b + " ");
|
|
}
|
|
sb.Append("]");
|
|
return sb.ToString();
|
|
}
|
|
|
|
public string ArrayToString(int[] bytes)
|
|
{
|
|
var sb = new StringBuilder("[ ");
|
|
foreach (var b in bytes)
|
|
{
|
|
sb.Append(b + " ");
|
|
}
|
|
sb.Append("]");
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static int GetFlattenedSize(byte[][] data, int start, int length)
|
|
{
|
|
var size = 0;
|
|
for (int i = start; i < start + length; i++)
|
|
{
|
|
size += data[i].Length;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
private static byte[] Flatten(byte[][] data, int start, int length)
|
|
{
|
|
var finalLength = GetFlattenedSize(data, start, length);
|
|
|
|
var result = new byte[finalLength];
|
|
int resultIndex = 0;
|
|
|
|
for (int sourceIndex = start; sourceIndex < start + length; sourceIndex++)
|
|
{
|
|
var array = data[sourceIndex];
|
|
Array.Copy(array, 0, result, resultIndex, array.Length);
|
|
resultIndex += array.Length;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static byte[] GetArrayPart(byte[] data, int start, int length)
|
|
{
|
|
var result = new byte[length];
|
|
Array.Copy(data, start, result, 0, length);
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region SyncedData
|
|
public override void CollectSyncedData(byte[] data, ref int index, NetworkEventType eventType)
|
|
{
|
|
// Nothing
|
|
}
|
|
|
|
public override bool WriteSyncedData(byte[] data, ref int index, NetworkEventType eventType)
|
|
{
|
|
switch (eventType)
|
|
{
|
|
case NetworkEventType.Pause:
|
|
Pause();
|
|
break;
|
|
case NetworkEventType.Resume:
|
|
Resume();
|
|
break;
|
|
case NetworkEventType.Step:
|
|
Step();
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region Debug
|
|
public void SimulateSyncToTimestamp(float timestamp)
|
|
{
|
|
//SyncToTimestamp(timestamp);
|
|
}
|
|
|
|
public void WriteDebugOutput(TMP_InputField debugOutput)
|
|
{
|
|
debugOutput.text = $"{nameof(NetworkManager)}:\n" +
|
|
$"IsOwner: {IsOwner}\n" +
|
|
$"Ready: {Ready}\n" +
|
|
$"Synced: {Synced}\n" +
|
|
$"hasFullSyncReady: {hasFullSyncReady}\n" +
|
|
$"lastEventId: {lastEventId}\n" +
|
|
$"Time.fixedTime: {Time.fixedTime}\n" +
|
|
$"startTime: {startTime}\n" +
|
|
$"targetTicks: {targetTicks}\n" +
|
|
$"SyncedTime: {SyncedTime}\n" +
|
|
$"Dt: {SyncedDeltaTime}\n" +
|
|
$"BufferIndex: {eventsQueueIndex}\n" +
|
|
$"BufferIndexHistory: {ArrayToString(eventTransmissionHistory)}\n" +
|
|
$"\n";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Text field to display debug info in.
|
|
/// </summary>
|
|
[SerializeField] private TMP_InputField debugOutput;
|
|
|
|
/// <summary>
|
|
/// An animator which visualizes whether the current perspective is the owner.
|
|
/// </summary>
|
|
[SerializeField] private Animator DebugImageToIndicateOwner;
|
|
|
|
/// <summary>
|
|
/// An animator which visualizes whether the NetworkManager is synced.
|
|
/// </summary>
|
|
[SerializeField] private Animator DebugImageToIndicateSynced;
|
|
|
|
/// <summary>
|
|
/// An animator which visualizes whether the NetworkManager is synced.
|
|
/// </summary>
|
|
[SerializeField] private Animator DebugImageToIndicateReady;
|
|
|
|
private NetworkManagerTester tester;
|
|
public void SetNetworkManagerTester(NetworkManagerTester tester)
|
|
{
|
|
this.tester = tester;
|
|
}
|
|
|
|
public byte[] NetworkedData
|
|
{
|
|
get => networkedData;
|
|
set => networkedData = value;
|
|
}
|
|
|
|
public bool SerializationRequested => serializationRequested;
|
|
|
|
public void SetIsOwner(bool isOwner) => IsOwner = isOwner;
|
|
|
|
public void DoFullSync()
|
|
{
|
|
SendEventSoon(NetworkEventType.FullSync);
|
|
}
|
|
|
|
public void DoPelletSync()
|
|
{
|
|
SendEventSoon(NetworkEventType.SyncPellets);
|
|
}
|
|
|
|
public void DoGhostSync()
|
|
{
|
|
SendEventSoon(NetworkEventType.GhostUpdate);
|
|
}
|
|
|
|
public void DoTimeSequenceSync()
|
|
{
|
|
SendEventSoon(NetworkEventType.TimeSequenceSync);
|
|
}
|
|
|
|
public void Pause()
|
|
{
|
|
paused = true;
|
|
stepNext = false;
|
|
}
|
|
|
|
private void Resume()
|
|
{
|
|
paused = false;
|
|
stepNext = false;
|
|
}
|
|
|
|
private void Step()
|
|
{
|
|
paused = true;
|
|
stepNext = true;
|
|
}
|
|
|
|
public void PauseButtonPressed()
|
|
{
|
|
Pause();
|
|
SendEventSoon(NetworkEventType.Pause);
|
|
}
|
|
|
|
public void ResumeButtonPressed()
|
|
{
|
|
Resume();
|
|
SendEventSoon(NetworkEventType.Resume);
|
|
}
|
|
|
|
public void StepButtonPressed()
|
|
{
|
|
Step();
|
|
SendEventSoon(NetworkEventType.Step);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|