public PublishedFile(PublishedFileId_t id, AppId_t appId) {
Contract.Requires<ArgumentNullException>(id != null);
Contract.Requires<ArgumentNullException>(appId != null);
Pid = id;
Aid = appId;
}
public static bool GetItemInstallInfo(PublishedFileId_t nPublishedFileID, out ulong punSizeOnDisk, out string pchFolder, uint cchFolderSize, out uint punTimeStamp)
{
InteropHelp.TestIfAvailableClient();
IntPtr intPtr = Marshal.AllocHGlobal((int)cchFolderSize);
bool flag = NativeMethods.ISteamUGC_GetItemInstallInfo(nPublishedFileID, out punSizeOnDisk, intPtr, cchFolderSize, out punTimeStamp);
pchFolder = ((!flag) ? null : InteropHelp.PtrToStringUTF8(intPtr));
Marshal.FreeHGlobal(intPtr);
return flag;
}
private void Reset() {
m_State = EState.Initialized;
m_tmpPublishedFileId = PublishedFileId_t.Invalid;
m_tmpNeedsToAcceptTOS = false;
m_tmpUpdateHandle = UGCUpdateHandle_t.Invalid;
m_tmpContentFolder = "";
m_tmpPreviewFile = "";
m_tmpName = "";
m_tmpDescription = "";
m_tmpVisibility = ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPrivate;
m_CrateItemResult.Cancel();
m_SubmitItemUpdateResult.Cancel();
}
private void OnCreateItemResult(CreateItemResult_t pCallback, bool bIOFailed) {
print("OnCreateItemResult - m_eResult: " + pCallback.m_eResult + " | m_nPublishedFileId: " + pCallback.m_nPublishedFileId + " | m_bUserNeedsToAcceptWorkshopLegalAgreement: " + pCallback.m_bUserNeedsToAcceptWorkshopLegalAgreement);
if (bIOFailed) {
//ESteamAPICallFailure failureReason = SteamUtils.GetAPICallFailureReason(m_CrateItemResult.Handle);
//Debug.LogError("OnCreateItemResult bIOFailed = true. Reason: " + failureReason);
m_State = EState.Failed;
return;
}
if (pCallback.m_eResult != EResult.k_EResultOK) {
Debug.LogError("OnCreateItemResult m_eResult != k_EResultOK");
m_State = EState.Failed;
return;
}
m_tmpPublishedFileId = pCallback.m_nPublishedFileId;
m_tmpNeedsToAcceptTOS = pCallback.m_bUserNeedsToAcceptWorkshopLegalAgreement;
UpdateWorkshopItem();
}
/// <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.ISteamGameServerUGC_CreateQueryUGCDetailsRequest(pvecPublishedFileID, unNumPublishedFileIDs);
}
/// <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.ISteamGameServerUGC_RequestUGCDetails(nPublishedFileID, unMaxAgeSeconds);
}
public static SteamAPICall_t AddItemToFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID) {
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamUGC_AddItemToFavorites(nAppId, nPublishedFileID);
}
/// <summary>
/// Queries the steam UGC.
/// </summary>
public void QuerySteamUGC()
{
Debug.Log("Started SteamUGC Query");
//Check how many items are being downloaded right now
if(m_RequestUGGDetailsResult.Count > 0)
{
//debug log the items being downloaded
Debug.Log("Number of Items Downloaded right now: " + m_RequestUGGDetailsResult.Count);
}
//If an item is being downloaded. Clear it so we don't have to deal with it.
m_RequestUGGDetailsResult.Clear();
//get the number of items downloaded already
uint nSubscriptions = SteamUGC.GetNumSubscribedItems();
Debug.Log("Subscribed Items: " + nSubscriptions);
PublishedFileId_t[] fileIds = new PublishedFileId_t[nSubscriptions];
uint ret = SteamUGC.GetSubscribedItems(fileIds, nSubscriptions);
if(ret != nSubscriptions)
{
Debug.LogWarning("Subscriptions Returned: " + ret + "| Expected: " + nSubscriptions);
}
for (int i = 0; i < nSubscriptions; i++)
{
//print("Looping over: " + i + " | " + fileIds[i]);
CreatedLevel _creation = new CreatedLevel();
bool installed = SteamUGC.GetItemInstallInfo(fileIds[i], out _creation.unusedSizeOnDisk, out _creation.path, 300, out _creation.unusedLegacyItem);
//Debug.Log("Creation Path: " + _creation.path + " | Creation Unused Size On Disk: " + _creation.unusedSizeOnDisk + "| Creation Unused Legacy Item: " + _creation.unusedLegacyItem);
if(!installed)
{
//TODO do something if the user is subscribed to an item but does not have it downloaded
Debug.Log("Not Installed");
}
int index = i;
//Debug.Log("Get Subscriptions");
var subscriptionDetails = CallResult<SteamUGCRequestUGCDetailsResult_t>.Create(OnSteamUGCRequestUGCDetailsResult);
subscriptionDetails.Set(SteamUGC.RequestUGCDetails(fileIds[i], 0));
m_RequestUGGDetailsResult.Add(subscriptionDetails);
_creation.publishFileID = fileIds[i];
//m_RequestUGGDetailsResult.Remove(subscriptionDetails);
//add the level we got from WorkShop Servers the the Created Levels List for later use
m_CreatedLevels.Add(_creation);
}
//TODO: Create a list of the levels you are subscribed too!
//TODO: Consume when clicking the levels you are subscribed too!
}
protected override bool CanStart(PublishedFileId_t id)
{
return(true);
}
public static SteamAPICall_t GetUserPublishedItemVoteDetails(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamRemoteStorage_GetUserPublishedItemVoteDetails(unPublishedFileId);
}
/// <summary>
/// <para> get info about currently installed content on disc for items that have k_EItemStateInstalled set</para>
/// <para> if k_EItemStateLegacyItem is set, pchFolder contains the path to the legacy file itself (not a folder)</para>
/// </summary>
public static bool GetItemInstallInfo(PublishedFileId_t nPublishedFileID, out ulong punSizeOnDisk, out string pchFolder, uint cchFolderSize, out uint punTimeStamp) {
InteropHelp.TestIfAvailableGameServer();
IntPtr pchFolder2 = Marshal.AllocHGlobal((int)cchFolderSize);
bool ret = NativeMethods.ISteamGameServerUGC_GetItemInstallInfo(nPublishedFileID, out punSizeOnDisk, pchFolder2, cchFolderSize, out punTimeStamp);
pchFolder = ret ? InteropHelp.PtrToStringUTF8(pchFolder2) : null;
Marshal.FreeHGlobal(pchFolder2);
return ret;
}
public SteamPublished(string newName, PublishedFileId_t newID)
{
this._name = newName;
this._id = newID;
}
/// <summary> /// Called when an error occurs during download. /// </summary> /// <param name="id">The mod ID that failed to download.</param> /// <param name="result">The result of the download.</param> protected abstract void OnError(PublishedFileId_t id, EResult result);
/// <summary> /// Called when a mod successfully downloads. /// </summary> /// <param name="id">The mod ID that was just downloaded.</param> /// <param name="size">The size of the file downloaded in bytes.</param> protected abstract void OnComplete(PublishedFileId_t id, int size);
/// <summary>
/// Executes the Steam remote storage call to download this mod.
/// </summary>
/// <param name="id">The mod ID in the queue.</param>
/// <param name="globalEvent">If true, waits for the global DownloadItem event instead
/// of the result.</param>
/// <returns>The ID of the content to be downloaded.</returns>
protected abstract SteamAPICall_t ExecuteDownload(PublishedFileId_t id,
out bool globalEvent);
/// <summary>
/// If true, the download of this mod will be temporarily skipped, and will only be
/// rechecked
/// </summary>
/// <param name="id">The mod ID to check.</param>
/// <returns>true if that mod can be downloaded now, or false if it should not be started.</returns>
protected virtual bool Defer(PublishedFileId_t id)
{
return(false);
}
public static SteamAPICall_t RemoveItemFromFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID) {
InteropHelp.TestIfAvailableGameServer();
return (SteamAPICall_t)NativeMethods.ISteamGameServerUGC_RemoveItemFromFavorites(nAppId, nPublishedFileID);
}
void OnCreateItemResult(CreateItemResult_t pCallback, bool bIOFailure)
{
Debug.Log("[" + CreateItemResult_t.k_iCallback + " - CreateItemResult] - " + pCallback.m_eResult + " -- " + pCallback.m_nPublishedFileId + " -- " + pCallback.m_bUserNeedsToAcceptWorkshopLegalAgreement);
m_PublishedFileId = pCallback.m_nPublishedFileId;
}
/// <summary>
/// <para> all subscribed item PublishFileIDs</para>
/// </summary>
public static uint GetSubscribedItems(PublishedFileId_t[] pvecPublishedFileID, uint cMaxEntries) {
InteropHelp.TestIfAvailableGameServer();
return NativeMethods.ISteamGameServerUGC_GetSubscribedItems(pvecPublishedFileID, cMaxEntries);
}
void OnRemoteStorageUnsubscribePublishedFileResult(RemoteStorageUnsubscribePublishedFileResult_t pCallback, bool bIOFailure)
{
Debug.Log("[" + RemoteStorageUnsubscribePublishedFileResult_t.k_iCallback + " - RemoteStorageUnsubscribePublishedFileResult] - " + pCallback.m_eResult + " -- " + pCallback.m_nPublishedFileId);
m_PublishedFileId = pCallback.m_nPublishedFileId;
}
/// <summary> /// Checks to see if downloading can be performed on this mod. /// </summary> /// <param name="id">The mod ID to check.</param> /// <returns>true if that mod can be downloaded now, or false if it should not be started.</returns> protected abstract bool CanStart(PublishedFileId_t id);
public void RenderOnGUI()
{
GUILayout.BeginArea(new Rect(Screen.width - 200, 0, 200, Screen.height));
GUILayout.Label("Variables:");
GUILayout.Label("m_UGCQueryHandle: " + m_UGCQueryHandle);
GUILayout.Label("m_PublishedFileId: " + m_PublishedFileId);
GUILayout.Label("m_UGCUpdateHandle: " + m_UGCUpdateHandle);
GUILayout.EndArea();
GUILayout.BeginVertical("box");
m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos, GUILayout.Width(Screen.width - 215), GUILayout.Height(Screen.height - 33));
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);
print("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_Items, AppId_t.Invalid, SteamUtils.GetAppID(), 1)"))
{
m_UGCQueryHandle = SteamUGC.CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByPublicationDate, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Items, AppId_t.Invalid, SteamUtils.GetAppID(), 1);
print("SteamUGC.CreateQueryAllUGCRequest(" + EUGCQuery.k_EUGCQuery_RankedByPublicationDate + ", " + EUGCMatchingUGCType.k_EUGCMatchingUGCType_Items + ", " + AppId_t.Invalid + ", " + SteamUtils.GetAppID() + ", " + 1 + ") : " + m_UGCQueryHandle);
}
if (GUILayout.Button("CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByPublicationDate, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Items, AppId_t.Invalid, SteamUtils.GetAppID(), null)"))
{
m_UGCQueryHandle = SteamUGC.CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByPublicationDate, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Items, AppId_t.Invalid, SteamUtils.GetAppID(), null);
print("SteamUGC.CreateQueryAllUGCRequest(" + EUGCQuery.k_EUGCQuery_RankedByPublicationDate + ", " + EUGCMatchingUGCType.k_EUGCMatchingUGCType_Items + ", " + AppId_t.Invalid + ", " + SteamUtils.GetAppID() + ", " + null + ") : " + m_UGCQueryHandle);
}
if (GUILayout.Button("CreateQueryUGCDetailsRequest(PublishedFileIDs, (uint)PublishedFileIDs.Length)"))
{
PublishedFileId_t[] PublishedFileIDs = new PublishedFileId_t[] { TestConstants.Instance.k_PublishedFileId_Champions };
m_UGCQueryHandle = SteamUGC.CreateQueryUGCDetailsRequest(PublishedFileIDs, (uint)PublishedFileIDs.Length);
print("SteamUGC.CreateQueryUGCDetailsRequest(" + PublishedFileIDs + ", " + (uint)PublishedFileIDs.Length + ") : " + m_UGCQueryHandle);
}
if (GUILayout.Button("SendQueryUGCRequest(m_UGCQueryHandle)"))
{
SteamAPICall_t handle = SteamUGC.SendQueryUGCRequest(m_UGCQueryHandle);
OnSteamUGCQueryCompletedCallResult.Set(handle);
print("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);
print(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);
print("SteamUGC.GetQueryUGCResult(" + m_UGCQueryHandle + ", " + 0 + ", " + "out Details" + ") : " + ret + " -- " + Details);
}
if (GUILayout.Button("GetQueryUGCPreviewURL(m_UGCQueryHandle, 0, out URL, 1024)"))
{
string URL;
bool ret = SteamUGC.GetQueryUGCPreviewURL(m_UGCQueryHandle, 0, out URL, 1024);
print("SteamUGC.GetQueryUGCPreviewURL(" + m_UGCQueryHandle + ", " + 0 + ", " + "out URL" + ", " + 1024 + ") : " + ret + " -- " + URL);
}
if (GUILayout.Button("GetQueryUGCMetadata(m_UGCQueryHandle, 0, out Metadata, Constants.k_cchDeveloperMetadataMax)"))
{
string Metadata;
bool ret = SteamUGC.GetQueryUGCMetadata(m_UGCQueryHandle, 0, out Metadata, Constants.k_cchDeveloperMetadataMax);
print("SteamUGC.GetQueryUGCMetadata(" + m_UGCQueryHandle + ", " + 0 + ", " + "out Metadata" + ", " + Constants.k_cchDeveloperMetadataMax + ") : " + ret + " -- " + Metadata);
}
if (GUILayout.Button("GetQueryUGCChildren(m_UGCQueryHandle, 0, PublishedFileIDs, (uint)PublishedFileIDs.Length)"))
{
PublishedFileId_t[] PublishedFileIDs = new PublishedFileId_t[1]; // Use SteamUGCDetails_t.m_unNumChildren instead...
bool ret = SteamUGC.GetQueryUGCChildren(m_UGCQueryHandle, 0, PublishedFileIDs, (uint)PublishedFileIDs.Length);
print("SteamUGC.GetQueryUGCChildren(" + m_UGCQueryHandle + ", " + 0 + ", " + PublishedFileIDs + ", " + (uint)PublishedFileIDs.Length + ") : " + ret);
}
if (GUILayout.Button("GetQueryUGCStatistic(m_UGCQueryHandle, 0, EItemStatistic.k_EItemStatistic_NumSubscriptions, out StatValue)"))
{
ulong StatValue;
bool ret = SteamUGC.GetQueryUGCStatistic(m_UGCQueryHandle, 0, EItemStatistic.k_EItemStatistic_NumSubscriptions, out StatValue);
print("SteamUGC.GetQueryUGCStatistic(" + m_UGCQueryHandle + ", " + 0 + ", " + EItemStatistic.k_EItemStatistic_NumSubscriptions + ", " + "out StatValue" + ") : " + ret + " -- " + StatValue);
}
if (GUILayout.Button("GetQueryUGCNumAdditionalPreviews(m_UGCQueryHandle, 0)"))
{
uint ret = SteamUGC.GetQueryUGCNumAdditionalPreviews(m_UGCQueryHandle, 0);
print("SteamUGC.GetQueryUGCNumAdditionalPreviews(" + m_UGCQueryHandle + ", " + 0 + ") : " + ret);
}
if (GUILayout.Button("GetQueryUGCAdditionalPreview(m_UGCQueryHandle, 0, 0, out pchURLOrVideoID, 1024, out pchOriginalFileName, 260, out pPreviewType)"))
{
// Should check GetQueryUGCNumAdditionalPreviews first.
string pchURLOrVideoID;
string pchOriginalFileName;
EItemPreviewType pPreviewType;
bool ret = SteamUGC.GetQueryUGCAdditionalPreview(m_UGCQueryHandle, 0, 0, out pchURLOrVideoID, 1024, out pchOriginalFileName, 260, out pPreviewType);
print("SteamUGC.GetQueryUGCAdditionalPreview(" + m_UGCQueryHandle + ", " + 0 + ", " + 0 + ", " + "out pchURLOrVideoID" + ", " + 1024 + ", " + "out pchOriginalFileName" + ", " + 260 + ", " + "out pPreviewType" + ") : " + ret + " -- " + pchURLOrVideoID + " -- " + pchOriginalFileName + " -- " + pPreviewType);
}
if (GUILayout.Button("GetQueryUGCNumKeyValueTags(m_UGCQueryHandle, 0)"))
{
uint ret = SteamUGC.GetQueryUGCNumKeyValueTags(m_UGCQueryHandle, 0);
print("SteamUGC.GetQueryUGCNumKeyValueTags(" + m_UGCQueryHandle + ", " + 0 + ") : " + ret);
}
if (GUILayout.Button("GetQueryUGCKeyValueTag(m_UGCQueryHandle, 0, 0, out Key, 260, out Value, 260)"))
{
string Key;
string Value;
bool ret = SteamUGC.GetQueryUGCKeyValueTag(m_UGCQueryHandle, 0, 0, out Key, 260, out Value, 260);
print("SteamUGC.GetQueryUGCKeyValueTag(" + m_UGCQueryHandle + ", " + 0 + ", " + 0 + ", " + "out Key" + ", " + 260 + ", " + "out Value" + ", " + 260 + ") : " + ret + " -- " + Key + " -- " + Value);
}
if (GUILayout.Button("ReleaseQueryUGCRequest(m_UGCQueryHandle)"))
{
bool ret = SteamUGC.ReleaseQueryUGCRequest(m_UGCQueryHandle);
print("SteamUGC.ReleaseQueryUGCRequest(" + m_UGCQueryHandle + ") : " + ret);
}
if (GUILayout.Button("AddRequiredTag(m_UGCQueryHandle, \"Co-op\")"))
{
bool ret = SteamUGC.AddRequiredTag(m_UGCQueryHandle, "Co-op");
print("SteamUGC.AddRequiredTag(" + m_UGCQueryHandle + ", " + "\"Co-op\"" + ") : " + ret);
}
if (GUILayout.Button("AddExcludedTag(m_UGCQueryHandle, \"Co-op\")"))
{
bool ret = SteamUGC.AddExcludedTag(m_UGCQueryHandle, "Co-op");
print("SteamUGC.AddExcludedTag(" + m_UGCQueryHandle + ", " + "\"Co-op\"" + ") : " + ret);
}
if (GUILayout.Button("SetReturnOnlyIDs(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnOnlyIDs(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnOnlyIDs(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnKeyValueTags(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnKeyValueTags(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnKeyValueTags(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnLongDescription(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnLongDescription(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnLongDescription(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnMetadata(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnMetadata(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnMetadata(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnChildren(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnChildren(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnChildren(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnAdditionalPreviews(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnAdditionalPreviews(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnAdditionalPreviews(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnTotalOnly(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetReturnTotalOnly(m_UGCQueryHandle, true);
print("SteamUGC.SetReturnTotalOnly(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetReturnPlaytimeStats(m_UGCQueryHandle, 7)"))
{
bool ret = SteamUGC.SetReturnPlaytimeStats(m_UGCQueryHandle, 7);
print("SteamUGC.SetReturnPlaytimeStats(" + m_UGCQueryHandle + ", " + 7 + ") : " + ret);
}
if (GUILayout.Button("SetLanguage(m_UGCQueryHandle, \"english\")"))
{
bool ret = SteamUGC.SetLanguage(m_UGCQueryHandle, "english");
print("SteamUGC.SetLanguage(" + m_UGCQueryHandle + ", " + "\"english\"" + ") : " + ret);
}
if (GUILayout.Button("SetAllowCachedResponse(m_UGCQueryHandle, 5)"))
{
bool ret = SteamUGC.SetAllowCachedResponse(m_UGCQueryHandle, 5);
print("SteamUGC.SetAllowCachedResponse(" + m_UGCQueryHandle + ", " + 5 + ") : " + ret);
}
if (GUILayout.Button("SetCloudFileNameFilter(m_UGCQueryHandle, \"\")"))
{
bool ret = SteamUGC.SetCloudFileNameFilter(m_UGCQueryHandle, "");
print("SteamUGC.SetCloudFileNameFilter(" + m_UGCQueryHandle + ", " + "\"\"" + ") : " + ret);
}
if (GUILayout.Button("SetMatchAnyTag(m_UGCQueryHandle, true)"))
{
bool ret = SteamUGC.SetMatchAnyTag(m_UGCQueryHandle, true);
print("SteamUGC.SetMatchAnyTag(" + m_UGCQueryHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("SetSearchText(m_UGCQueryHandle, \"Test\")"))
{
bool ret = SteamUGC.SetSearchText(m_UGCQueryHandle, "Test");
print("SteamUGC.SetSearchText(" + m_UGCQueryHandle + ", " + "\"Test\"" + ") : " + ret);
}
if (GUILayout.Button("SetRankedByTrendDays(m_UGCQueryHandle, 7)"))
{
bool ret = SteamUGC.SetRankedByTrendDays(m_UGCQueryHandle, 7);
print("SteamUGC.SetRankedByTrendDays(" + m_UGCQueryHandle + ", " + 7 + ") : " + ret);
}
if (GUILayout.Button("AddRequiredKeyValueTag(m_UGCQueryHandle, \"TestKey\", \"TestValue\")"))
{
bool ret = SteamUGC.AddRequiredKeyValueTag(m_UGCQueryHandle, "TestKey", "TestValue");
print("SteamUGC.AddRequiredKeyValueTag(" + m_UGCQueryHandle + ", " + "\"TestKey\"" + ", " + "\"TestValue\"" + ") : " + ret);
}
if (GUILayout.Button("RequestUGCDetails(m_PublishedFileId, 5)"))
{
SteamAPICall_t handle = SteamUGC.RequestUGCDetails(m_PublishedFileId, 5);
OnSteamUGCRequestUGCDetailsResultCallResult.Set(handle);
print("SteamUGC.RequestUGCDetails(" + m_PublishedFileId + ", " + 5 + ") : " + handle);
}
if (GUILayout.Button("CreateItem(SteamUtils.GetAppID(), EWorkshopFileType.k_EWorkshopFileTypeCommunity)"))
{
SteamAPICall_t handle = SteamUGC.CreateItem(SteamUtils.GetAppID(), EWorkshopFileType.k_EWorkshopFileTypeCommunity);
OnCreateItemResultCallResult.Set(handle);
print("SteamUGC.CreateItem(" + SteamUtils.GetAppID() + ", " + EWorkshopFileType.k_EWorkshopFileTypeCommunity + ") : " + handle);
}
if (GUILayout.Button("StartItemUpdate(SteamUtils.GetAppID(), m_PublishedFileId)"))
{
m_UGCUpdateHandle = SteamUGC.StartItemUpdate(SteamUtils.GetAppID(), m_PublishedFileId);
print("SteamUGC.StartItemUpdate(" + SteamUtils.GetAppID() + ", " + m_PublishedFileId + ") : " + m_UGCUpdateHandle);
}
if (GUILayout.Button("SetItemTitle(m_UGCUpdateHandle, \"This is a Test\")"))
{
bool ret = SteamUGC.SetItemTitle(m_UGCUpdateHandle, "This is a Test");
print("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.");
print("SteamUGC.SetItemDescription(" + m_UGCUpdateHandle + ", " + "\"This is the test description.\"" + ") : " + ret);
}
if (GUILayout.Button("SetItemUpdateLanguage(m_UGCUpdateHandle, \"english\")"))
{
bool ret = SteamUGC.SetItemUpdateLanguage(m_UGCUpdateHandle, "english");
print("SteamUGC.SetItemUpdateLanguage(" + m_UGCUpdateHandle + ", " + "\"english\"" + ") : " + ret);
}
if (GUILayout.Button("SetItemMetadata(m_UGCUpdateHandle, \"This is the test metadata.\")"))
{
bool ret = SteamUGC.SetItemMetadata(m_UGCUpdateHandle, "This is the test metadata.");
print("SteamUGC.SetItemMetadata(" + m_UGCUpdateHandle + ", " + "\"This is the test metadata.\"" + ") : " + ret);
}
if (GUILayout.Button("SetItemVisibility(m_UGCUpdateHandle, ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic)"))
{
bool ret = SteamUGC.SetItemVisibility(m_UGCUpdateHandle, ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic);
print("SteamUGC.SetItemVisibility(" + m_UGCUpdateHandle + ", " + ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic + ") : " + 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" });
print("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, Application.dataPath + "/Scenes");
print("SteamUGC.SetItemContent(" + m_UGCUpdateHandle + ", " + Application.dataPath + "/Scenes" + ") : " + ret);
}
if (GUILayout.Button("SetItemPreview(m_UGCUpdateHandle, Application.dataPath + \"/PreviewImage.jpg\")"))
{
bool ret = SteamUGC.SetItemPreview(m_UGCUpdateHandle, Application.dataPath + "/PreviewImage.jpg");
print("SteamUGC.SetItemPreview(" + m_UGCUpdateHandle + ", " + Application.dataPath + "/PreviewImage.jpg" + ") : " + ret);
}
if (GUILayout.Button("SetAllowLegacyUpload(m_UGCUpdateHandle, true)"))
{
bool ret = SteamUGC.SetAllowLegacyUpload(m_UGCUpdateHandle, true);
print("SteamUGC.SetAllowLegacyUpload(" + m_UGCUpdateHandle + ", " + true + ") : " + ret);
}
if (GUILayout.Button("RemoveItemKeyValueTags(m_UGCUpdateHandle, \"TestKey\")"))
{
bool ret = SteamUGC.RemoveItemKeyValueTags(m_UGCUpdateHandle, "TestKey");
print("SteamUGC.RemoveItemKeyValueTags(" + m_UGCUpdateHandle + ", " + "\"TestKey\"" + ") : " + ret);
}
if (GUILayout.Button("AddItemKeyValueTag(m_UGCUpdateHandle, \"TestKey\", \"TestValue\")"))
{
bool ret = SteamUGC.AddItemKeyValueTag(m_UGCUpdateHandle, "TestKey", "TestValue");
print("SteamUGC.AddItemKeyValueTag(" + m_UGCUpdateHandle + ", " + "\"TestKey\"" + ", " + "\"TestValue\"" + ") : " + ret);
}
if (GUILayout.Button("AddItemPreviewFile(m_UGCUpdateHandle, Application.dataPath + \"/PreviewImage.jpg\", EItemPreviewType.k_EItemPreviewType_Image)"))
{
bool ret = SteamUGC.AddItemPreviewFile(m_UGCUpdateHandle, Application.dataPath + "/PreviewImage.jpg", EItemPreviewType.k_EItemPreviewType_Image);
print("SteamUGC.AddItemPreviewFile(" + m_UGCUpdateHandle + ", " + Application.dataPath + "/PreviewImage.jpg" + ", " + EItemPreviewType.k_EItemPreviewType_Image + ") : " + ret);
}
if (GUILayout.Button("AddItemPreviewVideo(m_UGCUpdateHandle, \"jHgZh4GV9G0\")"))
{
bool ret = SteamUGC.AddItemPreviewVideo(m_UGCUpdateHandle, "jHgZh4GV9G0");
print("SteamUGC.AddItemPreviewVideo(" + m_UGCUpdateHandle + ", " + "\"jHgZh4GV9G0\"" + ") : " + ret);
}
if (GUILayout.Button("UpdateItemPreviewFile(m_UGCUpdateHandle, 0, Application.dataPath + \"/PreviewImage.jpg\")"))
{
bool ret = SteamUGC.UpdateItemPreviewFile(m_UGCUpdateHandle, 0, Application.dataPath + "/PreviewImage.jpg");
print("SteamUGC.UpdateItemPreviewFile(" + m_UGCUpdateHandle + ", " + 0 + ", " + Application.dataPath + "/PreviewImage.jpg" + ") : " + ret);
}
if (GUILayout.Button("UpdateItemPreviewVideo(m_UGCUpdateHandle, 0, \"jHgZh4GV9G0\")"))
{
bool ret = SteamUGC.UpdateItemPreviewVideo(m_UGCUpdateHandle, 0, "jHgZh4GV9G0");
print("SteamUGC.UpdateItemPreviewVideo(" + m_UGCUpdateHandle + ", " + 0 + ", " + "\"jHgZh4GV9G0\"" + ") : " + ret);
}
if (GUILayout.Button("RemoveItemPreview(m_UGCUpdateHandle, 0)"))
{
bool ret = SteamUGC.RemoveItemPreview(m_UGCUpdateHandle, 0);
print("SteamUGC.RemoveItemPreview(" + m_UGCUpdateHandle + ", " + 0 + ") : " + ret);
}
if (GUILayout.Button("SubmitItemUpdate(m_UGCUpdateHandle, \"Test Changenote\")"))
{
SteamAPICall_t handle = SteamUGC.SubmitItemUpdate(m_UGCUpdateHandle, "Test Changenote");
OnSubmitItemUpdateResultCallResult.Set(handle);
print("SteamUGC.SubmitItemUpdate(" + m_UGCUpdateHandle + ", " + "\"Test Changenote\"" + ") : " + handle);
}
{
ulong BytesProcessed;
ulong BytesTotal;
EItemUpdateStatus ret = SteamUGC.GetItemUpdateProgress(m_UGCUpdateHandle, out BytesProcessed, out BytesTotal);
GUILayout.Label("GetItemUpdateProgress(m_UGCUpdateHandle, out BytesProcessed, out BytesTotal) : " + ret + " -- " + BytesProcessed + " -- " + BytesTotal);
}
if (GUILayout.Button("SetUserItemVote(TestConstants.Instance.k_PublishedFileId_Champions, true)"))
{
SteamAPICall_t handle = SteamUGC.SetUserItemVote(TestConstants.Instance.k_PublishedFileId_Champions, true);
OnSetUserItemVoteResultCallResult.Set(handle);
print("SteamUGC.SetUserItemVote(" + TestConstants.Instance.k_PublishedFileId_Champions + ", " + true + ") : " + handle);
}
if (GUILayout.Button("GetUserItemVote(TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.GetUserItemVote(TestConstants.Instance.k_PublishedFileId_Champions);
OnGetUserItemVoteResultCallResult.Set(handle);
print("SteamUGC.GetUserItemVote(" + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
if (GUILayout.Button("AddItemToFavorites(SteamUtils.GetAppID(), TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.AddItemToFavorites(SteamUtils.GetAppID(), TestConstants.Instance.k_PublishedFileId_Champions);
OnUserFavoriteItemsListChangedCallResult.Set(handle);
print("SteamUGC.AddItemToFavorites(" + SteamUtils.GetAppID() + ", " + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
if (GUILayout.Button("RemoveItemFromFavorites(SteamUtils.GetAppID(), TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.RemoveItemFromFavorites(SteamUtils.GetAppID(), TestConstants.Instance.k_PublishedFileId_Champions);
OnUserFavoriteItemsListChangedCallResult.Set(handle);
print("SteamUGC.RemoveItemFromFavorites(" + SteamUtils.GetAppID() + ", " + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
if (GUILayout.Button("SubscribeItem(TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.SubscribeItem(TestConstants.Instance.k_PublishedFileId_Champions);
OnRemoteStorageSubscribePublishedFileResultCallResult.Set(handle);
print("SteamUGC.SubscribeItem(" + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
if (GUILayout.Button("UnsubscribeItem(TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.UnsubscribeItem(TestConstants.Instance.k_PublishedFileId_Champions);
OnRemoteStorageUnsubscribePublishedFileResultCallResult.Set(handle);
print("SteamUGC.UnsubscribeItem(" + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
GUILayout.Label("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];
print("SteamUGC.GetSubscribedItems(" + PublishedFileID + ", " + (uint)PublishedFileID.Length + ") : " + ret);
print(m_PublishedFileId);
}
GUILayout.Label("GetItemState(PublishedFileID) : " + (EItemState)SteamUGC.GetItemState(m_PublishedFileId));
{
ulong SizeOnDisk;
string Folder;
uint punTimeStamp;
bool ret = SteamUGC.GetItemInstallInfo(m_PublishedFileId, out SizeOnDisk, out Folder, 1024, out punTimeStamp);
GUILayout.Label("GetItemInstallInfo(m_PublishedFileId, out SizeOnDisk, out Folder, 1024, out punTimeStamp) : " + ret + " -- " + SizeOnDisk + " -- " + Folder + " -- " + punTimeStamp);
}
if (GUILayout.Button("GetItemDownloadInfo(m_PublishedFileId, out BytesDownloaded, out BytesTotal)"))
{
ulong BytesDownloaded;
ulong BytesTotal;
bool ret = SteamUGC.GetItemDownloadInfo(m_PublishedFileId, out BytesDownloaded, out BytesTotal);
print("SteamUGC.GetItemDownloadInfo(" + m_PublishedFileId + ", " + "out BytesDownloaded" + ", " + "out BytesTotal" + ") : " + ret + " -- " + BytesDownloaded + " -- " + BytesTotal);
}
if (GUILayout.Button("DownloadItem(m_PublishedFileId, true)"))
{
bool ret = SteamUGC.DownloadItem(m_PublishedFileId, true);
print("SteamUGC.DownloadItem(" + m_PublishedFileId + ", " + true + ") : " + ret);
}
if (GUILayout.Button("BInitWorkshopForGameServer((DepotId_t)481, \"C:/UGCTest\")"))
{
bool ret = SteamUGC.BInitWorkshopForGameServer((DepotId_t)481, "C:/UGCTest");
print("SteamUGC.BInitWorkshopForGameServer(" + (DepotId_t)481 + ", " + "\"C:/UGCTest\"" + ") : " + ret);
}
if (GUILayout.Button("SuspendDownloads(true)"))
{
SteamUGC.SuspendDownloads(true);
print("SteamUGC.SuspendDownloads(" + true + ")");
}
if (GUILayout.Button("StartPlaytimeTracking(PublishedFileIds, (uint)PublishedFileIds.Length)"))
{
PublishedFileId_t[] PublishedFileIds = new PublishedFileId_t[] { TestConstants.Instance.k_PublishedFileId_Champions };
SteamAPICall_t handle = SteamUGC.StartPlaytimeTracking(PublishedFileIds, (uint)PublishedFileIds.Length);
OnStartPlaytimeTrackingResultCallResult.Set(handle);
print("SteamUGC.StartPlaytimeTracking(" + PublishedFileIds + ", " + (uint)PublishedFileIds.Length + ") : " + handle);
}
if (GUILayout.Button("StopPlaytimeTracking(PublishedFileIds, (uint)PublishedFileIds.Length)"))
{
PublishedFileId_t[] PublishedFileIds = new PublishedFileId_t[] { TestConstants.Instance.k_PublishedFileId_Champions };
SteamAPICall_t handle = SteamUGC.StopPlaytimeTracking(PublishedFileIds, (uint)PublishedFileIds.Length);
OnStopPlaytimeTrackingResultCallResult.Set(handle);
print("SteamUGC.StopPlaytimeTracking(" + PublishedFileIds + ", " + (uint)PublishedFileIds.Length + ") : " + handle);
}
if (GUILayout.Button("StopPlaytimeTrackingForAllItems()"))
{
SteamAPICall_t handle = SteamUGC.StopPlaytimeTrackingForAllItems();
OnStopPlaytimeTrackingResultCallResult.Set(handle);
print("SteamUGC.StopPlaytimeTrackingForAllItems() : " + handle);
}
if (GUILayout.Button("AddDependency(m_PublishedFileId, TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.AddDependency(m_PublishedFileId, TestConstants.Instance.k_PublishedFileId_Champions);
OnAddUGCDependencyResultCallResult.Set(handle);
print("SteamUGC.AddDependency(" + m_PublishedFileId + ", " + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
if (GUILayout.Button("RemoveDependency(m_PublishedFileId, TestConstants.Instance.k_PublishedFileId_Champions)"))
{
SteamAPICall_t handle = SteamUGC.RemoveDependency(m_PublishedFileId, TestConstants.Instance.k_PublishedFileId_Champions);
OnRemoveUGCDependencyResultCallResult.Set(handle);
print("SteamUGC.RemoveDependency(" + m_PublishedFileId + ", " + TestConstants.Instance.k_PublishedFileId_Champions + ") : " + handle);
}
if (GUILayout.Button("AddAppDependency(m_PublishedFileId, SteamUtils.GetAppID())"))
{
SteamAPICall_t handle = SteamUGC.AddAppDependency(m_PublishedFileId, SteamUtils.GetAppID());
OnAddAppDependencyResultCallResult.Set(handle);
print("SteamUGC.AddAppDependency(" + m_PublishedFileId + ", " + SteamUtils.GetAppID() + ") : " + handle);
}
if (GUILayout.Button("RemoveAppDependency(m_PublishedFileId, SteamUtils.GetAppID())"))
{
SteamAPICall_t handle = SteamUGC.RemoveAppDependency(m_PublishedFileId, SteamUtils.GetAppID());
OnRemoveAppDependencyResultCallResult.Set(handle);
print("SteamUGC.RemoveAppDependency(" + m_PublishedFileId + ", " + SteamUtils.GetAppID() + ") : " + handle);
}
if (GUILayout.Button("GetAppDependencies(m_PublishedFileId)"))
{
SteamAPICall_t handle = SteamUGC.GetAppDependencies(m_PublishedFileId);
OnGetAppDependenciesResultCallResult.Set(handle);
print("SteamUGC.GetAppDependencies(" + m_PublishedFileId + ") : " + handle);
}
if (GUILayout.Button("DeleteItem(m_PublishedFileId)"))
{
SteamAPICall_t handle = SteamUGC.DeleteItem(m_PublishedFileId);
OnDeleteItemResultCallResult.Set(handle);
print("SteamUGC.DeleteItem(" + m_PublishedFileId + ") : " + handle);
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
public static SteamAPICall_t UnsubscribePublishedFile(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UnsubscribePublishedFile(unPublishedFileId);
}
public static void OpenWorkshopPage(PublishedFileId_t pfid)
{
SteamUtility.OpenUrl(SteamUtility.SteamWorkshopPageUrl(pfid));
}
public static extern bool ISteamGameServerUGC_DownloadItem(PublishedFileId_t nPublishedFileID, [MarshalAs(UnmanagedType.I1)] bool bHighPriority);
public static string SteamWorkshopPageUrl(PublishedFileId_t pfid)
{
return("steam://url/CommunityFilePage/" + pfid);
}
/// <summary>
/// <para> Steam Workshop Consumer API</para>
/// </summary>
public static SteamAPICall_t SetUserItemVote(PublishedFileId_t nPublishedFileID, bool bVoteUp) {
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamUGC_SetUserItemVote(nPublishedFileID, bVoteUp);
}
internal static void Notify_Subscribed(PublishedFileId_t pfid)
{
RebuildItemsList();
}
/// <summary>
/// <para> subscribe to this item, will be installed ASAP</para>
/// </summary>
public static SteamAPICall_t SubscribeItem(PublishedFileId_t nPublishedFileID) {
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamUGC_SubscribeItem(nPublishedFileID);
}
public static bool HasItem(PublishedFileId_t pfid)
{
return(WorkshopItems.GetItem(pfid) != null);
}
/// <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.ISteamGameServerUGC_StartItemUpdate(nConsumerAppId, nPublishedFileID);
}
internal static void Notify_Installed(PublishedFileId_t pfid)
{
WorkshopItems.RebuildItemsList();
}
public static SteamAPICall_t GetUserItemVote(PublishedFileId_t nPublishedFileID) {
InteropHelp.TestIfAvailableGameServer();
return (SteamAPICall_t)NativeMethods.ISteamGameServerUGC_GetUserItemVote(nPublishedFileID);
}
internal static void Notify_Unsubscribed(PublishedFileId_t pfid)
{
WorkshopItems.RebuildItemsList();
}
/// <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.ISteamGameServerUGC_UnsubscribeItem(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);
}
/// <summary>
/// <para> get EItemState flags about item on this client</para>
/// </summary>
public static uint GetItemState(PublishedFileId_t nPublishedFileID) {
InteropHelp.TestIfAvailableGameServer();
return NativeMethods.ISteamGameServerUGC_GetItemState(nPublishedFileID);
}
public static PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return (PublishedFileUpdateHandle_t)NativeMethods.ISteamRemoteStorage_CreatePublishedFileUpdateRequest(unPublishedFileId);
}
/// <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);
}
protected override void OnError(PublishedFileId_t id, EResult result)
{
TryLoadPreview(id, null);
}
public static bool GetQueryUGCChildren(UGCQueryHandle_t handle, uint index, PublishedFileId_t[] pvecPublishedFileID, uint cMaxEntries) {
InteropHelp.TestIfAvailableGameServer();
return NativeMethods.ISteamGameServerUGC_GetQueryUGCChildren(handle, index, pvecPublishedFileID, cMaxEntries);
}
public static extern uint ISteamGameServerUGC_GetItemState(PublishedFileId_t nPublishedFileID);
public static SteamAPICall_t GetPublishedFileDetails(PublishedFileId_t unPublishedFileId, uint unMaxSecondsOld)
{
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamRemoteStorage_GetPublishedFileDetails(unPublishedFileId, unMaxSecondsOld);
}
public static extern bool ISteamGameServerUGC_GetItemInstallInfo(PublishedFileId_t nPublishedFileID, out ulong punSizeOnDisk, IntPtr pchFolder, uint cchFolderSize, out uint punTimeStamp);
public static SteamAPICall_t SetUserPublishedFileAction(PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction)
{
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamRemoteStorage_SetUserPublishedFileAction(unPublishedFileId, eAction);
}
public static extern bool ISteamGameServerUGC_GetItemDownloadInfo(PublishedFileId_t nPublishedFileID, out ulong punBytesDownloaded, out ulong punBytesTotal);
public static SteamAPICall_t UpdateUserPublishedItemVote(PublishedFileId_t unPublishedFileId, bool bVoteUp)
{
InteropHelp.TestIfAvailableClient();
return (SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UpdateUserPublishedItemVote(unPublishedFileId, bVoteUp);
}
// event 回调
void UpdateUpLoadGrid(int index_0)
{
if (index_0 < 0)
{
index_0 = 0;
}
//this.m_index_0 = index_0;
mSelectedDetail = null;
mVCERightPanel.SetActive(false);
mMyWorkShopMgr.mGetIdStarIndex = Convert.ToUInt32(index_0);
if (!mMyWorkShopMgr.mIndexMap.ContainsKey(index_0))
{
for (int i = 0; i < mUploadGridCtrl.mUIItems.Count; i++)
{
mUploadGridCtrl.mUIItems[i].gameObject.SetActive(false);
}
this.GetPageGrid();
}
else
{
for (int i = 0; i < mUploadGridCtrl.mUIItems.Count; i++)
{
if (mMyWorkShopMgr.mIndexMap.ContainsKey(index_0 + i))
{
PublishedFileId_t p_id = mMyWorkShopMgr.mIndexMap[index_0 + i];
mUploadGridCtrl.mUIItems[i].gameObject.SetActive(true);
if (mMyWorkShopMgr.mItemsMap.ContainsKey(p_id))
{
SteamPreFileAndVoteDetail del = mMyWorkShopMgr.mItemsMap[p_id];
if (mMyWorkShopMgr.mDownMap.ContainsKey(p_id))
{
if (mMyWorkShopMgr.mDownMap[p_id] > 0)
{
mUploadGridCtrl.mUIItems[i].ActiveUpDown(true);
}
else
{
mUploadGridCtrl.mUIItems[i].ActiveUpDown(false);
}
}
else
{
mUploadGridCtrl.mUIItems[i].ActiveUpDown(false);
}
SetWorkShopGridItemInfo(del, mUploadGridCtrl.mUIItems[i]);
}
else
{
SetWorkShopGridItemInfo(null, mUploadGridCtrl.mUIItems[i]);
continue;
}
}
else
{
mUploadGridCtrl.mUIItems[i].gameObject.SetActive(false);
}
mUploadGridCtrl.mUIItems[i].SetSelected(false);
}
}
}
