Inheritance diagram for ModManager:

Classes
class	WorkshopDownload

Public Member Functions
override void	Init (string path, string defaultPackage="_Elona")

void	SaveLoadOrder ()

void	SplitGroups ()

void	LoadLoadOrder ()

List< FileInfo >	ListPresets ()

bool	SavePreset (string name, out string path)

bool	TryLoadPresetFile (FileInfo file, out ModLoadOrderPreset.Preset preset, out string error)

ModLoadOrderPreset.ApplyResult	ApplyPreset (ModLoadOrderPreset.Preset preset, bool disableOthers=true)

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 ()

void	InitPackagesMeta ()

void	ActivatePackages ()

void	ActivatePackageList ()

IEnumerator	LoadWorkshopPackages ()

void	LoadCachedWorkshopPackages ()

override void	ParseExtra (DirectoryInfo dir, BaseModPackage package)

Static Public Member Functions
static string	FormatLoadOrder (BaseModPackage p)

static string	GetPresetPath (string name)

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

readonly List< ModGroup >	emptyGroups = new List<ModGroup>()

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

static bool	disableMod

Properties
static List< string >	ListChainLoad `[get]`

static DirectoryInfo	DirWorkshop `[get]`

static bool	IsInitialized `[get]`

static new ModManager	Instance `[get]`

Private Member Functions
void	Halt (List< BaseModPackage > broken)

void	SortPackages ()

void	MapActivatedPackages ()

string	UnmetDependency (BaseModPackage p, Dictionary< string, BaseModPackage > loaded, Dictionary< string, BaseModPackage > installed)

IEnumerator	QuerySubscriptions (PublishedFileId_t[] subscribed)

IEnumerator	DownloadSubscriptions ()

void	InstallWorkshopPackage (WorkshopDownload download, string path)

void	FailWorkshopPackage (WorkshopDownload download, string reason)

void	AbortDownloads (List< WorkshopDownload > queue, string reason)

Static Private Member Functions
static string	NormalizeOrderPath (string path)

static BaseModPackage	FindIncompatible (BaseModPackage p, Dictionary< string, BaseModPackage > loaded, Dictionary< string, BaseModPackage > claimed)

static void	RegisterLoaded (BaseModPackage p, Dictionary< string, BaseModPackage > loaded, Dictionary< string, BaseModPackage > claimed)

static bool	IsItemReady (WorkshopItem item, out string path)

static bool	IsCancelRequested ()

static void	SetStatus (Text status, string message)

Private Attributes
LoadingScreen	_loading

HashSet< ulong >	_subscribedItems

readonly HashSet< ulong >	_blockedItems = new HashSet<ulong>()

int	_missingContent

Detailed Description

Definition at line 14 of file ModManager.cs.

Member Function Documentation

◆ AbortDownloads()

void ModManager.AbortDownloads	(	List< WorkshopDownload >	queue,
		string	reason
	)

inlineprivate

Definition at line 1030 of file ModManager.cs.

    {
        foreach (WorkshopDownload item in queue)
        {
            FailWorkshopPackage(item, reason);
        }
        queue.Clear();
    }

References FailWorkshopPackage(), and item.

Referenced by DownloadSubscriptions().

◆ ActivatePackageList()

void ModManager.ActivatePackageList ( )

inline

Definition at line 545 of file ModManager.cs.

    {
        Dictionary<string, BaseModPackage> loaded = new Dictionary<string, BaseModPackage>();
        Dictionary<string, BaseModPackage> claimed = new Dictionary<string, BaseModPackage>();
        int num = 0;
        foreach (BaseModPackage package in packages)
        {
            package.blockedBy = null;
            package.langDepError = null;
        }
        Dictionary<string, BaseModPackage> dictionary = new Dictionary<string, BaseModPackage>();
        foreach (BaseModPackage package2 in packages)
        {
            string text = BaseModPackage.NormalizeId(package2.id);
            if (text != null && !package2.hasPublishedPackage)
            {
                dictionary.TryAdd(text, package2);
            }
        }
        foreach (ModPackage item in from p in packages.OfType<ModPackage>()
            where !disableMod || p.builtin
            select p)
        {
            if (!item.IsValidVersion())
            {
                _loading?.Log("Skipped (made for game " + item.version + "): " + item.title + "/" + item.id);
            }
            else
            {
                if (item.banned)
                {
                    continue;
                }
                if (item.CanActivate)
                {
                    BaseModPackage baseModPackage = FindIncompatible(item, loaded, claimed);
                    if (baseModPackage != null)
                    {
                        item.blockedBy = baseModPackage;
                        num++;
                        _loading?.Log("Blocked: " + item.title + "/" + item.id + " <-> " + baseModPackage.title + "/" + baseModPackage.id);
                        continue;
                    }
                    string text2 = UnmetDependency(item, loaded, dictionary);
                    if (text2 != null)
                    {
                        item.langDepError = text2;
                        _loading?.Log("Skipped (" + text2 + "): " + item.title + "/" + item.id);
                        continue;
                    }
                }
                try
                {
                    item.Activate();
                }
                catch (Exception ex)
                {
                    _loading?.Log("Failed to activate mod " + item.title + ": " + ex.Message);
                }
                finally
                {
                    if (item.activated)
                    {
                        BaseModManager.listChainLoad.Add(item.dirInfo.FullName);
                        RegisterLoaded(item, loaded, claimed);
                    }
                }
            }
        }
        if (num > 0)
        {
            Debug.LogWarning($"#mod {num} package(s) skipped due to incompatibility");
        }
    }

References $, _loading, Debug, disableMod, FindIncompatible(), BaseModPackage.hasPublishedPackage, BaseModPackage.id, item, BaseModManager.listChainLoad, LoadingScreen.Log(), BaseModPackage.NormalizeId(), RegisterLoaded(), BaseModPackage.title, and UnmetDependency().

Referenced by ActivatePackages().

◆ ActivatePackages()

void ModManager.ActivatePackages ( )

inline

Definition at line 536 of file ModManager.cs.

    {
        BaseModManager.listChainLoad.Clear();
        ListPluginObject.Clear();
        ActivatePackageList();
        ModUtil.OnModsActivated();
        ModUtil.LoadTypeFallback();
    }

References ActivatePackageList(), BaseModManager.listChainLoad, and ListPluginObject.

Referenced by RefreshMods().

◆ AddPackage()

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

inline

Definition at line 424 of file ModManager.cs.

    {
        ModPackage modPackage = new ModPackage
        {
            dirInfo = new DirectoryInfo(dir.FullName.NormalizePath()),
            installed = true,
            isInPackages = isInPackages,
            Mapping = new FileMapping(dir)
        };
        packages.Add(modPackage);
        return modPackage;
    }

References installed.

Referenced by AddWorkshopPackage(), LoadCachedWorkshopPackages(), LoadLocalPackages(), and LayerMod.SetModRow().

◆ AddWorkshopPackage()

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

inline

Definition at line 437 of file ModManager.cs.

    {
        bool itemInstallInfo = UserGeneratedContent.Client.GetItemInstallInfo(item.FileId, out var _, out var folderPath, out var _);
        if (folderPath.IsEmpty())
        {
            folderPath = Path.Combine(DirWorkshop.FullName, item.FileId.ToString());
        }
        DirectoryInfo directoryInfo = new DirectoryInfo(folderPath);
        itemInstallInfo &= directoryInfo.Exists;
        ModPackage modPackage = AddPackage(directoryInfo, isInPackages);
        modPackage.installed = itemInstallInfo;
        modPackage.banned = item.IsBanned;
        modPackage.workshopId = item.FileId.ToString();
        modPackage.item = item;
        return modPackage;
    }

References AddPackage(), DirWorkshop, and item.

Referenced by QuerySubscriptions().

◆ ApplyPreset()

ModLoadOrderPreset.ApplyResult ModManager.ApplyPreset	(	ModLoadOrderPreset::Preset	preset,
		bool	disableOthers = `true`
	)

inline

Definition at line 338 of file ModManager.cs.

    {
        ModLoadOrderPreset.ApplyResult result = ModLoadOrderPreset.Apply(packages, preset, disableOthers);
        SaveLoadOrder();
        return result;
    }

References SaveLoadOrder().

Referenced by LayerMod.ApplyPreset().

◆ CountUserMod()

int ModManager.CountUserMod ( )

inline

Definition at line 454 of file ModManager.cs.

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

References BaseModPackage.builtin.

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

◆ DownloadSubscriptions()

IEnumerator ModManager.DownloadSubscriptions ( )

inlineprivate

Definition at line 865 of file ModManager.cs.

    {
        float now = Time.realtimeSinceStartup;
        List<WorkshopDownload> queue = (from p in packages
            where p.item is WorkshopItem workshopItem && (!p.installed || workshopItem.IsNeedsUpdate)
            select new WorkshopDownload(p, now)).ToList();
        if (queue.Count == 0)
        {
            yield break;
        }
        WaitForEndOfFrame awaiter = new WaitForEndOfFrame();
        Text status = _loading.Log($"Downloading {queue.Count} mods...");
        Dictionary<ulong, EResult> results = new Dictionary<ulong, EResult>();
        int total = queue.Count;
        int completed = 0;
        float lastActivity = now;
        float nextStatus = 0f;
        UserGeneratedContent.Client.EventItemDownloaded.AddListener(OnItemDownloaded);
        try
        {
            while (queue.Count > 0)
            {
                now = Time.realtimeSinceStartup;
                for (int num = queue.Count - 1; num >= 0; num--)
                {
                    WorkshopDownload workshopDownload = queue[num];
                    WorkshopItem item = workshopDownload.item;
                    ulong publishedFileId = item.FileId.m_PublishedFileId;
                    string path = null;
                    string reason = null;
                    bool flag = false;
                    EResult value;
                    if (!workshopDownload.package.downloadStarted)
                    {
                        workshopDownload.package.downloadStarted = true;
                        workshopDownload.lastChange = now;
                        if (item.DownloadItem(highPriority: true))
                        {
                            Debug.Log("Start downloading: " + workshopDownload.Title + " | " + $"Installed={item.IsInstalled}, " + $"Update={item.IsNeedsUpdate}, " + $"Downloading={item.IsDownloading}, " + $"Pending={item.IsDownloadPending}");
                            continue;
                        }
                        reason = "cannot start the download";
                    }
                    else if (results.TryGetValue(publishedFileId, out value) && value != EResult.k_EResultOK)
                    {
                        reason = $"download failed ({value})";
                    }
                    else if (IsItemReady(item, out path))
                    {
                        flag = true;
                    }
                    else
                    {
                        if (item.IsDownloadPending)
                        {
                            workshopDownload.lastChange = now;
                            continue;
                        }
                        if (item.IsDownloading)
                        {
                            float downloadCompletion = item.DownloadCompletion;
                            if (downloadCompletion > workshopDownload.progress)
                            {
                                workshopDownload.progress = downloadCompletion;
                                float lastChange;
                                lastActivity = (lastChange = now);
                                workshopDownload.lastChange = lastChange;
                            }
                            continue;
                        }
                        if (!(now - workshopDownload.lastChange > 20f))
                        {
                            continue;
                        }
                        reason = "cannot start the download";
                    }
                    queue.RemoveAt(num);
                    lastActivity = now;
                    if (flag)
                    {
                        completed++;
                        InstallWorkshopPackage(workshopDownload, path);
                    }
                    else
                    {
                        FailWorkshopPackage(workshopDownload, reason);
                    }
                }
                if (queue.Count == 0)
                {
                    break;
                }
                if (IsCancelRequested())
                {
                    AbortDownloads(queue, "cancelled");
                    break;
                }
                if (now - lastActivity > 90f)
                {
                    AbortDownloads(queue, "not responding");
                    break;
                }
                if (now >= nextStatus)
                {
                    nextStatus = now + 0.5f;
                    WorkshopDownload workshopDownload2 = queue.Find((WorkshopDownload d) => d.item.IsDownloading) ?? queue[0];
                    SetStatus(status, $"Downloading mods {completed}/{total}: " + $"{workshopDownload2.Title} {Mathf.FloorToInt(workshopDownload2.progress * 100f)}%...(Hit ESC to cancel)");
                }
                yield return awaiter;
            }
        }
        finally
        {
            UserGeneratedContent.Client.EventItemDownloaded.RemoveListener(OnItemDownloaded);
        }
        SetStatus(status, $"Downloaded {completed}/{total} mods");
        packages.RemoveAll((BaseModPackage p) => p.item is WorkshopItem && !p.installed);
        void OnItemDownloaded(DownloadItemResult_t result)
        {
            results[result.m_nPublishedFileId.m_PublishedFileId] = result.m_eResult;
        }
    }

References $, _loading, AbortDownloads(), Debug, BaseModPackage.downloadStarted, FailWorkshopPackage(), BaseModPackage.installed, InstallWorkshopPackage(), IsCancelRequested(), IsItemReady(), ModManager.WorkshopDownload.item, BaseModPackage.item, item, ModManager.WorkshopDownload.lastChange, LoadingScreen.Log(), ModManager.WorkshopDownload.package, ModManager.WorkshopDownload.progress, SetStatus(), and ModManager.WorkshopDownload.Title.

Referenced by LoadWorkshopPackages().

◆ FailWorkshopPackage()

void ModManager.FailWorkshopPackage	(	WorkshopDownload	download,
		string	reason
	)

inlineprivate

Definition at line 1019 of file ModManager.cs.

    {
        if (download.isUpdate)
        {
            Debug.LogWarning("Workshop update failed: " + download.Title + ", " + reason);
            return;
        }
        _missingContent++;
        Debug.LogWarning("Workshop download failed: " + download.Title + ", " + reason);
    }

References _missingContent, Debug, ModManager.WorkshopDownload.isUpdate, and ModManager.WorkshopDownload.Title.

Referenced by AbortDownloads(), and DownloadSubscriptions().

◆ FindIncompatible()

static BaseModPackage ModManager.FindIncompatible	(	BaseModPackage	p,
		Dictionary< string, BaseModPackage >	loaded,
		Dictionary< string, BaseModPackage >	claimed
	)

inlinestaticprivate

Definition at line 681 of file ModManager.cs.

    {
        if (p.builtin)
        {
            return null;
        }
        string text = BaseModPackage.NormalizeId(p.id);
        if (text == null)
        {
            return null;
        }
        string[][] incompatible = p.incompatible;
        if (incompatible != null)
        {
            string[][] array = incompatible;
            foreach (string[] array2 in array)
            {
                if (array2 == null)
                {
                    continue;
                }
                string[] array3 = array2;
                for (int j = 0; j < array3.Length; j++)
                {
                    string text2 = BaseModPackage.NormalizeId(array3[j]);
                    if (text2 == null)
                    {
                        continue;
                    }
                    BaseModPackage value;
                    if (text2 == text)
                    {
                        Debug.Log("#mod incompatible: '" + p.id + "' self decl, ignored");
                    }
                    else if (loaded.TryGetValue(text2, out value) && value != null)
                    {
                        if (!value.builtin)
                        {
                            return value;
                        }
                        Debug.Log("#mod incompatible: '" + p.id + "' targets builtin '" + value.id + "', ignored");
                    }
                }
            }
        }
        if (claimed.TryGetValue(text, out var value2) && value2 != null && !value2.builtin)
        {
            return value2;
        }
        return null;
    }

References BaseModPackage.builtin, Debug, BaseModPackage.id, BaseModPackage.incompatible, and BaseModPackage.NormalizeId().

Referenced by ActivatePackageList().

◆ FormatLoadOrder()

static string ModManager.FormatLoadOrder ( BaseModPackage p )

inlinestatic

Definition at line 95 of file ModManager.cs.

    {
        string arg = p.dirInfo?.FullName;
        int num = (p.willActivate ? 1 : 0);
        if (ModLoadOrderPreset.IsValidId(p.id))
        {
            return $"{arg},{num},{p.id.Trim()}";
        }
        return "";
    }

References $, BaseModPackage.dirInfo, and BaseModPackage.id.

Referenced by SaveLoadOrder().

◆ GetPresetPath()

static string ModManager.GetPresetPath ( string name )

inlinestatic

Definition at line 287 of file ModManager.cs.

    {
        return CorePath.PathLoadOrderPreset + name.SanitizeFileName() + ".txt";
    }

Referenced by LayerMod.SavePreset(), and SavePreset().

◆ Halt()

void ModManager.Halt ( List< BaseModPackage > broken )

inlineprivate

Definition at line 393 of file ModManager.cs.

    {
        List<string> list = broken.Select((BaseModPackage p) => p.title.IsEmpty(p.dirInfo?.Name) + ": package.xml does not parse - " + p.parseError).ToList();
        list.Add("Fix the package.xml, or unsubscribe / delete the mod, then restart the game.");
        string text = string.Join("\n", list);
        Debug.LogError("#mod game will not start:\n" + text);
        EGui.CreatePopup(() => new EGui.UpdateInfo(text), (EGui _) => false);
    }

References Debug, BaseModPackage.dirInfo, BaseModPackage.parseError, and BaseModPackage.title.

Referenced by RefreshMods().

◆ Init()

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

inline

Definition at line 63 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)) ?? true)
        {
            dirWorkshop = null;
        }
        Debug.Log("Workshop:" + dirWorkshop);
        Debug.Log("Packages:" + BaseModManager.rootMod);
        Debug.Log("Core Mod:" + BaseModManager.rootDefaultPacakge);
    }

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

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

◆ InitPackagesMeta()

void ModManager.InitPackagesMeta ( )

inline

Definition at line 493 of file ModManager.cs.

    {
        Text status = _loading.Log("Initializing mods...");
        HashSet<BaseModPackage> hashSet = new HashSet<BaseModPackage>();
        int num = 0;
        foreach (BaseModPackage package in packages)
        {
            num++;
            try
            {
                if (!package.Init())
                {
                    hashSet.Add(package);
                    Debug.LogWarning("Not a package: " + package.dirInfo.FullName);
                    continue;
                }
                if (package.parseError.IsEmpty() && package.id.IsEmpty())
                {
                    hashSet.Add(package);
                    Debug.LogWarning("No <id> in package.xml, skipped: " + package.dirInfo.FullName);
                    continue;
                }
                if (!package.id.IsEmpty())
                {
                    mappedPackages[package.id] = package as ModPackage;
                }
                Debug.Log(package.ToString());
                SetStatus(status, $"Initializing mods {num}/{packages.Count}: {package.title}");
            }
            catch (Exception ex)
            {
                _loading.Log("Mod " + package.title + "/" + package.id + " has failed to initialize, " + ex.Message);
                Debug.LogError(ex);
            }
        }
        if (hashSet.Count > 0)
        {
            packages.RemoveAll(hashSet.Contains);
            _loading.Log($"Ignored {hashSet.Count} folder(s) without a usable package.xml");
        }
        SetStatus(status, $"Initialized {packages.Count} mods");
    }

References $, _loading, Debug, BaseModPackage.dirInfo, BaseModPackage.id, BaseModPackage.Init(), LoadingScreen.Log(), BaseModPackage.parseError, SetStatus(), and BaseModPackage.title.

Referenced by RefreshMods().

◆ InstallWorkshopPackage()

void ModManager.InstallWorkshopPackage	(	WorkshopDownload	download,
		string	path
	)

inlineprivate

Definition at line 1007 of file ModManager.cs.

    {
        BaseModPackage package = download.package;
        package.installed = true;
        package.dirInfo = new DirectoryInfo(path.NormalizePath());
        if (package is ModPackage modPackage)
        {
            modPackage.Mapping = new FileMapping(package.dirInfo);
        }
        Debug.Log("Downloaded: " + download.Title + " -> " + package.dirInfo.FullName);
    }

References Debug, BaseModPackage.dirInfo, and ModManager.WorkshopDownload.Title.

Referenced by DownloadSubscriptions().

◆ IsCancelRequested()

static bool ModManager.IsCancelRequested ( )

inlinestaticprivate

Definition at line 1053 of file ModManager.cs.

    {
        return UnityEngine.Input.GetKey(KeyCode.Escape);
    }

Referenced by DownloadSubscriptions(), and QuerySubscriptions().

◆ IsItemReady()

static bool ModManager.IsItemReady	(	WorkshopItem	item,
		out string	path
	)

inlinestaticprivate

Definition at line 1039 of file ModManager.cs.

    {
        path = null;
        if (!item.IsInstalled || item.IsNeedsUpdate || item.IsDownloading || item.IsDownloadPending)
        {
            return false;
        }
        if (UserGeneratedContent.Client.GetItemInstallInfo(item.FileId, out var _, out path, out var _) && !path.IsEmpty())
        {
            return Directory.Exists(path);
        }
        return false;
    }

References item.

Referenced by DownloadSubscriptions().

◆ ListPresets()

List< FileInfo > ModManager.ListPresets ( )

inline

Definition at line 292 of file ModManager.cs.

    {
        if (!Directory.Exists(CorePath.PathLoadOrderPreset))
        {
            return new List<FileInfo>();
        }
        return new DirectoryInfo(CorePath.PathLoadOrderPreset).GetFiles("*.txt", SearchOption.TopDirectoryOnly).OrderBy((FileInfo f) => f.Name, StringComparer.OrdinalIgnoreCase).ToList();
    }

References CorePath.PathLoadOrderPreset.

Referenced by LayerMod.SelectPreset().

◆ LoadCachedWorkshopPackages()

void ModManager.LoadCachedWorkshopPackages ( )

inline

Definition at line 988 of file ModManager.cs.

    {
        HashSet<string> hashSet = packages.Select((BaseModPackage p) => p.dirInfo.FullName).ToHashSet(StringComparer.OrdinalIgnoreCase);
        DirectoryInfo[] directories = dirWorkshop.GetDirectories();
        foreach (DirectoryInfo directoryInfo in directories)
        {
            ulong result;
            bool flag = ulong.TryParse(directoryInfo.Name, out result);
            if ((!flag || !_blockedItems.Contains(result)) && (_subscribedItems == null || (flag && _subscribedItems.Contains(result))) && !hashSet.Contains(new DirectoryInfo(directoryInfo.FullName.NormalizePath()).FullName))
            {
                ModPackage modPackage = AddPackage(directoryInfo);
                if (flag)
                {
                    modPackage.workshopId = directoryInfo.Name;
                }
            }
        }
    }

References _blockedItems, _subscribedItems, AddPackage(), and BaseModPackage.dirInfo.

Referenced by RefreshMods().

◆ LoadCustomPackage()

void ModManager.LoadCustomPackage ( )

inline

Definition at line 481 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 172 of file ModManager.cs.

    {
        emptyGroups.Clear();
        foreach (BaseModPackage package in packages)
        {
            package.orderIndex = -1;
            package.group = null;
        }
        string pathLoadOrder = CorePath.PathLoadOrder;
        if (!File.Exists(pathLoadOrder))
        {
            return;
        }
        Dictionary<string, BaseModPackage> dictionary = new Dictionary<string, BaseModPackage>(StringComparer.OrdinalIgnoreCase);
        Dictionary<string, BaseModPackage> dictionary2 = new Dictionary<string, BaseModPackage>();
        foreach (BaseModPackage package2 in packages)
        {
            if (!package2.builtin)
            {
                string text = NormalizeOrderPath(package2.dirInfo?.FullName);
                if (!text.IsEmpty())
                {
                    dictionary.TryAdd(text, package2);
                }
                string text2 = BaseModPackage.NormalizeId(package2.id);
                if (!text2.IsEmpty())
                {
                    dictionary2.TryAdd(text2, package2);
                }
            }
        }
        int num = 0;
        int num2 = 0;
        ModGroup modGroup = null;
        BaseModPackage after = null;
        HashSet<BaseModPackage> hashSet = new HashSet<BaseModPackage>();
        foreach (string item in File.ReadAllLines(pathLoadOrder).Append("#group"))
        {
            string path;
            bool activate;
            string id;
            if (ModGroup.TryParse(item, out var group))
            {
                if (modGroup != null && num2 == 0)
                {
                    modGroup.after = after;
                    emptyGroups.Add(modGroup);
                }
                modGroup = group;
                num2 = 0;
            }
            else if (ParseLoadOrderLine(item, out path, out activate, out id))
            {
                num2++;
                if (!dictionary.TryGetValue(NormalizeOrderPath(path), out var value))
                {
                    dictionary2.TryGetValue(BaseModPackage.NormalizeId(id) ?? "", out value);
                }
                if (value != null && hashSet.Add(value))
                {
                    value.orderIndex = num;
                    value.willActivate = activate;
                    value.group = modGroup;
                    after = value;
                    num++;
                }
            }
        }
        static bool ParseLoadOrderLine(string line, out string reference, out bool reference2, out string reference3)
        {
            reference = null;
            reference2 = true;
            reference3 = null;
            if (line.IsEmpty() || line.Trim().IsEmpty())
            {
                return false;
            }
            int num3 = line.LastIndexOf(',');
            if (num3 <= 0)
            {
                return false;
            }
            string text3 = line[(num3 + 1)..].Trim();
            if (text3 == "0" || text3 == "1")
            {
                reference = line[..num3];
                reference2 = text3 == "1";
                return !reference.IsEmpty();
            }
            int num4 = line.LastIndexOf(',', num3 - 1);
            if (num4 <= 0)
            {
                return false;
            }
            string text4 = line[(num4 + 1)..num3].Trim();
            if (text4 != "0" && text4 != "1")
            {
                return false;
            }
            reference = line[..num4];
            reference2 = text4 == "1";
            reference3 = text3;
            return !reference.IsEmpty();
        }
    }

References BaseModPackage.builtin, BaseModPackage.dirInfo, emptyGroups, BaseModPackage.id, item, BaseModPackage.NormalizeId(), NormalizeOrderPath(), CorePath.PathLoadOrder, and ModGroup.TryParse().

Referenced by SortPackages().

◆ LoadLocalPackages()

void ModManager.LoadLocalPackages ( )

inline

Definition at line 459 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 || BaseModPackage.IsBuiltinDir(directoryInfo.Name))
            {
                if (directoryInfo.Name == "Mod_FixedPackageLoader")
                {
                    IO.DeleteDirectory(directoryInfo.FullName);
                }
                else
                {
                    AddPackage(directoryInfo, isInPackages: true);
                }
            }
        }
    }

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

Referenced by RefreshMods().

◆ LoadWorkshopPackages()

IEnumerator ModManager.LoadWorkshopPackages ( )

inline

Definition at line 769 of file ModManager.cs.

    {
        PublishedFileId_t[] subscribedItems = UserGeneratedContent.Client.GetSubscribedItems();
        if (!subscribedItems.IsEmpty())
        {
            _subscribedItems = subscribedItems.Select((PublishedFileId_t id) => id.m_PublishedFileId).ToHashSet();
            yield return QuerySubscriptions(subscribedItems);
            yield return DownloadSubscriptions();
            if (_missingContent > 0)
            {
                yield return new WaitForSecondsRealtime(3f);
            }
        }
    }

References _missingContent, _subscribedItems, DownloadSubscriptions(), and QuerySubscriptions().

Referenced by RefreshMods().

◆ MapActivatedPackages()

void ModManager.MapActivatedPackages ( )

inlineprivate

Definition at line 416 of file ModManager.cs.

    {
        foreach (BaseModPackage item in packages.Where((BaseModPackage p) => p.activated && !p.id.IsEmpty()))
        {
            mappedPackages[item.id] = item as ModPackage;
        }
    }

References BaseModPackage.activated, BaseModPackage.id, and item.

Referenced by RefreshMods().

◆ NormalizeOrderPath()

static string ModManager.NormalizeOrderPath ( string path )

inlinestaticprivate

Definition at line 278 of file ModManager.cs.

    {
        if (!path.IsEmpty())
        {
            return path.NormalizePath().TrimEnd('/');
        }
        return "";
    }

Referenced by LoadLoadOrder().

◆ ParseExtra()

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

inline

Definition at line 1066 of file ModManager.cs.

    {
        ModPackage modPackage = (ModPackage)package;
        switch (dir.Name.ToLower())
        {
        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.

◆ QuerySubscriptions()

IEnumerator ModManager.QuerySubscriptions ( PublishedFileId_t[] subscribed )

inlineprivate

Definition at line 784 of file ModManager.cs.

    {
        WaitForEndOfFrame awaiter = new WaitForEndOfFrame();
        Text status = _loading.Log("Fetching subscriptions...");
        Dictionary<ulong, WorkshopItem> fetched = new Dictionary<ulong, WorkshopItem>();
        bool aborted = false;
        for (int i = 0; i < subscribed.Length; i += 50)
        {
            PublishedFileId_t[] array = subscribed.Skip(i).Take(50).ToArray();
            UgcQuery query = UgcQuery.Get(array);
            bool completed = false;
            bool discard = false;
            SetStatus(status, $"Fetching subscriptions {i + array.Length}/{subscribed.Length}...(Hit ESC to cancel)");
            if (query == null || !query.Execute(OnQueryCompleted))
            {
                Debug.LogWarning("Workshop: steam rejected the subscription query");
                query?.Dispose();
                aborted = true;
                break;
            }
            float deadline = Time.realtimeSinceStartup + 30f;
            while (!completed)
            {
                if (IsCancelRequested() || Time.realtimeSinceStartup > deadline)
                {
                    discard = true;
                    aborted = true;
                    query.Dispose();
                    break;
                }
                yield return awaiter;
            }
            if (aborted)
            {
                Debug.LogWarning("Workshop: subscription query cancelled or timed out");
                break;
            }
            void OnQueryCompleted(UgcQuery result)
            {
                completed = true;
                if (discard)
                {
                    return;
                }
                foreach (WorkshopItem results in result.ResultsList)
                {
                    SteamUGCDetails_t sourceItemDetails = results.SourceItemDetails;
                    if (sourceItemDetails.m_eResult == EResult.k_EResultOK && sourceItemDetails.m_nPublishedFileId.m_PublishedFileId != 0L)
                    {
                        fetched[sourceItemDetails.m_nPublishedFileId.m_PublishedFileId] = results;
                    }
                }
            }
        }
        foreach (WorkshopItem value in fetched.Values)
        {
            if (value.IsBanned)
            {
                _blockedItems.Add(value.FileId.m_PublishedFileId);
                _missingContent++;
            }
            else
            {
                AddWorkshopPackage(value);
            }
        }
        SetStatus(status, $"Fetched {fetched.Count}/{subscribed.Length} subscriptions");
        if (aborted)
        {
            yield break;
        }
        for (int j = 0; j < subscribed.Length; j++)
        {
            PublishedFileId_t publishedFileId_t = subscribed[j];
            if (!fetched.ContainsKey(publishedFileId_t.m_PublishedFileId) && !Directory.Exists(Path.Combine(dirWorkshop.FullName, publishedFileId_t.ToString())))
            {
                _missingContent++;
            }
        }
    }

References $, _blockedItems, _loading, _missingContent, AddWorkshopPackage(), Debug, IsCancelRequested(), LoadingScreen.Log(), and SetStatus().

Referenced by LoadWorkshopPackages().

◆ RefreshMods()

IEnumerator ModManager.RefreshMods	(	Action	onComplete,
		bool	syncMods
	)

inline

Definition at line 345 of file ModManager.cs.

    {
        if ((bool)_loading)
        {
            UnityEngine.Object.Destroy(_loading.gameObject);
        }
        _loading = Util.Instantiate<LoadingScreen>("LoadingScreen");
        bool flag = !BaseCore.IsOffline && syncMods && UserGeneratedContent.Client.GetNumSubscribedItems() != 0;
        WaitForEndOfFrame awaiter = new WaitForEndOfFrame();
        packages.Clear();
        _subscribedItems = null;
        _blockedItems.Clear();
        _missingContent = 0;
        disableMod |= Application.isEditor && EClass.debug.skipMod;
        LoadLocalPackages();
        LoadCustomPackage();
        if (!disableMod && dirWorkshop != null)
        {
            _loading.Log("Loading workshop contents...");
            if (flag)
            {
                yield return LoadWorkshopPackages();
            }
            LoadCachedWorkshopPackages();
        }
        InitPackagesMeta();
        SortPackages();
        List<BaseModPackage> list = packages.Where((BaseModPackage p) => p.CanActivate && !p.parseError.IsEmpty()).ToList();
        if (list.Count > 0)
        {
            Halt(list);
            yield break;
        }
        _loading.Log($"Total number of mods:{packages.Count}");
        _loading.Log("Activating Mods...");
        yield return awaiter;
        ActivatePackages();
        MapActivatedPackages();
        BaseModManager.isInitialized = true;
        yield return awaiter;
        onComplete?.Invoke();
        if ((bool)_loading)
        {
            UnityEngine.Object.Destroy(_loading.gameObject);
        }
        yield return null;
    }

References $, _blockedItems, _loading, _missingContent, _subscribedItems, ActivatePackages(), BaseModPackage.CanActivate, EClass.debug, disableMod, Halt(), InitPackagesMeta(), LoadCachedWorkshopPackages(), LoadCustomPackage(), LoadLocalPackages(), LoadWorkshopPackages(), LoadingScreen.Log(), MapActivatedPackages(), BaseModPackage.parseError, CoreDebug.skipMod, SortPackages(), and Util.

Referenced by Core.StartCase().

◆ RegisterLoaded()

static void ModManager.RegisterLoaded	(	BaseModPackage	p,
		Dictionary< string, BaseModPackage >	loaded,
		Dictionary< string, BaseModPackage >	claimed
	)

inlinestaticprivate

Definition at line 733 of file ModManager.cs.

    {
        if (p.builtin)
        {
            return;
        }
        string text = BaseModPackage.NormalizeId(p.id);
        if (text == null)
        {
            return;
        }
        loaded[text] = p;
        string[][] incompatible = p.incompatible;
        if (incompatible == null)
        {
            return;
        }
        string[][] array = incompatible;
        foreach (string[] array2 in array)
        {
            if (array2 == null)
            {
                continue;
            }
            string[] array3 = array2;
            for (int j = 0; j < array3.Length; j++)
            {
                string text2 = BaseModPackage.NormalizeId(array3[j]);
                if (text2 != null && !(text2 == text))
                {
                    claimed.TryAdd(text2, p);
                }
            }
        }
    }

References BaseModPackage.builtin, BaseModPackage.id, BaseModPackage.incompatible, and BaseModPackage.NormalizeId().

Referenced by ActivatePackageList().

◆ SaveLoadOrder()

void ModManager.SaveLoadOrder ( )

inline

Definition at line 106 of file ModManager.cs.

    {
        SplitGroups();
        if (disableMod)
        {
            return;
        }
        List<string> list = new List<string>();
        ModGroup modGroup = null;
        foreach (ModGroup emptyGroup in emptyGroups)
        {
            if (emptyGroup.after == null)
            {
                list.Add((modGroup = emptyGroup).ToString());
            }
        }
        foreach (BaseModPackage package in packages)
        {
            string str = package.dirInfo?.FullName;
            string text = ((package.builtin || str.IsEmpty()) ? "" : FormatLoadOrder(package));
            if (!text.IsEmpty())
            {
                if (package.group != modGroup)
                {
                    modGroup = package.group;
                    list.Add(modGroup?.ToString() ?? "#group");
                }
                list.Add(text);
            }
            foreach (ModGroup emptyGroup2 in emptyGroups)
            {
                if (emptyGroup2.after == package)
                {
                    list.Add((modGroup = emptyGroup2).ToString());
                }
            }
        }
        File.WriteAllLines(CorePath.PathLoadOrder, list);
    }

References ModGroup.after, BaseModPackage.dirInfo, disableMod, emptyGroups, FormatLoadOrder(), BaseModPackage.group, CorePath.PathLoadOrder, and SplitGroups().

Referenced by ApplyPreset(), LayerMod.OnKill(), LayerMod.OnReorder(), and LayerMod.SetModRow().

◆ SavePreset()

bool ModManager.SavePreset	(	string	name,
		out string	path
	)

inline

Definition at line 301 of file ModManager.cs.

    {
        path = GetPresetPath(name);
        ModLoadOrderPreset.Preset preset = ModLoadOrderPreset.Save(packages, name, EClass.core.version.GetText());
        if (disableMod || preset.entries.Count == 0)
        {
            return false;
        }
        Directory.CreateDirectory(CorePath.PathLoadOrderPreset);
        File.WriteAllText(path, ModLoadOrderPreset.Serialize(preset));
        return true;
    }

References EClass.core, disableMod, GetPresetPath(), Version.GetText(), CorePath.PathLoadOrderPreset, and BaseCore.version.

Referenced by LayerMod.WritePreset().

◆ SetStatus()

static void ModManager.SetStatus	(	Text	status,
		string	message
	)

inlinestaticprivate

Definition at line 1058 of file ModManager.cs.

    {
        if ((bool)status)
        {
            status.text = message;
        }
    }

Referenced by DownloadSubscriptions(), InitPackagesMeta(), and QuerySubscriptions().

◆ SortPackages()

void ModManager.SortPackages ( )

inlineprivate

Definition at line 402 of file ModManager.cs.

    {
        LoadLoadOrder();
        List<BaseModPackage> list = ModOrder.SolveOrder(packages, useLoadorder: true);
        if (list.Count != packages.Count)
        {
            Debug.LogError($"#mod order {list.Count} of {packages.Count} packages");
            return;
        }
        packages.Clear();
        packages.AddRange(list);
        SplitGroups();
    }

References $, Debug, LoadLoadOrder(), and SplitGroups().

Referenced by RefreshMods().

◆ SplitGroups()

void ModManager.SplitGroups ( )

inline

Definition at line 146 of file ModManager.cs.

    {
        HashSet<ModGroup> hashSet = new HashSet<ModGroup>();
        ModGroup modGroup = null;
        ModGroup modGroup2 = null;
        foreach (BaseModPackage package in packages)
        {
            if (package.group != modGroup)
            {
                modGroup = package.group;
                modGroup2 = ((modGroup == null || hashSet.Add(modGroup)) ? modGroup : modGroup.Clone());
            }
            package.group = modGroup2;
        }
        foreach (ModGroup emptyGroup in emptyGroups)
        {
            foreach (BaseModPackage package2 in packages)
            {
                if (package2.group != null && package2.group == emptyGroup.after?.group)
                {
                    emptyGroup.after = package2;
                }
            }
        }
    }

References ModGroup.after, emptyGroups, and BaseModPackage.group.

Referenced by SaveLoadOrder(), and SortPackages().

◆ TryLoadPresetFile()

bool ModManager.TryLoadPresetFile	(	FileInfo	file,
		out ModLoadOrderPreset::Preset	preset,
		out string	error
	)

inline

Definition at line 314 of file ModManager.cs.

    {
        preset = null;
        string text;
        try
        {
            text = File.ReadAllText(file.FullName);
        }
        catch (Exception ex)
        {
            error = ex.Message;
            return false;
        }
        if (!ModLoadOrderPreset.TryParse(text, out preset, out error))
        {
            return false;
        }
        if (preset.name.IsEmpty())
        {
            preset.name = Path.GetFileNameWithoutExtension(file.Name);
        }
        return true;
    }

Referenced by LayerMod.ApplyPresetFile().

◆ UnmetDependency()

string ModManager.UnmetDependency	(	BaseModPackage	p,
		Dictionary< string, BaseModPackage >	loaded,
		Dictionary< string, BaseModPackage >	installed
	)

inlineprivate

Definition at line 620 of file ModManager.cs.

    {
        if (p.dependency == null)
        {
            return null;
        }
        string[][] dependency = p.dependency;
        foreach (string[] array in dependency)
        {
            if (array == null || array.Length == 0)
            {
                continue;
            }
            BaseModPackage baseModPackage = null;
            BaseModPackage baseModPackage2 = null;
            bool flag = false;
            string[] array2 = array;
            for (int j = 0; j < array2.Length; j++)
            {
                string text = BaseModPackage.NormalizeId(array2[j]);
                if (text == null)
                {
                    continue;
                }
                if (loaded.ContainsKey(text))
                {
                    flag = true;
                    break;
                }
                if (!installed.TryGetValue(text, out var value) || value == p)
                {
                    continue;
                }
                if (packages.IndexOf(value) > packages.IndexOf(p))
                {
                    if (baseModPackage == null)
                    {
                        baseModPackage = value;
                    }
                }
                else if (baseModPackage2 == null)
                {
                    baseModPackage2 = value;
                }
            }
            if (!flag)
            {
                if (baseModPackage != null)
                {
                    return "mod_info_dep_order\t" + baseModPackage.title.IsEmpty(baseModPackage.dirInfo?.Name);
                }
                if (baseModPackage2 != null)
                {
                    return "mod_info_dep_failed\t" + baseModPackage2.title.IsEmpty(baseModPackage2.dirInfo?.Name);
                }
                return "mod_info_dep_missing\t" + string.Join('\t', array);
            }
        }
        return null;
    }

References BaseModPackage.dependency, BaseModPackage.dirInfo, installed, BaseModPackage.NormalizeId(), and BaseModPackage.title.

Referenced by ActivatePackageList().

Member Data Documentation

◆ _blockedItems

readonly HashSet<ulong> ModManager._blockedItems = new HashSet<ulong>()

private

Definition at line 51 of file ModManager.cs.

Referenced by LoadCachedWorkshopPackages(), QuerySubscriptions(), and RefreshMods().

◆ _loading

LoadingScreen ModManager._loading

private

Definition at line 43 of file ModManager.cs.

Referenced by ActivatePackageList(), DownloadSubscriptions(), InitPackagesMeta(), LoadCustomPackage(), LoadLocalPackages(), QuerySubscriptions(), and RefreshMods().

◆ _missingContent

int ModManager._missingContent

private

Definition at line 53 of file ModManager.cs.

Referenced by FailWorkshopPackage(), LoadWorkshopPackages(), QuerySubscriptions(), and RefreshMods().

◆ _subscribedItems

HashSet<ulong> ModManager._subscribedItems

private

Definition at line 49 of file ModManager.cs.

Referenced by LoadCachedWorkshopPackages(), LoadWorkshopPackages(), and RefreshMods().

◆ disableMod

bool ModManager.disableMod

static

Definition at line 41 of file ModManager.cs.

Referenced by ActivatePackageList(), LoadLocalPackages(), LayerMod.NewGroup(), RefreshMods(), SaveLoadOrder(), SavePreset(), LayerMod.ShowPresetMenu(), and Core.StartCase().

◆ emptyGroups

readonly List<ModGroup> ModManager.emptyGroups = new List<ModGroup>()

Definition at line 47 of file ModManager.cs.

Referenced by LayerMod.CreateCallbacks(), LayerMod.GetGroupIndex(), LayerMod.Groups(), LayerMod.LeaveGroup(), LoadLoadOrder(), LayerMod.MoveTo(), LayerMod.NewGroup(), LayerMod.OnReorder(), SaveLoadOrder(), LayerMod.SetGroup(), LayerMod.SetGroupRow(), and SplitGroups().

◆ ListPluginObject

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

static

Definition at line 39 of file ModManager.cs.

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

◆ replaceFiles

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

Definition at line 45 of file ModManager.cs.

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

Property Documentation

◆ DirWorkshop

DirectoryInfo ModManager.DirWorkshop

staticget

Definition at line 57 of file ModManager.cs.

Referenced by AddWorkshopPackage().

◆ Instance

new ModManager ModManager.Instance

staticget

Definition at line 61 of file ModManager.cs.

◆ IsInitialized

bool ModManager.IsInitialized

staticget

Definition at line 59 of file ModManager.cs.

Referenced by Core.StartCase().

◆ ListChainLoad

List<string> ModManager.ListChainLoad

staticget

Definition at line 55 of file ModManager.cs.

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

Elin/ModManager.cs

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ AbortDownloads()

◆ ActivatePackageList()

◆ ActivatePackages()

◆ AddPackage()

◆ AddWorkshopPackage()

◆ ApplyPreset()

◆ CountUserMod()

◆ DownloadSubscriptions()

◆ FailWorkshopPackage()

◆ FindIncompatible()

◆ FormatLoadOrder()

◆ GetPresetPath()

◆ Halt()

◆ Init()

◆ InitPackagesMeta()

◆ InstallWorkshopPackage()

◆ IsCancelRequested()

◆ IsItemReady()

◆ ListPresets()

◆ LoadCachedWorkshopPackages()

◆ LoadCustomPackage()

◆ LoadLoadOrder()

◆ LoadLocalPackages()

◆ LoadWorkshopPackages()

◆ MapActivatedPackages()

◆ NormalizeOrderPath()

◆ ParseExtra()

◆ QuerySubscriptions()

◆ RefreshMods()

◆ RegisterLoaded()

◆ SaveLoadOrder()

◆ SavePreset()

◆ SetStatus()

◆ SortPackages()

◆ SplitGroups()

◆ TryLoadPresetFile()

◆ UnmetDependency()

Member Data Documentation

◆ _blockedItems

◆ _loading

◆ _missingContent

◆ _subscribedItems

◆ disableMod

◆ emptyGroups

◆ ListPluginObject

◆ replaceFiles

Property Documentation

◆ DirWorkshop

◆ Instance

◆ IsInitialized

◆ ListChainLoad