ModManager Class Reference

Inheritance diagram for ModManager:

Public Member Functions
override void	Init (string path, string defaultPackage="_Elona")
void	SaveLoadOrder ()
void	LoadLoadOrder ()
void	ImportSourceLocalizations (string lang)
void	ImportAllModSourceSheets ()
void	ImportAllModDialogs ()
void	ImportAllModGodTalks ()
IEnumerator	RefreshMods (Action onComplete, bool syncMods)
ModPackage	AddPackage (DirectoryInfo dir, bool isInPackages=false)
ModPackage	AddWorkshopPackage (WorkshopItem item, bool isInPackages=false)
int	CountUserMod ()
void	LoadLocalPackages ()
void	LoadCustomPackage ()
IEnumerator	LoadWorkshopPackages ()
void	InitPackagesMeta ()
void	ActivatePackages ()
override void	ParseExtra (DirectoryInfo dir, BaseModPackage package)

Public Attributes
List< FileInfo >	replaceFiles = new List<FileInfo>()

Static Public Attributes
static List< object >	ListPluginObject = new List<object>()
static bool	disableMod

Properties
static List< string >	ListChainLoad [get]
static DirectoryInfo	DirWorkshop [get]
static new ModManager	Instance [get]
static bool	IsInitialized [get]

Private Member Functions
IEnumerator	UpdateWorkshopPackages ()

Private Attributes
LoadingScreen	_loading
Action	ImportModGodTalks

Detailed Description

Definition at line 14 of file ModManager.cs.

Member Function Documentation

ActivatePackages()

void ModManager.ActivatePackages ( )

inline

Definition at line 491 of file ModManager.cs.

    {
        BaseModManager.listChainLoad.Clear();
        ListPluginObject.Clear();
        foreach (ModPackage package in packages)
        {
            if ((disableMod && !package.builtin) || !package.IsValidVersion())
            {
                continue;
            }
            try
            {
                package.Activate();
                if (package.activated)
                {
                    BaseModManager.listChainLoad.Add(package.dirInfo.FullName);
                }
            }
            catch (Exception ex)
            {
                _loading.Log("Failed to activate mod: " + package.title + ", reason: " + ex.Message);
            }
        }
        ModUtil.OnModsActivated();
        ModUtil.LoadTypeFallback();
    }

References _loading, disableMod, BaseModManager.listChainLoad, ListPluginObject, ModUtil.LoadTypeFallback(), LoadingScreen.Log(), and ModUtil.OnModsActivated().

Referenced by RefreshMods().

AddPackage()

ModPackage ModManager.AddPackage ( DirectoryInfo  dir, bool  isInPackages = false  )

inline

Definition at line 337 of file ModManager.cs.

    {
        ModPackage modPackage = new ModPackage
        {
            dirInfo = dir,
            installed = true,
            isInPackages = isInPackages,
            loadPriority = priorityIndex,
            Mapping = new FileMapping(dir)
        };
        packages.Add(modPackage);
        priorityIndex++;
        return modPackage;
    }

References installed.

Referenced by AddWorkshopPackage(), LoadLocalPackages(), and RefreshMods().

AddWorkshopPackage()

ModPackage ModManager.AddWorkshopPackage ( WorkshopItem  item, bool  isInPackages = false  )

inline

Definition at line 352 of file ModManager.cs.

    {
        ulong sizeOnDisk;
        string folderPath;
        DateTime timeStamp;
        bool itemInstallInfo = UserGeneratedContent.Client.GetItemInstallInfo(item.FileId, out sizeOnDisk, out folderPath, out timeStamp);
        DirectoryInfo dir = new DirectoryInfo(folderPath);
        ModPackage modPackage = AddPackage(dir, isInPackages);
        modPackage.installed = itemInstallInfo;
        modPackage.banned = item.IsBanned;
        return modPackage;
    }

References AddPackage(), and item.

Referenced by LoadWorkshopPackages().

CountUserMod()

int ModManager.CountUserMod ( )

inline

Definition at line 365 of file ModManager.cs.

    {
        return packages.Count((BaseModPackage p) => !p.builtin);
    }

References BaseModPackage.builtin.

Referenced by LayerTitle.OnClickContinue(), and LayerTitle.OnClickStart().

ImportAllModDialogs()

void ModManager.ImportAllModDialogs ( )

inline

Definition at line 231 of file ModManager.cs.

    {
        Lang.extraExcelDialogs = new HashSet<string>(PathComparer.Default);
        Lang.excelDialog = null;
        FileInfo[] files = PackageIterator.GetFiles("Dialog/dialog.xlsx");
        foreach (FileInfo fileInfo in files)
        {
            Lang.extraExcelDialogs.Add(fileInfo.FullName);
            Debug.Log("#dialog loaded " + fileInfo.ShortPath());
        }
    }

References Debug, and Lang.extraExcelDialogs.

Referenced by Init().

ImportAllModGodTalks()

void ModManager.ImportAllModGodTalks ( )

inline

Definition at line 243 of file ModManager.cs.

    {
        if (Lang.setting?.dir == null)
        {
            return;
        }
        Dictionary<string, Dictionary<string, string>> map = EClass.sources.dataGodTalk.sheets["_default"].map;
        foreach (ExcelData item in from f in PackageIterator.GetFiles("Data/god_talk.xlsx")
            select new ExcelData(f.FullName, 3))
        {
            foreach (KeyValuePair<string, Dictionary<string, string>> item2 in map)
            {
                item2.Deconstruct(out var key, out var _);
                string text = key;
                if (text.IsEmpty())
                {
                    continue;
                }
                Dictionary<string, string> valueOrDefault = item.sheets["_default"].map.GetValueOrDefault(text);
                if (valueOrDefault == null)
                {
                    continue;
                }
                foreach (KeyValuePair<string, string> item3 in valueOrDefault)
                {
                    item3.Deconstruct(out key, out var value2);
                    string text2 = key;
                    string value3 = value2;
                    if (text2 != "id")
                    {
                        map[text][text2] = value3;
                    }
                }
            }
            Debug.Log("#dialog loaded " + item.path.ShortPath());
        }
    }

References SourceManager.dataGodTalk, Debug, LangSetting.dir, item, Lang.setting, ExcelData.sheets, and EClass.sources.

ImportAllModSourceSheets()

void ModManager.ImportAllModSourceSheets ( )

inline

Definition at line 193 of file ModManager.cs.

    {
        try
        {
            SourceCache.InvalidateCacheVersion();
            SourceImporter.HotInit(new SourceData[2]
            {
                EClass.sources.elements,
                EClass.sources.materials
            });
            List<string> list = new List<string>();
            foreach (EMod value in base.MappedPackages.Values)
            {
                if (value.builtin || !value.activated)
                {
                    continue;
                }
                foreach (FileInfo sourceSheet in value.Mapping.SourceSheets)
                {
                    if (!sourceSheet.Name.StartsWith(".") && !sourceSheet.Name.Contains("~"))
                    {
                        ModUtil.sourceImporter.fileProviders[sourceSheet.FullName] = value;
                        list.Add(sourceSheet.FullName);
                    }
                }
            }
            ModUtil.sourceImporter.ImportFilesCached(list);
            SourceCache.FinalizeCache();
            SourceCache.InvalidateCacheBlobs();
            SourceCache.ClearDetail();
        }
        catch (Exception message)
        {
            Debug.LogError(message);
        }
        Debug.Log("#source finished importing workbooks");
    }

References Debug, SourceManager.elements, SourceImporter.fileProviders, SourceImporter.HotInit(), SourceImporter.ImportFilesCached(), ModUtil.sourceImporter, and EClass.sources.

Referenced by SourceManager.Init().

ImportSourceLocalizations()

void ModManager.ImportSourceLocalizations ( string  lang )

inline

Definition at line 114 of file ModManager.cs.

    {
        string text = lang + "/SourceLocalization.json";
        (FileInfo file, EMod package)[] filesEx = PackageIterator.GetFilesEx(text);
        SortedDictionary<string, string> sortedDictionary = new SortedDictionary<string, string>();
        Dictionary<string, SortedDictionary<string, string>> dictionary = new Dictionary<string, SortedDictionary<string, string>>();
        (FileInfo, EMod)[] array = filesEx;
        string key;
        string value;
        for (int i = 0; i < array.Length; i++)
        {
            var (fileInfo, eMod) = array[i];
            try
            {
                SortedDictionary<string, string> sortedDictionary2 = IO.LoadFile<SortedDictionary<string, string>>(fileInfo.FullName);
                foreach (KeyValuePair<string, string> item in sortedDictionary2)
                {
                    item.Deconstruct(out key, out value);
                    string key2 = key;
                    string value2 = value;
                    sortedDictionary[key2] = value2;
                }
                dictionary[eMod.id] = sortedDictionary2;
            }
            catch (Exception arg)
            {
                Debug.LogError($"#source localization failed to load {fileInfo.ShortPath()}\n{arg}");
            }
        }
        JsonSerializerSettings setting = new JsonSerializerSettings
        {
            PreserveReferencesHandling = PreserveReferencesHandling.None,
            NullValueHandling = NullValueHandling.Ignore
        };
        foreach (EMod value4 in base.MappedPackages.Values)
        {
            if (!(value4 is ModPackage modPackage) || value4.builtin || !value4.activated)
            {
                continue;
            }
            HashSet<SourceData.BaseRow> sourceRows = value4.sourceRows;
            if (sourceRows == null || sourceRows.Count <= 0)
            {
                continue;
            }
            modPackage.ImportSourceLocalizations(sortedDictionary);
            if (!ModManagerCore.generateLocalizations || (!modPackage.isInPackages && !Application.isEditor))
            {
                continue;
            }
            if (Lang.IsBuiltin(lang))
            {
                break;
            }
            try
            {
                SortedDictionary<string, string> sortedDictionary3 = dictionary.GetValueOrDefault(modPackage.id) ?? new SortedDictionary<string, string>();
                SortedDictionary<string, string> sortedDictionary4 = modPackage.ExportSourceLocalizations();
                SortedDictionary<string, string> final = new SortedDictionary<string, string>();
                foreach (KeyValuePair<string, string> item2 in sortedDictionary4)
                {
                    item2.Deconstruct(out value, out key);
                    string key3 = value;
                    string defaultValue = key;
                    final[key3] = sortedDictionary3.GetValueOrDefault(key3, defaultValue);
                }
                if (sortedDictionary3.Count != final.Count || sortedDictionary3.Any((KeyValuePair<string, string> kv) => !final.TryGetValue(kv.Key, out var value3) || value3 != kv.Value))
                {
                    IO.SaveFile(Path.Combine(modPackage.dirInfo.FullName, "LangMod", text), final, compress: false, setting);
                    Debug.Log($"#source localization updated {text} / {modPackage}");
                }
            }
            catch (Exception arg2)
            {
                Debug.LogError($"#source localization failed to generate {modPackage}\n{arg2}");
            }
        }
    }

References $, Debug, Lang.IsBuiltin(), and item.

Init()

override void ModManager.Init ( string  path, string  defaultPackage = "_Elona"  )

inline

Definition at line 34 of file ModManager.cs.

    {
        base.Init(path, defaultPackage);
        Debug.Log("IsOffline:" + BaseCore.IsOffline);
        IniData elinIni = Core.GetElinIni();
        if (elinIni != null)
        {
            if (BaseCore.IsOffline)
            {
                string key = elinIni.GetKey("path_workshop");
                if (!key.IsEmpty())
                {
                    dirWorkshop = new DirectoryInfo(key);
                }
            }
            else
            {
                string path2 = Path.Combine(App.Client.GetAppInstallDirectory(SteamSettings.behaviour.settings.applicationId), "../../workshop/content/2135150");
                dirWorkshop = new DirectoryInfo(path2);
                elinIni.Global["path_workshop"] = dirWorkshop.FullName;
                Core.SaveElinIni(elinIni);
            }
        }
        if (!dirWorkshop.Exists)
        {
            dirWorkshop = null;
        }
        Debug.Log("Workshop:" + dirWorkshop);
        Debug.Log("Packages:" + BaseModManager.rootMod);
        Debug.Log("Core Mod:" + BaseModManager.rootDefaultPacakge);
        BaseModManager.SubscribeEvent("elin.source.lang_set", delegate(object lang)
        {
            if (ModManagerCore.useLocalizations)
            {
                ImportSourceLocalizations(lang as string);
            }
            ImportAllModDialogs();
        });
    }

References Debug, Core.GetElinIni(), ImportAllModDialogs(), BaseCore.IsOffline, BaseModManager.rootDefaultPacakge, BaseModManager.rootMod, Core.SaveElinIni(), and BaseModManager.SubscribeEvent().

Referenced by CoreDebug.RegenerateNames(), and Core.StartCase().

InitPackagesMeta()

void ModManager.InitPackagesMeta ( )

inline

Definition at line 473 of file ModManager.cs.

    {
        foreach (BaseModPackage package in packages)
        {
            try
            {
                package.Init();
                mappedPackages[package.id] = package as ModPackage;
                _loading?.Log(package.ToString());
            }
            catch (Exception ex)
            {
                package.willActivate = false;
                _loading?.Log("Mod " + package.title + "/" + package.id + " has failed to initialize, reason: " + ex.Message);
            }
        }
    }

References _loading, BaseModPackage.id, BaseModPackage.Init(), LoadingScreen.Log(), and BaseModPackage.title.

Referenced by RefreshMods().

LoadCustomPackage()

void ModManager.LoadCustomPackage ( )

inline

Definition at line 385 of file ModManager.cs.

    {
        _loading.Log("Loading user Custom...");
        DirectoryInfo[] directories = new DirectoryInfo(CorePath.custom).GetDirectories();
        ModPackage package = new ModPackage();
        DirectoryInfo[] array = directories;
        foreach (DirectoryInfo dir in array)
        {
            ParseExtra(dir, package);
        }
    }

References _loading, CorePath.custom, and LoadingScreen.Log().

Referenced by RefreshMods().

LoadLoadOrder()

void ModManager.LoadLoadOrder ( )

inline

Definition at line 85 of file ModManager.cs.

    {
        string path = CorePath.rootExe + "loadorder.txt";
        if (!File.Exists(path))
        {
            return;
        }
        Dictionary<string, BaseModPackage> dictionary = new Dictionary<string, BaseModPackage>();
        foreach (BaseModPackage package in packages)
        {
            if (!package.builtin)
            {
                dictionary[package.dirInfo.FullName] = package;
            }
        }
        int num = 0;
        string[] array = File.ReadAllLines(path);
        for (int i = 0; i < array.Length; i++)
        {
            string[] array2 = array[i].Split(',');
            if (dictionary.TryGetValue(array2[0], out var value))
            {
                value.loadPriority = num;
                value.willActivate = array2[1] == "1";
            }
            num++;
        }
    }

References BaseModPackage.builtin, and BaseModPackage.dirInfo.

Referenced by RefreshMods().

LoadLocalPackages()

void ModManager.LoadLocalPackages ( )

inline

Definition at line 370 of file ModManager.cs.

    {
        _loading.Log("Loading local Package...");
        DirectoryInfo[] directories = new DirectoryInfo(BaseModManager.rootMod).GetDirectories();
        Array.Reverse(directories);
        DirectoryInfo[] array = directories;
        foreach (DirectoryInfo directoryInfo in array)
        {
            if (!disableMod || !(directoryInfo.Name != "_Elona") || !(directoryInfo.Name != "_Lang_Chinese"))
            {
                AddPackage(directoryInfo, isInPackages: true);
            }
        }
    }

References _loading, AddPackage(), disableMod, LoadingScreen.Log(), and BaseModManager.rootMod.

Referenced by RefreshMods().

LoadWorkshopPackages()

IEnumerator ModManager.LoadWorkshopPackages ( )

inline

Definition at line 397 of file ModManager.cs.

    {
        WaitForEndOfFrame awaiter = new WaitForEndOfFrame();
        UgcQuery activeQuery = UgcQuery.GetSubscribed(withLongDescription: false, withMetadata: false, withKeyValueTags: false, withAdditionalPreviews: false, 0u);
        activeQuery.Execute(HandleWorkshopQuery);
        _loading.Log("Fetching subscriptions...(Hit ESC to cancel)");
        while (activeQuery.handle != UGCQueryHandle_t.Invalid && !UnityEngine.Input.GetKey(KeyCode.Escape))
        {
            yield return awaiter;
        }
        yield return UpdateWorkshopPackages();
        void HandleWorkshopQuery(UgcQuery query)
        {
            foreach (WorkshopItem results in query.ResultsList)
            {
                AddWorkshopPackage(results);
            }
        }
    }

References _loading, AddWorkshopPackage(), LoadingScreen.Log(), and UpdateWorkshopPackages().

Referenced by RefreshMods().

ParseExtra()

override void ModManager.ParseExtra ( DirectoryInfo  dir, BaseModPackage  package  )

inline

Definition at line 518 of file ModManager.cs.

    {
        ModPackage modPackage = (ModPackage)package;
        switch (dir.Name)
        {
        case "TalkText":
            modPackage.ParseTalkText(dir);
            break;
        case "Map":
            if (!package.builtin)
            {
                modPackage.ParseMap(dir);
            }
            break;
        case "Map Piece":
            if (!package.builtin)
            {
                modPackage.ParseMapPiece(dir);
            }
            break;
        case "Texture Replace":
            replaceFiles.AddRange(modPackage.ParseTextureReplace(dir));
            break;
        case "Texture":
            modPackage.ParseTexture(dir);
            break;
        case "Portrait":
            modPackage.ParsePortrait(dir);
            break;
        case "LangMod":
            modPackage.ParseLangMod(dir);
            break;
        case "Sound":
            modPackage.ParseSound(dir);
            break;
        case "Lang":
            modPackage.AddOrUpdateLang(dir);
            break;
        }
    }

References ModPackage.AddOrUpdateLang(), BaseModPackage.builtin, ModPackage.ParseLangMod(), ModPackage.ParseMap(), ModPackage.ParseMapPiece(), ModPackage.ParsePortrait(), ModPackage.ParseSound(), ModPackage.ParseTalkText(), ModPackage.ParseTexture(), ModPackage.ParseTextureReplace(), and replaceFiles.

RefreshMods()

IEnumerator ModManager.RefreshMods ( Action  onComplete, bool  syncMods  )

inline

Definition at line 281 of file ModManager.cs.

    {
        bool flag = !BaseCore.IsOffline && syncMods && UserGeneratedContent.Client.GetNumSubscribedItems() != 0;
        _loading = Util.Instantiate<LoadingScreen>("LoadingScreen");
        WaitForEndOfFrame awaiter = new WaitForEndOfFrame();
        packages.Clear();
        disableMod |= Application.isEditor && EClass.debug.skipMod;
        LoadLocalPackages();
        LoadCustomPackage();
        if (!disableMod)
        {
            _loading.Log("Loading workshop contents...");
            if (flag)
            {
                yield return LoadWorkshopPackages();
            }
            else if (dirWorkshop != null)
            {
                DirectoryInfo[] directories = dirWorkshop.GetDirectories();
                foreach (DirectoryInfo dir in directories)
                {
                    AddPackage(dir);
                }
            }
        }
        InitPackagesMeta();
        LoadLoadOrder();
        packages.Sort((BaseModPackage a, BaseModPackage b) => a.loadPriority - b.loadPriority);
        foreach (BaseModPackage item in packages.Where((BaseModPackage p) => !p.isInPackages && p.willActivate && !p.id.IsEmpty()))
        {
            if (mappedPackages.TryGetValue(item.id, out var value) && value.isInPackages)
            {
                value.hasPublishedPackage = true;
            }
        }
        _loading.Log($"Total number of mods:{packages.Count}");
        _loading.Log("Activating Mods...");
        yield return awaiter;
        ActivatePackages();
        foreach (BaseModPackage package in packages)
        {
            if (package.activated)
            {
                mappedPackages[package.id] = package as ModPackage;
            }
        }
        BaseModManager.isInitialized = true;
        yield return awaiter;
        onComplete?.Invoke();
        if ((bool)_loading)
        {
            UnityEngine.Object.Destroy(_loading.gameObject);
        }
        yield return null;
    }

References $, _loading, BaseModPackage.activated, ActivatePackages(), AddPackage(), EClass.debug, disableMod, BaseModPackage.id, InitPackagesMeta(), BaseModPackage.isInPackages, item, LoadCustomPackage(), LoadLoadOrder(), LoadLocalPackages(), BaseModPackage.loadPriority, LoadWorkshopPackages(), LoadingScreen.Log(), CoreDebug.skipMod, Util, and BaseModPackage.willActivate.

Referenced by Core.StartCase().

SaveLoadOrder()

void ModManager.SaveLoadOrder ( )

inline

Definition at line 74 of file ModManager.cs.

    {
        if (!disableMod)
        {
            List<string> contents = (from p in packages
                where !p.builtin && p.dirInfo.Exists
                select $"{p.dirInfo.FullName},{(p.willActivate ? 1 : 0)}").ToList();
            File.WriteAllLines(CorePath.rootExe + "loadorder.txt", contents);
        }
    }

References $, disableMod, and CorePath.rootExe.

Referenced by LayerMod.Move(), LayerMod.OnInit(), and LayerMod.OnKill().

UpdateWorkshopPackages()

IEnumerator ModManager.UpdateWorkshopPackages ( )

inlineprivate

Definition at line 417 of file ModManager.cs.

    {
        _loading?.Log("Updating subscriptions...");
        WaitForEndOfFrame awaiter = new WaitForEndOfFrame();
        while (true)
        {
            bool flag = false;
            foreach (BaseModPackage item in packages.Where((BaseModPackage p) => !p.installed))
            {
                if (!(item.item is WorkshopItem { IsBanned: false } workshopItem))
                {
                    continue;
                }
                flag = true;
                string text = "Downloading " + workshopItem.Title + ": ";
                BaseModPackage baseModPackage = item;
                if ((object)baseModPackage.progressText == null)
                {
                    baseModPackage.progressText = _loading?.Log(text);
                }
                if (item.downloadStarted && workshopItem.DownloadCompletion >= 1f)
                {
                    item.installed = true;
                    if ((bool)item.progressText)
                    {
                        item.progressText.text = text + "Done!";
                    }
                }
                else if (workshopItem.IsDownloading || workshopItem.IsDownloadPending)
                {
                    int num = Mathf.FloorToInt(workshopItem.DownloadCompletion * 100f);
                    if ((bool)item.progressText)
                    {
                        item.progressText.text = text + num + "%";
                    }
                }
                else if (!item.downloadStarted)
                {
                    item.downloadStarted = true;
                    workshopItem.DownloadItem(highPriority: true);
                    Debug.Log("Start downloading: " + workshopItem.Title + " | " + $"Installed={workshopItem.IsInstalled}, " + $"Downloading={workshopItem.IsDownloading}, " + $"Pending={workshopItem.IsDownloadPending}");
                }
            }
            if (!flag)
            {
                yield break;
            }
            if (UnityEngine.Input.GetKey(KeyCode.Escape))
            {
                break;
            }
            yield return awaiter;
        }
        Debug.Log("Workshop updating cancelled");
    }

References $, _loading, Debug, BaseModPackage.installed, item, LoadingScreen.Log(), and BaseModPackage.progressText.

Referenced by LoadWorkshopPackages().

Member Data Documentation

_loading

LoadingScreen ModManager._loading

private

Definition at line 20 of file ModManager.cs.

Referenced by ActivatePackages(), InitPackagesMeta(), LoadCustomPackage(), LoadLocalPackages(), LoadWorkshopPackages(), RefreshMods(), and UpdateWorkshopPackages().

disableMod

bool ModManager.disableMod

static

Definition at line 18 of file ModManager.cs.

Referenced by ActivatePackages(), LoadLocalPackages(), RefreshMods(), SaveLoadOrder(), and Core.StartCase().

ImportModGodTalks

Action ModManager.ImportModGodTalks

private

Definition at line 24 of file ModManager.cs.

ListPluginObject

List<object> ModManager.ListPluginObject = new List<object>()

static

Definition at line 16 of file ModManager.cs.

Referenced by ActivatePackages(), and Core.StartCase().

replaceFiles

List<FileInfo> ModManager.replaceFiles = new List<FileInfo>()

Definition at line 22 of file ModManager.cs.

Referenced by TextureManager.Init(), and ParseExtra().

Property Documentation

DirWorkshop

DirectoryInfo ModManager.DirWorkshop

staticget

Definition at line 28 of file ModManager.cs.

Instance

new ModManager ModManager.Instance

staticget

Definition at line 30 of file ModManager.cs.

Referenced by SourceManager.Init().

IsInitialized

bool ModManager.IsInitialized

staticget

Definition at line 32 of file ModManager.cs.

Referenced by Core.StartCase().

ListChainLoad

List<string> ModManager.ListChainLoad

staticget

Definition at line 26 of file ModManager.cs.

---

The documentation for this class was generated from the following file:

• Elin/ModManager.cs