public void OnDestroy()
{
if (boundData != null)
{
boundData.ReleaseThumbnailReference();
}
boundData = null;
}
private bool MatchesPart(RagdollPresetPartMetadata partRef, WorkshopItemMetadata part)
{
if (RagdollPresetPartMetadata.IsEmpty(partRef))
{
return(RagdollPresetPartMetadata.IsEmpty(part.folder));
}
return(partRef.modelPath == part.folder);
}
private IEnumerator RefreshTitleDescription()
{
int levelsCount = levelsToRefresh.Count;
if (levelsCount != 0)
{
int startCount = 0;
int batchCount = CalcBatchSize(levelsCount, startCount, 50);
List <PublishedFileId_t> publishFields = new List <PublishedFileId_t>(50);
while (batchCount > 0)
{
publishFields.Clear();
for (int i = 0; i < batchCount; i++)
{
publishFields.Add(new PublishedFileId_t(levelsToRefresh[i + startCount].workshopId));
}
UGCQueryHandle_t m_UGCQueryHandle = SteamUGC.CreateQueryUGCDetailsRequest(publishFields.ToArray(), (uint)publishFields.Count);
SteamUGC.SetReturnLongDescription(m_UGCQueryHandle, bReturnLongDescription: true);
OnSteamUGCQueryCompletedCallResult = CallResult <SteamUGCQueryCompleted_t> .Create(OnSteamUGCQueryCompleted);
SteamAPICall_t h = SteamUGC.SendQueryUGCRequest(m_UGCQueryHandle);
OnSteamUGCQueryCompletedCallResult.Set(h);
while (OnSteamUGCQueryCompletedCallResult != null)
{
yield return(null);
}
for (int j = 0; j < batchCount; j++)
{
if (SteamUGC.GetQueryUGCResult(refreshResults, (uint)j, out SteamUGCDetails_t UGCDetails))
{
bool flag = false;
WorkshopItemMetadata workshopItemMetadata = levelsToRefresh[j + startCount];
if (!workshopItemMetadata.title.Equals(UGCDetails.m_rgchTitle))
{
workshopItemMetadata.title = UGCDetails.m_rgchTitle;
flag = true;
}
if (!workshopItemMetadata.description.Equals(UGCDetails.m_rgchDescription))
{
workshopItemMetadata.description = UGCDetails.m_rgchDescription;
flag = true;
}
if (flag)
{
workshopItemMetadata.Save(workshopItemMetadata.folder);
}
}
}
SteamUGC.ReleaseQueryUGCRequest(refreshResults);
startCount += batchCount;
batchCount = CalcBatchSize(levelsCount, startCount, 50);
}
}
levelsToRefresh.Clear();
}
protected void RemoveItem(WorkshopItemSource source, WorkshopItemMetadata item)
{
if (item != null)
{
Remove((T)item);
foreach (List <T> value in bySource.Values)
{
value.Remove((T)item);
}
}
}
private void LoadBuiltinModels()
{
for (int i = 0; i < builtinModels.Length; i++)
{
if (builtinModels[i] != null)
{
WorkshopItemMetadata meta = builtinModels[i].meta;
modelRepos[meta.itemType].AddItem(WorkshopItemSource.BuiltIn, meta);
}
}
presetRepo.LoadSkins();
}
private void EnsureSkin(string path)
{
if (GetItem(path) == null)
{
RagdollPresetMetadata ragdollPresetMetadata = WorkshopItemMetadata.Load <RagdollPresetMetadata>(path);
if (ragdollPresetMetadata == null)
{
ragdollPresetMetadata = CreateDefaultSkin();
ragdollPresetMetadata.folder = path;
}
AddItem(WorkshopItemSource.BuiltIn, ragdollPresetMetadata);
}
}
public static void Upload(WorkshopItemMetadata meta, string folder, string thumbnail, string updateNotes, Action <WorkshopItemMetadata, bool, EResult> uploadCallback)
{
if (!Initialize())
{
uploadCallback(meta, arg2: false, EResult.k_EResultConnectFailed);
return;
}
WorkshopUpload.uploadCallback = uploadCallback;
WorkshopUpload.meta = meta;
WorkshopUpload.folder = folder;
WorkshopUpload.thumbnail = thumbnail;
WorkshopUpload.updateNotes = updateNotes;
Upload();
}
private void OnDownloadLevel(DownloadItemResult_t param)
{
if (onRead != null)
{
if (param.m_eResult == EResult.k_EResultOK)
{
onRead(WorkshopItemMetadata.Load <WorkshopLevelMetadata>("ws:" + param.m_nPublishedFileId));
}
else
{
onRead(null);
}
onRead = null;
}
}
public void AddItem(WorkshopItemSource source, WorkshopItemMetadata item)
{
item.levelType = source;
T item2 = GetItem(item.folder);
if (item2 != null)
{
int index = IndexOf(item2);
base[index] = (T)item;
index = bySource[source].IndexOf(item2);
bySource[source][index] = (T)item;
}
else
{
bySource[source].Add((T)item);
Add((T)item);
}
}
private void OnPublishOver(WorkshopItemMetadata meta, bool needAgreement, EResult error)
{
FileTools.DeleteTempDirectory(tempFolder);
switch (error)
{
case EResult.k_EResultOK:
SteamProgressOverlay.instance.ShowSteamProgress(showProgress: false, null, null);
base.gameObject.SetActive(value: true);
preset.workshopId = meta.workshopId;
preset.Save(preset.folder);
TransitionForward <CustomizationRootMenu>();
return;
case EResult.k_EResultFileNotFound:
preset.workshopId = 0uL;
preset.Save(preset.folder);
break;
}
SteamProgressOverlay.instance.ShowSteamProgress(showProgress: false, string.Empty, DismissSteamError);
}
public override void Bind(int index, object data)
{
base.Bind(index, data);
WorkshopItemMetadata workshopItemMetadata = data as WorkshopItemMetadata;
if (workshopItemMetadata.isModel)
{
string name = (data as RagdollModelMetadata).modelPrefab.name;
label.text = LocalizationManager.GetTermTranslation("SKINS/" + name);
}
else
{
label.text = workshopItemMetadata.title;
}
image.texture = workshopItemMetadata.thumbnailTexture;
if (boundData != null)
{
boundData.ReleaseThumbnailReference();
}
boundData = workshopItemMetadata;
}
private void OnPublishOver(WorkshopItemMetadata meta, bool needAgreement, EResult error)
{
GameObject currentSelectedGameObject = EventSystem.current.currentSelectedGameObject;
if (error == EResult.k_EResultOK)
{
SteamProgressOverlay.instance.ShowSteamProgress(showProgress: false, null, null);
base.gameObject.SetActive(value: true);
Rebind();
}
else
{
if (error == EResult.k_EResultFileNotFound)
{
meta.workshopId = 0uL;
meta.Save(meta.folder);
}
SteamProgressOverlay.instance.ShowSteamProgress(showProgress: false, string.Empty, DismissSteamError);
}
previousSelectedItem = currentSelectedGameObject;
}
public void LoadLevel(ulong levelId, Action <WorkshopLevelMetadata> onRead)
{
PublishedFileId_t publishedFileId_t = new PublishedFileId_t(levelId);
uint itemState = SteamUGC.GetItemState(publishedFileId_t);
Debug.Log("itemstate: " + itemState + " " + publishedFileId_t);
if ((itemState & 8) != 0 || itemState == 0)
{
this.onRead = onRead;
OnDownloadItemCallResult = Callback <DownloadItemResult_t> .Create(OnDownloadLevel);
if (!SteamUGC.DownloadItem(publishedFileId_t, bHighPriority: true))
{
onRead(null);
this.onRead = null;
}
}
else
{
onRead(WorkshopItemMetadata.Load <WorkshopLevelMetadata>("ws:" + publishedFileId_t.m_PublishedFileId));
this.onRead = null;
}
}
private void ReadFolder(WorkshopItemSource source, string folder)
{
WorkshopItemMetadata workshopItemMetadata = WorkshopItemMetadata.Load(folder);
if (workshopItemMetadata == null)
{
return;
}
switch (workshopItemMetadata.itemType)
{
case WorkshopItemType.Level:
break;
case WorkshopItemType.Levels:
if (source == WorkshopItemSource.Subscription || source == WorkshopItemSource.LocalWorkshop)
{
levelRepo.AddItem(source, workshopItemMetadata);
}
break;
case WorkshopItemType.Lobbies:
if (source == WorkshopItemSource.SubscriptionLobbies || source == WorkshopItemSource.LocalWorkshop)
{
levelRepo.AddItem(source, workshopItemMetadata);
}
break;
case WorkshopItemType.RagdollPreset:
presetRepo.AddItem(source, workshopItemMetadata);
break;
default:
modelRepos[workshopItemMetadata.itemType].AddItem(source, workshopItemMetadata);
break;
}
}
public static AssetBundle LoadBundle(WorkshopItemMetadata wsMeta)
{
string path = FileTools.Combine(wsMeta.folder, "data");
return(FileTools.LoadBundle(path));
}