Ejemplo n.º 1
0
 private void CreateExtensionInSteam(ExtensionInfo info)
 {
     this.m_CreateItemResult.Set(SteamUGC.CreateItem(this.hacknetAppID, EWorkshopFileType.k_EWorkshopFileTypeFirst), (CallResult <CreateItemResult_t> .APIDispatchDelegate)null);
     this.showLoadingSpinner  = true;
     this.currentTitleMessage = "Creating Extension with Steam...";
 }
Ejemplo n.º 2
0
        public void Update()
        {
            switch (State)
            {
            case States.Creating:
                if (Mod.SteamID == 0)
                {
                    CreateCallResult = CallResult <CreateItemResult_t> .Create((callback, IOFailure) =>
                    {
                        if (IOFailure)
                        {
                            State   = States.Done;
                            Message = "There was an error communicating with steam.";
                            Status  = UGCStatus.Failure;
                            return;
                        }

                        if (callback.m_eResult != EResult.k_EResultOK)
                        {
                            State   = States.Done;
                            Status  = UGCStatus.Failure;
                            Message = String.Format("Creating new item failed: {0}", callback.m_eResult);
                            return;
                        }

                        Mod.SteamID = (ulong)callback.m_nPublishedFileId;
                        Mod.Save();

                        State = States.Initializing;
                    });

                    CreateCallResult.Set(SteamUGC.CreateItem(Steam.AppID, EWorkshopFileType.k_EWorkshopFileTypeCommunity));
                    State   = States.WaitingForCreation;
                    Message = "Creating new UGC Item";
                }
                else
                {
                    State   = States.Initializing;
                    Message = "Initializing update";
                }
                return;

            case States.WaitingForCreation:
                return;

            case States.Initializing:
                UpdateHandle = SteamUGC.StartItemUpdate(Steam.AppID, (PublishedFileId_t)Mod.SteamID);
                SteamUGC.SetItemTitle(UpdateHandle, Mod.Name);
                SteamUGC.SetItemDescription(UpdateHandle, Mod.Description);
                SteamUGC.SetItemVisibility(UpdateHandle, ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic);
                SteamUGC.SetItemPreview(UpdateHandle, System.IO.Path.GetFullPath(Mod.Directory) + Program.DirChar + Mod.PreviewURL);
                SteamUGC.SetItemContent(UpdateHandle, System.IO.Path.GetFullPath(Mod.Directory));
                State   = States.Submitting;
                Message = "Submitting";
                return;

            case States.Submitting:
                SubmitCallResult = CallResult <SubmitItemUpdateResult_t> .Create((callback, IOFailure) =>
                {
                    if (IOFailure)
                    {
                        State   = States.Done;
                        Status  = UGCStatus.Failure;
                        Message = "There was an error communicating with steam.";
                        return;
                    }

                    if (callback.m_eResult != EResult.k_EResultOK)
                    {
                        State   = States.Done;
                        Status  = UGCStatus.Failure;
                        Message = String.Format("Update item failed: {0}", callback.m_eResult);
                        return;
                    }

                    State   = States.Done;
                    Status  = UGCStatus.Success;
                    Message = "Successfully updated mod";
                });

                SubmitCallResult.Set(SteamUGC.SubmitItemUpdate(UpdateHandle, Mod.ChangeNote));
                State = States.WaitingForSubmission;
                return;

            case States.WaitingForSubmission:
            {
                ulong bytesProcessed = 0;
                ulong totalBytes     = 0;
                SteamUGC.GetItemUpdateProgress(UpdateHandle, out bytesProcessed, out totalBytes);
                Message = String.Format("Submitting {0} of {1}", bytesProcessed, totalBytes);
            }
                return;

            case States.Done:
                return;
            }
        }
Ejemplo n.º 3
0
 public static void DownloadItem(ulong id)
 {
     _downloadItemCallback = Callback<DownloadItemResult_t>.Create(ItemDownloaded);
     SteamUGC.DownloadItem(new PublishedFileId_t(id), true);
 }
Ejemplo n.º 4
0
        private async Task <GameLoadResult> _CreateGameAsync(string mapName, string gamemode)
        {
            DevConsole.SetVariable("game.mode", gamemode, true, true);

            State = GameLoaderState.ChangingMap;

            LoadingHint = "Loading map: " + mapName;

            if (ulong.TryParse(mapName, out ulong workshopId))
            {
                LoadingHint = "Downloading map from workshop";

                if (!SteamServer.IsValid &&
                    !SteamClient.IsValid)
                {
                    return(GameLoadResult.FailedToLoadMap);
                }

                var item = await Item.GetAsync(workshopId);

                if (!item.HasValue)
                {
                    return(GameLoadResult.FailedToLoadMap);
                }

                var download = await SteamUGC.DownloadAsync(workshopId);

                if (!download)
                {
                    return(GameLoadResult.FailedToLoadMap);
                }

                var provider = FileSystem.AddLocalProvider(item.Value.Directory);
                FileSystem.Build();
                foreach (var file in provider.Files)
                {
                    file.Value.WorkshopId = workshopId;
                }
            }

            if (MapLoader.Instance.CurrentMap == null || MapLoader.Instance.CurrentMap.Name != mapName)
            {
                var mapLoadResult = await MapLoader.Instance.LoadMapAsync2(mapName);

                if (mapLoadResult != MapLoadState.Loaded)
                {
                    return(GameLoadResult.FailedToLoadMap);
                }
            }

            if (_cancelled)
            {
                return(GameLoadResult.Cancelled);
            }

            PreGameLoaded?.Invoke();

            LoadingHint = "Loading gamemode: " + gamemode;

            var gamemodeLoaded = Game.GamemodeLoader.LoadGamemode(gamemode);

            if (!gamemodeLoaded)
            {
                return(GameLoadResult.FailedToLoadGamemode);
            }
            GameLoaded?.Invoke();

            State = GameLoaderState.Playing;

            LoadingHint = "Done, game is created.";

            return(GameLoadResult.Success);
        }
    protected void OnGUI()
    {
        if (!SteamAPI.IsSteamRunning())
        {
            EditorGUILayout.HelpBox("Steam is not running. Please start Steam to continue.", MessageType.Error);
        }
        else if (ModConfig.Instance == null || string.IsNullOrEmpty(ModConfig.ID))
        {
            EditorGUILayout.HelpBox("You must configure your ModConfig using \"Keep Talking Mod Kit -> Configure Mod\".", MessageType.Error);
        }
        else if (!isInitialized)
        {
            EditorGUILayout.HelpBox("You must log in to Steam to continue.", MessageType.Error);
        }
        else
        {
            if (currentWorkshopItem == null)
            {
                string workshopItemAssetPath = "Assets/Editor/Resources/WorkshopItem.asset";

                currentWorkshopItem = AssetDatabase.LoadAssetAtPath <WorkshopItem>(workshopItemAssetPath);

                if (currentWorkshopItem == null)
                {
                    currentWorkshopItem = ScriptableObject.CreateInstance <WorkshopItem>();

                    if (ModConfig.Instance != null)
                    {
                        currentWorkshopItem.Title = ModConfig.Title;
                    }

                    AssetDatabase.CreateAsset(currentWorkshopItem, workshopItemAssetPath);
                }

                if (workshopItemEditor != null && workshopItemEditor.target != currentWorkshopItem)
                {
                    DestroyImmediate(workshopItemEditor);
                    workshopItemEditor = null;
                }

                if (workshopItemEditor == null)
                {
                    workshopItemEditor = (WorkshopItemEditor)Editor.CreateEditor(currentWorkshopItem, typeof(WorkshopItemEditor));
                }
            }

            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
            workshopItemEditor.OnInspectorGUI();

            //Publishing Tools
            EditorGUILayout.Separator();
            Color oldBGColor = GUI.backgroundColor;
            GUI.backgroundColor = new Color(0.1f, 0.1f, 0.5f, 0.7f);
            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
            GUI.backgroundColor = oldBGColor;

            EditorGUILayout.LabelField("Publishing Tools", EditorStyles.largeLabel);
            EditorGUILayout.Separator();
            EditorGUILayout.LabelField("User:"******"Content Folder:", GetContentPath());

            DirectoryInfo dir = new DirectoryInfo(GetContentPath());

            if (dir.Exists)
            {
                FileInfo[] files     = dir.GetFiles("*.*", SearchOption.AllDirectories);
                long       totalSize = 0;
                foreach (var file in files)
                {
                    totalSize += file.Length;
                }

                EditorGUILayout.LabelField("File Count:", files.Length.ToString());
                EditorGUILayout.LabelField("Total Size:", FormatFileSize(totalSize));
            }
            else
            {
                EditorGUILayout.HelpBox("Content folder not found", MessageType.Error);
            }

            string[] tags = GetTags();
            if (tags == null)
            {
                EditorGUILayout.LabelField("Tags [0]: (none set)");
            }
            else
            {
                EditorGUILayout.LabelField(string.Format("Tags [{0}]: {1}", tags == null ? "0" : tags.Length.ToString(), string.Join(", ", tags)));
            }

            //Change Notes
            EditorGUILayout.PrefixLabel("Change Notes:");
            changeNotes = EditorGUILayout.TextArea(changeNotes, GUILayout.MinHeight(64));

            if (string.IsNullOrEmpty(changeNotes))
            {
                EditorGUILayout.HelpBox("Change notes must be entered before publishing to Workshop", MessageType.Warning);
            }


            //Publishing changes
            if (currentWorkshopItem.WorkshopPublishedFileID == 0)
            {
                //Create and Publish
                GUI.enabled = (onCreateItemCallResultHandler != null && !onCreateItemCallResultHandler.IsActive() && !string.IsNullOrEmpty(changeNotes));
                if (GUILayout.Button("Create New Workshop Item and Publish to Steam"))
                {
                    Debug.Log("CreateItem");
                    var createItemCall = SteamUGC.CreateItem(KTANE_APP_ID, EWorkshopFileType.k_EWorkshopFileTypeCommunity);
                    onCreateItemCallResultHandler.Set(createItemCall);
                }
                GUI.enabled = true;
            }
            else
            {
                //Publish to Existing Item
                GUI.enabled = (onItemUpdateCallResultHandler != null && !onItemUpdateCallResultHandler.IsActive() && !string.IsNullOrEmpty(changeNotes));
                if (GUILayout.Button("Publish Changes to Steam"))
                {
                    PublishWorkshopChanges();
                }

                if (!string.IsNullOrEmpty(ugcUpdateStatus))
                {
                    EditorGUILayout.LabelField(ugcUpdateStatus);
                }

                GUI.enabled = true;
            }
            EditorGUILayout.EndVertical();
            EditorGUILayout.EndScrollView();
        }
    }
Ejemplo n.º 6
0
        private void ExportLoadButtonClick(object sender, EventArgs e)
        {
            var dialog = new OpenFileDialog
            {
                Filter          = "Text files|*.txt",
                DefaultExt      = "txt",
                CheckPathExists = true,
                CheckFileExists = true,
                Multiselect     = false,
            };

            if (dialog.ShowDialog() != DialogResult.OK)
            {
                return;
            }

            bool OverrideTags;

            if (!Settings.NeverImportTags)
            {
                OverrideTags = MessageBox.Show("Do you want to override the tags and categories of your current mods with the tags saved in your profile?\r\n" +
                                               "Warning: This action cannot be undone", "Importing profile", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes;
            }
            else
            {
                OverrideTags = false;
            }
            // parse file

            var categoryRegex = new Regex(@"^(?<category>.*?)\s\(\d*\):$", RegexOptions.Compiled | RegexOptions.Multiline);
            var modEntryRegex = new Regex(@"^\s*(?<name>.*?)[ ]*\t(?<id>.*?)[ ]*\t(?:.*=)?(?<sourceID>\d+)([ ]*\t(?<tags>.*?))?$", RegexOptions.Compiled | RegexOptions.Multiline);

            var mods         = Mods.All.ToList();
            var activeMods   = new List <ModEntry>();
            var missingMods  = new List <Match>();
            var categoryName = "";

            foreach (var line in File.ReadAllLines(dialog.FileName))
            {
                var categoryMatch = categoryRegex.Match(line);
                if (categoryMatch.Success)
                {
                    categoryName = categoryMatch.Groups["category"].Value;
                }

                var modMatch = modEntryRegex.Match(line);
                if (!modMatch.Success)
                {
                    continue;
                }

                var entries = mods.Where(mod => mod.ID == modMatch.Groups["id"].Value).ToList();

                if (entries.Count == 0)
                {
                    // Mod missing
                    // -> add to list
                    missingMods.Add(modMatch);
                    continue;
                }

                activeMods.AddRange(entries);

                if (OverrideTags)
                {
                    var tags = modMatch.Groups["tags"].Value.Split(';').Where(t => !string.IsNullOrWhiteSpace(t)).ToList();

                    foreach (var tag in tags)
                    {
                        if (AvailableTags.ContainsKey(tag.ToLower()) == false)
                        {
                            AvailableTags[tag.ToLower()] = new ModTag(tag);
                        }
                    }

                    foreach (var modEntry in entries)
                    {
                        modEntry.Tags = tags;
                        Mods.RemoveMod(modEntry);
                        Mods.AddMod(categoryName, modEntry);
                    }
                }
            }

            // Check entries
            if (activeMods.Count == 0)
            {
                MessageBox.Show("No mods found. Bad profile?", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            // Check missing
            if (missingMods.Count > 0)
            {
                var steamMissingMods = missingMods.Where(match => match.Groups["sourceID"].Value != "Unknown").ToList();

                var text = $"This profile contains {missingMods.Count} mod(s) that are not currently installed:\r\n\r\n";

                foreach (var match in missingMods)
                {
                    text += match.Groups["name"].Value;

                    if (steamMissingMods.Contains(match))
                    {
                        text += "*";
                    }

                    text += "\r\n";
                }

                if (steamMissingMods.Count != 0)
                {
                    text += "\r\nDo you want to subscribe to the mods marked with an asterisk on Steam?";

                    var result = FlexibleMessageBox.Show(this, text, "Mods missing!", MessageBoxButtons.YesNoCancel);

                    if (result == DialogResult.Cancel)
                    {
                        return;
                    }

                    if (result == DialogResult.Yes)
                    {
                        // subscribe
                        foreach (var id in steamMissingMods.Select(match => ulong.Parse(match.Groups["sourceID"].Value)))
                        {
                            SteamUGC.SubscribeItem(id.ToPublishedFileID());
                        }

                        MessageBox.Show("Done. Close the launcher, wait for steam to download the mod(s) and try again.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }
                }
                else
                {
                    text += "\r\nDo you wish to continue?";

                    if (FlexibleMessageBox.Show(this, text, "Mods missing!", MessageBoxButtons.YesNo) == DialogResult.No)
                    {
                        return;
                    }
                }
            }

            // Confirm
            if (FlexibleMessageBox.Show(this, $"Adopt profile? {activeMods.Count} mods found.", "Confirm", MessageBoxButtons.YesNo) == DialogResult.No)
            {
                return;
            }

            // Apply changes
            foreach (var mod in mods)
            {
                mod.isActive = false;
            }

            foreach (var mod in activeMods)
            {
                mod.isActive = true;
            }

            modlist_ListObjectListView.RefreshObjects(mods);

            UpdateExport();
            UpdateLabels();
        }
 /// <summary>
 /// Start downloading this item.
 /// If this returns false the item isn't getting downloaded.
 /// </summary>
 public bool Download(bool highPriority = false)
 {
     return(SteamUGC.Download(Id, highPriority));
 }
Ejemplo n.º 8
0
        public static bool Upload(Mod mod, string changeNotes)
        {
            if (string.IsNullOrEmpty(changeNotes))
            {
                changeNotes = $"[Auto-generated text]: Update on {DateTime.Now:yyyy-MM-dd HH:mm:ss}";
            }
            var creating = false;

            if (mod.PublishedFileId == PublishedFileId_t.Invalid)
            {
                // create item first.
                creating = true;
                Console.WriteLine("No PublishedFileId found, create new mod?");
                Console.ReadLine();

                if (!Create(mod))
                {
                    throw new Exception("mod creation failed!");
                }
            }

            // set up steam API call
            var handle = SteamUGC.StartItemUpdate(RIMWORLD, mod.PublishedFileId);

            SetItemAttributes(handle, mod, creating);

            // start async call
            var call = SteamUGC.SubmitItemUpdate(handle, changeNotes);

            submitResultCallback = CallResult <SubmitItemUpdateResult_t> .Create(OnItemSubmitted);

            submitResultCallback.Set(call);

            // keep checking for async call to complete
            var lastStatus = "";
            var niceStatus = "";

            while (!ready.WaitOne(500))
            {
                var status = SteamUGC.GetItemUpdateProgress(handle, out ulong done, out ulong total);
                SteamAPI.RunCallbacks();
                if (lastStatus != status.ToString() && status.ToString() != "k_EItemUpdateStatusInvalid")
                {
                    niceStatus = status.ToString().Replace("k_EItemUpdateStatus", "");
                    niceStatus = Regex.Replace(niceStatus, "(\\B[A-Z])", " $1");
                    switch (niceStatus)
                    {
                    case "Uploading Content":
                        Console.WriteLine($"{niceStatus} ({Math.Round((double)mod.ModBytes / 1000)} KB)");
                        break;

                    case "Uploading Preview File":
                        Console.WriteLine($"{niceStatus} ({Math.Round((double)mod.PreviewBytes / 1000)} KB)");
                        break;

                    default:
                        Console.WriteLine(niceStatus);
                        break;
                    }
                    lastStatus = status.ToString();
                }
            }

            // we have completed!
            if (submitResult.m_eResult != EResult.k_EResultOK)
            {
                Console.WriteLine($"Unexpected result: {submitResult.m_eResult}");
            }
            return(submitResult.m_eResult == EResult.k_EResultOK);
        }
Ejemplo n.º 9
0
 public void GetSubscribedItems(out PublishedFileId_t[] subscribedItems, out uint numberOfSubscribedItems)
 {
     numberOfSubscribedItems = SteamUGC.GetNumSubscribedItems();
     subscribedItems         = new PublishedFileId_t[numberOfSubscribedItems];
     SteamUGC.GetSubscribedItems(subscribedItems, numberOfSubscribedItems);
 }
 /// <summary>
 /// Not sure if this is needed. Accessing the ISteamUGC API. The API must be accessed through the pointer that is returned from SteamUGC().
 /// </summary>
 public SteamAPICall_t getID(PublishedFileId_t workshopItemID)
 {
     return(SteamUGC.RequestUGCDetails(workshopItemID, 60));
 }
Ejemplo n.º 11
0
 private void LoadExtensions()
 {
     if (!Directory.Exists("Extensions/"))
     {
         Directory.CreateDirectory("Extensions/");
     }
     foreach (string directory in Directory.GetDirectories("Extensions/"))
     {
         this.AddExtensionSafe(directory);
     }
     this.DefaultModImage = Game1.getSingleton().Content.Load <Texture2D>("Sprites/Hammer");
     if (PlatformAPISettings.Running)
     {
         PublishedFileId_t[] pvecPublishedFileID = new PublishedFileId_t[200];
         uint subscribedItems = SteamUGC.GetSubscribedItems(pvecPublishedFileID, 200U);
         Console.WriteLine(subscribedItems);
         if (pvecPublishedFileID != null)
         {
             for (int index = 0; (long)index < (long)subscribedItems; ++index)
             {
                 if (((EItemState)Enum.Parse(typeof(EItemState), string.Concat((object)SteamUGC.GetItemState(pvecPublishedFileID[index])))).HasFlag((Enum)EItemState.k_EItemStateInstalled))
                 {
                     ulong  punSizeOnDisk = 0;
                     string pchFolder     = (string)null;
                     uint   cchFolderSize = 20000;
                     uint   punTimeStamp  = 0;
                     Console.WriteLine((SteamUGC.GetItemInstallInfo(pvecPublishedFileID[index], out punSizeOnDisk, out pchFolder, cchFolderSize, out punTimeStamp) ? "Installed" : "Uninstalled") + " Extension at: " + pchFolder);
                     this.AddExtensionSafe(pchFolder);
                 }
             }
         }
     }
     this.HasLoaded = true;
 }
    public void RenderOnGUI()
    {
        //GUILayout.BeginArea(new Rect(Screen.width - 120, 0, 120, Screen.height));
        Console.WriteLine("Variables:");
        Console.WriteLine("m_UGCQueryHandle: " + m_UGCQueryHandle);
        Console.WriteLine("m_PublishedFileId: " + m_PublishedFileId);
        Console.WriteLine("m_UGCUpdateHandle: " + m_UGCUpdateHandle);
        //GUILayout.EndArea();

        //if (GUILayout.Button("CreateQueryUserUGCRequest(SteamUser.GetSteamID().GetAccountID(), EUserUGCList.k_EUserUGCList_Published, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Screenshots, EUserUGCListSortOrder.k_EUserUGCListSortOrder_CreationOrderDesc, AppId_t.Invalid, SteamUtils.GetAppID(), 1)"))
        {
            m_UGCQueryHandle = SteamUGC.CreateQueryUserUGCRequest(SteamUser.GetSteamID().GetAccountID(), EUserUGCList.k_EUserUGCList_Published, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Screenshots, EUserUGCListSortOrder.k_EUserUGCListSortOrder_CreationOrderDesc, AppId_t.Invalid, SteamUtils.GetAppID(), 1);
            Console.WriteLine("SteamUGC.CreateQueryUserUGCRequest(" + SteamUser.GetSteamID().GetAccountID() + ", EUserUGCList.k_EUserUGCList_Published, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Screenshots, EUserUGCListSortOrder.k_EUserUGCListSortOrder_CreationOrderDesc, " + AppId_t.Invalid + ", " + SteamUtils.GetAppID() + ", 1) : " + m_UGCQueryHandle);
        }

        //if (GUILayout.Button("CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByPublicationDate, EUGCMatchingUGCType.k_EUGCMatchingUGCType_AllGuides, AppId_t.Invalid, SteamUtils.GetAppID(), 1)"))
        {
            m_UGCQueryHandle = SteamUGC.CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByPublicationDate, EUGCMatchingUGCType.k_EUGCMatchingUGCType_AllGuides, AppId_t.Invalid, SteamUtils.GetAppID(), 1);
            Console.WriteLine("SteamUGC.CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByPublicationDate, EUGCMatchingUGCType.k_EUGCMatchingUGCType_AllGuides, " + AppId_t.Invalid + ", " + SteamUtils.GetAppID() + ", 1) : " + m_UGCQueryHandle);
        }

        //if (GUILayout.Button("SendQueryUGCRequest(m_UGCQueryHandle)"))
        {
            SteamAPICall_t handle = SteamUGC.SendQueryUGCRequest(m_UGCQueryHandle);
            OnSteamUGCQueryCompletedCallResult.Set(handle);
            Console.WriteLine("SteamUGC.SendQueryUGCRequest(" + m_UGCQueryHandle + ") : " + handle);
        }

        //if (GUILayout.Button("GetQueryUGCResult(m_UGCQueryHandle, 0, out Details)"))
        {
            SteamUGCDetails_t Details;
            bool ret = SteamUGC.GetQueryUGCResult(m_UGCQueryHandle, 0, out Details);
            Console.WriteLine("SteamUGC.GetQueryUGCResult(" + m_UGCQueryHandle + ", 0, out Details) : " + ret);
            Console.WriteLine(Details.m_nPublishedFileId + " -- " + Details.m_eResult + " -- " + Details.m_eFileType + " -- " + Details.m_nCreatorAppID + " -- " + Details.m_nConsumerAppID + " -- " + Details.m_rgchTitle + " -- " + Details.m_rgchDescription + " -- " + Details.m_ulSteamIDOwner + " -- " + Details.m_rtimeCreated + " -- " + Details.m_rtimeUpdated + " -- " + Details.m_rtimeAddedToUserList + " -- " + Details.m_eVisibility + " -- " + Details.m_bBanned + " -- " + Details.m_bAcceptedForUse + " -- " + Details.m_bTagsTruncated + " -- " + Details.m_rgchTags + " -- " + Details.m_hFile + " -- " + Details.m_hPreviewFile + " -- " + Details.m_pchFileName + " -- " + Details.m_nFileSize + " -- " + Details.m_nPreviewFileSize + " -- " + Details.m_rgchURL + " -- " + Details.m_unVotesUp + " -- " + Details.m_unVotesDown + " -- " + Details.m_flScore + " -- " + Details.m_unNumChildren);
        }

        //if (GUILayout.Button("ReleaseQueryUGCRequest(m_UGCQueryHandle)"))
        {
            Console.WriteLine("SteamUGC.ReleaseQueryUGCRequest(" + m_UGCQueryHandle + ") : " + SteamUGC.ReleaseQueryUGCRequest(m_UGCQueryHandle));
        }

        //if (GUILayout.Button("AddRequiredTag(m_UGCQueryHandle, \"Co-op\")"))
        {
            Console.WriteLine("SteamUGC.AddRequiredTag(" + m_UGCQueryHandle + ", \"Co-op\") : " + SteamUGC.AddRequiredTag(m_UGCQueryHandle, "Co-op"));
        }

        //if (GUILayout.Button("AddExcludedTag(m_UGCQueryHandle, \"Co-op\")"))
        {
            Console.WriteLine("SteamUGC.AddExcludedTag(" + m_UGCQueryHandle + ", \"Co-op\") : " + SteamUGC.AddExcludedTag(m_UGCQueryHandle, "Co-op"));
        }

        //if (GUILayout.Button("SetReturnLongDescription(m_UGCQueryHandle, true)"))
        {
            Console.WriteLine("SteamUGC.SetReturnLongDescription(" + m_UGCQueryHandle + ", true) : " + SteamUGC.SetReturnLongDescription(m_UGCQueryHandle, true));
        }

        // if (GUILayout.Button("SetReturnTotalOnly(m_UGCQueryHandle, true)"))
        {
            Console.WriteLine("SteamUGC.SetReturnTotalOnly(" + m_UGCQueryHandle + ", true) : " + SteamUGC.SetReturnTotalOnly(m_UGCQueryHandle, true));
        }

        //if (GUILayout.Button("SetAllowCachedResponse(m_UGCQueryHandle, 5)"))
        {
            Console.WriteLine("SteamUGC.SetAllowCachedResponse(" + m_UGCQueryHandle + ", 5) : " + SteamUGC.SetAllowCachedResponse(m_UGCQueryHandle, 5));
        }

        //if (GUILayout.Button("SetCloudFileNameFilter(m_UGCQueryHandle, \"\")"))
        {
            Console.WriteLine("SteamUGC.SetCloudFileNameFilter(" + m_UGCQueryHandle + ", \"\") : " + SteamUGC.SetCloudFileNameFilter(m_UGCQueryHandle, ""));
        }

        //if (GUILayout.Button("SetMatchAnyTag(m_UGCQueryHandle, true)"))
        {
            Console.WriteLine("SteamUGC.SetMatchAnyTag(" + m_UGCQueryHandle + ", true) : " + SteamUGC.SetMatchAnyTag(m_UGCQueryHandle, true));
        }

        //if (GUILayout.Button("SetSearchText(m_UGCQueryHandle, \"AciD\")"))
        {
            Console.WriteLine("SteamUGC.SetSearchText(" + m_UGCQueryHandle + ", \"AciD\") : " + SteamUGC.SetSearchText(m_UGCQueryHandle, "AciD"));
        }

        //if (GUILayout.Button("SetRankedByTrendDays(m_UGCQueryHandle, 7)"))
        {
            Console.WriteLine("SteamUGC.SetRankedByTrendDays(" + m_UGCQueryHandle + ", 7) : " + SteamUGC.SetRankedByTrendDays(m_UGCQueryHandle, 7));
        }

        //if (GUILayout.Button("RequestUGCDetails(m_PublishedFileId, 5)"))
        {
            SteamAPICall_t handle = SteamUGC.RequestUGCDetails(m_PublishedFileId, 5);
            OnSteamUGCRequestUGCDetailsResultCallResult.Set(handle);
            Console.WriteLine("SteamUGC.RequestUGCDetails(m_PublishedFileId, 5) : " + handle);
        }

        //if (GUILayout.Button("CreateItem((AppId_t)480, EWorkshopFileType.k_EWorkshopFileTypeWebGuide)"))
        {
            SteamAPICall_t handle = SteamUGC.CreateItem((AppId_t)480, EWorkshopFileType.k_EWorkshopFileTypeWebGuide);
            OnCreateItemResultCallResult.Set(handle);
            Console.WriteLine("SteamUGC.CreateItem((AppId_t)480, EWorkshopFileType.k_EWorkshopFileTypeWebGuide) : " + handle);
        }

        //if (GUILayout.Button("StartItemUpdate((AppId_t)480, m_PublishedFileId)"))
        {
            m_UGCUpdateHandle = SteamUGC.StartItemUpdate((AppId_t)480, m_PublishedFileId);
            Console.WriteLine("SteamUGC.StartItemUpdate((AppId_t)480, " + m_PublishedFileId + ") : " + m_UGCUpdateHandle);
        }

        // if (GUILayout.Button("SetItemTitle(m_UGCUpdateHandle, \"This is a Test\")"))
        {
            bool ret = SteamUGC.SetItemTitle(m_UGCUpdateHandle, "This is a Test");
            Console.WriteLine("SteamUGC.SetItemTitle(" + m_UGCUpdateHandle + ", \"This is a Test\") : " + ret);
        }

        //if (GUILayout.Button("SetItemDescription(m_UGCUpdateHandle, \"This is the test description.\")"))
        {
            bool ret = SteamUGC.SetItemDescription(m_UGCUpdateHandle, "This is the test description.");
            Console.WriteLine("SteamUGC.SetItemDescription(" + m_UGCUpdateHandle + ", \"This is the test description.\") : " + ret);
        }

        //if (GUILayout.Button("SetItemVisibility(m_UGCUpdateHandle, ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPrivate)"))
        {
            bool ret = SteamUGC.SetItemVisibility(m_UGCUpdateHandle, ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPrivate);
            Console.WriteLine("SteamUGC.SetItemVisibility(" + m_UGCUpdateHandle + ", ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPrivate) : " + ret);
        }

        //if (GUILayout.Button("SetItemTags(m_UGCUpdateHandle, new string[] {\"Tag One\", \"Tag Two\", \"Test Tags\", \"Sorry\"})"))
        {
            bool ret = SteamUGC.SetItemTags(m_UGCUpdateHandle, new string[] { "Tag One", "Tag Two", "Test Tags", "Sorry" });
            Console.WriteLine("SteamUGC.SetItemTags(" + m_UGCUpdateHandle + ", new string[] {\"Tag One\", \"Tag Two\", \"Test Tags\", \"Sorry\"}) : " + ret);
        }

        //if (GUILayout.Button("SetItemContent(m_UGCUpdateHandle, Application.dataPath + \"/Scenes\")"))
        {
            bool ret = SteamUGC.SetItemContent(m_UGCUpdateHandle, AppDomain.CurrentDomain.BaseDirectory + "/Scenes"); // Should point to a folder containing the UGC Item
            Console.WriteLine("SteamUGC.SetItemContent(" + m_UGCUpdateHandle + ", Application.dataPath + \"/Scenes\") : " + ret);
        }

        //if (GUILayout.Button("SetItemPreview(m_UGCUpdateHandle, Application.dataPath + \"/controller.vdf\")"))
        {
            bool ret = SteamUGC.SetItemPreview(m_UGCUpdateHandle, AppDomain.CurrentDomain.BaseDirectory + "/controller.vdf"); // Should actually be a PNG/JPG Screenshot.
            Console.WriteLine("SteamUGC.SetItemPreview(" + m_UGCUpdateHandle + ", Application.dataPath + \"/controller.vdf\") : " + ret);
        }

        //if (GUILayout.Button("SubmitItemUpdate(m_UGCUpdateHandle, \"Test Changenote\")"))
        {
            SteamAPICall_t handle = SteamUGC.SubmitItemUpdate(m_UGCUpdateHandle, "Test Changenote");
            OnSubmitItemUpdateResultCallResult.Set(handle);
            Console.WriteLine("SteamUGC.SubmitItemUpdate(" + m_UGCUpdateHandle + ", \"Test Changenote\") : " + handle);
        }

        {
            ulong             BytesProcessed;
            ulong             BytesTotal;
            EItemUpdateStatus ret = SteamUGC.GetItemUpdateProgress(m_UGCUpdateHandle, out BytesProcessed, out BytesTotal);
            Console.WriteLine("GetItemUpdateProgress(m_UGCUpdateHandle, out BytesProcessed, out BytesTotal) : " + ret + " -- " + BytesProcessed + " -- " + BytesTotal);
        }

        //if (GUILayout.Button("SubscribeItem((PublishedFileId_t)113142309)"))
        {
            SteamAPICall_t handle = SteamUGC.SubscribeItem((PublishedFileId_t)113142309); // http://steamcommunity.com/sharedfiles/filedetails/?id=113142309
            OnRemoteStorageSubscribePublishedFileResultCallResult.Set(handle);
            Console.WriteLine("SteamUGC. : " + handle);
        }

        //if (GUILayout.Button("UnsubscribeItem((PublishedFileId_t)113142309)"))
        {
            SteamAPICall_t handle = SteamUGC.UnsubscribeItem((PublishedFileId_t)113142309); // http://steamcommunity.com/sharedfiles/filedetails/?id=113142309
            OnRemoteStorageUnsubscribePublishedFileResultCallResult.Set(handle);
            Console.WriteLine("SteamUGC. : " + handle);
        }

        Console.WriteLine("GetNumSubscribedItems() : " + SteamUGC.GetNumSubscribedItems());

        //if (GUILayout.Button("GetSubscribedItems(PublishedFileID, (uint)PublishedFileID.Length)"))
        {
            PublishedFileId_t[] PublishedFileID = new PublishedFileId_t[1];
            uint ret = SteamUGC.GetSubscribedItems(PublishedFileID, (uint)PublishedFileID.Length);
            m_PublishedFileId = PublishedFileID[0];
            Console.WriteLine("SteamUGC.GetSubscribedItems(" + PublishedFileID + ", (uint)PublishedFileID.Length) : " + ret + " -- " + PublishedFileID[0]);
        }

        {
            ulong  SizeOnDisk;
            string Folder;
            uint   LegacyItem; //bool LegacyItem;
            bool   ret = SteamUGC.GetItemInstallInfo(m_PublishedFileId, out SizeOnDisk, out Folder, 1024, out LegacyItem);
            Console.WriteLine("GetItemInstallInfo(m_PublishedFileId, out SizeOnDisk, out Folder, 1024) : " + ret + " -- " + SizeOnDisk + " -- " + Folder + " -- " + LegacyItem);
        }

        {
            //bool NeedsUpdate;
            //bool IsDownloading;
            ulong BytesDownloaded;
            ulong BytesTotal;                                                                                 //bool ret = SteamUGC.GetItemUpdateInfo(m_PublishedFileId, out NeedsUpdate, out IsDownloading, out BytesDownloaded, out BytesTotal);
            bool  ret = SteamUGC.GetItemDownloadInfo(m_PublishedFileId, out BytesDownloaded, out BytesTotal); //, out BytesDownloaded, out BytesTotal);
            Console.WriteLine("GetItemUpdateInfo(m_PublishedFileId, out NeedsUpdate, out IsDownloading, out BytesDownloaded, out BytesTotal) : " + ret + " -- " + " -- " + BytesDownloaded + " -- " + BytesTotal);
            //Console.WriteLine("GetItemUpdateInfo(m_PublishedFileId, out NeedsUpdate, out IsDownloading, out BytesDownloaded, out BytesTotal) : " + ret + " -- " + NeedsUpdate + " -- " + IsDownloading + " -- " + BytesDownloaded + " -- " + BytesTotal);
        }
    }
 /// <summary>
 /// Sends or updates a file (must be registered first). 5. If desired, the progress of the upload can be tracked using EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal). In the same way as Creating a Workshop Item, confirm the user has accepted the legal agreement. This is necessary in case where the user didn't initially create the item but is editing an existing item.
 /// </summary>
 /// <param name="handle"></param>
 /// <param name="changeNote">Info about the change to the file for updates.</param>
 /// <returns></returns>
 public SteamAPICall_t sendFileOrUpdate(UGCUpdateHandle_t handle, string changeNote)
 {
     //4. Once the update calls have been completed, calling SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) will initiate the upload process to the Steam Workshop.
     return(SteamUGC.SubmitItemUpdate(handle, changeNote));
 }
Ejemplo n.º 14
0
        private void PerformUpdate(ExtensionInfo info)
        {
            this.updateHandle = SteamUGC.StartItemUpdate(this.hacknetAppID, new PublishedFileId_t((ulong)Convert.ToInt64(info.WorkshopPublishID)));
            this.isInUpload   = true;
            bool flag1 = ((true & SteamUGC.SetItemTitle(this.updateHandle, info.Name) & SteamUGC.SetItemDescription(this.updateHandle, info.WorkshopDescription) ? 1 : 0) & (SteamUGC.SetItemTags(this.updateHandle, (IList <string>)info.WorkshopTags.Split(new string[3] {
                " ,", ", ", ","
            }, StringSplitOptions.RemoveEmptyEntries)) ? 1 : 0)) != 0;
            string str = (Path.Combine(Directory.GetCurrentDirectory(), info.FolderPath) + "/" + info.WorkshopPreviewImagePath).Replace("\\", "/");

            if (File.Exists(str))
            {
                if (new FileInfo(str).Length < 1000000L)
                {
                    flag1 &= SteamUGC.SetItemPreview(this.updateHandle, str);
                }
                else
                {
                    this.currentStatusMessage = "Workshop Preview Image too large! Max size 1mb. Ignoring...";
                }
            }
            ERemoteStoragePublishedFileVisibility eVisibility = (int)info.WorkshopVisibility <= 0 ? ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic : ((int)info.WorkshopVisibility == 1 ? ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityFriendsOnly : ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPrivate);
            bool   flag2            = flag1 & SteamUGC.SetItemVisibility(this.updateHandle, eVisibility);
            string pszContentFolder = Path.Combine(Directory.GetCurrentDirectory(), info.FolderPath).Replace("\\", "/");

            Console.WriteLine("Content Path: " + pszContentFolder);
            if (!(flag2 & SteamUGC.SetItemContent(this.updateHandle, pszContentFolder)))
            {
                Console.WriteLine("Error!");
            }
            string path          = info.FolderPath + "/Changelog.txt";
            string pchChangeNote = "";

            if (File.Exists(path))
            {
                pchChangeNote = File.ReadAllText(path);
            }
            this.SubmitItemUpdateResult_t.Set(SteamUGC.SubmitItemUpdate(this.updateHandle, pchChangeNote), (CallResult <Steamworks.SubmitItemUpdateResult_t> .APIDispatchDelegate)null);
            this.transferStarted     = DateTime.Now;
            this.showLoadingSpinner  = true;
            this.isInUpload          = true;
            this.currentBodyMessage  = "Uploading to Steam Workshop...";
            this.currentTitleMessage = "Upload in progress";
        }
Ejemplo n.º 15
0
        public void UploadMod(ModObject mod, string changelog, string[] tags, bool keepUnCooked, bool keepScripts, int visibility, string description)
        {
            if (IsUploaderRunning)
            {
                MainWindow.Instance.Invoke(new MethodInvoker(() => {
                    GUI.MessageBox.Show(MainWindow.Instance, "Only one uploader instance can run at once!");
                }));
                return;
            }

            success           = true;
            IsUploaderRunning = true;
            try
            {
                ERemoteStoragePublishedFileVisibility fileVisibility
                    = (ERemoteStoragePublishedFileVisibility)Enum.ToObject(typeof(ERemoteStoragePublishedFileVisibility), visibility);;

                mod.Refresh();
                SetStatus("Preparing the uploader...");
                var tmpDir = Path.Combine(Program.GetAppRoot(), "uploader_tmp");
                if (Directory.Exists(tmpDir))
                {
                    Directory.Delete(tmpDir, true);
                }
                Directory.CreateDirectory(tmpDir);

                Utils.DirectoryCopy(mod.RootPath, tmpDir, true);
                if (!keepScripts)
                {
                    if (Directory.Exists(Path.Combine(tmpDir, "CompiledScripts")))
                    {
                        Directory.Delete(Path.Combine(tmpDir, "CompiledScripts"), true);
                    }
                    if (Directory.Exists(Path.Combine(tmpDir, "Classes")))
                    {
                        Directory.Delete(Path.Combine(tmpDir, "Classes"), true);
                    }
                }

                if (!keepUnCooked)
                {
                    if (Directory.Exists(Path.Combine(tmpDir, "Maps")))
                    {
                        Directory.Delete(Path.Combine(tmpDir, "Maps"), true);
                    }
                    if (Directory.Exists(Path.Combine(tmpDir, "Content")))
                    {
                        Directory.Delete(Path.Combine(tmpDir, "Content"), true);
                    }
                }

                //var description = mod.GetDescription();

                var modid = mod.GetUploadedId();

                SetStatus("Creating callback...");

                m_itemCreated = CallResult <CreateItemResult_t> .Create(OnItemCreated);

                var appId = new AppId_t(uint.Parse(GameFinder.AppID));

                if (modid == 0)
                {
                    SteamAPICall_t call = SteamUGC.CreateItem(appId, EWorkshopFileType.k_EWorkshopFileTypeCommunity);
                    m_itemCreated.Set(call);
                }
                else
                {
                    publishID = modid;
                }
                while (publishID == 0)
                {
                    SteamAPI.RunCallbacks();
                    Thread.Sleep(1000);
                }

                Thread.Sleep(1000);

                if (modid == 0)
                {
                    SetStatus("Uploading an new mod " + mod.Name + " with WorkshopID: " + publishID);
                    mod.SetUploadedId(publishID);
                }
                else
                {
                    SetStatus("Updating the mod " + mod.Name + " with WorkshopID: " + publishID);
                }
                var publishFileID_t = new PublishedFileId_t(publishID);

                ugcUpdateHandle = SteamUGC.StartItemUpdate(appId, publishFileID_t);

                SteamUGC.SetItemTitle(ugcUpdateHandle, mod.Name);
                SteamUGC.SetItemDescription(ugcUpdateHandle, description);
                SteamUGC.SetItemVisibility(ugcUpdateHandle, fileVisibility);
                if (tags != null)
                {
                    SteamUGC.SetItemTags(ugcUpdateHandle, tags);
                }
                SteamUGC.SetItemPreview(ugcUpdateHandle, Path.Combine(tmpDir, mod.Icon));
                SteamUGC.SetItemContent(ugcUpdateHandle, tmpDir);

                SteamAPICall_t t = SteamUGC.SubmitItemUpdate(ugcUpdateHandle, changelog);
                m_itemSubmitted = CallResult <SubmitItemUpdateResult_t> .Create(OnItemSubmitted);

                m_itemSubmitted.Set(t);

                while (true)
                {
                    Thread.Sleep(1000);
                    if (ugcUpdateHandle == UGCUpdateHandle_t.Invalid)
                    {
                        break;
                    }
                    SteamAPI.RunCallbacks();
                    ulong             bytesDone, bytesTotal;
                    EItemUpdateStatus status = SteamUGC.GetItemUpdateProgress(ugcUpdateHandle, out bytesDone, out bytesTotal);
                    if (status == EItemUpdateStatus.k_EItemUpdateStatusInvalid && !success)
                    {
                        break;
                    }
                    SetStatus(string.Format("[{3}%] Status: {0}\n{1}/{2}", TranslateStatus(status), BytesToString(bytesDone), BytesToString(bytesTotal), bytesTotal > 0 ? Math.Floor(((double)bytesDone / (double)bytesTotal) * (double)100) : 100));
                }

                DialogResult res = DialogResult.No;

                if (success)
                {
                    MainWindow.Instance.Invoke(new MethodInvoker(() => {
                        res = GUI.MessageBox.Show(MainWindow.Instance, "Done, mod url:" + "\nhttps://steamcommunity.com/sharedfiles/filedetails/?id=" + publishID + "\n\nOpen it in the browser?", "Uploader", MessageBoxButtons.YesNo, MessageBoxIcon.Information);

                        if (res == DialogResult.Yes)
                        {
                            Process.Start("steam://openurl/https://steamcommunity.com/sharedfiles/filedetails/?id=" + publishID);
                        }
                    }));

                    SetStatus("Item uploaded successfully!");
                    Thread.Sleep(1000);
                }

                SetStatus("Cleanup");
                if (Directory.Exists(tmpDir))
                {
                    Directory.Delete(tmpDir, true);
                }

                SetStatus(null);

                IsUploaderRunning = false;
            }
            catch (Exception e)
            {
                MainWindow.Instance.Invoke(new MethodInvoker(() => {
                    GUI.MessageBox.Show(MainWindow.Instance, e.Message + "\n" + e.ToString());
                }));
                IsUploaderRunning = false;
                SetStatus(null);
            }
        }
Ejemplo n.º 16
0
 public void GetUpdateProgress(out ulong bytesProcessed, out ulong bytesTotal)
 {
     EItemUpdateStatus status = SteamUGC.GetItemUpdateProgress(updateHandle, out bytesProcessed, out bytesTotal);
 }
Ejemplo n.º 17
0
 // Token: 0x060013B6 RID: 5046 RVA: 0x0007E702 File Offset: 0x0007CB02
 protected void downloadWorkshopItem()
 {
     Debug.Log("Downloading...");
     SteamUGC.DownloadItem(this.workshopItemDetails.m_nPublishedFileId, true);
 }
Ejemplo n.º 18
0
        private async void ItemInstalled(ItemInstalled item)
        {
            var result = await SteamUGC.GetItemDetailsAsync(item.PublishedFile);

            Console.WriteLine("Installed: " + result.Details.Title);
        }
Ejemplo n.º 19
0
 internal static void Unsubscribe(WorkshopUploadable item)
 {
     SteamUGC.UnsubscribeItem(item.GetPublishedFileId());
 }
Ejemplo n.º 20
0
        private async void ItemSubscribed(RemoteStoragePublishedFileSubscribed item)
        {
            var result = await SteamUGC.GetItemDetailsAsync(item.PublishedField);

            Console.WriteLine("Subscribed: " + result.Details.Title);
        }
Ejemplo n.º 21
0
 /// <summary>
 /// Allows the user to subscribe to download this item asyncronously
 /// If CancellationToken is default then there is 60 seconds timeout
 /// Progress will be set to 0-1
 /// </summary>
 public async Task <bool> DownloadAsync(Action <float> progress = null, int milisecondsUpdateDelay = 60, CancellationToken ct = default)
 {
     return(await SteamUGC.DownloadAsync(Id, progress, milisecondsUpdateDelay, ct));
 }
Ejemplo n.º 22
0
 public uint CountWorkshopStuff() => SteamUGC.GetNumSubscribedItems();
Ejemplo n.º 23
0
 public static void Subscribe(string identifier)
 {
     SteamUGC.SubscribeItem(new PublishedFileId_t(ulong.Parse(identifier)));
 }
Ejemplo n.º 24
0
 /// <summary>
 /// Configures the request to limit the cache time to 1 hour, then sends it.
 /// </summary>
 /// <param name="query">The UGC query to send.</param>
 /// <returns>The API call result of the query.</returns>
 internal static SteamAPICall_t ConfigureAndSend(UGCQueryHandle_t query)
 {
     SteamUGC.SetAllowCachedResponse(query, 3600U);
     return(SteamUGC.SendQueryUGCRequest(query));
 }
Ejemplo n.º 25
0
 public unsafe void Subscribe()
 {
     SteamUGC.SubscribeItem(_id);
 }
Ejemplo n.º 26
0
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            e.Graphics.DrawImage(globals.GetTexture(ulFileID.ToString(), "jpg"), new Rectangle(1, 1, Height - 2, Height - 2));

            if (m_bWhitelisted)
            {
                e.Graphics.DrawImage(Properties.Resources.verified, new Rectangle(Height - 18, Height - 18, 18, 18));
            }

            e.Graphics.FillRectangle(new SolidBrush(colOverlay), new Rectangle(0, 0, Width, Height));
            e.Graphics.DrawRectangle(Pens.Black, new Rectangle(1, 1, Height - 2, Height - 2));

            StringFormat formatter = new StringFormat();

            formatter.LineAlignment = StringAlignment.Center;
            formatter.Alignment     = StringAlignment.Near;

            if (m_bUploading)
            {
                bool              bDrawProgress = false;
                string            statusString = "";
                ulong             punBytesProcessed = 0, punBytesTotal = 0;
                EItemUpdateStatus uploadStatus = SteamUGC.GetItemUpdateProgress(updateHandle, out punBytesProcessed, out punBytesTotal);

                if (uploadStatus == EItemUpdateStatus.k_EItemUpdateStatusPreparingConfig)
                {
                    statusString = "Preparing Content...";
                }
                else if (uploadStatus == EItemUpdateStatus.k_EItemUpdateStatusPreparingContent)
                {
                    statusString  = string.Format("Uploading Content: {0} / {1} bytes", punBytesProcessed, punBytesTotal);
                    bDrawProgress = true;
                }
                else if (uploadStatus == EItemUpdateStatus.k_EItemUpdateStatusUploadingContent || uploadStatus == EItemUpdateStatus.k_EItemUpdateStatusUploadingPreviewFile)
                {
                    statusString = "Configuring Content...";
                }
                else if (uploadStatus == EItemUpdateStatus.k_EItemUpdateStatusCommittingChanges)
                {
                    statusString = "Committing Changes...";
                }

                e.Graphics.DrawString(statusString, new Font("Times New Roman", 11, FontStyle.Bold), new SolidBrush(Color.White), new Rectangle(Height + 2, 1, Width - Height - 2, 30), formatter);
                if (bDrawProgress && (punBytesTotal > 0))
                {
                    e.Graphics.DrawImage(globals.GetTexture("bar"), new Rectangle(Height + 2, 33, Width - Height - 24, 16));

                    double flPercent = ((double)punBytesProcessed) / ((double)punBytesTotal);
                    double flWide    = (double)(Width - Height - 24) * flPercent;
                    e.Graphics.FillRectangle(new SolidBrush(Color.FromArgb(145, 200, 15, 15)), new Rectangle(Height + 2, 33, (int)flWide, 16));
                    e.Graphics.DrawRectangle(Pens.Black, new Rectangle(Height + 2, 33, Width - Height - 24, 16));
                }

                return;
            }

            e.Graphics.DrawString(pszName, new Font("Times New Roman", 20, FontStyle.Bold), new SolidBrush(Color.White), new Rectangle(Height + 2, 1, Width - Height - 2, 30), formatter);
            e.Graphics.DrawString(pszDescription, new Font("Times New Roman", 10, FontStyle.Regular), new SolidBrush(Color.White), new Rectangle(Height + 3, 33, Width - Height - 3, 20), formatter);

            formatter.LineAlignment = StringAlignment.Center;
            formatter.Alignment     = StringAlignment.Far;

            e.Graphics.DrawString(pszDate, new Font("Times New Roman", 10, FontStyle.Bold), new SolidBrush(Color.White), new Rectangle(Width - 142, 2, 140, 20), formatter);
        }
Ejemplo n.º 27
0
        private void ExportLoadButtonClick(object sender, EventArgs e)
        {
            var dialog = new OpenFileDialog
            {
                Filter          = "Text files|*.txt",
                DefaultExt      = "txt",
                CheckPathExists = true,
                CheckFileExists = true,
                Multiselect     = false,
            };

            if (dialog.ShowDialog() != DialogResult.OK)
            {
                return;
            }

            // parse file

            var regex = new Regex(@"^\s*(?<name>.*?)[ ]*\t(?<id>.*?)[ ]*\t(?:.*=)?(?<sourceID>\d+)$", RegexOptions.Compiled | RegexOptions.Multiline);

            var mods        = Mods.All.ToList();
            var activeMods  = new List <ModEntry>();
            var missingMods = new List <Match>();

            foreach (var line in File.ReadAllLines(dialog.FileName))
            {
                var match = regex.Match(line);
                if (!match.Success)
                {
                    continue;
                }

                var entries = mods.Where(mod => mod.ID == match.Groups["id"].Value).ToList();

                if (entries.Count == 0)
                {
                    // Mod missing
                    // -> add to list
                    missingMods.Add(match);
                    continue;
                }

                activeMods.AddRange(entries);

                if (entries.Count > 1)
                {
                    // More than 1 mod
                    // Add warning?
                }
            }

            // Check entries
            if (activeMods.Count == 0)
            {
                MessageBox.Show("No mods found. Bad profile?");
                return;
            }

            // Check missing
            if (missingMods.Count > 0)
            {
                var steamMissingMods = missingMods.Where(match => match.Groups["sourceID"].Value != "Unknown").ToList();

                var text = $"This profile contains {missingMods.Count} mod(s) that are not currently installed:\r\n\r\n";

                foreach (var match in missingMods)
                {
                    text += match.Groups["name"].Value;

                    if (steamMissingMods.Contains(match))
                    {
                        text += "*";
                    }

                    text += "\r\n";
                }

                if (steamMissingMods.Count != 0)
                {
                    text += "\r\nDo you want to subscribe to the mods marked with an asterisk on Steam?";

                    var result = MessageBox.Show(this, text, "Mods missing!", MessageBoxButtons.YesNoCancel);

                    if (result == DialogResult.Cancel)
                    {
                        return;
                    }

                    if (result == DialogResult.Yes)
                    {
                        // subscribe
                        foreach (var id in steamMissingMods.Select(match => ulong.Parse(match.Groups["sourceID"].Value)))
                        {
                            SteamUGC.SubscribeItem(id.ToPublishedFileID());
                        }

                        MessageBox.Show("Done. Close the launcher, wait for steam to download the mod(s) and try again.");
                        return;
                    }
                }
                else
                {
                    text += "\r\nDo you wish to continue?";

                    if (MessageBox.Show(this, text, "Mods missing!", MessageBoxButtons.YesNo) == DialogResult.No)
                    {
                        return;
                    }
                }
            }

            // Confirm
            if (MessageBox.Show(this, $"Adopt profile? {activeMods.Count} mods found.", "Confirm", MessageBoxButtons.YesNo) == DialogResult.No)
            {
                return;
            }

            // Apply changes
            foreach (var mod in mods)
            {
                mod.isActive = false;
            }

            foreach (var mod in activeMods)
            {
                mod.isActive = true;
            }

            modlist_objectlistview.UpdateObjects(mods);

            UpdateExport();
            UpdateLabels();
        }
Ejemplo n.º 28
0
 public static EItemState GetDownloadStatus(ulong id)
 {
     SteamAPIWrapper.Init();
     return((EItemState)SteamUGC.GetItemState(new PublishedFileId_t(id)));
 }
Ejemplo n.º 29
0
        public static void Unsubscribe(ulong id)
        {
            SteamAPIWrapper.Init();

            SteamUGC.UnsubscribeItem(id.ToPublishedFileID());
        }
Ejemplo n.º 30
0
        public Vector2 Draw(SpriteBatch sb, Rectangle dest, ExtensionInfo info)
        {
            this.ActiveInfo = info;
            if (!this.HasInitializedSteamCallbacks)
            {
                this.InitSteamCallbacks();
            }
            this.Update();
            Vector2 vector2 = new Vector2((float)dest.X, (float)dest.Y);
            bool    flag1   = info.WorkshopPublishID != "NONE";

            this.currentStatusMessage = flag1 ? "Ready to push Updates" : "Ready to create in steam";
            if (!flag1 && string.IsNullOrWhiteSpace(this.currentBodyMessage))
            {
                this.currentBodyMessage = "By submitting this item, you agree to the workshop terms of service\nhttp://steamcommunity.com/sharedfiles/workshoplegalagreement";
            }
            Vector2 pos1 = new Vector2(vector2.X + (float)(dest.Width / 2), vector2.Y);

            TextItem.doFontLabel(pos1, this.currentStatusMessage, GuiData.font, new Color?(Color.Gray), (float)dest.Width / 2f, 30f, false);
            pos1.Y += 30f;
            TextItem.doFontLabel(pos1, this.currentTitleMessage, GuiData.font, new Color?(Color.White), (float)dest.Width / 2f, 30f, false);
            pos1.Y += 30f;
            Vector2 pos2 = pos1;

            if (this.showLoadingSpinner)
            {
                pos1.X          += 16f;
                this.spinnerRot += 0.1f;
                Rectangle destinationRectangle = new Rectangle((int)pos1.X, (int)pos1.Y + 20, 40, 40);
                sb.Draw(this.spinnerTex, destinationRectangle, new Rectangle?(), Color.White, this.spinnerRot, this.spinnerTex.GetCentreOrigin(), SpriteEffects.None, 0.5f);
                pos2.X += 45f;
            }
            if (this.isInUpload)
            {
                Rectangle rectangle          = new Rectangle((int)pos2.X, (int)pos2.Y + 6, dest.Width / 2, 20);
                ulong     punBytesProcessed  = 0;
                ulong     punBytesTotal      = 1;
                int       itemUpdateProgress = (int)SteamUGC.GetItemUpdateProgress(this.updateHandle, out punBytesProcessed, out punBytesTotal);
                double    val1 = (double)punBytesProcessed / (double)punBytesTotal;
                if ((long)punBytesTotal == 0L)
                {
                    val1 = 0.0;
                }
                sb.Draw(Utils.white, Utils.InsetRectangle(rectangle, -1), Utils.AddativeWhite * 0.7f);
                sb.Draw(Utils.white, rectangle, Utils.VeryDarkGray);
                rectangle.Width = (int)((double)rectangle.Width * val1);
                sb.Draw(Utils.white, rectangle, Color.LightBlue);
                pos2.Y += 31f;
                if (punBytesTotal > 0UL)
                {
                    string format = "{0}% - {1}mb of {2}mb Transfered";
                    string str1   = (val1 * 100.0).ToString("00.00");
                    ulong  num    = punBytesProcessed / 1000000UL;
                    string str2   = num.ToString("0.00");
                    num = punBytesTotal / 1000000UL;
                    string str3  = num.ToString("0.00");
                    string text1 = string.Format(format, (object)str1, (object)str2, (object)str3);
                    Utils.DrawStringMonospace(sb, text1, GuiData.smallfont, pos2, Color.White, 9f);
                    pos2.Y += 20f;
                    TimeSpan time  = DateTime.Now - this.transferStarted;
                    string   text2 = string.Format("ETA: {0} // Elapsed : {1}", (object)this.getTimespanDisplayString(TimeSpan.FromSeconds(time.TotalSeconds / Math.Max(val1, 0.01))), (object)this.getTimespanDisplayString(time));
                    Utils.DrawStringMonospace(sb, text2, GuiData.smallfont, pos2, Color.White, 9f);
                    pos2.Y += 25f;
                }
            }
            TextItem.doFontLabel(pos2, this.currentBodyMessage, GuiData.smallfont, new Color?(Color.White * 0.8f), (float)dest.Width / 2f, 30f, false);
            int  height = 40;
            int  width  = 450;
            bool flag2  = !this.showLoadingSpinner;

            if (!this.isInUpload)
            {
                if (Button.doButton(371711001, (int)vector2.X, (int)vector2.Y, width, height, flag1 ? " - Item Created -" : "Create Entry in Steam Workshop", new Color?(flag1 ? Color.LightBlue : Color.Gray)) && !flag1 && flag2)
                {
                    this.CreateExtensionInSteam(info);
                }
                vector2.Y += (float)(height + 4);
                if (Button.doButton(371711003, (int)vector2.X, (int)vector2.Y, width, height, "Upload to Steam Workshop", new Color?(flag1 ? Color.LightBlue : Color.Gray)) && flag2)
                {
                    this.PerformUpdate(info);
                }
                vector2.Y += (float)(height + 4);
                if (Button.doButton(371711005, (int)vector2.X, (int)vector2.Y + 10, width, height - 10, "Back to Extension Menu", new Color?(Color.Black)) && flag2 && this.GoBack != null)
                {
                    this.GoBack();
                }
                vector2.Y += (float)(height + 4);
            }
            return(vector2);
        }