ModManager.cs File Reference

Go to the source code of this file.

Classes
class	ModManager
class	ModManager.WorkshopDownload

Functions
	[instance initializer]
	... (HitESCtocancel)"$"Fetched

Variables
	$ {arg}
$	Initializingmods
$	Fetchingsubscriptions
$	ownloading ={item.IsDownloading}
mods...$	Installed ={item.IsInstalled}
mods...$ $	Update ={item.IsNeedsUpdate}

Function Documentation

...()

DownloadSubscriptions....

(

HitESCtocancel

)

Definition at line 794 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;
        }
    }
 
    public void LoadCachedWorkshopPackages()
    {
        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;
                }
            }
        }
    }
 
    private void InstallWorkshopPackage(WorkshopDownload download, string path)
    {
        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);
    }
 
    private void FailWorkshopPackage(WorkshopDownload download, string reason)
    {
        if (download.isUpdate)
        {
            Debug.LogWarning("Workshop update failed: " + download.Title + ", " + reason);
            return;
        }
        _missingContent++;
        Debug.LogWarning("Workshop download failed: " + download.Title + ", " + reason);
    }
 
    private void AbortDownloads(List<WorkshopDownload> queue, string reason)
    {
        foreach (WorkshopDownload item in queue)
        {
            FailWorkshopPackage(item, reason);
        }
        queue.Clear();
    }
 
    private static bool IsItemReady(WorkshopItem item, out string path)
    {
        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;
    }
 
    private static bool IsCancelRequested()
    {
        return UnityEngine.Input.GetKey(KeyCode.Escape);
    }
 
    private static void SetStatus(Text status, string message)
    {
        if ((bool)status)
        {
            status.text = message;
        }
    }
 
    public override void ParseExtra(DirectoryInfo dir, BaseModPackage package)
    {
        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;
        }
    }
}

[instance initializer]()

SaveLoadOrder.[instance initializer]

Definition at line 104 of file ModManager.cs.

Variable Documentation

$

$ {arg}

Definition at line 104 of file ModManager.cs.

Referenced by ModManager.ActivatePackageList(), ModManager.DownloadSubscriptions(), ModManager.FormatLoadOrder(), ModManager.InitPackagesMeta(), ModManager.QuerySubscriptions(), ModManager.RefreshMods(), and ModManager.SortPackages().

Fetchingsubscriptions

$ Fetchingsubscriptions

Definition at line 794 of file ModManager.cs.

Initializingmods

$ Initializingmods

Definition at line 465 of file ModManager.cs.

Installed

mods...$ Installed ={item.IsInstalled}

Definition at line 917 of file ModManager.cs.

Referenced by Zone.SpawnAltar().

ownloading

mods $ $ $ ownloading ={item.IsDownloading}

Definition at line 917 of file ModManager.cs.

Update

mods...$ $ Update ={item.IsNeedsUpdate}

Definition at line 917 of file ModManager.cs.

Referenced by PointTarget.CycleTarget().