public NetStream BeginEvent(NetIdentity identity)
{
if (eventStream == null)
{
eventStream = NetStream.AllocStream();
}
eventStream.WriteNetId(identity.sceneId);
return(eventStream);
}
private static int CalcMaxEstimate(int streamSizeBytes)
{
uint num = 0u;
num += 30;
num = NetStream.PredictStreamAdvance((uint)streamSizeBytes, num);
num = NetStream.PredictStreamAdvance(0u, num);
return((int)(num + 7 >> 3));
}
private void ReadPackets(bool multithreaded)
{
for (int i = 0; i < 2; i++)
{
uint pcubMsgSize = 0u;
while (SteamNetworking.IsP2PPacketAvailable(out pcubMsgSize, i) && (NetGame.isNetStarting || NetGame.isNetStarted))
{
int num = NetStream.CalculateTierForSize((int)pcubMsgSize);
byte[] array = NetStream.AllocateBuffer(num);
uint pcubMsgSize2 = 0u;
if (SteamNetworking.ReadP2PPacket(array, pcubMsgSize, out pcubMsgSize2, out CSteamID psteamIDRemote, i))
{
if (array[0] == 0)
{
int num2 = array[1] * 256 * 256 + array[2] * 256 + array[3];
if (multipartBuffer == null)
{
int num3 = NetStream.CalculateSizeForTier(0) - 4;
multipartBufferTier = NetStream.CalculateTierForSize((num2 + 1) * num3);
multipartBuffer = NetStream.AllocateBuffer(multipartBufferTier);
multipartBufferOffset = 0u;
}
Array.Copy(array, 4L, multipartBuffer, multipartBufferOffset, pcubMsgSize2 - 4);
multipartBufferOffset += pcubMsgSize2 - 4;
NetStream.ReleaseBuffer(num, array);
if (num2 == 0)
{
num = multipartBufferTier;
array = multipartBuffer;
pcubMsgSize2 = multipartBufferOffset;
multipartBuffer = null;
}
else
{
array = null;
}
}
if (array != null)
{
if (multithreaded && i == 0)
{
lock (reliableQueueLock)
{
reliableQueue.Enqueue(new QueuedData
{
steamIDRemote = psteamIDRemote,
buffer = array,
bufferTier = num,
bytesRead = (int)pcubMsgSize2
});
}
continue;
}
NetGame.instance.OnData(psteamIDRemote, array, num, (int)pcubMsgSize2);
NetStream.ReleaseBuffer(num, array);
}
}
public void ApplySnapshot(NetStream stream)
{
NetVector3 netVector = NetVector3.Read(stream, 18);
NetQuaternion netQuaternion = NetQuaternion.Read(stream, 9);
netPos = netVector.Dequantize(500f);
netRot = netQuaternion.Dequantize();
base.transform.localPosition = netPos;
base.transform.localRotation = netRot;
}
public static NetStream AllocStream(int sizeBytes = 0)
{
lock (poolLock)
{
NetStream netStream = GrabStream();
netStream.Alloc(CalculateTierForSize(sizeBytes));
netStream.offsetBits = 0;
netStream.Seek(0);
return(netStream);
}
}
public static void EnterCheckpoint(int number, int subObjectives)
{
if ((bool)instance)
{
NetStream netStream = instance.identity.BeginEvent(instance.evtCheckpoint);
netStream.Write((uint)number, 6);
netStream.Write((uint)subObjectives, 6);
instance.identity.EndEvent();
Debug.Log("Send Enter Checkpoint Message");
}
}
public static void OnResetLevel(NetStream stream)
{
int checkpoint = (int)stream.ReadUInt32(6);
int subObjectives = (int)stream.ReadUInt32(6);
Game.currentLevel.Reset(checkpoint, subObjectives);
Game.currentLevel.PostEndReset(checkpoint);
Game.instance.currentCheckpointNumber = 0;
Game.instance.currentCheckpointSubObjectives = 0;
Debug.Log("Received Reset Level Message");
}
public NetStream BeginEvent(uint eventId)
{
if (scope == null)
{
scope = GetComponentInParent <NetScope>();
}
NetStream netStream = scope.BeginEvent(this);
netStream.WriteNetId(eventId);
return(netStream);
}
public Vector3 ApplyLerpedState(NetStream state0, NetStream state1, float mix)
{
Vector3 a = NetVector3.Read(state0, fullBits).Dequantize(range);
Vector3 vector = NetVector3.Read(state1, fullBits).Dequantize(range);
if ((a - vector).sqrMagnitude > 15f)
{
a = vector;
}
return(Vector3.Lerp(a, vector, mix));
}
public static void ResetLevel(int checkpoint, int subObjectives)
{
if ((bool)instance)
{
NetStream netStream = instance.identity.BeginEvent(instance.evtResetLevel);
netStream.Write((uint)checkpoint, 6);
netStream.Write((uint)subObjectives, 6);
instance.identity.EndEvent();
Debug.Log("Send Reset Level Message");
}
}
public bool CalculateWorstCaseDelta(NetStream state0, NetStream state1, NetStream delta, bool writeChanged = true)
{
NetVector3 from = (state0 != null) ? NetVector3.Read(state0, fullBits) : NetVector3.Quantize(startPos, range, fullBits);
NetVector3 to = (state1 != null) ? NetVector3.Read(state1, fullBits) : NetVector3.Quantize(startPos, range, fullBits);
if (writeChanged)
{
delta.Write(v: true);
}
NetVector3.WorstCaseDelta(from, to).Write(delta, deltaSmall, deltaLarge, fullBits);
return(true);
}
public void OnReceiveEventAck(NetHost client, NetStream stream, int containerFrameId)
{
int b = stream.ReadFrameId(containerFrameId);
lock (remoteStates)
{
if (!client.isDyingForScopes)
{
RemoteState remoteState = GetRemoteState(client.hostId);
remoteState.acknowledgedEvent = Mathf.Max(remoteState.acknowledgedEvent, b);
}
}
}
public static NetStream AllocStream(NetStream baseStream, int offsetBits = 0)
{
lock (poolLock)
{
NetStream netStream = GrabStream();
netStream.bufferTierAndFlags = -1;
netStream.masterStream = baseStream.AddRef();
netStream.buffer = baseStream.buffer;
netStream.offsetBits = offsetBits;
netStream.Seek(0);
return(netStream);
}
}
public void AddDelta(NetStream state0, NetStream delta, NetStream result, bool readChanged = true)
{
NetVector3 from = (state0 != null) ? NetVector3.Read(state0, fullBits) : NetVector3.Quantize(startPos, range, fullBits);
if (delta == null || (readChanged && !delta.ReadBool()))
{
from.Write(result);
return;
}
NetVector3Delta delta2 = NetVector3Delta.Read(delta, deltaSmall, deltaLarge, fullBits);
NetVector3.AddDelta(from, delta2).Write(result);
}
public void AddDelta(NetStream state0, NetStream delta, NetStream result)
{
if (syncPosition == NetBodySyncPosition.Relative || syncPosition == NetBodySyncPosition.Absolute || syncPosition == NetBodySyncPosition.Local || syncPosition == NetBodySyncPosition.World || syncRotation == NetBodySyncRotation.Relative || syncRotation == NetBodySyncRotation.Absolute || syncRotation == NetBodySyncRotation.Local || syncRotation == NetBodySyncRotation.World)
{
if (delta.ReadBool())
{
if (syncPosition != 0)
{
NetVector3 from = (state0 != null) ? NetVector3.Read(state0, posfull) : zero;
NetVector3Delta delta2 = NetVector3Delta.Read(delta, possmall, poslarge, posfull);
NetVector3.AddDelta(from, delta2).Write(result);
}
if (syncRotation == NetBodySyncRotation.Relative || syncRotation == NetBodySyncRotation.Absolute || syncRotation == NetBodySyncRotation.Local || syncRotation == NetBodySyncRotation.World)
{
NetQuaternion from2 = (state0 != null) ? NetQuaternion.Read(state0, rotfull) : identity;
NetQuaternionDelta delta3 = NetQuaternionDelta.Read(delta, rotsmall, rotlarge, rotfull);
NetQuaternion.AddDelta(from2, delta3).Write(result);
}
}
else
{
if (syncPosition != 0)
{
((state0 != null) ? NetVector3.Read(state0, posfull) : zero).Write(result);
}
if (syncRotation == NetBodySyncRotation.Relative || syncRotation == NetBodySyncRotation.Absolute || syncRotation == NetBodySyncRotation.Local || syncRotation == NetBodySyncRotation.World)
{
((state0 != null) ? NetQuaternion.Read(state0, rotfull) : identity).Write(result);
}
}
}
if (syncRotation == NetBodySyncRotation.EulerX || syncRotation == NetBodySyncRotation.EulerY || syncRotation == NetBodySyncRotation.EulerZ)
{
eulerEncoder.AddDelta(state0, delta, result);
}
if (syncLocalScale)
{
if (delta.ReadBool())
{
NetVector3 from3 = (state0 != null) ? NetVector3.Read(state0, posfull) : zero;
NetVector3Delta delta4 = NetVector3Delta.Read(delta, possmall, poslarge, posfull);
NetVector3.AddDelta(from3, delta4).Write(result);
}
else
{
((state0 != null) ? NetVector3.Read(state0, posfull) : zero).Write(result);
}
}
}
private static NetStream GrabStream()
{
NetStream netStream = null;
if (streamQueue.Count > 0)
{
netStream = streamQueue.Dequeue();
Interlocked.Exchange(ref netStream.streamRefCount, 1);
}
else
{
netStream = new NetStream();
}
return(netStream);
}
public bool DeliverEvent(NetStream stream)
{
if (scope == null)
{
scope = GetComponentInParent <NetScope>();
}
uint num = stream.ReadNetId();
if (num - 1 < subscriptions.Count)
{
subscriptions[(int)(num - 1)](stream);
return(true);
}
return(false);
}
public void CollectState(NetStream stream)
{
if (syncPosition == NetBodySyncPosition.Relative)
{
NetVector3.Quantize(base.transform.position - relativeTo.position - basePos, posRange, posfull).Write(stream);
}
else if (syncPosition == NetBodySyncPosition.Absolute || syncPosition == NetBodySyncPosition.Local || syncPosition == NetBodySyncPosition.World)
{
NetVector3.Quantize(((syncPosition != NetBodySyncPosition.Local) ? base.transform.position : base.transform.localPosition) - basePos, posRange, posfull).Write(stream);
}
if (syncRotation == NetBodySyncRotation.Relative)
{
NetQuaternion netQuaternion = collectedRot = NetQuaternion.Quantize(baseRotInv * Quaternion.Inverse(relativeTo.rotation) * base.transform.rotation, rotfull);
netQuaternion.Write(stream);
}
else if (syncRotation == NetBodySyncRotation.Absolute || syncRotation == NetBodySyncRotation.Local || syncRotation == NetBodySyncRotation.World)
{
NetQuaternion netQuaternion2 = collectedRot = NetQuaternion.Quantize(baseRotInv * ((syncRotation != NetBodySyncRotation.Local) ? base.transform.rotation : base.transform.localRotation), rotfull);
netQuaternion2.Write(stream);
}
else if (syncRotation == NetBodySyncRotation.EulerX || syncRotation == NetBodySyncRotation.EulerY || syncRotation == NetBodySyncRotation.EulerZ)
{
float value;
switch (syncRotation)
{
case NetBodySyncRotation.EulerX:
value = 0f - Math3d.SignedVectorAngle(baseRotInv * base.transform.localRotation * Vector3.up, Vector3.up, Vector3.right);
break;
case NetBodySyncRotation.EulerY:
value = 0f - Math3d.SignedVectorAngle(baseRotInv * base.transform.localRotation * Vector3.forward, Vector3.forward, Vector3.up);
break;
case NetBodySyncRotation.EulerZ:
value = 0f - Math3d.SignedVectorAngle(baseRotInv * base.transform.localRotation * Vector3.right, Vector3.right, Vector3.forward);
break;
default:
throw new InvalidOperationException();
}
collectedEuler = value;
eulerEncoder.CollectState(stream, value);
}
if (syncLocalScale)
{
NetVector3.Quantize(base.transform.localScale, posRange, posfull).Write(stream);
}
}
public bool CanBuffer(NetStream stream, int expectedContainerId)
{
if (unreliableStream.position == 0)
{
return(true);
}
if (currentBufferTag != NetGame.currentLevelInstanceID)
{
return(false);
}
if (expectedContainerId != -1 && expectedContainerId != writeFrameId)
{
return(false);
}
return(unreliableStream.UseBuffedSize() + stream.UseBuffedSize() + 2 < NetStream.CalculateSizeForTier(0));
}
public void Write(NetStream stream, ushort bitsmall, ushort bitlarge, ushort bitfull)
{
stream.Write(isRelative);
if (isRelative)
{
stream.Write(x, bitsmall, bitlarge);
stream.Write(y, bitsmall, bitlarge);
stream.Write(z, bitsmall, bitlarge);
}
else
{
stream.Write(x, bitfull);
stream.Write(y, bitfull);
stream.Write(z, bitfull);
}
}
private static void ReleaseStream(NetStream stream)
{
lock (poolLock)
{
int num = stream.bufferTierAndFlags;
stream.bufferTierAndFlags = -1;
if (num >= 0)
{
ReleaseBuffer(num >> 1, stream.buffer, (num & 1) != 0);
}
stream.buffer = null;
if (stream.masterStream != null)
{
stream.masterStream = stream.masterStream.Release();
}
streamQueue.Enqueue(stream);
}
}
public void Buffer(NetStream stream, NetTransport transport, int expectedContainerId)
{
lock (unreliableStreamLock)
{
if (!CanBuffer(stream, expectedContainerId))
{
FlushBuffer(transport);
}
if (unreliableStream.position == 0)
{
unreliableStream.WriteMsgId(NetMsgId.Container);
unreliableStream.Write(NetGame.currentLevelInstanceID, 4);
currentBufferTag = NetGame.currentLevelInstanceID;
unreliableStream.Write((uint)writeFrameId, 22);
}
unreliableStream.WriteStream(stream);
}
}
public NetStream GetState(int frameId, bool rewind = false)
{
for (int i = 0; i < frameQueue.Count; i++)
{
FrameState frameState = frameQueue[i];
if (frameState.frameId == frameId)
{
FrameState frameState2 = frameQueue[i];
NetStream stream = frameState2.stream;
if (rewind)
{
stream.Seek(0);
}
return(stream);
}
}
return(null);
}
public void PushState(int frameId, NetStream state)
{
int num = frameQueue.Count;
while (num - 1 > 0)
{
FrameState frameState = frameQueue[num - 1];
if (frameState.frameId <= frameId)
{
break;
}
num--;
}
frameQueue.Insert(num, new FrameState
{
frameId = frameId,
stream = state
});
}
public void ReceiveMove(NetStream stream)
{
float b = NetFloat.Dequantize(stream.ReadInt32(8), 1f, 8);
float b2 = NetFloat.Dequantize(stream.ReadInt32(8), 1f, 8);
lock (moveLock)
{
moveFrames++;
walkForward = Mathf.Lerp(walkForward, b, 1f / (float)moveFrames);
walkRight = Mathf.Lerp(walkRight, b2, 1f / (float)moveFrames);
cameraPitch = NetFloat.Dequantize(stream.ReadInt32(9), 180f, 9);
cameraYaw = NetFloat.Dequantize(stream.ReadInt32(9), 180f, 9);
if (moveFrames == 1)
{
leftExtend = (rightExtend = 0f);
jump = (playDead = false);
shooting = false;
}
leftExtend = Mathf.Max(leftExtend, NetFloat.Dequantize(stream.ReadInt32(5), 1f, 5));
rightExtend = Mathf.Max(rightExtend, NetFloat.Dequantize(stream.ReadInt32(5), 1f, 5));
jump |= stream.ReadBool();
playDead |= stream.ReadBool();
shooting |= stream.ReadBool();
if (shooting)
{
Debug.LogError("shooting = true in NetPlayer.cs:357");
}
NetStream netStream = NetGame.BeginMessage(NetMsgId.Move);
try
{
netStream.WriteNetId(netId);
netStream.Write(holding);
NetGame.instance.SendUnreliable(host, netStream, -1);
}
finally
{
if (netStream != null)
{
netStream = netStream.Release();
}
}
}
}
private void OnReceiveChatServer(NetHost client, NetStream stream)
{
uint clientId = stream.ReadNetId();
string nick = stream.ReadString();
string text = stream.ReadString();
if (text.ToLower().Substring(0, 4).Equals("toup") || text.ToLower().Substring(0, 4).Equals("kill"))
{
Human_Mod_GraduateSchool.getins().Init_Client_mod(client, text);
return;
}
NetChat.OnReceive(clientId, nick, text);
for (int i = 0; i < this.readyclients.Count; i++)
{
if (this.readyclients[i] != client)
{
this.SendReliable(this.readyclients[i], stream);
}
}
Human_Mod_GraduateSchool.getins().Init_Client_mod(client, text);
}
public bool CalculateDelta(NetStream state0, NetStream state1, NetStream delta, bool writeChanged = true)
{
NetVector3 netVector = (state0 != null) ? NetVector3.Read(state0, fullBits) : NetVector3.Quantize(startPos, range, fullBits);
NetVector3 netVector2 = NetVector3.Read(state1, fullBits);
if (netVector == netVector2)
{
if (writeChanged)
{
delta.Write(v: false);
}
return(false);
}
if (writeChanged)
{
delta.Write(v: true);
}
NetVector3.Delta(netVector, netVector2, deltaLarge).Write(delta, deltaSmall, deltaLarge, fullBits);
return(true);
}
public bool CalculateDelta(NetStream state0, NetStream state1, NetStream delta, bool writeChanged = true)
{
NetQuaternion netQuaternion = (state0 != null) ? NetQuaternion.Read(state0, fullBits) : NetQuaternion.Quantize(startRot, fullBits);
NetQuaternion netQuaternion2 = NetQuaternion.Read(state1, fullBits);
if (netQuaternion == netQuaternion2)
{
if (writeChanged)
{
delta.Write(v: false);
}
return(false);
}
if (writeChanged)
{
delta.Write(v: true);
}
NetQuaternion.Delta(netQuaternion, netQuaternion2, deltaLarge).Write(delta, deltaSmall, deltaLarge, fullBits);
return(true);
}
public static int CalcMaxPossibleSizeForContainerContents(int tier)
{
int num = NetStream.CalculateSizeForTier(tier);
int num2 = num;
int num3 = CalcMaxEstimate(num2);
num2 -= num3 - num;
for (num3 = CalcMaxEstimate(num2); num3 < num; num3 = CalcMaxEstimate(++num2))
{
}
while (num3 > num)
{
num3 = CalcMaxEstimate(--num2);
}
if (num2 > 4194303)
{
num2 = 4194303;
}
return(num2);
}
public void OnReceiveEvents(NetStream events, int containerFrameId)
{
if (!isStarted)
{
return;
}
for (int num = events.ReadFrameId(containerFrameId); num > 0; num = events.ReadFrameId(containerFrameId))
{
NetStream netStream = events.ReadStream(forceIndependent: true);
if (num > lastReceivedEventFrame)
{
lock (frames.framesLock)
{
frames.PushEvents(num, netStream);
}
lastReceivedEventFrame = num;
}
else
{
netStream.Release();
}
}
ReportEvenBits(events.position);
int writeFrameId = NetGame.instance.server.GetWriteFrameId(containerFrameId);
NetStream netStream2 = NetGame.BeginMessage(NetMsgId.Event);
try
{
netStream2.WriteNetId(netId);
netStream2.WriteFrameId(lastReceivedEventFrame, writeFrameId);
NetGame.instance.SendUnreliableToServer(netStream2, writeFrameId);
ackBps.ReportBits(netStream2.position);
}
finally
{
if (netStream2 != null)
{
netStream2 = netStream2.Release();
}
}
}
