public static void Send_EndGameFool(long connectionId, long foolPlayerId, Dictionary <long, double> rewards)
{
//New packet
ByteBuffer buffer = new ByteBuffer();
//Add packet id
buffer.WriteLong((long)ServerPacketId.EndGameFool);
//Add foolPlayerId
buffer.WriteLong(foolPlayerId);
//Add rewards count
buffer.WriteInteger(rewards.Count);
//Add rewards
foreach (var reward in rewards)
{
//Add player id
buffer.WriteLong(reward.Key);
//Add player reward
buffer.WriteDouble(reward.Value);
}
//Send packet
SendDataTo(connectionId, buffer.ToArray());
}
protected override void writeVectorToBuffer(ByteBuffer buffer)
{
foreach (double val in values)
{
buffer.WriteDouble(val);
}
}
public static void Send_UpdateUserData(long connectionId)
{
//New packet
ByteBuffer buffer = new ByteBuffer();
//Add packet id
buffer.WriteLong((long)ServerPacketId.UpdateUserData);
Client client = ClientManager.GetConnectedClient(connectionId);
//Add current connection id
buffer.WriteLong(connectionId);
//Add userId
buffer.WriteLong(client.UserData.UserId);
//Add client's display name
buffer.WriteStringUnicode(client.UserData.Nickname);
//Add client's money
buffer.WriteDouble(client.UserData.Money);
//Add client's avatar file URL
string avatarUrl = client.UserData.AvatarFileUrl;
buffer.WriteString(avatarUrl);
//Send packet
SendDataTo(connectionId, buffer.ToArray());
}
static int WriteDouble(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 2);
ByteBuffer obj = (ByteBuffer)LuaScriptMgr.GetNetObjectSelf(L, 1, "ByteBuffer");
double arg0 = (double)LuaScriptMgr.GetNumber(L, 2);
obj.WriteDouble(arg0);
return(0);
}
public override byte[] Serialize()
{
ByteBuffer buffer = new ByteBuffer(Size);
buffer.WriteByte(TypeID);
buffer.WriteShort((short)Name.Length);
buffer.WriteString(Name, Encoding.ASCII, Name.Length);
buffer.WriteDouble((double)Value);
return(buffer.Data);
}
public override int serialize(int indexStart, int offect, int targetNumElement, out int numElement, out int partial, ByteBuffer @out)
{
targetNumElement = Math.Min((@out.remain() / getUnitLength()), targetNumElement);
for (int i = 0; i < targetNumElement; ++i)
{
@out.WriteDouble(values[indexStart + i]);
}
numElement = targetNumElement;
partial = 0;
return(targetNumElement * 8);
}
public static void WriteToBuffer(ByteBuffer buffer, object value)
{
if (!value.IsNull())
{
var type = value.GetType();
if (type.IsNumeric())
{
if (type.IsFloating())
{
buffer.WriteUInt8(3);
buffer.WriteDouble(Convert.ToDouble(value));
}
else
{
if (Convert.ToDouble(value) < 0.0)
{
buffer.WriteUInt8(1);
buffer.WriteInt64(Convert.ToInt64(value));
}
else
{
buffer.WriteUInt8(2);
buffer.WriteUInt64(Convert.ToUInt64(value));
}
}
}
else if (type.Equals(typeof(bool)))
{
buffer.WriteUInt8(4);
buffer.WriteBool(Convert.ToBoolean(value));
}
else if (type.Equals(typeof(string)))
{
buffer.WriteUInt8(5);
buffer.WriteString(Convert.ToString(value));
}
else if (type.IsArray)
{
buffer.WriteUInt8(6);
buffer.WriteArray(((IList)value).ToArray(), WriteToBuffer);
}
else if (value is ISerializeToBuffer)
{
buffer.WriteUInt8(7);
(value as ISerializeToBuffer).ToBuffer(buffer);
}
else
{
throw new InvalidOperationException("Not support type: " + type.Name);
}
}
}
static int WriteDouble(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
ByteBuffer obj = (ByteBuffer)ToLua.CheckObject(L, 1, typeof(ByteBuffer));
double arg0 = (double)LuaDLL.luaL_checknumber(L, 2);
obj.WriteDouble(arg0);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// Sent when cover some card on table
/// </summary>
public static void Send_CreateRoom(int maxPlayers, int deckSize, double bet)
{
ByteBuffer buffer = new ByteBuffer();
//Write packet id
buffer.WriteLong((long)ClientPacketId.CreateRoom);
//write max players
buffer.WriteInteger(maxPlayers);
//write deck size
buffer.WriteInteger(deckSize);
//write bet
buffer.WriteDouble(bet);
SendDataToServer(buffer.ToArray());
}
public static void Send_PlayerWon(long connectionId, long winnerId, double winnerReward)
{
//New packet
ByteBuffer buffer = new ByteBuffer();
//Add packet id
buffer.WriteLong((long)ServerPacketId.PlayerWon);
//Add winnerId
buffer.WriteLong(winnerId);
//Add winner's reward
buffer.WriteDouble(winnerReward);
//Send packet
SendDataTo(connectionId, buffer.ToArray());
}
private static int WriteDouble(IntPtr L)
{
int result;
try
{
ToLua.CheckArgsCount(L, 2);
ByteBuffer byteBuffer = (ByteBuffer)ToLua.CheckObject(L, 1, typeof(ByteBuffer));
double v = LuaDLL.luaL_checknumber(L, 2);
byteBuffer.WriteDouble(v);
result = 0;
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
static int _m_WriteDouble(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
ByteBuffer gen_to_be_invoked = (ByteBuffer)translator.FastGetCSObj(L, 1);
{
double _v = LuaAPI.lua_tonumber(L, 2);
gen_to_be_invoked.WriteDouble(_v);
return(0);
}
} catch (System.Exception gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
}
}
public static byte[] ParseBytes(string str)
{
ByteBuffer buffer = new ByteBuffer();
// writeD(7);writeS(hallo);writeD(7);
string[] splitted = str.Split(';');
int len = 7;
foreach (string s in splitted)
{
if (s.StartsWith("writeC"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
if (tmp.StartsWith("0x"))
{
buffer.WriteByte(byte.Parse(tmp, System.Globalization.NumberStyles.HexNumber));
}
else
{
buffer.WriteByte(byte.Parse(tmp));
}
}
else if (s.StartsWith("writeF"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
if (tmp.StartsWith("0x"))
{
buffer.WriteDouble(double.Parse(tmp, System.Globalization.NumberStyles.HexNumber));
}
else
{
buffer.WriteDouble(double.Parse(tmp));
}
}
else if (s.StartsWith("writeH"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
if (tmp.StartsWith("0x"))
{
buffer.WriteInt16(short.Parse(tmp, System.Globalization.NumberStyles.HexNumber));
}
else
{
buffer.WriteInt16(short.Parse(tmp));
}
}
else if (s.StartsWith("writeD"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
if (tmp.StartsWith("0x"))
{
buffer.WriteInt32(int.Parse(tmp, System.Globalization.NumberStyles.HexNumber));
}
else
{
buffer.WriteInt32(int.Parse(tmp));
}
}
else if (s.StartsWith("writeQ"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
if (tmp.StartsWith("0x"))
{
buffer.WriteInt64(long.Parse(tmp, System.Globalization.NumberStyles.HexNumber));
}
else
{
buffer.WriteInt64(long.Parse(tmp));
}
}
else if (s.StartsWith("writeB"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
if (tmp.StartsWith("0x"))
{
buffer.WriteByte(byte.Parse(tmp, System.Globalization.NumberStyles.HexNumber));
}
else
{
buffer.WriteByte(byte.Parse(tmp));
}
}
else if (s.StartsWith("writeS"))
{
string tmp = s.Substring(len, s.Length - (len + 1));
buffer.WriteString(tmp);
}
else
{
if (s != "")
{
throw new ArgumentException("Syntax error: " + s);
}
}
}
return(buffer.Get_ByteArray());
}
private void WriteCell(ByteBuffer buffer, HeadWrapper head, string value, string createLogo)
{
if (head.IsNotes || head.Logo.Contains(createLogo) == false)
{
return;
}
if (head.Type == "int")
{
buffer.WriteInt(StringConvert.StringToValue <int>(value));
}
else if (head.Type == "long")
{
buffer.WriteLong(StringConvert.StringToValue <long>(value));
}
else if (head.Type == "float")
{
buffer.WriteFloat(StringConvert.StringToValue <float>(value));
}
else if (head.Type == "double")
{
buffer.WriteDouble(StringConvert.StringToValue <double>(value));
}
else if (head.Type == "List<int>")
{
buffer.WriteListInt(StringConvert.StringToValueList <int>(value, ConstDefine.StrSplitChar));
}
else if (head.Type == "List<long>")
{
buffer.WriteListLong(StringConvert.StringToValueList <long>(value, ConstDefine.StrSplitChar));
}
else if (head.Type == "List<float>")
{
buffer.WriteListFloat(StringConvert.StringToValueList <float>(value, ConstDefine.StrSplitChar));
}
else if (head.Type == "List<double>")
{
buffer.WriteListDouble(StringConvert.StringToValueList <double>(value, ConstDefine.StrSplitChar));
}
// bool
else if (head.Type == "bool")
{
buffer.WriteBool(StringConvert.StringToBool(value));
}
// string
else if (head.Type == "string")
{
buffer.WriteUTF(value);
}
else if (head.Type == "List<string>")
{
buffer.WriteListUTF(StringConvert.StringToStringList(value, ConstDefine.StrSplitChar));
}
// NOTE：多语言在字节流会是哈希值
else if (head.Type == "language")
{
buffer.WriteInt(value.GetHashCode());
}
else if (head.Type == "List<language>")
{
List <string> langList = StringConvert.StringToStringList(value, ConstDefine.StrSplitChar);
List <int> hashList = new List <int>();
for (int i = 0; i < langList.Count; i++)
{
hashList.Add(langList[i].GetHashCode());
}
buffer.WriteListInt(hashList);
}
// wrapper
else if (head.Type.Contains("class"))
{
buffer.WriteUTF(value);
}
// enum
else if (head.Type.Contains("enum"))
{
buffer.WriteInt(StringConvert.StringToValue <int>(value));
}
else
{
throw new Exception($"Not support head type {head.Type}");
}
}
public void TestByteBuffer()
{
checkBufferEmpty(ByteBuffer.Empty);
var buffer = new ByteBuffer();
checkBufferEmpty(buffer);
buffer = new ByteBuffer(checkCount);
checkBufferNotEmpty(ref buffer, null, 0, checkCount);
var tempBuffer = buffer;
var array = new byte[checkCount];
buffer = new ByteBuffer(array);
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer != tempBuffer);
tempBuffer = buffer;
buffer = new ByteBuffer(array, 1, 3);
checkBufferNotEmpty(ref buffer, array, 1, 3);
Assert.IsTrue(buffer != tempBuffer);
buffer = new ByteBuffer(new ArraySegment <byte>(array));
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer == tempBuffer);
buffer = new ByteBuffer(new ByteBufferNode(array));
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer == tempBuffer);
buffer = new ByteBuffer(new ByteBuffer(array));
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer == tempBuffer);
buffer = new ByteBuffer(array);
buffer = new ByteBuffer(ref buffer, 1);
checkBufferNotEmpty(ref buffer, array, 1, checkCount - 1);
Assert.IsTrue(buffer != tempBuffer);
buffer = new ByteBuffer(checkCount);
checkBufferNotEmpty(ref buffer, null, 0, checkCount);
for (int i = 0; i < checkCount; i++)
{
buffer[i] = (byte)i;
}
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(buffer[i], (byte)i);
}
int advanceOffset = 10;
tempBuffer = ByteBuffer.AdvanceOffset(ref buffer, advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, advanceOffset, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(0, ref buffer, advanceOffset));
tempBuffer = ByteBuffer.AdvanceSize(ref buffer, advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = ByteBuffer.Resize(ref buffer, checkCount - advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = buffer;
tempBuffer.AdvanceOffset(advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, advanceOffset, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(0, ref buffer, advanceOffset));
tempBuffer = buffer;
tempBuffer.AdvanceSize(advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = buffer;
tempBuffer.Resize(checkCount - advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = buffer;
buffer = new ByteBuffer(checkCount);
Assert.IsFalse(buffer.CheckPtr(ref tempBuffer));
tempBuffer.CopyTo(ref buffer);
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(buffer[i], (byte)i);
}
tempBuffer.CopyTo(10, ref buffer, 20, 30);
Assert.AreEqual(buffer[20 - 1], 20 - 1);
for (int i = 0; i < 30; i++)
{
Assert.AreEqual(buffer[20 + i], (byte)(10 + i));
}
Assert.AreEqual(buffer[20 + 30], 20 + 30);
buffer = new ByteBuffer(checkCount);
for (int i = 0; i < checkCount; i++)
{
buffer.WriteByte(i, (byte)i);
}
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(buffer.ReadByte(i), (byte)i);
}
var blockBuffer = new BlockBuffer();
blockBuffer.Add(buffer);
tempBuffer = blockBuffer.ToBuffer();
checkBufferNotEmpty(ref tempBuffer, null, 0, buffer.Count);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(tempBuffer.ReadByte(i), (byte)i);
}
buffer = new ByteBuffer(checkCount);
long startValue = Byte.MaxValue * 2;
int count = checkCount / 2;
for (int i = 0; i < count; i++)
{
buffer.WriteUint16(i * 2, (ushort)(startValue + i));
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint16(i * 2), (ushort)(startValue + i));
}
buffer = new ByteBuffer(checkCount);
startValue = ushort.MaxValue * 2;
count = checkCount / 4;
for (int i = 0; i < count; i++)
{
buffer.WriteUint32(i * 4, (uint)(startValue + i));
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint32(i * 4), (uint)(startValue + i));
}
buffer = new ByteBuffer(checkCount);
startValue = (long)uint.MaxValue * 2;
count = checkCount / 8;
for (int i = 0; i < count; i++)
{
buffer.WriteUint64(i * 8, (uint)(startValue + i));
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint64(i * 8), (uint)(startValue + i));
}
tempBuffer = buffer;
buffer = new ByteBuffer(checkCount);
for (int i = 0; i < count; i++)
{
buffer.WriteBuffer(i * 8, ref tempBuffer, i * 8, 8);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint64(i * 8), (uint)(startValue + i));
}
tempBuffer = buffer;
buffer = new ByteBuffer(checkCount);
for (int i = 0; i < count; i++)
{
tempBuffer.ReadBuffer(i * 8, ref buffer, i * 8, 8);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint64(i * 8), (uint)(startValue + i));
}
string checkString = "";
for (int i = 0; i < checkCount / 2; i++)
{
checkString += i.ToString();
}
int stringSize = Encoding.UTF8.GetByteCount(checkString);
Assert.IsTrue(stringSize > 0 && stringSize < checkCount);
int index = Rand.Default.RandInt(checkCount - stringSize);
buffer = new ByteBuffer(checkCount);
buffer.WriteString(index, checkString);
int readOffset;
var value = buffer.ReadString(index, out readOffset);
Assert.AreEqual(value, checkString);
Assert.Less(stringSize, readOffset);
buffer = new ByteBuffer(checkCount);
count = checkCount / 4;
float[] checkFloatSet = new float[count];
for (int i = 0; i < count; i++)
{
checkFloatSet[i] = Rand.Default.RandFloat();
}
for (int i = 0; i < count; i++)
{
buffer.WriteFloat(i * 4, checkFloatSet[i]);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadFloat(i * 4), checkFloatSet[i]);
}
buffer = new ByteBuffer(checkCount);
count = checkCount / 8;
double[] checkDoubleSet = new double[count];
for (int i = 0; i < count; i++)
{
checkDoubleSet[i] = Rand.Default.RandFloat();
}
for (int i = 0; i < count; i++)
{
buffer.WriteDouble(i * 8, checkDoubleSet[i]);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadDouble(i * 8), checkDoubleSet[i]);
}
buffer = new ByteBuffer(checkCount);
count = checkCount / 5;
uint[] checkUintSet = new uint[count];
for (int i = 0; i < count; i++)
{
checkUintSet[i] = Rand.Default.RandUint();
}
int offset = 0;
for (int i = 0; i < count; i++)
{
offset += buffer.WriteVarint32(offset, checkUintSet[i]);
}
offset = 0;
for (int i = 0; i < count; i++)
{
int size;
Assert.AreEqual(buffer.ReadVarint32(offset, out size), checkUintSet[i]);
offset += size;
}
count = checkCount / 9;
long[] checkLongSet = new long[count];
for (int i = 0; i < count; i++)
{
checkLongSet[i] = Rand.Default.RandLong();
}
offset = 0;
for (int i = 0; i < count; i++)
{
offset += buffer.WriteVarint64(offset, (ulong)checkLongSet[i]);
}
offset = 0;
for (int i = 0; i < count; i++)
{
int size;
Assert.AreEqual(buffer.ReadVarint32(offset, out size), (uint)checkLongSet[i]);
offset += size;
}
offset = 0;
for (int i = 0; i < count; i++)
{
int size;
Assert.AreEqual(buffer.ReadVarint64(offset, out size), checkLongSet[i]);
offset += size;
}
}
public void TestBasic()
{
ByteBuffer bb = ByteBuffer.Allocate();
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
{
bool v = true;
bb.WriteBool(v);
Assert.AreEqual(1, bb.Size);
Assert.AreEqual(1, bb.Bytes[bb.ReadIndex]);
Assert.AreEqual(v, bb.ReadBool());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
byte v = 1;
bb.WriteByte(v);
Assert.AreEqual(1, bb.Size);
Assert.AreEqual(1, bb.Bytes[bb.ReadIndex]);
Assert.AreEqual(v, bb.ReadByte());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
double v = 1.1;
bb.WriteDouble(v);
Assert.AreEqual(8, bb.Size);
//Console.WriteLine(bb);
Assert.AreEqual("9A-99-99-99-99-99-F1-3F", bb.ToString());
Assert.AreEqual(v, bb.ReadDouble());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
float v = 1.1f;
bb.WriteFloat(v);
Assert.AreEqual(4, bb.Size);
//Console.WriteLine(bb);
Assert.AreEqual("CD-CC-8C-3F", bb.ToString());
Assert.AreEqual(v, bb.ReadFloat());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
int int4 = 0x12345678;
bb.WriteInt4(int4);
Assert.AreEqual(4, bb.Size);
//Console.WriteLine(bb);
Assert.AreEqual("78-56-34-12", bb.ToString());
Assert.AreEqual(int4, bb.ReadInt4());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
long long8 = 0x1234567801020304;
bb.WriteLong8(long8);
Assert.AreEqual(8, bb.Size);
//Console.WriteLine(bb);
Assert.AreEqual("04-03-02-01-78-56-34-12", bb.ToString());
Assert.AreEqual(long8, bb.ReadLong8());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
long long8 = -12345678;
bb.WriteLong8(long8);
Assert.AreEqual(8, bb.Size);
//Console.WriteLine(bb);
Assert.AreEqual("B2-9E-43-FF-FF-FF-FF-FF", bb.ToString());
Assert.AreEqual(long8, bb.ReadLong8());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
{
long long8 = -1;
bb.WriteLong8(long8);
Assert.AreEqual(8, bb.Size);
//Console.WriteLine(bb);
Assert.AreEqual("FF-FF-FF-FF-FF-FF-FF-FF", bb.ToString());
Assert.AreEqual(long8, bb.ReadLong8());
Assert.AreEqual(bb.ReadIndex, bb.WriteIndex);
}
}
public void Test()
{
var bytes = new byte[] { 3, 4, 5, 6 };
var byteSeg = new ArraySegment <byte>(bytes, 1, 2);
const string thisIsATest = "this is a test \u3333 \x22";
const double d = 1.2345e-200;
const float f = 1.2345e22f;
const ulong ul = 0xddddccccbbbbaaaaL;
const long l = 0x4dddcc3cbb2baa1aL;
var bb = new ByteBuffer(4);
for (var i = 0; i < 4; ++i)
{
Console.WriteLine(i);
var startingPos = ByteBuffer.StartWritePacket(bb);
ByteBuffer.WriteUlong(bb, ul);
ByteBuffer.WriteUshort(bb, 2345);
ByteBuffer.WriteBool(bb, true);
ByteBuffer.WriteLong(bb, l);
ByteBuffer.WriteBool(bb, false);
ByteBuffer.WriteByte(bb, 0x44);
ByteBuffer.WriteDouble(bb, d);
ByteBuffer.WriteFloat(bb, f);
ByteBuffer.WriteInt(bb, 45);
ByteBuffer.WriteUint(bb, 33);
ByteBuffer.WriteBytes(bb, bytes);
ByteBuffer.WriteBytes(bb, byteSeg);
ByteBuffer.WriteString(bb, thisIsATest);
ByteBuffer.WriteString(bb, null);
ByteBuffer.WriteUlong(bb, 0xFDECBA9876543210L);
ByteBuffer.WriteInt(bb, 0); // not read by reader
ByteBuffer.EndWritePacket(bb, startingPos, 0);
var startingPos1 = ByteBuffer.StartWritePacket(bb);
ByteBuffer.WriteInt(bb, 55);
ByteBuffer.EndWritePacket(bb, startingPos1, 0);
Assert.IsFalse(ByteBuffer.TryReadPacket(bb, r => { }, 0));
ByteBuffer.WriteCommit(bb);
Assert.IsTrue(ByteBuffer.TryReadPacket(bb, r =>
{
Assert.AreEqual(ul, ByteBuffer.ReadUlong(r));
Assert.AreEqual(2345, ByteBuffer.ReadUshort(r));
Assert.AreEqual(true, ByteBuffer.ReadBool(r));
Assert.AreEqual(l, ByteBuffer.ReadLong(r));
Assert.AreEqual(false, ByteBuffer.ReadBool(r));
Assert.AreEqual(0x44, ByteBuffer.ReadByte(r));
Assert.AreEqual(d, ByteBuffer.ReadDouble(r));
Assert.AreEqual(f, ByteBuffer.ReadFloat(r));
Assert.AreEqual(45, ByteBuffer.ReadInt(r));
Assert.AreEqual(33, ByteBuffer.ReadUint(r));
var readBytes = ByteBuffer.ReadBytes(r);
Assert.IsTrue(bytes.Eq(readBytes));
readBytes = ByteBuffer.ReadBytes(r);
Assert.IsTrue(byteSeg.Eq(readBytes));
var readString = ByteBuffer.ReadString(r);
Assert.AreEqual(thisIsATest, readString);
Assert.IsNull(ByteBuffer.ReadString(r));
Assert.AreEqual(0xFDECBA9876543210L, ByteBuffer.ReadUlong(r));
},
0));
var rp = bb.ReadPosition;
Assert.Greater(rp, 0);
ByteBuffer.ReadCommit(bb);
Assert.Greater(bb.WriteCommitPosition, 0);
Assert.AreEqual(0, bb.ReadPosition);
ByteBuffer.ReadCommit(bb);
Assert.IsTrue(ByteBuffer.TryReadPacket(bb, r => { Assert.AreEqual(55, ByteBuffer.ReadInt(r)); }, 0));
ByteBuffer.ReadCommit(bb);
Assert.AreEqual(0, bb.ReadPosition);
Assert.AreEqual(0, bb.WritePosition);
Assert.AreEqual(0, bb.WriteCommitPosition);
var x = ByteBuffer.StartWritePacket(bb);
ByteBuffer.WriteUlong(bb, 0xddddccccbbbbaaaaL);
ByteBuffer.WriteString(bb, thisIsATest);
ByteBuffer.WriteInt(bb, 45);
ByteBuffer.WriteUint(bb, 33);
ByteBuffer.WriteUlong(bb, 0xFDECBA9876543210L);
ByteBuffer.WriteInt(bb, 0); // not read by reader
ByteBuffer.EndWritePacket(bb, x, 0);
ByteBuffer.WriteCommit(bb);
int ep;
ByteBuffer.StartTryReadPacket(bb, out ep, 0);
Assert.AreEqual(0xddddccccbbbbaaaaL, ByteBuffer.ReadUlong(bb));
Assert.AreEqual(thisIsATest, ByteBuffer.ReadString(bb));
Assert.AreEqual(45, ByteBuffer.ReadInt(bb));
Assert.AreEqual(33, ByteBuffer.ReadUint(bb));
Assert.AreEqual(0xFDECBA9876543210L, ByteBuffer.ReadUlong(bb));
ByteBuffer.EndReadPacket(bb, ep);
ByteBuffer.ReadCommit(bb);
Assert.AreEqual(0, bb.ReadPosition);
Assert.AreEqual(0, bb.WritePosition);
Assert.AreEqual(0, bb.WriteCommitPosition);
}
}
