internal Builder Lock()
{
if (mLock)
{
Exception.Throw <NetworkException>("FlatBufferBuilder has already been locked, recursive lock is not allowed");
}
mLock = true;
mBuilder.Clear();
return(this);
}
void FB_Serialize(FlatBufferBuilder fbb)
{
fbb.Clear();
for (int p = 0; p < 10; ++p)
{
for (int n = 0; n < 10; ++n)
{
StringOffset phoneNumberOffset = fbb.CreateString(phoneNumber);
PhoneNumber.StartPhoneNumber(fbb);
PhoneNumber.AddNumber(fbb, phoneNumberOffset);
PhoneNumber.AddType(fbb, (PhoneType)(n % 3));
mPhoneArray[n] = PhoneNumber.EndPhoneNumber(fbb);
}
StringOffset nameOffset = fbb.CreateString(personName);
StringOffset emailOffset = fbb.CreateString(email);
VectorOffset phoneArrayOffset = Person.CreatePhonesVector(fbb, mPhoneArray);
Person.StartPerson(fbb);
Person.AddName(fbb, nameOffset);
Person.AddId(fbb, p);
Person.AddEmail(fbb, emailOffset);
Person.AddPhones(fbb, phoneArrayOffset);
mPersonArray[p] = Person.EndPerson(fbb);
}
VectorOffset peopleArrayOffset = AddressBook.CreatePeopleVector(fbb, mPersonArray);
AddressBook.StartAddressBook(fbb);
AddressBook.AddPeople(fbb, peopleArrayOffset);
Offset <AddressBook> offset = AddressBook.EndAddressBook(fbb);
fbb.Finish(offset.Value);
}
void EncodeAndDecode()
{
Enemy enemy = Pool.Get <Enemy>();
enemy.id = 100;
enemy.position = Pool.Get <Vec3>();
enemy.position.x = 10;
enemy.position.y = 0;
enemy.position.z = 200;
enemy.weapon = Pool.Get <Weapon>();
enemy.weapon.id = 10032;
enemy.weapon.ammo_capacity = 30;
enemy.teamId = 1;
for (int i = 0; i < 10; i++)
{
enemy.inventoryIds.Add(i * 3);
}
fbb.Clear();
enemy.Encode(fbb);
Pool.Put(enemy);
enemy = null;
Enemy anotherEnemy = Pool.Get <Enemy>();
anotherEnemy.Decode(fbb.DataBuffer);
Pool.Put(anotherEnemy);
// Debug.Log(anotherEnemy.id);
// Debug.Log(anotherEnemy.weapon.ammo_capacity);
}
public byte[] makeClient_PacketInfo(Vector3 pos, int Player_Animator, float dirX, float dirZ, float horizontal, float vertical, Vector3 PlayerRotation, string nickName)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
fbb.Clear(); // 클리어를 안해주고 시작하면 계속 누적해서 데이터가 들어간다.
var fbbNickName = fbb.CreateString(nickName); // String 문자열이 있을경우 미리 생성해라.
Client_info.StartClient_info(fbb);
Client_info.AddAnimator(fbb, Player_Animator);
Client_info.AddDirX(fbb, dirX);
Client_info.AddDirZ(fbb, dirZ);
Client_info.AddHorizontal(fbb, horizontal);
Client_info.AddVertical(fbb, vertical);
Client_info.AddName(fbb, fbbNickName);
Client_info.AddPosition(fbb, Vec3.CreateVec3(fbb, pos.x, pos.y, pos.z));
Client_info.AddRotation(fbb, Vec3.CreateVec3(fbb, PlayerRotation.x, PlayerRotation.y, PlayerRotation.z));
var endOffset = Client_info.EndClient_info(fbb);
fbb.Finish(endOffset.Value);
byte[] packet = fbb.SizedByteArray(); // flatbuffers 실제 패킷 데이터
byte[] magic_packet = makePacketinfo(packet.Length, CS_INFO);
byte[] real_packet = new byte[packet.Length + 8];
System.Buffer.BlockCopy(magic_packet, 0, real_packet, 0, magic_packet.Length);
System.Buffer.BlockCopy(packet, 0, real_packet, 8, packet.Length);
return(real_packet);
}
void Save()
{
mBuilder.Clear();
mStream.SetLength(0);
FlatBufferBuilder fbb = mBuilder;
// FlatBufferBuilder fbb = new FlatBufferBuilder(1);
// Create our sword for GameDataWhatever
//------------------------------------------------------
WeaponClassesOrWhatever weaponType = WeaponClassesOrWhatever.Sword;
Sword.StartSword(fbb);
Sword.AddDamage(fbb, 123);
Sword.AddDistance(fbb, 999);
Offset <Sword> offsetWeapon = Sword.EndSword(fbb);
/*
* // For gun uncomment this one and remove the sword one
* WeaponClassesOrWhatever weaponType = WeaponClassesOrWhatever.Gun;
* Gun.StartGun(fbb);
* Gun.AddDamage(fbb, 123);
* Gun.AddReloadspeed(fbb, 999);
* Offset<Gun> offsetWeapon = Gun.EndGun(fbb);
*/
//------------------------------------------------------
// Create strings for GameDataWhatever
//------------------------------------------------------
StringOffset cname = fbb.CreateString(mTime);
//------------------------------------------------------
// Create GameDataWhatever object we will store string and weapon in
//------------------------------------------------------
GameDataWhatever.StartGameDataWhatever(fbb);
GameDataWhatever.AddName(fbb, cname);
GameDataWhatever.AddPos(fbb, Vec3.CreateVec3(fbb, 1, 2, 1)); // structs can be inserted directly, no need to be defined earlier
GameDataWhatever.AddColor(fbb, CompanyNamespaceWhatever.Color.Red);
//Store weapon
GameDataWhatever.AddWeaponType(fbb, weaponType);
GameDataWhatever.AddWeapon(fbb, offsetWeapon.Value);
var offset = GameDataWhatever.EndGameDataWhatever(fbb);
//------------------------------------------------------
// GameDataWhatever.FinishGameDataWhateverBuffer(fbb, offset);
mStream.Write(fbb.DataBuffer.Data, fbb.DataBuffer.Position, fbb.Offset);
// Debug.Log("size: " + mStream.Length);
}
public byte[] ConstructClientHello(ClientMessageType type, ushort clientId, string playerName)
{
fbBuilder.Clear();
StringOffset playerNameOffset = fbBuilder.CreateString(playerName);
ClientHello.StartClientHello(fbBuilder);
ClientHello.AddPlayerName(fbBuilder, playerNameOffset);
Offset <ClientHello> clientHelloOffset = ClientHello.EndClientHello(fbBuilder);
ClientMessage.StartClientMessage(fbBuilder);
//var clientIdOffset = clientId;
ClientMessage.AddClientId(fbBuilder, clientId);
ClientMessage.AddMsgType(fbBuilder, type);
ClientMessage.AddMsg(fbBuilder, clientHelloOffset.Value);
Offset <ClientMessage> clientMessageOffset = ClientMessage.EndClientMessage(fbBuilder);
ClientMessage.FinishClientMessageBuffer(fbBuilder, clientMessageOffset);
return(fbBuilder.SizedByteArray());
}
public void FlatBufferBuilder_Empty_Builder()
{
var fbb = new FlatBufferBuilder(16);
var str = "Hello";
var flatbuffer = "Flatbuffers!";
var strOffset = fbb.CreateSharedString(str);
var flatbufferOffset = fbb.CreateSharedString(flatbuffer);
fbb.Clear();
var flatbufferOffset2 = fbb.CreateSharedString(flatbuffer);
var strOffset2 = fbb.CreateSharedString(str);
Assert.IsFalse(strOffset.Value == strOffset2.Value);
Assert.IsFalse(flatbufferOffset.Value == flatbufferOffset2.Value);
}
static void FB_Serialize(FlatBufferBuilder fbb)
{
fbb.Clear();
var phoneArray = OffsetArrayPool.Alloc <PhoneNumber>(10);
var personArray = OffsetArrayPool.Alloc <Person>(10);
for (int p = 0; p < 10; ++p)
{
phoneArray.Clear();
for (int n = 0; n < 10; ++n)
{
StringOffset phoneNumberOffset = fbb.CreateString((p * 100 + n).ToString());
PhoneNumber.StartPhoneNumber(fbb);
PhoneNumber.AddNumber(fbb, phoneNumberOffset);
PhoneNumber.AddType(fbb, (PhoneType)(n % 3));
phoneArray.offsets[phoneArray.position++] = PhoneNumber.EndPhoneNumber(fbb);
}
StringOffset nameOffset = fbb.CreateString(personName + p);
StringOffset emailOffset = fbb.CreateString(string.Format("{0}{1}@gmail.com", personName, p));
Person.StartPhonesVector(fbb, phoneArray.position);
VectorOffset phoneArrayOffset = Helpers.SetVector(fbb, phoneArray);
Person.StartPerson(fbb);
Person.AddName(fbb, nameOffset);
Person.AddId(fbb, p);
Person.AddEmail(fbb, emailOffset);
Person.AddPhones(fbb, phoneArrayOffset);
personArray.offsets[personArray.position++] = Person.EndPerson(fbb);
}
AddressBook.StartPeopleVector(fbb, personArray.position);
VectorOffset peopleArrayOffset = Helpers.SetVector(fbb, personArray);
AddressBook.StartAddressBook(fbb);
AddressBook.AddPeople(fbb, peopleArrayOffset);
Offset <AddressBook> offset = AddressBook.EndAddressBook(fbb);
fbb.Finish(offset.Value);
OffsetArrayPool.Dealloc(ref phoneArray);
OffsetArrayPool.Dealloc(ref personArray);
}
public byte[] makeEatItemPacket(int item, int player)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
fbb.Clear();
Eat_Item.StartEat_Item(fbb);
Eat_Item.AddItemID(fbb, item);
Eat_Item.AddPlayerID(fbb, player);
var endOffset = Eat_Item.EndEat_Item(fbb);
fbb.Finish(endOffset.Value);
byte[] packet = fbb.SizedByteArray(); // flatbuffers 실제 패킷 데이터
byte[] magic_packet = makePacketinfo(packet.Length, CS_GET_ITEM);
byte[] real_packet = new byte[packet.Length + 8];
System.Buffer.BlockCopy(magic_packet, 0, real_packet, 0, magic_packet.Length);
System.Buffer.BlockCopy(packet, 0, real_packet, 8, packet.Length);
return(real_packet);
}
public byte[] makeLoginInfoPacket(string id, string pw)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
fbb.Clear();
var idOffset = fbb.CreateString(id); // String 문자열이 있을경우 미리 생성해라.
var pwOffset = fbb.CreateString(pw); // String 문자열이 있을경우 미리 생성해라.
Login.StartLogin(fbb);
Login.AddId(fbb, idOffset);
Login.AddPassword(fbb, pwOffset);
var endOffset = Login.EndLogin(fbb);
fbb.Finish(endOffset.Value);
byte[] packet = fbb.SizedByteArray();
byte[] magic_packet = makePacketinfo(packet.Length, CS_LOGIN);
byte[] real_packet = new byte[packet.Length + 8];
System.Buffer.BlockCopy(magic_packet, 0, real_packet, 0, magic_packet.Length);
System.Buffer.BlockCopy(packet, 0, real_packet, 8, packet.Length);
return(real_packet);
}
public byte[] makeMonsterInfoPacket(int id, int ani, float x, float z, Vector3 pos, Vector3 rot)
{
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
fbb.Clear();
Monster_info.StartMonster_info(fbb);
Monster_info.AddId(fbb, id);
Monster_info.AddAnimator(fbb, ani);
Monster_info.AddDirX(fbb, x);
Monster_info.AddDirZ(fbb, z);
Monster_info.AddPosition(fbb, Vec3.CreateVec3(fbb, pos.x, pos.y, pos.z));
Monster_info.AddRotation(fbb, Vec3.CreateVec3(fbb, rot.x, rot.y, rot.z));
var endOffset = Monster_info.EndMonster_info(fbb);
fbb.Finish(endOffset.Value);
byte[] packet = fbb.SizedByteArray();
byte[] magic_packet = makePacketinfo(packet.Length, CS_MONSTER_STATUS);
byte[] real_packet = new byte[packet.Length + 8];
System.Buffer.BlockCopy(magic_packet, 0, real_packet, 0, magic_packet.Length);
System.Buffer.BlockCopy(packet, 0, real_packet, 8, packet.Length);
return(real_packet);
}
public void SimpleStoreRetrieve()
{
var config = new DatabaseConfiguration(DatabaseOptions.Create);
Database dbase;
Statistics stats;
using (var tx = fixture.Env.BeginDatabaseTransaction(TransactionModes.None)) {
dbase = tx.OpenDatabase("TestDb3", config);
stats = dbase.GetStats(tx);
tx.Commit();
}
var buffer = fixture.Buffers.Acquire(1024);
try {
FlatBufferBuilder liBuilder = new FlatBufferBuilder(64);
FlatBufferBuilder liKeyBuilder = new FlatBufferBuilder(32);
// in FlatBuffers, each serializable item is backed by a byte buffer, the item itself is a struct
byte[] liBytes;
byte[] li2Bytes;
using (var tx = fixture.Env.BeginTransaction(TransactionModes.None)) {
var prodCode = liKeyBuilder.CreateString("GIN");
var lik = LineItemKey.CreateLineItemKey(liKeyBuilder, prodCode, 1);
liKeyBuilder.Finish(lik.Value);
prodCode = liBuilder.CreateString("GIN");
lik = LineItemKey.CreateLineItemKey(liBuilder, prodCode, 1);
var li = LineItem.CreateLineItem(liBuilder, lik, 24);
liBuilder.Finish(li.Value);
liBytes = liBuilder.SizedByteArray();
// lineItem points into the liBuilder's data buffer
var lineItem = LineItem.GetRootAsLineItem(liBuilder.DataBuffer);
var keySpan = liKeyBuilder.DataBuffer.ToSpan();
var dataSpan = liBuilder.DataBuffer.ToSpan();
dbase.Put(tx, keySpan, dataSpan, PutOptions.None);
liKeyBuilder.Clear();
liBuilder.Clear();
prodCode = liKeyBuilder.CreateString("WHISKY");
lik = LineItemKey.CreateLineItemKey(liKeyBuilder, prodCode, 2);
liKeyBuilder.Finish(lik.Value);
prodCode = liBuilder.CreateString("WHISKY");
lik = LineItemKey.CreateLineItemKey(liBuilder, prodCode, 2);
li = LineItem.CreateLineItem(liBuilder, lik, 32);
liBuilder.Finish(li.Value);
li2Bytes = liBuilder.SizedByteArray();
keySpan = liKeyBuilder.DataBuffer.ToSpan();
dataSpan = liBuilder.DataBuffer.ToSpan();
dbase.Put(tx, keySpan, dataSpan, PutOptions.None);
tx.Commit();
}
byte[] liOutBytes;
byte[] liOut2Bytes;
using (var tx = fixture.Env.BeginReadOnlyTransaction(TransactionModes.None)) {
liKeyBuilder.Clear();
var prodCode = liKeyBuilder.CreateString("GIN");
var lik = LineItemKey.CreateLineItemKey(liKeyBuilder, prodCode, 1);
liKeyBuilder.Finish(lik.Value);
var keySpan = liKeyBuilder.DataBuffer.ToSpan();
Assert.True(dbase.Get(tx, keySpan, out ReadOnlySpan <byte> dataSpan));
liOutBytes = dataSpan.ToArray();
// lineItemOut points into liOutBytes
var lineItemOut = LineItem.GetRootAsLineItem(new ByteBuffer(liOutBytes));
liKeyBuilder.Clear();
prodCode = liKeyBuilder.CreateString("WHISKY");
lik = LineItemKey.CreateLineItemKey(liKeyBuilder, prodCode, 2);
liKeyBuilder.Finish(lik.Value);
keySpan = liKeyBuilder.DataBuffer.ToSpan();
Assert.True(dbase.Get(tx, keySpan, out dataSpan));
liOut2Bytes = dataSpan.ToArray();
tx.Commit();
}
Assert.True(liBytes.SequenceEqual(liOutBytes));
Assert.True(li2Bytes.SequenceEqual(liOut2Bytes));
}
finally {
fixture.Buffers.Return(buffer);
using (var tx = fixture.Env.BeginDatabaseTransaction(TransactionModes.None)) {
dbase.Drop(tx);
tx.Commit();
}
}
}
public void Send <T>(Offset <T> message) where T : struct, IFlatbufferObject
{
ClientServerMessage.StartClientServerMessage(builder);
if (message is Offset <GetVersionMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.GetVersionMessage);
}
else if (message is Offset <EnterQueueMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.EnterQueueMessage);
}
else if (message is Offset <LeaveQueueMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.LeaveQueueMessage);
}
else if (message is Offset <CreateRoomMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.CreateRoomMessage);
}
else if (message is Offset <LeaveRoomMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.LeaveRoomMessage);
}
else if (message is Offset <EnterRoomMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.EnterRoomMessage);
}
else if (message is Offset <StartRoomMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.StartRoomMessage);
}
else if (message is Offset <SelectTeamMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.SelectTeamMessage);
}
else if (message is Offset <ConnectMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.ConnectMessage);
}
else if (message is Offset <ClientReadyMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.ClientReadyMessage);
}
else if (message is Offset <ClientInputMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.ClientInputMessage);
}
else if (message is Offset <ClientActionMessage> )
{
ClientServerMessage.AddContentType(builder, ClientServerMessageContent.ClientActionMessage);
}
else
{
throw new NotImplementedException("Message type not implemented!");
}
ClientServerMessage.AddContent(builder, message.Value);
var clientServerMessage = ClientServerMessage.EndClientServerMessage(builder);
builder.Finish(clientServerMessage.Value);
byte[] buf = builder.SizedByteArray();
if (message is Offset <ClientInputMessage> )
{
netClient.SendUnreliable(buf, Convert.ToUInt16(buf.Length));
}
else
{
netClient.SendReliable(buf, Convert.ToUInt16(buf.Length));
}
builder.Clear();
}
internal Builder(FlatBufferBuilder fbb)
{
mBuilder = fbb;
mBuilder.Clear();
}