public void TestStringDiff() { var testString = "Hello, World"; // The simulated "new" value of testString var originalString = "Heyo, World"; // This is what testString supposedly changed *from* var outNetworkBuffer = new NetworkBuffer(); var outNetworkWriter = new NetworkWriter(outNetworkBuffer); outNetworkWriter.WriteStringDiff(testString, originalString); outNetworkWriter.WriteStringDiff(testString, originalString, true); var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer()); var inNetworkReader = new NetworkReader(inNetworkBuffer); // Read regular diff StringBuilder readBuilder = inNetworkReader.ReadStringDiff(originalString); // Read diff directly to StringBuilder inNetworkBuffer.BitPosition = 0; var stringCompare = new StringBuilder(originalString); inNetworkReader.ReadStringDiff(stringCompare); // Read single-byte diff StringBuilder byteBuilder = inNetworkReader.ReadStringDiff(originalString, true); Assert.That(readBuilder.ToString(), Is.EqualTo(testString)); Assert.That(stringCompare.ToString(), Is.EqualTo(testString)); Assert.That(byteBuilder.ToString(), Is.EqualTo(testString)); }
private void ListenForClients() { listener.Start(); try { while (started) { TcpClient client = listener.AcceptTcpClient(); Thread clientThread = new Thread(new ParameterizedThreadStart(WorkWithClient)); Console.WriteLine(); _logger.LogDebug("New client connected"); NetworkBuffer newBuff = new NetworkBuffer(); newBuff.WriteBuffer = new byte[sendBufferSize]; newBuff.ReadBuffer = new byte[readBufferSize]; newBuff.CurrentWriteByteCount = 0; clientBuffers.GetOrAdd(client, newBuff); clients.Add(client); clientThread.Start(client); Thread.Sleep(15); } } catch { } }
public void ResetPositionTest2() { MemoryStream bytesRead = new MemoryStream(); var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA); byte[] read = buffer.Read(BIG_BUFFER_DATA.Length); try { buffer.Read(1); Assert.Fail("An exception should have been thrown when reading a fully read buffer."); }catch (Exception) { } buffer.ResetPosition(); try { read = buffer.Read(1); Assert.AreEqual <byte>(BIG_BUFFER_DATA[0], read[0]); } catch (Exception) { Assert.Fail("Reset position should have allowed for the buffer to be readable again."); } finally { buffer.Dispose(); } }
/// <summary> /// Constructs a new client /// </summary> public Client() { buffer = new NetworkBuffer(); buffer.WriteBuffer = new byte[writeBufferSize]; buffer.ReadBuffer = new byte[readBufferSize]; buffer.CurrentWriteByteCount = 0; }
private bool Send(byte[] buffer, int offset, int count, int protocolId, int channelId) { bool result; if (!IsConnected()) { LoggerManager.Instance.Info("Send protocolId {0}-{0:X} but connected false", protocolId); result = false; } else { this.channelId = channelId; NetworkBuffer networkBuffer = new NetworkBuffer(count + 4, true); networkBuffer.Write(protocolId); networkBuffer.Write(buffer, offset, count); if (handlerPipeline.OutHeader != null) { handlerPipeline.OutHeader.Send(this, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes); result = true; } else { LoggerManager.Instance.Info("IConnection.Send data protocolId {0}-{0:X} then call_Send", protocolId); result = Send(networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes); } } return(result); }
public void AsyncCallbackIPV4SendLargeBufferTest() { try { ManualResetEventSlim mevent = new ManualResetEventSlim(false); NetworkBuffer buffer = TestData.GetLargeBuffer(); byte[] sentData = null; int bytesSent = 0; while ((sentData = buffer.Read(UdpProtocol.BUFFER_SIZE)) != null) { mevent.Reset(); ipv4Client.SendAsync(sentData, (sent) => { bytesSent += sent; ipv4ServerClient.ReceiveAsync(); mevent.Set(); }); mevent.Wait(1000); } Assert.AreEqual(buffer.Size, bytesSent, "Not all bytes were sent"); } catch (Exception ex) { Assert.Fail(ex.ToString()); } }
private void LaunchRocket(World world) { if (!RocketResources.HasEnoughForRocket(RocketMission.rocket)) { return; } RocketResources.InvestInRocket(RocketMission.rocket); var target = Renderer.target.MapPixelToCoords(Input.mousePosition).ToVector2(); if (!RocketMission.InTargetBounds(target.X)) { return; } this.m_NextTimeFire = Time.time + 3f; var entity = world.CreateEntity(this.m_Arch); var spawn = RocketMission.launchLocations[Player.playerId] + new Vector2(10f, -10f); world.SetComponentData <Position>(entity, new Position(spawn)); world.SetComponentData <Rocket>(entity, new Rocket(Player.playerId, RocketMission.rocket, target)); if (Player.isMultiplayer) { NetworkBuffer.Add(new RocketLaunchCommand(Player.playerId, RocketMission.rocket, target)); } }
public bool Serialize <T>(NetworkBuffer outBuffer, T instance) { outBuffer.GetStream().Position = outBuffer.WriteOffset; protobufSerializer.Serialize(outBuffer.GetStream(), instance); outBuffer.WriteOffset = (int)outBuffer.GetStream().Position; return(true); }
protected int msgCount; //数据部分实际长度 public void OnReceived(Connection connection, byte[] buffer, int offset, int count) { if (networkBuffer == null) { networkBuffer = new NetworkBuffer(NHNet._MAX_COMPRESS_MESSAGE_SIZE, true); } networkBuffer.Write(buffer, offset, count); try { CallDecode(connection); } catch (Exception e) { LogU.Debug(e.Message); LogU.Debug(e.StackTrace); //通知connection,连接异常 if (null != connection.OnReceived) { connection.OnReceived(connection, null, 0, -1); } } }
public void TestInOutPacked64Bit() { var buffer = new byte[100]; long someNumber = -1469598103934656037; ulong uNumber = 81246971249124124; ulong uNumber2 = 2287; ulong uNumber3 = 235; var outNetworkBuffer = new NetworkBuffer(buffer); var outNetworkWriter = new NetworkWriter(outNetworkBuffer); outNetworkWriter.WriteInt64Packed(someNumber); outNetworkWriter.WriteUInt64Packed(uNumber); outNetworkWriter.WriteUInt64Packed(uNumber2); outNetworkWriter.WriteUInt64Packed(uNumber3); // the bit should now be stored in the buffer, lets see if it comes out var inNetworkBuffer = new NetworkBuffer(buffer); var inNetworkReader = new NetworkReader(inNetworkBuffer); Assert.That(inNetworkReader.ReadInt64Packed(), Is.EqualTo(someNumber)); Assert.That(inNetworkReader.ReadUInt64Packed(), Is.EqualTo(uNumber)); Assert.That(inNetworkReader.ReadUInt64Packed(), Is.EqualTo(uNumber2)); Assert.That(inNetworkReader.ReadUInt64Packed(), Is.EqualTo(uNumber3)); }
private async void Listen() { while (_connection.IsConnected) { NetworkBuffer nextPacket = _storage.Acquire(); NetworkBuffer result = await _connection.ReceiveAsync(nextPacket, 0, 4, true); if (result == null) { return; // disconnected } BncsReader reader = new BncsReader(result); if (reader.Length > 4) { result = await _connection.ReceiveAsync(nextPacket, 4, reader.Length - 4); if (result == null) { return; // disconnected } } else if (reader.Length == 4) { // packet is complete } else { throw new ProtocolViolationException("The Battle.net server indicated an invalid packet size."); } DispatchPacketHandler(reader); _storage.Release(nextPacket); } }
public void TestStreamCopy() { var inNetworkBuffer = new NetworkBuffer(); var copyNetworkBuffer = new NetworkBuffer(); byte initialValue1 = 56; byte initialValue2 = 24; inNetworkBuffer.WriteByte(initialValue1); inNetworkBuffer.WriteByte(initialValue2); byte copyValue1 = 27; byte copyValue2 = 100; copyNetworkBuffer.WriteByte(copyValue1); copyNetworkBuffer.WriteByte(copyValue2); inNetworkBuffer.CopyFrom(copyNetworkBuffer, 2); var outNetworkBuffer = new NetworkBuffer(inNetworkBuffer.ToArray()); Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(initialValue1)); Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(initialValue2)); Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(copyValue1)); Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(copyValue2)); }
public void TestBool() { var networkBuffer = new NetworkBuffer(new byte[100]); networkBuffer.WriteBit(true); Assert.That(networkBuffer.Length, Is.EqualTo(100)); }
public void TestWriteMisaligned() { var outNetworkBuffer = new NetworkBuffer(); var outNetworkWriter = new NetworkWriter(outNetworkBuffer); outNetworkWriter.WriteBit(true); outNetworkWriter.WriteBit(false); // now the stream is misalligned, lets write some bytes outNetworkWriter.WriteByte(244); outNetworkWriter.WriteByte(123); outNetworkWriter.WriteInt16(-5457); outNetworkWriter.WriteUInt64(4773753249); outNetworkWriter.WriteUInt64Packed(5435285812313212); outNetworkWriter.WriteInt64Packed(-5435285812313212); outNetworkWriter.WriteBit(true); outNetworkWriter.WriteByte(1); outNetworkWriter.WriteByte(0); var outBuffer = outNetworkBuffer.GetBuffer(); var inNetworkBuffer = new NetworkBuffer(outBuffer); var inNetworkReader = new NetworkReader(inNetworkBuffer); Assert.That(inNetworkReader.ReadBit(), Is.True); Assert.That(inNetworkReader.ReadBit(), Is.False); Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(244)); Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(123)); Assert.That(inNetworkReader.ReadInt16(), Is.EqualTo(-5457)); Assert.That(inNetworkReader.ReadUInt64(), Is.EqualTo(4773753249)); Assert.That(inNetworkReader.ReadUInt64Packed(), Is.EqualTo(5435285812313212)); Assert.That(inNetworkReader.ReadInt64Packed(), Is.EqualTo(-5435285812313212)); Assert.That(inNetworkReader.ReadBit(), Is.True); Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(1)); Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(0)); }
internal static void Send(byte messageType, NetworkChannel networkChannel, NetworkBuffer messageBuffer) { messageBuffer.PadBuffer(); using (var buffer = MessagePacker.WrapMessage(messageType, messageBuffer)) { #if !UNITY_2020_2_OR_NEWER NetworkProfiler.StartEvent(TickType.Send, (uint)buffer.Length, networkChannel, NetworkConstants.MESSAGE_NAMES[messageType]); #endif for (int i = 0; i < NetworkManager.Singleton.ConnectedClientsList.Count; i++) { if (NetworkManager.Singleton.IsServer && NetworkManager.Singleton.ConnectedClientsList[i].ClientId == NetworkManager.Singleton.ServerClientId) { continue; } NetworkManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment <byte>(buffer.GetBuffer(), 0, (int)buffer.Length), networkChannel); ProfilerStatManager.BytesSent.Record((int)buffer.Length); PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)buffer.Length); } #if !UNITY_2020_2_OR_NEWER NetworkProfiler.EndEvent(); #endif } }
public void Destroy() { Close(); Receiver = null; receiveNetworkBuffer = null; OnDestroy?.Invoke(this); OnDestroy = null; }
public override void Send(IConnection connection, byte[] buffer, int offset, int size) { NetworkBuffer networkBuffer = new NetworkBuffer(size + 1, true); networkBuffer.Write(Message.UnCompressed); networkBuffer.Write(buffer, offset, size); SendBuffDown(connection, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes); }
/// <summary> /// Creates a new BNCS packet with the specified packet ID. /// </summary> /// <param name="id">The BNCS packet ID.</param> public BncsPacket(BncsPacketId id, NetworkBuffer backingStore) : base(backingStore) { _id = (byte)id; InsertByte(0xff); InsertByte((byte)id); InsertInt16(0); }
public void NetworkBufferTest1() { var buffer = new NetworkBuffer(100); Assert.AreEqual <int>(0, buffer.Received, "Received obtain a value without data"); //An impossible test case Assert.AreEqual <int>(100, buffer.Size, "Size was not assign the right value."); //An impossible test case buffer.Dispose(); }
public void TestGrow() { // stream should not grow when given a buffer var networkBuffer = new NetworkBuffer(new byte[0]); var networkWriter = new NetworkWriter(networkBuffer); Assert.That(() => { networkWriter.WriteInt64(long.MaxValue); }, Throws.TypeOf <NotSupportedException>()); }
public void TestSetLength() { var networkBuffer = new NetworkBuffer(4); networkBuffer.SetLength(100); Assert.That(networkBuffer.Capacity, Is.GreaterThanOrEqualTo(100)); }
public void TestToArray() { var inNetworkBuffer = new NetworkBuffer(); inNetworkBuffer.WriteByte(5); inNetworkBuffer.WriteByte(6); Assert.That(inNetworkBuffer.ToArray().Length, Is.EqualTo(2)); }
internal NetworkBuffer EncodeWithProtocolID() { NetworkBuffer outBuffer = new NetworkBuffer(NetworkParameters._MAX_SEND_BUFFER_SIZE, true); outBuffer.WriteInt32(this.ProtocolId); EncodeBody(outBuffer); return(outBuffer); }
/// <summary> /// Finalizes the data in the packet before preparing to send. /// </summary> public void ConstructPacket() { NetworkBuffer buffer = base.UnderlyingBuffer; byte[] tmp = buffer.UnderlyingBuffer; byte[] len = BitConverter.GetBytes((ushort)Count); tmp[buffer.StartingPosition + 2] = len[0]; tmp[buffer.StartingPosition + 3] = len[1]; }
public void ResizeTest1() { var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA); buffer.Resize(1000); byte[] read = buffer.ToArray(); Assert.AreEqual <int>(1000, read.Length, "The resized buffer should contain 1000 bytes."); buffer.Dispose(); }
public void NetworkBufferTest3() { var buffer = new NetworkBuffer(5, new byte[] { 0, 1, 2, 3, 4 }); Assert.AreEqual <int>(5, buffer.Received, "Received was not the right size."); //An impossible test case Assert.AreEqual <int>(5, buffer.Size, "Size was not assign the right value."); //An impossible test case Assert.IsTrue(buffer.Completed, "Completed should be true."); //An impossible test case buffer.Dispose(); }
public override void Send(IConnection connection, Object msg) { if (msg is Message) { Message outMsg = (Message)msg; NetworkBuffer outBuffer = outMsg.EncodeWithProtocolID(); Send(connection, outBuffer.GetBuffer(), outBuffer.ReadOffset, outBuffer.ReadableBytes); } }
public Boolean FireBuffReceived(IConnection connection, NetworkBuffer buffer, int offset, int size) { if (NextInHandler != null) { NextInHandler.OnReceived(connection, buffer, offset, size); return(true); } return(false); }
public override void Send(IConnection connection, object msg) { if (msg is Message) { Message message = (Message)msg; NetworkBuffer networkBuffer = message.EncodeWithSnappyProtocolIdCallBackId(); SendBuffDown(connection, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes); } }
public void CloneTest() { var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA); var copy = buffer.Clone(); Assert.AreEqual <int>(buffer.Size, copy.Size, "Cloned buffer should have the same size."); Assert.AreEqual <int>(buffer.Received, copy.Received, "Cloned buffer should have the same received number of bytes."); buffer.Dispose(); (copy as NetworkBuffer).Dispose(); }
public void AppendFillBuffer() { var buffer = new NetworkBuffer(10); buffer.Append(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.AreEqual <int>(10, buffer.Received, "Received was not the right size."); //An impossible test case Assert.AreEqual <int>(10, buffer.Size, "Size was not assign the right value."); //An impossible test case Assert.IsTrue(buffer.Completed, "Completed should be true."); //An impossible test case buffer.Dispose(); }
/// <summary> /// Runs in its own thread. Responsible for accepting new clients and kicking them off into their own thread /// </summary> private void ListenForClients() { listener.Start(); while (started) { TcpClient client = listener.AcceptTcpClient(); Thread clientThread = new Thread(new ParameterizedThreadStart(WorkWithClient)); Console.WriteLine("New client connected"); NetworkBuffer newBuff = new NetworkBuffer(); newBuff.WriteBuffer = new byte[sendBufferSize]; newBuff.ReadBuffer = new byte[readBufferSize]; newBuff.CurrentWriteByteCount = 0; clientBuffers.GetOrAdd(client, newBuff); clients.Add(client); clientThread.Start(client); Thread.Sleep(15); } }