/// <summary> /// Create VectorOffset from List /// </summary> /// <typeparam name="T">IFBSerializable</typeparam> /// <typeparam name="S">FlatbufferType</typeparam> /// <param name="builder"></param> /// <param name="list"></param> /// <param name="fbCreateList"></param> /// <returns></returns> public static FlatBuffers.VectorOffset?CreateList <T, S>(FlatBuffers.FlatBufferBuilder builder , List <T> list, Func <FlatBufferBuilder, Offset <S>[], VectorOffset> fbCreateList) where S : struct, FlatBuffers.IFlatbufferObject where T : IFBSerializable { if (list == null) { return(null); } if (FlatbufferSerializer.obj2FSMapping.TryGetValue(list, out int bufPos)) { // the list was already serialized so we need to use this VectorOffset in order to keep the reference var result = new FlatBuffers.VectorOffset(bufPos); return(result); } else { if (typeof(IFBSerializable).IsAssignableFrom(typeof(T))) { var tempArray = new FlatBuffers.Offset <S> [list.Count]; for (int i = 0; i < list.Count; i++) { var listElemOffset = FlatbufferSerializer.GetOrCreateSerialize(builder, (IFBSerializable)list[i]); if (listElemOffset != null) { tempArray[i] = new FlatBuffers.Offset <S>((int)listElemOffset); } } var result = fbCreateList(builder, tempArray); FlatbufferSerializer.obj2FSMapping[list] = result.Value; return(result); } return(null); } }
public static int CreateGetModuleResponse(FlatBufferBuilder builder, int module = 0) { builder.StartObject(1); GetModuleResponse.AddModule(builder, module); return GetModuleResponse.EndGetModuleResponse(builder); }
public static int CreateTest(FlatBufferBuilder builder, short A, sbyte B) { builder.Prep(2, 4); builder.Pad(1); builder.PutSbyte(B); builder.PutShort(A); return builder.Offset(); }
public static int CreateEmbeddedMessage(FlatBufferBuilder builder, int id = 0) { builder.StartObject(1); EmbeddedMessage.AddId(builder, id); return EmbeddedMessage.EndEmbeddedMessage(builder); }
public static int CreateGetModuleRequest(FlatBufferBuilder builder, uint module_id = 0) { builder.StartObject(1); GetModuleRequest.AddModuleId(builder, module_id); return GetModuleRequest.EndGetModuleRequest(builder); }
public static int CreateListThreadsResponse(FlatBufferBuilder builder, int thread = 0) { builder.StartObject(1); ListThreadsResponse.AddThread(builder, thread); return ListThreadsResponse.EndListThreadsResponse(builder); }
public static Offset<Test> CreateTest(FlatBufferBuilder builder, short A, sbyte B) { builder.Prep(2, 4); builder.Pad(1); builder.PutSbyte(B); builder.PutShort(A); return new Offset<Test>(builder.Offset); }
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"); } } }
public static int CreateListModuleEntry(FlatBufferBuilder builder, uint Handle, uint FunctionCount) { builder.Prep(4, 8); builder.PutUint(FunctionCount); builder.PutUint(Handle); return builder.Offset; }
public static Offset<LoginResponse> CreateLoginResponse(FlatBufferBuilder builder, int objectId = 0) { builder.StartObject(1); LoginResponse.AddObjectId(builder, objectId); return LoginResponse.EndLoginResponse(builder); }
public void ConvertMessageAnswer(string path) { List <string> lineList = this.getLineList(path); FlatBuffers.FlatBufferBuilder fbb = new FlatBuffers.FlatBufferBuilder(1); FlatBuffers.Offset <MessageAnswerTable.Data>[] data = new FlatBuffers.Offset <MessageAnswerTable.Data> [lineList.Count]; int count = 0; foreach (string line in lineList) { string[] values = line.Split(','); int id = int.Parse(values[0]); int selectId = int.Parse(values[1]); int[] answerList = new int[values.Length - 1]; for (int i = 2; i < values.Length; ++i) { string message = values[i].Replace("\\n", "\n");; answerList[i - 2] = int.Parse(values[i]); } data[count] = MessageAnswerTable.Data.CreateData(fbb, id, selectId, MessageAnswerTable.Data.CreateAnswerVector(fbb, answerList)); ++count; } FlatBuffers.VectorOffset infoVec = MessageAnswerTable.DataList.CreateDatasVector(fbb, data); FlatBuffers.Offset <MessageAnswerTable.DataList> reslut = MessageAnswerTable.DataList.CreateDataList(fbb, infoVec); MessageAnswerTable.DataList.FinishDataListBuffer(fbb, reslut); using (System.IO.FileStream fs = new System.IO.FileStream("message-answer-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(); }
public static Offset<StructInNestedNS> CreateStructInNestedNS(FlatBufferBuilder builder, int A, int B) { builder.Prep(4, 8); builder.PutInt(B); builder.PutInt(A); return new Offset<StructInNestedNS>(builder.Offset); }
public static int CreateGetFunctionResponse(FlatBufferBuilder builder, int function = 0) { builder.StartObject(1); GetFunctionResponse.AddFunction(builder, function); return GetFunctionResponse.EndGetFunctionResponse(builder); }
public static Offset<animation> Createanimation(FlatBufferBuilder builder, VectorOffset clips = default(VectorOffset)) { builder.StartObject(1); animation.AddClips(builder, clips); return animation.Endanimation(builder); }
public static int CreateListModulesResponse(FlatBufferBuilder builder, int entry = 0) { builder.StartObject(1); ListModulesResponse.AddEntry(builder, entry); return ListModulesResponse.EndListModulesResponse(builder); }
public static int CreateAddBreakpointsRequest(FlatBufferBuilder builder, int breakpoints = 0) { builder.StartObject(1); AddBreakpointsRequest.AddBreakpoints(builder, breakpoints); return AddBreakpointsRequest.EndAddBreakpointsRequest(builder); }
public static Offset<LoginRequest> CreateLoginRequest(FlatBufferBuilder builder, StringOffset name = default(StringOffset)) { builder.StartObject(1); LoginRequest.AddName(builder, name); return LoginRequest.EndLoginRequest(builder); }
public static Offset<anchorPointsHolder> CreateanchorPointsHolder(FlatBufferBuilder builder, VectorOffset anchorPoints = default(VectorOffset)) { builder.StartObject(1); anchorPointsHolder.AddAnchorPoints(builder, anchorPoints); return anchorPointsHolder.EndanchorPointsHolder(builder); }
public static Offset<VariableParameters> CreateVariableParameters(FlatBufferBuilder builder, VariableType type = (VariableType)0) { builder.StartObject(1); VariableParameters.AddType(builder, type); return VariableParameters.EndVariableParameters(builder); }
public static Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(FlatBufferBuilder builder, Color color = Color.Green) { builder.StartObject(1); TestSimpleTableWithEnum.AddColor(builder, color); return TestSimpleTableWithEnum.EndTestSimpleTableWithEnum(builder); }
public static Offset<SensorData> CreateSensorData(FlatBufferBuilder builder, int TouchSenser = 0, int ReflectionSensor = 0, int SonerSensor = 0, int GyroSensor = 0, int A_Power = 0, int B_Power = 0, int B_Odometer = 0, int C_Power = 0, int C_Odometer = 0, int Battery = 0, int TaskProcessTime = 0) { builder.StartObject(11); SensorData.AddTaskProcessTime(builder, TaskProcessTime); SensorData.AddBattery(builder, Battery); SensorData.AddCOdometer(builder, C_Odometer); SensorData.AddCPower(builder, C_Power); SensorData.AddBOdometer(builder, B_Odometer); SensorData.AddBPower(builder, B_Power); SensorData.AddAPower(builder, A_Power); SensorData.AddGyroSensor(builder, GyroSensor); SensorData.AddSonerSensor(builder, SonerSensor); SensorData.AddReflectionSensor(builder, ReflectionSensor); SensorData.AddTouchSenser(builder, TouchSenser); return SensorData.EndSensorData(builder); }
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); } }
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.Equal(3, parsed.Vector.Length); Assert.Equal(1, parsed.Vector[0].Int); Assert.Equal(2, parsed.Vector[1].Int); Assert.Equal(3, parsed.Vector[2].Int); Assert.Equal((byte)1, parsed.Vector[0].Byte); Assert.Equal((byte)2, parsed.Vector[1].Byte); Assert.Equal((byte)3, parsed.Vector[2].Byte); }
public static Offset<uvSwapItemHolder> CreateuvSwapItemHolder(FlatBufferBuilder builder, VectorOffset meshes = default(VectorOffset)) { builder.StartObject(1); uvSwapItemHolder.AddMeshes(builder, meshes); return uvSwapItemHolder.EnduvSwapItemHolder(builder); }
public void ConvertTekiInfo(string path) { List <string> lineList = this.getLineList(path); FlatBuffers.FlatBufferBuilder fbb = new FlatBuffers.FlatBufferBuilder(1); FlatBuffers.Offset <TekiInfoTable.Data>[] data = new FlatBuffers.Offset <TekiInfoTable.Data> [lineList.Count]; int count = 0; foreach (string line in lineList) { string[] values = line.Split(','); int id = int.Parse(values[0]); TekiDefine.MoveType moveType = (TekiDefine.MoveType)Enum.Parse(typeof(TekiDefine.MoveType), values[1]); int messageEventId = int.Parse(values[2]); data[count] = TekiInfoTable.Data.CreateData(fbb, id, moveType, messageEventId); ++count; } FlatBuffers.VectorOffset infoVec = TekiInfoTable.DataList.CreateDatasVector(fbb, data); FlatBuffers.Offset <TekiInfoTable.DataList> reslut = TekiInfoTable.DataList.CreateDataList(fbb, infoVec); TekiInfoTable.DataList.FinishDataListBuffer(fbb, reslut); using (System.IO.FileStream fs = new System.IO.FileStream("teki-info-table.bin", System.IO.FileMode.Create)) { using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(fs)) { bw.Write(fbb.SizedByteArray()); } } }
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 static Offset<Area> CreateArea(FlatBufferBuilder builder, float Largura, float Comprimento) { builder.Prep(4, 8); builder.PutFloat(Comprimento); builder.PutFloat(Largura); return new Offset<Area>(builder.Offset); }
/*block:serialization*/ #region serialization public override int Serialize(FlatBuffers.FlatBufferBuilder builder) { /*block:inheritanceSer*/ var baseData = base.Serialize(builder); /*endblock:inheritanceSer*/ /*block:s_enum*/ var /*name|fu,pre#s:name*/ sState /*endname*/ = (byte)/*name:name*/ state /*endname*/; /*endblock:s_enum*/ /*block:s_string*/ var /*name|fu,pre#s:name*/ sTestName /*endname*/ = (StringOffset)FlatbufferSerializer.GetOrCreateSerialize(builder, /*name:name*/ testName /*endname*/); /*endblock:s_string*/ /*block:s_nonprim*/ var /*name|fu,pre#s:name*/ sTestUID /*endname*/ = new Offset <Serial./*name|pre#FB:type*/ FBUID /*endname*/>((int)FlatbufferSerializer.GetOrCreateSerialize(builder, /*name:name*/ testUID /*endname*/)); /*endblock:s_nonprim*/ /*block:s_list_primitive*/ var /*name|fu,pre#s:name*/ sTestListPrimitive /*endname*/ = FlatbufferSerializer.CreateList </*name:innertype*/ int /*endname*/>(builder, /*name:name*/ testListPrimitive /*endname*/, Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|fu,pre#Create,post#Vector:name*/ CreateTestListPrimitiveVector /*endname*/); /*endblock:s_list_primitive*/ /*block:s_list_nonprim*/ var /*name|fu,pre#s:name*/ sTestListUID /*endname*/ = FlatbufferSerializer.CreateList </*name:innertype*/ UID /*endname*/, Serial./*name|pre#FB:innertype*/ FBUID /*endname*/>(builder, /*name:name*/ testListUID /*endname*/, Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|fu,pre#Create,post#Vector:name*/ CreateTestListUIDVector /*endname*/); /*endblock:s_list_nonprim*/ Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|pre#StartFB:ComponentName*/ StartFBGenTemplateComponent/*endname*/ (builder); /*block:s2_default*/ Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|fu,pre#Add:name*/ AddState/*endname*/ (builder, /*name|fu,pre#s:name*/ sState /*endname*/); /*endblock:s2_default*/ /*block:s2_primitive*/ Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|fu,pre#Add:name*/ AddState/*endname*/ (builder, /*name:name*/ sState /*endname*/); /*endblock:s2_primitive*/ /*block:s2_list*/ if (/*name:name*/ testListPrimitive /*endname*/ != null) { Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|fu,pre#Add:name*/ AddTestListPrimitive/*endname*/ (builder, (VectorOffset)/*name|fu,pre#s:name*/ sTestListPrimitive /*endname*/); } /*endblock:s2_list*/ /*block:inheritanceSer2*/ Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/.AddBaseData(builder, new Offset <Serial./*name:basetype*/ FBComponent /*endname*/>(baseData)); /*endblock:inheritanceSer2*/ return(Serial./*name|pre#FB:ComponentName*/ FBGenTemplateComponent /*endname*/./*name|pre#EndFB:ComponentName*/ EndFBGenTemplateComponent/*endname*/ (builder).Value); }
public static Offset<TableInNestedNS> CreateTableInNestedNS(FlatBufferBuilder builder, int foo = 0) { builder.StartObject(1); TableInNestedNS.AddFoo(builder, foo); return TableInNestedNS.EndTableInNestedNS(builder); }
public static Offset<InputCommand> CreateInputCommand(FlatBufferBuilder builder, Offset<CommandFrame> frame = default(Offset<CommandFrame>)) { builder.StartObject(1); InputCommand.AddFrame(builder, frame); return InputCommand.EndInputCommand(builder); }
public static Offset<animationMeshList> CreateanimationMeshList(FlatBufferBuilder builder, VectorOffset timeSamples = default(VectorOffset)) { builder.StartObject(1); animationMeshList.AddTimeSamples(builder, timeSamples); return animationMeshList.EndanimationMeshList(builder); }
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.Equal(2, unionTable.Union.Value.Discriminator); Location parsed = unionTable.Union.Value.Item2; Assert.NotNull(parsed); Assert.Equal(1.0f, parsed.X); Assert.Equal(2.0f, parsed.Y); Assert.Equal(3.0f, parsed.Z); }
public static Offset<SyncFrame> CreateSyncFrame(FlatBufferBuilder builder, VectorOffset frames = default(VectorOffset)) { builder.StartObject(1); SyncFrame.AddFrames(builder, frames); return SyncFrame.EndSyncFrame(builder); }
public static Offset<SecondTableInA> CreateSecondTableInA(FlatBufferBuilder builder, Offset<NamespaceC.TableInC> refer_to_cOffset = default(Offset<NamespaceC.TableInC>)) { builder.StartObject(1); SecondTableInA.AddReferToC(builder, refer_to_cOffset); return SecondTableInA.EndSecondTableInA(builder); }
public void ConvertMessageEvent(string path) { List <string> lineList = this.getLineList(path); FlatBuffers.FlatBufferBuilder fbb = new FlatBuffers.FlatBufferBuilder(1); FlatBuffers.Offset <MessageEventTable.Data>[] data = new FlatBuffers.Offset <MessageEventTable.Data> [lineList.Count]; int count = 0; foreach (string line in lineList) { string[] values = line.Split(','); int id = int.Parse(values[0]); int checkId = int.Parse(values[1]); int messageId = int.Parse(values[2]); int selectId = int.Parse(values[3]); int flag = int.Parse(values[4]); int addTime = int.Parse(values[5]); data[count] = MessageEventTable.Data.CreateData(fbb, id, checkId, messageId, selectId, flag, addTime); ++count; } FlatBuffers.VectorOffset infoVec = MessageEventTable.DataList.CreateDatasVector(fbb, data); FlatBuffers.Offset <MessageEventTable.DataList> reslut = MessageEventTable.DataList.CreateDataList(fbb, infoVec); MessageEventTable.DataList.FinishDataListBuffer(fbb, reslut); using (System.IO.FileStream fs = new System.IO.FileStream("message-event-table.bin", System.IO.FileMode.Create)) { using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(fs)) { bw.Write(fbb.SizedByteArray()); } } }
public static Offset<skeleton> Createskeleton(FlatBufferBuilder builder, VectorOffset bones = default(VectorOffset)) { builder.StartObject(1); skeleton.AddBones(builder, bones); return skeleton.Endskeleton(builder); }
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) }); }
public static Offset<NamespaceC.TableInC> CreateTableInC(FlatBufferBuilder builder, Offset<NamespaceA.TableInFirstNS> refer_to_a1Offset = default(Offset<NamespaceA.TableInFirstNS>), Offset<SecondTableInA> refer_to_a2Offset = default(Offset<SecondTableInA>)) { builder.StartObject(2); TableInC.AddReferToA2(builder, refer_to_a2Offset); TableInC.AddReferToA1(builder, refer_to_a1Offset); return TableInC.EndTableInC(builder); }
public byte[] GenerateGameState() { FlatBufferBuilder fbb = default(FlatBufferBuilder); fbb = new FlatBufferBuilder (1); MakeGameState (fbb); return new MemoryStream(fbb.DataBuffer.Data, fbb.DataBuffer.Position, fbb.Offset).ToArray(); }
public static int CreateStat(FlatBufferBuilder builder, int id = 0, long val = 0) { builder.StartObject(2); Stat.AddVal(builder, val); Stat.AddId(builder, id); return Stat.EndStat(builder); }
static FlatBuffersObject.PersonVector SerializeArrayFlatBuffers() { Console.WriteLine("FlatBuffers"); FlatBuffersObject.PersonVector copy = default(FlatBuffersObject.PersonVector); byte[] bytes = null; Func <FlatBuffers.FlatBufferBuilder, FlatBuffers.Offset <FlatBuffersObject.Person>[]> makeVector = b => { var array = new FlatBuffers.Offset <FlatBuffersObject.Person> [1000]; var count = 0; for (int j = 1000; j < 2000; j++) { var person = FlatBuffersObject.Person.CreatePerson(b, j, b.CreateString("Windows"), b.CreateString("Server"), FlatBuffersObject.Sex.Female); array[count++] = person; } return(array); }; using (new Measure("Serialize")) { for (int i = 0; i < Iteration; i++) { var builder = new FlatBuffers.FlatBufferBuilder(1); var personVector = FlatBuffersObject.PersonVector.CreatePersonVector(builder, FlatBuffersObject.PersonVector.CreateListVector(builder, makeVector(builder))); builder.Finish(personVector.Value); bytes = builder.SizedByteArray(); } } using (new Measure("Deserialize")) { for (int i = 0; i < Iteration; i++) { copy = FlatBuffersObject.PersonVector.GetRootAsPersonVector(new FlatBuffers.ByteBuffer(bytes)); } } using (new Measure("ReSerialize")) { for (int i = 0; i < Iteration; i++) { var bb = copy.ByteBuffer; var newbytes = new byte[bb.Length]; Buffer.BlockCopy(bb.Data, 0, newbytes, 0, bb.Length); } } if (!dryRun) { Console.WriteLine(string.Format("{0,15} {1}", "Binary Size", ToHumanReadableSize(bytes.Length))); } return(copy); }
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 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.Null(unionTable.Union); }
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); }
private void SendDisconnectMessage() { var builder = new FlatBuffers.FlatBufferBuilder(1024); NetworkedPhysics.Message.StartMessage(builder); NetworkedPhysics.Message.AddDataType(builder, NetworkedPhysics.MessageType.ClientDisconnectMessage); var message = NetworkedPhysics.Message.EndMessage(builder); builder.Finish(message.Value); byte[] bytes = builder.SizedByteArray(); _udpClient.Send(bytes, bytes.Length); Debug.Log("Sent Disconnect message " + bytes.Length); }
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)); }
public void VectorOfUnion() { Oracle.VectorOfUnionTableT table = new Oracle.VectorOfUnionTableT { Value = new List <Oracle.UnionUnion> { new Oracle.UnionUnion { Value = new Oracle.BasicTypesT { Int = 7 }, Type = Oracle.Union.BasicTypes }, new Oracle.UnionUnion { Value = new Oracle.LocationT { X = 1, Y = 2, Z = 3 }, Type = Oracle.Union.Location }, new Oracle.UnionUnion { Value = "foobar", Type = Oracle.Union.stringValue }, } }; var builder = new FlatBuffers.FlatBufferBuilder(1024); var offset = Oracle.VectorOfUnionTable.Pack(builder, table); builder.Finish(offset.Value); byte[] data = builder.SizedByteArray(); var parsed = FlatBufferSerializer.Default.Parse <ArrayVectorOfUnionTable>(data); Assert.Equal(3, parsed.Union.Length); Assert.Equal(1, parsed.Union[0].Discriminator); Assert.Equal(2, parsed.Union[1].Discriminator); Assert.Equal(3, parsed.Union[2].Discriminator); Assert.True(parsed.Union[0].TryGet(out BasicTypes basicTypes)); Assert.Equal(7, basicTypes.Int); Assert.True(parsed.Union[1].TryGet(out Location location)); Assert.Equal(1, location.X); Assert.Equal(2, location.Y); Assert.Equal(3, location.Z); Assert.True(parsed.Union[2].TryGet(out string str)); Assert.Equal("foobar", str); }
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; }
private void SendInputMessage(InputType type) { var builder = new FlatBuffers.FlatBufferBuilder(1024); ClientInputMessage.StartClientInputMessage(builder); ClientInputMessage.AddType(builder, type); var input = ClientInputMessage.EndClientInputMessage(builder); Message.StartMessage(builder); Message.AddDataType(builder, MessageType.ClientInputMessage); Message.AddData(builder, input.Value); var message = Message.EndMessage(builder); builder.Finish(message.Value); byte[] bytes = builder.SizedByteArray(); _udpClient.Send(bytes, bytes.Length); //Debug.Log("Sent Input message " + bytes.Length); }
private void SendMessageAck(int messageId) { var builder = new FlatBuffers.FlatBufferBuilder(1024); MessageAck.StartMessageAck(builder); MessageAck.AddMessageId(builder, messageId); var ack = MessageAck.EndMessageAck(builder); Message.StartMessage(builder); Message.AddDataType(builder, MessageType.MessageAck); Message.AddData(builder, ack.Value); var message = NetworkedPhysics.Message.EndMessage(builder); builder.Finish(message.Value); byte[] bytes = builder.SizedByteArray(); _udpClient.Send(bytes, bytes.Length); //Debug.Log("Sent MessageAck message " + messageId + " " + bytes.Length); }
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 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.Equal(6, intItems.Count); for (int i = 0; i < 6; ++i) { Assert.Equal(1 + i, intItems[i]); } IList <long> longItems = parsed.LongVector; Assert.Equal(6, longItems.Count); for (int i = 0; i < 6; ++i) { Assert.Equal(7 + i, longItems[i]); } Memory <byte> mem = parsed.ByteVector2.Value; Assert.Equal(5, mem.Length); for (int i = 1; i <= 5; ++i) { Assert.Equal(i, mem.Span[i - 1]); } Assert.True(parsed.ByteVector3.IsEmpty); }
public void ConvertEvent(string dst, string path) { List <string> lineList = this.getLineList(path); FlatBuffers.FlatBufferBuilder fbb = new FlatBuffers.FlatBufferBuilder(1); FlatBuffers.Offset <EventTable.Data>[] data = new FlatBuffers.Offset <EventTable.Data> [lineList.Count]; int count = 0; foreach (string line in lineList) { string[] values = line.Split(','); int id = int.Parse(values[0]); int bitNum = values.Length - 1; int byteNum = ((bitNum - 1) / 8) + 1; byte[] flag = new byte[byteNum]; int byteNo = -1; for (int i = 0; i < byteNum; ++i) { flag[i] = 0; } for (int i = 0; i < bitNum; ++i) { if ((i % 8) == 0) { ++byteNo; } flag[byteNo] |= (byte)(int.Parse(values[1 + i]) << (i % 8)); } data[count] = EventTable.Data.CreateData(fbb, id, EventTable.Data.CreateFlagVector(fbb, flag)); ++count; } FlatBuffers.VectorOffset infoVec = EventTable.DataList.CreateDatasVector(fbb, data); FlatBuffers.Offset <EventTable.DataList> reslut = EventTable.DataList.CreateDataList(fbb, infoVec); EventTable.DataList.FinishDataListBuffer(fbb, reslut); using (System.IO.FileStream fs = new System.IO.FileStream(dst, System.IO.FileMode.Create)) { using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(fs)) { bw.Write(fbb.SizedByteArray()); } } }
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.NotNull(parsed?.OuterStruct?.InnerStruct); Assert.Equal(401, parsed.OuterStruct.InnerStruct.A); Assert.Equal(100, parsed.OuterStruct.A); }
public void ConvertMessage(string path) { List <string> lineList = this.getLineList(path); FlatBuffers.FlatBufferBuilder fbb = new FlatBuffers.FlatBufferBuilder(1); FlatBuffers.Offset <MessageTable.Data>[] data = new FlatBuffers.Offset <MessageTable.Data> [lineList.Count]; int count = 0; foreach (string line in lineList) { string[] works = line.Split(','); List <string> values = new List <string>(); int id = int.Parse(works[0]); for (int i = 1; i < works.Length; ++i) { if (string.IsNullOrEmpty(works[i])) { break; } values.Add(works[i]); } FlatBuffers.StringOffset[] messageList = new FlatBuffers.StringOffset[values.Count]; for (int i = 0; i < values.Count; ++i) { string message = values[i].Replace("\\n", "\n");; messageList[i] = fbb.CreateString(message); } data[count] = MessageTable.Data.CreateData(fbb, id, MessageTable.Data.CreateMessageVector(fbb, messageList)); ++count; } FlatBuffers.VectorOffset infoVec = MessageTable.DataList.CreateDatasVector(fbb, data); FlatBuffers.Offset <MessageTable.DataList> reslut = MessageTable.DataList.CreateDataList(fbb, infoVec); MessageTable.DataList.FinishDataListBuffer(fbb, reslut); using (System.IO.FileStream fs = new System.IO.FileStream("message-table.bin", System.IO.FileMode.Create)) { using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(fs)) { bw.Write(fbb.SizedByteArray()); } } }
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())); }
public static FlatBuffers.VectorOffset?CreateList <T>(FlatBuffers.FlatBufferBuilder builder , List <T> list, Func <FlatBufferBuilder, T[], VectorOffset> fbCreateList) { if (list == null || typeof(T).IsPrimitive) { return(null); } if (FlatbufferSerializer.obj2FSMapping.TryGetValue(list, out int bufPos)) { // the list was already serialized so we need to use this VectorOffset in order to keep the reference var result = new FlatBuffers.VectorOffset(bufPos); return(result); } else { var tempArray = list.ToArray(); // call the createFunction with the array var result = fbCreateList(builder, tempArray); FlatbufferSerializer.obj2FSMapping[list] = result.Value; return(result); } }
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); }
void Start() { oNetworkManager MainPlayer = NetworkObject.mainPlayer.GetComponent <oNetworkManager>(); NetDataReader.GetInstace().Reder[Class.Player] = (data) => { var m_player = Player.GetRootAsPlayer(data.ByteBuffer); if (m_player.ID != MainPlayer.id) { if (!OPlayers.ContainsKey(m_player.ID)) { var obj = Instantiate(PlayerPrifab, Vector3.zero, Quaternion.identity); obj.AddComponent <OtherPlayer>(); obj.AddComponent <oNetworkIdentity>().id = m_player.ID; obj.GetComponent <oNetworkIdentity>().type = oNetworkIdentity.ObjType.player; OPlayers[m_player.ID] = obj.GetComponent <OtherPlayer>(); SendToMe_PlayerStat.Send(m_player.ID); } OPlayers[m_player.ID].UpdateOtherObj(m_player); } else if (m_player.ID == MainPlayer.id) { var pos = m_player.Pos.Value; MainPlayer.transform.position.Set(pos.X, pos.Y, pos.Z); } }; NetDataReader.GetInstace().Reder[Class.FirstCharacterData] = (data) => { var FirstPlayerData = FirstCharacterData.GetRootAsFirstCharacterData(data.ByteBuffer); var fbb = new FlatBuffers.FlatBufferBuilder(1); fbb.Finish(PlayerStat.CreatePlayerStat( fbb, Class.PlayerStat, FirstPlayerData.HP, FirstPlayerData.HPLim, FirstPlayerData.MP, FirstPlayerData.MPLim, FirstPlayerData.EXP, FirstPlayerData.Attack, FirstPlayerData.LV, FirstPlayerData.ID ).Value); var buf = new FlatBuffers.ByteBuffer(fbb.SizedByteArray()); var _PlayerStat = PlayerStat.GetRootAsPlayerStat(buf); var pos = FirstPlayerData.Pos.Value; MainPlayer.GetComponent <oCreature>().Data_Update(_PlayerStat); MainPlayer.GetComponent <oCreature>().Data_Update(pos); MainPlayer.GetComponent <NetworkObject>().m_CurrentHP.NoEventSet(_PlayerStat.HP); MainPlayer.GetComponent <NetworkObject>().m_CurrentMP.NoEventSet(_PlayerStat.MP); MainPlayer.GetComponent <NetworkObject>().m_CurrentHPLim.NoEventSet(_PlayerStat.HPLim); MainPlayer.GetComponent <NetworkObject>().m_CurrentMPLim.NoEventSet(_PlayerStat.MPLim); MainPlayer.GetComponent <NetworkObject>().m_CurrentLV.NoEventSet(_PlayerStat.LV); MainPlayer.GetComponent <NetworkObject>().m_CurrentEXP.NoEventSet(_PlayerStat.EXP); MainPlayer.GetComponent <NetworkObject>().m_CurrentATK.NoEventSet(_PlayerStat.Attack); MainPlayer.GetComponent <NetworkObject>().CharacterName.NoEventSet(FirstPlayerData.Name); Vector3 v3 = new Vector3(); v3.Set(pos.X, pos.Y, pos.Z); }; NetDataReader.GetInstace().Reder[Class.fEquipSome] = (data) => { var equipSome = fEquipSome.GetRootAsfEquipSome(data.ByteBuffer); Debug.Log(MainPlayer.GetComponent <oNetworkIdentity>().id + ":" + equipSome.PID + ":" + equipSome.SlotNum + ":" + equipSome.ObjNum); if (MainPlayer.GetComponent <oNetworkIdentity>().id == equipSome.PID) { MainPlayer.GetComponent <EquipManager>().Equip(equipSome.ObjNum, equipSome.SlotNum); } else { OPlayers[equipSome.PID].GetComponent <EquipManager>().Equip(equipSome.ObjNum, -1); } }; NetDataReader.GetInstace().Reder[Class.PlayerStat] = (data) => { var _PlayerStat = PlayerStat.GetRootAsPlayerStat(data.ByteBuffer); var player = MainPlayer.GetComponent <NetworkObject>(); if (_PlayerStat.ID == MainPlayer.id) { MainPlayer.GetComponent <oCreature>().Data_Update(_PlayerStat); player.m_CurrentHP.NoEventSet(_PlayerStat.HP); player.m_CurrentMP.NoEventSet(_PlayerStat.MP); player.m_CurrentHPLim.NoEventSet(_PlayerStat.HPLim); player.m_CurrentMPLim.NoEventSet(_PlayerStat.MPLim); player.m_CurrentEXP.NoEventSet(_PlayerStat.EXP); player.m_CurrentATK.NoEventSet(_PlayerStat.Attack); if (_PlayerStat.LV > player.m_CurrentLV.Value) { IG_EffectManager.Show(player.gameObject.transform.position, "LVUP"); } player.m_CurrentLV.NoEventSet(_PlayerStat.LV); } else if (OPlayers.ContainsKey(_PlayerStat.ID)) { if (OPlayers[_PlayerStat.ID].GetComponent <oCreature>() == null) { OPlayers[_PlayerStat.ID].gameObject.AddComponent <oCreature>(); OPlayers[_PlayerStat.ID].gameObject.AddComponent <SendStateManager>(); OPlayers[_PlayerStat.ID].gameObject.GetComponent <OtherPlayer>().SetStatEvent(); OPlayers[_PlayerStat.ID].gameObject.name = _PlayerStat.NikName; } OPlayers[_PlayerStat.ID].gameObject.GetComponent <oCreature>().Data_Update(_PlayerStat); } }; }