public virtual void SerializeBoxMetadata(bool bSaving)
{
GraphWindow <EntityType> .BoxMetaDataSerializer <EntityType> TempSerializer = new GraphWindow <EntityType> .BoxMetaDataSerializer <EntityType>();
GraphWindow <EntityType> .BoxMetaDataSerializer <EntityType> .WindowToSerialize = this;
XMLSerializable.SerializeFromXML <GraphWindow <EntityType> .BoxMetaDataSerializer <EntityType> >(GetBoxMetadataFile(), ref TempSerializer, bSaving);
}
public static MonsterTest LoadMonsterTest(string Filename)
{
MonsterTest LoadedInstance = new MonsterTest();
XMLSerializable.SerializeFromXML <MonsterTest>(GetFullPathFromFilename(Filename), ref LoadedInstance, false);
return(LoadedInstance);
}
protected virtual void SerializeEntityManager(bool bSaving)
{
if (bSaving)
{
SerializeListOwnerPrefixFixup();
}
LinkedEntityManager <EntityType> Instance = new LinkedEntityManager <EntityType>();
XMLSerializable.SerializeFromXML <LinkedEntityManager <EntityType> >(GetEntityListFilename(), ref Instance, bSaving);
}
public static MonsterTestManager SwapActiveMonsterTestManager(MonsterTest NewTest)
{
if (Instance != null)
{
Instance.UnloadTests();
}
Instance = new MonsterTestManager();
EntityListFilename = NewTest.GetTestStateListFilename();
Owner = NewTest;
XMLSerializable.SerializeFromXML <MonsterTestManager>(NewTest.GetTestStateListFilename(), ref Instance, false);
return(Instance);
}
public void SerializeDictionaryObjectFloatEmbedded <KeyType>(string ListName, string KeyName, string ValueName, ref Dictionary <KeyType, float> DictionaryToSerialize)
where KeyType : XMLSerializable, new()
{
if (bReading)
{
bool isEmptyElement = InternalReader.IsEmptyElement;
InternalReader.ReadStartElement(ListName);
if (!isEmptyElement)
{
int CurrentDepth = InternalReader.Depth;
while (InternalReader.Depth >= CurrentDepth)
{
KeyType NewKey = new KeyType();
float NewValue = 0.0f;
XMLSerializable.SerializeFromXMLEmbedded <KeyType>(ref InternalReader, ref InternalWriter, ref NewKey);
NewKey = (KeyType)NewKey.ResolveIDPatching();
SerializeFloat(ValueName, ref NewValue);
if (NewKey == null)
{
NewKey = new KeyType();
}
DictionaryToSerialize.Add(NewKey, NewValue);
}
InternalReader.ReadEndElement();
}
}
else
{
InternalWriter.WriteStartElement(ListName);
if (DictionaryToSerialize.Count > 0)
{
foreach (KeyValuePair <KeyType, float> CurrentElement in DictionaryToSerialize)
{
KeyType RefCurrentKey = CurrentElement.Key;
XMLSerializable.SerializeFromXMLEmbedded <KeyType>(ref InternalReader, ref InternalWriter, ref RefCurrentKey);
float RefCurrentValue = CurrentElement.Value;
SerializeFloat(ValueName, ref RefCurrentValue);
}
}
InternalWriter.WriteEndElement();
}
}
protected override void SerializeEntityManager(bool bSaving)
{
if (bSaving)
{
// StringLibrary.SaveLibrary();
SerializeListOwnerPrefixFixup();
}
XMLSerializable.SerializeFromXML <MonsterTestManager>(GetEntityListFilename(), ref Instance, bSaving);
if (bSaving)
{
#if UNITY_EDITOR
if (Owner != null)
{
Owner.EditorSaveMonsterTest();
}
#endif // UNITY_EDITOR
}
}
public virtual XMLSerializable InspectorGUIDragAndDropField(string FieldLabel, XMLSerializable CurrentValue, DragAndDropHandler HandlerFunction, int Index = -1)
{
XMLSerializable NewObject = CurrentValue;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(FieldLabel);
GUILayout.Box(CurrentValue != null ? CurrentValue.EditorGetDisplayName() : "", GUILayout.ExpandWidth(true));
Rect DropBoxRect = GUILayoutUtility.GetLastRect();
if (DropBoxRect.Contains(Event.current.mousePosition))
{
EventType TypeOfEvent = Event.current.type;
if (TypeOfEvent == EventType.DragUpdated || TypeOfEvent == EventType.DragPerform)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (TypeOfEvent == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
NewObject = HandlerFunction(DragAndDrop.paths[0], Index);
if (NewObject == null)
{
NewObject = CurrentValue;
}
}
Event.current.Use();
}
}
EditorGUILayout.EndHorizontal();
return(NewObject);
}
public void SerializeListEmbedded <ListType>(string ListName, string ElementName, ref List <ListType> ListToSerialize) where ListType : XMLSerializable, new()
{
if (bReading)
{
bool isEmptyElement = InternalReader.IsEmptyElement;
InternalReader.ReadStartElement(ListName);
if (!isEmptyElement)
{
int CurrentDepth = InternalReader.Depth;
while (InternalReader.Depth >= CurrentDepth)
{
// InternalReader.ReadStartElement(ElementName);
ListType NewElement = new ListType();
XMLSerializable.SerializeFromXMLEmbedded <ListType>(ref InternalReader, ref InternalWriter, ref NewElement);
NewElement = (ListType)NewElement.ResolveIDPatching();
ListToSerialize.Add(NewElement);
// InternalReader.ReadEndElement();
}
InternalReader.ReadEndElement();
}
}
else
{
InternalWriter.WriteStartElement(ListName);
if (ListToSerialize.Count > 0)
{
foreach (ListType CurrentElement in ListToSerialize)
{
ListType RefCurrentElement = CurrentElement;
XMLSerializable.SerializeFromXMLEmbedded <ListType>(ref InternalReader, ref InternalWriter, ref RefCurrentElement);
}
}
InternalWriter.WriteEndElement();
}
}
protected virtual void SerializeEntity(string EntityFilename, ref EntityType ToSerialize, bool bSaving, XmlSerializer Serializer)
{
XMLSerializable.SerializeFromXML <EntityType>(GetDefaultEntityPath() + EntityFilename + ".xml", ref ToSerialize, bSaving, Serializer);
}
public void SetOwner(XMLSerializable NewOwner)
{
Owner = NewOwner;
}
public virtual void ListFixup <EntityType>(ref List <EntityLink <EntityType> > ListToFix, XMLSerializable Owner, string ListPrefix, LinkType ListType) where EntityType : LinkedEntity <EntityType>, new()
{
for (int CurrentEntry = 0; CurrentEntry < ListToFix.Count; ++CurrentEntry)
{
ListToFix[CurrentEntry].SetOwner(Owner);
ListToFix[CurrentEntry].ListPrefix = ListPrefix;
ListToFix[CurrentEntry].CurrentLinkType = ListType;
}
}
public void SerializeDictionaryStringEmbedded <ValueType>(string ListName, string KeyName, string ValueName, ref Dictionary <string, ValueType> DictionaryToSerialize)
where ValueType : XMLSerializable, new()
{
if (bReading)
{
bool isEmptyElement = InternalReader.IsEmptyElement;
InternalReader.ReadStartElement(ListName);
if (!isEmptyElement)
{
int CurrentDepth = InternalReader.Depth;
while (InternalReader.Depth >= CurrentDepth)
{
string NewKey = "";
SerializeString(KeyName, ref NewKey);
ValueType NewValue = new ValueType();
if (InternalReader.IsStartElement())
{
string NextElementType = InternalReader.Name;
object Temp = TypeUtils.GetNewObjectOfTypeString(NextElementType);
if (typeof(ValueType).IsAssignableFrom(Temp.GetType()))
{
NewValue = (ValueType)Temp;
}
bReadStartElement = true;
}
XMLSerializable.SerializeFromXMLEmbedded <ValueType>(ref InternalReader, ref InternalWriter, ref NewValue);
NewValue = (ValueType)NewValue.ResolveIDPatching();
if (NewKey == null)
{
NewKey = "";
}
if (NewValue == null)
{
NewValue = new ValueType();
}
DictionaryToSerialize.Add(NewKey, NewValue);
}
InternalReader.ReadEndElement();
}
}
else
{
InternalWriter.WriteStartElement(ListName);
if (DictionaryToSerialize.Count > 0)
{
foreach (KeyValuePair <string, ValueType> CurrentElement in DictionaryToSerialize)
{
string RefCurrentKey = CurrentElement.Key;
SerializeString(KeyName, ref RefCurrentKey);
ValueType RefCurrentValue = CurrentElement.Value;
XMLSerializable.SerializeFromXMLEmbedded <ValueType>(ref InternalReader, ref InternalWriter, ref RefCurrentValue);
}
}
InternalWriter.WriteEndElement();
}
}
public virtual void EditorSaveMonsterTest()
{
MonsterTest ThisInst = this;
XMLSerializable.SerializeFromXML <MonsterTest>(GetFullPathFromFilename(GetFilename()), ref ThisInst, true);
}
