public static void Init()
{
bool flag = !new FileInfo(GenFilePaths.KeyPrefsFilePath).Exists;
Dictionary <string, KeyBindingData> dictionary = DirectXmlLoader.ItemFromXmlFile <Dictionary <string, KeyBindingData> >(GenFilePaths.KeyPrefsFilePath, true);
KeyPrefs.data = new KeyPrefsData();
KeyPrefs.unresolvedBindings = new Dictionary <string, KeyBindingData>();
foreach (KeyValuePair <string, KeyBindingData> current in dictionary)
{
KeyBindingDef namedSilentFail = DefDatabase <KeyBindingDef> .GetNamedSilentFail(current.Key);
if (namedSilentFail != null)
{
KeyPrefs.data.keyPrefs[namedSilentFail] = current.Value;
}
else
{
KeyPrefs.unresolvedBindings[current.Key] = current.Value;
}
}
if (flag)
{
KeyPrefs.data.ResetToDefaults();
}
KeyPrefs.data.AddMissingDefaultBindings();
KeyPrefs.data.ErrorCheck();
if (flag)
{
KeyPrefs.Save();
}
}
private void Init()
{
meta = DirectXmlLoader.ItemFromXmlFile <ModMetaDataInternal>(RootDir.FullName + Path.DirectorySeparatorChar + "About" + Path.DirectorySeparatorChar + "About.xml");
loadFolders = DirectXmlLoader.ItemFromXmlFile <ModLoadFolders>(RootDir.FullName + Path.DirectorySeparatorChar + "LoadFolders.xml");
bool shouldLogIssues = ModLister.ShouldLogIssues;
HadIncorrectlyFormattedVersionInMetadata = !meta.TryParseSupportedVersions(!OnSteamWorkshop && shouldLogIssues);
if (meta.name.NullOrEmpty())
{
if (OnSteamWorkshop)
{
meta.name = "Workshop mod " + FolderName;
}
else
{
meta.name = FolderName;
}
}
HadIncorrectlyFormattedPackageId = !meta.TryParsePackageId(Official, !OnSteamWorkshop && shouldLogIssues);
packageIdLowerCase = meta.packageId.ToLower();
meta.InitVersionedData();
meta.ValidateDependencies_NewTmp(shouldLogIssues);
string publishedFileIdPath = PublishedFileIdPath;
if (File.Exists(PublishedFileIdPath) && ulong.TryParse(File.ReadAllText(publishedFileIdPath), out var result))
{
publishedFileIdInt = new PublishedFileId_t(result);
}
}
static ModsConfig()
{
bool flag = false;
ModsConfig.data = DirectXmlLoader.ItemFromXmlFile <ModsConfig.ModsConfigData>(GenFilePaths.ModsConfigFilePath, true);
if (ModsConfig.data.buildNumber < VersionControl.CurrentBuild)
{
Log.Message(string.Concat(new object[]
{
"Mods config data is from build ",
ModsConfig.data.buildNumber,
" while we are at build ",
VersionControl.CurrentBuild,
". Resetting."
}), false);
ModsConfig.data = new ModsConfig.ModsConfigData();
flag = true;
}
ModsConfig.data.buildNumber = VersionControl.CurrentBuild;
bool flag2 = File.Exists(GenFilePaths.ModsConfigFilePath);
if (!flag2 || flag)
{
ModsConfig.data.activeMods.Add(ModContentPack.CoreModIdentifier);
ModsConfig.Save();
}
}
static ModsConfig()
{
bool flag = false;
data = DirectXmlLoader.ItemFromXmlFile <ModsConfigData>(GenFilePaths.ModsConfigFilePath);
if (data.version != null)
{
bool flag2 = false;
int result;
if (data.version.Contains("."))
{
int num = VersionControl.MinorFromVersionString(data.version);
int num2 = VersionControl.MajorFromVersionString(data.version);
if (num2 != VersionControl.CurrentMajor || num != VersionControl.CurrentMinor)
{
flag2 = true;
}
}
else if (data.version.Length > 0 && data.version.All(char.IsNumber) && int.TryParse(data.version, out result) && result <= 2009)
{
flag2 = true;
}
if (flag2)
{
Log.Message("Mods config data is from version " + data.version + " while we are running " + VersionControl.CurrentVersionStringWithRev + ". Resetting.");
data = new ModsConfigData();
flag = true;
}
}
if (!File.Exists(GenFilePaths.ModsConfigFilePath) || flag)
{
data.activeMods.Add(ModContentPack.CoreModIdentifier);
Save();
}
}
private void Init()
{
this.meta = DirectXmlLoader.ItemFromXmlFile <ModMetaData.ModMetaDataInternal>(string.Concat(new object[]
{
this.RootDir.FullName,
Path.DirectorySeparatorChar,
"About",
Path.DirectorySeparatorChar,
"About.xml"
}), true);
if (this.meta.name.NullOrEmpty())
{
if (this.OnSteamWorkshop)
{
this.meta.name = "Workshop mod " + this.Identifier;
}
else
{
this.meta.name = this.Identifier;
}
}
if (!this.IsCoreMod && !this.OnSteamWorkshop && !VersionControl.IsWellFormattedVersionString(this.meta.targetVersion))
{
Log.ErrorOnce(string.Concat(new string[]
{
"Mod ",
this.meta.name,
" has incorrectly formatted target version '",
this.meta.targetVersion,
"'. For the current version, write: <targetVersion>",
VersionControl.CurrentVersionString,
"</targetVersion>"
}), this.Identifier.GetHashCode(), false);
}
LongEventHandler.ExecuteWhenFinished(delegate
{
string url = GenFilePaths.SafeURIForUnityWWWFromPath(this.PreviewImagePath);
using (WWW www = new WWW(url))
{
www.threadPriority = UnityEngine.ThreadPriority.High;
while (!www.isDone)
{
Thread.Sleep(1);
}
if (www.error == null)
{
this.previewImage = www.textureNonReadable;
}
}
});
string publishedFileIdPath = this.PublishedFileIdPath;
if (File.Exists(this.PublishedFileIdPath))
{
string s = File.ReadAllText(publishedFileIdPath);
this.publishedFileIdInt = new PublishedFileId_t(ulong.Parse(s));
}
}
public static void Init()
{
bool flag = !new FileInfo(GenFilePaths.PrefsFilePath).Exists;
Prefs.data = new PrefsData();
Prefs.data = DirectXmlLoader.ItemFromXmlFile <PrefsData>(GenFilePaths.PrefsFilePath, true);
if (flag)
{
Prefs.data.langFolderName = LanguageDatabase.SystemLanguageFolderName();
}
}
public static void Init()
{
bool num = !new FileInfo(GenFilePaths.PrefsFilePath).Exists;
data = new PrefsData();
data = DirectXmlLoader.ItemFromXmlFile <PrefsData>(GenFilePaths.PrefsFilePath);
BackCompatibility.PrefsDataPostLoad(data);
if (num)
{
data.langFolderName = LanguageDatabase.SystemLanguageFolderName();
data.uiScale = ResolutionUtility.GetRecommendedUIScale(data.screenWidth, data.screenHeight);
}
if (DevModePermanentlyDisabledUtility.Disabled)
{
DevMode = false;
}
Apply();
}
public static void Init()
{
bool flag = !new FileInfo(GenFilePaths.PrefsFilePath).Exists;
Prefs.data = new PrefsData();
Prefs.data = DirectXmlLoader.ItemFromXmlFile <PrefsData>(GenFilePaths.PrefsFilePath, true);
if (flag)
{
Prefs.data.langFolderName = LanguageDatabase.SystemLanguageFolderName();
if (UnityData.isDebugBuild && !DevModePermanentlyDisabledUtility.Disabled)
{
Prefs.DevMode = true;
}
}
if (DevModePermanentlyDisabledUtility.Disabled)
{
Prefs.DevMode = false;
}
}
static ModsConfig()
{
bool flag = false;
ModsConfig.data = DirectXmlLoader.ItemFromXmlFile <ModsConfigData>(GenFilePaths.ModsConfigFilePath, true);
if (ModsConfig.data.buildNumber < VersionControl.CurrentBuild)
{
Log.Message("Mods config data is from build " + ModsConfig.data.buildNumber + " while we are at build " + VersionControl.CurrentBuild + ". Resetting.");
ModsConfig.data = new ModsConfigData();
flag = true;
}
ModsConfig.data.buildNumber = VersionControl.CurrentBuild;
if (File.Exists(GenFilePaths.ModsConfigFilePath) && !flag)
{
return;
}
ModsConfig.data.activeMods.Add(ModContentPack.CoreModIdentifier);
ModsConfig.Save();
}
private void Init()
{
meta = DirectXmlLoader.ItemFromXmlFile <ModMetaDataInternal>(RootDir.FullName + Path.DirectorySeparatorChar + "About" + Path.DirectorySeparatorChar + "About.xml");
if (meta.name.NullOrEmpty())
{
if (OnSteamWorkshop)
{
meta.name = "Workshop mod " + Identifier;
}
else
{
meta.name = Identifier;
}
}
if (!IsCoreMod && !OnSteamWorkshop && !VersionControl.IsWellFormattedVersionString(meta.targetVersion))
{
Log.ErrorOnce("Mod " + meta.name + " has incorrectly formatted target version '" + meta.targetVersion + "'. For the current version, write: <targetVersion>" + VersionControl.CurrentVersionString + "</targetVersion>", Identifier.GetHashCode());
}
LongEventHandler.ExecuteWhenFinished(delegate
{
string url = GenFilePaths.SafeURIForUnityWWWFromPath(PreviewImagePath);
using (WWW wWW = new WWW(url))
{
wWW.threadPriority = UnityEngine.ThreadPriority.High;
while (!wWW.isDone)
{
Thread.Sleep(1);
}
if (wWW.error == null)
{
previewImage = wWW.textureNonReadable;
}
}
});
string publishedFileIdPath = PublishedFileIdPath;
if (File.Exists(PublishedFileIdPath))
{
string s = File.ReadAllText(publishedFileIdPath);
publishedFileIdInt = new PublishedFileId_t(ulong.Parse(s));
}
}
public void LoadMetadata()
{
if (info != null && infoIsRealMetadata)
{
return;
}
infoIsRealMetadata = true;
foreach (ModContentPack runningMod in LoadedModManager.RunningMods)
{
foreach (string item in runningMod.foldersToLoadDescendingOrder)
{
string text = Path.Combine(item, "Languages");
if (!new DirectoryInfo(text).Exists)
{
continue;
}
foreach (VirtualDirectory directory in AbstractFilesystem.GetDirectories(text, "*", SearchOption.TopDirectoryOnly))
{
if (directory.Name == folderName || directory.Name == legacyFolderName)
{
info = DirectXmlLoader.ItemFromXmlFile <LanguageInfo>(directory, "LanguageInfo.xml", resolveCrossRefs: false);
if (info.friendlyNameNative.NullOrEmpty() && directory.FileExists("FriendlyName.txt"))
{
info.friendlyNameNative = directory.ReadAllText("FriendlyName.txt");
}
if (info.friendlyNameNative.NullOrEmpty())
{
info.friendlyNameNative = folderName;
}
if (info.friendlyNameEnglish.NullOrEmpty())
{
info.friendlyNameEnglish = folderName;
}
return;
}
}
}
}
}
public void TryLoadMetadataFrom(string folderPath)
{
if (this.info == null)
{
string filePath = Path.Combine(folderPath.ToString(), "LanguageInfo.xml");
this.info = DirectXmlLoader.ItemFromXmlFile <LanguageInfo>(filePath, false);
if (this.info.friendlyNameNative.NullOrEmpty())
{
FileInfo fileInfo = new FileInfo(Path.Combine(folderPath.ToString(), "FriendlyName.txt"));
if (fileInfo.Exists)
{
this.info.friendlyNameNative = GenFile.TextFromRawFile(fileInfo.ToString());
}
}
if (this.info.friendlyNameNative.NullOrEmpty())
{
this.info.friendlyNameNative = this.folderName;
}
if (this.info.friendlyNameEnglish.NullOrEmpty())
{
this.info.friendlyNameEnglish = this.folderName;
}
}
}
static ModsConfig()
{
activeModsHashSet = new HashSet <string>();
activeModsInLoadOrderCached = new List <ModMetaData>();
bool flag = false;
bool flag2 = false;
data = DirectXmlLoader.ItemFromXmlFile <ModsConfigData>(GenFilePaths.ModsConfigFilePath);
if (data.version != null)
{
bool flag3 = false;
int result;
if (data.version.Contains("."))
{
int num = VersionControl.MinorFromVersionString(data.version);
if (VersionControl.MajorFromVersionString(data.version) != VersionControl.CurrentMajor || num != VersionControl.CurrentMinor)
{
flag3 = true;
}
}
else if (data.version.Length > 0 && data.version.All((char x) => char.IsNumber(x)) && int.TryParse(data.version, out result) && result <= 2009)
{
flag3 = true;
}
if (flag3)
{
Log.Message("Mods config data is from version " + data.version + " while we are running " + VersionControl.CurrentVersionStringWithRev + ". Resetting.");
data = new ModsConfigData();
flag = true;
}
}
for (int i = 0; i < data.activeMods.Count; i++)
{
string packageId = data.activeMods[i];
if (ModLister.GetModWithIdentifier(packageId) == null)
{
ModMetaData modMetaData = ModLister.AllInstalledMods.FirstOrDefault((ModMetaData m) => m.FolderName == packageId);
if (modMetaData != null)
{
data.activeMods[i] = modMetaData.PackageId;
flag2 = true;
}
if (TryGetPackageIdWithoutExtraSteamPostfix(packageId, out var nonSteamPackageId) && ModLister.GetModWithIdentifier(nonSteamPackageId) != null)
{
data.activeMods[i] = nonSteamPackageId;
}
}
}
HashSet <string> hashSet = new HashSet <string>();
foreach (ModMetaData allInstalledMod in ModLister.AllInstalledMods)
{
if (allInstalledMod.Active)
{
if (hashSet.Contains(allInstalledMod.PackageIdNonUnique))
{
allInstalledMod.Active = false;
Log.Warning("There was more than one enabled instance of mod with PackageID: " + allInstalledMod.PackageIdNonUnique + ". Disabling the duplicates.");
continue;
}
hashSet.Add(allInstalledMod.PackageIdNonUnique);
}
if (!allInstalledMod.IsCoreMod && allInstalledMod.Official && IsExpansionNew(allInstalledMod.PackageId))
{
SetActive(allInstalledMod.PackageId, active: true);
AddKnownExpansion(allInstalledMod.PackageId);
flag2 = true;
}
}
if (!File.Exists(GenFilePaths.ModsConfigFilePath) || flag)
{
Reset();
}
else if (flag2)
{
Save();
}
RecacheActiveMods();
}
