/// <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);
}
};
}
