private void VerifyStuff(PublishedFileId item)
{
uint timeStamp;
ulong sizeOnDisk;
string folderPath;
if (!SteamUGC.GetItemInstallInfo(item, out sizeOnDisk, out folderPath, 1024 * 1024 * 16, out timeStamp))
{
Console.WriteLine("Steam said its not there.");
QueueDownload(item);
}
else if (!Directory.Exists(folderPath))
{
Console.WriteLine("Folder not found");
QueueDownload(item);
}
else if (!Directory.EnumerateFiles(folderPath).Any())
{
Console.WriteLine("No files in folder.");
QueueDownload(item);
}
else
{
Console.WriteLine($"{item.Id} already installed.");
}
}
// click link/button
void DgDLCs_OnCellContentClick(object sender, DataGridViewCellEventArgs e)
{
try {
if (DLCList == null)
{
return;
}
if (e.RowIndex < 0 || e.RowIndex >= DLCList.Filtered.Count)
{
return;
}
var dlc = DLCList.Filtered[e.RowIndex];
if (e.ColumnIndex == CName.Index)
{
var id = new PublishedFileId((ulong)dlc.DLC);
string url = ContentUtil.GetDLCURL(id);
if (url != null)
{
ContentUtil.OpenURL(url);
}
}
} catch (Exception ex) {
Log.Exception(ex);
}
}
public Editor(PublishedFileId fileId)
{
this = new Editor()
{
fileId = fileId
};
}
public ItemT(ulong id)
{
PublishedFileId = new PublishedFileId(id);
State = StateT.None;
LastEventTime = default;
RequestCount = 0;
}
public static string getModPath()
{
string text = ".";
PublishedFileId[] subscribedItems = PlatformService.workshop.GetSubscribedItems();
for (int i = 0; i < subscribedItems.Length; i++)
{
PublishedFileId id = subscribedItems[i];
if (id.AsUInt64 == 633547552)
{
text = PlatformService.workshop.GetSubscribedItemPath(id);
Debug.Log("Roads United Core: Workshop path: " + text);
break;
}
}
string text2 = DataLocation.modsPath + "/RoadsUnited_Core";
Debug.Log("Roads United Core: " + text2);
string result;
if (Directory.Exists(text2))
{
Debug.Log("Roads United Core: Local path exists, looking for assets here: " + text2);
result = text2;
}
else
{
result = text;
}
return(result);
}
public void OnSettingsUI(UIHelperBase helper)
{
try
{
UIHelper group = helper.AddGroup(Name) as UIHelper;
UIPanel panel = group.self as UIPanel;
panel.gameObject.AddComponent <OptionsKeymapping>();
group.AddSpace(10);
// Disable SJA
PublishedFileId SJA_ID = new PublishedFileId(553184329);
foreach (PluginManager.PluginInfo plugin in PluginManager.instance.GetPluginsInfo())
{
if (plugin.publishedFileID == SJA_ID && plugin.isEnabled)
{
try
{
DebugUtils.Log("Disabling SJA");
plugin.isEnabled = false;
}
catch { }
}
}
}
catch (Exception e)
{
DebugUtils.Log("OnSettingsUI failed");
DebugUtils.LogException(e);
}
}
public Item(PublishedFileId id)
{
this = new Item()
{
_id = id
};
}
private void OnTooltipClicked(UIComponent c, UIMouseEventParameter p)
{
if (!p.used && p.buttons == UIMouseButton.Right && currentData != null && currentData.asset != null)
{
if (currentData.asset.author.IsNullOrWhiteSpace() || currentData.asset.steamID == 0 || !currentData.asset.prefab.m_isCustomContent)
{
return;
}
PublishedFileId publishedFileId = new PublishedFileId(currentData.asset.steamID);
if (publishedFileId != PublishedFileId.invalid)
{
if (!Settings.useDefaultBrowser)
{
PlatformService.ActivateGameOverlayToWorkshopItem(publishedFileId);
}
else
{
System.Diagnostics.Process.Start("https://steamcommunity.com/sharedfiles/filedetails/?id=" + publishedFileId);
}
p.Use();
}
}
}
public IEnumerator RedownloadCoroutine(PublishedFileId id)
{
Log.Called(id);
if (id != PublishedFileId.invalid)
{
try {
string path = SubscriptionsTab.SteamExePath;
if (path.IsNullorEmpty())
{
yield break;
}
ReDownload(new[] { id.AsUInt64 }, new FileInfo(path));
} catch (Exception ex) { ex.Log(); }
yield return(new WaitForSeconds(10));
try {
var method = typeof(PlatformService).GetMethod("TriggerWorkshopSubscriptionChanged", throwOnError: true);
method.Invoke(null, new object[] { id, false });
method.Invoke(null, new object[] { id, true });
} catch (Exception ex) { ex.Log(); }
yield return(0);
}
}
// tooltip
void DgDLCs_OnCellToolTipTextNeeded(object sender, DataGridViewCellToolTipTextNeededEventArgs e)
{
try {
if (DLCList == null)
{
return;
}
if (e.RowIndex < 0 || e.RowIndex >= DLCList.Filtered.Count)
{
return;
}
var dlc = DLCList.Filtered[e.RowIndex];
if (e.ColumnIndex == CName.Index)
{
var id = new PublishedFileId((ulong)dlc.DLC);
string url = ContentUtil.GetDLCURL(id);
if (url != null)
{
e.ToolTipText = url;
}
}
} catch (Exception ex) {
Log.Exception(ex, $"rowIndex={e.RowIndex}");
e.ToolTipText = ex.ToString();
}
}
Package.Asset FindByName(string packageName, string assetName)
{
PublishedFileId id = Util.GetPackageId(packageName);
if (id != PublishedFileId.invalid)
{
if (packagesToPaths == null || packagesToPaths.Count == 0)
{
packagesToPaths = (Dictionary <PublishedFileId, HashSet <string> >)Util.GetStatic(typeof(PackageManager), "m_PackagesSteamToPathsMap");
}
HashSet <string> paths;
if (packagesToPaths.TryGetValue(id, out paths))
{
Package package; Package.Asset asset;
foreach (string path in paths)
{
if ((package = PackageManager.FindPackageAt(path)) != null && (asset = package.Find(assetName)) != null)
{
return(asset);
}
}
}
}
return(null);
}
public static string GetDLCURL(PublishedFileId id)
{
if (id == PublishedFileId.invalid || id.AsUInt64 == 0)
{
return(null);
}
return(DLC_URL_PREFIX + id.AsUInt64);
}
public static string GetSteamSubscribedItemPath(ulong fileID)
{
PublishedFileId _publishedFileID = new PublishedFileId(fileID);
string _path = PlatformService.workshop.GetSubscribedItemPath(_publishedFileID);
return(_path);
}
private static void OnWorkshopItemInstalled(PublishedFileId id)
{
if (Singleton <PluginManager> .instance.GetImplementations <IAmAware>()
.Exists((i) => i.DoOnHarmonyReady(_harmonyReadyActions)))
{
UnityEngine.Debug.Log($"[{Versioning.FULL_PACKAGE_NAME}] Harmony workshop item subscribed and {_harmonyReadyActions.Count} OnReady tasks dispatched!");
}
}
public void GetWorkshopStuff()
{
var numSubscribedItems = CountWorkshopStuff();
var items = new PublishedFileId[numSubscribedItems];
var numFound = SteamUGC.GetSubscribedItems(items, numSubscribedItems);
Array.Resize(ref items, (int)numFound);
CheckWorkshopStuff(items);
}
private async Task UnSubscribeItem(PublishedFileId fileID)
{
var result = await SteamUGC.UnSubscribeItem(fileID);
if (result)
{
}
propertyGridElementDetails.Refresh();
}
public static async Task <Item?> GetAsync(PublishedFileId id, int maxageseconds = 60 * 30)
{
var i = await Item.GetAsync(id, maxageseconds);
if (i.HasValue)
{
return(i.Value);
}
return(null);
}
public void OnEnabled()
{
// Probably useless
try
{
WORKSHOP_FILE_ID = new PublishedFileId(1625704117uL);
} catch
{
Debug.Log("Error when assigning Workshop File ID");
}
}
public static bool Subscribe(PublishedFileId item, bool enable = true, string name = "") // why tf is string.Empty not a compile time constant *sigh*
{
Archive.Instance.BeingSubscribed.Add(new ArchiveEntry {
Name = name,
WorkshopId = item.AsUInt64,
Enabled = enable
});
Archive.Instance.Save();
Audit.Add($"[SubscriptionsManager.Subscribe] Subscribing {item.AsUInt64} '{name}'");
return(PlatformService.workshop.Subscribe(item));
}
public static async Task <Item?> GetAsync(PublishedFileId id, int maxageseconds = 60 * 30)
{
var result = await SteamUGC.Internal.RequestUGCDetails(id, (uint)maxageseconds);
if (!result.HasValue)
{
return(null);
}
return(From(result.Value.Details));
}
/// <summary>
/// Retrieve a review for the specified item.
/// </summary>
///
/// <param name="publishedFileId">The <see cref="PublishedFileId"/> to review.</param>
/// <param name="review">The assessment, if found.</param>
///
/// <returns>Returns <c>true</c> if the item was found, otherwise <c>false</c>.</returns>
public bool TryGetReview(PublishedFileId publishedFileId, out Review review)
{
if (Reviews.TryGetValue(publishedFileId.AsUInt64, out var value))
{
review = value;
return(true);
}
review = null;
return(false);
}
private void OnTooltipClicked(UIComponent c, UIMouseEventParameter p)
{
if (!p.used && p.buttons == UIMouseButton.Right && currentData != null && currentData.asset != null)
{
PublishedFileId publishedFileId = new PublishedFileId(currentData.asset.steamID);
if (publishedFileId != PublishedFileId.invalid)
{
PlatformService.ActivateGameOverlayToWorkshopItem(publishedFileId);
p.Use();
}
}
}
private static IncompatibleMod GetModDetails(PublishedFileId publishedFileId)
{
var pluginsInfo = PluginManager.instance.GetPluginsInfo();
var foundPlugins = pluginsInfo.Where(pluginInfo => pluginInfo.publishedFileID == publishedFileId && pluginInfo.isEnabled);
var allIncompatibilities = AllIncompatibilities;
if (foundPlugins.Count() > 0 && allIncompatibilities.ContainsKey(publishedFileId))
{
return(new IncompatibleMod(foundPlugins.First(), allIncompatibilities[publishedFileId]));
}
return(null);
}
private async void QueueDownload(PublishedFileId item)
{
var result = await SteamUGC.GetItemDetailsAsync(item);
Console.WriteLine($"{result.Details.Description} - Is {(result.CachedData ? "" : "not")} on your hdd!");
if (!SteamUGC.DownloadItem(item, true))
{
return;
}
Console.WriteLine("Download queued");
PendingDownloads.Add(result.Details.Field.Id, result.Details.Title);
}
public static bool HasMod(this Package package)
{
PublishedFileId publishedFileId = package.GetPublishedFileID();
var plugins = PluginManager.instance.GetPluginsInfo();
if (publishedFileId != PublishedFileId.invalid)
{
return(plugins.Any(item => item.publishedFileID == publishedFileId));
}
else
{
return(false);
// local mod assets are not loaded
// return plugins.Any(item => item.name == package.packageName);
}
}
public ContextMenuItems(string path, PublishedFileId id)
{
path_ = path;
var itemOpenFile = new ToolStripMenuItem("Open File Location");
itemOpenFile.Click += ItemOpenFile_Click;
Items.Add(itemOpenFile);
if (id != PublishedFileId.invalid)
{
url_ = ContentUtil.GetItemURL(id);
var itemOpenURL = new ToolStripMenuItem("Open In Workshop");
itemOpenURL.Click += ItemOpenURL_Click;;
Items.Add(itemOpenURL);
}
}
public async Task <PublishedFileDetails> GetPublishedFileDetailsAsync(PublishedFileId publishedFileId)
{
var request = new CPublishedFile_GetDetails_Request();
request.publishedfileids.Add(publishedFileId);
var result = await PublishedFileService.SendMessage(api => api.GetDetails(request));
if (result.Result == EResult.OK)
{
var details = result.GetDeserializedResponse <CPublishedFile_GetDetails_Response>().publishedfiledetails.First();
return(details);
}
throw new SteamPublishedFileDetailsFetchException(result.Result);
}
private void LoadTreeAuthors()
{
TreeAuthors = new Dictionary <string, string>();
foreach (Package.Asset current in PackageManager.FilterAssets(new Package.AssetType[] { UserAssetType.CustomAssetMetaData }))
{
PublishedFileId id = current.package.GetPublishedFileID();
string publishedFileId = string.Concat(id.AsUInt64);
if (!TreeAuthors.ContainsKey(publishedFileId) && !current.package.packageAuthor.IsNullOrWhiteSpace())
{
if (ulong.TryParse(current.package.packageAuthor.Substring("steamid:".Length), out ulong authorID))
{
string author = new Friend(new UserID(authorID)).personaName;
TreeAuthors.Add(publishedFileId, author);
}
}
}
}
/// <summary>
/// Utility function to fetch a single item. Internally this uses Ugc.FileQuery -
/// which you can use to query multiple items if you need to.
/// </summary>
public static async Task <Ugc.Item?> QueryFileAsync(PublishedFileId fileId)
{
var result = await Ugc.Query.All
.WithFileId(fileId)
.GetPageAsync(1);
if (!result.HasValue || result.Value.ResultCount != 1)
{
return(null);
}
var item = result.Value.Entries.First();
result.Value.Dispose();
return(item);
}
public static async Task <Item?> GetAsync(PublishedFileId id, int maxageseconds = 1800)
{
Item?nullable;
SteamUGCRequestUGCDetailsResult_t?nullable1 = await SteamUGC.Internal.RequestUGCDetails(id, (uint)maxageseconds);
SteamUGCRequestUGCDetailsResult_t?nullable2 = nullable1;
nullable1 = null;
if (nullable2.HasValue)
{
nullable = new Item?(Item.From(nullable2.Value.Details));
}
else
{
nullable = null;
}
return(nullable);
}
public void DeletePublishedFile(PublishedFileId publishedFileId)
{
CheckIfUsable();
NativeMethods.Cloud_DeletePublishedFile(publishedFileId.AsUInt64);
}
public void UpdateUserPublishedItemVote(PublishedFileId publishedFileId, bool voteUp)
{
CheckIfUsable();
NativeMethods.Cloud_UpdateUserPublishedItemVote(publishedFileId.AsUInt64, voteUp);
}
public void RequestUGCDetails(PublishedFileId publishedFileId)
{
NativeMethods.UGC_RequestUGCDetails( publishedFileId.AsUInt64 );
}
public bool TagPublishedFile(ScreenshotHandle screenshot, PublishedFileId publishedFileID)
{
return NativeMethods.Screenshots_TagPublishedFile( screenshot.AsUInt32, publishedFileID.AsUInt64 );
}
public void GetUserPublishedItemVoteDetails(PublishedFileId publishedFileId)
{
CheckIfUsable();
NativeMethods.Cloud_GetUserPublishedItemVoteDetails(publishedFileId.AsUInt64);
}
public void SetUserPublishedFileAction(PublishedFileId publishedFileId, WorkshopFileAction action)
{
CheckIfUsable();
NativeMethods.Cloud_SetUserPublishedFileAction(publishedFileId.AsUInt64, (int)action);
}
public void GetPublishedFileDetails(PublishedFileId publishedFileId, uint maxSecondsOld)
{
CheckIfUsable();
NativeMethods.Cloud_GetPublishedFileDetails(publishedFileId.AsUInt64, maxSecondsOld);
}
public void UnsubscribePublishedFile(PublishedFileId publishedFileId)
{
CheckIfUsable();
NativeMethods.Cloud_UnsubscribePublishedFile(publishedFileId.AsUInt64);
}
public PublishedFileUpdateHandle CreatePublishedFileUpdateRequest(PublishedFileId publishedFileId)
{
CheckIfUsable();
return new PublishedFileUpdateHandle(NativeMethods.Cloud_CreatePublishedFileUpdateRequest(publishedFileId.AsUInt64));
}
