private void OnUGCDetailsComplete(SteamUGCQueryCompleted_t callback, bool ioError)
{
var result = callback.m_eResult;
var handle = callback.m_handle;
PublishedFileId_t id;
if (!ioError && result == EResult.k_EResultOK)
{
var allResults = ListPool <SteamUGCDetails_t, SteamUGCServiceFixed> .Allocate();
for (uint i = 0U; i < callback.m_unNumResultsReturned; i++)
{
if (SteamUGC.GetQueryUGCResult(handle, i, out SteamUGCDetails_t details) &&
allMods.TryGetValue(id = details.m_nPublishedFileId,
out ModInfo mod))
{
#if false
PUtil.LogDebug("Updated mod {0:D} ({1})".F(id.m_PublishedFileId,
details.m_rgchTitle));
#endif
mod.Populate(details);
// Queue up the preview image
download.Queue(id);
preview.Queue(id);
allResults.Add(details);
}
}
ModUpdateDetails.OnInstalledUpdate(allResults);
allResults.Recycle();
}
SteamUGC.ReleaseQueryUGCRequest(handle);
onQueryComplete?.Dispose();
onQueryComplete = null;
}
private void OnUGCSteamUGCQueryCompleted(SteamUGCQueryCompleted_t pResult, bool failed)
{
Debug.Log("OnUGCSteamUGCQueryCompleted() " + pResult.m_eResult);
if (failed == false)
{
for (uint i = 0; i < pResult.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t details;
SteamUGC.GetQueryUGCResult(pResult.m_handle, i, out details);
// Only load items when explicitly requested by something
if (loadItems)
{
bool owner = false;
if (details.m_ulSteamIDOwner == SteamUser.GetSteamID().m_SteamID)
{
owner = true;
}
uint itemState = SteamUGC.GetItemState(details.m_nPublishedFileId);
if ((itemState & (uint)EItemState.k_EItemStateInstalled) != 0)
{
LoadModIntoGame(details.m_nPublishedFileId, owner);
}
}
}
}
else
{
Debug.LogError("OnUGCSteamUGCQueryCompleted() error " + pResult.m_eResult);
}
loadItems = false;
SteamUGC.ReleaseQueryUGCRequest(pResult.m_handle);
}
public void CallBackSendQuery(SteamUGCQueryCompleted_t pCallback, bool bIOFailure)
{
try
{
if (pCallback.m_eResult == EResult.k_EResultOK)
{
uint count = pCallback.m_unNumResultsReturned;
uint index = _StartIndex % 50;
if (count - index > _Count)
{
count = _Count;
}
SteamUGCDetails_t detail = new SteamUGCDetails_t();
for (uint i = index; i < count + index; i++)
{
SteamUGC.GetQueryUGCResult(_UGCQueryHandle, i, out detail);
_FileIDLsit.Add(detail.m_nPublishedFileId);
Debug.LogWarning("CallBackSendQuery PublishedFileId_t " + i.ToString() + " = " + detail.m_nPublishedFileId);
}
Finish(_FileIDLsit, (int)pCallback.m_unTotalMatchingResults, _StartIndex, true);
}
else
{
Finish(null, 0, _StartIndex, false);
}
}
catch (Exception)
{
Finish(null, 0, _StartIndex, false);
}
}
static void GetModsInfoFromUserTask(SteamAPICall_t handle)
{
while (!IsCompleted(handle))
{
}
List <string> _ModsReceivedResult = new List <string>();
SteamUGCQueryCompleted_t result = AllocCallback <SteamUGCQueryCompleted_t>(handle, out IntPtr pCallback, SteamUGCQueryCompleted_t.k_iCallback);
Console.WriteLine("*************************************");
_ModsReceivedResult.Add("User mods: " + result.m_unNumResultsReturned.ToString());
for (uint i = 0; i < result.m_unNumResultsReturned; i++)
{
if (SteamUGC.GetQueryUGCResult(result.m_handle, i, out var details))
{
DateTime FromUnixTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(details.m_rtimeUpdated);
_ModsReceivedResult.Add("- " + details.m_rgchTitle.ToString() + ", " + details.m_rgchDescription.ToString() + ", " + FromUnixTime.ToString() + ", " + details.m_nPublishedFileId.ToString());
}
}
for (int i = 0; i < _ModsReceivedResult.Count; i++)
{
Console.WriteLine(_ModsReceivedResult[i]);
}
Console.WriteLine("*************************************");
ReleaseCallback(pCallback);
}
private static void OnUGCQueryComplete(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
factory_list_init._mainFormAccessor._addonList.RemoveItems();
pszImagePreviewURLs.Clear();
if (bIOFailure || (param.m_eResult != EResult.k_EResultOK))
{
utils.ShowWarningDialog("Unable to fetch workshop items!", null, true);
SteamUGC.ReleaseQueryUGCRequest(_ugcHandle);
return;
}
for (uint i = 0; i < param.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t pDetails;
if (SteamUGC.GetQueryUGCResult(param.m_handle, i, out pDetails))
{
string url = null;
if (SteamUGC.GetQueryUGCPreviewURL(param.m_handle, i, out url, 1024))
{
AddImagePreviewItemToQueue(url, pDetails.m_nPublishedFileId.m_PublishedFileId.ToString());
}
string tags = pDetails.m_rgchTags + ",";
factory_list_init._mainFormAccessor._addonList.AddItem(pDetails.m_rgchTitle, pDetails.m_rgchDescription, tags, (int)pDetails.m_eVisibility, pDetails.m_nPublishedFileId, utils.GetDateFromTimeCreated((ulong)pDetails.m_rtimeUpdated));
}
}
SteamUGC.ReleaseQueryUGCRequest(_ugcHandle);
StartDownloadingPreviewImages();
}
private void OnUGCDetailsComplete(SteamUGCQueryCompleted_t callback, bool ioError)
{
var result = callback.m_eResult;
var handle = callback.m_handle;
PublishedFileId_t id;
if (!ioError && result == EResult.k_EResultOK)
{
for (uint i = 0U; i < callback.m_unNumResultsReturned; i++)
{
if (SteamUGC.GetQueryUGCResult(handle, i, out SteamUGCDetails_t details) &&
allMods.TryGetValue(id = details.m_nPublishedFileId,
out ModInfo mod))
{
#if false
PUtil.LogDebug("Updated mod {0:D} ({1})".F(id.m_PublishedFileId,
details.m_rgchTitle));
#endif
mod.Populate(details);
// Queue up a download and a preview
download.Queue(id);
preview.Queue(id);
}
}
}
SteamUGC.ReleaseQueryUGCRequest(handle);
onQueryComplete?.Dispose();
onQueryComplete = null;
}
private void OnQueryCompleted(SteamUGCQueryCompleted_t p_callback, bool p_bIOFailure)
{
waitingOnQuery = false;
items.Clear();
if (p_bIOFailure || p_callback.m_eResult != EResult.k_EResultOK)
{
Util.LogError($"Failed to query featured workshop items. Result code: {p_callback.m_eResult}");
return;
}
for (uint i = 0; i < p_callback.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t itemDetails;
if (SteamUGC.GetQueryUGCResult(p_callback.m_handle, i, out itemDetails))
{
if (itemDetails.m_eResult != Steamworks.EResult.k_EResultOK)
{
Util.LogError($"Something is wrong with featured file ID {FeaturedPublishedFileIds[i]} - ignoring.");
}
else
{
WorkshopItem item = SteamWorkshopMain.Instance.RegisterQueryResultItem(p_callback.m_handle, i, itemDetails);
items.Add(item);
// Util.Log($"got WorkshopItem for featured ID {item.SteamNative.m_nPublishedFileId}, name is {item.Name} {item.PreviewImageURL}. sub'd? {item.IsSubscribed}");
}
}
else
{
Util.LogError($"Could not query details of featured file ID {FeaturedPublishedFileIds[i]} - ignoring.");
}
}
}
private static void OnQueryCompleted(SteamUGCQueryCompleted_t p_callback, bool p_bIOFailure, WorkShopItemHandler handleItem, ulong requestedFileId)
{
if (p_bIOFailure || p_callback.m_eResult != EResult.k_EResultOK)
{
Util.LogError($"Failed to query workshop item {requestedFileId}. Result code: {p_callback.m_eResult}");
handleItem(Util.Maybe <WorkshopItem> .CreateEmpty());
return;
}
// There should just be 1..but doesn't hurt.
for (uint i = 0; i < p_callback.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t itemDetails;
if (SteamUGC.GetQueryUGCResult(p_callback.m_handle, i, out itemDetails))
{
if (itemDetails.m_eResult != Steamworks.EResult.k_EResultOK)
{
Util.LogError($"Something is wrong with workshop item {requestedFileId} - returning empty. Result code: {itemDetails.m_eResult}");
handleItem(Util.Maybe <WorkshopItem> .CreateEmpty());
}
else
{
WorkshopItem item = SteamWorkshopMain.Instance.RegisterQueryResultItem(p_callback.m_handle, i, itemDetails);
handleItem(Util.Maybe <WorkshopItem> .CreateWith(item));
}
}
else
{
Util.LogError($"Could not query details of workshop item {requestedFileId} - returning empty. Result code: {itemDetails.m_eResult}");
handleItem(Util.Maybe <WorkshopItem> .CreateEmpty());
}
}
}
private static void OnVisibilityQueryCompleted(SteamUGCQueryCompleted_t p_callback, bool p_bIOFailure, System.Action <Util.Maybe <bool> > handleResult, ulong requestedFileId)
{
if (p_bIOFailure || p_callback.m_eResult != EResult.k_EResultOK)
{
Util.LogError($"Failed to query workshop item {requestedFileId}. Result code: {p_callback.m_eResult}");
handleResult(Util.Maybe <bool> .CreateEmpty());
return;
}
// There should just be 1..but doesn't hurt.
for (uint i = 0; i < p_callback.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t itemDetails;
if (SteamUGC.GetQueryUGCResult(p_callback.m_handle, i, out itemDetails))
{
if (itemDetails.m_eResult != Steamworks.EResult.k_EResultOK)
{
Util.LogError($"Something is wrong with workshop item {requestedFileId} - returning empty. Result code: {itemDetails.m_eResult}");
handleResult(Util.Maybe <bool> .CreateEmpty());
}
else
{
bool isPublicyVisible = itemDetails.m_eVisibility == Steamworks.ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic;
handleResult(Util.Maybe <bool> .CreateWith(isPublicyVisible));
}
}
else
{
Util.LogError($"Could not query details of workshop item {requestedFileId} - returning empty. Result code: {itemDetails.m_eResult}");
handleResult(Util.Maybe <bool> .CreateEmpty());
}
}
}
private void OnSteamUGCQueryCompleted(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
if (param.m_eResult == EResult.k_EResultOK)
{
refreshResults = param.m_handle;
}
OnSteamUGCQueryCompletedCallResult = null;
}
void OnSteamUGCQueryCompleted(SteamUGCQueryCompleted_t pCallback, bool bIOFailure)
{
Console.WriteLine("[" + SteamUGCQueryCompleted_t.k_iCallback + " - SteamUGCQueryCompleted_t] - " + pCallback.m_handle + " -- " + pCallback.m_eResult + " -- " + pCallback.m_unNumResultsReturned + " -- " + pCallback.m_unTotalMatchingResults + " -- " + pCallback.m_bCachedData);
SteamUGCDetails_t pDetails;
SteamUGC.GetQueryUGCResult(pCallback.m_handle, 17, out pDetails);
Console.WriteLine("pDetails.m_pchFileName (" + pDetails.m_nPublishedFileId + "): " + pDetails.m_rgchTitle + " -- " + pDetails.m_rgchDescription);
//Console.WriteLine("URL: " +pDetails.m_rgchURL);
}
void OnSteamUGCQueryCompleted(SteamUGCQueryCompleted_t pCallback, bool bIOFailure)
{
Debug.Log("[" + SteamUGCQueryCompleted_t.k_iCallback + " - SteamUGCQueryCompleted] - " + pCallback.m_handle + " -- " + pCallback.m_eResult + " -- " + pCallback.m_unNumResultsReturned + " -- " + pCallback.m_unTotalMatchingResults + " -- " + pCallback.m_bCachedData);
for (uint i = 0; i < pCallback.m_unNumResultsReturned; i++)
{
bool ret = SteamUGC.GetQueryUGCResult(pCallback.m_handle, i, out SteamUGCDetails_t details);
_modList.Add(details);
}
}
private void OnQueryResultReceived(SteamUGCQueryCompleted_t result, bool ioFail)
{
QueryResult = new QueryPublishedModResult()
{
ResultCount = result.m_unNumResultsReturned,
TotalMatchingResultCount = result.m_unTotalMatchingResults
};
if (ioFail)
{
ExitCode = Steam.ExitCodes.SteamIOError;
QueryResult.IsIOFailure = true;
QueryResult.FailureReason = result.m_eResult;
AllAsyncOperationsFinished = true;
return;
}
if (result.m_eResult != EResult.k_EResultOK)
{
QueryResult.FailureReason = result.m_eResult;
AllAsyncOperationsFinished = true;
return;
}
QueryResult.ModData = new PublishedModData[result.m_unNumResultsReturned];
for (uint i = 0; i < result.m_unNumResultsReturned; i++)
{
SteamUGC.GetQueryUGCResult(result.m_handle, i, out SteamUGCDetails_t detail);
QueryResult.ModData[i] = new PublishedModData()
{
Description = detail.m_rgchDescription,
FileSize = detail.m_nFileSize,
PreviewFileSize = detail.m_nPreviewFileSize,
HFile = detail.m_hFile,
HPreviewFile = detail.m_hPreviewFile,
ID = detail.m_nPublishedFileId,
IsBanned = detail.m_bBanned,
IsTagsTruncated = detail.m_bTagsTruncated,
NumChildren = detail.m_unNumChildren,
Owner = new CSteamID(detail.m_ulSteamIDOwner),
Score = detail.m_flScore,
Tags = detail.m_rgchTags,
TimeAddedToUserList = detail.m_rtimeAddedToUserList,
TimeCreated = detail.m_rtimeCreated,
TimeUpdated = detail.m_rtimeUpdated,
Title = detail.m_rgchTitle,
Visibility = detail.m_eVisibility,
VotesDown = detail.m_unVotesDown,
VotesUp = detail.m_unVotesUp,
URL = detail.m_rgchURL
};
}
ExitCode = Steam.ExitCodes.NoError;
AllAsyncOperationsFinished = true;
}
private void QueryCompleted(SteamUGCQueryCompleted_t pCallback, bool bIOFailure)
{
Success = pCallback.m_eResult == EResult.k_EResultOK;
if (!Success)
{
Log.Warn("SendQueryUGCRequest result was " + pCallback.m_eResult);
}
Finished = true;
}
//Called when the Steam query returns asynchronously
private static void OnSendQueryUGCRequest(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
if (param.m_eResult == EResult.k_EResultOK)
{
UGCQueryHandle_t UGCHandle = param.m_handle;
SteamUGC.GetQueryUGCResult(UGCHandle, 0, out SteamUGCDetails_t itemDetails);
if (Settings.CurrentProfile.EnabledMods.Contains(itemDetails.m_rgchTitle))
{
modPackList.Add(itemDetails.m_pchFileName.Remove(0, 5));
}
}
}
private static void OnQueryCompleted(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
if (bIOFailure)
{
Console.WriteLine("Querying Workshop Failed.");
return;
}
else
{
IndexPage(param);
}
}
private static void OnUGCQueryCompleted(SteamUGCQueryCompleted_t pCallback, bool bIOFailure)
{
publishedWorkshopItems = new SteamUGCDetails_t[pCallback.m_unNumResultsReturned];
for (uint index = 0u; index < pCallback.m_unNumResultsReturned; index++)
{
SteamUGC.GetQueryUGCResult(pCallback.m_handle, index, out publishedWorkshopItems[index]);
}
SteamUGC.ReleaseQueryUGCRequest(pCallback.m_handle);
WorkshopTool.WorkshopToolForm.BeginInvoke((Action) delegate
{
PublishedItems_delegate(pCallback.m_eResult);
});
}
// SteamAPICall_t
public CallbackHandle SendQueryUGCRequest(UGCQueryHandle_t handle /*UGCQueryHandle_t*/, Action <SteamUGCQueryCompleted_t, bool> CallbackFunction = null /*Action<SteamUGCQueryCompleted_t, bool>*/)
{
SteamAPICall_t callback = 0;
callback = platform.ISteamUGC_SendQueryUGCRequest(handle.Value);
if (CallbackFunction == null)
{
return(null);
}
return(SteamUGCQueryCompleted_t.CallResult(steamworks, callback, CallbackFunction));
}
private static void OnSteamUGCQueryCompleted(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
if (param.m_eResult == EResult.k_EResultOK && SteamUGC.GetQueryUGCResult(param.m_handle, 0u, out SteamUGCDetails_t pDetails) && pDetails.m_eResult == EResult.k_EResultFileNotFound)
{
meta.workshopId = 0uL;
meta.Save(folder);
Upload();
}
else
{
PerformUpload();
}
}
private static void OnModDetailsReceived(SteamUGCQueryCompleted_t result, bool failure)
{
Debug.Log($"Received mod details: failure: {failure}, result: {result.m_eResult}, count: {result.m_unNumResultsReturned}");
for (uint i = 0; i < result.m_unNumResultsReturned; i++)
{
if (SteamUGC.GetQueryUGCResult(result.m_handle, i, out var details))
{
Debug.Log($" - {details.m_rgchTitle} ({details.m_ulSteamIDOwner}");
var author = new CSteamID(details.m_ulSteamIDOwner).GetAccountID();
_authorForMod.Add(details.m_nPublishedFileId, author);
_currentlyFetchingFiles.Remove(details.m_nPublishedFileId);
}
}
SteamUGC.ReleaseQueryUGCRequest(result.m_handle);
}
/// <summary>
/// 查询与自己关联的创意工坊物品
/// </summary>
/// <param name="itemResult"></param>
/// <param name="bIOFailure"></param>
private void QueryUserUGCCallBack(SteamUGCQueryCompleted_t itemResult, bool bIOFailure)
{
if (bIOFailure || itemResult.m_eResult != EResult.k_EResultOK)
{
if (mQueryInstallInfoCallBack != null)
{
mQueryInstallInfoCallBack.GetInstallInfoFail(SteamWorkshopQueryFailEnum.REQUEST_FAIL);
}
return;
}
List <SteamWorkshopQueryInstallInfoBean> listInstallInfo = new List <SteamWorkshopQueryInstallInfoBean>();
for (uint i = 0; i < itemResult.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t detailsInfo;
SteamUGC.GetQueryUGCResult(itemResult.m_handle, i, out detailsInfo);
ulong punSizeOnDisk;
string pchFolder;
uint punTimeStamp;
SteamUGC.GetItemInstallInfo(detailsInfo.m_nPublishedFileId, out punSizeOnDisk, out pchFolder, (uint)detailsInfo.m_nFileSize, out punTimeStamp);
string metaData;
SteamUGC.GetQueryUGCMetadata(itemResult.m_handle, i, out metaData, 1000);
//if (punSizeOnDisk == 0 || punTimeStamp == 0 || CheckUtil.StringIsNull(pchFolder))
//{
// continue;
//}
//添加缩略图地址
string previewUrl;
SteamUGC.GetQueryUGCPreviewURL(itemResult.m_handle, i, out previewUrl, (uint)detailsInfo.m_nPreviewFileSize);
SteamWorkshopQueryInstallInfoBean installInfoBean = new SteamWorkshopQueryInstallInfoBean
{
punSizeOnDisk = punSizeOnDisk,
pchFolder = pchFolder,
punTimeStamp = punTimeStamp,
detailsInfo = detailsInfo,
previewUrl = previewUrl,
metaData = metaData
};
listInstallInfo.Add(installInfoBean);
}
if (mQueryInstallInfoCallBack != null)
{
mQueryInstallInfoCallBack.GetInstallInfoSuccess(listInstallInfo);
}
}
private void OnSteamUGCQueryCompleted(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
if (param.m_eResult != EResult.k_EResultOK)
{
onRead(null);
onRead = null;
return;
}
bool queryUGCResult = SteamUGC.GetQueryUGCResult(param.m_handle, 0u, out UGCDetails);
OnUGCDownloadCallResult = CallResult <RemoteStorageDownloadUGCResult_t> .Create(OnDownloadThumbnail);
SteamAPICall_t hAPICall = SteamRemoteStorage.UGCDownload(UGCDetails.m_hPreviewFile, 0u);
OnUGCDownloadCallResult.Set(hAPICall);
}
private void OnSteamUGCQueryCompletedUserMods(SteamUGCQueryCompleted_t pCallback, bool bIOFailure)
{
SteamUGCDetails_t steamUGCDetailsT;
if (!bIOFailure && pCallback.m_eResult == EResult.k_EResultOK && pCallback.m_unNumResultsReturned > 0)
{
for (uint i = 0; i < pCallback.m_unNumResultsReturned; i++)
{
if (SteamUGC.GetQueryUGCResult(pCallback.m_handle, i, out steamUGCDetailsT))
{
this.publishedContent.Add(steamUGCDetailsT.m_nPublishedFileId);
}
}
}
SteamManager.logger.Info("Published user mods IDs: {0}", string.Join <PublishedFileId_t>(", ", this.publishedContent));
SteamUGC.ReleaseQueryUGCRequest(pCallback.m_handle);
}
public void OnSteamUGCQueryCompletedCallFunc(SteamUGCQueryCompleted_t result, bool ioFailure)
{
Debug.LogFormat("SteamUnity.OnSteamUGCQueryCompletedCallFunc: result: {0} (total: {1})", result.m_unNumResultsReturned, result.m_unTotalMatchingResults);
publishedItems.Clear();
for (int i = 0; i < result.m_unNumResultsReturned; ++i)
{
var details = new SteamUGCDetails_t();
SteamUGC.GetQueryUGCResult(query, (uint)i, out details);
publishedItems.Add(details);
}
busy = false;
}
protected void onSteamUGCQueryCompleted(SteamUGCQueryCompleted_t callback, bool io)
{
if (callback.m_handle != this.itemHandle)
{
return;
}
Debug.Log("Queried: " + callback.m_eResult);
if (SteamUGC.GetQueryUGCResult(this.itemHandle, 0u, ref this.workshopItemDetails))
{
this.hasPersonaInfo = false;
if (!SteamFriends.RequestUserInformation((CSteamID)this.workshopItemDetails.m_ulSteamIDOwner, true))
{
this.downloadWorkshopItem();
}
}
SteamUGC.ReleaseQueryUGCRequest(this.itemHandle);
this.itemHandle = UGCQueryHandle_t.Invalid;
}
private void onQueryCompleted(SteamUGCQueryCompleted_t callback, bool io)
{
if (callback.m_eResult != 1 || io)
{
return;
}
for (uint num = 0u; num < callback.m_unNumResultsReturned; num += 1u)
{
SteamUGCDetails_t steamUGCDetails_t;
SteamUGC.GetQueryUGCResult(this.ugcRequest, num, ref steamUGCDetails_t);
SteamPublished item = new SteamPublished(steamUGCDetails_t.m_rgchTitle, steamUGCDetails_t.m_nPublishedFileId);
this.published.Add(item);
}
if (this.onPublishedAdded != null)
{
this.onPublishedAdded();
}
}
private static void IndexPage(SteamUGCQueryCompleted_t param)
{
Console.WriteLine("Indexing page " + index);
if (param.m_unNumResultsReturned == 0)
{
done = true;
}
else
{
for (uint i = 0; i < param.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t details;
SteamUGC.GetQueryUGCResult(param.m_handle, i, out details);
if (details.m_pchFileName.Length > 0)
{
levels.Add(new WorkshopLevel(details));
}
}
RequestNextPage();
}
}
private void OnUGCQueryResult(SteamUGCQueryCompleted_t result, bool ioFailure)
{
_UGCDetails.Clear();
_Missions.Clear();
for (int i = 0; i < result.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t infos;
SteamUGC.GetQueryUGCResult(result.m_handle, (uint)i, out infos);
_Missions.Add(infos.m_rgchTitle + " - " + infos.m_nPublishedFileId);
_UGCDetails.Add(infos);
// Clear broken files
if (infos.m_rgchTitle == null || infos.m_rgchTitle == "")
{
SteamUGC.DeleteItem(infos.m_nPublishedFileId);
}
}
listBox.ItemsSource = _Missions.ToArray();
}
private static void OnUserModsReceived(SteamUGCQueryCompleted_t result, bool failure)
{
Debug.Log($"Received user mods: failure: {failure}, result: {result.m_eResult}, count: {result.m_unNumResultsReturned}");
CSteamID author = CSteamID.Nil;
List <CrossPromotion> promotions = new List <CrossPromotion>();
for (uint i = 0; i < result.m_unNumResultsReturned; i++)
{
if (SteamUGC.GetQueryUGCResult(result.m_handle, i, out var details))
{
Debug.Log($" - {details.m_rgchTitle} ({details.m_ulSteamIDOwner}");
author = new CSteamID(details.m_ulSteamIDOwner);
promotions.Add(new CrossPromotion(details));
}
}
if (author != CSteamID.Nil)
{
_modsForAuthor.Add(author.GetAccountID(), promotions);
_currentlyFetchingAuthors.Remove(author.GetAccountID());
}
SteamUGC.ReleaseQueryUGCRequest(result.m_handle);
}
private void HandleQueryCompleted(SteamUGCQueryCompleted_t param, bool bIOFailure)
{
if (!bIOFailure)
{
if (param.m_eResult == EResult.k_EResultOK)
{
matchedRecordCount = param.m_unTotalMatchingResults;
PageCount = (uint)Mathf.Clamp((int)matchedRecordCount / 50, 1, int.MaxValue);
if (PageCount * 50 < matchedRecordCount)
{
PageCount++;
}
for (int i = 0; i < param.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t details;
SteamUGC.GetQueryUGCResult(param.m_handle, (uint)i, out details);
var nRecord = new HeathenWorkshopReadCommunityItem(details);
ResultsList.Add(nRecord);
}
ReleaseHandle();
if (Callback != null)
{
Callback.Invoke(this);
}
}
else
{
Debug.LogError("HeathenWorkitemQuery|HandleQueryCompleted Unexpected results, state = " + param.m_eResult.ToString());
}
}
else
{
Debug.LogError("HeathenWorkitemQuery|HandleQueryCompleted failed.");
}
}