public static T ItemFromXmlString <T>(string xmlContent, string filePath, bool resolveCrossRefs = true) where T : new()
{
if (resolveCrossRefs && DirectXmlCrossRefLoader.LoadingInProgress)
{
Log.Error("Cannot call ItemFromXmlString with resolveCrossRefs=true while loading is already in progress (forgot to resolve or clear cross refs from previous loading?).");
}
try
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xmlContent);
T result = DirectXmlToObject.ObjectFromXml <T>(xmlDocument.DocumentElement, doPostLoad: false);
if (resolveCrossRefs)
{
try
{
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors);
}
finally
{
DirectXmlCrossRefLoader.Clear();
}
}
return(result);
}
catch (Exception ex)
{
Log.Error("Exception loading file at " + filePath + ". Loading defaults instead. Exception was: " + ex.ToString());
return(new T());
}
}
public static T ItemFromXmlFile <T>(string filePath, bool resolveCrossRefs = true) where T : new()
{
if (resolveCrossRefs && DirectXmlCrossRefLoader.LoadingInProgress)
{
Log.Error("Cannot call ItemFromXmlFile with resolveCrossRefs=true while loading is already in progress.");
}
FileInfo fileInfo = new FileInfo(filePath);
if (!fileInfo.Exists)
{
return(Activator.CreateInstance <T>());
}
T result;
try
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(File.ReadAllText(fileInfo.FullName));
T t = DirectXmlToObject.ObjectFromXml <T>(xmlDocument.DocumentElement, false);
if (resolveCrossRefs)
{
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors);
}
result = t;
}
catch (Exception ex)
{
Log.Error("Exception loading file at " + filePath + ". Loading defaults instead. Exception was: " + ex.ToString());
result = Activator.CreateInstance <T>();
}
return(result);
}
private static List <T> ListFromXml <T>(XmlNode listRootNode) where T : new()
{
List <T> list = new List <T>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(T));
foreach (XmlNode xmlNode in listRootNode.ChildNodes)
{
if (DirectXmlToObject.ValidateListNode(xmlNode, listRootNode, typeof(T)))
{
if (flag)
{
DirectXmlCrossRefLoader.RegisterListWantsCrossRef <T>(list, xmlNode.InnerText);
}
else
{
list.Add(DirectXmlToObject.ObjectFromXml <T>(xmlNode, true));
}
}
}
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception loading list from XML: ",
ex,
"\nXML:\n",
listRootNode.OuterXml
}));
}
return(list);
}
public void LoadDataFromXmlCustom(XmlNode xmlRoot)
{
if (xmlRoot.ChildNodes.Count != 1)
{
Log.Error("Misconfigured SkillGain: " + xmlRoot.OuterXml, false);
return;
}
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(this, "skill", xmlRoot.Name);
this.xp = (int)ParseHelper.FromString(xmlRoot.FirstChild.Value, typeof(int));
}
public void LoadDataFromXmlCustom(XmlNode xmlRoot)
{
if (xmlRoot.ChildNodes.Count != 1)
{
Log.Error("Misconfigured ThingDefCountClass: " + xmlRoot.OuterXml);
return;
}
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(this, "thingDef", xmlRoot.Name);
count = ParseHelper.FromString <int>(xmlRoot.FirstChild.Value);
}
public void LoadDataFromXmlCustom(XmlNode xmlRoot)
{
if (xmlRoot.ChildNodes.Count != 1)
{
Log.Error("Misconfigured ThingOption: " + xmlRoot.OuterXml);
return;
}
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(this, "thingDef", xmlRoot.Name);
this.weight = (float)ParseHelper.FromString(xmlRoot.FirstChild.Value, typeof(float));
}
public void LoadDataFromXmlCustom(XmlNode xmlRoot)
{
if (xmlRoot.ChildNodes.Count != 1)
{
Log.Error("Misconfigured ThingDefCountRangeClass: " + xmlRoot.OuterXml, false);
return;
}
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(this, "thingDef", xmlRoot.Name);
this.countRange = (IntRange)ParseHelper.FromString(xmlRoot.FirstChild.Value, typeof(IntRange));
}
public static void LoadAllPlayData(bool recovering = false)
{
if (PlayDataLoader.loadedInt)
{
Log.Error("Loading play data when already loaded. Call ClearAllPlayData first.");
}
else
{
DeepProfiler.Start("LoadAllPlayData");
try
{
PlayDataLoader.DoPlayLoad();
}
catch (Exception arg)
{
if (!Prefs.ResetModsConfigOnCrash)
{
throw;
}
if (recovering)
{
Log.Warning("Could not recover from errors loading play data. Giving up.");
throw;
}
IEnumerable <ModMetaData> activeModsInLoadOrder = ModsConfig.ActiveModsInLoadOrder;
if (activeModsInLoadOrder.Count() == 1 && activeModsInLoadOrder.First().IsCoreMod)
{
throw;
}
Log.Warning("Caught exception while loading play data but there are active mods other than Core. Resetting mods config and trying again.\nThe exception was: " + arg);
try
{
PlayDataLoader.ClearAllPlayData();
}
catch
{
Log.Warning("Caught exception while recovering from errors and trying to clear all play data. Ignoring it.\nThe exception was: " + arg);
}
ModsConfig.Reset();
DirectXmlCrossRefLoader.Clear();
PlayDataLoader.LoadAllPlayData(true);
return;
}
finally
{
DeepProfiler.End();
}
PlayDataLoader.loadedInt = true;
if (recovering)
{
Log.Message("Successfully recovered from errors and loaded play data.");
DelayedErrorWindowRequest.Add("RecoveredFromErrorsText".Translate(), "RecoveredFromErrorsDialogTitle".Translate());
}
}
}
public override bool TryResolve(FailMode failReportMode)
{
failReportMode = FailMode.LogErrors;
bool flag = typeof(Def).IsAssignableFrom(typeof(K));
bool flag2 = typeof(Def).IsAssignableFrom(typeof(V));
List <Pair <K, V> > list = new List <Pair <K, V> >();
foreach (XmlNode xmlNode in this.wantedDictRefs)
{
XmlNode xmlNode2 = xmlNode["key"];
XmlNode xmlNode3 = xmlNode["value"];
K first;
if (flag)
{
first = DirectXmlCrossRefLoader.TryResolveDef <K>(xmlNode2.InnerText, failReportMode, this.debugWanterInfo);
}
else
{
first = DirectXmlToObject.ObjectFromXml <K>(xmlNode2, true);
}
V second;
if (flag2)
{
second = DirectXmlCrossRefLoader.TryResolveDef <V>(xmlNode3.InnerText, failReportMode, this.debugWanterInfo);
}
else
{
second = DirectXmlToObject.ObjectFromXml <V>(xmlNode3, true);
}
list.Add(new Pair <K, V>(first, second));
}
Dictionary <K, V> dictionary = (Dictionary <K, V>) this.wanter;
dictionary.Clear();
foreach (Pair <K, V> pair in list)
{
try
{
dictionary.Add(pair.First, pair.Second);
}
catch
{
Log.Error(string.Concat(new object[]
{
"Failed to load key/value pair: ",
pair.First,
", ",
pair.Second
}), false);
}
}
return(true);
}
private static List <T> ListFromXml <T>(XmlNode listRootNode) where T : new()
{
List <T> list = new List <T>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(T));
IEnumerator enumerator = listRootNode.ChildNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
XmlNode xmlNode = (XmlNode)obj;
if (DirectXmlToObject.ValidateListNode(xmlNode, listRootNode, typeof(T)))
{
if (flag)
{
DirectXmlCrossRefLoader.RegisterListWantsCrossRef <T>(list, xmlNode.InnerText, listRootNode.Name);
}
else
{
list.Add(DirectXmlToObject.ObjectFromXml <T>(xmlNode, true));
}
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception loading list from XML: ",
ex,
"\nXML:\n",
listRootNode.OuterXml
}), false);
}
return(list);
}
public void LoadDataFromXmlCustom(XmlNode xmlRoot)
{
if (xmlRoot.ChildNodes.Count != 1)
{
Log.Error("Misconfigured DefHyperlink: " + xmlRoot.OuterXml);
return;
}
Type typeInAnyAssembly = GenTypes.GetTypeInAnyAssembly(xmlRoot.Name);
if (typeInAnyAssembly == null)
{
Log.Error("Misconfigured DefHyperlink. Could not find def of type " + xmlRoot.Name);
}
else
{
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(this, "def", xmlRoot.FirstChild.Value, null, typeInAnyAssembly);
}
}
private static Dictionary <K, V> DictionaryFromXml <K, V>(XmlNode dictRootNode) where K : new() where V : new()
{
Dictionary <K, V> dictionary = new Dictionary <K, V>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(K));
bool flag2 = typeof(Def).IsAssignableFrom(typeof(V));
if (!flag && !flag2)
{
foreach (XmlNode xmlNode in dictRootNode.ChildNodes)
{
if (DirectXmlToObject.ValidateListNode(xmlNode, dictRootNode, typeof(KeyValuePair <K, V>)))
{
K key = DirectXmlToObject.ObjectFromXml <K>(xmlNode["key"], true);
V value = DirectXmlToObject.ObjectFromXml <V>(xmlNode["value"], true);
dictionary.Add(key, value);
}
}
}
else
{
foreach (XmlNode xmlNode2 in dictRootNode.ChildNodes)
{
if (DirectXmlToObject.ValidateListNode(xmlNode2, dictRootNode, typeof(KeyValuePair <K, V>)))
{
DirectXmlCrossRefLoader.RegisterDictionaryWantsCrossRef <K, V>(dictionary, xmlNode2);
}
}
}
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Malformed dictionary XML. Node: ",
dictRootNode.OuterXml,
".\n\nException: ",
ex
}));
}
return(dictionary);
}
private static List <T> ListFromXml <T>(XmlNode listRootNode) where T : new()
{
List <T> list = new List <T>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(T));
IEnumerator enumerator = listRootNode.ChildNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlNode xmlNode = (XmlNode)enumerator.Current;
if (ValidateListNode(xmlNode, listRootNode, typeof(T)))
{
if (flag)
{
DirectXmlCrossRefLoader.RegisterListWantsCrossRef(list, xmlNode.InnerText, listRootNode.Name);
}
else
{
list.Add(ObjectFromXml <T>(xmlNode, doPostLoad: true));
}
}
}
return(list);
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
catch (Exception ex)
{
Log.Error("Exception loading list from XML: " + ex + "\nXML:\n" + listRootNode.OuterXml);
return(list);
}
}
public override bool TryResolve(FailMode failReportMode)
{
bool flag = false;
for (int i = 0; i < this.defNames.Count; i++)
{
T t = DirectXmlCrossRefLoader.TryResolveDef <T>(this.defNames[i], failReportMode, this.debugWanterInfo);
if (t != null)
{
((List <T>) this.wanter).Add(t);
this.defNames.RemoveAt(i);
i--;
}
else
{
flag = true;
}
}
return(!flag);
}
private static List <T> ListFromXml <T>(XmlNode listRootNode)
{
List <T> list = new List <T>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(T));
foreach (XmlNode childNode in listRootNode.ChildNodes)
{
if (ValidateListNode(childNode, listRootNode, typeof(T)))
{
XmlAttribute xmlAttribute = childNode.Attributes["MayRequire"];
if (flag)
{
DirectXmlCrossRefLoader.RegisterListWantsCrossRef(list, childNode.InnerText, listRootNode.Name, xmlAttribute?.Value);
}
else
{
try
{
if (xmlAttribute == null || xmlAttribute.Value.NullOrEmpty() || ModsConfig.IsActive(xmlAttribute.Value))
{
list.Add(ObjectFromXml <T>(childNode, doPostLoad: true));
}
}
catch (Exception ex)
{
Log.Error("Exception loading list element from XML: " + ex + "\nXML:\n" + listRootNode.OuterXml);
}
}
}
}
return(list);
}
catch (Exception ex2)
{
Log.Error("Exception loading list from XML: " + ex2 + "\nXML:\n" + listRootNode.OuterXml);
return(list);
}
}
private static Dictionary <K, V> DictionaryFromXml <K, V>(XmlNode dictRootNode)
{
Dictionary <K, V> dictionary = new Dictionary <K, V>();
try
{
bool num = typeof(Def).IsAssignableFrom(typeof(K));
bool flag = typeof(Def).IsAssignableFrom(typeof(V));
if (!num && !flag)
{
foreach (XmlNode childNode in dictRootNode.ChildNodes)
{
if (ValidateListNode(childNode, dictRootNode, typeof(KeyValuePair <K, V>)))
{
K key = ObjectFromXml <K>(childNode["key"], doPostLoad: true);
V value = ObjectFromXml <V>(childNode["value"], doPostLoad: true);
dictionary.Add(key, value);
}
}
return(dictionary);
}
foreach (XmlNode childNode2 in dictRootNode.ChildNodes)
{
if (ValidateListNode(childNode2, dictRootNode, typeof(KeyValuePair <K, V>)))
{
DirectXmlCrossRefLoader.RegisterDictionaryWantsCrossRef(dictionary, childNode2, dictRootNode.Name);
}
}
return(dictionary);
}
catch (Exception ex)
{
Log.Error("Malformed dictionary XML. Node: " + dictRootNode.OuterXml + ".\n\nException: " + ex);
return(dictionary);
}
}
private static Dictionary <K, V> DictionaryFromXml <K, V>(XmlNode dictRootNode) where K : new()where V : new()
{
Dictionary <K, V> dictionary = new Dictionary <K, V>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(K));
bool flag2 = typeof(Def).IsAssignableFrom(typeof(V));
if (!flag && !flag2)
{
IEnumerator enumerator = dictRootNode.ChildNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlNode xmlNode = (XmlNode)enumerator.Current;
if (ValidateListNode(xmlNode, dictRootNode, typeof(KeyValuePair <K, V>)))
{
K key = ObjectFromXml <K>(xmlNode["key"], doPostLoad: true);
V value = ObjectFromXml <V>(xmlNode["value"], doPostLoad: true);
dictionary.Add(key, value);
}
}
return(dictionary);
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
IEnumerator enumerator2 = dictRootNode.ChildNodes.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
XmlNode xmlNode2 = (XmlNode)enumerator2.Current;
if (ValidateListNode(xmlNode2, dictRootNode, typeof(KeyValuePair <K, V>)))
{
DirectXmlCrossRefLoader.RegisterDictionaryWantsCrossRef(dictionary, xmlNode2, dictRootNode.Name);
}
}
return(dictionary);
}
finally
{
IDisposable disposable2;
if ((disposable2 = (enumerator2 as IDisposable)) != null)
{
disposable2.Dispose();
}
}
}
catch (Exception ex)
{
Log.Error("Malformed dictionary XML. Node: " + dictRootNode.OuterXml + ".\n\nException: " + ex);
return(dictionary);
}
}
private static void DoPlayLoad()
{
DeepProfiler.Start("GraphicDatabase.Clear()");
try
{
GraphicDatabase.Clear();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Load all active mods.");
try
{
LoadedModManager.LoadAllActiveMods();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Load language metadata.");
try
{
LanguageDatabase.InitAllMetadata();
}
finally
{
DeepProfiler.End();
}
LongEventHandler.SetCurrentEventText("LoadingDefs".Translate());
DeepProfiler.Start("Copy all Defs from mods to global databases.");
try
{
foreach (Type item in typeof(Def).AllSubclasses())
{
GenGeneric.InvokeStaticMethodOnGenericType(typeof(DefDatabase <>), item, "AddAllInMods");
}
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Resolve cross-references between non-implied Defs.");
try
{
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.Silent);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Rebind defs (early).");
try
{
DefOfHelper.RebindAllDefOfs(earlyTryMode: true);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("TKeySystem.BuildMappings()");
try
{
TKeySystem.BuildMappings();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Inject selected language data into game data (early pass).");
try
{
LanguageDatabase.activeLanguage.InjectIntoData_BeforeImpliedDefs();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Generate implied Defs (pre-resolve).");
try
{
DefGenerator.GenerateImpliedDefs_PreResolve();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Resolve cross-references between Defs made by the implied defs.");
try
{
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors);
}
finally
{
DirectXmlCrossRefLoader.Clear();
DeepProfiler.End();
}
DeepProfiler.Start("Rebind DefOfs (final).");
try
{
DefOfHelper.RebindAllDefOfs(earlyTryMode: false);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Other def binding, resetting and global operations (pre-resolve).");
try
{
PlayerKnowledgeDatabase.ReloadAndRebind();
LessonAutoActivator.Reset();
CostListCalculator.Reset();
Pawn.ResetStaticData();
PawnApparelGenerator.Reset();
RestUtility.Reset();
ThoughtUtility.Reset();
ThinkTreeKeyAssigner.Reset();
ThingCategoryNodeDatabase.FinalizeInit();
TrainableUtility.Reset();
HaulAIUtility.Reset();
GenConstruct.Reset();
MedicalCareUtility.Reset();
InspectPaneUtility.Reset();
GraphicDatabaseHeadRecords.Reset();
DateReadout.Reset();
ResearchProjectDef.GenerateNonOverlappingCoordinates();
BaseGen.Reset();
ResourceCounter.ResetDefs();
ApparelProperties.ResetStaticData();
WildPlantSpawner.ResetStaticData();
PawnGenerator.Reset();
TunnelHiveSpawner.ResetStaticData();
Hive.ResetStaticData();
ExpectationsUtility.Reset();
WealthWatcher.ResetStaticData();
SkillUI.Reset();
QuestNode_GetThingPlayerCanProduce.ResetStaticData();
Pawn_PsychicEntropyTracker.ResetStaticData();
ColoredText.ResetStaticData();
QuestNode_GetRandomNegativeGameCondition.ResetStaticData();
RoyalTitleUtility.ResetStaticData();
RewardsGenerator.ResetStaticData();
WorkGiver_FillFermentingBarrel.ResetStaticData();
WorkGiver_DoBill.ResetStaticData();
WorkGiver_InteractAnimal.ResetStaticData();
WorkGiver_Warden_DoExecution.ResetStaticData();
WorkGiver_GrowerSow.ResetStaticData();
WorkGiver_Miner.ResetStaticData();
WorkGiver_FixBrokenDownBuilding.ResetStaticData();
WorkGiver_ConstructDeliverResources.ResetStaticData();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Resolve references.");
try
{
DeepProfiler.Start("ThingCategoryDef resolver");
try
{
DefDatabase <ThingCategoryDef> .ResolveAllReferences();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("RecipeDef resolver");
try
{
DeepProfiler.enabled = false;
DefDatabase <RecipeDef> .ResolveAllReferences(onlyExactlyMyType : true, parallel : true);
DeepProfiler.enabled = true;
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Static resolver calls");
try
{
foreach (Type item2 in typeof(Def).AllSubclasses())
{
if (!(item2 == typeof(ThingDef)) && !(item2 == typeof(ThingCategoryDef)) && !(item2 == typeof(RecipeDef)))
{
GenGeneric.InvokeStaticMethodOnGenericType(typeof(DefDatabase <>), item2, "ResolveAllReferences", true, false);
}
}
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("ThingDef resolver");
try
{
DefDatabase <ThingDef> .ResolveAllReferences();
}
finally
{
DeepProfiler.End();
}
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Generate implied Defs (post-resolve).");
try
{
DefGenerator.GenerateImpliedDefs_PostResolve();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Other def binding, resetting and global operations (post-resolve).");
try
{
PawnWeaponGenerator.Reset();
BuildingProperties.FinalizeInit();
ThingSetMakerUtility.Reset();
}
finally
{
DeepProfiler.End();
}
if (Prefs.DevMode)
{
DeepProfiler.Start("Error check all defs.");
try
{
foreach (Type item3 in typeof(Def).AllSubclasses())
{
GenGeneric.InvokeStaticMethodOnGenericType(typeof(DefDatabase <>), item3, "ErrorCheckAllDefs");
}
}
finally
{
DeepProfiler.End();
}
}
LongEventHandler.SetCurrentEventText("Initializing".Translate());
DeepProfiler.Start("Load keyboard preferences.");
try
{
KeyPrefs.Init();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Short hash giving.");
try
{
ShortHashGiver.GiveAllShortHashes();
}
finally
{
DeepProfiler.End();
}
LongEventHandler.ExecuteWhenFinished(delegate
{
DeepProfiler.Start("Load backstories.");
try
{
BackstoryDatabase.ReloadAllBackstories();
}
finally
{
DeepProfiler.End();
}
});
LongEventHandler.ExecuteWhenFinished(delegate
{
DeepProfiler.Start("Inject selected language data into game data.");
try
{
LanguageDatabase.activeLanguage.InjectIntoData_AfterImpliedDefs();
GenLabel.ClearCache();
}
finally
{
DeepProfiler.End();
}
});
LongEventHandler.ExecuteWhenFinished(delegate
{
DeepProfiler.Start("Static constructor calls");
try
{
StaticConstructorOnStartupUtility.CallAll();
if (Prefs.DevMode)
{
StaticConstructorOnStartupUtility.ReportProbablyMissingAttributes();
}
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Garbage Collection");
try
{
AbstractFilesystem.ClearAllCache();
GC.Collect(int.MaxValue, GCCollectionMode.Forced);
}
finally
{
DeepProfiler.End();
}
});
}
private static Dictionary <K, V> DictionaryFromXml <K, V>(XmlNode dictRootNode) where K : new() where V : new()
{
Dictionary <K, V> dictionary = new Dictionary <K, V>();
try
{
bool flag = typeof(Def).IsAssignableFrom(typeof(K));
bool flag2 = typeof(Def).IsAssignableFrom(typeof(V));
if (!flag && !flag2)
{
IEnumerator enumerator = dictRootNode.ChildNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
XmlNode xmlNode = (XmlNode)obj;
if (DirectXmlToObject.ValidateListNode(xmlNode, dictRootNode, typeof(KeyValuePair <K, V>)))
{
K key = DirectXmlToObject.ObjectFromXml <K>(xmlNode["key"], true);
V value = DirectXmlToObject.ObjectFromXml <V>(xmlNode["value"], true);
dictionary.Add(key, value);
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
else
{
IEnumerator enumerator2 = dictRootNode.ChildNodes.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
object obj2 = enumerator2.Current;
XmlNode xmlNode2 = (XmlNode)obj2;
if (DirectXmlToObject.ValidateListNode(xmlNode2, dictRootNode, typeof(KeyValuePair <K, V>)))
{
DirectXmlCrossRefLoader.RegisterDictionaryWantsCrossRef <K, V>(dictionary, xmlNode2, dictRootNode.Name);
}
}
}
finally
{
IDisposable disposable2;
if ((disposable2 = (enumerator2 as IDisposable)) != null)
{
disposable2.Dispose();
}
}
}
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Malformed dictionary XML. Node: ",
dictRootNode.OuterXml,
".\n\nException: ",
ex
}), false);
}
return(dictionary);
}
public void LoadDataFromXmlCustom(XmlNode xmlRoot)
{
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(this, "skill", xmlRoot.Name);
this.minLevel = (int)ParseHelper.FromString(xmlRoot.FirstChild.Value, typeof(int));
}
public static T ObjectFromXml <T>(XmlNode xmlRoot, bool doPostLoad) where T : new()
{
MethodInfo methodInfo = DirectXmlToObject.CustomDataLoadMethodOf(typeof(T));
T result;
if (methodInfo != null)
{
xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot);
Type type = DirectXmlToObject.ClassTypeOf <T>(xmlRoot);
DirectXmlToObject.currentlyInstantiatingObjectOfType.Push(type);
T t;
try
{
t = (T)((object)Activator.CreateInstance(type));
}
finally
{
DirectXmlToObject.currentlyInstantiatingObjectOfType.Pop();
}
try
{
methodInfo.Invoke(t, new object[]
{
xmlRoot
});
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception in custom XML loader for ",
typeof(T),
". Node is:\n ",
xmlRoot.OuterXml,
"\n\nException is:\n ",
ex.ToString()
}), false);
t = default(T);
}
if (doPostLoad)
{
DirectXmlToObject.TryDoPostLoad(t);
}
result = t;
}
else if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.CDATA)
{
if (typeof(T) != typeof(string))
{
Log.Error("CDATA can only be used for strings. Bad xml: " + xmlRoot.OuterXml, false);
result = default(T);
}
else
{
result = (T)((object)xmlRoot.FirstChild.Value);
}
}
else if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.Text)
{
try
{
return((T)((object)ParseHelper.FromString(xmlRoot.InnerText, typeof(T))));
}
catch (Exception ex2)
{
Log.Error(string.Concat(new object[]
{
"Exception parsing ",
xmlRoot.OuterXml,
" to type ",
typeof(T),
": ",
ex2
}), false);
}
result = default(T);
}
else if (Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
{
List <T> list = DirectXmlToObject.ListFromXml <T>(xmlRoot);
int num = 0;
foreach (T t2 in list)
{
int num2 = (int)((object)t2);
num |= num2;
}
result = (T)((object)num);
}
else if (typeof(T).HasGenericDefinition(typeof(List <>)))
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ListFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
Type[] genericArguments = typeof(T).GetGenericArguments();
MethodInfo methodInfo2 = method.MakeGenericMethod(genericArguments);
object[] parameters = new object[]
{
xmlRoot
};
object obj = methodInfo2.Invoke(null, parameters);
result = (T)((object)obj);
}
else if (typeof(T).HasGenericDefinition(typeof(Dictionary <, >)))
{
MethodInfo method2 = typeof(DirectXmlToObject).GetMethod("DictionaryFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
Type[] genericArguments2 = typeof(T).GetGenericArguments();
MethodInfo methodInfo3 = method2.MakeGenericMethod(genericArguments2);
object[] parameters2 = new object[]
{
xmlRoot
};
object obj2 = methodInfo3.Invoke(null, parameters2);
result = (T)((object)obj2);
}
else
{
if (!xmlRoot.HasChildNodes)
{
if (typeof(T) == typeof(string))
{
return((T)((object)""));
}
XmlAttribute xmlAttribute = xmlRoot.Attributes["IsNull"];
if (xmlAttribute != null && xmlAttribute.Value.ToUpperInvariant() == "TRUE")
{
return(default(T));
}
if (typeof(T).IsGenericType)
{
Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(List <>) || genericTypeDefinition == typeof(HashSet <>) || genericTypeDefinition == typeof(Dictionary <, >))
{
return(Activator.CreateInstance <T>());
}
}
}
xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot);
Type type2 = DirectXmlToObject.ClassTypeOf <T>(xmlRoot);
Type type3 = Nullable.GetUnderlyingType(type2) ?? type2;
DirectXmlToObject.currentlyInstantiatingObjectOfType.Push(type3);
T t3;
try
{
t3 = (T)((object)Activator.CreateInstance(type3));
}
finally
{
DirectXmlToObject.currentlyInstantiatingObjectOfType.Pop();
}
List <string> list2 = null;
if (xmlRoot.ChildNodes.Count > 1)
{
list2 = new List <string>();
}
for (int i = 0; i < xmlRoot.ChildNodes.Count; i++)
{
XmlNode xmlNode = xmlRoot.ChildNodes[i];
if (!(xmlNode is XmlComment))
{
if (xmlRoot.ChildNodes.Count > 1)
{
if (list2.Contains(xmlNode.Name))
{
Log.Error(string.Concat(new object[]
{
"XML ",
typeof(T),
" defines the same field twice: ",
xmlNode.Name,
".\n\nField contents: ",
xmlNode.InnerText,
".\n\nWhole XML:\n\n",
xmlRoot.OuterXml
}), false);
}
else
{
list2.Add(xmlNode.Name);
}
}
FieldInfo fieldInfo = DirectXmlToObject.GetFieldInfoForType(t3.GetType(), xmlNode.Name, xmlRoot);
if (fieldInfo == null)
{
foreach (FieldInfo fieldInfo2 in t3.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
foreach (object obj3 in fieldInfo2.GetCustomAttributes(typeof(LoadAliasAttribute), true))
{
string alias = ((LoadAliasAttribute)obj3).alias;
if (alias.EqualsIgnoreCase(xmlNode.Name))
{
fieldInfo = fieldInfo2;
break;
}
}
if (fieldInfo != null)
{
break;
}
}
}
if (fieldInfo == null)
{
bool flag = false;
foreach (object obj4 in t3.GetType().GetCustomAttributes(typeof(IgnoreSavedElementAttribute), true))
{
string elementToIgnore = ((IgnoreSavedElementAttribute)obj4).elementToIgnore;
if (string.Equals(elementToIgnore, xmlNode.Name, StringComparison.OrdinalIgnoreCase))
{
flag = true;
break;
}
}
if (!flag)
{
Log.Error(string.Concat(new string[]
{
"XML error: ",
xmlNode.OuterXml,
" doesn't correspond to any field in type ",
t3.GetType().Name,
". Context: ",
xmlRoot.OuterXml
}), false);
}
}
else if (typeof(Def).IsAssignableFrom(fieldInfo.FieldType))
{
if (xmlNode.InnerText.NullOrEmpty())
{
fieldInfo.SetValue(t3, null);
}
else
{
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(t3, fieldInfo, xmlNode.InnerText);
}
}
else
{
object value = null;
try
{
MethodInfo method3 = typeof(DirectXmlToObject).GetMethod("ObjectFromXml", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo methodInfo4 = method3.MakeGenericMethod(new Type[]
{
fieldInfo.FieldType
});
value = methodInfo4.Invoke(null, new object[]
{
xmlNode,
doPostLoad
});
}
catch (Exception ex3)
{
Log.Error("Exception loading from " + xmlNode.ToString() + ": " + ex3.ToString(), false);
goto IL_863;
}
if (!typeof(T).IsValueType)
{
fieldInfo.SetValue(t3, value);
}
else
{
object obj5 = t3;
fieldInfo.SetValue(obj5, value);
t3 = (T)((object)obj5);
}
}
}
IL_863 :;
}
if (doPostLoad)
{
DirectXmlToObject.TryDoPostLoad(t3);
}
result = t3;
}
return(result);
}
public static T ObjectFromXml <T>(XmlNode xmlRoot, bool doPostLoad)
{
XmlAttribute xmlAttribute = xmlRoot.Attributes["IsNull"];
if (xmlAttribute != null && xmlAttribute.Value.ToUpperInvariant() == "TRUE")
{
return(default(T));
}
MethodInfo methodInfo = CustomDataLoadMethodOf(typeof(T));
if (methodInfo != null)
{
xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot);
Type type = ClassTypeOf <T>(xmlRoot);
currentlyInstantiatingObjectOfType.Push(type);
T val;
try
{
val = (T)Activator.CreateInstance(type);
}
finally
{
currentlyInstantiatingObjectOfType.Pop();
}
try
{
methodInfo.Invoke(val, new object[1]
{
xmlRoot
});
}
catch (Exception ex)
{
Log.Error(string.Concat("Exception in custom XML loader for ", typeof(T), ". Node is:\n ", xmlRoot.OuterXml, "\n\nException is:\n ", ex.ToString()));
val = default(T);
}
if (doPostLoad)
{
TryDoPostLoad(val);
}
return(val);
}
if (typeof(ISlateRef).IsAssignableFrom(typeof(T)))
{
try
{
return(ParseHelper.FromString <T>(InnerTextWithReplacedNewlinesOrXML(xmlRoot)));
}
catch (Exception ex2)
{
Log.Error(string.Concat("Exception parsing ", xmlRoot.OuterXml, " to type ", typeof(T), ": ", ex2));
}
return(default(T));
}
if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.CDATA)
{
if (typeof(T) != typeof(string))
{
Log.Error("CDATA can only be used for strings. Bad xml: " + xmlRoot.OuterXml);
return(default(T));
}
return((T)(object)xmlRoot.FirstChild.Value);
}
if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.Text)
{
try
{
return(ParseHelper.FromString <T>(xmlRoot.InnerText));
}
catch (Exception ex3)
{
Log.Error(string.Concat("Exception parsing ", xmlRoot.OuterXml, " to type ", typeof(T), ": ", ex3));
}
return(default(T));
}
if (Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
{
List <T> list = ListFromXml <T>(xmlRoot);
int num = 0;
foreach (T item in list)
{
int num2 = (int)(object)item;
num |= num2;
}
return((T)(object)num);
}
if (typeof(T).HasGenericDefinition(typeof(List <>)))
{
Func <XmlNode, object> value = null;
if (!listFromXmlMethods.TryGetValue(typeof(T), out value))
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ListFromXmlReflection", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
Type[] genericArguments = typeof(T).GetGenericArguments();
value = (Func <XmlNode, object>)Delegate.CreateDelegate(typeof(Func <XmlNode, object>), method.MakeGenericMethod(genericArguments));
listFromXmlMethods.Add(typeof(T), value);
}
return((T)value(xmlRoot));
}
if (typeof(T).HasGenericDefinition(typeof(Dictionary <, >)))
{
Func <XmlNode, object> value2 = null;
if (!dictionaryFromXmlMethods.TryGetValue(typeof(T), out value2))
{
MethodInfo method2 = typeof(DirectXmlToObject).GetMethod("DictionaryFromXmlReflection", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
Type[] genericArguments2 = typeof(T).GetGenericArguments();
value2 = (Func <XmlNode, object>)Delegate.CreateDelegate(typeof(Func <XmlNode, object>), method2.MakeGenericMethod(genericArguments2));
dictionaryFromXmlMethods.Add(typeof(T), value2);
}
return((T)value2(xmlRoot));
}
if (!xmlRoot.HasChildNodes)
{
if (typeof(T) == typeof(string))
{
return((T)(object)"");
}
XmlAttribute xmlAttribute2 = xmlRoot.Attributes["IsNull"];
if (xmlAttribute2 != null && xmlAttribute2.Value.ToUpperInvariant() == "TRUE")
{
return(default(T));
}
if (typeof(T).IsGenericType)
{
Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(List <>) || genericTypeDefinition == typeof(HashSet <>) || genericTypeDefinition == typeof(Dictionary <, >))
{
return(Activator.CreateInstance <T>());
}
}
}
xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot);
Type type2 = ClassTypeOf <T>(xmlRoot);
Type type3 = Nullable.GetUnderlyingType(type2) ?? type2;
currentlyInstantiatingObjectOfType.Push(type3);
T val2;
try
{
val2 = (T)Activator.CreateInstance(type3);
}
finally
{
currentlyInstantiatingObjectOfType.Pop();
}
HashSet <string> hashSet = null;
if (xmlRoot.ChildNodes.Count > 1)
{
hashSet = new HashSet <string>();
}
for (int i = 0; i < xmlRoot.ChildNodes.Count; i++)
{
XmlNode xmlNode = xmlRoot.ChildNodes[i];
if (xmlNode is XmlComment)
{
continue;
}
if (xmlRoot.ChildNodes.Count > 1)
{
if (hashSet.Contains(xmlNode.Name))
{
Log.Error(string.Concat("XML ", typeof(T), " defines the same field twice: ", xmlNode.Name, ".\n\nField contents: ", xmlNode.InnerText, ".\n\nWhole XML:\n\n", xmlRoot.OuterXml));
}
else
{
hashSet.Add(xmlNode.Name);
}
}
FieldInfo value3 = null;
DeepProfiler.Start("GetFieldInfoForType");
try
{
value3 = GetFieldInfoForType(val2.GetType(), xmlNode.Name, xmlRoot);
}
finally
{
DeepProfiler.End();
}
if (value3 == null)
{
DeepProfiler.Start("Field search");
try
{
FieldAliasCache key = new FieldAliasCache(val2.GetType(), xmlNode.Name);
if (!fieldAliases.TryGetValue(key, out value3))
{
FieldInfo[] fields = val2.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo fieldInfo in fields)
{
object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(LoadAliasAttribute), inherit: true);
for (int k = 0; k < customAttributes.Length; k++)
{
if (((LoadAliasAttribute)customAttributes[k]).alias.EqualsIgnoreCase(xmlNode.Name))
{
value3 = fieldInfo;
break;
}
}
if (value3 != null)
{
break;
}
}
fieldAliases.Add(key, value3);
}
}
finally
{
DeepProfiler.End();
}
}
if (value3 != null && value3.TryGetAttribute <UnsavedAttribute>() != null && !value3.TryGetAttribute <UnsavedAttribute>().allowLoading)
{
Log.Error("XML error: " + xmlNode.OuterXml + " corresponds to a field in type " + val2.GetType().Name + " which has an Unsaved attribute. Context: " + xmlRoot.OuterXml);
}
else if (value3 == null)
{
DeepProfiler.Start("Field search 2");
try
{
bool flag = false;
XmlAttribute xmlAttribute3 = xmlNode.Attributes?["IgnoreIfNoMatchingField"];
if (xmlAttribute3 != null && xmlAttribute3.Value.ToUpperInvariant() == "TRUE")
{
flag = true;
}
else
{
object[] customAttributes = val2.GetType().GetCustomAttributes(typeof(IgnoreSavedElementAttribute), inherit: true);
for (int j = 0; j < customAttributes.Length; j++)
{
if (string.Equals(((IgnoreSavedElementAttribute)customAttributes[j]).elementToIgnore, xmlNode.Name, StringComparison.OrdinalIgnoreCase))
{
flag = true;
break;
}
}
}
if (!flag)
{
Log.Error("XML error: " + xmlNode.OuterXml + " doesn't correspond to any field in type " + val2.GetType().Name + ". Context: " + xmlRoot.OuterXml);
}
}
finally
{
DeepProfiler.End();
}
}
else if (typeof(Def).IsAssignableFrom(value3.FieldType))
{
if (xmlNode.InnerText.NullOrEmpty())
{
value3.SetValue(val2, null);
continue;
}
XmlAttribute xmlAttribute4 = xmlNode.Attributes["MayRequire"];
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(val2, value3, xmlNode.InnerText, xmlAttribute4?.Value.ToLower());
}
else
{
object obj = null;
try
{
obj = GetObjectFromXmlMethod(value3.FieldType)(xmlNode, doPostLoad);
}
catch (Exception ex4)
{
Log.Error("Exception loading from " + xmlNode.ToString() + ": " + ex4.ToString());
continue;
}
if (!typeof(T).IsValueType)
{
value3.SetValue(val2, obj);
continue;
}
object obj2 = val2;
value3.SetValue(obj2, obj);
val2 = (T)obj2;
}
}
if (doPostLoad)
{
TryDoPostLoad(val2);
}
return(val2);
}
public static object Convert(object obj, Type to, object defaultValue)
{
if (obj == null)
{
return(defaultValue);
}
if (to.IsAssignableFrom(obj.GetType()))
{
return(obj);
}
if (to == typeof(string))
{
return(obj.ToString());
}
string text = obj as string;
if (text != null && !to.IsPrimitive && ParseHelper.CanParse(to, (string)obj))
{
if (text == "")
{
return(defaultValue);
}
return(ParseHelper.FromString(text, to));
}
if (text != null && typeof(Def).IsAssignableFrom(to))
{
if (text == "")
{
return(defaultValue);
}
return(GenDefDatabase.GetDef(to, text));
}
if (text != null && to == typeof(Faction))
{
if (text == "")
{
return(defaultValue);
}
List <Faction> allFactionsListForReading = Find.FactionManager.AllFactionsListForReading;
for (int i = 0; i < allFactionsListForReading.Count; i++)
{
if (allFactionsListForReading[i].GetUniqueLoadID() == text)
{
return(allFactionsListForReading[i]);
}
}
for (int j = 0; j < allFactionsListForReading.Count; j++)
{
if (allFactionsListForReading[j].HasName && allFactionsListForReading[j].Name == text)
{
return(allFactionsListForReading[j]);
}
}
for (int k = 0; k < allFactionsListForReading.Count; k++)
{
if (allFactionsListForReading[k].def.defName == text)
{
return(allFactionsListForReading[k]);
}
}
return(defaultValue);
}
if (CanConvertBetweenDataTypes(obj.GetType(), to))
{
return(ConvertBetweenDataTypes(obj, to));
}
if (IsXml(obj) && !to.IsPrimitive)
{
try
{
Type type = to;
if (type == typeof(IEnumerable))
{
type = typeof(List <string>);
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable <>) && type.GetGenericArguments().Length >= 1)
{
type = typeof(List <>).MakeGenericType(type.GetGenericArguments()[0]);
}
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\n" + text + "\n</root>");
object result = DirectXmlToObject.GetObjectFromXmlMethod(type)(xmlDocument.DocumentElement, arg2 : true);
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors);
return(result);
}
finally
{
DirectXmlCrossRefLoader.Clear();
}
}
if (to.IsGenericType && (to.GetGenericTypeDefinition() == typeof(IEnumerable <>) || to.GetGenericTypeDefinition() == typeof(List <>)) && to.GetGenericArguments().Length >= 1 && (!(to.GetGenericArguments()[0] == typeof(string)) || !(obj is string)))
{
IEnumerable enumerable = obj as IEnumerable;
if (enumerable != null)
{
Type type2 = to.GetGenericArguments()[0];
bool flag = true;
foreach (object item in enumerable)
{
if (!CanConvert(item, type2))
{
flag = false;
break;
}
}
if (flag)
{
IList list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(type2));
{
foreach (object item2 in enumerable)
{
list.Add(Convert(item2, type2));
}
return(list);
}
}
}
}
if (obj is IEnumerable && !(obj is string))
{
IEnumerable e = (IEnumerable)obj;
if (GenCollection.Count_EnumerableBase(e) == 1)
{
object obj2 = GenCollection.FirstOrDefault_EnumerableBase(e);
if (CanConvert(obj2, to))
{
return(Convert(obj2, to));
}
}
}
if (typeof(IList).IsAssignableFrom(to))
{
IList list2 = (IList)Activator.CreateInstance(to);
Type[] genericArguments = to.GetGenericArguments();
if (genericArguments.Length >= 1)
{
list2.Add(Convert(obj, genericArguments[0]));
}
else
{
list2.Add(obj);
}
return(list2);
}
if (to == typeof(IEnumerable))
{
return(Gen.YieldSingleNonGeneric(obj));
}
if (to.IsGenericType && to.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
Type[] genericArguments2 = to.GetGenericArguments();
if (genericArguments2.Length >= 1)
{
IList obj3 = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(genericArguments2[0]));
obj3.Add(Convert(obj, genericArguments2[0]));
return(obj3);
}
return(Gen.YieldSingleNonGeneric(obj));
}
IConvertible convertible = obj as IConvertible;
if (convertible == null)
{
return(defaultValue);
}
try
{
return(ConvertToPrimitive(convertible, to, defaultValue));
}
catch (FormatException)
{
return(defaultValue);
}
}
public override bool TryResolve(FailMode failReportMode)
{
failReportMode = FailMode.LogErrors;
bool flag = typeof(Def).IsAssignableFrom(typeof(K));
bool flag2 = typeof(Def).IsAssignableFrom(typeof(V));
List <Pair <K, V> > list = new List <Pair <K, V> >();
foreach (XmlNode wantedDictRef in this.wantedDictRefs)
{
XmlNode xmlNode = wantedDictRef["key"];
XmlNode xmlNode2 = wantedDictRef["value"];
K first = (!flag) ? DirectXmlToObject.ObjectFromXml <K>(xmlNode, true) : DirectXmlCrossRefLoader.TryResolveDef <K>(xmlNode.InnerText, failReportMode);
V second = (!flag2) ? DirectXmlToObject.ObjectFromXml <V>(xmlNode2, true) : DirectXmlCrossRefLoader.TryResolveDef <V>(xmlNode2.InnerText, failReportMode);
list.Add(new Pair <K, V>(first, second));
}
Dictionary <K, V> dictionary = (Dictionary <K, V>)base.wanter;
dictionary.Clear();
foreach (Pair <K, V> item in list)
{
try
{
dictionary.Add(item.First, item.Second);
}
catch
{
Log.Error("Failed to load key/value pair: " + item.First + ", " + item.Second);
}
}
return(true);
}
public static T ObjectFromXml <T>(XmlNode xmlRoot, bool doPostLoad) where T : new()
{
MethodInfo methodInfo = DirectXmlToObject.CustomDataLoadMethodOf(typeof(T));
if (methodInfo != null)
{
xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot);
Type type = DirectXmlToObject.ClassTypeOf <T>(xmlRoot);
T val = (T)Activator.CreateInstance(type);
try
{
methodInfo.Invoke(val, new object[1]
{
xmlRoot
});
}
catch (Exception ex)
{
Log.Error("Exception in custom XML loader for " + typeof(T) + ". Node is:\n " + xmlRoot.OuterXml + "\n\nException is:\n " + ex.ToString());
val = default(T);
}
if (doPostLoad)
{
DirectXmlToObject.TryDoPostLoad(val);
}
return(val);
}
if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.CDATA)
{
if (typeof(T) != typeof(string))
{
Log.Error("CDATA can only be used for strings. Bad xml: " + xmlRoot.OuterXml);
return(default(T));
}
return((T)(object)xmlRoot.FirstChild.Value);
}
if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.Text)
{
try
{
return((T)ParseHelper.FromString(xmlRoot.InnerText, typeof(T)));
}
catch (Exception ex2)
{
Log.Error("Exception parsing " + xmlRoot.OuterXml + " to type " + typeof(T) + ": " + ex2);
}
return(default(T));
}
if (Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
{
List <T> list = DirectXmlToObject.ListFromXml <T>(xmlRoot);
int num = 0;
foreach (T item in list)
{
int num2 = (int)(object)item;
num |= num2;
}
return((T)(object)num);
}
if (typeof(T).HasGenericDefinition(typeof(List <>)))
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ListFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
Type[] genericArguments = typeof(T).GetGenericArguments();
MethodInfo methodInfo2 = method.MakeGenericMethod(genericArguments);
object[] parameters = new object[1]
{
xmlRoot
};
object obj = methodInfo2.Invoke(null, parameters);
return((T)obj);
}
if (typeof(T).HasGenericDefinition(typeof(Dictionary <, >)))
{
MethodInfo method2 = typeof(DirectXmlToObject).GetMethod("DictionaryFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
Type[] genericArguments2 = typeof(T).GetGenericArguments();
MethodInfo methodInfo3 = method2.MakeGenericMethod(genericArguments2);
object[] parameters2 = new object[1]
{
xmlRoot
};
object obj2 = methodInfo3.Invoke(null, parameters2);
return((T)obj2);
}
if (!xmlRoot.HasChildNodes)
{
if (typeof(T) == typeof(string))
{
return((T)(object)string.Empty);
}
XmlAttribute xmlAttribute = xmlRoot.Attributes["IsNull"];
if (xmlAttribute != null && xmlAttribute.Value.ToUpperInvariant() == "TRUE")
{
return(default(T));
}
if (typeof(T).IsGenericType)
{
Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition();
if (genericTypeDefinition != typeof(List <>) && genericTypeDefinition != typeof(HashSet <>) && genericTypeDefinition != typeof(Dictionary <, >))
{
goto IL_03ed;
}
return(new T());
}
}
goto IL_03ed;
IL_03ed:
xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot);
Type type2 = DirectXmlToObject.ClassTypeOf <T>(xmlRoot);
T val2 = (T)Activator.CreateInstance(type2);
List <string> list2 = null;
if (xmlRoot.ChildNodes.Count > 1)
{
list2 = new List <string>();
}
for (int i = 0; i < xmlRoot.ChildNodes.Count; i++)
{
XmlNode xmlNode = xmlRoot.ChildNodes[i];
if (!(xmlNode is XmlComment))
{
if (xmlRoot.ChildNodes.Count > 1)
{
if (list2.Contains(xmlNode.Name))
{
Log.Error("XML " + typeof(T) + " defines the same field twice: " + xmlNode.Name + ".\n\nField contents: " + xmlNode.InnerText + ".\n\nWhole XML:\n\n" + xmlRoot.OuterXml);
}
else
{
list2.Add(xmlNode.Name);
}
}
FieldInfo fieldInfo = DirectXmlToObject.GetFieldInfoForType(val2.GetType(), xmlNode.Name, xmlRoot);
if (fieldInfo == null)
{
FieldInfo[] fields = val2.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num3 = 0;
while (num3 < fields.Length)
{
FieldInfo fieldInfo2 = fields[num3];
object[] customAttributes = fieldInfo2.GetCustomAttributes(typeof(LoadAliasAttribute), true);
foreach (object obj3 in customAttributes)
{
string alias = ((LoadAliasAttribute)obj3).alias;
if (alias.EqualsIgnoreCase(xmlNode.Name))
{
fieldInfo = fieldInfo2;
break;
}
}
if (fieldInfo == null)
{
num3++;
continue;
}
break;
}
}
if (fieldInfo == null)
{
bool flag = false;
object[] customAttributes2 = val2.GetType().GetCustomAttributes(typeof(IgnoreSavedElementAttribute), true);
foreach (object obj4 in customAttributes2)
{
string elementToIgnore = ((IgnoreSavedElementAttribute)obj4).elementToIgnore;
if (string.Equals(elementToIgnore, xmlNode.Name, StringComparison.OrdinalIgnoreCase))
{
flag = true;
break;
}
}
if (!flag)
{
Log.Error("XML error: " + xmlNode.OuterXml + " doesn't correspond to any field in type " + val2.GetType().Name + ".");
}
}
else if (typeof(Def).IsAssignableFrom(fieldInfo.FieldType))
{
if (xmlNode.InnerText.NullOrEmpty())
{
fieldInfo.SetValue(val2, null);
}
else
{
DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(val2, fieldInfo, xmlNode.InnerText);
}
}
else
{
object obj5 = null;
try
{
MethodInfo method3 = typeof(DirectXmlToObject).GetMethod("ObjectFromXml", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo methodInfo4 = method3.MakeGenericMethod(fieldInfo.FieldType);
obj5 = methodInfo4.Invoke(null, new object[2]
{
xmlNode,
doPostLoad
});
}
catch (Exception ex3)
{
Log.Error("Exception loading from " + xmlNode.ToString() + ": " + ex3.ToString());
continue;
}
if (!typeof(T).IsValueType)
{
fieldInfo.SetValue(val2, obj5);
}
else
{
object obj6 = val2;
fieldInfo.SetValue(obj6, obj5);
val2 = (T)obj6;
}
}
}
}
if (doPostLoad)
{
DirectXmlToObject.TryDoPostLoad(val2);
}
return(val2);
}
private static void DoPlayLoad()
{
GraphicDatabase.Clear();
DeepProfiler.Start("Load all active mods.");
try
{
LoadedModManager.LoadAllActiveMods();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Load language metadata.");
try
{
LanguageDatabase.LoadAllMetadata();
}
finally
{
DeepProfiler.End();
}
LongEventHandler.SetCurrentEventText("LoadingDefs".Translate());
DeepProfiler.Start("Copy all Defs from mods to global databases.");
try
{
foreach (Type item in typeof(Def).AllSubclasses())
{
GenGeneric.InvokeStaticMethodOnGenericType(typeof(DefDatabase <>), item, "AddAllInMods");
}
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Resolve cross-references between non-implied Defs.");
try
{
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.Silent);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Rebind defs (early).");
try
{
DefOfHelper.RebindAllDefOfs(true);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Generate implied Defs (pre-resolve).");
try
{
DefGenerator.GenerateImpliedDefs_PreResolve();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Resolve cross-references between Defs made by the implied defs.");
try
{
DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Rebind DefOfs (final).");
try
{
DefOfHelper.RebindAllDefOfs(false);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Other def binding, resetting and global operations.");
try
{
PlayerKnowledgeDatabase.ReloadAndRebind();
LessonAutoActivator.Reset();
CostListCalculator.Reset();
PawnApparelGenerator.Reset();
RestUtility.Reset();
ThoughtUtility.Reset();
PawnWeaponGenerator.Reset();
ThinkTreeKeyAssigner.Reset();
ThingCategoryNodeDatabase.FinalizeInit();
TrainableUtility.Reset();
HaulAIUtility.Reset();
GenConstruct.Reset();
WorkGiver_FillFermentingBarrel.Reset();
WorkGiver_DoBill.Reset();
Pawn.Reset();
WorkGiver_InteractAnimal.Reset();
WorkGiver_Warden_DoExecution.Reset();
WorkGiver_GrowerSow.Reset();
WorkGiver_Miner.Reset();
MedicalCareUtility.Reset();
InspectPaneUtility.Reset();
GraphicDatabaseHeadRecords.Reset();
DateReadout.Reset();
ResearchProjectDef.GenerateNonOverlappingCoordinates();
WorkGiver_FixBrokenDownBuilding.CacheTranslations();
ItemCollectionGeneratorUtility.Reset();
BaseGen.Reset();
HealthUtility.Reset();
ResourceCounter.ResetDefs();
WildSpawner.Reset();
ApparelProperties.Reset();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Resolve references.");
try
{
foreach (Type item2 in typeof(Def).AllSubclasses())
{
if (item2 != typeof(ThingDef))
{
GenGeneric.InvokeStaticMethodOnGenericType(typeof(DefDatabase <>), item2, "ResolveAllReferences", true);
}
}
DefDatabase <ThingDef> .ResolveAllReferences(true);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Generate implied Defs (post-resolve).");
try
{
DefGenerator.GenerateImpliedDefs_PostResolve();
}
finally
{
DeepProfiler.End();
}
if (Prefs.DevMode)
{
DeepProfiler.Start("Error check all defs.");
try
{
foreach (Type item3 in typeof(Def).AllSubclasses())
{
GenGeneric.InvokeStaticMethodOnGenericType(typeof(DefDatabase <>), item3, "ErrorCheckAllDefs");
}
}
finally
{
DeepProfiler.End();
}
}
LongEventHandler.SetCurrentEventText("Initializing".Translate());
DeepProfiler.Start("Load keyboard preferences.");
try
{
KeyPrefs.Init();
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("Short hash giving.");
try
{
ShortHashGiver.GiveAllShortHashes();
}
finally
{
DeepProfiler.End();
}
LongEventHandler.ExecuteWhenFinished(delegate
{
DeepProfiler.Start("Load backstories.");
try
{
BackstoryDatabase.ReloadAllBackstories();
}
finally
{
DeepProfiler.End();
}
});
LongEventHandler.ExecuteWhenFinished(delegate
{
DeepProfiler.Start("Inject selected language data into game data.");
try
{
LanguageDatabase.activeLanguage.InjectIntoData();
GenLabel.ClearCache();
}
finally
{
DeepProfiler.End();
}
});
LongEventHandler.ExecuteWhenFinished(delegate
{
StaticConstructorOnStartupUtility.CallAll();
if (Prefs.DevMode)
{
StaticConstructorOnStartupUtility.ReportProbablyMissingAttributes();
}
});
}