public static void ParseAndProcessXML(XmlDocument xmlDoc, Dictionary <XmlNode, LoadableXmlAsset> assetlookup)
{
XmlNodeList childNodes = xmlDoc.DocumentElement.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
if (childNodes[i].NodeType == XmlNodeType.Element)
{
LoadableXmlAsset loadableXmlAsset = assetlookup.TryGetValue(childNodes[i], null);
XmlInheritance.TryRegister(childNodes[i], (loadableXmlAsset == null) ? null : loadableXmlAsset.mod);
}
}
XmlInheritance.Resolve();
DefPackage defPackage = new DefPackage("Unknown", string.Empty);
ModContentPack modContentPack = LoadedModManager.runningMods.FirstOrDefault <ModContentPack>();
modContentPack.AddDefPackage(defPackage);
foreach (XmlNode xmlNode in xmlDoc.DocumentElement.ChildNodes)
{
LoadableXmlAsset loadableXmlAsset2 = assetlookup.TryGetValue(xmlNode, null);
DefPackage defPackage2 = (loadableXmlAsset2 == null) ? defPackage : loadableXmlAsset2.defPackage;
Def def = DirectXmlLoader.DefFromNode(xmlNode, loadableXmlAsset2);
if (def != null)
{
def.modContentPack = ((loadableXmlAsset2 == null) ? modContentPack : loadableXmlAsset2.mod);
defPackage2.AddDef(def);
}
}
}
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new()
{
if (asset.xmlDoc != null)
{
XmlNodeList xmlNodeList = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name);
bool gotData = false;
foreach (XmlNode item in xmlNodeList)
{
XmlAttribute xmlAttribute = item.Attributes["Abstract"];
if (xmlAttribute == null || !(xmlAttribute.Value.ToLower() == "true"))
{
T val;
try
{
val = DirectXmlToObject.ObjectFromXml <T>(item, doPostLoad: true);
gotData = true;
}
catch (Exception ex)
{
Log.Error("Exception loading data from file " + asset.name + ": " + ex);
continue;
}
yield return(val);
}
}
if (!gotData)
{
Log.Error("Found no usable data when trying to get " + typeof(T) + "s from file " + asset.name);
}
}
}
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new()
{
if (asset.xmlDoc == null)
{
yield break;
}
XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name);
bool gotData = false;
IEnumerator enumerator = assetNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
XmlNode node = (XmlNode)obj;
XmlAttribute abstractAtt = node.Attributes["Abstract"];
if (abstractAtt == null || !(abstractAtt.Value.ToLower() == "true"))
{
T item;
try
{
item = DirectXmlToObject.ObjectFromXml <T>(node, true);
gotData = true;
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception loading data from file ",
asset.name,
": ",
ex
}), false);
continue;
}
yield return(item);
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
if (!gotData)
{
Log.Error(string.Concat(new object[]
{
"Found no usable data when trying to get ",
typeof(T),
"s from file ",
asset.name
}), false);
}
yield break;
}
public static IEnumerable <T> LoadXmlDataInResourcesFolder <T>(string folderPath) where T : new()
{
XmlInheritance.Clear();
List <LoadableXmlAsset> assets = new List <LoadableXmlAsset>();
object[] textObjects = Resources.LoadAll <TextAsset>(folderPath);
object[] array = textObjects;
for (int j = 0; j < array.Length; j++)
{
TextAsset textAsset = (TextAsset)array[j];
LoadableXmlAsset loadableXmlAsset = new LoadableXmlAsset(textAsset.name, string.Empty, textAsset.text);
XmlInheritance.TryRegisterAllFrom(loadableXmlAsset, null);
assets.Add(loadableXmlAsset);
}
XmlInheritance.Resolve();
for (int i = 0; i < assets.Count; i++)
{
using (IEnumerator <T> enumerator = DirectXmlLoader.AllGameItemsFromAsset <T>(assets[i]).GetEnumerator())
{
if (enumerator.MoveNext())
{
T item = enumerator.Current;
yield return(item);
/*Error: Unable to find new state assignment for yield return*/;
}
}
}
XmlInheritance.Clear();
yield break;
IL_0195:
/*Error near IL_0196: Unexpected return in MoveNext()*/;
}
public static Def DefFromNode(XmlNode node, LoadableXmlAsset loadingAsset)
{
Def result;
if (node.NodeType != XmlNodeType.Element)
{
result = null;
}
else
{
XmlAttribute xmlAttribute = node.Attributes["Abstract"];
if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true")
{
result = null;
}
else
{
Type typeInAnyAssembly = GenTypes.GetTypeInAnyAssembly(node.Name);
if (typeInAnyAssembly == null)
{
result = null;
}
else if (!typeof(Def).IsAssignableFrom(typeInAnyAssembly))
{
result = null;
}
else
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ObjectFromXml");
MethodInfo methodInfo = method.MakeGenericMethod(new Type[]
{
typeInAnyAssembly
});
Def def = null;
try
{
def = (Def)methodInfo.Invoke(null, new object[]
{
node,
true
});
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception loading def from file ",
(loadingAsset == null) ? "(unknown)" : loadingAsset.name,
": ",
ex
}), false);
}
result = def;
}
}
}
return(result);
}
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new()
{
if (DirectXmlLoader.loadingAsset != null)
{
Log.Error("Tried to load " + asset + " while loading " + DirectXmlLoader.loadingAsset + ". This will corrupt the internal state of DataLoader.");
}
if (asset.xmlDoc != null)
{
DirectXmlLoader.loadingAsset = asset;
XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name);
bool gotData = false;
IEnumerator enumerator = assetNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlNode node = (XmlNode)enumerator.Current;
XmlAttribute abstractAtt = node.Attributes["Abstract"];
if (abstractAtt != null && abstractAtt.Value.ToLower() == "true")
{
continue;
}
T item;
try
{
item = DirectXmlToObject.ObjectFromXml <T>(node, true);
gotData = true;
}
catch (Exception ex)
{
Log.Error("Exception loading data from file " + asset.name + ": " + ex);
continue;
}
yield return(item);
/*Error: Unable to find new state assignment for yield return*/;
}
}
finally
{
IDisposable disposable;
IDisposable disposable2 = disposable = (enumerator as IDisposable);
if (disposable != null)
{
disposable2.Dispose();
}
}
if (!gotData)
{
Log.Error("Found no usable data when trying to get " + typeof(T) + "s from file " + asset.name);
}
DirectXmlLoader.loadingAsset = null;
}
yield break;
IL_0247:
/*Error near IL_0248: Unexpected return in MoveNext()*/;
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
bool flag = false;
switch (num)
{
case 0u:
if (this.defPackages.Count != 0)
{
Log.ErrorOnce("LoadDefs called with already existing def packages", 39029405, false);
}
enumerator = DirectXmlLoader.XmlAssetsInModFolder(this, "Defs/").GetEnumerator();
num = 4294967293u;
break;
case 1u:
break;
default:
return(false);
}
try
{
switch (num)
{
}
if (enumerator.MoveNext())
{
asset = enumerator.Current;
defPackage = new DefPackage(asset.name, GenFilePaths.FolderPathRelativeToDefsFolder(asset.fullFolderPath, this));
base.AddDefPackage(defPackage);
asset.defPackage = defPackage;
this.$current = asset;
if (!this.$disposing)
{
this.$PC = 1;
}
flag = true;
return(true);
}
}
finally
{
if (!flag)
{
if (enumerator != null)
{
enumerator.Dispose();
}
}
}
this.$PC = -1;
return(false);
}
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new()
{
if (DirectXmlLoader.loadingAsset != null)
{
Log.Error(string.Concat(new object[]
{
"Tried to load ",
asset,
" while loading ",
DirectXmlLoader.loadingAsset,
". This will corrupt the internal state of DataLoader."
}));
}
if (asset.xmlDoc != null)
{
DirectXmlLoader.loadingAsset = asset;
XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name);
bool gotData = false;
foreach (XmlNode node in assetNodes)
{
XmlAttribute abstractAtt = node.Attributes["Abstract"];
if (abstractAtt == null || !(abstractAtt.Value.ToLower() == "true"))
{
T item;
try
{
item = DirectXmlToObject.ObjectFromXml <T>(node, true);
gotData = true;
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception loading data from file ",
asset.name,
": ",
ex
}));
continue;
}
yield return(item);
}
}
if (!gotData)
{
Log.Error(string.Concat(new object[]
{
"Found no usable data when trying to get ",
typeof(T),
"s from file ",
asset.name
}));
}
DirectXmlLoader.loadingAsset = null;
}
}
public static void TryRegisterAllFrom(LoadableXmlAsset xmlAsset, ModContentPack mod)
{
if (xmlAsset.xmlDoc != null)
{
XmlNodeList childNodes = xmlAsset.xmlDoc.DocumentElement.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
if (childNodes[i].NodeType == XmlNodeType.Element)
{
XmlInheritance.TryRegister(childNodes[i], mod);
}
}
}
}
public static void TryRegisterAllFrom(LoadableXmlAsset xmlAsset, ModContentPack mod)
{
if (xmlAsset.xmlDoc != null)
{
DeepProfiler.Start("XmlInheritance.TryRegisterAllFrom");
foreach (XmlNode childNode in xmlAsset.xmlDoc.DocumentElement.ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
TryRegister(childNode, mod);
}
}
DeepProfiler.End();
}
}
public static IEnumerable <LoadableXmlAsset> XmlAssetsInModFolder(ModContentPack mod, string folderPath)
{
DirectoryInfo di = new DirectoryInfo(Path.Combine(mod.RootDir, folderPath));
if (di.Exists)
{
FileInfo[] files = di.GetFiles("*.xml", SearchOption.AllDirectories);
FileInfo[] array = files;
for (int i = 0; i < array.Length; i++)
{
FileInfo file = array[i];
LoadableXmlAsset asset = new LoadableXmlAsset(file.Name, file.Directory.FullName, File.ReadAllText(file.FullName));
yield return(asset);
}
}
}
public static void ParseAndProcessXML(XmlDocument xmlDoc, Dictionary <XmlNode, LoadableXmlAsset> assetlookup)
{
XmlNodeList childNodes = xmlDoc.DocumentElement.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
if (childNodes[i].NodeType == XmlNodeType.Element)
{
LoadableXmlAsset loadableXmlAsset = assetlookup.TryGetValue(childNodes[i], null);
XmlInheritance.TryRegister(childNodes[i], (loadableXmlAsset == null) ? null : loadableXmlAsset.mod);
}
}
XmlInheritance.Resolve();
DefPackage defPackage = new DefPackage("(unknown)", "(unknown)");
ModContentPack modContentPack = LoadedModManager.runningMods.FirstOrDefault <ModContentPack>();
modContentPack.AddDefPackage(defPackage);
IEnumerator enumerator = xmlDoc.DocumentElement.ChildNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
XmlNode xmlNode = (XmlNode)obj;
LoadableXmlAsset loadableXmlAsset2 = assetlookup.TryGetValue(xmlNode, null);
DefPackage defPackage2 = (loadableXmlAsset2 == null) ? defPackage : loadableXmlAsset2.defPackage;
Def def = DirectXmlLoader.DefFromNode(xmlNode, loadableXmlAsset2);
if (def != null)
{
def.modContentPack = ((loadableXmlAsset2 == null) ? modContentPack : loadableXmlAsset2.mod);
defPackage2.AddDef(def);
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
public static LoadableXmlAsset[] XmlAssetsInModFolder(ModContentPack mod, string folderPath, List <string> foldersToLoadDebug = null)
{
List <string> list = foldersToLoadDebug ?? mod.foldersToLoadDescendingOrder;
Dictionary <string, FileInfo> dictionary = new Dictionary <string, FileInfo>();
for (int j = 0; j < list.Count; j++)
{
string text = list[j];
DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(text, folderPath));
if (!directoryInfo.Exists)
{
continue;
}
FileInfo[] files = directoryInfo.GetFiles("*.xml", SearchOption.AllDirectories);
foreach (FileInfo fileInfo in files)
{
string key = fileInfo.FullName.Substring(text.Length + 1);
if (!dictionary.ContainsKey(key))
{
dictionary.Add(key, fileInfo);
}
}
}
if (dictionary.Count == 0)
{
return(emptyXmlAssetsArray);
}
List <FileInfo> fileList = dictionary.Values.ToList();
LoadableXmlAsset[] assets = new LoadableXmlAsset[fileList.Count];
GenThreading.ParallelFor(0, fileList.Count, delegate(int i)
{
FileInfo fileInfo2 = fileList[i];
LoadableXmlAsset loadableXmlAsset = new LoadableXmlAsset(fileInfo2.Name, fileInfo2.Directory.FullName, File.ReadAllText(fileInfo2.FullName))
{
mod = mod
};
assets[i] = loadableXmlAsset;
});
return(assets);
}
public static Def DefFromNode(XmlNode node, LoadableXmlAsset loadingAsset)
{
if (node.NodeType != XmlNodeType.Element)
{
return(null);
}
XmlAttribute xmlAttribute = node.Attributes["Abstract"];
if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true")
{
return(null);
}
Type typeInAnyAssembly = GenTypes.GetTypeInAnyAssembly(node.Name);
if (typeInAnyAssembly == null)
{
return(null);
}
if (typeof(Def).IsAssignableFrom(typeInAnyAssembly))
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ObjectFromXml");
MethodInfo methodInfo = method.MakeGenericMethod(typeInAnyAssembly);
Def result = null;
try
{
result = (Def)methodInfo.Invoke(null, new object[2]
{
node,
true
});
return(result);
}
catch (Exception ex)
{
Log.Error("Exception loading def from file " + ((loadingAsset == null) ? "(unknown)" : loadingAsset.name) + ": " + ex);
return(result);
}
}
return(null);
}
public static IEnumerable <T> LoadXmlDataInResourcesFolder <T>(string folderPath) where T : new()
{
XmlInheritance.Clear();
List <LoadableXmlAsset> assets = new List <LoadableXmlAsset>();
object[] textObjects = Resources.LoadAll <TextAsset>(folderPath);
foreach (TextAsset textAsset in textObjects)
{
LoadableXmlAsset loadableXmlAsset = new LoadableXmlAsset(textAsset.name, string.Empty, textAsset.text);
XmlInheritance.TryRegisterAllFrom(loadableXmlAsset, null);
assets.Add(loadableXmlAsset);
}
XmlInheritance.Resolve();
for (int i = 0; i < assets.Count; i++)
{
foreach (T item in DirectXmlLoader.AllGameItemsFromAsset <T>(assets[i]))
{
yield return(item);
}
}
XmlInheritance.Clear();
yield break;
}
public static IEnumerable <T> LoadXmlDataInResourcesFolder <T>(string folderPath) where T : new()
{
XmlInheritance.Clear();
List <LoadableXmlAsset> assets = new List <LoadableXmlAsset>();
object[] array = Resources.LoadAll <TextAsset>(folderPath);
for (int j = 0; j < array.Length; j++)
{
TextAsset textAsset = (TextAsset)array[j];
LoadableXmlAsset loadableXmlAsset = new LoadableXmlAsset(textAsset.name, "", textAsset.text);
XmlInheritance.TryRegisterAllFrom(loadableXmlAsset, null);
assets.Add(loadableXmlAsset);
}
XmlInheritance.Resolve();
for (int i = 0; i < assets.Count; i++)
{
foreach (T item in AllGameItemsFromAsset <T>(assets[i]))
{
yield return(item);
}
}
XmlInheritance.Clear();
}
public IEnumerable <LoadableXmlAsset> LoadDefs()
{
if (defPackages.Count != 0)
{
Log.ErrorOnce("LoadDefs called with already existing def packages", 39029405);
}
using (IEnumerator <LoadableXmlAsset> enumerator = DirectXmlLoader.XmlAssetsInModFolder(this, "Defs/").GetEnumerator())
{
if (enumerator.MoveNext())
{
LoadableXmlAsset asset = enumerator.Current;
DefPackage defPackage = new DefPackage(asset.name, GenFilePaths.FolderPathRelativeToDefsFolder(asset.fullFolderPath, this));
AddDefPackage(defPackage);
asset.defPackage = defPackage;
yield return(asset);
/*Error: Unable to find new state assignment for yield return*/;
}
}
yield break;
IL_0131:
/*Error near IL_0132: Unexpected return in MoveNext()*/;
}
public static Def DefFromNode(XmlNode node, LoadableXmlAsset loadingAsset)
{
if (node.NodeType != XmlNodeType.Element)
{
return(null);
}
XmlAttribute xmlAttribute = node.Attributes["Abstract"];
if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true")
{
return(null);
}
Type typeInAnyAssembly = GenTypes.GetTypeInAnyAssembly(node.Name);
if (typeInAnyAssembly == null)
{
return(null);
}
if (!typeof(Def).IsAssignableFrom(typeInAnyAssembly))
{
return(null);
}
Func <XmlNode, bool, object> objectFromXmlMethod = DirectXmlToObject.GetObjectFromXmlMethod(typeInAnyAssembly);
Def result = null;
try
{
result = (Def)objectFromXmlMethod(node, arg2: true);
return(result);
}
catch (Exception ex)
{
Log.Error("Exception loading def from file " + ((loadingAsset != null) ? loadingAsset.name : "(unknown)") + ": " + ex);
return(result);
}
}
public static IEnumerable <Def> AllDefsFromAsset(LoadableXmlAsset asset)
{
if (DirectXmlLoader.loadingAsset != null)
{
Log.Error("Tried to load " + asset + " while loading " + DirectXmlLoader.loadingAsset + ". This will corrupt the internal state of DataLoader.");
}
if (asset.xmlDoc != null)
{
DirectXmlLoader.loadingAsset = asset;
XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.ChildNodes;
bool gotData = false;
IEnumerator enumerator = assetNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlNode node = (XmlNode)enumerator.Current;
if (node.NodeType == XmlNodeType.Element)
{
XmlAttribute abstractAtt = node.Attributes["Abstract"];
if (abstractAtt != null && abstractAtt.Value.ToLower() == "true")
{
gotData = true;
}
else
{
Type defType = GenTypes.GetTypeInAnyAssembly(node.Name);
if (defType != null && typeof(Def).IsAssignableFrom(defType))
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ObjectFromXml");
MethodInfo gen = method.MakeGenericMethod(defType);
Def def = null;
try
{
def = (Def)gen.Invoke(null, new object[2]
{
node,
true
});
gotData = true;
}
catch (Exception ex)
{
Log.Error("Exception loading def from file " + asset.name + ": " + ex);
}
if (def != null)
{
yield return(def);
/*Error: Unable to find new state assignment for yield return*/;
}
}
}
}
}
}
finally
{
IDisposable disposable;
IDisposable disposable2 = disposable = (enumerator as IDisposable);
if (disposable != null)
{
disposable2.Dispose();
}
}
if (!gotData)
{
Log.Error("Found no usable data when trying to get defs from file " + asset.name);
}
DirectXmlLoader.loadingAsset = null;
}
yield break;
IL_02e2:
/*Error near IL_02e3: Unexpected return in MoveNext()*/;
}
public static void ParseAndProcessXML(XmlDocument xmlDoc, Dictionary <XmlNode, LoadableXmlAsset> assetlookup)
{
XmlNodeList childNodes = xmlDoc.DocumentElement.ChildNodes;
List <XmlNode> list = new List <XmlNode>();
foreach (object item in childNodes)
{
list.Add(item as XmlNode);
}
DeepProfiler.Start("Loading asset nodes " + list.Count);
try
{
for (int i = 0; i < list.Count; i++)
{
if (list[i].NodeType == XmlNodeType.Element)
{
LoadableXmlAsset value = null;
DeepProfiler.Start("assetlookup.TryGetValue");
try
{
assetlookup.TryGetValue(list[i], out value);
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("XmlInheritance.TryRegister");
try
{
XmlInheritance.TryRegister(list[i], value?.mod);
}
finally
{
DeepProfiler.End();
}
}
}
}
finally
{
DeepProfiler.End();
}
DeepProfiler.Start("XmlInheritance.Resolve()");
try
{
XmlInheritance.Resolve();
}
finally
{
DeepProfiler.End();
}
runningMods.FirstOrDefault();
DeepProfiler.Start("Loading defs for " + list.Count + " nodes");
try
{
foreach (XmlNode item2 in list)
{
LoadableXmlAsset loadableXmlAsset = assetlookup.TryGetValue(item2);
Def def = DirectXmlLoader.DefFromNode(item2, loadableXmlAsset);
if (def != null)
{
ModContentPack modContentPack = loadableXmlAsset?.mod;
if (modContentPack != null)
{
modContentPack.AddDef(def, loadableXmlAsset.name);
}
else
{
patchedDefs.Add(def);
}
}
}
}
finally
{
DeepProfiler.End();
}
}
public static IEnumerable <Def> AllDefsFromAsset(LoadableXmlAsset asset)
{
if (DirectXmlLoader.loadingAsset != null)
{
Log.Error(string.Concat(new object[]
{
"Tried to load ",
asset,
" while loading ",
DirectXmlLoader.loadingAsset,
". This will corrupt the internal state of DataLoader."
}));
}
if (asset.xmlDoc != null)
{
DirectXmlLoader.loadingAsset = asset;
XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.ChildNodes;
bool gotData = false;
foreach (XmlNode node in assetNodes)
{
if (node.NodeType == XmlNodeType.Element)
{
XmlAttribute abstractAtt = node.Attributes["Abstract"];
if (abstractAtt != null && abstractAtt.Value.ToLower() == "true")
{
gotData = true;
}
else
{
Type defType = GenTypes.GetTypeInAnyAssembly(node.Name);
if (defType != null)
{
if (typeof(Def).IsAssignableFrom(defType))
{
MethodInfo method = typeof(DirectXmlToObject).GetMethod("ObjectFromXml");
MethodInfo gen = method.MakeGenericMethod(new Type[]
{
defType
});
Def def = null;
try
{
def = (Def)gen.Invoke(null, new object[]
{
node,
true
});
gotData = true;
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception loading def from file ",
asset.name,
": ",
ex
}));
}
if (def != null)
{
yield return(def);
}
}
}
}
}
}
if (!gotData)
{
Log.Error("Found no usable data when trying to get defs from file " + asset.name);
}
DirectXmlLoader.loadingAsset = null;
}
}