public void CanCreateNewFlatBufferFromScratch()
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2);
fbb.AddOffset(test1);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, (byte)1);
Monster.AddTest(fbb, mon2);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
var mon = Monster.EndMonster(fbb);
fbb.Finish(mon);
// Dump to output directory so we can inspect later, if needed
using (var ms = new MemoryStream(fbb.DataBuffer().Data, fbb.DataBuffer().position(), fbb.Offset()))
{
var data = ms.ToArray();
File.WriteAllBytes(@"Resources/monsterdata_cstest.mon",data);
}
// Now assert the buffer
TestBuffer(fbb.DataBuffer());
}
public void TestBunchOfBools()
{
var builder = new FlatBufferBuilder(1);
builder.StartObject(8);
for (var i = 0; i < 8; i++)
{
builder.AddBool(i, true, false);
}
var off = builder.EndObject();
builder.Finish(off);
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0, // padding to 64 bytes
24, 0, 0, 0, // root of table, pointing to vtable offset (obj0)
20, 0, // vtable bytes
12, 0, // object length
11, 0, // start of value 0
10, 0, // start of value 1
9, 0, // start of value 2
8, 0, // start of value 3
7, 0, // start of value 4
6, 0, // start of value 5
5, 0, // start of value 6
4, 0, // start of value 7
20, 0, 0, 0, // int32 offset for start of vtable
1, 1, 1, 1, // values
1, 1, 1, 1,
},
builder.DataBuffer.Data);
}
public async Task StepAsync(CancellationToken cancellationToken)
{
try
{
if (player != null)
{
var builder = new FlatBufferBuilder(1);
lock (world.Bodies) // wrong kind of lock but might do for now
{
// First try to focus camera on the player if they have
// a fleet alive;
var followFleet = player?.Fleet;
// if the player doesn't have a fleet alive
if (followFleet == null)
{
// check to see if they are spectating a fleet that's alive
if (SpectatingFleet != null && SpectatingFleet.Exists)
{
followFleet = SpectatingFleet;
}
}
if (followFleet == null)
{
// find someone else to watch
followFleet = Player.GetWorldPlayers(world)
.ToList()
.Where(p => p.IsAlive)
.OrderByDescending(p => p.Score * 10000 + (10000 - p.Fleet?.ID ?? 0))
.FirstOrDefault()
?.Fleet;
}
Body followBody = null;
// if we're watching a fleet, watch the center of their fleet
if (followFleet != null)
{
var center = Core.Steering.Flocking.FleetCenterNaive(followFleet.Ships);
followBody = new Body
{
DefinitionTime = world.Time,
OriginalPosition = center,
Position = center,
Momentum = followFleet.FleetMomentum
};
}
// we've found someone to spectate, record it
if (followFleet != player?.Fleet && followFleet != SpectatingFleet)
{
SpectatingFleet = followFleet;
}
// if we haven't found anything to watch yet, watch the first ship we find
if (followBody == null)
{
followBody = player?.World.Bodies.OfType <Ship>().FirstOrDefault();
}
// if we haven't found anything to watch yet, watch anything
if (followBody == null)
{
followBody = player?.World.Bodies.FirstOrDefault();
}
if (followBody != null)
{
var halfViewport = new Vector2(3300, 3300);
BodyCache.Update(
world.Bodies,
world.Groups,
world.Time,
Vector2.Subtract(followBody.Position, halfViewport),
Vector2.Add(followBody.Position, halfViewport)
);
var updates = BodyCache.BodiesByError();
var updateBodies = updates.Take((int)this.Bandwidth);
var newHash = world.Hook.GetHashCode();
float VELOCITY_SCALE_FACTOR = 5000;
var updatedGroups = BodyCache.GroupsByError().ToList();
var groupsVector = NetWorldView.CreateGroupsVector(builder,
updatedGroups.Select(b =>
{
var serverGroup = b.GroupUpdated;
var caption = builder.CreateString(serverGroup.Caption ?? " ");
var group = NetGroup.CreateNetGroup(builder,
group: serverGroup.ID,
type: serverGroup.GroupType,
captionOffset: caption,
zindex: serverGroup.ZIndex
);
return(group);
}).ToArray());
foreach (var update in updatedGroups)
{
update.GroupClient = update.GroupUpdated.Clone();
}
var groupDeletesVector = NetWorldView.CreateGroupDeletesVector(builder, BodyCache.CollectStaleGroups().Select(b =>
b.GroupUpdated.ID
).ToArray());
NetWorldView.StartUpdatesVector(builder, updateBodies.Count());
foreach (var b in updateBodies)
{
var serverBody = b.BodyUpdated;
var body = NetBody.CreateNetBody(builder,
Id: serverBody.ID,
DefinitionTime: serverBody.DefinitionTime,
originalPosition_X: (short)serverBody.OriginalPosition.X,
originalPosition_Y: (short)serverBody.OriginalPosition.Y,
velocity_X: (short)(serverBody.Momentum.X * VELOCITY_SCALE_FACTOR),
velocity_Y: (short)(serverBody.Momentum.Y * VELOCITY_SCALE_FACTOR),
OriginalAngle: (sbyte)(serverBody.OriginalAngle / MathF.PI * 127),
AngularVelocity: (sbyte)(serverBody.AngularVelocity * 10000),
Size: (byte)(serverBody.Size / 5),
Sprite: (byte)serverBody.Sprite,
Mode: 0,
Group: serverBody.Group?.ID ?? 0);
}
var updatesVector = builder.EndVector();
foreach (var update in updateBodies)
{
update.BodyClient = update.BodyUpdated.Clone();
}
var deletesVector = NetWorldView.CreateDeletesVector(builder, BodyCache.CollectStaleBuckets().Select(b =>
b.BodyUpdated.ID
).ToArray());
var messages = player.GetMessages();
VectorOffset announcementsVector = new VectorOffset();
if (messages != null && messages.Any())
{
announcementsVector = NetWorldView.CreateAnnouncementsVector(builder, messages.Select(e =>
{
var stringName = builder.CreateString(e);
NetAnnouncement.StartNetAnnouncement(builder);
NetAnnouncement.AddText(builder, stringName);
return(NetAnnouncement.EndNetAnnouncement(builder));
}).ToArray());
}
NetWorldView.StartNetWorldView(builder);
// define camera
var cameraBody = NetBody.CreateNetBody(
builder,
Id: 0,
DefinitionTime: followBody?.DefinitionTime ?? 0,
originalPosition_X: (short)(followBody?.OriginalPosition.X ?? 0),
originalPosition_Y: (short)(followBody?.OriginalPosition.Y ?? 0),
velocity_X: (short)(followBody?.Momentum.X * VELOCITY_SCALE_FACTOR ?? 0),
velocity_Y: (short)(followBody?.Momentum.Y * VELOCITY_SCALE_FACTOR ?? 0),
OriginalAngle: (sbyte)(followBody?.OriginalAngle / MathF.PI / 127 ?? 0),
AngularVelocity: 0,
Size: 0,
Sprite: 0,
Mode: 0,
Group: 0
);
NetWorldView.AddCamera(builder, cameraBody);
NetWorldView.AddIsAlive(builder, player?.IsAlive ?? false);
NetWorldView.AddTime(builder, world.Time);
NetWorldView.AddUpdates(builder, updatesVector);
NetWorldView.AddDeletes(builder, deletesVector);
NetWorldView.AddGroups(builder, groupsVector);
NetWorldView.AddGroupDeletes(builder, groupDeletesVector);
if (messages != null && messages.Any())
{
NetWorldView.AddAnnouncements(builder, announcementsVector);
}
var players = Player.GetWorldPlayers(world);
NetWorldView.AddPlayerCount(builder, (uint)players.Count(p => p.IsAlive || (!p.PendingDestruction && p.DeadSince > world.Time - world.Hook.PlayerCountGracePeriodMS)));
NetWorldView.AddSpectatorCount(builder, (uint)players.Count(p => p.Connection?.IsSpectating ?? false));
NetWorldView.AddCooldownBoost(builder, (byte)((player?.Fleet?.BoostCooldownStatus * 255) ?? 0));
NetWorldView.AddCooldownShoot(builder, (byte)((player?.Fleet?.ShootCooldownStatus * 255) ?? 0));
NetWorldView.AddWorldSize(builder, (ushort)world.Hook.WorldSize);
var worldView = NetWorldView.EndNetWorldView(builder);
HookHash = newHash;
var q = NetQuantum.CreateNetQuantum(builder, AllMessages.NetWorldView, worldView.Value);
builder.Finish(q.Value);
}
}
await this.SendAsync(builder.DataBuffer, cancellationToken);
if (LeaderboardTime != (world.Leaderboard?.Time ?? 0))
{
LeaderboardTime = (world.Leaderboard?.Time ?? 0);
builder = new FlatBufferBuilder(1);
var stringName = builder.CreateString(world.Leaderboard?.ArenaRecord?.Name ?? " ");
var stringColor = builder.CreateString(world.Leaderboard?.ArenaRecord?.Color ?? " ");
NetLeaderboardEntry.StartNetLeaderboardEntry(builder);
NetLeaderboardEntry.AddColor(builder, stringColor);
NetLeaderboardEntry.AddName(builder, stringName);
NetLeaderboardEntry.AddScore(builder, world.Leaderboard?.ArenaRecord?.Score ?? 0);
NetLeaderboardEntry.AddToken(builder, !string.IsNullOrEmpty(world.Leaderboard?.ArenaRecord?.Token));
var record = NetLeaderboardEntry.EndNetLeaderboardEntry(builder);
var entriesVector = NetLeaderboard.CreateEntriesVector(builder, world.Leaderboard.Entries.Select(e =>
{
stringName = builder.CreateString(e.Name ?? string.Empty);
stringColor = builder.CreateString(e.Color ?? string.Empty);
// stringToken = builder.CreateString( ?? string.Empty);
NetLeaderboardEntry.StartNetLeaderboardEntry(builder);
NetLeaderboardEntry.AddName(builder, stringName);
NetLeaderboardEntry.AddColor(builder, stringColor);
NetLeaderboardEntry.AddScore(builder, e.Score);
NetLeaderboardEntry.AddPosition(builder, FromPositionVector(builder, e.Position));
NetLeaderboardEntry.AddToken(builder, !string.IsNullOrEmpty(e.Token));
return(NetLeaderboardEntry.EndNetLeaderboardEntry(builder));
}).ToArray());
var stringType = builder.CreateString(world.Leaderboard.Type ?? string.Empty);
NetLeaderboard.StartNetLeaderboard(builder);
NetLeaderboard.AddEntries(builder, entriesVector);
NetLeaderboard.AddType(builder, stringType);
NetLeaderboard.AddRecord(builder, record);
var leaderboardOffset = NetLeaderboard.EndNetLeaderboard(builder);
builder.Finish(NetQuantum.CreateNetQuantum(builder, AllMessages.NetLeaderboard, leaderboardOffset.Value).Value);
await this.SendAsync(builder.DataBuffer, cancellationToken);
}
}
}
catch (WebSocketException e)
{
//Console.WriteLine(e);
throw;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static void FinishModifyMultisigAccountTransactionBufferBuffer(FlatBufferBuilder builder, Offset <ModifyMultisigAccountTransactionBuffer> offset)
{
builder.Finish(offset.Value);
}
public void TestTwoFinishTable()
{
var builder = new FlatBufferBuilder(1);
builder.StartObject(2);
builder.AddByte(0, 33, 0);
builder.AddByte(1, 44, 0);
var off0 = builder.EndObject();
builder.Finish(off0);
builder.StartObject(3);
builder.AddByte(0, 55, 0);
builder.AddByte(1, 66, 0);
builder.AddByte(2, 77, 0);
var off1 = builder.EndObject();
builder.Finish(off1);
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0, // padding to 64 bytes
16, 0, 0, 0, // root of table, pointing to vtable offset (obj1)
0, 0, // padding
10, 0, // vtable bytes
8, 0, // object length
7, 0, // start of value 0
6, 0, // start of value 1
5, 0, // start of value 2
10, 0, 0, 0, // int32 offset for start of vtable
0, // pad
77, // values 2, 1, 0
66,
55,
12, 0, 0, 0, // root of table, pointing to vtable offset (obj0)
8, 0, // vtable bytes
8, 0, // object length
7, 0, // start of value 0
6, 0, // start of value 1
8, 0, 0, 0, // int32 offset for start of vtable
0, 0, // pad
44, // value 1, 0
33,
},
builder.DataBuffer.Data);
}
public static void FinishBossSimpleDataBuffer(FlatBufferBuilder builder, Offset <BossSimpleData> offset)
{
builder.Finish(offset.Value);
}
public static void FinishFClientIdBuffer(FlatBufferBuilder builder, Offset <mainServer.schemas.FClientId.FClientId> offset)
{
builder.Finish(offset.Value);
}
public static void FinishDataListBuffer(FlatBufferBuilder builder, Offset <DataList> offset)
{
builder.Finish(offset.Value);
}
public static void FinishClientMessageBuffer(FlatBufferBuilder builder, Offset <ButtplugFFI.ClientMessage> offset)
{
builder.Finish(offset.Value);
}
public static void FinishFlatGraphBuffer(FlatBufferBuilder builder, Offset <FlatGraph> offset)
{
builder.Finish(offset.Value);
}
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();
}
public static void FinishVipBuffer(FlatBufferBuilder builder, Offset <Vip> offset)
{
builder.Finish(offset.Value);
}
public static void FinishTransferTransactionBufferBuffer(FlatBufferBuilder builder, Offset <TransferTransactionBuffer> offset)
{
builder.Finish(offset.Value);
}
public static void FinishEnemyHPBuffer(FlatBufferBuilder builder, Offset <EnemyHP> offset)
{
builder.Finish(offset.Value);
}
public static void FinishGetGameRewardsRspBuffer(FlatBufferBuilder builder, Offset <GetGameRewardsRsp> offset)
{
builder.Finish(offset.Value);
}
public static void FinishEnterMultiplayGameRspBuffer(FlatBufferBuilder builder, Offset <EnterMultiplayGameRsp> offset)
{
builder.Finish(offset.Value);
}
public static void FinishModifyMetadataTransactionBufferBuffer(FlatBufferBuilder builder, Offset <ModifyMetadataTransactionBuffer> offset)
{
builder.Finish(offset.Value);
}
public static void FinishMonsterBuffer(FlatBufferBuilder builder, Offset <Monster> offset)
{
builder.Finish(offset.Value, "MONS");
}
public static void FinishMonsterExtraBuffer(FlatBufferBuilder builder, Offset <MyGame.MonsterExtra> offset)
{
builder.Finish(offset.Value, "MONE");
}
public static void FinishStatePushBuffer(FlatBufferBuilder builder, Offset <StatePush> offset)
{
builder.Finish(offset.Value);
}
public static void FinishBookShelfFlatBuffer(FlatBufferBuilder builder, Offset <BookShelfFlat> offset)
{
builder.Finish(offset.Value);
}
static Benchmarks()
{
{
var builder = new FlatBufferBuilder(8);
var offset = Data_8b.CreateData_8b(builder);
builder.Finish(offset.Value);
InputData.Add(Data_8b.GetRootAsData_8b(builder.DataBuffer));
}
{
var builder = new FlatBufferBuilder(128);
List <Offset <Data_8b> > inner8b = new List <Offset <Data_8b> >();
for (var i = 0; i < 16; i++)
{
inner8b.Add(Data_8b.CreateData_8b(builder));
}
var innerOffset = Data_128b.CreateInnerVector(builder, inner8b.ToArray());
var offset = Data_128b.CreateData_128b(builder, innerOffset);
builder.Finish(offset.Value);
InputData.Add(Data_128b.GetRootAsData_128b(builder.DataBuffer));
}
{
var builder = new FlatBufferBuilder(128);
List <Offset <Data_128b> > inner128b = new List <Offset <Data_128b> >();
for (var i = 0; i < 8; i++)
{
List <Offset <Data_8b> > inner8b = new List <Offset <Data_8b> >();
for (var j = 0; j < 16; j++)
{
inner8b.Add(Data_8b.CreateData_8b(builder));
}
var inner8bOffset = Data_128b.CreateInnerVector(builder, inner8b.ToArray());
inner128b.Add(Data_128b.CreateData_128b(builder, inner8bOffset));
}
var innerOffset = Data_1KB.CreateInnerVector(builder, inner128b.ToArray());
var offset = Data_1KB.CreateData_1KB(builder, innerOffset);
builder.Finish(offset.Value);
InputData.Add(Data_1KB.GetRootAsData_1KB(builder.DataBuffer));
}
{
var builder = new FlatBufferBuilder(128);
List <Offset <Data_1KB> > inner1kb = new List <Offset <Data_1KB> >();
for (var i = 0; i < 1024; i++)
{
List <Offset <Data_128b> > inner128b = new List <Offset <Data_128b> >();
for (var j = 0; j < 8; j++)
{
List <Offset <Data_8b> > inner8b = new List <Offset <Data_8b> >();
for (var k = 0; k < 16; k++)
{
inner8b.Add(Data_8b.CreateData_8b(builder));
}
var inner8bOffset = Data_128b.CreateInnerVector(builder, inner8b.ToArray());
inner128b.Add(Data_128b.CreateData_128b(builder, inner8bOffset));
}
var inner128bOffset = Data_1KB.CreateInnerVector(builder, inner128b.ToArray());
inner1kb.Add(Data_1KB.CreateData_1KB(builder, inner128bOffset));
}
var innerOffset = Data_1MB.CreateInnerVector(builder, inner1kb.ToArray());
var offset = Data_1MB.CreateData_1MB(builder, innerOffset);
builder.Finish(offset.Value);
InputData.Add(Data_1MB.GetRootAsData_1MB(builder.DataBuffer));
}
}
public static void FinishMovieBuffer(FlatBufferBuilder builder, Offset <Movie> offset)
{
builder.Finish(offset.Value, "MOVI");
}
public static void FinishFlatInferenceRequestBuffer(FlatBufferBuilder builder, Offset <FlatInferenceRequest> offset)
{
builder.Finish(offset.Value);
}
public static void FinishGameMessageBuffer(FlatBufferBuilder builder, Offset <syncnet.GameMessage> offset)
{
builder.Finish(offset.Value);
}
public void CanCreateNewFlatBufferFromScratch()
{
// Second, let's create a FlatBuffer from scratch in C#, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
var fbb = new FlatBufferBuilder(1);
// We set up the same values as monsterdata.json:
var str = fbb.CreateString("MyMonster");
var test1 = fbb.CreateString("test1");
var test2 = fbb.CreateString("test2");
Monster.StartInventoryVector(fbb, 5);
for (int i = 4; i >= 0; i--)
{
fbb.AddByte((byte)i);
}
var inv = fbb.EndVector();
var fred = fbb.CreateString("Fred");
Monster.StartMonster(fbb);
Monster.AddName(fbb, fred);
var mon2 = Monster.EndMonster(fbb);
Monster.StartTest4Vector(fbb, 2);
MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
var test4 = fbb.EndVector();
Monster.StartTestarrayofstringVector(fbb, 2);
fbb.AddOffset(test2.Value);
fbb.AddOffset(test1.Value);
var testArrayOfString = fbb.EndVector();
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, (short)5, (sbyte)6));
Monster.AddHp(fbb, (short)80);
Monster.AddName(fbb, str);
Monster.AddInventory(fbb, inv);
Monster.AddTestType(fbb, Any.Monster);
Monster.AddTest(fbb, mon2.Value);
Monster.AddTest4(fbb, test4);
Monster.AddTestarrayofstring(fbb, testArrayOfString);
Monster.AddTestbool(fbb, false);
var mon = Monster.EndMonster(fbb);
fbb.Finish(mon.Value);
// Dump to output directory so we can inspect later, if needed
using (var ms = new MemoryStream(fbb.DataBuffer.Data, fbb.DataBuffer.Position, fbb.Offset))
{
var data = ms.ToArray();
File.WriteAllBytes(@"Resources/monsterdata_cstest.mon", data);
}
// Now assert the buffer
TestBuffer(fbb.DataBuffer);
}
public static void FinishPacketBuffer(FlatBufferBuilder builder, Offset <Packet> offset)
{
builder.Finish(offset.Value);
}
public void TestVTableWithSomeElements()
{
var builder = new FlatBufferBuilder(1);
builder.StartObject(2);
builder.AddByte(0, 33, 0);
builder.AddShort(1, 66, 0);
var off = builder.EndObject();
builder.Finish(off);
Assert.ArrayEqual(new byte[]
{
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0, //Padding to 32 bytes
12, 0, 0, 0, // root of table, pointing to vtable offset
8, 0, // vtable bytes
8, 0, // object length
7, 0, // start of value 0
4, 0, // start of value 1
8, 0, 0, 0, // int32 offset for start of vtable
66, 0, // value 1
0, 33, // value 0
},
builder.DataBuffer.Data);
}
public static void FinishGetGameDatasReqBuffer(FlatBufferBuilder builder, Offset <GetGameDatasReq> offset)
{
builder.Finish(offset.Value);
}
public static void FinishLockFundsTransactionBufferBuffer(FlatBufferBuilder builder, Offset <LockFundsTransactionBuffer> offset)
{
builder.Finish(offset.Value);
}
public static void FinishMessageRootBuffer(FlatBufferBuilder builder, Offset <MessageRoot> offset)
{
builder.Finish(offset.Value);
}
public static void FinishSimpleTypeBuffer(FlatBufferBuilder builder, Offset <SimpleType> offset)
{
builder.Finish(offset.Value);
}
public static void FinishTestGlobal2TemplateBuffer(FlatBufferBuilder builder, Offset <Config.TestGlobal2Template> offset)
{
builder.Finish(offset.Value);
}
public static void FinishArrayTableBuffer(FlatBufferBuilder builder, Offset <MyGame.Example.ArrayTable> offset)
{
builder.Finish(offset.Value, "ARRT");
}