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