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.AreEqual(parsed.Fake, "foobar");
Assert.AreEqual(parsed.Location.X, 0.1f);
Assert.AreEqual(parsed.Location.Y, 0.2f);
Assert.AreEqual(parsed.Location.Z, 0.3f);
Assert.AreEqual(parsed.LocationVector.Count, 3);
for (int i = 0; i < 3; ++i)
{
Assert.AreEqual((float)(3 * i + 1), parsed.LocationVector[i].X);
Assert.AreEqual((float)(3 * i + 2), parsed.LocationVector[i].Y);
Assert.AreEqual((float)(3 * i + 3), parsed.LocationVector[i].Z);
}
}
private void button_enter_Click(object sender, EventArgs e)
{
if (client == null)
{
log("not connected server. cannot enter");
return;
}
if (textBox_channel_no.TextLength <= 0)
{
log("can't enter. request channel no is empty.");
return;
}
if (textBox_nickname.TextLength <= 0)
{
log("can't enter. request textBox_nickname is empty.");
return;
}
FlatBuffers.FlatBufferBuilder builder = new FlatBuffers.FlatBufferBuilder(1);
var offset = PACKET.ENTER.CreateENTER(builder, builder.CreateString(textBox_nickname.Text), builder.CreateString(""), user_index);
builder.Finish(offset.Value);
if (false == client.Send((int)PACKET_C2S.ENTER, builder.SizedByteArray(), uint.Parse(textBox_channel_no.Text)))
{
log("can't enter. disconnected server.");
}
}
public void FiveByteStructVector()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
Oracle.FiveByteStructTable.StartVectorVector(builder, 3);
Oracle.FiveByteStruct.CreateFiveByteStruct(builder, 3, 3);
Oracle.FiveByteStruct.CreateFiveByteStruct(builder, 2, 2);
Oracle.FiveByteStruct.CreateFiveByteStruct(builder, 1, 1);
var vectorOffset = builder.EndVector();
Oracle.FiveByteStructTable.StartFiveByteStructTable(builder);
Oracle.FiveByteStructTable.AddVector(builder, vectorOffset);
var testData = Oracle.FiveByteStructTable.EndFiveByteStructTable(builder);
builder.Finish(testData.Value);
byte[] realBuffer = builder.SizedByteArray();
var parsed = FlatBufferSerializer.Default.Parse <FiveByteStructTable>(realBuffer);
Assert.AreEqual(3, parsed.Vector.Length);
Assert.AreEqual(1, parsed.Vector[0].Int);
Assert.AreEqual(2, parsed.Vector[1].Int);
Assert.AreEqual(3, parsed.Vector[2].Int);
Assert.AreEqual((byte)1, parsed.Vector[0].Byte);
Assert.AreEqual((byte)2, parsed.Vector[1].Byte);
Assert.AreEqual((byte)3, parsed.Vector[2].Byte);
}
public void Union_Struct_Location()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var locationOffset = Oracle.Location.CreateLocation(
builder,
1.0f,
2.0f,
3.0f);
var offset = Oracle.UnionTable.CreateUnionTable(
builder,
Oracle.Union.Location,
locationOffset.Value);
builder.Finish(offset.Value);
byte[] realBuffer = builder.DataBuffer.ToSizedArray();
var unionTable = FlatBufferSerializer.Default.Parse <UnionTable>(realBuffer);
Assert.AreEqual(2, unionTable.Union.Discriminator);
Location parsed = unionTable.Union.Item2;
Assert.IsNotNull(parsed);
Assert.AreEqual(1.0f, parsed.X);
Assert.AreEqual(2.0f, parsed.Y);
Assert.AreEqual(3.0f, parsed.Z);
}
public void NestedStructWithOddAlignment_Parse()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var offset = Oracle.AlignmentTestOuter.CreateAlignmentTestOuter(builder, 1, 2, 3, 4, 5, 6, 7, 8, 9);
Oracle.AlignmentTestOuterHoder.StartAlignmentTestOuterHoder(builder);
Oracle.AlignmentTestOuterHoder.AddValue(builder, offset);
var testData = Oracle.AlignmentTestOuterHoder.EndAlignmentTestOuterHoder(builder);
builder.Finish(testData.Value);
byte[] realBuffer = builder.SizedByteArray();
var parsed = FlatBufferSerializer.Default.Parse <AlignmentTestDataHolder>(realBuffer);
Assert.NotNull(parsed);
var outer = parsed.Value;
Assert.NotNull(outer);
Assert.Equal(1, outer.A);
Assert.Equal(2, outer.B);
Assert.Equal(3, outer.C);
Assert.Equal(4u, outer.D);
Assert.Equal(5, outer.E);
Assert.Equal(6ul, outer.F);
var inner = outer.Inner;
Assert.NotNull(inner);
Assert.Equal(7, inner.A);
Assert.Equal(8, inner.B);
Assert.Equal(9, inner.C);
}
public void SortedVectors()
{
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 parsed = FlatBufferSerializer.Default.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)
});
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, ImageTypeUnion _o)
{
switch (_o.Type)
{
default: return(0);
case ImageType.RawImage: return(hyperionnet.RawImage.Pack(builder, _o.AsRawImage()).Value);
}
}
private void button_ready_Click(object sender, EventArgs e)
{
FlatBuffers.FlatBufferBuilder builder = new FlatBuffers.FlatBufferBuilder(1);
if (false == client.Send((int)PACKET_C2S.READY, builder.SizedByteArray(), uint.Parse(textBox_joined_channel.Text)))
{
log("can't send. disconnected server.");
}
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, UnionInNestedNSUnion _o)
{
switch (_o.Type)
{
default: return(0);
case UnionInNestedNS.TableInNestedNS: return(NamespaceA.NamespaceB.TableInNestedNS.Pack(builder, _o.AsTableInNestedNS()).Value);
}
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, GadgetUnion _o)
{
switch (_o.Type)
{
default: return(0);
case Gadget.FallingTub: return(FallingTub.Pack(builder, _o.AsFallingTub()).Value);
case Gadget.HandFan: return(HandFan.Pack(builder, _o.AsHandFan()).Value);
}
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, KeywordsInUnionUnion _o)
{
switch (_o.Type)
{
default: return(0);
case KeywordsInUnion.static_: return(KeywordsInTable.Pack(builder, _o.Asstatic()).Value);
case KeywordsInUnion.internal_: return(KeywordsInTable.Pack(builder, _o.Asinternal()).Value);
}
}
private void button_spawn_Click(object sender, EventArgs e)
{
FlatBuffers.FlatBufferBuilder builder = new FlatBuffers.FlatBufferBuilder(1);
var offset = PACKET.REQ_SPAWN.CreateREQ_SPAWN(builder, 1); // 1은 MONSTER_ID
builder.Finish(offset.Value);
if (false == client.Send((int)PACKET_C2S.SPAWN, builder.SizedByteArray(), uint.Parse(textBox_joined_channel.Text)))
{
log("can't send. disconnected server.");
}
}
void relay_start_callback(JObject json)
{
if (null != json)
{
relay_info = json;
string[] address = relay_info["server_address"].ToString().Split(':');
if (client != null)
{
if (true == client.IsConnected())
{
log("already connected server. server[" + address[0] + ":" + address[1] + "]");
return;
}
}
else
{
client = new light.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] + "]");
JArray array = JArray.Parse(relay_info["members"].ToString());
foreach (var member in array)
{
if (member["id"].ToString() == user_index.ToString())
{
FlatBuffers.FlatBufferBuilder builder = new FlatBuffers.FlatBufferBuilder(1);
var offset = PACKET.REQ_JOIN.CreateREQ_JOIN(builder, builder.CreateString(login_info["UserID"].ToString()), builder.CreateString(member["hash"].ToString()), user_index);
builder.Finish(offset.Value);
if (false == client.Send((int)PACKET_C2S.JOIN, 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 static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUnion _o)
{
switch (_o.Type)
{
default: return(0);
case Any.Monster: return(MyGame.Example.Monster.Pack(builder, _o.AsMonster()).Value);
case Any.TestSimpleTableWithEnum: return(MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTestSimpleTableWithEnum()).Value);
case Any.MyGame_Example2_Monster: return(MyGame.Example2.Monster.Pack(builder, _o.AsMyGame_Example2_Monster()).Value);
}
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyAmbiguousAliasesUnion _o)
{
switch (_o.Type)
{
default: return(0);
case AnyAmbiguousAliases.M1: return(MyGame.Example.Monster.Pack(builder, _o.AsM1()).Value);
case AnyAmbiguousAliases.M2: return(MyGame.Example.Monster.Pack(builder, _o.AsM2()).Value);
case AnyAmbiguousAliases.M3: return(MyGame.Example.Monster.Pack(builder, _o.AsM3()).Value);
}
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUniqueAliasesUnion _o)
{
switch (_o.Type)
{
default: return(0);
case AnyUniqueAliases.M: return(MyGame.Example.Monster.Pack(builder, _o.AsM()).Value);
case AnyUniqueAliases.TS: return(MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTS()).Value);
case AnyUniqueAliases.M2: return(MyGame.Example2.Monster.Pack(builder, _o.AsM2()).Value);
}
}
public void Union_NotSet()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var offset = Oracle.UnionTable.CreateUnionTable(builder);
builder.Finish(offset.Value);
byte[] realBuffer = builder.DataBuffer.ToSizedArray();
var unionTable = FlatBufferSerializer.Default.Parse <UnionTable>(realBuffer);
Assert.IsNull(unionTable.Union);
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, UnionUnion _o)
{
switch (_o.Type)
{
default: return(0);
case Union.BasicTypes: return(FlatSharpTests.Oracle.BasicTypes.Pack(builder, _o.AsBasicTypes()).Value);
case Union.Location: return(FlatSharpTests.Oracle.Location.Pack(builder, _o.AsLocation()).Value);
case Union.stringValue: return(builder.CreateString(_o.AsstringValue()).Value);
}
}
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);
var simpleUnsafe = FlatBufferSerializer.Default.Parse <BasicTypes>(new UnsafeMemoryInputBuffer(realBuffer));
var simpleUnsafeArray = FlatBufferSerializer.Default.Parse <BasicTypes>(new UnsafeArrayInputBuffer(realBuffer));
foreach (var parsed in new[] { simple, simpleUnsafe, simpleUnsafeArray })
{
Assert.IsTrue(parsed.Bool);
Assert.AreEqual(oracle.Byte, parsed.Byte);
Assert.AreEqual(oracle.SByte, parsed.SByte);
Assert.AreEqual(oracle.UShort, parsed.UShort);
Assert.AreEqual(oracle.Short, parsed.Short);
Assert.AreEqual(oracle.UInt, parsed.UInt);
Assert.AreEqual(oracle.Int, parsed.Int);
Assert.AreEqual(oracle.ULong, parsed.ULong);
Assert.AreEqual(oracle.Long, parsed.Long);
Assert.AreEqual(oracle.Float, parsed.Float);
Assert.AreEqual(oracle.Double, parsed.Double);
Assert.AreEqual("foobar", parsed.String);
}
// Ensures the caching works correctly.
//Assert.ReferenceEquals(cached.String, cached.String);
Assert.IsTrue(object.ReferenceEquals(simple.String, simple.String));
}
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.AreEqual(1, unionTable.Union.Discriminator);
BasicTypes parsed = unionTable.Union.Item1;
Assert.IsNotNull(parsed);
Assert.IsTrue(parsed.Bool);
Assert.AreEqual(oracle.Byte, parsed.Byte);
Assert.AreEqual(oracle.SByte, parsed.SByte);
Assert.AreEqual(oracle.UShort, parsed.UShort);
Assert.AreEqual(oracle.Short, parsed.Short);
Assert.AreEqual(oracle.UInt, parsed.UInt);
Assert.AreEqual(oracle.Int, parsed.Int);
Assert.AreEqual(oracle.ULong, parsed.ULong);
Assert.AreEqual(oracle.Long, parsed.Long);
Assert.AreEqual(oracle.Float, parsed.Float);
Assert.AreEqual(oracle.Double, parsed.Double);
Assert.AreEqual("foobar", parsed.String);
}
static StackObject *EndVector_7(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
FlatBuffers.FlatBufferBuilder instance_of_this_method = (FlatBuffers.FlatBufferBuilder) typeof(FlatBuffers.FlatBufferBuilder).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.EndVector();
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, NInputExtraUnion _o)
{
switch (_o.Type)
{
default: return(0);
case NInputExtra.Button: return(NymaTypes.NButtonInfo.Pack(builder, _o.AsButton()).Value);
case NInputExtra.Axis: return(NymaTypes.NAxisInfo.Pack(builder, _o.AsAxis()).Value);
case NInputExtra.Switch: return(NymaTypes.NSwitchInfo.Pack(builder, _o.AsSwitch()).Value);
case NInputExtra.Status: return(NymaTypes.NStatusInfo.Pack(builder, _o.AsStatus()).Value);
}
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, CommandUnion _o)
{
switch (_o.Type)
{
default: return(0);
case Command.Color: return(hyperionnet.Color.Pack(builder, _o.AsColor()).Value);
case Command.Image: return(hyperionnet.Image.Pack(builder, _o.AsImage()).Value);
case Command.Clear: return(hyperionnet.Clear.Pack(builder, _o.AsClear()).Value);
case Command.Register: return(hyperionnet.Register.Pack(builder, _o.AsRegister()).Value);
}
}
static StackObject *StartObject_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Int32 @numfields = ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
FlatBuffers.FlatBufferBuilder instance_of_this_method = (FlatBuffers.FlatBufferBuilder) typeof(FlatBuffers.FlatBufferBuilder).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
instance_of_this_method.StartObject(@numfields);
return(__ret);
}
public static int Pack(FlatBuffers.FlatBufferBuilder builder, CharacterUnion _o)
{
switch (_o.Type)
{
default: return(0);
case Character.MuLan: return(Attacker.Pack(builder, _o.AsMuLan()).Value);
case Character.Rapunzel: return(Rapunzel.Pack(builder, _o.AsRapunzel()).Value);
case Character.Belle: return(BookReader.Pack(builder, _o.AsBelle()).Value);
case Character.BookFan: return(BookReader.Pack(builder, _o.AsBookFan()).Value);
case Character.Other: return(builder.CreateString(_o.AsOther()).Value);
case Character.Unused: return(builder.CreateString(_o.AsUnused()).Value);
}
}
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.AreEqual(3, unionTable.Union.Discriminator);
string parsed = unionTable.Union.Item3;
Assert.AreEqual("foobar", parsed);
}
public static void GetCurrentEventTable(SaveBlockAccessor8SWSH blocks, RaidTables rt)
{
var archive = blocks.GetBlock(NORMAL_ENCOUNTER).Data;
if (archive.Length < 0x20 || archive.Length != 4 + BitConverter.ToInt32(archive, 0x10) || BitConverter.ToInt32(archive, 0x8) != 0x20)
{
return; // no event loaded
}
var encount_data = new byte[archive.Length - 0x24];
Array.Copy(archive, 0x20, encount_data, 0, encount_data.Length);
var fbb = new FlatBuffers.FlatBufferBuilder(new FlatBuffers.ByteBuffer(encount_data));
var dist_encounts = PKHeX_Raid_Plugin.NestHoleDistributionEncounter8Archive.GetRootAsNestHoleDistributionEncounter8Archive(fbb.DataBuffer);
var sword_table = dist_encounts.Tables(0).Value;
var shield_table = dist_encounts.Tables(1).Value;
if (sword_table.GameVersion != 1)
{
sword_table = dist_encounts.Tables(1).Value;
shield_table = dist_encounts.Tables(0).Value;
}
var swordTable = new RaidTemplateTable(1721953670860364124, 1, new RaidTemplate[sword_table.EntriesLength]);
var shieldTable = new RaidTemplateTable(1721953670860364124, 2, new RaidTemplate[sword_table.EntriesLength]);
for (int i = 0; i < sword_table.EntriesLength; i++)
{
var entry1 = sword_table.Entries(i).Value;
swordTable.Entries[i] = new RaidTemplate(entry1.Species, entry1.GetProbabilitiesArray(), entry1.FlawlessIVs, entry1.AltForm, entry1.Ability, entry1.Gender, entry1.Nature, entry1.IsGigantamax, entry1.ShinyForced);
entry1 = shield_table.Entries(i).Value;
shieldTable.Entries[i] = new RaidTemplate(entry1.Species, entry1.GetProbabilitiesArray(), entry1.FlawlessIVs, entry1.AltForm, entry1.Ability, entry1.Gender, entry1.Nature, entry1.IsGigantamax, entry1.ShinyForced);
}
if (sword_table.EntriesLength > 0)
{
rt.SwordNestsEvent[0] = swordTable;
rt.ShieldNestsEvent[0] = shieldTable;
}
}
public void ScalarVectors()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var testData = Oracle.Vectors.CreateVectors(
builder,
Oracle.Vectors.CreateIntVectorVector(builder, new[] { 1, 2, 3, 4, 5, 6, }),
Oracle.Vectors.CreateLongVectorVector(builder, new[] { 7L, 8, 9, 10, 11, 12, }),
Oracle.Vectors.CreateByteVector1Vector(builder, new byte[] { 1, 2, 3, 4, 5 }),
Oracle.Vectors.CreateByteVector2Vector(builder, new byte[] { 1, 2, 3, 4, 5 }));
builder.Finish(testData.Value);
byte[] realBuffer = builder.SizedByteArray();
var parsed = FlatBufferSerializer.Default.Parse <ScalarVectorsTable>(realBuffer);
IList <int> intItems = parsed.IntVector;
Assert.AreEqual(6, intItems.Count);
for (int i = 0; i < 6; ++i)
{
Assert.AreEqual(1 + i, intItems[i]);
}
IList <long> longItems = parsed.LongVector;
Assert.AreEqual(6, longItems.Count);
for (int i = 0; i < 6; ++i)
{
Assert.AreEqual(7 + i, longItems[i]);
}
Memory <byte> mem = parsed.ByteVector2;
Assert.AreEqual(5, mem.Length);
for (int i = 1; i <= 5; ++i)
{
Assert.AreEqual(i, mem.Span[i - 1]);
}
Assert.IsTrue(parsed.ByteVector3.IsEmpty);
}
public void NestedStruct()
{
var builder = new FlatBuffers.FlatBufferBuilder(1024);
var outerOffset = Oracle.OuterStruct.CreateOuterStruct(builder, 401, 100);
Oracle.NestedStructs.StartNestedStructs(builder);
Oracle.NestedStructs.AddOuter(builder, outerOffset);
var offset = Oracle.NestedStructs.EndNestedStructs(builder);
builder.Finish(offset.Value);
byte[] realBuffer = builder.DataBuffer.ToSizedArray();
var parsed = FlatBufferSerializer.Default.Parse <NestedStructs>(realBuffer);
Assert.IsNotNull(parsed?.OuterStruct?.InnerStruct);
Assert.AreEqual(401, parsed.OuterStruct.InnerStruct.A);
Assert.AreEqual(100, parsed.OuterStruct.A);
}
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.ThrowsException <InvalidOperationException>(
() => Oracle.SortedVectorStringTable.CreateSortedVectorOfSortedVectorStringTable(builder, stringOffsets.ToArray()));
}
