public static Offset <Monster> BuildMonster(FlatBufferBuilder fbb)
{
var sword = Weapon.CreateWeapon(fbb, fbb.CreateString("Sword"), 3);
var axe = Weapon.CreateWeapon(fbb, fbb.CreateString("Axe"), 5);
Monster.StartInventoryVector(fbb, 5);
var inventoryOffset = BuildVector(fbb, true);;
var weapons = new Offset <Weapon>[2] {
sword, axe
};
var weaponsOffset = Monster.CreateWeaponsVector(fbb, weapons);
Monster.StartPathVector(fbb, 2); //Vector of structs
Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f);
Vec3.CreateVec3(fbb, 4.0f, 5.0f, 6.0f);
var path = fbb.EndVector();
var nameOffset = fbb.CreateString("Orc");
Monster.StartMonster(fbb);
Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f));
Monster.AddHp(fbb, 300);
Monster.AddName(fbb, nameOffset);
Monster.AddInventory(fbb, inventoryOffset);
Monster.AddColor(fbb, Color.Red);
Monster.AddWeapons(fbb, weaponsOffset);
Monster.AddEquippedType(fbb, Equipment.Weapon); //Type of union stored
Monster.AddEquipped(fbb, axe.Value); // Value of union
Monster.AddPath(fbb, path);
return(Monster.EndMonster(fbb));
}
public void LocationStruct()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var fakeString = builder.CreateString("foobar");
Oracle.LocationHolder.StartLocationVectorVector(builder, 3);
Oracle.Location.CreateLocation(builder, 7f, 8f, 9f);
Oracle.Location.CreateLocation(builder, 4f, 5f, 6f);
Oracle.Location.CreateLocation(builder, 1f, 2f, 3f);
var vectorOffset = builder.EndVector();
Oracle.LocationHolder.StartLocationHolder(builder);
Oracle.LocationHolder.AddFake(builder, fakeString);
Oracle.LocationHolder.AddSingleLocation(builder, Oracle.Location.CreateLocation(builder, 0.1f, 0.2f, 0.3f));
Oracle.LocationHolder.AddLocationVector(builder, vectorOffset);
var testData = Oracle.LocationHolder.EndLocationHolder(builder);
builder.Finish(testData.Value);
byte[] realBuffer = builder.SizedByteArray();
var parsed = FlatBufferSerializer.Default.Parse <LocationHolder>(realBuffer);
Assert.Equal("foobar", parsed.Fake);
Assert.Equal(0.1f, parsed.Location.X);
Assert.Equal(0.2f, parsed.Location.Y);
Assert.Equal(0.3f, parsed.Location.Z);
Assert.Equal(3, parsed.LocationVector.Count);
for (int i = 0; i < 3; ++i)
{
Assert.Equal((float)(3 * i + 1), parsed.LocationVector[i].X);
Assert.Equal((float)(3 * i + 2), parsed.LocationVector[i].Y);
Assert.Equal((float)(3 * i + 3), parsed.LocationVector[i].Z);
}
}
static FlatBuffersObject.Person SerializeSingleFlatBuffers()
{
Console.WriteLine("FlatBuffers");
FlatBuffersObject.Person copy = default(FlatBuffersObject.Person);
byte[] bytes = null;
using (new Measure("Serialize"))
{
for (int i = 0; i < Iteration; i++)
{
var builder = new FlatBuffers.FlatBufferBuilder(1);
var person = FlatBuffersObject.Person.CreatePerson(builder, 99999, builder.CreateString("Windows"), builder.CreateString("Server"), FlatBuffersObject.Sex.Male);
builder.Finish(person.Value);
bytes = builder.SizedByteArray();
}
}
using (new Measure("Deserialize"))
{
for (int i = 0; i < Iteration; i++)
{
copy = FlatBuffersObject.Person.GetRootAsPerson(new FlatBuffers.ByteBuffer(bytes));
}
}
if (!dryRun)
{
Console.WriteLine(string.Format("{0,15} {1}", "Binary Size", ToHumanReadableSize(bytes.Length)));
}
return(copy);
}
public void ConvertMessageSelect(string path)
{
List <string> lineList = this.getLineList(path);
FlatBuffers.FlatBufferBuilder fbb = new FlatBuffers.FlatBufferBuilder(1);
FlatBuffers.Offset <MessageSelectTable.Data>[] data = new FlatBuffers.Offset <MessageSelectTable.Data> [lineList.Count];
int count = 0;
foreach (string line in lineList)
{
string[] values = line.Split(',');
int id = int.Parse(values[0]);
FlatBuffers.StringOffset[] selectList = new FlatBuffers.StringOffset[values.Length - 1];
for (int i = 1; i < values.Length; ++i)
{
string message = values[i].Replace("\\n", "\n");;
selectList[i - 1] = fbb.CreateString(message);
}
data[count] = MessageSelectTable.Data.CreateData(fbb, id, MessageSelectTable.Data.CreateSelectVector(fbb, selectList));
++count;
}
FlatBuffers.VectorOffset infoVec = MessageSelectTable.DataList.CreateDatasVector(fbb, data);
FlatBuffers.Offset <MessageSelectTable.DataList> reslut = MessageSelectTable.DataList.CreateDataList(fbb, infoVec);
MessageSelectTable.DataList.FinishDataListBuffer(fbb, reslut);
using (System.IO.FileStream fs = new System.IO.FileStream("message-select-table.bin", System.IO.FileMode.Create))
{
using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(fs))
{
bw.Write(fbb.SizedByteArray());
}
}
}
private void SetupFbs()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var elementOffsets = new Offset <flatbuffers.SampleModel1Element> [1000];
foreach (var i in Enumerable.Range(0, 1000))
{
elementOffsets[i] = flatbuffers.SampleModel1Element.CreateSampleModel1Element(
builder,
builder.CreateString(i.ToString()),
i,
(float)i,
(double)i
);
}
var elements = flatbuffers.SampleModel1Array.CreateElementsVector(builder, elementOffsets);
flatbuffers.SampleModel1Array.StartSampleModel1Array(builder);
{
flatbuffers.SampleModel1Array.AddElements(
builder,
elements
);
}
var orc = flatbuffers.SampleModel1Array.EndSampleModel1Array(builder);
builder.Finish(orc.Value);
this.ArrayModelFbsSerialized = builder.SizedByteArray();
}
void RunSerialize()
{
for (int i = 0; i < N; i++)
{
FlatBufferBuilder messageBuffer = new FlatBufferBuilder(100);
var text = messageBuffer.CreateString(@"Test message included");
int embeddedOffset = EmbeddedMessage.CreateEmbeddedMessage(messageBuffer, i);
TestMessage.StartTestMessage(messageBuffer);
TestMessage.AddText(messageBuffer, text.Value);
TestMessage.AddEmbedded(messageBuffer, embeddedOffset);
TestMessage.AddId(messageBuffer, i);
int testMessage = TestMessage.EndTestMessage(messageBuffer);
TestMessage.FinishTestMessageBuffer(messageBuffer, testMessage);
string s = "";
for (int j = 0; j < messageBuffer.DataBuffer.Data.Length; j++) s += messageBuffer.DataBuffer.Data[i].ToString() + ", ";
Debug.Log(s);
using (MemoryStream ms = new MemoryStream(messageBuffer.DataBuffer.Data,
0,
messageBuffer.DataBuffer.Data.Length))
{
ByteBuffer byteBuffer = new ByteBuffer(ms.ToArray());
TestMessage parsed = TestMessage.GetRootAsTestMessage(byteBuffer);
if (parsed.Embedded().Id() != i) throw new Exception("Invalid embedded value");
}
}
}
void relay_start_callback(object req, ApiClient api_client)
{
if (null != req)
{
RelayStart relay_start = (RelayStart)req;
relay_info = relay_start.response;
string[] address = relay_info.server_address.Split(':');
if (client != null)
{
if (true == client.IsConnected())
{
log("already connected server. server[" + address[0] + ":" + address[1] + "]");
return;
}
}
else
{
client = new wise.net.Client();
}
if (false == client.Connect(address[0], int.Parse(address[1])))
{
log("cannot connect server. server[" + address[0] + ":" + address[1] + "]");
return;
}
log("connect server. server[" + address[0] + ":" + address[1] + "]");
foreach (var member in relay_info.members)
{
if (member.id == user_index.ToString())
{
FlatBuffers.FlatBufferBuilder builder = new FlatBuffers.FlatBufferBuilder(1);
var offset = PACKET.ENTER.CreateENTER(builder, builder.CreateString(login_info.UserID), builder.CreateString(member.hash), user_index);
builder.Finish(offset.Value);
if (false == client.Send((int)PACKET_C2S.ENTER, builder.SizedByteArray(), uint.Parse(relay_info.roomnum.ToString())))
{
log("can't enter.");
}
return;
}
}
log("not find my information from relay/start.");
}
else
{
log("failed relay_start.");
}
}
public void Login()
{
var fbb = new FlatBufferBuilder(1024);
var oName = fbb.CreateString(this.name);
var oLogin = LoginRequest.CreateLoginRequest(fbb, oName);
LoginRequest.FinishLoginRequestBuffer(fbb, oLogin);
WriteBytes(FlatBufferExtensions.ToProtocolMessage(fbb, ClientMessageIds.LoginRequest));
Debug.Log("Login");
}
VectorOffset createCurrentQuests(FlatBufferBuilder fbb)
{
Entity[] entities = metaPool.GetGroup(Matcher.AllOf(MetaGameMatcher.Quest, MetaGameMatcher.QuestTaskAmount)).GetEntities();
int count = entities.Length;
Offset<CurrentQuest>[] quests = new Offset<CurrentQuest>[count];
for (int i = 0; i < count; i++) {
var e = entities[i];
StringOffset questName = fbb.CreateString(e.quest.id);
quests[i] = CurrentQuest.CreateCurrentQuest(fbb, questName, e.questTaskAmount.toComplete, e.questTaskAmount.done, e.isQuestDone);
}
return GameData.CreateCurrentQuestsVector(fbb, quests);
}
public void Union_Table_BasicTypes()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var basicTypesOffset = Oracle.BasicTypes.CreateBasicTypes(
builder,
Bool: true,
Byte: GetRandom <byte>(),
SByte: GetRandom <sbyte>(),
UShort: GetRandom <ushort>(),
Short: GetRandom <short>(),
UInt: GetRandom <uint>(),
Int: GetRandom <int>(),
ULong: GetRandom <ulong>(),
Long: GetRandom <long>(),
Float: GetRandom <float>(),
Double: GetRandom <double>(),
StringOffset: builder.CreateString("foobar"));
var offset = Oracle.UnionTable.CreateUnionTable(
builder,
Oracle.Union.BasicTypes,
basicTypesOffset.Value);
builder.Finish(offset.Value);
byte[] realBuffer = builder.DataBuffer.ToSizedArray();
var oracle = Oracle.UnionTable.GetRootAsUnionTable(new FlatBuffers.ByteBuffer(realBuffer)).Value <Oracle.BasicTypes>().Value;
var unionTable = FlatBufferSerializer.Default.Parse <UnionTable>(realBuffer);
Assert.Equal(1, unionTable.Union.Value.Discriminator);
BasicTypes parsed = unionTable.Union.Value.Item1;
Assert.NotNull(parsed);
Assert.True(parsed.Bool);
Assert.Equal(oracle.Byte, parsed.Byte);
Assert.Equal(oracle.SByte, parsed.SByte);
Assert.Equal(oracle.UShort, parsed.UShort);
Assert.Equal(oracle.Short, parsed.Short);
Assert.Equal(oracle.UInt, parsed.UInt);
Assert.Equal(oracle.Int, parsed.Int);
Assert.Equal(oracle.ULong, parsed.ULong);
Assert.Equal(oracle.Long, parsed.Long);
Assert.Equal(oracle.Float, parsed.Float);
Assert.Equal(oracle.Double, parsed.Double);
Assert.Equal("foobar", parsed.String);
}
VectorOffset createDefences(FlatBufferBuilder fbb)
{
Entity[] entities = corePool.GetGroup(CoreGameMatcher.Defence).GetEntities();
int count = entities.Length;
Offset<CityDefences>[] defences = new Offset<CityDefences>[count];
for (int i = 0; i < count; i++) {
var e = entities[i];
StringOffset type = fbb.CreateString(e.type.value);
Offset<TimeInterval> production = e.hasStartEndTime ? TimeInterval.CreateTimeInterval (fbb, e.startEndTime.start.GetMicrosecondsFromEpoch (), e.startEndTime.end.GetMicrosecondsFromEpoch ()) : default(Offset<TimeInterval>);
defences[i] = CityDefences.CreateCityDefences(fbb, type, (sbyte)e.level.value, e.isDefenceUpgrading, production);
}
return GameData.CreateDefencesVector(fbb, defences);
}
public void LinkedList()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var testData = Oracle.LinkedListNode.CreateLinkedListNode(
builder,
builder.CreateString("node 1"),
Oracle.LinkedListNode.CreateLinkedListNode(
builder,
builder.CreateString("node 2")));
builder.Finish(testData.Value);
byte[] realBuffer = builder.SizedByteArray();
var linkedList = FlatBufferSerializer.Default.Parse <TestLinkedListNode>(realBuffer);
Assert.NotNull(linkedList);
Assert.NotNull(linkedList.Next);
Assert.Null(linkedList.Next.Next);
Assert.Equal("node 1", linkedList.Value);
Assert.Equal("node 2", linkedList.Next.Value);
}
public static Offset <ComplexType> BuildComplexType(FlatBufferBuilder fbb)
{
StringOffset stringOffset = fbb.CreateString("Some random string");
ComplexType.StartIntVectorTypeVector(fbb, 5);
var intVectorOffset = BuildVector(fbb);
ComplexType.StartComplexType(fbb);
ComplexType.AddStringType(fbb, stringOffset);
ComplexType.AddIntVectorType(fbb, intVectorOffset);
ComplexType.AddEnumType(fbb, Color.Green);
ComplexType.AddStructType(fbb, Axis.CreateAxis(fbb, 1.1f, 2.1f, 3.1f));
return(ComplexType.EndComplexType(fbb));
}
public void SimpleTypes()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var fbOffset = Oracle.BasicTypes.CreateBasicTypes(
builder,
Bool: true,
Byte: GetRandom <byte>(),
SByte: GetRandom <sbyte>(),
UShort: GetRandom <ushort>(),
Short: GetRandom <short>(),
UInt: GetRandom <uint>(),
Int: GetRandom <int>(),
ULong: GetRandom <ulong>(),
Long: GetRandom <long>(),
Float: GetRandom <float>(),
Double: GetRandom <double>(),
StringOffset: builder.CreateString("foobar"));
builder.Finish(fbOffset.Value);
byte[] realBuffer = builder.DataBuffer.ToSizedArray();
var oracle = Oracle.BasicTypes.GetRootAsBasicTypes(new FlatBuffers.ByteBuffer(realBuffer));
var simple = FlatBufferSerializer.Default.Parse <BasicTypes>(realBuffer);
foreach (var parsed in new[] { simple })
{
Assert.True(parsed.Bool);
Assert.Equal(oracle.Byte, parsed.Byte);
Assert.Equal(oracle.SByte, parsed.SByte);
Assert.Equal(oracle.UShort, parsed.UShort);
Assert.Equal(oracle.Short, parsed.Short);
Assert.Equal(oracle.UInt, parsed.UInt);
Assert.Equal(oracle.Int, parsed.Int);
Assert.Equal(oracle.ULong, parsed.ULong);
Assert.Equal(oracle.Long, parsed.Long);
Assert.Equal(oracle.Float, parsed.Float);
Assert.Equal(oracle.Double, parsed.Double);
Assert.Equal("foobar", parsed.String);
}
// Ensures the caching works correctly.
//Assert.ReferenceEquals(cached.String, cached.String);
Assert.True(object.ReferenceEquals(simple.String, simple.String));
}
VectorOffset createBuildings(FlatBufferBuilder fbb)
{
Entity[] entities = corePool.GetGroup(CoreGameMatcher.Building).GetEntities();
int count = entities.Length;
Offset<Building>[] buildings = new Offset<Building>[count];
for (int i = 0; i < count; i++) {
var e = entities[i];
var production = Production (fbb, e);
StringOffset buildingType = fbb.CreateString (e.type.value);
Offset<Position> position = Position.CreatePosition(fbb, (short)e.position.x, (short)e.position.y);
VectorOffset storage = e.hasBuildingStorage ? TypeAmountVector(fbb, e.buildingStorage.items) : default(VectorOffset);;
buildings[i] = Building.CreateBuilding(fbb, buildingType, (sbyte)e.level.value, position, e.isProductionPaused, production, storage);
}
return GameData.CreateBuildingsVector(fbb, buildings);
}
VectorOffset createCompletedQuests(FlatBufferBuilder fbb)
{
if(!metaPool.hasQuestsCompleted){
return default(VectorOffset);
}
int count = metaPool.questsCompleted.ids.Count;
StringOffset[] questArray = new StringOffset[count];
int index = 0;
foreach (var quests in metaPool.questsCompleted.ids) {
questArray[index] = fbb.CreateString(quests);
index++;
}
return GameData.CreateCompletedQuestsVector(fbb, questArray);
}
void send_broadcast()
{
if (time != 0.0f)
{
log("elapsed time : " + time + " count : " + count);
}
FlatBuffers.FlatBufferBuilder builder = new FlatBuffers.FlatBufferBuilder(1);
var offset = PACKET.BROADCAST.CreateBROADCAST(builder, builder.CreateString(login_info.UserID), user_index, builder.CreateString(count.ToString()));
builder.Finish(offset.Value);
client.Send((int)PACKET_C2S.BROADCAST, builder.SizedByteArray(), uint.Parse(relay_info.roomnum.ToString()));
count++;
time = Time.deltaTime;
}
public void Union_String()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var stringOffset = builder.CreateString("foobar");
var offset = Oracle.UnionTable.CreateUnionTable(
builder,
Oracle.Union.stringValue,
stringOffset.Value);
builder.Finish(offset.Value);
byte[] realBuffer = builder.DataBuffer.ToSizedArray();
var unionTable = FlatBufferSerializer.Default.Parse <UnionTable>(realBuffer);
Assert.Equal(3, unionTable.Union.Value.Discriminator);
string parsed = unionTable.Union.Value.Item3;
Assert.Equal("foobar", parsed);
}
public void SortedVectors_NullKey_NotAllowed()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024 * 1024);
var strings = new List <string>();
var stringOffsets = new List <FlatBuffers.Offset <Oracle.SortedVectorStringTable> >();
foreach (string s in new[] { Guid.NewGuid().ToString(), null, Guid.NewGuid().ToString() })
{
strings.Add(s);
FlatBuffers.StringOffset strOffset = default;
if (s != null)
{
strOffset = builder.CreateString(s);
}
stringOffsets.Add(Oracle.SortedVectorStringTable.CreateSortedVectorStringTable(builder, strOffset));
}
Assert.Throws <InvalidOperationException>(
() => Oracle.SortedVectorStringTable.CreateSortedVectorOfSortedVectorStringTable(builder, stringOffsets.ToArray()));
}
private int SerializeReferenceType(object obj, TypeModel typeModel)
{
if (typeModel.IsString)
{
return(_builder.CreateString((string)obj).Value);
}
if (typeModel.IsVector)
{
return(SerializeVector(obj, typeModel));
}
if (typeModel.IsTable)
{
return(SerializeStruct(obj, typeModel));
}
if (typeModel.IsUnion)
{
return(SerializeUnion(obj, typeModel));
}
throw new NotSupportedException();
}
/// <summary>
/// Sends a chat message.
/// </summary>
/// <param name="message">Message.</param>
public static void sendChatMessage(string message)
{
FlatBufferBuilder fbb = new FlatBufferBuilder (1);
var mon = NetMessage.CreateNetMessage (fbb,
NetID.Chat,
Chat.CreateChat (fbb,
fbb.CreateString (userName),
fbb.CreateString (message)).Value);
NetMessage.FinishNetMessageBuffer (fbb, mon);
peer.Send (0, fbb.SizedByteArray (), PacketFlags.Reliable);
}
// Example how to use FlatBuffers to create and read binary buffers.
static void Main()
{
var builder = new FlatBufferBuilder(1);
// Create some weapons for our Monster ('Sword' and 'Axe').
var weapon1Name = builder.CreateString("Sword");
var weapon1Damage = 3;
var weapon2Name = builder.CreateString("Axe");
var weapon2Damage = 5;
// Use the `CreateWeapon()` helper function to create the weapons, since we set every field.
var weaps = new Offset<Weapon>[2];
weaps[0] = Weapon.CreateWeapon(builder, weapon1Name, (short)weapon1Damage);
weaps[1] = Weapon.CreateWeapon(builder, weapon2Name, (short)weapon2Damage);
// Serialize the FlatBuffer data.
var name = builder.CreateString("Orc");
var treasure = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
var inv = Monster.CreateInventoryVector(builder, treasure);
var weapons = Monster.CreateWeaponsVector(builder, weaps);
var pos = Vec3.CreateVec3(builder, 1.0f, 2.0f, 3.0f);
Monster.StartMonster(builder);
Monster.AddPos(builder, pos);
Monster.AddHp(builder, (short)300);
Monster.AddName(builder, name);
Monster.AddInventory(builder, inv);
Monster.AddColor(builder, Color.Red);
Monster.AddWeapons(builder, weapons);
Monster.AddEquippedType(builder, Equipment.Weapon);
Monster.AddEquipped(builder, weaps[1].Value);
var orc = Monster.EndMonster(builder);
builder.Finish(orc.Value); // You could also call `Monster.FinishMonsterBuffer(builder, orc);`.
// We now have a FlatBuffer that we could store on disk or send over a network.
// ...Code to store to disk or send over a network goes here...
// Instead, we are going to access it right away, as if we just received it.
var buf = builder.DataBuffer;
// Get access to the root:
var monster = Monster.GetRootAsMonster(buf);
// For C#, unlike other languages, most values (except for vectors and unions) are available as
// properties instead of accessor methods.
// Note: We did not set the `Mana` field explicitly, so we get back the default value.
Assert(monster.Mana == 150, "monster.Mana", Convert.ToString(monster.Mana),
Convert.ToString(150));
Assert(monster.Hp == 300, "monster.Hp", Convert.ToString(monster.Hp), Convert.ToString(30));
Assert(monster.Name.Equals("Orc", StringComparison.Ordinal), "monster.Name", monster.Name,
"Orc");
Assert(monster.Color == Color.Red, "monster.Color", Convert.ToString(monster.Color),
Convert.ToString(Color.Red));
// C# also allows you to use performance-enhanced methods to fill an object that has already
// been created. These functions are prefixed with "Get". For example: `monster.GetPos()`.
var myAlreadyCreatedVector = new Vec3();
monster.GetPos(myAlreadyCreatedVector); // Instead of `var myNewVec3 = monster.Pos`.
Assert(myAlreadyCreatedVector.X == 1.0f, "myAlreadyCreatedVector.X",
Convert.ToString(myAlreadyCreatedVector.X), Convert.ToString(1.0f));
Assert(myAlreadyCreatedVector.Y == 2.0f, "myAlreadyCreatedVector.Y",
Convert.ToString(myAlreadyCreatedVector.Y), Convert.ToString(2.0f));
Assert(myAlreadyCreatedVector.Z == 3.0f, "myAlreadyCreatedVector.Z",
Convert.ToString(myAlreadyCreatedVector.Z), Convert.ToString(3.0f));
// Get and test the `Inventory` FlatBuffer `vector`.
for (int i = 0; i < monster.InventoryLength; i++)
{
Assert(monster.GetInventory(i) == i, "monster.GetInventory",
Convert.ToString(monster.GetInventory(i)), Convert.ToString(i));
}
// Get and test the `Weapons` FlatBuffer `vector` of `table`s.
var expectedWeaponNames = new string[] {"Sword", "Axe"};
var expectedWeaponDamages = new short[] {3, 5};
for (int i = 0; i < monster.WeaponsLength; i++)
{
Assert(monster.GetWeapons(i).Name.Equals(expectedWeaponNames[i], StringComparison.Ordinal),
"monster.GetWeapons", monster.GetWeapons(i).Name, expectedWeaponNames[i]);
Assert(monster.GetWeapons(i).Damage == expectedWeaponDamages[i], "monster.GetWeapons",
Convert.ToString(monster.GetWeapons(i).Damage),
Convert.ToString(expectedWeaponDamages[i]));
}
// Get and test the `Equipped` FlatBuffer `union`.
Assert(monster.EquippedType == Equipment.Weapon, "monster.EquippedType",
Convert.ToString(monster.EquippedType), Convert.ToString(Equipment.Weapon));
var equipped = (Weapon)monster.GetEquipped(new Weapon());
Assert(equipped.Name.Equals("Axe", StringComparison.Ordinal), "equipped.Name", equipped.Name,
"Axe");
Assert(equipped.Damage == 5, "equipped.Damage", Convert.ToString(equipped.Damage),
Convert.ToString(5));
Console.WriteLine("The FlatBuffer was successfully created and verified!");
}
public void SortedVectors(FlatBufferDeserializationOption option)
{
var builder = new FlatBuffers.FlatBufferBuilder(1024 * 1024);
var strings = new List <string>();
var stringOffsets = new List <FlatBuffers.Offset <Oracle.SortedVectorStringTable> >();
List <int> ints = new List <int>();
var intOffsets = new List <FlatBuffers.Offset <Oracle.SortedVectorInt32Table> >();
List <double> doubles = new List <double>();
var doubleOffsets = new List <FlatBuffers.Offset <Oracle.SortedVectorDoubleTable> >();
const int Iterations = 1000;
Random random = new Random();
for (int i = 0; i < Iterations; ++i)
{
string value = Guid.NewGuid().ToString();
strings.Add(value);
stringOffsets.Add(Oracle.SortedVectorStringTable.CreateSortedVectorStringTable(builder, builder.CreateString(value)));
}
for (int i = 0; i < Iterations; ++i)
{
int value = random.Next();
ints.Add(value);
intOffsets.Add(Oracle.SortedVectorInt32Table.CreateSortedVectorInt32Table(builder, value));
}
for (int i = 0; i < Iterations; ++i)
{
double value = random.NextDouble() * random.Next();
doubles.Add(value);
doubleOffsets.Add(Oracle.SortedVectorDoubleTable.CreateSortedVectorDoubleTable(builder, value));
}
var table = Oracle.SortedVectorTest.CreateSortedVectorTest(
builder,
Oracle.SortedVectorInt32Table.CreateSortedVectorOfSortedVectorInt32Table(builder, intOffsets.ToArray()),
Oracle.SortedVectorStringTable.CreateSortedVectorOfSortedVectorStringTable(builder, stringOffsets.ToArray()),
Oracle.SortedVectorDoubleTable.CreateSortedVectorOfSortedVectorDoubleTable(builder, doubleOffsets.ToArray()));
builder.Finish(table.Value);
byte[] serialized = builder.SizedByteArray();
var serializer = new FlatBufferSerializer(option);
var parsed = serializer.Parse <SortedVectorTest <SortedVectorItem <int> > >(serialized);
VerifySorted(parsed.StringVector, new Utf8StringComparer(), strings, new List <string> {
Guid.NewGuid().ToString(), "banana"
});
VerifySorted(parsed.IntVector, Comparer <int> .Default, ints, new List <int> {
-1, -3, 0
});
VerifySorted(parsed.Double, Comparer <double> .Default, doubles, new List <double> {
Math.PI, Math.E, Math.Sqrt(2)
});
}
StringOffset createPlayerName(FlatBufferBuilder fbb)
{
return fbb.CreateString("Caterina Spadari");//fbb.CreateString(GameSetupBehaviour.credentials.credentials.name);
}
VectorOffset createShips(FlatBufferBuilder fbb)
{
Entity[] entities = corePool.GetGroup(CoreGameMatcher.Ship).GetEntities();
int count = entities.Length;
Offset<Ship>[] ships = new Offset<Ship>[count];
for (int i = 0; i < count; i++) {
var e = entities[i];
StringOffset typeStringOffset = fbb.CreateString(e.type.value);
VectorOffset cargo = e.hasShipCargo ? TypeAmountVector(fbb, e.shipCargo.items) : default(VectorOffset);
VectorOffset armyCargo = e.hasShipArmyCargo ? TypeAmountVector(fbb, e.shipArmyCargo.troops) : default(VectorOffset);
ships[i] = Ship.CreateShip(fbb, typeStringOffset, e.shipStatus.value, (sbyte)e.order.value, (sbyte)e.level.value, cargo, armyCargo);
}
return GameData.CreateShipsVector(fbb, ships);
}
VectorOffset createTechnologies(FlatBufferBuilder fbb)
{
if(!metaPool.hasTechnologies){
return default(VectorOffset);
}
int count = metaPool.technologies.values.Count;
StringOffset[] technologies = new StringOffset[count];
int index = 0;
foreach (var tech in metaPool.technologies.values) {
technologies[index] = fbb.CreateString(tech);
index++;
}
return GameData.CreateTechnologiesVector(fbb, technologies);
}
VectorOffset createIslands(FlatBufferBuilder fbb)
{
Entity[] entities = corePool.GetGroup(CoreGameMatcher.Island).GetEntities();
int count = entities.Length;
Offset<Island>[] islands = new Offset<Island>[count];
for (int i = 0; i < count; i++) {
var e = entities[i];
var defences = IslandDefences (fbb, e);
Offset<TimeInterval> production = Production(fbb, e);
islands[i] = Island.CreateIsland (fbb, fbb.CreateString (entities [i].islandID.value), fbb.CreateString (entities [i].islandOwner.value), (sbyte)e.level.value, production, defences);
}
return GameData.CreateIslandsVector(fbb, islands);
}
VectorOffset IslandDefences(FlatBufferBuilder fbb, Entity e)
{
VectorOffset defences = default(VectorOffset);
if (e.hasIslandDefence) {
int defencesCount = e.islandDefence.defences.Count;
Offset<Defence>[] defenceArray = new Offset<Defence>[defencesCount];
for (int j = 0; j < defencesCount; j++) {
var defenceType = fbb.CreateString (e.islandDefence.defences [j].type);
defenceArray [j] = Defence.CreateDefence (fbb, defenceType, (sbyte)e.islandDefence.defences [j].level, e.islandDefence.defences [j].hp);
}
defences = Island.CreateDefencesVector (fbb, defenceArray);
}
return defences;
}
VectorOffset TypeAmountVector(FlatBufferBuilder fbb, System.Collections.Generic.Dictionary<string, int> items)
{
if(items == null || items.Count == 0){
return default(VectorOffset);
}
int count = items.Count;
Offset<TypeAmount>[] resources = new Offset<TypeAmount>[count];
int index = 0;
foreach (var type in items.Keys) {
StringOffset typeStringOffset = fbb.CreateString(type);
resources[index] = TypeAmount.CreateTypeAmount(fbb,typeStringOffset, items[type]);
index++;
}
fbb.StartVector(4, resources.Length, 4);
for (int i = resources.Length - 1; i >= 0; i--) fbb.AddOffset(resources[i].Value);
return fbb.EndVector();
}
VectorOffset TypeLevelVector(FlatBufferBuilder fbb, System.Collections.Generic.Dictionary<string, int> items)
{
var quantities = metaPool.unitLevels.values;
int count = quantities.Count;
Offset<TypeLevel>[] resources = new Offset<TypeLevel>[count];
int index = 0;
foreach (var type in quantities.Keys) {
StringOffset typeStringOffset = fbb.CreateString(type);
resources[index] = TypeLevel.CreateTypeLevel(fbb,typeStringOffset, (sbyte)quantities[type]);
index++;
}
fbb.StartVector(4, resources.Length, 4);
for (int i = resources.Length - 1; i >= 0; i--) fbb.AddOffset(resources[i].Value);
return fbb.EndVector();
}
