void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
string msg = "[" + SubmitItemUpdateResult_t.k_iCallback + " - SubmitItemUpdateResult] - " + pCallback.m_eResult + " -- " + pCallback.m_bUserNeedsToAcceptWorkshopLegalAgreement + " -- " + pCallback.m_nPublishedFileId;
Debug.Log(msg);
EditorUtility.DisplayDialog("Info", msg, "OK");
}
private static void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
WorkshopTool.WorkshopToolForm.BeginInvoke((Action) delegate
{
UpdateItem_delegate(pCallback.m_eResult);
});
}
void OnSubmitItemResult(SubmitItemUpdateResult_t p, bool ioFailure)
{
bool ok = true;
this.lastResult = p.m_eResult;
this.isUpdatingItem = false;
if (ioFailure)
{
SetError("Submit Item failed, IO Failure!");
ok = false;
}
else if (p.m_eResult != EResult.k_EResultOK)
{
SetError("Submit Item failed, error: " + p.m_eResult.ToString());
ok = false;
}
else
{
this.needsToAcceptWorkshopLegalAgreement = p.m_bUserNeedsToAcceptWorkshopLegalAgreement;
Debug.Log("Item was successfully uploaded!");
}
if (OnSubmitItemDone != null)
{
OnSubmitItemDone(ok);
}
SignalStateChanged();
}
private static void OnItemSubmitted(SubmitItemUpdateResult_t result, bool IOFailure)
{
if (IOFailure || result.m_eResult != EResult.k_EResultOK)
{
Workshop.uploadingHook = null;
Dialog_WorkshopOperationInProgress.CloseAll();
Log.Error("Workshop: OnItemSubmitted failure. Result: " + result.m_eResult.GetLabel(), false);
Find.WindowStack.Add(new Dialog_MessageBox("WorkshopSubmissionFailed".Translate(new object[]
{
GenText.SplitCamelCase(result.m_eResult.GetLabel())
}), null, null, null, null, null, false, null, null));
}
else
{
SteamUtility.OpenWorkshopPage(Workshop.uploadingHook.PublishedFileId);
Messages.Message("WorkshopUploadSucceeded".Translate(new object[]
{
Workshop.uploadingHook.Name
}), MessageTypeDefOf.TaskCompletion, false);
if (Prefs.LogVerbose)
{
Log.Message("Workshop: Item submit result: " + result.m_eResult, false);
}
}
Workshop.curStage = WorkshopInteractStage.None;
Workshop.submitResult = null;
}
private void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t pResult, bool failed)
{
if (pResult.m_bUserNeedsToAcceptWorkshopLegalAgreement)
{
Debug.LogError("Player needs to agree to the user agreement.");
}
if (failed == false)
{
if (pResult.m_eResult != EResult.k_EResultOK)
{
Debug.LogError("Steam SubmitItemUpdate error " + pResult.m_eResult.ToString());
}
else
{
if (pResult.m_bUserNeedsToAcceptWorkshopLegalAgreement)
{
Debug.LogWarning("User needs to accept workshop legal agreement");
}
string itemPath = "steam://url/CommunityFilePage/" + steamworks_id.ToString();
SteamFriends.ActivateGameOverlayToWebPage(itemPath);
}
}
else
{
Debug.LogError("Error on Steam Workshop item update");
}
waiting_for_create = false;
uploading = false;
ignore = prev_ignore;
UpdateMetadata();
}
/// <summary>
/// 提交item回调
/// </summary>
/// <param name="pCallback"></param>
/// <param name="bIOFailure"></param>
private void OnSubmitItemCallBack(SubmitItemUpdateResult_t itemResult, bool bIOFailure)
{
mIsComplete = true;
if (bIOFailure || itemResult.m_eResult != EResult.k_EResultOK)
{
SteamUGC.DeleteItem(itemResult.m_nPublishedFileId);
mContent.StopCoroutine(ProgressCoroutine(mUpdateHandle, itemResult.m_nPublishedFileId));
if (this.mUpdateCallBack != null)
{
if (itemResult.m_eResult == EResult.k_EResultLimitExceeded)
{
this.mUpdateCallBack.UpdateFail(SteamWorkshopUpdateFailEnum.PREVIEW_BIG);
}
else
{
this.mUpdateCallBack.UpdateFail(SteamWorkshopUpdateFailEnum.REQUEST_FAIL);
}
}
return;
}
if (this.mUpdateCallBack != null)
{
this.mUpdateCallBack.UpdateSuccess();
}
}
private void OnSubmitItemUpdate(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
callbacksListener.Stop();
this.bIsUploading = false;
this.btnSendContentButton.BackgroundImage = Progressbar(0.0f);
if (bIOFailure || pCallback.m_eResult != EResult.k_EResultOK)
{
Debug.WriteLine("SubmitItemUpdate failed, " + pCallback.m_eResult.ToString().Substring(9));
MessageBox.Show(AddSpacesToSentence(pCallback.m_eResult.ToString().Substring(9)), "Submitting Workshop Item Update failed");
if (this.WorkshopItemInfo.ItemID == 0)
{
this.btnSendContentButton.Text = "Upload Content";
}
else
{
this.btnSendContentButton.Text = "Update Content";
}
return;
}
Debug.WriteLine("SubmitItemUpdate finished");
Process.Start("https://steamcommunity.com/sharedfiles/filedetails/?id=" + pCallback.m_nPublishedFileId);
this.btnSendContentButton.Text = "Update Content";
}
private void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t callback, bool ioFailure)
{
if (ioFailure)
{
Failed = true;
Status = "Publishing failed.";
return;
}
switch (callback.m_eResult)
{
case EResult.k_EResultOK:
Status = "Done.";
steamSection.PublishedFileId = callback.m_nPublishedFileId.m_PublishedFileId;
break;
case EResult.k_EResultFileNotFound:
Failed = true;
Status = "UGC not found.";
break;
case EResult.k_EResultLimitExceeded:
Failed = true;
Status = "Size limit exceeded.";
break;
default:
Failed = true;
Status = string.Format("Publishing failed. ({0})", callback.m_eResult);
break;
}
}
private unsafe static void OnSubmitItemUpdate(SubmitItemUpdateResult_t result, bool ioFailure)
{
if (!_initialized)
{
return;
}
_pendingItem?.ApplyResult((SteamResult)result.m_eResult, result.m_bUserNeedsToAcceptWorkshopLegalAgreement, _pendingItem.id);
}
private static void OnItemSubmitted(SubmitItemUpdateResult_t result, bool failure)
{
Console.WriteLine("submit callback called:" + result.m_eResult + " :: " + result.m_nPublishedFileId);
// store result and let the main thread continue
submitResult = result;
ready.Set();
}
private void OnItemUpdateResult(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
if (pCallback.m_eResult == EResult.k_EResultOK)
{
Debug.Log("The item is now uploaded with a thumbnail");
}
else
{
Debug.Log("The item is now uploaded with out a thumbnail");
}
}
private void HandleItemUpdated(SubmitItemUpdateResult_t param, bool bIOFailure)
{
if (bIOFailure)
{
UpdateFailed.Invoke(param);
}
else
{
Updated.Invoke(param);
}
}
private void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t param, bool bIOFailure)
{
if (!bIOFailure && param.m_eResult != 0)
{
submitItemCallBack(true);
}
else
{
Debug.LogError("Failed to submit workshop item!");
submitItemCallBack(false);
}
}
private static void OnSubmitItem(SubmitItemUpdateResult_t param, bool bIOFailure)
{
if (param.m_bUserNeedsToAcceptWorkshopLegalAgreement || bIOFailure || (param.m_eResult != EResult.k_EResultOK))
{
RetrievePublishedItems();
utils.ShowWarningDialog("Unable to submit item!", null, true);
return;
}
factory_list_init._mainFormAccessor._addonList.StopUploading();
utils.ShowWarningDialog("Submitted item successfully!", null, true);
}
// SteamAPICall_t
public CallbackHandle SubmitItemUpdate(UGCUpdateHandle_t handle /*UGCUpdateHandle_t*/, string pchChangeNote /*const char **/, Action <SubmitItemUpdateResult_t, bool> CallbackFunction = null /*Action<SubmitItemUpdateResult_t, bool>*/)
{
SteamAPICall_t callback = 0;
callback = platform.ISteamUGC_SubmitItemUpdate(handle.Value, pchChangeNote);
if (CallbackFunction == null)
{
return(null);
}
return(SubmitItemUpdateResult_t.CallResult(steamworks, callback, CallbackFunction));
}
public void OnSubmitItemUpdateResultFunc(SubmitItemUpdateResult_t result, bool ioFailure)
{
Debug.LogFormat("SteamUnity.SubmitItemUpdate: result: {0}, {1}", result.m_eResult, result.m_nPublishedFileId);
if (result.m_bUserNeedsToAcceptWorkshopLegalAgreement)
{
CheckLegal(result.m_nPublishedFileId);
}
working = result.m_nPublishedFileId;
busy = false;
}
private void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
if (!this.Uploading || this.uploadingMod == null || this.uploadCallback == null)
{
return;
}
bool flag = true;
string empty = string.Empty;
if (bIOFailure)
{
flag = false;
empty = "Error updating workshop item. Error: I/O failure";
}
else if (pCallback.m_eResult == EResult.k_EResultInsufficientPrivilege)
{
flag = false;
empty = "Error updating workshop item. Error: The user creating the item is currently banned in the community.";
}
else if (pCallback.m_eResult == EResult.k_EResultTimeout)
{
flag = false;
empty = "Error updating workshop item. Error: Timeout.";
}
else if (pCallback.m_eResult == EResult.k_EResultNotLoggedOn)
{
flag = false;
empty = "Error updating workshop item. Error: The user is not currently logged into Steam.";
}
else if (pCallback.m_eResult != EResult.k_EResultOK)
{
flag = false;
empty = string.Format("Error updating workshop item. Error value: {0}", pCallback.m_eResult.ToString());
}
if (flag)
{
SteamManager.logger.Info <string, ulong>("Updated mod '{0}' successfully. ID: {1}", this.uploadingMod.mod, this.uploadingMod.id);
this.Uploading = false;
this.uploadingMod = null;
this.uploadCallback(true, string.Empty);
this.uploadCallback = null;
this.uploadState = SteamManager.UploadState.None;
return;
}
SteamManager.logger.Error <string, ulong, string>("Error updating mod '{0}' (ID: {1}). Info: {1}", this.uploadingMod.mod, this.uploadingMod.id, empty);
this.Uploading = false;
this.uploadingMod = null;
this.uploadState = SteamManager.UploadState.None;
this.uploadCallback(false, empty);
this.uploadCallback = null;
}
void SubmittedItemCallback(SubmitItemUpdateResult_t args, bool failure)
{
Logger.Trace("[WORKSHOP] Got callback for updating item");
switch (args.m_eResult)
{
case EResult.k_EResultOK:
break;
case EResult.k_EResultFail:
MessageBox.Show("Something went wrong! We're not sure what, but something did. And it's probably Steam's fault :(", "Item Update Failed");
ResetUIState();
return;
case EResult.k_EResultInvalidParam:
MessageBox.Show("This shouldn't happen... but something didn't match up with the App IDs", "Item Update Failed");
ResetUIState();
return;
case EResult.k_EResultAccessDenied:
MessageBox.Show("You don't appear to have a license for VRUB... That's weird. Did you compile this from source per chance?", "Item Update Failed");
ResetUIState();
return;
case EResult.k_EResultFileNotFound:
MessageBox.Show("We couldn't access the folder and/or preview image. OR the File ID is not valid.", "Item Update Failed");
ResetUIState();
return;
case EResult.k_EResultLockingFailed:
MessageBox.Show("Failed to acquire UGC Lock", "Item Update Failed");
ResetUIState();
return;
case EResult.k_EResultLimitExceeded:
MessageBox.Show("The preview image is too large, it must be less than 1 Megabyte. Or... your Steam Cloud doesn't have enough space left?", "Item Update Failed");
ResetUIState();
return;
}
if (args.m_bUserNeedsToAcceptWorkshopLegalAgreement)
{
System.Diagnostics.Process.Start("http://steamcommunity.com/sharedfiles/workshoplegalagreement");
}
System.Diagnostics.Process.Start("https://steamcommunity.com/sharedfiles/filedetails/" + _selectedAddon.FileId);
ResetUIState();
MessageBox.Show("Done! The item has been updated.", "Item Updated!");
}
protected void OnSubmitItemUpdate(SubmitItemUpdateResult_t result, bool failed)
{
if (result.m_eResult == EResult.k_EResultOK)
{
Debug.LogFormat("OnSubmitItemUpdate complete: {0}", result.m_eResult);
}
else
{
Debug.LogErrorFormat("OnSubmitItemUpdate complete: {0}", result.m_eResult);
}
ugcUpdateHandle = UGCUpdateHandle_t.Invalid;
ugcUpdateStatus = string.Format("Upload Status: {0} ({1})", result.m_eResult, System.DateTime.Now.ToShortTimeString());
Repaint();
}
private static void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t res, bool bIOFailure)
{
m_SubmitItemUpdateResult = null;
if (res.m_bUserNeedsToAcceptWorkshopLegalAgreement || res.m_eResult != EResult.k_EResultOK)
{
uploadCallback(meta, res.m_bUserNeedsToAcceptWorkshopLegalAgreement, res.m_eResult);
uploadCallback = null;
}
else
{
ShowWorkshopItem(meta.workshopId);
uploadCallback(meta, arg2: false, EResult.k_EResultOK);
uploadCallback = null;
}
}
private static void OnItemSubmitted(SubmitItemUpdateResult_t param, bool bIOFailure)
{
if (bIOFailure)
{
Console.WriteLine("Error: I/O Failure! :(");
return;
}
switch (param.m_eResult)
{
case EResult.k_EResultOK:
Console.WriteLine("SUCCESS! Item submitted! :D :D :D");
ugcUpdateHandle = UGCUpdateHandle_t.Invalid;
break;
}
}
private void OnItemSubmitted(SubmitItemUpdateResult_t callback, bool ioFailure)
{
if (ioFailure)
{
statusText.text = "Error: I/O Failure! :(";
return;
}
switch (callback.m_eResult)
{
case EResult.k_EResultOK:
statusText.text = "SUCCESS! Item submitted! :D :D :D";
currentHandle = UGCUpdateHandle_t.Invalid;
break;
}
}
private void SubmitItemCallResult(SubmitItemUpdateResult_t res, bool ioFailure)
{
runMT runMTCB = () =>
{
if (res.m_eResult == EResult.k_EResultOK)
{
MessageBox.Show("Successfully sent to Steam");
}
else
{
MessageBox.Show("Failed upload to Steam");
}
};
pending = runMTCB;
}
private void OnItemSubmitted(SubmitItemUpdateResult_t callback, bool ioFailure)
{
if (ioFailure)
{
statusText.text = "Error: I/O Failure! :(";
return;
}
if (callback.m_bUserNeedsToAcceptWorkshopLegalAgreement)
{
statusText.text = "You need to accept the Steam Workshop legal agreement for this game before you can upload items!";
return;
}
currentHandle = UGCUpdateHandle_t.Invalid;
switch (callback.m_eResult)
{
case EResult.k_EResultOK:
statusText.text = "SUCCESS! Item submitted! :D :D :D";
break;
case EResult.k_EResultFail:
statusText.text = "Failed, dunno why :(";
break;
case EResult.k_EResultInvalidParam:
statusText.text = "Either the provided app ID is invalid or doesn't match the consumer app ID of the item or, you have not enabled ISteamUGC for the provided app ID on the Steam Workshop Configuration App Admin page. The preview file is smaller than 16 bytes.";
break;
case EResult.k_EResultAccessDenied:
statusText.text = "ERROR: The user doesn't own a license for the provided app ID.";
break;
case EResult.k_EResultFileNotFound:
statusText.text = "Failed to get the workshop info for the item or failed to read the preview file.";
break;
case EResult.k_EResultLockingFailed:
statusText.text = "Failed to aquire UGC Lock.";
break;
case EResult.k_EResultLimitExceeded:
statusText.text = "The preview image is too large, it must be less than 1 Megabyte; or there is not enough space available on the users Steam Cloud.";
break;
}
}
static void SubmitItemTask(SteamAPICall_t handle, UGCUpdateHandle_t updateHandle)
{
while (!IsCompleted(handle))
{
if (updateHandle != UGCUpdateHandle_t.Invalid)
{
System.Threading.Thread.Sleep(1);
EItemUpdateStatus status = SteamUGC.GetItemUpdateProgress(updateHandle, out ulong punBytesProcessed, out ulong punBytesTotal);
float progress = (float)punBytesProcessed / (float)punBytesTotal * 100.0f;
if (status == EItemUpdateStatus.k_EItemUpdateStatusPreparingConfig)
{
ClearLine("Processing configuration data...");
}
else if (status == EItemUpdateStatus.k_EItemUpdateStatusPreparingContent && !Single.IsNaN(progress))
{
ClearLine("Processing files: " + progress.ToString("F2") + " % ");
}
else if (status == EItemUpdateStatus.k_EItemUpdateStatusUploadingContent && !Single.IsNaN(progress))
{
ClearLine("Upload files: " + progress.ToString("F2") + " % ");
}
else if (status == EItemUpdateStatus.k_EItemUpdateStatusUploadingPreviewFile)
{
ClearLine("Upload preview file...");
}
else if (status == EItemUpdateStatus.k_EItemUpdateStatusCommittingChanges)
{
ClearLine("Commiting changes...");
}
}
}
SubmitItemUpdateResult_t callback = AllocCallback <SubmitItemUpdateResult_t>(handle, out IntPtr pCallback, SubmitItemUpdateResult_t.k_iCallback);
if (callback.m_eResult == EResult.k_EResultOK)
{
Console.WriteLine("\nSuccessfully submitted item to Steam ! Press any key to continue...");
}
else
{
Console.WriteLine("\nCouldn't submit the item to Steam (" + callback.m_eResult.ToString() + ") ! Press any key to continue...");
}
ReleaseCallback(pCallback);
}
private void onSubmitItemUpdateResult(SubmitItemUpdateResult_t callback, bool io)
{
if (callback.m_bUserNeedsToAcceptWorkshopLegalAgreement || callback.m_eResult != 1 || io)
{
if (callback.m_bUserNeedsToAcceptWorkshopLegalAgreement)
{
Assets.errors.Add("Failed to submit update because you need to accept the workshop legal agreement.");
}
if (callback.m_eResult != 1)
{
Assets.errors.Add("Failed to submit update because: " + callback.m_eResult);
}
if (io)
{
Assets.errors.Add("Failed to submit update because of an IO issue.");
}
MenuUI.alert(Provider.localization.format("UGC_Fail"));
return;
}
MenuUI.alert(Provider.localization.format("UGC_Success"));
Provider.provider.workshopService.open(this.publishedFileID);
this.refreshPublished();
}
private static void OnItemSubmitted(SubmitItemUpdateResult_t param, bool bIOFailure)
{
if (bIOFailure)
{
SetStatus("Error: I/O Failure!");
return;
}
switch (param.m_eResult)
{
case EResult.k_EResultOK:
SetStatus("SUCCESS! Item submitted!");
ugcUpdateHandle = UGCUpdateHandle_t.Invalid;
success = true;
break;
default:
SetStatus("Item upload failed! Result code: " + param.m_eResult.ToString());
GUI.MessageBox.Show("Item upload failed! Result code: " + param.m_eResult.ToString());
ugcUpdateHandle = UGCUpdateHandle_t.Invalid;
success = false;
break;
}
}
void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
Console.WriteLine("[" + SubmitItemUpdateResult_t.k_iCallback + " - SubmitItemUpdateResult_t] - " + pCallback.m_eResult + " -- " + pCallback.m_bUserNeedsToAcceptWorkshopLegalAgreement);
}
private static void OnItemSubmitted(SubmitItemUpdateResult_t result, bool failure)
{
// store result and let the main thread continue
submitResult = result;
ready.Set();
}
void OnSubmitItemUpdateResult(SubmitItemUpdateResult_t pCallback, bool bIOFailure)
{
Debug.Log("[" + SubmitItemUpdateResult_t.k_iCallback + " - SubmitItemUpdateResult] - " + pCallback.m_eResult + " -- " + pCallback.m_bUserNeedsToAcceptWorkshopLegalAgreement + " -- " + pCallback.m_nPublishedFileId);
}
