protected virtual void Dispose(bool flag)
{
Destroy();
_completedCallResult?.Cancel();
(_completedCallResult as IDisposable)?.Dispose();
_completedCallResult = null;
}
public void Vote(bool uprated, bool downrated, bool skip)
{
if (!skip)
{
if (m_SetUserItemVoteResult != null)
{
m_SetUserItemVoteResult.Cancel();
}
m_SetUserItemVoteResult = CallResult <SetUserItemVoteResult_t> .Create(OnSetUserItemVoteResult);
SteamAPICall_t hAPICall = SteamUGC.SetUserItemVote(new PublishedFileId_t(mCurrentWorkshopLevel), uprated);
m_SetUserItemVoteResult.Set(hAPICall);
}
}
//Creates new item and returns ID in the callback
//Always check if the returned id is valid to check if the call was successful (valid ids are not 0)
public bool CreateNewItem(CreateItemCallBack callback)
{
bool result = false;
if (SteamManager.Initialized)
{
SteamAPICall_t apiCall = SteamUGC.CreateItem(SteamUtils.GetAppID(), EWorkshopFileType.k_EWorkshopFileTypeCommunity);
if (createItemResult.IsActive())
{
createItemResult.Cancel();
createItemResult.Dispose();
}
createItemResult.Set(apiCall);
createItemCallBack = callback;
result = true;
}
return(result);
}
public void QueryRatingStatus(ulong item, bool reset = true)
{
if (reset)
{
mCurrentWorkshopLevelRated = true;
mCurrentWorkshopLevel = item;
mLevelPlayedTime = Time.unscaledTime;
}
if (m_GetUserItemVoteResult != null)
{
m_GetUserItemVoteResult.Cancel();
}
m_GetUserItemVoteResult = CallResult <GetUserItemVoteResult_t> .Create(OnGetUserItemVoteResult);
SteamAPICall_t userItemVote = SteamUGC.GetUserItemVote(new PublishedFileId_t(item));
m_GetUserItemVoteResult.Set(userItemVote);
}
//Used to update a workshop item, the callback function is called after the update is completed. The return value will indicate success or failure.
public bool UpdateItem(PublishedFileId_t fileId, string title, string description, string contentPath, string previewImagePath, string changeNote, SubmitItemCallBack submitItemCallBack)
{
bool result = false;
if (SteamManager.Initialized && fileId.m_PublishedFileId != 0)
{
updateHandle = SteamUGC.StartItemUpdate(SteamUtils.GetAppID(), fileId);
result = true;
result = result && SteamUGC.SetItemTitle(updateHandle, title);
if (result)
{
result = result && SteamUGC.SetItemDescription(updateHandle, description);
}
if (result)
{
result = result && SteamUGC.SetItemContent(updateHandle, contentPath);
}
if (result)
{
result = result && SteamUGC.SetItemPreview(updateHandle, previewImagePath);
}
if (result)
{
result = result && SteamUGC.SetItemVisibility(updateHandle, ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic);
}
if (result)
{
SteamAPICall_t apiCall = SteamUGC.SubmitItemUpdate(updateHandle, changeNote);
if (submitItemResult.IsActive())
{
submitItemResult.Cancel();
submitItemResult.Dispose();
}
submitItemResult.Set(apiCall);
this.submitItemCallBack = submitItemCallBack;
}
}
return(result);
}
public void GetLevel(ulong levelId, WorkshopItemSource levelType, Action <WorkshopLevelMetadata> onRead)
{
if (OnSteamUGCQueryCompletedCallResult != null)
{
OnSteamUGCQueryCompletedCallResult.Cancel();
OnSteamUGCQueryCompletedCallResult = null;
}
if (OnUGCDownloadCallResult != null)
{
OnUGCDownloadCallResult.Cancel();
OnUGCDownloadCallResult = null;
}
switch (levelType)
{
case WorkshopItemSource.BuiltIn:
onRead(GetItem("builtin:" + levelId.ToString()));
return;
case WorkshopItemSource.EditorPick:
onRead(GetItem("editorpick:" + levelId.ToString()));
return;
}
WorkshopLevelMetadata item = GetItem("ws:" + levelId.ToString() + "/");
if (item != null)
{
onRead(item);
return;
}
this.onRead = onRead;
UGCQueryHandle_t handle = SteamUGC.CreateQueryUGCDetailsRequest(new PublishedFileId_t[1]
{
new PublishedFileId_t(levelId)
}, 1u);
OnSteamUGCQueryCompletedCallResult = CallResult <SteamUGCQueryCompleted_t> .Create(OnSteamUGCQueryCompleted);
SteamAPICall_t hAPICall = SteamUGC.SendQueryUGCRequest(handle);
OnSteamUGCQueryCompletedCallResult.Set(hAPICall);
}
public static void UploadMonitor()
{
if (!NetTransportSteam.sSteamServersConnected)
{
bool flag = false;
if (m_CreateItemResult != null)
{
m_CreateItemResult.Cancel();
m_CreateItemResult = null;
flag = true;
}
if (m_SubmitItemUpdateResult != null)
{
m_SubmitItemUpdateResult.Cancel();
m_SubmitItemUpdateResult = null;
flag = true;
}
if (flag && uploadCallback != null)
{
uploadCallback(meta, arg2: false, EResult.k_EResultCancelled);
uploadCallback = null;
}
}
}
internal static void Cancel()
{
_callback.Cancel();
}
