Ejemplo n.º 1
0
            public static void SerializeSnapshot(global::Improbable.Restricted.Worker.Snapshot snapshot, global::Improbable.Worker.CInterop.SchemaObject obj)
            {
                obj.AddString(1, snapshot.WorkerId);

                obj.AddString(2, snapshot.WorkerType);

                global::Improbable.Restricted.Connection.Serialization.Serialize(snapshot.Connection, obj.AddObject(3));
            }
Ejemplo n.º 2
0
            public static void SerializeComponent(global::Improbable.Restricted.Worker.Component component, global::Improbable.Worker.CInterop.SchemaObject obj, global::Unity.Entities.World world)
            {
                obj.AddString(1, component.WorkerId);

                obj.AddString(2, component.WorkerType);

                global::Improbable.Restricted.Connection.Serialization.Serialize(component.Connection, obj.AddObject(3));
            }
Ejemplo n.º 3
0
 public static void Serialize(PlayerIdentity instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         obj.AddString(1, instance.PlayerIdentifier);
     }
     {
         obj.AddString(2, instance.Provider);
     }
     {
         obj.AddBytes(3, instance.Metadata);
     }
 }
Ejemplo n.º 4
0
 public static unsafe void Write(global::Improbable.Worker.Internal.GcHandlePool _pool,
                                 WorkerData _data, global::Improbable.Worker.CInterop.SchemaObject _obj)
 {
     {
         _obj.AddString(1, _data.workerId);
     }
     {
         _obj.AddString(2, _data.workerType);
     }
     {
         global::Improbable.Restricted.Connection_Internal.Write(_pool, _data.connection, _obj.AddObject(3));
     }
 }
Ejemplo n.º 5
0
 public static unsafe void Write(global::Improbable.Worker.Internal.GcHandlePool _pool,
                                 MetadataData _data, global::Improbable.Worker.CInterop.SchemaObject _obj)
 {
     {
         _obj.AddString(1, _data.entityType);
     }
 }
 public static void Serialize(ExhaustiveSingularData instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         obj.AddBool(1, instance.Field1);
     }
     {
         obj.AddFloat(2, instance.Field2);
     }
     {
         obj.AddBytes(3, instance.Field3);
     }
     {
         obj.AddInt32(4, instance.Field4);
     }
     {
         obj.AddInt64(5, instance.Field5);
     }
     {
         obj.AddDouble(6, instance.Field6);
     }
     {
         obj.AddString(7, instance.Field7);
     }
     {
         obj.AddUint32(8, instance.Field8);
     }
     {
         obj.AddUint64(9, instance.Field9);
     }
     {
         obj.AddSint32(10, instance.Field10);
     }
     {
         obj.AddSint64(11, instance.Field11);
     }
     {
         obj.AddFixed32(12, instance.Field12);
     }
     {
         obj.AddFixed64(13, instance.Field13);
     }
     {
         obj.AddSfixed32(14, instance.Field14);
     }
     {
         obj.AddSfixed64(15, instance.Field15);
     }
     {
         obj.AddEntityId(16, instance.Field16);
     }
     {
         global::Improbable.Gdk.Tests.SomeType.Serialization.Serialize(instance.Field17, obj.AddObject(17));
     }
     {
         obj.AddEnum(18, (uint)instance.Field18);
     }
 }
Ejemplo n.º 7
0
 public static void Serialize(WorkerAttributeSet instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         foreach (var value in instance.Attribute)
         {
             obj.AddString(1, value);
         }
     }
 }
Ejemplo n.º 8
0
 public static void Serialize(FirstEventPayload instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         obj.AddBool(1, instance.Field1);
     }
     {
         obj.AddString(2, instance.Field2);
     }
 }
Ejemplo n.º 9
0
 public static unsafe void Write(global::Improbable.Worker.Internal.GcHandlePool _pool,
                                 PlayerIdentity _data, global::Improbable.Worker.CInterop.SchemaObject _obj)
 {
     {
         _obj.AddString(1, _data.playerIdentifier);
     }
     {
         _obj.AddString(2, _data.provider);
     }
     {
         if (_data.metadata.BackingArray != null)
         {
             _obj.AddBytes(3, (byte *)_pool.Pin(_data.metadata.BackingArray), (uint)_data.metadata.Length);
         }
         else
         {
             _obj.AddBytes(3, null, 0);
         }
     }
 }
Ejemplo n.º 10
0
 public static unsafe void Write(global::Improbable.Worker.Internal.GcHandlePool _pool,
                                 WorkerAttributeSet _data, global::Improbable.Worker.CInterop.SchemaObject _obj)
 {
     if (_data.attribute != null)
     {
         for (int _i = 0; _i < _data.attribute.Count; ++_i)
         {
             _obj.AddString(1, _data.attribute[_i]);
         }
     }
 }
Ejemplo n.º 11
0
            public static void Serialize(ExhaustiveOptionalData instance, global::Improbable.Worker.CInterop.SchemaObject obj)
            {
                {
                    if (instance.Field1.HasValue)
                    {
                        obj.AddBool(1, instance.Field1.Value);
                    }
                }

                {
                    if (instance.Field2.HasValue)
                    {
                        obj.AddFloat(2, instance.Field2.Value);
                    }
                }

                {
                    if (instance.Field3.HasValue)
                    {
                        obj.AddBytes(3, instance.Field3.Value);
                    }
                }

                {
                    if (instance.Field4.HasValue)
                    {
                        obj.AddInt32(4, instance.Field4.Value);
                    }
                }

                {
                    if (instance.Field5.HasValue)
                    {
                        obj.AddInt64(5, instance.Field5.Value);
                    }
                }

                {
                    if (instance.Field6.HasValue)
                    {
                        obj.AddDouble(6, instance.Field6.Value);
                    }
                }

                {
                    if (instance.Field7.HasValue)
                    {
                        obj.AddString(7, instance.Field7.Value);
                    }
                }

                {
                    if (instance.Field8.HasValue)
                    {
                        obj.AddUint32(8, instance.Field8.Value);
                    }
                }

                {
                    if (instance.Field9.HasValue)
                    {
                        obj.AddUint64(9, instance.Field9.Value);
                    }
                }

                {
                    if (instance.Field10.HasValue)
                    {
                        obj.AddSint32(10, instance.Field10.Value);
                    }
                }

                {
                    if (instance.Field11.HasValue)
                    {
                        obj.AddSint64(11, instance.Field11.Value);
                    }
                }

                {
                    if (instance.Field12.HasValue)
                    {
                        obj.AddFixed32(12, instance.Field12.Value);
                    }
                }

                {
                    if (instance.Field13.HasValue)
                    {
                        obj.AddFixed64(13, instance.Field13.Value);
                    }
                }

                {
                    if (instance.Field14.HasValue)
                    {
                        obj.AddSfixed32(14, instance.Field14.Value);
                    }
                }

                {
                    if (instance.Field15.HasValue)
                    {
                        obj.AddSfixed64(15, instance.Field15.Value);
                    }
                }

                {
                    if (instance.Field16.HasValue)
                    {
                        obj.AddEntityId(16, instance.Field16.Value);
                    }
                }

                {
                    if (instance.Field17.HasValue)
                    {
                        global::Improbable.TestSchema.SomeType.Serialization.Serialize(instance.Field17.Value, obj.AddObject(17));
                    }
                }

                {
                    if (instance.Field18.HasValue)
                    {
                        obj.AddEnum(18, (uint)instance.Field18.Value);
                    }
                }
            }
Ejemplo n.º 12
0
 public static void SerializeComponent(global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component component, global::Improbable.Worker.CInterop.SchemaObject obj, global::Unity.Entities.World world)
 {
     obj.AddString(1, component.WorkerId);
 }
Ejemplo n.º 13
0
 public static void SerializeSnapshot(global::Improbable.Metadata.Snapshot snapshot, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     obj.AddString(1, snapshot.EntityType);
 }
Ejemplo n.º 14
0
 public static void SerializeComponent(global::Improbable.Metadata.Component component, global::Improbable.Worker.CInterop.SchemaObject obj, global::Unity.Entities.World world)
 {
     obj.AddString(1, component.EntityType);
 }
 public static void Serialize(ExhaustiveRepeatedData instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         foreach (var value in instance.Field1)
         {
             obj.AddBool(1, value);
         }
     }
     {
         foreach (var value in instance.Field2)
         {
             obj.AddFloat(2, value);
         }
     }
     {
         foreach (var value in instance.Field3)
         {
             obj.AddBytes(3, value);
         }
     }
     {
         foreach (var value in instance.Field4)
         {
             obj.AddInt32(4, value);
         }
     }
     {
         foreach (var value in instance.Field5)
         {
             obj.AddInt64(5, value);
         }
     }
     {
         foreach (var value in instance.Field6)
         {
             obj.AddDouble(6, value);
         }
     }
     {
         foreach (var value in instance.Field7)
         {
             obj.AddString(7, value);
         }
     }
     {
         foreach (var value in instance.Field8)
         {
             obj.AddUint32(8, value);
         }
     }
     {
         foreach (var value in instance.Field9)
         {
             obj.AddUint64(9, value);
         }
     }
     {
         foreach (var value in instance.Field10)
         {
             obj.AddSint32(10, value);
         }
     }
     {
         foreach (var value in instance.Field11)
         {
             obj.AddSint64(11, value);
         }
     }
     {
         foreach (var value in instance.Field12)
         {
             obj.AddFixed32(12, value);
         }
     }
     {
         foreach (var value in instance.Field13)
         {
             obj.AddFixed64(13, value);
         }
     }
     {
         foreach (var value in instance.Field14)
         {
             obj.AddSfixed32(14, value);
         }
     }
     {
         foreach (var value in instance.Field15)
         {
             obj.AddSfixed64(15, value);
         }
     }
     {
         foreach (var value in instance.Field16)
         {
             obj.AddEntityId(16, value);
         }
     }
     {
         foreach (var value in instance.Field17)
         {
             global::Improbable.TestSchema.SomeType.Serialization.Serialize(value, obj.AddObject(17));
         }
     }
     {
         foreach (var value in instance.Field18)
         {
             obj.AddEnum(18, (uint)value);
         }
     }
 }
Ejemplo n.º 16
0
 public static void SerializeSnapshot(global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Snapshot snapshot, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     obj.AddString(1, snapshot.WorkerId);
 }
Ejemplo n.º 17
0
 public static void Serialize(SecondCommandResponse instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         obj.AddString(1, instance.Response);
     }
 }
Ejemplo n.º 18
0
 public static void Serialize(ComponentIcon instance, global::Improbable.Worker.CInterop.SchemaObject obj)
 {
     {
         obj.AddString(1, instance.IconName);
     }
 }