/// <summary>
/// <para> Query for all matching UGC using the new deep paging interface. Creator app id or consumer app id must be valid and be set to the current running app. pchCursor should be set to NULL or "*" to get the first result set.</para>
/// </summary>
public static UGCQueryHandle_t CreateQueryAllUGCRequest(EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, string pchCursor = null)
{
InteropHelp.TestIfAvailableGameServer();
using (var pchCursor2 = new InteropHelp.UTF8StringHandle(pchCursor)) {
return((UGCQueryHandle_t)NativeMethods.ISteamUGC_CreateQueryAllUGCRequestCursor(CSteamGameServerAPIContext.GetSteamUGC(), eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor2));
}
}
/// <summary>
/// <para> Release the request to free up memory, after retrieving results</para>
/// </summary>
public static bool ReleaseQueryUGCRequest(UGCQueryHandle_t handle)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_ReleaseQueryUGCRequest(CSteamGameServerAPIContext.GetSteamUGC(), handle));
}
/// <summary>
/// <para> Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.</para>
/// </summary>
public static UGCQueryHandle_t CreateQueryUserUGCRequest(AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint unPage)
{
InteropHelp.TestIfAvailableGameServer();
return((UGCQueryHandle_t)NativeMethods.ISteamUGC_CreateQueryUserUGCRequest(CSteamGameServerAPIContext.GetSteamUGC(), unAccountID, eListType, eMatchingUGCType, eSortOrder, nCreatorAppID, nConsumerAppID, unPage));
}
/// <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.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_GetAppDependencies(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID));
}
public static bool GetQueryUGCStatistic(UGCQueryHandle_t handle, uint index, EItemStatistic eStatType, out ulong pStatValue)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetQueryUGCStatistic(CSteamGameServerAPIContext.GetSteamUGC(), handle, index, eStatType, out pStatValue));
}
/// <summary>
/// <para> Retrieve an individual result after receiving the callback for querying UGC</para>
/// </summary>
public static bool GetQueryUGCResult(UGCQueryHandle_t handle, uint index, out SteamUGCDetails_t pDetails)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetQueryUGCResult(CSteamGameServerAPIContext.GetSteamUGC(), handle, index, out pDetails));
}
public static SteamAPICall_t StopPlaytimeTrackingForAllItems()
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_StopPlaytimeTrackingForAllItems(CSteamGameServerAPIContext.GetSteamUGC()));
}
/// <summary>
/// <para> remove a preview by index starting at 0 (previews are sorted)</para>
/// </summary>
public static bool RemoveItemPreview(UGCUpdateHandle_t handle, uint index)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_RemoveItemPreview(CSteamGameServerAPIContext.GetSteamUGC(), handle, index));
}
public static EItemUpdateStatus GetItemUpdateProgress(UGCUpdateHandle_t handle, out ulong punBytesProcessed, out ulong punBytesTotal)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetItemUpdateProgress(CSteamGameServerAPIContext.GetSteamUGC(), handle, out punBytesProcessed, out punBytesTotal));
}
/// <summary>
/// <para> remove all existing key-value tags (you can add new ones via the AddItemKeyValueTag function)</para>
/// </summary>
public static bool RemoveAllItemKeyValueTags(UGCUpdateHandle_t handle)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_RemoveAllItemKeyValueTags(CSteamGameServerAPIContext.GetSteamUGC(), handle));
}
/// <summary>
/// <para> Query for the details of the given published file ids (the RequestUGCDetails call is deprecated and replaced with this)</para>
/// </summary>
public static UGCQueryHandle_t CreateQueryUGCDetailsRequest(PublishedFileId_t[] pvecPublishedFileID, uint unNumPublishedFileIDs)
{
InteropHelp.TestIfAvailableGameServer();
return((UGCQueryHandle_t)NativeMethods.ISteamUGC_CreateQueryUGCDetailsRequest(CSteamGameServerAPIContext.GetSteamUGC(), pvecPublishedFileID, unNumPublishedFileIDs));
}
/// <summary>
/// <para> use legacy upload for a single small file. The parameter to SetItemContent() should either be a directory with one file or the full path to the file. The file must also be less than 10MB in size.</para>
/// </summary>
public static bool SetAllowLegacyUpload(UGCUpdateHandle_t handle, bool bAllowLegacyUpload)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_SetAllowLegacyUpload(CSteamGameServerAPIContext.GetSteamUGC(), handle, bAllowLegacyUpload));
}
/// <summary>
/// <para> change the tags of an UGC item</para>
/// </summary>
public static bool SetItemTags(UGCUpdateHandle_t updateHandle, System.Collections.Generic.IList <string> pTags)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_SetItemTags(CSteamGameServerAPIContext.GetSteamUGC(), updateHandle, new InteropHelp.SteamParamStringArray(pTags)));
}
/// <summary>
/// <para> change the visibility of an UGC item</para>
/// </summary>
public static bool SetItemVisibility(UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_SetItemVisibility(CSteamGameServerAPIContext.GetSteamUGC(), handle, eVisibility));
}
/// <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.ISteamUGC_DownloadItem(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID, bHighPriority));
}
/// <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> SuspendDownloads( true ) will suspend all workshop downloads until SuspendDownloads( false ) is called or the game ends</para>
/// </summary>
public static void SuspendDownloads(bool bSuspend)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamUGC_SuspendDownloads(CSteamGameServerAPIContext.GetSteamUGC(), bSuspend);
}
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 SteamAPICall_t StopPlaytimeTracking(PublishedFileId_t[] pvecPublishedFileID, uint unNumPublishedFileIDs)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_StopPlaytimeTracking(CSteamGameServerAPIContext.GetSteamUGC(), pvecPublishedFileID, unNumPublishedFileIDs));
}
/// <summary>
/// <para> Send the query to Steam</para>
/// </summary>
public static SteamAPICall_t SendQueryUGCRequest(UGCQueryHandle_t handle)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_SendQueryUGCRequest(CSteamGameServerAPIContext.GetSteamUGC(), handle));
}
public static SteamAPICall_t RemoveDependency(PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_RemoveDependency(CSteamGameServerAPIContext.GetSteamUGC(), nParentPublishedFileID, nChildPublishedFileID));
}
/// <summary>
/// <para> number of subscribed items</para>
/// </summary>
public static uint GetNumSubscribedItems()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetNumSubscribedItems(CSteamGameServerAPIContext.GetSteamUGC()));
}
/// <summary>
/// <para> delete the item without prompting the user</para>
/// </summary>
public static SteamAPICall_t DeleteItem(PublishedFileId_t nPublishedFileID)
{
InteropHelp.TestIfAvailableGameServer();
return((SteamAPICall_t)NativeMethods.ISteamUGC_DeleteItem(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID));
}
/// <summary>
/// <para> all subscribed item PublishFileIDs</para>
/// </summary>
public static uint GetSubscribedItems(PublishedFileId_t[] pvecPublishedFileID, uint cMaxEntries)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetSubscribedItems(CSteamGameServerAPIContext.GetSteamUGC(), pvecPublishedFileID, cMaxEntries));
}
public static uint GetQueryUGCNumKeyValueTags(UGCQueryHandle_t handle, uint index)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_GetQueryUGCNumKeyValueTags(CSteamGameServerAPIContext.GetSteamUGC(), handle, index));
}
/// <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));
}
/// <summary>
/// <para> match any of the tags in this group</para>
/// </summary>
public static bool AddRequiredTagGroup(UGCQueryHandle_t handle, System.Collections.Generic.IList <string> pTagGroups)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_AddRequiredTagGroup(CSteamGameServerAPIContext.GetSteamUGC(), handle, new InteropHelp.SteamParamStringArray(pTagGroups)));
}
/// <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.ISteamUGC_GetItemDownloadInfo(CSteamGameServerAPIContext.GetSteamUGC(), nPublishedFileID, out punBytesDownloaded, out punBytesTotal));
}
public static bool SetReturnMetadata(UGCQueryHandle_t handle, bool bReturnMetadata)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUGC_SetReturnMetadata(CSteamGameServerAPIContext.GetSteamUGC(), handle, bReturnMetadata));
}
/// <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));
}
