public Vector3 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var length = reader.ReadArrayHeader();
var __MyProperty1__ = default(float);
var __MyProperty2__ = default(float);
var __MyProperty3__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__MyProperty1__ = reader.ReadSingle();
break;
case 1:
__MyProperty2__ = reader.ReadSingle();
break;
case 2:
__MyProperty3__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
return(new Vector3(__MyProperty1__, __MyProperty2__, __MyProperty3__));
}
public global::UnityEngine.Vector2 Deserialize(ref MessagePackReader reader, global::MessagePack.IFormatterResolver formatterResolver)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var x = default(float);
var y = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadSingle();
break;
case 1:
y = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var result = new global::UnityEngine.Vector2(x, y);
return(result);
}
public float2 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var x = default(float);
var y = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadSingle();
break;
case 1:
y = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var result = float2(x, y);
return(result);
}
public global::UnityEngine.GradientAlphaKey Deserialize(ref MessagePackReader reader, global::MessagePack.IFormatterResolver formatterResolver)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var __alpha__ = default(float);
var __time__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__alpha__ = reader.ReadSingle();
break;
case 1:
__time__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.GradientAlphaKey(__alpha__, __time__);
____result.alpha = __alpha__;
____result.time = __time__;
return(____result);
}
public global::Server.SharedThings.Packets.Representations.Player Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Id__ = default(string);
var __X__ = default(float);
var __Y__ = default(float);
var __Nickname__ = default(string);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Id__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__X__ = reader.ReadSingle();
break;
case 2:
__Y__ = reader.ReadSingle();
break;
case 3:
__Nickname__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.Representations.Player();
____result.Id = __Id__;
____result.X = __X__;
____result.Y = __Y__;
____result.Nickname = __Nickname__;
return(____result);
}
public global::UnityEngine.Keyframe Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var __time__ = default(float);
var __value__ = default(float);
var __inTangent__ = default(float);
var __outTangent__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__time__ = reader.ReadSingle();
break;
case 1:
__value__ = reader.ReadSingle();
break;
case 2:
__inTangent__ = reader.ReadSingle();
break;
case 3:
__outTangent__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.Keyframe(__time__, __value__, __inTangent__, __outTangent__);
____result.time = __time__;
____result.value = __value__;
____result.inTangent = __inTangent__;
____result.outTangent = __outTangent__;
return(____result);
}
public object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (id == 0)
{
return(reader.ReadString());
}
if (id == 1)
{
return(reader.ReadInt32());
}
if (id == 2)
{
return(reader.ReadByte());
}
if (id == 4)
{
return(options.Resolver.GetFormatterWithVerify <Vector3>().Deserialize(ref reader, options));
}
if (id == 5)
{
return(reader.ReadSingle());
}
return(null);
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
public Single?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadSingle());
}
public global::UnityEngine.Rect Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var x = default(float);
var y = default(float);
var width = default(float);
var height = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
x = reader.ReadSingle();
break;
case 1:
y = reader.ReadSingle();
break;
case 2:
width = reader.ReadSingle();
break;
case 3:
height = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var result = new global::UnityEngine.Rect(x, y, width, height);
return(result);
}
public global::UnityEngine.Color Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var r = default(float);
var g = default(float);
var b = default(float);
var a = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
r = reader.ReadSingle();
break;
case 1:
g = reader.ReadSingle();
break;
case 2:
b = reader.ReadSingle();
break;
case 3:
a = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var result = new global::UnityEngine.Color(r, g, b, a);
return(result);
}
public override TestTarget Deserialize(ref MessagePackReader reader)
{
if (!reader.TryReadNil())
{
var value = new TestTarget();
int count = reader.ReadMapHeader();
for (int i = 0; i < count; i++)
{
ArraySegment<byte> segment = reader.ReadStringSegment();
if (m_nameToKey.TryGetValue(segment.Array, segment.Offset, segment.Count, out int key))
{
switch (key)
{
case 0:
{
value.BoolValue = reader.ReadBoolean();
break;
}
case 1:
{
value.IntValue = reader.ReadInt32();
break;
}
case 2:
{
value.FloatValue = reader.ReadSingle();
break;
}
case 3:
{
value.StringValue = reader.ReadString();
break;
}
case 4:
{
value.EnumValue = m_formatterTypeCode.Deserialize(ref reader);
break;
}
default:
{
reader.ReadNextBlock();
break;
}
}
}
else
{
reader.ReadNextBlock();
}
}
}
return default;
}
public override TestTarget Deserialize(ref MessagePackReader reader)
{
if (!reader.TryReadNil())
{
var value = new TestTarget();
int count = reader.ReadArrayHeader();
for (int i = 0; i < count; i++)
{
int key = reader.ReadInt32();
switch (key)
{
case 0:
{
value.BoolValue = reader.ReadBoolean();
break;
}
case 1:
{
value.IntValue = reader.ReadInt32();
break;
}
case 2:
{
value.FloatValue = reader.ReadSingle();
break;
}
case 3:
{
value.StringValue = reader.ReadString();
break;
}
case 4:
{
value.EnumValue = m_formatterTypeCode.Deserialize(ref reader);
break;
}
default:
{
reader.ReadNextBlock();
break;
}
}
}
return(value);
}
return(default);
public object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options)
{
switch (id)
{
case MASS_ID:
return(reader.ReadSingle());
case DRAG_ID:
return(reader.ReadSingle());
case ANGULAR_DRAG_ID:
return(reader.ReadSingle());
case USE_GRAVITY_ID:
return(reader.ReadBoolean());
case IS_KINEMATIC_ID:
return(reader.ReadBoolean());
}
return(default);
public global::Sakaba.Domain.StatModifier Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadMapHeader();
var __value__ = default(float);
var __type__ = default(global::Sakaba.Domain.StatModType);
var __targetType__ = default(global::Sakaba.Domain.ModTargetType);
for (int i = 0; i < length; i++)
{
ReadOnlySpan <byte> stringKey = global::MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref reader);
int key;
if (!this.____keyMapping.TryGetValue(stringKey, out key))
{
reader.Skip();
continue;
}
switch (key)
{
case 0:
__value__ = reader.ReadSingle();
break;
case 1:
__type__ = formatterResolver.GetFormatterWithVerify <global::Sakaba.Domain.StatModType>().Deserialize(ref reader, options);
break;
case 2:
__targetType__ = formatterResolver.GetFormatterWithVerify <global::Sakaba.Domain.ModTargetType>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Sakaba.Domain.StatModifier();
____result.value = __value__;
____result.type = __type__;
____result.targetType = __targetType__;
reader.Depth--;
return(____result);
}
public global::Server.SharedThings.Packets.ServerPackets.Game.PlayerUpdateOwnPosition Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __X__ = default(float);
var __Y__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__X__ = reader.ReadSingle();
break;
case 1:
__Y__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.ServerPackets.Game.PlayerUpdateOwnPosition();
____result.X = __X__;
____result.Y = __Y__;
return(____result);
}
public override TestTarget Deserialize(ref MessagePackReader reader)
{
if (!reader.TryReadNil())
{
var value = new TestTarget();
value.BoolValue = reader.ReadBoolean();
value.IntValue = reader.ReadInt32();
value.FloatValue = reader.ReadSingle();
value.StringValue = reader.ReadString();
value.EnumValue = m_formatterTypeCode.Deserialize(ref reader);
return(value);
}
return(default);
public Single[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new Single[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadSingle();
}
return(array);
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
if (!bytes.HasValue)
{
return(null);
}
else if (bytes.Value.Length == 0)
{
return(Array.Empty <byte>());
}
return(bytes.Value.ToArray());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
public global::Pathfinding.Node Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __pos__ = default(global::UnityEngine.Vector3);
var __isoValue__ = default(float);
var __neighbourIdentifiers__ = default(global::System.Collections.Generic.List <global::Pathfinding.NodeIdentifier>);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__pos__ = formatterResolver.GetFormatterWithVerify <global::UnityEngine.Vector3>().Deserialize(ref reader, options);
break;
case 1:
__isoValue__ = reader.ReadSingle();
break;
case 2:
__neighbourIdentifiers__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <global::Pathfinding.NodeIdentifier> >().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Pathfinding.Node(__pos__, __isoValue__, __neighbourIdentifiers__);
____result.pos = __pos__;
____result.isoValue = __isoValue__;
____result.neighbourIdentifiers = __neighbourIdentifiers__;
reader.Depth--;
return(____result);
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
if (!bytes.HasValue)
{
return(null);
}
else if (bytes.Value.Length == 0)
{
return(Array.Empty <byte>());
}
return(bytes.Value.ToArray());
}
else if (type == typeof(JsonElement))
{
var bytes = reader.ReadBytes();
if (bytes is null)
{
return(default);
public void SingleTest(Single target, int length)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.Write(target);
writer.Flush();
sequence.Length.Is(length);
packer.Pack(target).Position.Is(sequence.Length);
stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadSingle().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsSingle().Is(target);
}
private static object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
// MessagePack ensures there are at least as many bytes in the message as declared by the byte header.
// Consequently it is safe to do ToArray on the returned SequenceReader instance.
return(bytes.ToArray());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
public Matrix44F Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("type code is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var result = new Matrix44F();
for (int i = 0; i < length; i++)
{
if (i > 16)
{
reader.Skip();
continue;
}
result[i / 4, i % 4] = reader.ReadSingle();
}
return(result);
}
public global::UnityEngine.GradientColorKey Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var __color__ = default(global::UnityEngine.Color);
var __time__ = default(float);
IFormatterResolver resolver = options.Resolver;
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__color__ = resolver.GetFormatterWithVerify <global::UnityEngine.Color>().Deserialize(ref reader, options);
break;
case 1:
__time__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.GradientColorKey(__color__, __time__);
____result.color = __color__;
____result.time = __time__;
return(____result);
}
public global::UnityEngine.Matrix4x4 Deserialize(ref MessagePackReader reader, global::MessagePack.IFormatterResolver formatterResolver)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var __m00__ = default(float);
var __m10__ = default(float);
var __m20__ = default(float);
var __m30__ = default(float);
var __m01__ = default(float);
var __m11__ = default(float);
var __m21__ = default(float);
var __m31__ = default(float);
var __m02__ = default(float);
var __m12__ = default(float);
var __m22__ = default(float);
var __m32__ = default(float);
var __m03__ = default(float);
var __m13__ = default(float);
var __m23__ = default(float);
var __m33__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__m00__ = reader.ReadSingle();
break;
case 1:
__m10__ = reader.ReadSingle();
break;
case 2:
__m20__ = reader.ReadSingle();
break;
case 3:
__m30__ = reader.ReadSingle();
break;
case 4:
__m01__ = reader.ReadSingle();
break;
case 5:
__m11__ = reader.ReadSingle();
break;
case 6:
__m21__ = reader.ReadSingle();
break;
case 7:
__m31__ = reader.ReadSingle();
break;
case 8:
__m02__ = reader.ReadSingle();
break;
case 9:
__m12__ = reader.ReadSingle();
break;
case 10:
__m22__ = reader.ReadSingle();
break;
case 11:
__m32__ = reader.ReadSingle();
break;
case 12:
__m03__ = reader.ReadSingle();
break;
case 13:
__m13__ = reader.ReadSingle();
break;
case 14:
__m23__ = reader.ReadSingle();
break;
case 15:
__m33__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::UnityEngine.Matrix4x4();
____result.m00 = __m00__;
____result.m10 = __m10__;
____result.m20 = __m20__;
____result.m30 = __m30__;
____result.m01 = __m01__;
____result.m11 = __m11__;
____result.m21 = __m21__;
____result.m31 = __m31__;
____result.m02 = __m02__;
____result.m12 = __m12__;
____result.m22 = __m22__;
____result.m32 = __m32__;
____result.m03 = __m03__;
____result.m13 = __m13__;
____result.m23 = __m23__;
____result.m33 = __m33__;
return(____result);
}
public void ReadSingle_CanReadDouble()
{
var reader = new MessagePackReader(Encode((ref MessagePackWriter w) => w.Write(1.23)));
Assert.Equal(1.23f, reader.ReadSingle());
}
public Half Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return((Half)reader.ReadSingle());
}
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
MessagePackType type = reader.NextMessagePackType;
IFormatterResolver resolver = options.Resolver;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (code >= MessagePackCode.MinNegativeFixInt && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (code >= MessagePackCode.MinFixInt && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (reader.NextCode == MessagePackCode.Float32)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
// We must copy the sequence returned by ReadBytes since the reader's sequence is only valid during deserialization.
return(reader.ReadBytes()?.ToArray());
case MessagePackType.Extension:
ExtensionHeader ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
if (length == 0)
{
return(Array.Empty <object>());
}
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, options);
}
}
finally
{
reader.Depth--;
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length, options.Security.GetEqualityComparer <object>());
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, options);
var value = objectFormatter.Deserialize(ref reader, options);
hash.Add(key, value);
}
}
finally
{
reader.Depth--;
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new MessagePackSerializationException("Invalid primitive bytes.");
}
}
public global::MSP_Game_Base Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __DataKey__ = default(string);
var __Var_int__ = default(int);
var __Var_float__ = default(float);
var __Var_string__ = default(string);
var __Var_list_int__ = default(global::System.Collections.Generic.List <int>);
var __Var_list_float__ = default(global::System.Collections.Generic.List <float>);
var __Var_list_string__ = default(global::System.Collections.Generic.List <string>);
for (int i = 0; i < length; i++)
{
switch (i)
{
case 0:
__DataKey__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__Var_int__ = reader.ReadInt32();
break;
case 2:
__Var_float__ = reader.ReadSingle();
break;
case 3:
__Var_string__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 4:
__Var_list_int__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <int> >().Deserialize(ref reader, options);
break;
case 5:
__Var_list_float__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <float> >().Deserialize(ref reader, options);
break;
case 6:
__Var_list_string__ = formatterResolver.GetFormatterWithVerify <global::System.Collections.Generic.List <string> >().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::MSP_Game_Base();
____result.DataKey = __DataKey__;
____result.Var_int = __Var_int__;
____result.Var_float = __Var_float__;
____result.Var_string = __Var_string__;
____result.Var_list_int = __Var_list_int__;
____result.Var_list_float = __Var_list_float__;
____result.Var_list_string = __Var_list_string__;
reader.Depth--;
return(____result);
}