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 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));
}
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));
}
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);
}
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 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);
}
}
internal static NetworkBuffer WrapMessage(byte messageType, NetworkBuffer messageBody)
{
var outStream = PooledNetworkBuffer.Get();
using (var outWriter = PooledNetworkWriter.Get(outStream))
{
outWriter.WriteByte(messageType);
outStream.Write(messageBody.GetBuffer(), 0, (int)messageBody.Length);
}
return(outStream);
}
public void TestWritePackedSingle()
{
float somenumber = (float)Math.PI;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteSinglePacked(somenumber);
var buffer = outNetworkBuffer.GetBuffer();
var inNetworkBuffer = new NetworkBuffer(buffer);
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadSinglePacked(), Is.EqualTo(somenumber));
}
public void TestWritePackedDouble()
{
double somenumber = Math.PI;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteDoublePacked(somenumber);
var outBuffer = outNetworkBuffer.GetBuffer();
var inNetworkBuffer = new NetworkBuffer(outBuffer);
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadDoublePacked(), Is.EqualTo(somenumber));
}
public void TestStringPacked()
{
var testString = "Hello, World";
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteStringPacked(testString);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
var inNetworkReader = new NetworkReader(inNetworkBuffer);
var readString = inNetworkReader.ReadStringPacked();
Assert.That(readString, Is.EqualTo(testString));
}
public void TestWriteSingle()
{
float somenumber = 0.1f;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteSingle(somenumber);
var outBuffer = outNetworkBuffer.GetBuffer();
var inNetworkBuffer = new NetworkBuffer(outBuffer);
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadSingle(), Is.EqualTo(somenumber));
}
public bool Send(byte[] buffer, int offset, int count, int protocolId, int callback, int channelId = 1)
{
if (!isConnected())
{
return(false);
}
this.channelId = channelId;
NetworkBuffer outBuffer = new NetworkBuffer(count + 4, true);
outBuffer.WriteInt32(protocolId);
outBuffer.WriteBytes(buffer, offset, count);
if (handlerPipeline.OutHeader != null)
{
handlerPipeline.OutHeader.Send(this, outBuffer.GetBuffer(), outBuffer.ReadOffset, outBuffer.ReadableBytes);
return(true);
}
else
{
return(_Send(outBuffer.GetBuffer(), outBuffer.ReadOffset, outBuffer.ReadableBytes));
}
}
public void TestRangedSingle()
{
const float rangeMinA = -180;
const float rangeMaxA = 180;
const int rangeBytesA = 2;
float randFloatValueA = UnityEngine.Random.Range(rangeMinA, rangeMaxA);
var outNetworkBufferA = new NetworkBuffer();
var outNetworkWriterA = new NetworkWriter(outNetworkBufferA);
outNetworkWriterA.WriteRangedSingle(randFloatValueA, rangeMinA, rangeMaxA, rangeBytesA);
outNetworkWriterA.WriteRangedSingle(rangeMinA, rangeMinA, rangeMaxA, rangeBytesA);
outNetworkWriterA.WriteRangedSingle(rangeMaxA, rangeMinA, rangeMaxA, rangeBytesA);
var rawBufferBytesA = outNetworkBufferA.GetBuffer();
var inNetworkBufferA = new NetworkBuffer(rawBufferBytesA);
var inNetworkReaderA = new NetworkReader(inNetworkBufferA);
Assert.That(Math.Abs(randFloatValueA - inNetworkReaderA.ReadRangedSingle(rangeMinA, rangeMaxA, rangeBytesA)), Is.LessThan(1.6f));
Assert.That(Math.Abs(rangeMinA - inNetworkReaderA.ReadRangedSingle(rangeMinA, rangeMaxA, rangeBytesA)), Is.LessThan(1.6f));
Assert.That(Math.Abs(rangeMaxA - inNetworkReaderA.ReadRangedSingle(rangeMinA, rangeMaxA, rangeBytesA)), Is.LessThan(1.6f));
const float rangeMinB = 0;
const float rangeMaxB = 360;
const int rangeBytesB = 4;
float randFloatValueB = UnityEngine.Random.Range(rangeMinB, rangeMaxB);
var outNetworkBufferB = new NetworkBuffer();
var outNetworkWriterB = new NetworkWriter(outNetworkBufferB);
outNetworkWriterB.WriteRangedSingle(randFloatValueB, rangeMinB, rangeMaxB, rangeBytesB);
outNetworkWriterB.WriteRangedSingle(rangeMinB, rangeMinB, rangeMaxB, rangeBytesB);
outNetworkWriterB.WriteRangedSingle(rangeMaxB, rangeMinB, rangeMaxB, rangeBytesB);
var rawBufferBytesB = outNetworkBufferB.GetBuffer();
var inNetworkBufferB = new NetworkBuffer(rawBufferBytesB);
var inNetworkReaderB = new NetworkReader(inNetworkBufferB);
Assert.That(Math.Abs(randFloatValueB - inNetworkReaderB.ReadRangedSingle(rangeMinB, rangeMaxB, rangeBytesB)), Is.LessThan(0.4f));
Assert.That(Math.Abs(rangeMinB - inNetworkReaderB.ReadRangedSingle(rangeMinB, rangeMaxB, rangeBytesB)), Is.LessThan(0.4f));
Assert.That(Math.Abs(rangeMaxB - inNetworkReaderB.ReadRangedSingle(rangeMinB, rangeMaxB, rangeBytesB)), Is.LessThan(0.4f));
}
public void TestRangedDouble()
{
const double rangeMinA = -180;
const double rangeMaxA = 180;
const int rangeBytesA = 2;
double randDoubleValueA = new Random().NextDouble() * (rangeMaxA - rangeMinA) + rangeMinA;
var outNetworkBufferA = new NetworkBuffer();
var outNetworkWriterA = new NetworkWriter(outNetworkBufferA);
outNetworkWriterA.WriteRangedDouble(randDoubleValueA, rangeMinA, rangeMaxA, rangeBytesA);
outNetworkWriterA.WriteRangedDouble(rangeMinA, rangeMinA, rangeMaxA, rangeBytesA);
outNetworkWriterA.WriteRangedDouble(rangeMaxA, rangeMinA, rangeMaxA, rangeBytesA);
var rawBufferBytesA = outNetworkBufferA.GetBuffer();
var inNetworkBufferA = new NetworkBuffer(rawBufferBytesA);
var inNetworkReaderA = new NetworkReader(inNetworkBufferA);
Assert.That(Math.Abs(randDoubleValueA - inNetworkReaderA.ReadRangedDouble(rangeMinA, rangeMaxA, rangeBytesA)), Is.LessThan(1.6f));
Assert.That(Math.Abs(rangeMinA - inNetworkReaderA.ReadRangedDouble(rangeMinA, rangeMaxA, rangeBytesA)), Is.LessThan(1.6f));
Assert.That(Math.Abs(rangeMaxA - inNetworkReaderA.ReadRangedDouble(rangeMinA, rangeMaxA, rangeBytesA)), Is.LessThan(1.6f));
const double rangeMinB = 0;
const double rangeMaxB = 360;
const int rangeBytesB = 4;
double randDoubleValueB = new Random().NextDouble() * (rangeMaxB - rangeMinB) + rangeMinB;
var outNetworkBufferB = new NetworkBuffer();
var outNetworkWriterB = new NetworkWriter(outNetworkBufferB);
outNetworkWriterB.WriteRangedDouble(randDoubleValueB, rangeMinB, rangeMaxB, rangeBytesB);
outNetworkWriterB.WriteRangedDouble(rangeMinB, rangeMinB, rangeMaxB, rangeBytesB);
outNetworkWriterB.WriteRangedDouble(rangeMaxB, rangeMinB, rangeMaxB, rangeBytesB);
var rawBufferBytesB = outNetworkBufferB.GetBuffer();
var inNetworkBufferB = new NetworkBuffer(rawBufferBytesB);
var inNetworkReaderB = new NetworkReader(inNetworkBufferB);
Assert.That(Math.Abs(randDoubleValueB - inNetworkReaderB.ReadRangedDouble(rangeMinB, rangeMaxB, rangeBytesB)), Is.LessThan(0.4f));
Assert.That(Math.Abs(rangeMinB - inNetworkReaderB.ReadRangedDouble(rangeMinB, rangeMaxB, rangeBytesB)), Is.LessThan(0.4f));
Assert.That(Math.Abs(rangeMaxB - inNetworkReaderB.ReadRangedDouble(rangeMinB, rangeMaxB, rangeBytesB)), Is.LessThan(0.4f));
}
public void TestIntOutPacked16Bit()
{
short svalue = -31934;
ushort uvalue = 64893;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteInt16Packed(svalue);
outNetworkWriter.WriteUInt16Packed(uvalue);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadInt16Packed(), Is.EqualTo(svalue));
Assert.That(inNetworkReader.ReadUInt16Packed(), Is.EqualTo(uvalue));
}
public void TestNibble()
{
byte somevalue = 0b1010011;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteNibble(somevalue);
var outBuffer = outNetworkBuffer.GetBuffer();
var inNetworkBuffer = new NetworkBuffer(outBuffer);
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadNibble(), Is.EqualTo(0b0011));
}
public void TestBits()
{
ulong somevalue = 0b1100101010011;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteBits(somevalue, 5);
var outBuffer = outNetworkBuffer.GetBuffer();
var inNetworkBuffer = new NetworkBuffer(outBuffer);
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadBits(5), Is.EqualTo(0b10011));
}
public void TestIntOutPacked32Bit()
{
int svalue = -100913642;
uint uvalue = 1467867235;
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteInt32Packed(svalue);
outNetworkWriter.WriteUInt32Packed(uvalue);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadInt32Packed(), Is.EqualTo(svalue));
Assert.That(inNetworkReader.ReadUInt32Packed(), Is.EqualTo(uvalue));
}
public override void Send(IConnection connection, byte[] buffer, int offset, int size)
{
int length = size + lengthAdjustment;
if (lengthIncludesLengthFieldLength)
{
length += lengthFieldLength;
}
if (length < 0)
{
throw new ArgumentException(
"Adjusted frame length (" + length + ") is less than zero");
}
NetworkBuffer outBuffer = new NetworkBuffer(size + lengthFieldLength, true);
switch (lengthFieldLength)
{
case 1:
if (length >= 256)
{
throw new ArgumentException(
"length does not fit into a byte: " + length);
}
outBuffer.WriteByte((byte)length);
break;
case 2:
if (length >= 65536)
{
throw new ArgumentException(
"length does not fit into a short integer: " + length);
}
outBuffer.WriteInt16((short)length);
break;
case 4:
outBuffer.WriteInt32(length);
break;
default:
throw new ArgumentException("should not reach here");
}
outBuffer.WriteBytes(buffer, offset, size);
sendBuffDown(connection, outBuffer.GetBuffer(), outBuffer.ReadOffset, outBuffer.ReadableBytes);
}
public void TestString()
{
var testString = "Hello, World";
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteString(testString);
outNetworkWriter.WriteString(testString, true);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
var inNetworkReader = new NetworkReader(inNetworkBuffer);
StringBuilder readBuilder = inNetworkReader.ReadString();
StringBuilder readBuilderSingle = inNetworkReader.ReadString(true);
Assert.That(readBuilder.ToString(), Is.EqualTo(testString));
Assert.That(readBuilderSingle.ToString(), Is.EqualTo(testString));
}
public override void OnReceived(IConnection connection, byte[] buffer, int offset, int count)
{
if (msgBuffer == null)
{
msgBuffer = new NetworkBuffer(NetworkParameters.MaxCompressMessageSize, true);
}
msgBuffer.Write(buffer, offset, count);
try
{
while (msgBuffer.Readable)
{
int readOffset = msgBuffer.ReadOffset;
int num = 0;
if (!Decode(msgBuffer, ref num))
{
if (readOffset == msgBuffer.ReadOffset)
{
break;
}
}
else
{
if (num == 0)
{
throw new InvalidOperationException("decode() method must read at least one byte if it returned a frame ");
}
try
{
FireBuffReceived(connection, msgBuffer.GetBuffer(), msgBuffer.ReadOffset, num);
}
finally
{
msgBuffer.ReadOffset = msgBuffer.ReadOffset + num;
msgBuffer.DiscardReadBytes();
}
}
}
}
catch (Exception ex)
{
LoggerManager.Instance.Info("OnReceived connection {0} catch Exception {1}", connection.ToString(), ex.ToString());
}
}
public void TestArraysPacked()
{
var outShortArray = new short[]
{
1,
2,
13,
37,
69
};
var outIntArray = new int[]
{
1337,
69420,
12345,
0,
0,
5
};
var outDoubleArray = new double[]
{
0.02,
0.06,
1E40,
256.0
};
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteShortArrayPacked(outShortArray);
outNetworkWriter.WriteIntArrayPacked(outIntArray);
outNetworkWriter.WriteDoubleArrayPacked(outDoubleArray);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
var inNetworkReader = new NetworkReader(inNetworkBuffer);
var inShortArray = inNetworkReader.ReadShortArrayPacked();
var inIntArray = inNetworkReader.ReadIntArrayPacked();
var inDoubleArray = inNetworkReader.ReadDoubleArrayPacked();
Assert.That(outShortArray, Is.EqualTo(inShortArray));
Assert.That(outIntArray, Is.EqualTo(inIntArray));
Assert.That(outDoubleArray, Is.EqualTo(inDoubleArray));
}
public override void Send(IConnection connection, byte[] buffer, int offset, int size)
{
int num = size + lengthAdjustment;
if (lengthIncludesLengthFieldLength)
{
num += lengthFieldLength;
}
if (num < 0)
{
throw new ArgumentException("Adjusted frame length (" + num + ") is less than zero");
}
NetworkBuffer networkBuffer = new NetworkBuffer(size + lengthFieldLength, true);
switch (lengthFieldLength)
{
case 1:
if (num >= 256)
{
throw new ArgumentException("length does not fit into a byte: " + num);
}
networkBuffer.Write((byte)num);
goto IL_EC;
case 2:
if (num >= 65536)
{
throw new ArgumentException("length does not fit into a short integer: " + num);
}
networkBuffer.Write((short)num);
goto IL_EC;
case 4:
networkBuffer.Write(num);
goto IL_EC;
}
throw new ArgumentException("should not reach here");
IL_EC:
networkBuffer.Write(buffer, offset, size);
SendBuffDown(connection, networkBuffer.GetBuffer(), networkBuffer.ReadOffset, networkBuffer.ReadableBytes);
}
/// <summary>
/// AddQueueItemToInboundFrame
/// Adds an RPC queue item to the outbound frame
/// </summary>
/// <param name="qItemType">type of rpc (client or server)</param>
/// <param name="timeStamp">when it was received</param>
/// <param name="sourceNetworkId">who sent the rpc</param>
/// <param name="message">the message being received</param>
internal void AddQueueItemToInboundFrame(QueueItemType qItemType, float timeStamp, ulong sourceNetworkId, NetworkBuffer message)
{
long originalPosition = message.Position;
NetworkUpdateStage updateStage;
using (var reader = PooledNetworkReader.Get(message))
{
var longValue = reader.ReadUInt64Packed(); // NetworkObjectId (temporary, we reset position just below)
var shortValue = reader.ReadUInt16Packed(); // NetworkBehaviourId (temporary, we reset position just below)
updateStage = (NetworkUpdateStage)reader.ReadByteDirect();
}
message.Position = originalPosition;
var rpcQueueHistoryItem = GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, updateStage);
rpcQueueHistoryItem.IsDirty = true;
long StartPosition = rpcQueueHistoryItem.QueueBuffer.Position;
//Write the packed version of the queueItem to our current queue history buffer
rpcQueueHistoryItem.QueueWriter.WriteUInt16((ushort)qItemType);
rpcQueueHistoryItem.QueueWriter.WriteSingle(timeStamp);
rpcQueueHistoryItem.QueueWriter.WriteUInt64(sourceNetworkId);
//Inbound we copy the entire packet and store the position offset
long streamSize = message.Length;
rpcQueueHistoryItem.QueueWriter.WriteInt64(streamSize);
rpcQueueHistoryItem.QueueWriter.WriteInt64(message.Position);
rpcQueueHistoryItem.QueueWriter.WriteBytes(message.GetBuffer(), streamSize);
//Add the packed size to the offsets for parsing over various entries
rpcQueueHistoryItem.QueueItemOffsets.Add((uint)rpcQueueHistoryItem.QueueBuffer.Position);
//Calculate the packed size based on stream progression
rpcQueueHistoryItem.TotalSize += (uint)(rpcQueueHistoryItem.QueueBuffer.Position - StartPosition);
}
public void TestReadWriteMissaligned()
{
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteBit(true);
var writeBuffer = new byte[16]
{
0,
5,
2,
54,
192,
60,
214,
65,
95,
2,
43,
62,
252,
190,
45,
2
};
outNetworkBuffer.Write(writeBuffer);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
Assert.That(inNetworkBuffer.ReadBit(), Is.True);
var readBuffer = new byte[16];
inNetworkBuffer.Read(readBuffer, 0, 16);
Assert.That(readBuffer, Is.EquivalentTo(writeBuffer));
}
public override void OnReceived(IConnection connection, NetworkBuffer buffer, int offset, int size)
{
int protocolId = buffer.ReadInt32();
int bodySize = size - 4;
Type msgType = messageInitializer.getMessageType(protocolId);
if (msgType == null)
{
UnityEngine.Debug.Log(":::此消息C#无处理，进入ulua检测处理,消息号：" + protocolId + "-消息长度：" + size);
LuaFramework.Util.CallMethod("Network", "OnSocket", protocolId, new ByteBuffer(buffer.GetBuffer()));
return;
}
if (msgType == null)
{
this.ReceviedFail(buffer, protocolId, bodySize);
return;
}
Message msg = (Message)Activator.CreateInstance(msgType);
if (msg == null)
{
this.ReceviedFail(buffer, protocolId, bodySize);
return;
}
msg.DecodeBody(buffer, buffer.ReadOffset, bodySize);
IMessageHandler messageHandler = messageInitializer.GetMessageHandler(protocolId);
if (AbstractMessageInitializer.getDefaultLogger() != null)
{
AbstractMessageInitializer.getDefaultLogger()("message recv:" + msgType.FullName + ", messageId:" + protocolId);
}
if (messageHandler != null)
{
messageHandler.handleMessage(connection, msg);
}
else
{
if (!msgDelegateProcessor.HandleMessage(msg, connection))
{
//ReceviedFail(buffer, protocolId, bodySize);
return;
//messageHandler = messageInitializer.GetDefaultMessageHandler();
//if (messageHandler != null)
// messageHandler.handleMessage(connection, msg);
}
}
}
public void TestArraysPackedDiff()
{
// Values changed test
var longOutDiffData = new long[]
{
1,
2,
13,
29,
44,
15
};
var longOutData = new long[]
{
1,
2,
13,
37,
69
};
// No change test
var intOutDiffData = new int[]
{
1337,
69420,
12345,
0,
0,
5
};
var intOutData = new int[]
{
1337,
69420,
12345,
0,
0,
5
};
// Array resize test
var doubleOutDiffData = new double[]
{
0.2,
6,
1E39
};
var doubleOutData = new double[]
{
0.02,
0.06,
1E40,
256.0
};
// Serialize
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteLongArrayPackedDiff(longOutData, longOutDiffData);
outNetworkWriter.WriteIntArrayPackedDiff(intOutData, intOutDiffData);
outNetworkWriter.WriteDoubleArrayPackedDiff(doubleOutData, doubleOutDiffData);
// Deserialize
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
var inNetworkReader = new NetworkReader(inNetworkBuffer);
var longInData = inNetworkReader.ReadLongArrayPackedDiff(longOutDiffData);
var intInData = inNetworkReader.ReadIntArrayPackedDiff(intOutDiffData);
var doubleInData = inNetworkReader.ReadDoubleArrayPackedDiff(doubleOutDiffData);
// Compare
Assert.That(longInData, Is.EqualTo(longOutData));
Assert.That(intInData, Is.EqualTo(intOutData));
Assert.That(doubleInData, Is.EqualTo(doubleOutData));
}
