/// <summary>
/// Deregister ISerializableGameObject from SaveLoadManager.
/// </summary>
public static void DeregisterSerializableGameObject(ISerializableGameObject serializableObject)
{
if (sceneUnloaded)
{
return;
}
if (serializableObject.LoadID == 0)
{
throw new Exception(invalidLoadIDExceptionText);
}
if (serializableObject is SerializableActionDoor)
{
Instance.serializableActionDoors.Remove(serializableObject.LoadID);
}
else if (serializableObject is SerializableActionObject)
{
Instance.serializableActionObjects.Remove(serializableObject.LoadID);
}
else if (serializableObject is SerializableEnemy)
{
Instance.serializableEnemies.Remove(serializableObject.LoadID);
}
}
/// <summary>
/// Register ISerializableGameObject with SerializableStateManager.
/// </summary>
public void RegisterStatefulGameObject(ISerializableGameObject serializableObject)
{
if (serializableObject.LoadID == 0)
{
throw new Exception(invalidLoadIDExceptionText);
}
if (serializableObject is SerializablePlayer)
{
serializablePlayer = serializableObject as SerializablePlayer;
}
else
{
StatefulGameObjectTypes sgObjType = GetStatefulGameObjectType(serializableObject);
Dictionary <ulong, ISerializableGameObject> serializableObjects = statefulGameObjects[(int)sgObjType];
if (serializableObjects.ContainsKey(serializableObject.LoadID))
{
DaggerfallUnity.LogMessage(string.Format(duplicateLoadIDErrorText, sgObjType, serializableObject.LoadID));
}
else
{
serializableObjects.Add(serializableObject.LoadID, serializableObject);
}
}
}
/// <summary>
/// Reads a non-primitive data value from a stream.
/// </summary>
private object ReadObject <T>(BinaryReader reader)
{
Type type = typeof(T);
// ISerializableGameObject
if (typeof(ISerializableGameObject).IsAssignableFrom(type))
{
object obj = Activator.CreateInstance(type);
ISerializableGameObject result = (ISerializableGameObject)obj;
result.Read(reader);
return(result);
}
// Maybe<>
else if (type.IsGenericType &&
typeof(Maybe <>) == type.GetGenericTypeDefinition())
{
Type[] genericTypes = type.GetGenericArguments();
var resolvedType = typeof(Maybe <>).MakeGenericType(genericTypes);
bool isSomething = reader.ReadBoolean();
if (isSomething)
{
object value = Read(reader, genericTypes[0]);
string methodName = "op_Implicit";
var opImplicit = resolvedType.GetMethod(
methodName,
new Type[] { genericTypes[0] });
object obj = (T)opImplicit.Invoke(null, new object[] { value });
return(obj);
}
else
{
string propertyName = nameof(Maybe <object> .Nothing);
var nothing = resolvedType.GetProperty(
propertyName,
BindingFlags.Static | BindingFlags.Public);
object maybeValue = nothing.GetValue(null, null);
return(maybeValue);
}
}
// Array
else if (typeof(Array).IsAssignableFrom(type))
{
// Read dimensions
int dimensions = reader.ReadInt32();
int[] lengths = new int[dimensions];
for (int i = 0; i < dimensions; i++)
{
lengths[i] = reader.ReadInt32();
}
// Read elements
object value = ReadArray(reader, lengths, type);
return(value);
}
else
{
throw new ArgumentException("Tried to read SerializerData for a\ntype that is not handled");
}
}
/// <summary>
/// Register ISerializableGameObject with SaveLoadManager.
/// </summary>
public static void RegisterSerializableGameObject(ISerializableGameObject serializableObject)
{
if (sceneUnloaded)
{
return;
}
if (serializableObject.LoadID == 0)
{
throw new Exception(invalidLoadIDExceptionText);
}
if (serializableObject is SerializablePlayer)
{
Instance.serializablePlayer = serializableObject as SerializablePlayer;
}
else if (serializableObject is SerializableActionDoor)
{
AddSerializableActionDoor(serializableObject as SerializableActionDoor);
}
else if (serializableObject is SerializableActionObject)
{
AddSerializableActionObject(serializableObject as SerializableActionObject);
}
else if (serializableObject is SerializableEnemy)
{
AddSerializableEnemy(serializableObject as SerializableEnemy);
}
}
/// <summary>
/// Deregister ISerializableGameObject from SerializableStateManager.
/// </summary>
public static void DeregisterSerializableGameObject(ISerializableGameObject serializableObject)
{
if (sceneUnloaded)
{
return;
}
Instance.stateManager.DeregisterStatefulGameObject(serializableObject);
}
/// <summary>
/// Deregister ISerializableGameObject from SerializableStateManager.
/// </summary>
public void DeregisterStatefulGameObject(ISerializableGameObject serializableObject)
{
if (serializableObject.LoadID == 0)
{
throw new Exception(invalidLoadIDExceptionText);
}
StatefulGameObjectTypes sgObjType = GetStatefulGameObjectType(serializableObject);
Dictionary <ulong, ISerializableGameObject> serializableObjects = statefulGameObjects[(int)sgObjType];
serializableObjects.Remove(serializableObject.LoadID);
}
ulong GetCasterLoadID(DaggerfallEntityBehaviour caster)
{
// Only supporting LoadID from enemies at this time
if (caster.EntityType == EntityTypes.EnemyMonster || caster.EntityType == EntityTypes.EnemyClass)
{
ISerializableGameObject serializableEnemy = caster.GetComponent <SerializableEnemy>() as ISerializableGameObject;
return(serializableEnemy.LoadID);
}
else
{
return(0);
}
}
/// <summary>
/// Reads serialized data into an <see cref="ISerializableGameObject"/>
/// from stream using a BinaryReader.
/// </summary>
private void ReadGameObject(BinaryReader reader, ISerializableGameObject gameObject)
{
Version readVersion = reader.ReadVersion();
// Read meta data
var metaData = ReadAllMetaData(reader, gameObject.ExpectedData(readVersion));
// Read data length
long length = reader.ReadInt64();
// Read data
long startPosition = reader.BaseStream.Position;
var data = SerializerData.Read(reader, metaData);
reader.BaseStream.Seek(startPosition + length, SeekOrigin.Begin);
gameObject.UpdateReadValues(readVersion, data);
gameObject.SetReadValues(data);
}
private StatefulGameObjectTypes GetStatefulGameObjectType(ISerializableGameObject sgObj)
{
if (sgObj is SerializableActionDoor)
{
return(StatefulGameObjectTypes.ActionDoor);
}
else if (sgObj is SerializableActionObject)
{
return(StatefulGameObjectTypes.ActionObject);
}
else if (sgObj is SerializableEnemy)
{
return(StatefulGameObjectTypes.Enemy);
}
else if (sgObj is SerializableLootContainer)
{
return(StatefulGameObjectTypes.LootContainer);
}
throw new Exception(typeNotImplementedExeptionText + sgObj.GetType().ToString());
}
/// <summary>
/// Reads serialized data into an <see cref="ISerializableGameObject"/>
/// from stream using a BinaryReader.
/// </summary>
public static void Read(
BinaryReader reader,
ISerializableGameObject gameObject)
{
SaveSerialization type = (SaveSerialization)reader.ReadByte();
SaveSerializer serializer;
switch (type)
{
case SaveSerialization.ExplicitTypes:
default:
serializer = new ExplicitSaveSerializer();
break;
case SaveSerialization.ImplicitTypes:
throw new NotImplementedException();
}
serializer.ReadGameObject(reader, gameObject);
}
/// <summary>
/// Writes an <see cref="ISerializableGameObject"/> to stream using a
/// BinaryWriter.
/// </summary>
/// <param name="type">The <see cref="SaveSerialization"/> method to use.</param>
public static void Write(
BinaryWriter writer,
ISerializableGameObject gameObject,
SaveSerialization type)
{
writer.Write((byte)type);
SaveSerializer serializer;
switch (type)
{
case SaveSerialization.ExplicitTypes:
default:
serializer = new ExplicitSaveSerializer();
break;
case SaveSerialization.ImplicitTypes:
throw new NotImplementedException();
}
serializer.WriteGameObject(writer, gameObject.GetSaveData());
}
/// <summary>
/// Register ISerializableGameObject with SaveLoadManager.
/// </summary>
public static void RegisterSerializableGameObject(ISerializableGameObject serializableObject)
{
if (sceneUnloaded)
return;
if (serializableObject.LoadID == 0)
throw new Exception(invalidLoadIDExceptionText);
if (serializableObject is SerializablePlayer)
Instance.serializablePlayer = serializableObject as SerializablePlayer;
else if (serializableObject is SerializableActionDoor)
AddSerializableActionDoor(serializableObject as SerializableActionDoor);
else if (serializableObject is SerializableActionObject)
AddSerializableActionObject(serializableObject as SerializableActionObject);
else if (serializableObject is SerializableEnemy)
AddSerializableEnemy(serializableObject as SerializableEnemy);
}
/// <summary>
/// Deregister ISerializableGameObject from SaveLoadManager.
/// </summary>
public static void DeregisterSerializableGameObject(ISerializableGameObject serializableObject)
{
if (sceneUnloaded)
return;
if (serializableObject.LoadID == 0)
throw new Exception(invalidLoadIDExceptionText);
if (serializableObject is SerializableActionDoor)
Instance.serializableActionDoors.Remove(serializableObject.LoadID);
else if (serializableObject is SerializableActionObject)
Instance.serializableActionObjects.Remove(serializableObject.LoadID);
else if (serializableObject is SerializableEnemy)
Instance.serializableEnemies.Remove(serializableObject.LoadID);
}
