public NetworkInstantiate(string pfName, IAutoSerializable callbackArg, string callback)
: base(RPCType.AllBuffered)
{
this.pfName = pfName;
this.callbackArg = callbackArg;
this.callback = callback;
}
/// <summary>
/// Write an instance of <see cref="IAutoSerializable"/> in the stream
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public BasicWriter SetAutoSerializable(IAutoSerializable value)
{
var type = value.GetType();
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance).OrderBy((x) => x.MetadataToken);
foreach (var field in fields)
{
if (field.GetCustomAttribute <IgnoreField>() == null)
{
var fieldValue = field.GetValue(value);
if (!typeof(IAutoSerializable).IsAssignableFrom(field.FieldType))
{
var customization = field.GetCustomAttribute <CustomSerialization>();
if (customization == null)
{
SetValue(fieldValue);
}
else
{
var method = type.GetMethod(customization.MethodName, BindingFlags.NonPublic | BindingFlags.Instance);
var parameters = method?.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(BasicWriter))
{
method.Invoke(value, new object[] { this });
}
}
}
else
{
if (fieldValue == null)
{
throw new MissingFieldException($"{ field.Name } is null");
}
SetAutoSerializable(fieldValue as IAutoSerializable);
}
}
}
return(this);
}
public static void Deserialize(IAutoSerializable obj, byte[] buffer)
{
int offset = 0;
foreach (var field in obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public))
{
object value = null;
var fieldType = field.FieldType;
if (!IsSerializableType(fieldType))
continue;
if (fieldType.IsEnum)
fieldType = Enum.GetUnderlyingType(fieldType);
string typeName = fieldType.Name;
if (fieldType.IsArray)
typeName = typeName.Replace("[]", "s");
if (fieldType.GetInterface("IAutoSerializable") != null || fieldType == typeof(IAutoSerializable))
typeName = "Packet";
value = typeof(Serializer).GetMethod("To" + typeName, new[] { typeof(byte[]), typeof(int) }).Invoke(null, new object[] { buffer, offset });
if (fieldType.GetInterface("IAutoSerializable") != null || fieldType == typeof(IAutoSerializable))
value = value.GetType().GetField("body").GetValue(value);
field.SetValue(obj, value);
offset += SerializedSize(obj, field);
}
}
public SerializedPlayer(IAutoSerializable player)
: base(RPCType.Others)
{
data = player.Serialize();
}
static int SerializedSize(IAutoSerializable obj, FieldInfo field)
{
int ret = 0;
var fieldType = field.FieldType;
if (!IsSerializableType(fieldType))
return 0;
object value = field.GetValue(obj);
if (fieldType.IsEnum)
{
fieldType = Enum.GetUnderlyingType(fieldType);
value = Convert.ChangeType(value, fieldType);
}
if (fieldType.GetInterface("IAutoSerializable") != null || fieldType == typeof(IAutoSerializable))
{
fieldType = typeof(Packet);
value = Activator.CreateInstance(typeof(Packet), field.GetValue(obj));
}
if (!serializedSizesCache.ContainsKey(fieldType))
serializedSizesCache.Add(fieldType, typeof(Serializer).GetMethod("SerializedSize", new[] { fieldType }));
ret += (int)serializedSizesCache[fieldType].Invoke(null, new[] { value });
return ret;
}
public static int SerializedSize(IAutoSerializable obj)
{
int ret = 0;
foreach (var field in obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public))
ret += SerializedSize(obj, field);
return ret;
}
public static Header CreateHeader(IAutoSerializable obj)
{
return new Header(Packet.GetIndexByType(obj.GetType()), obj.SerializedSize());
}
public static byte[] Serialize(IAutoSerializable obj)
{
List<byte[]> buffers = new List<byte[]>();
int totalBufferSize = 0;
foreach (var field in obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public))
{
byte[] buffer;
var fieldType = field.FieldType;
if (!IsSerializableType(fieldType))
continue;
var value = field.GetValue(obj);
if (fieldType.IsEnum)
{
fieldType = Enum.GetUnderlyingType(fieldType);
value = Convert.ChangeType(value, fieldType);
}
if (fieldType.GetInterface("IAutoSerializable") != null || fieldType == typeof(IAutoSerializable))
{
fieldType = typeof(Packet);
value = Activator.CreateInstance(typeof(Packet), field.GetValue(obj));
}
buffer = Serialize(fieldType, value);
totalBufferSize += buffer.Length;
buffers.Add(buffer);
}
byte[] ret = new byte[totalBufferSize];
int offset = 0;
foreach (var buffer in buffers)
{
buffer.CopyTo(ret, offset);
offset += buffer.Length;
}
return ret;
}
public void NetworkInstantiate(NetworkScript prefab, IAutoSerializable callbackArg, string callback)
{
var ni = new NetworkInstantiate(prefab.name, callbackArg, callback);
Send(ni);
}
public void NetworkInstantiate(NetworkScript prefab, IAutoSerializable callbackArg)
{
var ni = new NetworkInstantiate(prefab.name, callbackArg, "");
NetworkProgramUnity.currentInstance.Send(ni);
}
public void NetworkInstantiate(NetworkScript prefab, IAutoSerializable callbackArg, string callback)
{
var ni = new NetworkInstantiate(prefab.name, callbackArg, callback);
Send(ni);
}
Packet(Header header, IAutoSerializable body)
{
this.header = header;
this.body = body;
}
public Packet(IAutoSerializable body)
{
header = body.CreateHeader();
this.body = body;
}
