private void ProcessIncomingMessage <T>(EndPoint endpoint, TeleportReader reader) where T : ITeleportMessage, new()
{
var message = new T();
message.Deserialize(reader);
OnMessageArrival(endpoint, message);
}
public void OnClientDespawn(TeleportReader reader, GameObject despawned)
{
var instanceId = _instanceIdByInstance[despawned];
_instanceIdByInstance.Remove(despawned);
_instanceByInstanceId.Remove(instanceId);
}
public void OnClientSpawn(ushort instanceId, TeleportReader reader, GameObject spawned)
{
spawned.name = "ClientSpawn_" + spawned.name;
_instanceIdByInstance[spawned] = instanceId;
_instanceByInstanceId[instanceId] = spawned;
PostClientSpawn(reader, spawned);
}
protected override void PostClientSpawn(TeleportReader reader, GameObject spawned)
{
base.PostClientSpawn(reader, spawned);
var color = reader.ReadColor();
ApplyColor(color, spawned);
}
private void DeserializeClient(EndPoint e, TeleportReader r)
{
var seq = r.ReadInt32();
Debug.Log("Client got data");
_clientMissingSeqs.Remove(seq);
}
private void DeserializeServer(EndPoint e, TeleportReader r)
{
Debug.Log("Server got data");
var seq = r.ReadInt32();
_serverMissingSeqs.Remove(seq);
}
public GameObject ClientSideSpawn(ushort instanceId, TeleportReader reader)
{
var spawned = CreateInstance();
spawned.name = "ClientSpawn_" + spawned.name;
_instanceIdByInstance[spawned] = instanceId;
_instanceByInstanceId[instanceId] = spawned;
PostClientSpawn(reader, spawned);
return(spawned);
}
protected void ProcessMessage(EndPoint endpoint, byte msgTypeId, TeleportReader reader)
{
Action <EndPoint, TeleportReader> processor;
if (!_incomingMessageProcessors.TryGetValue(msgTypeId, out processor))
{
throw new Exception("Unknown msg type id, don't know how to process: " + msgTypeId);
}
processor(endpoint, reader);
}
public override void Deserialize(TeleportReader reader)
{
base.Deserialize(reader);
SpawnId = reader.ReadUInt16();
_instanceId = reader.ReadUInt16();
// The reader will be closed by the time we use it, so we create a new reader
var rawData = ((MemoryStream)reader.BaseStream).ToArray();
var data = new byte[rawData.Length - reader.BaseStream.Position];
Array.Copy(rawData, reader.BaseStream.Position, data, 0, data.Length);
_reader = new TeleportReader(data);
}
protected override void HandleIncomingMessage(EndPoint sender, TeleportReader reader)
{
TeleportClientData clientData;
var msgTypeId = reader.ReadByte();
if (!_clientDataByEndpoint.TryGetValue(sender, out clientData))
{
if (msgTypeId != TeleportMsgTypeIds.Handshake)
{
throw new Exception("First message must be handshake!");
}
clientData = PerformFirstMessageAuthentication(sender, reader);
return;
}
switch (msgTypeId)
{
case TeleportMsgTypeIds.Handshake:
break; // Already handshaked, do nothing
case TeleportMsgTypeIds.Disconnect:
clientData = GetClientData(sender);
CleanupClientData(clientData);
OnClientDisconnect(clientData.clientId, DisconnectReasonType.ClientInitiatedDisconnect);
break;
case TeleportMsgTypeIds.TimeSync:
ReplyToTimeSyncRequest(sender, reader);
break;
case TeleportMsgTypeIds.ClientReady:
clientData = GetClientData(sender);
if (clientData.isReady)
{
UnityEngine.Debug.LogError("Client notified ready twice: " + sender.ToString());
break;
}
clientData.isReady = true;
OnClientConnected(clientData.clientId, sender);
break;
default:
ProcessMessage(sender, msgTypeId, reader);
break;
}
}
public override void Deserialize(TeleportReader reader)
{
base.Deserialize(reader);
_spawnId = reader.ReadUInt16();
var stateAmount = reader.ReadUInt16();
var spawner = TeleportManager.Main.GetClientSpawner(_spawnId);
_states = new ITeleportState[stateAmount];
ITeleportState currentState;
for (int i = 0; i < stateAmount; i++)
{
currentState = spawner.GenerateEmptyState();
currentState.Deserialize(reader);
_states[i] = currentState;
}
}
private void HandleTimeSyncReponse(TeleportReader reader)
{
var clientTimeOnRequestSent = reader.ReadSingle();
var serverTimeOnRequestArrival = reader.ReadSingle();
var clientTimeOnResponseArrival = LocalTime;
var totalRoundtripDuration = clientTimeOnResponseArrival - clientTimeOnRequestSent;
var estimatedReturnTripDuration = totalRoundtripDuration * 0.5f;
var estimatedServerTime = serverTimeOnRequestArrival + estimatedReturnTripDuration;
var delta = estimatedServerTime - ServerTime;
var absDelta = Math.Abs(delta);
var deltaSign = Math.Sign(delta);
IsTimeSynchronized = true;
State = StateType.Connected;
if (absDelta > TIME_SYNC_MAX_TIME_DRIFT_BEFORE_HARD_SET_IN_SECONDS)
{
ServerTime = estimatedServerTime;
}
else
{
ServerTime += Math.Max(absDelta, TIME_SYNC_MAX_TIME_DRIFT_MAGNITUDE) * deltaSign;
}
}
private void HandleTimeSyncReponse(TeleportReader reader)
{
_isWaitingForTimesync = false;
bool shouldNotifyReady = !IsTimeSynchronized;
var clientTimeOnRequestSent = reader.ReadSingle();
var serverTimeOnRequestArrival = reader.ReadSingle();
var clientTimeOnResponseArrival = LocalTime;
var totalRoundtripDuration = clientTimeOnResponseArrival - clientTimeOnRequestSent;
_lastKnownPing = Mathf.CeilToInt(totalRoundtripDuration * 1000);
if (totalRoundtripDuration > TIME_SYNC_MAX_RESPONSE_DELAY)
{
Debug.LogWarning("Ignoring timesync response, took too long. RTT: " + totalRoundtripDuration);
return;
}
var estimatedReturnTripDuration = totalRoundtripDuration * 0.5f;
var estimatedServerTime = serverTimeOnRequestArrival + estimatedReturnTripDuration;
var delta = estimatedServerTime - ServerTime;
var absDelta = Math.Abs(delta);
var deltaSign = Math.Sign(delta);
IsTimeSynchronized = true;
State = StateType.Connected;
if (absDelta > TIME_SYNC_MAX_TIME_DRIFT_BEFORE_HARD_SET_IN_SECONDS)
{
ServerTime = estimatedServerTime;
}
else
{
ServerTime += Math.Max(absDelta, TIME_SYNC_MAX_TIME_DRIFT_MAGNITUDE) * deltaSign;
}
if (shouldNotifyReady)
{
SendClientReady();
}
}
protected override void HandleIncomingMessage(EndPoint sender, TeleportReader reader)
{
var msgTypeId = reader.ReadByte();
switch (msgTypeId)
{
case TeleportMsgTypeIds.Handshake:
ProcessHandshake(reader);
OnConnectionEstablisehd(_clientId);
break;
case TeleportMsgTypeIds.Disconnect:
Disconnect(DisconnectReasonType.ServerRequestedDisconnect);
break;
case TeleportMsgTypeIds.TimeSync:
HandleTimeSyncReponse(reader);
break;
default:
ProcessMessage(sender, msgTypeId, reader);
break;
}
}
public override void Deserialize(TeleportReader reader)
{
base.Deserialize(reader);
}
protected virtual void PostClientSpawn(TeleportReader reader, GameObject spawned)
{
}
public static string DebugString(TeleportReader reader)
{
return(DebugString((MemoryStream)reader.BaseStream));
}
protected abstract void HandleIncomingMessage(EndPoint sender, TeleportReader reader);
private void InternalHandleIncomingMessage(EndPoint sender, TeleportReader reader)
{
HandleIncomingMessage(sender, reader);
}
private TeleportClientData PerformFirstMessageAuthentication(EndPoint sender, TeleportReader reader)
{
TeleportClientData clientData;
var header = reader.ReadByte();
var isFirstAuth = (header & 1) == 0;
byte authKey;
uint clientId;
if (isFirstAuth)
{
authKey = 13; // TODO: Randomize
clientId = _nextClientId;
_nextClientId++;
clientData = new TeleportClientData()
{
endpoint = sender,
isAuthenticated = true,
authKey = authKey,
clientId = clientId,
};
_clientDataByEndpoint[sender] = clientData;
_clientDataById[clientId] = clientData;
Send((w) =>
{
w.Write(TeleportMsgTypeIds.Handshake);
w.Write(authKey);
w.Write(clientId);
});
OnClientConnected(clientId, sender);
}
else
{
authKey = (byte)(header >> 1);
clientId = reader.ReadUInt32();
clientData = _clientDataById[clientId];
if (authKey != clientData.authKey)
{
throw new Exception("Auth key mismatches");
}
}
return(clientData);
}
public override void Deserialize(TeleportReader reader)
{
base.Deserialize(reader);
_msgSeq = reader.ReadInt32();
}
private void ReplyToTimeSyncRequest(EndPoint sender, TeleportReader reader)
{
var clientTime = reader.ReadSingle();
SendToEndpoints((w) => SerializeTimeSyncResponse(w, clientTime), 0, sender);
}
public virtual void Deserialize(TeleportReader reader)
{
}
private void ProcessHandshake(TeleportReader reader)
{
_authKey = reader.ReadByte();
_clientId = reader.ReadUInt32();
_isAuthenticated = true;
}
public override void Deserialize(TeleportReader reader)
{
Timestamp = reader.ReadSingle();
base.Deserialize(reader);
}
public void Deserialize(TeleportReader reader)
{
InstanceId = reader.ReadUInt16();
Position = reader.ReadVector3(FloatCompressionTypeShort.Short_Two_Decimals);
Rotation = reader.ReadQuaternion(FloatCompressionTypeShort.Short_Two_Decimals);
}
