void OnCreateItemDone(bool ok, Steamworks.PublishedFileId_t itemId)
{
if (!ok)
{
string message = this.steamworks.errorMessage;
if (this.steamworks.lastResult == Steamworks.EResult.k_EResultTimeout)
{
message += "\n\nPlease try again later.";
}
EditorUtility.DisplayDialog("Could not create item", message, "Ok");
return;
}
if (this.steamworks.HasCurrentItem())
{
// Create staging folder for new item.
if (!Directory.Exists(CurrentItemStagingPath()))
{
Directory.CreateDirectory(CurrentItemStagingPath());
}
OpenedItem();
FindLocalItems();
this.changelog = "Created a new item.";
}
}
void QueryLocalItemDetails()
{
Steamworks.PublishedFileId_t[] itemIds = new Steamworks.PublishedFileId_t[this.localItems.Length];
for (int i = 0; i < this.localItems.Length; i++)
{
itemIds[i] = new Steamworks.PublishedFileId_t(this.localItems[i]);
}
this.steamworks.QueryItemInfo(itemIds);
}
public static SteamAPICall_t AddItemToFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_AddItemToFavorites(CSteamAPIContext.GetSteamUGC(), nAppId, nPublishedFileID));
}
/// <summary>
/// <para> unsubscribe from this item, will be uninstalled after game quits</para>
/// </summary>
public static SteamAPICall_t UnsubscribeItem(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_UnsubscribeItem(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID));
}
/// <summary>
/// <para> Steam Workshop Consumer API</para>
/// </summary>
public static SteamAPICall_t SetUserItemVote(PublishedFileId_t nPublishedFileID, bool bVoteUp)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_SetUserItemVote(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID, bVoteUp));
}
/// <summary>
/// <para> DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead!</para>
/// </summary>
public static SteamAPICall_t RequestUGCDetails(PublishedFileId_t nPublishedFileID, uint unMaxAgeSeconds)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_RequestUGCDetails(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID, unMaxAgeSeconds));
}
// unsubscribe from this item, will be uninstalled after game quits
public static SteamAPICall_t UnsubscribeItem(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_UnsubscribeItem(nPublishedFileID));
}
// Request full details for one piece of UGC
public static SteamAPICall_t RequestUGCDetails(PublishedFileId_t nPublishedFileID, uint unMaxAgeSeconds)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_RequestUGCDetails(nPublishedFileID, unMaxAgeSeconds));
}
public static SteamAPICall_t GetUserItemVote(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamGameServerUGC_GetUserItemVote(nPublishedFileID));
}
/// <summary>
/// <para> delete the item without prompting the user</para>
/// </summary>
public static SteamAPICall_t DeleteItem(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_DeleteItem(CSteamAPIContext.GetSteamUGC(), nPublishedFileID));
}
/// <summary>
/// <para> request app dependencies. note that whatever callback you register for GetAppDependenciesResult_t may be called multiple times</para>
/// <para> until all app dependencies have been returned</para>
/// </summary>
public static SteamAPICall_t GetAppDependencies(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_GetAppDependencies(CSteamAPIContext.GetSteamUGC(), nPublishedFileID));
}
public static SteamAPICall_t RemoveAppDependency(PublishedFileId_t nPublishedFileID, AppId_t nAppID)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_RemoveAppDependency(CSteamAPIContext.GetSteamUGC(), nPublishedFileID, nAppID));
}
/// <summary>
/// <para> parent-child relationship or dependency management</para>
/// </summary>
public static SteamAPICall_t AddDependency(PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUGC_AddDependency(CSteamAPIContext.GetSteamUGC(), nParentPublishedFileID, nChildPublishedFileID));
}
/// <summary>
/// <para> download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed,</para>
/// <para> then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time.</para>
/// <para> If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.</para>
/// </summary>
public static bool DownloadItem(PublishedFileId_t nPublishedFileID, bool bHighPriority)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamUGC_DownloadItem(CSteamAPIContext.GetSteamUGC(), nPublishedFileID, bHighPriority));
}
/// <summary>
/// <para> get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once</para>
/// </summary>
public static bool GetItemDownloadInfo(PublishedFileId_t nPublishedFileID, out ulong punBytesDownloaded, out ulong punBytesTotal)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamUGC_GetItemDownloadInfo(CSteamAPIContext.GetSteamUGC(), nPublishedFileID, out punBytesDownloaded, out punBytesTotal));
}
public static SteamAPICall_t GetUserPublishedItemVoteDetails(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_GetUserPublishedItemVoteDetails(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId));
}
public static SteamAPICall_t SetUserPublishedFileAction(PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_SetUserPublishedFileAction(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId, eAction));
}
public static SteamAPICall_t AddItemToFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamGameServerUGC_AddItemToFavorites(nAppId, nPublishedFileID));
}
// start an UGC item update. Set changed properties before commiting update with CommitItemUpdate()
public static UGCUpdateHandle_t StartItemUpdate(AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return((UGCUpdateHandle_t)NativeMethods.ISteamUGC_StartItemUpdate(nConsumerAppId, nPublishedFileID));
}
/// <summary>
/// <para> subscribe to this item, will be installed ASAP</para>
/// </summary>
public static SteamAPICall_t SubscribeItem(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamGameServerUGC_SubscribeItem(nPublishedFileID));
}
public static bool GetItemUpdateInfo(PublishedFileId_t nPublishedFileID, out bool pbNeedsUpdate, out bool pbIsDownloading, out ulong punBytesDownloaded, out ulong punBytesTotal)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamUGC_GetItemUpdateInfo(nPublishedFileID, out pbNeedsUpdate, out pbIsDownloading, out punBytesDownloaded, out punBytesTotal));
}
/// <summary>
/// <para> get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once</para>
/// </summary>
public static bool GetItemDownloadInfo(PublishedFileId_t nPublishedFileID, out ulong punBytesDownloaded, out ulong punBytesTotal)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerUGC_GetItemDownloadInfo(nPublishedFileID, out punBytesDownloaded, out punBytesTotal));
}
/// <summary>
/// <para> start an UGC item update. Set changed properties before commiting update with CommitItemUpdate()</para>
/// </summary>
public static UGCUpdateHandle_t StartItemUpdate(AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((UGCUpdateHandle_t)NativeMethods.ISteamUGC_StartItemUpdate(CSteamGameServerAPIContext.GetSteamUGC(), nConsumerAppId, nPublishedFileID));
}
/// <summary>
/// <para> download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed,</para>
/// <para> then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time.</para>
/// <para> If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.</para>
/// </summary>
public static bool DownloadItem(PublishedFileId_t nPublishedFileID, bool bHighPriority)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamGameServerUGC_DownloadItem(nPublishedFileID, bHighPriority));
}
public static SteamAPICall_t RemoveItemFromFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_RemoveItemFromFavorites(CSteamGameServerAPIContext.GetSteamUGC(), nAppId, nPublishedFileID));
}
public static PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return((PublishedFileUpdateHandle_t)NativeMethods.ISteamRemoteStorage_CreatePublishedFileUpdateRequest(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId));
}
/// <summary>
/// <para> get EItemState flags about item on this client</para>
/// </summary>
public static uint GetItemState(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetItemState(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID));
}
public static SteamAPICall_t UnsubscribePublishedFile(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UnsubscribePublishedFile(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId));
}
public static SteamAPICall_t UpdateUserPublishedItemVote(PublishedFileId_t unPublishedFileId, bool bVoteUp)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UpdateUserPublishedItemVote(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId, bVoteUp));
}
/// <summary>
/// <para> get EItemState flags about item on this client</para>
/// </summary>
public static uint GetItemState(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamUGC_GetItemState(nPublishedFileID));
}
