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(); } } }