internal FieldLoadInfo(FieldInfo field, SerializeAttribute attr, string yamlName, Func <MiniYaml, object> loader = null)
{
Field = field;
Attribute = attr;
YamlName = yamlName;
Loader = loader;
}
/// <summary>
/// Deserializes the given object.
/// </summary>
/// <param name="stream">Stream containing data.</param>
/// <param name="type">The type of the object to create.</param>
/// <returns>The deserialized object.</returns>
public object Deserialize(Type type, SerializeStream stream)
{
FieldInfo[] infos = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
object obj = Activator.CreateInstance(type, true);
for (int i = 0; i < infos.Length; i++)
{
FieldInfo info = infos[i];
if (info.IsDefined(typeof(SerializeAttribute), false))
{
SerializeAttribute attribute = (SerializeAttribute)
info.GetCustomAttributes(typeof(SerializeAttribute), false)[0];
if (attribute.Primitive)
{
info.SetValue(obj, stream.Read(info.Name, info.FieldType));
}
else
{
info.SetValue(obj, stream.ReadObject(info.Name));
}
}
}
PropertyInfo[] pInfos = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
for (int i = 0; i < pInfos.Length; i++)
{
PropertyInfo pInfo = pInfos[i];
if (pInfo.IsDefined(typeof(SerializeAttribute), false))
{
SerializeAttribute attribute = (SerializeAttribute)
pInfo.GetCustomAttributes(typeof(SerializeAttribute), false)[0];
if (pInfo.CanWrite)
{
if (attribute.Primitive)
{
pInfo.SetValue(obj, stream.Read(pInfo.Name, pInfo.PropertyType), null);
}
else
{
pInfo.SetValue(obj, stream.ReadObject(pInfo.Name), null);
}
}
}
}
return(obj);
}
//---------------------------------------------------------------
#endregion
//---------------------------------------------------------------
//---------------------------------------------------------------
#region ISerializer Members
//---------------------------------------------------------------
/// <summary>
/// Serializes the given object.
/// </summary>
/// <param name="obj">The object to serialize.</param>
/// <param name="stream">Stream to fill with data.</param>
public void Serialize(object obj, SerializeStream stream)
{
Type type = obj.GetType();
MemberInfo[] infos = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance);
for (int i = 0; i < infos.Length; i++)
{
if (infos[i].IsDefined(typeof(SerializeAttribute), false))
{
SerializeAttribute attribute = (SerializeAttribute)
infos[i].GetCustomAttributes(typeof(SerializeAttribute), false)[0];
FieldInfo info = infos[i] as FieldInfo;
PropertyInfo pInfo = infos[i] as PropertyInfo;
if (info != null)
{
if (attribute.Primitive)
{
stream.Write(info.Name, info.GetValue(obj));
}
else
{
stream.WriteAsObject(info.Name, info.GetValue(obj));
}
}
else if (pInfo != null && pInfo.CanRead && pInfo.CanWrite)
{
if (attribute.Primitive)
{
stream.Write(pInfo.Name, pInfo.GetValue(obj, null));
}
else
{
stream.WriteAsObject(pInfo.Name, pInfo.GetValue(obj, null));
}
}
else
{
throw new Exception("Can't get AND set member: " + pInfo.Name);
}
}
}
}
public FieldSerializeHelper(FieldInfo info, EntryFieldAttribute fieldInfo, SerializeAttribute serializer)
{
this.defaultValue = fieldInfo.DefaultValue;
this.GetValue = info.GetValue;
this.SetValue = info.SetValue;
if (serializer != null)
{
this.Serialize = serializeCustom(this, serializer.Serialize);
this.Deserialize = deserializeCustom(this, serializer.Deserialize);
this.DeserializeExact = deserializeCustomExact(this, serializer.Deserialize);
return;
}
this.Serialize = serializeDefault(this, fieldInfo.Format);
if (info.FieldType.GetTypeInfo().IsEnum)
{
this.Deserialize = deserializeEnum(this, info.FieldType);
this.DeserializeExact = deserializeEnumExact(this, info.FieldType);
}
else
{
this.Deserialize = deserializeDefault(this, info.FieldType);
this.DeserializeExact = deserializeDefaultExact(this, info.FieldType);
}
}
public bool Decode(byte[] data)
{
BinaryReader reader = new BinaryReader(new MemoryStream(data));
reader.ReadInt16(); // skip packet id
this.NetworkId = reader.ReadInt32();
ushort bitmask =
(ushort)
((this.GetType().GetCustomAttribute(typeof(PacketAttribute)) as PacketAttribute).BitmaskType ==
typeof(Byte)
? reader.ReadByte()
: reader.ReadUInt16());
foreach (var p in this.GetType().GetProperties())
{
SerializeAttribute serializeAttr =
p.GetCustomAttribute(typeof(SerializeAttribute)) as SerializeAttribute;
if (serializeAttr == null)
{
continue;
}
object buffer = null;
if (p.PropertyType == typeof(Int32) ||
p.PropertyType == typeof(Int16) ||
p.PropertyType == typeof(Byte))
{
if (serializeAttr.Dict.Length == 8)
{
var entry =
(int)serializeAttr.Dict[bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits)];
if (entry < -1 || entry > 7)
{
Serializer.Decode(out buffer, p.PropertyType, reader, Operations.GetOperations((uint)entry), serializeAttr.ReverseByteOrder);
}
else
{
buffer = entry;
}
}
else if (serializeAttr.Dict.Length == 1)
{
if (bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 0)
{
Serializer.Decode(out buffer, p.PropertyType, reader,
Operations.GetOperations((uint)serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder);
}
else
{
buffer = 0;
}
}
}
else if (p.PropertyType == typeof(Vector3))
{
if (bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 0)
{
Serializer.Decode(out buffer, p.PropertyType, reader,
Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder);
}
}
else if (p.PropertyType == typeof(Vector2))
{
if (bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 0)
{
Serializer.Decode(out buffer, p.PropertyType, reader,
Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder);
}
}
else if (p.PropertyType == typeof(Boolean))
{
buffer = bitmask.GetBits(serializeAttr.BitIndex, serializeAttr.Bits) == 1 ? true : false;
}
p.SetValue(this, Convert.ChangeType(buffer, p.PropertyType));
}
return(true);
}
public byte[] Encode()
{
PacketAttribute packetAttr = this.GetType().GetCustomAttribute(typeof(PacketAttribute)) as PacketAttribute;
var ms = new MemoryStream();
var writer = new BinaryWriter(ms);
ushort bitmask = 0;
foreach (var p in this.GetType().GetProperties())
{
SerializeAttribute serializeAttr =
p.GetCustomAttribute(typeof(SerializeAttribute)) as SerializeAttribute;
if (serializeAttr == null)
{
continue;
}
if (p.PropertyType == typeof(Int32) ||
p.PropertyType == typeof(Int16) ||
p.PropertyType == typeof(Byte))
{
var _data = (Int32)(dynamic)p.GetValue(this);
if (serializeAttr.Dict.Length == 8)
{
switch (_data)
{
case -1:
case 0:
case 1:
case 2:
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, (ushort)serializeAttr.Dict.ToList().IndexOf((uint)_data));
break;
default:
var cryptOperationHashes =
serializeAttr.Dict.Where(x => x > 7 && x != unchecked ((uint)-1)).ToList();
var cryptOperation = cryptOperationHashes[random.Next() % cryptOperationHashes.Count];
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits,
(ushort)serializeAttr.Dict.ToList().IndexOf(cryptOperation));
Serializer.Encode(p.GetValue(this), p.PropertyType, writer,
Operations.GetOperations(cryptOperation), serializeAttr.ReverseByteOrder);
break;
}
}
else if (serializeAttr.Dict.Length == 1)
{
if (_data == 0)
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 1);
}
else
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 0);
Serializer.Encode(p.GetValue(this), p.PropertyType, writer,
Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder);
}
}
}
else if (p.PropertyType == typeof(Vector3))
{
var _data = (Vector3)p.GetValue(this);
if (_data.X != 0.0f ||
_data.Y != 0.0f ||
_data.Z != 0.0f)
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 0);
Serializer.Encode(_data, p.PropertyType, writer, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder);
}
else
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 1);
}
}
else if (p.PropertyType == typeof(Vector2))
{
var _data = (Vector2)p.GetValue(this);
if (_data.X != 0.0f ||
_data.Y != 0.0f)
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 0);
Serializer.Encode(_data, p.PropertyType, writer, Operations.GetOperations(serializeAttr.Dict[0]), serializeAttr.ReverseByteOrder);
}
else
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits, 1);
}
}
else if (p.PropertyType == typeof(Boolean))
{
bitmask = bitmask.SetRange(serializeAttr.BitIndex, serializeAttr.Bits,
(ushort)((bool)p.GetValue(this) == true ? 1 : 0));
}
}
var packet = new byte[ms.Length + 8];
BitConverter.GetBytes(packetAttr.Id).CopyTo(packet, 0);
BitConverter.GetBytes(NetworkId).CopyTo(packet, 2);
BitConverter.GetBytes(packetAttr.BitmaskType == typeof(Byte) ? (byte)bitmask : bitmask).CopyTo(packet, 6);
Array.Copy(ms.GetBuffer(), 0, packet, packetAttr.BitmaskType == typeof(Byte) ? 7 : 8, ms.Length);
return(packet);
}
internal FieldLoadInfo(FieldInfo field, SerializeAttribute attr, string yamlName, Func<MiniYaml, object> loader = null)
{
Field = field;
Attribute = attr;
YamlName = yamlName;
Loader = loader;
}
public ScriptInfoSerializeHelper(FieldInfo info, ScriptInfoAttribute fieldInfo, SerializeAttribute serializer)
{
this.GetValue = info.GetValue;
this.SetValue = info.SetValue;
this.defaultValue = fieldInfo.DefaultValue;
if (serializer != null)
{
//custom
this.Deserialize = deserializeCustom(this, serializer.Deserialize);
this.DeserializeExact = deserializeCustomExact(this, serializer.Deserialize);
if (fieldInfo.IsOptional)
{
this.Serialize = serializeOptional(this, serializer.Serialize);
}
else
{
this.Serialize = serialize(this, serializer.Serialize);
}
this.format = fieldInfo.FieldName + ": {0}";
return;
}
//enum, nullable and others
if (fieldInfo.IsOptional)
{
this.Serialize = serializeOptional(this);
}
else
{
this.Serialize = serialize(this);
}
var fieldType = info.FieldType;
this.format = fieldInfo.FieldName + ": {0:" + fieldInfo.Format + "}";
Type nullableInner;
if ((nullableInner = Nullable.GetUnderlyingType(fieldType)) != null)
{
//nullable
if (this.defaultValue?.GetType() == nullableInner)
{
this.defaultValue = Activator.CreateInstance(fieldType, new[] { this.defaultValue });
}
this.Deserialize = deserializeNullable(this, fieldType, nullableInner);
this.DeserializeExact = deserializeNullableExact(this, fieldType, nullableInner);
return;
}
if (fieldType.GetTypeInfo().IsEnum)
{
//enum
this.Deserialize = deserializeEnum(this, fieldType);
this.DeserializeExact = deserializeEnumExact(this, fieldType);
return;
}
//default
this.Deserialize = deserializeDefault(this, fieldType);
this.DeserializeExact = deserializeDefaultExact(this, fieldType);
}
