public void OnEnable() {
m_HTML_NeedsPaint = Callback<HTML_NeedsPaint_t>.Create(OnHTML_NeedsPaint);
m_HTML_StartRequest = Callback<HTML_StartRequest_t>.Create(OnHTML_StartRequest);
m_HTML_CloseBrowser = Callback<HTML_CloseBrowser_t>.Create(OnHTML_CloseBrowser);
m_HTML_URLChanged = Callback<HTML_URLChanged_t>.Create(OnHTML_URLChanged);
m_HTML_FinishedRequest = Callback<HTML_FinishedRequest_t>.Create(OnHTML_FinishedRequest);
m_HTML_OpenLinkInNewTab = Callback<HTML_OpenLinkInNewTab_t>.Create(OnHTML_OpenLinkInNewTab);
m_HTML_ChangedTitle = Callback<HTML_ChangedTitle_t>.Create(OnHTML_ChangedTitle);
m_HTML_SearchResults = Callback<HTML_SearchResults_t>.Create(OnHTML_SearchResults);
m_HTML_CanGoBackAndForward = Callback<HTML_CanGoBackAndForward_t>.Create(OnHTML_CanGoBackAndForward);
m_HTML_HorizontalScroll = Callback<HTML_HorizontalScroll_t>.Create(OnHTML_HorizontalScroll);
m_HTML_VerticalScroll = Callback<HTML_VerticalScroll_t>.Create(OnHTML_VerticalScroll);
m_HTML_LinkAtPosition = Callback<HTML_LinkAtPosition_t>.Create(OnHTML_LinkAtPosition);
m_HTML_JSAlert = Callback<HTML_JSAlert_t>.Create(OnHTML_JSAlert);
m_HTML_JSConfirm = Callback<HTML_JSConfirm_t>.Create(OnHTML_JSConfirm);
m_HTML_FileOpenDialog = Callback<HTML_FileOpenDialog_t>.Create(OnHTML_FileOpenDialog);
m_HTML_NewWindow = Callback<HTML_NewWindow_t>.Create(OnHTML_NewWindow);
m_HTML_SetCursor = Callback<HTML_SetCursor_t>.Create(OnHTML_SetCursor);
m_HTML_StatusText = Callback<HTML_StatusText_t>.Create(OnHTML_StatusText);
m_HTML_ShowToolTip = Callback<HTML_ShowToolTip_t>.Create(OnHTML_ShowToolTip);
m_HTML_UpdateToolTip = Callback<HTML_UpdateToolTip_t>.Create(OnHTML_UpdateToolTip);
m_HTML_HideToolTip = Callback<HTML_HideToolTip_t>.Create(OnHTML_HideToolTip);
m_HTML_BrowserReadyResult = CallResult<HTML_BrowserReady_t>.Create(OnHTML_BrowserReady);
m_Init = SteamHTMLSurface.Init();
print("SteamHTMLSurface.Init() : " + m_Init);
m_Texture = null;
}
public void OnEnable() {
m_RemoteStorageAppSyncedClient = Callback<RemoteStorageAppSyncedClient_t>.Create(OnRemoteStorageAppSyncedClient);
m_RemoteStorageAppSyncedServer = Callback<RemoteStorageAppSyncedServer_t>.Create(OnRemoteStorageAppSyncedServer);
m_RemoteStorageAppSyncProgress = Callback<RemoteStorageAppSyncProgress_t>.Create(OnRemoteStorageAppSyncProgress);
m_RemoteStorageAppSyncStatusCheck = Callback<RemoteStorageAppSyncStatusCheck_t>.Create(OnRemoteStorageAppSyncStatusCheck);
m_RemoteStorageConflictResolution = Callback<RemoteStorageConflictResolution_t>.Create(OnRemoteStorageConflictResolution);
m_RemoteStoragePublishedFileSubscribed = Callback<RemoteStoragePublishedFileSubscribed_t>.Create(OnRemoteStoragePublishedFileSubscribed);
m_RemoteStoragePublishedFileUnsubscribed = Callback<RemoteStoragePublishedFileUnsubscribed_t>.Create(OnRemoteStoragePublishedFileUnsubscribed);
m_RemoteStoragePublishedFileDeleted = Callback<RemoteStoragePublishedFileDeleted_t>.Create(OnRemoteStoragePublishedFileDeleted);
m_RemoteStoragePublishFileProgress = Callback<RemoteStoragePublishFileProgress_t>.Create(OnRemoteStoragePublishFileProgress);
m_RemoteStoragePublishedFileUpdated = Callback<RemoteStoragePublishedFileUpdated_t>.Create(OnRemoteStoragePublishedFileUpdated);
RemoteStorageFileShareResult = CallResult<RemoteStorageFileShareResult_t>.Create(OnRemoteStorageFileShareResult);
RemoteStoragePublishFileResult = CallResult<RemoteStoragePublishFileResult_t>.Create(OnRemoteStoragePublishFileResult);
RemoteStorageDeletePublishedFileResult = CallResult<RemoteStorageDeletePublishedFileResult_t>.Create(OnRemoteStorageDeletePublishedFileResult);
RemoteStorageEnumerateUserPublishedFilesResult = CallResult<RemoteStorageEnumerateUserPublishedFilesResult_t>.Create(OnRemoteStorageEnumerateUserPublishedFilesResult);
RemoteStorageSubscribePublishedFileResult = CallResult<RemoteStorageSubscribePublishedFileResult_t>.Create(OnRemoteStorageSubscribePublishedFileResult);
RemoteStorageEnumerateUserSubscribedFilesResult = CallResult<RemoteStorageEnumerateUserSubscribedFilesResult_t>.Create(OnRemoteStorageEnumerateUserSubscribedFilesResult);
RemoteStorageUnsubscribePublishedFileResult = CallResult<RemoteStorageUnsubscribePublishedFileResult_t>.Create(OnRemoteStorageUnsubscribePublishedFileResult);
RemoteStorageUpdatePublishedFileResult = CallResult<RemoteStorageUpdatePublishedFileResult_t>.Create(OnRemoteStorageUpdatePublishedFileResult);
RemoteStorageDownloadUGCResult = CallResult<RemoteStorageDownloadUGCResult_t>.Create(OnRemoteStorageDownloadUGCResult);
RemoteStorageGetPublishedFileDetailsResult = CallResult<RemoteStorageGetPublishedFileDetailsResult_t>.Create(OnRemoteStorageGetPublishedFileDetailsResult);
RemoteStorageEnumerateWorkshopFilesResult = CallResult<RemoteStorageEnumerateWorkshopFilesResult_t>.Create(OnRemoteStorageEnumerateWorkshopFilesResult);
RemoteStorageGetPublishedItemVoteDetailsResult = CallResult<RemoteStorageGetPublishedItemVoteDetailsResult_t>.Create(OnRemoteStorageGetPublishedItemVoteDetailsResult);
RemoteStorageUpdateUserPublishedItemVoteResult = CallResult<RemoteStorageUpdateUserPublishedItemVoteResult_t>.Create(OnRemoteStorageUpdateUserPublishedItemVoteResult);
RemoteStorageUserVoteDetails = CallResult<RemoteStorageUserVoteDetails_t>.Create(OnRemoteStorageUserVoteDetails);
RemoteStorageEnumerateUserSharedWorkshopFilesResult = CallResult<RemoteStorageEnumerateUserSharedWorkshopFilesResult_t>.Create(OnRemoteStorageEnumerateUserSharedWorkshopFilesResult);
RemoteStorageSetUserPublishedFileActionResult = CallResult<RemoteStorageSetUserPublishedFileActionResult_t>.Create(OnRemoteStorageSetUserPublishedFileActionResult);
RemoteStorageEnumeratePublishedFilesByUserActionResult = CallResult<RemoteStorageEnumeratePublishedFilesByUserActionResult_t>.Create(OnRemoteStorageEnumeratePublishedFilesByUserActionResult);
}
// This should only ever be called by SteamManager in OnEnable()!
public void Init() {
m_callResultFindLeaderboard = new CallResult<LeaderboardFindResult_t>(OnFindLeaderboard);
m_callResultUploadScore = new CallResult<LeaderboardScoreUploaded_t>(OnScoreUploaded);
#if DISABLED
m_callResultDownloadedEntries = new CallResult<LeaderboardScoresDownloaded_t>(OnLeaderboardDownloadedEntries);
#endif
}
public void OnEnable() {
m_HTTPRequestHeadersReceived = Callback<HTTPRequestHeadersReceived_t>.Create(OnHTTPRequestHeadersReceived);
m_HTTPRequestDataReceived = Callback<HTTPRequestDataReceived_t>.Create(OnHTTPRequestDataReceived);
OnHTTPRequestCompletedCallResult = CallResult<HTTPRequestCompleted_t>.Create(OnHTTPRequestCompleted);
m_CookieContainer = HTTPCookieContainerHandle.Invalid;
}
static void InitializeCallbacks() {
m_NumberOfCurrentPlayers = CallResult<NumberOfCurrentPlayers_t>.Create(OnNumberOfCurrentPlayers);
m_callResultFindLeaderboard = CallResult<LeaderboardFindResult_t>.Create(OnFindLeaderboard);
m_PersonaStateChange = Callback<PersonaStateChange_t>.Create(OnPersonaStateChange);
m_UserStatsReceived = Callback<UserStatsReceived_t>.Create(
(pCallback) => {
Console.WriteLine("[" + UserStatsReceived_t.k_iCallback + " - UserStatsReceived] - " + pCallback.m_eResult + " -- " + pCallback.m_nGameID + " -- " + pCallback.m_steamIDUser);
});
}
public void OnEnable() {
m_IPCountry = Callback<IPCountry_t>.Create(OnIPCountry);
m_LowBatteryPower = Callback<LowBatteryPower_t>.Create(OnLowBatteryPower);
//m_SteamAPICallCompleted = Callback<SteamAPICallCompleted_t>.Create(OnSteamAPICallCompleted); // N/A - Far too spammy to test like this!
m_SteamShutdown = Callback<SteamShutdown_t>.Create(OnSteamShutdown);
m_GamepadTextInputDismissed = Callback<GamepadTextInputDismissed_t>.Create(OnGamepadTextInputDismissed);
OnCheckFileSignatureCallResult = CallResult<CheckFileSignature_t>.Create(OnCheckFileSignature);
}
void Start () {
OnCreateItemResultCallResult = CallResult<CreateItemResult_t>.Create(OnCreateItemResult);
OnSubmitItemUpdateResultCallResult = CallResult<SubmitItemUpdateResult_t>.Create(OnSubmitItemUpdateResult);
//Set the author name to the Steam Persona Name. Example: authorName = Kinifi
author_Name = SteamBasic.getPersonaName();
Debug.Log("Starting Game Manager");
}
public void DisplayMessage(CallResult result, bool mergeModelState = true)
{
var message = new Message();
message.Text = result.Message;
message.Type = result.Type;
TempData["DisplayMessage"] = message;
if(!result.Success && mergeModelState)
TempData["ModelState"] = ModelState;
}
// Use this for initialization
void Start () {
//set this to give an example to users
imagePath = Application.dataPath + "/UserLevels/" + "SantaHat.png";
OnCreateItemResultCallResult = CallResult<CreateItemResult_t>.Create(OnCreateItemResult);
OnSubmitItemUpdateResultCallResult = CallResult<SubmitItemUpdateResult_t>.Create(OnSubmitItemUpdateResult);
//Set the author name to the Steam Persona Name. Example: authorName = Kinifi
author_Name = SteamBasic.getPersonaName();
}
public void OnEnable() {
m_ItemInstalled = Callback<ItemInstalled_t>.Create(OnItemInstalled);
OnSteamUGCQueryCompletedCallResult = CallResult<SteamUGCQueryCompleted_t>.Create(OnSteamUGCQueryCompleted);
OnSteamUGCRequestUGCDetailsResultCallResult = CallResult<SteamUGCRequestUGCDetailsResult_t>.Create(OnSteamUGCRequestUGCDetailsResult);
OnCreateItemResultCallResult = CallResult<CreateItemResult_t>.Create(OnCreateItemResult);
OnSubmitItemUpdateResultCallResult = CallResult<SubmitItemUpdateResult_t>.Create(OnSubmitItemUpdateResult);
// These come from ISteamRemoteStorage but they are used here as well...
OnRemoteStorageSubscribePublishedFileResultCallResult = CallResult<RemoteStorageSubscribePublishedFileResult_t>.Create(OnRemoteStorageSubscribePublishedFileResult);
OnRemoteStorageUnsubscribePublishedFileResultCallResult = CallResult<RemoteStorageUnsubscribePublishedFileResult_t>.Create(OnRemoteStorageUnsubscribePublishedFileResult);
}
public void OnEnable() {
m_SteamServersConnected = Callback<SteamServersConnected_t>.Create(OnSteamServersConnected);
m_SteamServerConnectFailure = Callback<SteamServerConnectFailure_t>.Create(OnSteamServerConnectFailure);
m_SteamServersDisconnected = Callback<SteamServersDisconnected_t>.Create(OnSteamServersDisconnected);
m_ClientGameServerDeny = Callback<ClientGameServerDeny_t>.Create(OnClientGameServerDeny);
m_IPCFailure = Callback<IPCFailure_t>.Create(OnIPCFailure);
m_ValidateAuthTicketResponse = Callback<ValidateAuthTicketResponse_t>.Create(OnValidateAuthTicketResponse);
m_MicroTxnAuthorizationResponse = Callback<MicroTxnAuthorizationResponse_t>.Create(OnMicroTxnAuthorizationResponse);
m_GetAuthSessionTicketResponse = Callback<GetAuthSessionTicketResponse_t>.Create(OnGetAuthSessionTicketResponse);
m_GameWebCallback = Callback<GameWebCallback_t>.Create(OnGameWebCallback);
OnEncryptedAppTicketResponseCallResult = CallResult<EncryptedAppTicketResponse_t>.Create(OnEncryptedAppTicketResponse);
}
protected override async Task DoWork(PairConfig pair, CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
try
{
using (BinanceSocketClient client = new BinanceSocketClient())
{
ConnectionInfo cnInfo = new ConnectionInfo(_settings.Value.BusConnectionString);
using (NatsClient natsClient = new NatsClient(cnInfo))
{
if (!natsClient.IsConnected)
{
natsClient.Connect();
}
CallResult <UpdateSubscription> successKline = null;
successKline = client.SubscribeToTradeUpdates(pair.Symbol, async(data) =>
{
Trade trade = data.ToEntity();
if (!_settings.Value.DisadleDealsSaving)
{
long id = await _tradesProcessor.Create(trade);
}
await natsClient.PubAsJsonAsync(_settings.Value.TradesQueueName, new Notification <Trade>()
{
Code = ActionCode.CREATED.Code, Payload = trade
});
});
successKline.Data.ConnectionLost += () => { _logger.LogError($"Connection to {Exchange} is lost"); };
successKline.Data.ConnectionRestored += (data) => { _logger.LogError($"Connection to {Exchange} is Restored"); };
while (!stoppingToken.IsCancellationRequested)
{
}
natsClient.Disconnect();
await client.Unsubscribe(successKline.Data);
}
}
}
catch (Exception ex)
{
_logger.LogError($"{Exchange.Description} Trades service failed with message {ex.Message}", ex);
}
}
}
public static CallResult <string> ReplaceStyleImage(IUnitOfWork db,
ILogService log,
long itemImageId,
DateTime when,
long?by)
{
var images = db.ItemImages.GetAll()
.Where(im => im.Id == itemImageId &&
im.ImageType == (int)ProductImageType.Large)
.ToList();
if (images.Any())
{
var itemId = images[0].ItemId;
var item = db.Items.GetAll().FirstOrDefault(i => i.Id == itemId);
if (item != null &&
item.StyleId.HasValue)
{
var style = db.Styles.Get(item.StyleId.Value);
var styleDefaultImage = db.StyleImages.GetAll().FirstOrDefault(im => im.StyleId == style.Id && im.IsDefault);
var newImage = ImageHelper.RemoveAmazonImagePostfix(images[0].Image);
style.Image = newImage;
if (styleDefaultImage != null)
{
log.Info("Style image was replaced, from=" + styleDefaultImage.Image + ", to=" + images[0].Image);
styleDefaultImage.Image = newImage;
styleDefaultImage.Type = (int)Core.Models.StyleImageType.HiRes;
styleDefaultImage.Tag = "UI replaced";
styleDefaultImage.UpdateDate = when;
styleDefaultImage.UpdatedBy = by;
}
db.Commit();
var items = db.Items.GetAll().Where(i => i.StyleId == style.Id &&
(i.ItemPublishedStatus == (int)PublishedStatuses.ChangesSubmited ||
i.ItemPublishedStatus == (int)PublishedStatuses.Published ||
i.ItemPublishedStatus == (int)PublishedStatuses.PublishedInProgress ||
i.ItemPublishedStatus == (int)PublishedStatuses.PublishingErrors ||
i.ItemPublishedStatus == (int)PublishedStatuses.PublishedInactive)).ToList();
log.Info("Listings to resubmit, count=" + items.Count());
items.ForEach(i => i.ItemPublishedStatus = (int)PublishedStatuses.HasChanges);
db.Commit();
return(CallResult <string> .Success(images[0].Image));
}
}
return(CallResult <string> .Fail("Style listings do not have a suitable Hi-res images", null));
}
public ItemDetailsRequest Send()
{
SteamAPIWrapper.Init();
_onQueryCompleted = CallResult <SteamUGCQueryCompleted_t> .Create(QueryCompleted);
_queryHandle = SteamUGC.CreateQueryUGCDetailsRequest(new[] { ID.ToPublishedFileID() }, 1);
var apiCall = SteamUGC.SendQueryUGCRequest(_queryHandle);
_onQueryCompleted.Set(apiCall);
return(this);
}
public CallResult Post([FromBody] AddProductSPUDTO dto)
{
CallResult cr;
try
{
cr = productSPUService.AddProduct(dto);
}
catch (Exception ex)
{
cr = new CallResult(500, $"产品创建异常：{ex.Message}/r/n{ex.StackTrace}");
}
return(cr);
}
internal SteamFileItem()
{
RemoteStoragePreFileShareResult = CallResult <RemoteStorageFileShareResult_t> .Create(OnRemoteStoragePreFileShareResult);
RemoteStorageFileShareResult = CallResult <RemoteStorageFileShareResult_t> .Create(OnRemoteStorageFileShareResult);
RemoteStorageFilePublishResult = CallResult <RemoteStoragePublishFileResult_t> .Create(OnRemoteStorageFilePublishResult);
FileShareEvent += SteamWorkShop.OnFileSharedEvent;
FilePublishEvent += SteamWorkShop.OnFilePublishEvent;
_mgr.Add(this);
curinstanceId++;
instanceId = curinstanceId;
}
public async Task ReceivingAReconnectMessage_Should_PreventOperationsBeforeReconnect()
{
// arrange
CallResult <UpdateSubscription> subResultWhenPaused = null;
var socket = new TestSocket();
socket.CanConnect = true;
socket.CloseTime = TimeSpan.FromMilliseconds(1000);
socket.OpenTime = TimeSpan.FromMilliseconds(100);
socket.Url = "wss://api.bitfinex.com/ws/2";
var client = TestHelpers.CreateAuthenticatedSocketClient(socket, new BitfinexSocketClientOptions()
{
LogLevel = LogLevel.Debug,
ReconnectInterval = TimeSpan.FromMilliseconds(10)
});
var rstEvent = new ManualResetEvent(false);
var subTask = client.SpotStreams.SubscribeToKlineUpdatesAsync("tBTCUSD", KlineInterval.FiveMinutes, data => { });
socket.OnOpen += async() =>
{
await Task.Delay(10);
socket.InvokeMessage(new CandleSubscriptionResponse()
{
Channel = "candles",
Event = "subscribed",
ChannelId = 1,
Symbol = "tBTCUSD",
Key = "trade:" + JsonConvert.SerializeObject(KlineInterval.FiveMinutes, new KlineIntervalConverter(false)) +
":tBTCUSD"
});
};
var subResult = await subTask;
subResult.Data.ActivityPaused += async() =>
{
subResultWhenPaused = await client.SpotStreams.SubscribeToKlineUpdatesAsync("tBTCUSD", KlineInterval.FiveMinutes, data => { });
rstEvent.Set();
};
// act
socket.InvokeMessage("{\"event\":\"info\", \"code\": 20051}");
rstEvent.WaitOne(1000);
// assert
Assert.IsTrue(subResultWhenPaused?.Error?.Message.Contains("Socket is paused"));
}
public void QueryInstallInfo(uint pageNumber, EUserUGCList type, ISteamWorkshopQueryInstallInfoCallBack callBack)
{
this.mQueryInstallInfoCallBack = callBack;
//UGCQueryHandle_t handle = SteamUGC.CreateQueryAllUGCRequest(EUGCQuery.k_EUGCQuery_RankedByVote,EUGCMatchingUGCType.k_EUGCMatchingUGCType_All,mAppId, mAppId, pageNumber);
UGCQueryHandle_t handle = SteamUGC.CreateQueryUserUGCRequest(SteamUser.GetSteamID().GetAccountID(), type, EUGCMatchingUGCType.k_EUGCMatchingUGCType_All, EUserUGCListSortOrder.k_EUserUGCListSortOrder_CreationOrderAsc, mAppId, mAppId, pageNumber);
SteamUGC.SetReturnMetadata(handle, true);
CallResult <SteamUGCQueryCompleted_t> callResult = CallResult <SteamUGCQueryCompleted_t> .Create(QueryUserUGCCallBack);
SteamAPICall_t apiCall = SteamUGC.SendQueryUGCRequest(handle);
callResult.Set(apiCall);
}
public virtual ActionResult SendProductUpdate(int id)
{
LogI("SendProductUpdate, id=" + id);
var when = Time.GetAppNowTime();
ItemEditViewModel.SendProductUpdate(Db,
ActionService,
id,
when,
AccessManager.UserId);
return(JsonGet(CallResult <DateTime> .Success(when)));
}
private static void FindLeaderboard(string key)
{
SteamAPICall_t call = SteamUserStats.FindLeaderboard(key);
if (call.m_SteamAPICall != 0)
{
CallResult <LeaderboardFindResult_t> foundLeaderboard;
foundLeaderboard = new CallResult <LeaderboardFindResult_t>();
foundLeaderboard.Set(
call,
OnLeaderboardFound
);
}
}
public void Cleanup()
{
if (OnCreateItemResult != null)
{
OnCreateItemResult.Dispose();
}
OnCreateItemResult = null;
if (OnSubmitItemUpdateResult != null)
{
OnSubmitItemUpdateResult.Dispose();
}
OnSubmitItemUpdateResult = null;
}
internal static void Upload(WorkshopUploadable item)
{
if (Workshop.curStage != WorkshopInteractStage.None)
{
Messages.Message("UploadAlreadyInProgress".Translate(), MessageTypeDefOf.RejectInput, false);
return;
}
Workshop.uploadingHook = item.GetWorkshopItemHook();
if (Workshop.uploadingHook.PublishedFileId != PublishedFileId_t.Invalid)
{
if (Prefs.LogVerbose)
{
Log.Message(string.Concat(new object[]
{
"Workshop: Starting item update for mod '",
Workshop.uploadingHook.Name,
"' with PublishedFileId ",
Workshop.uploadingHook.PublishedFileId
}), false);
}
Workshop.curStage = WorkshopInteractStage.SubmittingItem;
Workshop.curUpdateHandle = SteamUGC.StartItemUpdate(SteamUtils.GetAppID(), Workshop.uploadingHook.PublishedFileId);
Workshop.SetWorkshopItemDataFrom(Workshop.curUpdateHandle, Workshop.uploadingHook, false);
SteamAPICall_t hAPICall = SteamUGC.SubmitItemUpdate(Workshop.curUpdateHandle, "[Auto-generated text]: Update on " + DateTime.Now.ToString() + ".");
if (Workshop.< > f__mg$cache3 == null)
{
Workshop.< > f__mg$cache3 = new CallResult <SubmitItemUpdateResult_t> .APIDispatchDelegate(Workshop.OnItemSubmitted);
}
Workshop.submitResult = CallResult <SubmitItemUpdateResult_t> .Create(Workshop.< > f__mg$cache3);
Workshop.submitResult.Set(hAPICall, null);
}
else
{
if (Prefs.LogVerbose)
{
Log.Message("Workshop: Starting item creation for mod '" + Workshop.uploadingHook.Name + "'.", false);
}
Workshop.curStage = WorkshopInteractStage.CreatingItem;
SteamAPICall_t hAPICall2 = SteamUGC.CreateItem(SteamUtils.GetAppID(), EWorkshopFileType.k_EWorkshopFileTypeFirst);
if (Workshop.< > f__mg$cache4 == null)
{
Workshop.< > f__mg$cache4 = new CallResult <CreateItemResult_t> .APIDispatchDelegate(Workshop.OnItemCreated);
}
Workshop.createResult = CallResult <CreateItemResult_t> .Create(Workshop.< > f__mg$cache4);
Workshop.createResult.Set(hAPICall2, null);
}
Find.WindowStack.Add(new Dialog_WorkshopOperationInProgress());
}
private static void Upload()
{
if (meta.workshopId == 0)
{
m_CreateItemResult = CallResult <CreateItemResult_t> .Create(OnCreateItemResult);
SteamAPICall_t hAPICall = SteamUGC.CreateItem((AppId_t)477160u, EWorkshopFileType.k_EWorkshopFileTypeFirst);
m_CreateItemResult.Set(hAPICall);
}
else
{
PerformUpload(preExisting: true);
}
}
void OnEnable()
{
ItemUpdateResult = CallResult <SubmitItemUpdateResult_t> .Create(OnItemUpdateResult);
RemoteStoragePublishFileResult = CallResult <RemoteStoragePublishFileResult_t> .Create(OnRemoteStoragePublishFileResult);
RemoteStorageEnumerateUserSubscribedFilesResult = CallResult <RemoteStorageEnumerateUserSubscribedFilesResult_t> .Create(OnRemoteStorageEnumerateUserSubscribedFilesResult);
RemoteStorageGetPublishedFileDetailsResult = CallResult <RemoteStorageGetPublishedFileDetailsResult_t> .Create(OnRemoteStorageGetPublishedFileDetailsResult);
RemoteStorageDownloadUGCResult = CallResult <RemoteStorageDownloadUGCResult_t> .Create(OnRemoteStorageDownloadUGCResult);
RemoteStorageUnsubscribePublishedFileResult = CallResult <RemoteStorageUnsubscribePublishedFileResult_t> .Create(OnRemoteStorageUnsubscribePublishedFileResult);
}
private void OnEnable()
{
basePath = Application.dataPath + relativeBasePath;
Debug.Log("basePath is: " + basePath);
if (SteamManager.Initialized)
{
m_NumberOfCurrentPlayers = CallResult <NumberOfCurrentPlayers_t> .Create(OnNumberOfCurrentPlayers);
m_itemCreated = CallResult <CreateItemResult_t> .Create(OnItemCreated);
m_itemSubmitted = CallResult <SubmitItemUpdateResult_t> .Create(OnItemSubmitted);
}
}
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);
}
}
private void Start()
{
if (SteamManager.Initialized)
{
Debug.Log("@Data: Registered handlers");
m_InventoryResultReady = Callback <SteamInventoryResultReady_t> .Create(OnInventoryResultReady);
m_InventoryFullUpdate = CallResult <SteamInventoryFullUpdate_t> .Create(OnInventoryFullUpdate);
m_ItemResultReady = Callback <SteamInventoryResultReady_t> .Create(OnItemResultReady);
GetInventory();
}
}
public static CallResult <RemoteStoragePublishFileResult_t> UploadWorkShop(string mapFile, string imageFile, string title, string description, Action <bool, bool, PublishedFileId_t> onDone)
{
var call = SteamRemoteStorage.PublishWorkshopFile(mapFile, imageFile, new AppId_t(Main.SteamAppID), title, description,
ERemoteStoragePublishedFileVisibility.k_ERemoteStoragePublishedFileVisibilityPublic, new List <string>(),
EWorkshopFileType.k_EWorkshopFileTypeCommunity);
var callResult = new CallResult <RemoteStoragePublishFileResult_t>((result, failure) =>
{
onDone(result.m_eResult == EResult.k_EResultOK, result.m_bUserNeedsToAcceptWorkshopLegalAgreement, result.m_nPublishedFileId);
});
callResult.Set(call);
return(callResult);
}
public CrossPromotion(SteamUGCDetails_t details)
{
_details = details;
_callResult = CallResult <RemoteStorageDownloadUGCResult_t> .Create(OnPreviewDownloaded);
if (File.Exists(PreviewPath) && new FileInfo(PreviewPath).Length == details.m_nPreviewFileSize)
{
LoadPreview();
}
else
{
FetchPreview(details.m_hPreviewFile);
}
}
void RequestInfo()
{
steam.Init();
if (steam.IsSign())
{
OnSteamUGCQueryCompletedCallResult = CallResult <SteamUGCQueryCompleted_t> .Create(OnSteamUGCQueryCompleted);
SteamAPICall_t handle = SteamUGC.SendQueryUGCRequest(SteamUGC.CreateQueryUserUGCRequest(SteamUser.GetSteamID().GetAccountID(), EUserUGCList.k_EUserUGCList_Published, EUGCMatchingUGCType.k_EUGCMatchingUGCType_Items, EUserUGCListSortOrder.k_EUserUGCListSortOrder_CreationOrderDesc, AppId_t.Invalid, SteamUtils.GetAppID(), 1));
OnSteamUGCQueryCompletedCallResult.Set(handle);
OnSubmitItemUpdateResultCallResult = CallResult <SubmitItemUpdateResult_t> .Create(OnSubmitItemUpdateResult);
OnCreateItemResultCallResult = CallResult <CreateItemResult_t> .Create(OnCreateItemResult);
}
}
protected override bool HandleQueryResponse <T>(SocketConnection s, object request, JToken data, out CallResult <T> callResult)
{
callResult = new CallResult <T>(default(T), null);
var v1Data = (data["data"] != null || data["tick"] != null) && data["rep"] != null;
var v1Error = data["status"] != null && (string)data["status"] == "error";
bool isV1QueryResponse = v1Data || v1Error;
if (isV1QueryResponse)
{
var hRequest = (HuobiSocketRequest)request;
if ((string)data["id"] != hRequest.Id)
{
return(false);
}
var desResult = Deserialize <T>(data, false);
if (!desResult.Success)
{
log.Write(LogVerbosity.Warning, $"Failed to deserialize data: {desResult.Error}. Data: {data}");
callResult = new CallResult <T>(default(T), desResult.Error);
return(true);
}
callResult = new CallResult <T>(desResult.Data, null);
}
var isV2Response = (string)data["op"] == "req";
if (isV2Response)
{
var hRequest = (HuobiAuthenticatedRequest)request;
if ((string)data["cid"] != hRequest.Id)
{
return(false);
}
var desResult = Deserialize <T>(data, false);
if (!desResult.Success)
{
log.Write(LogVerbosity.Warning, $"Failed to deserialize data: {desResult.Error}. Data: {data}");
return(false);
}
callResult = new CallResult <T>(desResult.Data, null);
return(true);
}
return(true);
}
protected override void OnSpawn()
{
base.OnSpawn();
// One long linear row
var panel = new PPanel("MoreModActions")
{
BackColor = PUITuning.Colors.DialogDarkBackground, Spacing = 6,
BackImage = PUITuning.Images.BoxBorder, ImageMode = Image.Type.Sliced,
Direction = PanelDirection.Horizontal, Margin = new RectOffset(6, 6, 6, 6)
}.AddChild(MakeButton("MoveToFirst", UI.TOOLTIPS.DNI_TOP,
SpriteRegistry.GetTopIcon(), OnMoveFirst, (obj) =>
buttonFirst = obj.GetComponent <KButton>()))
.AddChild(MakeButton("MoveUpTen", UI.TOOLTIPS.DNI_UP,
Assets.GetSprite("icon_priority_up_2"), OnMoveUp, (obj) =>
buttonUp = obj.GetComponent <KButton>()))
.AddChild(MakeButton("MoveDownTen", UI.TOOLTIPS.DNI_DOWN,
Assets.GetSprite("icon_priority_down_2"), OnMoveDown, (obj) =>
buttonDown = obj.GetComponent <KButton>()))
.AddChild(MakeButton("MoveToLast", UI.TOOLTIPS.DNI_BOTTOM,
SpriteRegistry.GetBottomIcon(), OnMoveLast, (obj) =>
buttonLast = obj.GetComponent <KButton>()));
// Manage mod (subscription / local folder), strings will be replaced
var manage = new PButton("ManageMod")
{
Text = UI.MODSSCREEN.BUTTON_SUBSCRIPTION, DynamicSize = false,
OnClick = OnManage, ToolTip = "Manage Mod", Margin = DebugUtils.BUTTON_MARGIN
}.SetKleiBlueStyle();
manage.OnRealize += (obj) => buttonManage = obj;
// Unsubscribe from mod
var unsub = new PButton("UnsubMod")
{
Text = UI.MODSSCREEN.BUTTON_UNSUB, DynamicSize = false,
OnClick = OnUnsub, ToolTip = UI.TOOLTIPS.DNI_UNSUB, Margin = DebugUtils.
BUTTON_MARGIN
}.SetKleiBlueStyle();
unsub.OnRealize += (obj) => buttonUnsub = obj.GetComponent <KButton>();
var actionsObj = panel.AddChild(manage).AddChild(unsub).AddTo(gameObject);
actionsObj.SetActive(false);
// Blacklist from auto layout
actionsObj.AddOrGet <LayoutElement>().ignoreLayout = true;
PUIElements.SetAnchors(actionsObj, PUIAnchoring.End, PUIAnchoring.Center);
callHandler = new CallResult <RemoteStorageUnsubscribePublishedFileResult_t>(
OnUnsubComplete);
actionsScreen = actionsObj.AddComponent <ModActionsScreen>();
callingButton = null;
}
public async Task <CallResult <ApplicationUser> > CreateUser(UserViewModel model)
{
CallResult <ApplicationUser> callResult = new CallResult <ApplicationUser>();
try
{
ApplicationUser user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email
};
IdentityResult idResult = await userManager.CreateAsync(user, model.Password);
if (idResult.Succeeded)
{
ApplicationRole applicationRole = await roleManager.FindByIdAsync(model.ApplicationRoleId);
if (applicationRole != null)
{
IdentityResult roleResult = await userManager.AddToRoleAsync(user, applicationRole.Name);
if (roleResult.Succeeded)
{
callResult.Model = user;
return(callResult);
}
else
{
callResult.HasError = 1;
callResult.Error = "Unable to add role for to the user";
}
}
}
else
{
callResult.HasError = 1;
callResult.Error = "Unable to create the user";
}
}
catch (Exception ex)
{
callResult.HasError = 1;
callResult.InternalError = ex.Message;
callResult.Error = "Internal Error";
//_logger.LogError("User {user} Creation Failed", ex.Message);
}
return(callResult);
}
internal static void RequestItemsDetails(PublishedFileId_t[] publishedFileIds)
{
if (detailsQueryCount >= 0)
{
Log.Error("Requested Workshop item details while a details request was already pending.");
return;
}
detailsQueryCount = publishedFileIds.Length;
detailsQueryHandle = SteamUGC.CreateQueryUGCDetailsRequest(publishedFileIds, (uint)detailsQueryCount);
SteamAPICall_t hAPICall = SteamUGC.SendQueryUGCRequest(detailsQueryHandle);
requestDetailsResult = CallResult <SteamUGCRequestUGCDetailsResult_t> .Create(OnGotItemDetails);
requestDetailsResult.Set(hAPICall);
}
public void OnEnable() {
m_UserStatsStored = Callback<UserStatsStored_t>.Create(OnUserStatsStored);
m_UserAchievementStored = Callback<UserAchievementStored_t>.Create(OnUserAchievementStored);
m_UserStatsUnloaded = Callback<UserStatsUnloaded_t>.Create(OnUserStatsUnloaded);
m_UserAchievementIconFetched = Callback<UserAchievementIconFetched_t>.Create(OnUserAchievementIconFetched);
UserStatsReceived = CallResult<UserStatsReceived_t>.Create(OnUserStatsReceived);
LeaderboardFindResult = CallResult<LeaderboardFindResult_t>.Create(OnLeaderboardFindResult);
LeaderboardScoresDownloaded = CallResult<LeaderboardScoresDownloaded_t>.Create(OnLeaderboardScoresDownloaded);
LeaderboardScoreUploaded = CallResult<LeaderboardScoreUploaded_t>.Create(OnLeaderboardScoreUploaded);
NumberOfCurrentPlayers = CallResult<NumberOfCurrentPlayers_t>.Create(OnNumberOfCurrentPlayers);
GlobalAchievementPercentagesReady = CallResult<GlobalAchievementPercentagesReady_t>.Create(OnGlobalAchievementPercentagesReady);
LeaderboardUGCSet = CallResult<LeaderboardUGCSet_t>.Create(OnLeaderboardUGCSet);
GlobalStatsReceived = CallResult<GlobalStatsReceived_t>.Create(OnGlobalStatsReceived);
}
void GetTotalCount(uint startIndex, string[] tags, uint days = 0, uint count = 1, EWorkshopEnumerationType orderBy = EWorkshopEnumerationType.k_EWorkshopEnumerationTypeRecent)
{//GetPreFileList step 1
try
{
GetTotalCountResult = CallResult <RemoteStorageEnumerateWorkshopFilesResult_t> .Create(OnGetTotalCountResult);
SteamAPICall_t handle = SteamRemoteStorage.EnumeratePublishedWorkshopFiles(orderBy, startIndex, count, days, tags, null);
GetTotalCountResult.Set(handle);
}
catch (System.Exception e)
{
Debug.Log("SteamRandomGetIsoProcess GetPreFileList " + e.ToString());
Finish(_fileIDs, _publishIDs, false);
}
}
public void OnEnable() {
m_FavoritesListChanged = Callback<FavoritesListChanged_t>.Create(OnFavoritesListChanged);
m_LobbyInvite = Callback<LobbyInvite_t>.Create(OnLobbyInvite);
m_LobbyEnter = Callback<LobbyEnter_t>.Create(OnLobbyEnter);
m_LobbyDataUpdate = Callback<LobbyDataUpdate_t>.Create(OnLobbyDataUpdate);
m_LobbyChatUpdate = Callback<LobbyChatUpdate_t>.Create(OnLobbyChatUpdate);
m_LobbyChatMsg = Callback<LobbyChatMsg_t>.Create(OnLobbyChatMsg);
m_LobbyGameCreated = Callback<LobbyGameCreated_t>.Create(OnLobbyGameCreated);
m_LobbyKicked = Callback<LobbyKicked_t>.Create(OnLobbyKicked);
m_FavoritesListAccountsUpdated = Callback<FavoritesListAccountsUpdated_t>.Create(OnFavoritesListAccountsUpdated);
OnLobbyEnterCallResult = CallResult<LobbyEnter_t>.Create(OnLobbyEnter);
OnLobbyMatchListCallResult = CallResult<LobbyMatchList_t>.Create(OnLobbyMatchList);
OnLobbyCreatedCallResult = CallResult<LobbyCreated_t>.Create(OnLobbyCreated);
}
public TempSteamworksWorkshop(SteamworksAppInfo newAppInfo)
{
this.appInfo = newAppInfo;
this.downloaded = new List <PublishedFileId_t>();
if (!this.appInfo.isDedicated)
{
this.createItemResult = CallResult <CreateItemResult_t> .Create(new CallResult <CreateItemResult_t> .APIDispatchDelegate(this.onCreateItemResult));
this.submitItemUpdateResult = CallResult <SubmitItemUpdateResult_t> .Create(new CallResult <SubmitItemUpdateResult_t> .APIDispatchDelegate(this.onSubmitItemUpdateResult));
this.queryCompleted = CallResult <SteamUGCQueryCompleted_t> .Create(new CallResult <SteamUGCQueryCompleted_t> .APIDispatchDelegate(this.onQueryCompleted));
this.itemDownloaded = Callback <DownloadItemResult_t> .Create(new Callback <DownloadItemResult_t> .DispatchDelegate(this.onItemDownloaded));
}
}
private static void OnSubscribed(RemoteStoragePublishedFileSubscribed_t subscribed)
{
if (!SteamInitialized)
{
return;
}
//Because Steam can be an idiot sometimes!
if (subscribed.m_nAppID.m_AppId != Main.SteamAppID)
{
return;
}
downloadLevelResult = DownloadLevel(subscribed.m_nPublishedFileId);
}
public virtual ActionResult GetInfo()
{
LogI("GetInfo");
var marketplaceManager = new MarketplaceKeeper(DbFactory, false);
marketplaceManager.Init();
IMarketApi api = new MarketFactory(marketplaceManager.GetAll(), Time, LogService, DbFactory, null)
.GetApi((AccessManager.Company ?? AccessManager.DefaultCompany).Id, MarketType.DropShipper, MarketplaceKeeper.DsToMBG);
var infoes = FedexCloseoutInfoViewModel.GetInfo(Db, Time, (DropShipperApi)api);
return(JsonGet(CallResult <IList <FedexCloseoutInfoViewModel> > .Success(infoes)));
}
private void SteamUGCRequest(ITimeStep t)
{
if (WorkshopID != 0 && ++RequestCount <= 5)
{
Console.WriteLine("SteamUGCRequest : " + RequestCount);
SteamAPICall_t UGCDetails = SteamUGC.RequestUGCDetails(new PublishedFileId_t(WorkshopID), 0);
SteamCall = new CallResult <SteamUGCRequestUGCDetailsResult_t>(Callback);
SteamCall.Set(UGCDetails);
}
else
{
GameEvents.Twice_Second.UnregWithEvent(SteamUGCRequest);
}
}
public void findLeaderboardEntriesForUser(ulong leaderboardId, LeaderboardEntriesFindResultCallBack callBack)
{
mFindDataType = 0;
OnLeaderboardEntriesFindResultCallBack = callBack;
m_SteamLeaderboard = new SteamLeaderboard_t();
m_SteamLeaderboard.m_SteamLeaderboard = leaderboardId;
OnLeaderboardScoresDownloadedCallResult = CallResult <LeaderboardScoresDownloaded_t> .Create(OnLeaderboardScoresDownloaded);
CSteamID[] Users = { SteamUser.GetSteamID() };
SteamAPICall_t handle = SteamUserStats.DownloadLeaderboardEntriesForUsers(m_SteamLeaderboard, Users, Users.Length);
//TODO 必须要延迟才能设置回调
Thread.Sleep(1000);
OnLeaderboardScoresDownloadedCallResult.Set(handle);
}
public virtual ActionResult CreateStyleVariations(AddVariationViewModel model)
{
LogI("GetStyleVariations, styleString=" + model.StyleString);
var items = ItemEditViewModel.CreateStyleVariations(Db,
LogService,
model.StyleString,
model.ExistSizes,
model.WalmartUrl,
(MarketType)model.Market,
model.MarketplaceId,
null);
return(JsonGet(CallResult <StyleVariationListViewModel> .Success(items)));
}
private static bool Init_SteamGame()
{
//Getting here means Steamworks MUST have initialized successfully. Oh, && operator!
RemoveWSTemp();
callbacks.Add(Callback<SteamUGCQueryCompleted_t>.Create(OnUGCQueryReturn));
callbacks.Add(Callback<UserStatsReceived_t>.Create(OnUserStatsReceived));
callbacks.Add(Callback<RemoteStoragePublishedFileSubscribed_t>.Create(OnSubscribed));
callbacks.Add(Callback<GameOverlayActivated_t>.Create(OnOverlayActivated));
queryResult = QuerySubscribed();
if (!SteamUserStats.RequestCurrentStats()) return false;
_achievementDictionary = new Dictionary<string, bool>();
_statDictionary = new Dictionary<string, int>();
return true;
}
bool findArgs(CallResult callResult)
{
var block = callResult.block;
var method = callResult.getMethodReference();
int numArgs = method.Parameters.Count + (method.HasThis ? 1 : 0);
var args = new object[numArgs];
int instrIndex = callResult.callEndIndex - 1;
for (int i = numArgs - 1; i >= 0; i--) {
if (!getArg(method, block, ref args[i], ref instrIndex))
return false;
}
callResult.args = args;
callResult.callStartIndex = instrIndex + 1;
return true;
}
public ICallResult UpdateProduct(Product product)
{
var result = new CallResult { Succeeded = false };
try
{
this.context.Products.Attach(product);
this.context.Entry(product).State = EntityState.Modified;
this.context.SaveChanges();
result.Succeeded = true;
}
catch (Exception ex)
{
result.AddErrors(ex);
}
return result;
}
public ICallResult CreateProduct(Product product)
{
var result = new CallResult { Succeeded = false };
product.Id = Guid.NewGuid().ToString();
try
{
this.context.Products.Add(product);
this.context.SaveChanges();
result.Succeeded = true;
}
catch (Exception ex)
{
result.AddErrors(ex);
}
return result;
}
public void CancelCallbacks()
{
#if STEAMWORKS
if (this.leaderboardFindCall != null)
this.leaderboardFindCall.Cancel();
this.leaderboardFindCall = null;
if (this.leaderboardUploadCall != null)
this.leaderboardUploadCall.Cancel();
this.leaderboardUploadCall = null;
if (this.globalLeaderboardDownloadCall != null)
this.globalLeaderboardDownloadCall.Cancel();
this.globalLeaderboardDownloadCall = null;
if (this.friendLeaderboardDownloadCall != null)
this.friendLeaderboardDownloadCall.Cancel();
this.friendLeaderboardDownloadCall = null;
this.friendScoresDownloaded = false;
this.globalScoresDownloaded = false;
#endif
}
/// <summary>
/// 删除数据（删除班级同时删除班级所在学员）
/// </summary>
/// <param name="studentBM">数据实体</param>
/// <returns>操作结果集</returns>
/// 创 建 人：HNAS .Net Framework 4.0 项目组
/// 创建日期：2011-12-5
/// 修 改 人：
/// 修改日期：
public CallResult<DataTable> GetStudentWithClass(StudentBM studentBM)
{
CallResult<DataTable> result = new CallResult<DataTable>();
try
{
result.Result = new StudentDA().GetStudentWithClass(studentBM);
result.Message = Message.Operate_Success;
}
catch (Exception ex)
{
result.Result = null;
result.Message = Message.Operate_Unsuccess;
result.Error = ex;
//处理异常
HandleException(ex);
}
return result;
}
public void OnEnable() {
m_PersonaStateChange = Callback<PersonaStateChange_t>.Create(OnPersonaStateChange);
m_GameOverlayActivated = Callback<GameOverlayActivated_t>.Create(OnGameOverlayActivated);
m_GameServerChangeRequested = Callback<GameServerChangeRequested_t>.Create(OnGameServerChangeRequested);
m_GameLobbyJoinRequested = Callback<GameLobbyJoinRequested_t>.Create(OnGameLobbyJoinRequested);
m_AvatarImageLoaded = Callback<AvatarImageLoaded_t>.Create(OnAvatarImageLoaded);
m_FriendRichPresenceUpdate = Callback<FriendRichPresenceUpdate_t>.Create(OnFriendRichPresenceUpdate);
m_GameRichPresenceJoinRequested = Callback<GameRichPresenceJoinRequested_t>.Create(OnGameRichPresenceJoinRequested);
m_GameConnectedClanChatMsg = Callback<GameConnectedClanChatMsg_t>.Create(OnGameConnectedClanChatMsg);
m_GameConnectedChatJoin = Callback<GameConnectedChatJoin_t>.Create(OnGameConnectedChatJoin);
m_GameConnectedChatLeave = Callback<GameConnectedChatLeave_t>.Create(OnGameConnectedChatLeave);
m_GameConnectedFriendChatMsg = Callback<GameConnectedFriendChatMsg_t>.Create(OnGameConnectedFriendChatMsg);
OnFriendRichPresenceCallResult = CallResult<ClanOfficerListResponse_t>.Create(OnClanOfficerListResponse);
OnDownloadClanActivityCountsResultCallResult = CallResult<DownloadClanActivityCountsResult_t>.Create(OnDownloadClanActivityCountsResult);
OnJoinClanChatRoomCompletionResultCallResult = CallResult<JoinClanChatRoomCompletionResult_t>.Create(OnJoinClanChatRoomCompletionResult);
OnFriendsGetFollowerCountCallResult = CallResult<FriendsGetFollowerCount_t>.Create(OnFriendsGetFollowerCount);
OnFriendsIsFollowingCallResult = CallResult<FriendsIsFollowing_t>.Create(OnFriendsIsFollowing);
OnFriendsEnumerateFollowingListCallResult = CallResult<FriendsEnumerateFollowingList_t>.Create(OnFriendsEnumerateFollowingList);
OnSetPersonaNameResponseCallResult = CallResult<SetPersonaNameResponse_t>.Create(OnSetPersonaNameResponse);
}
private static void OnUGCQueryReturn(SteamUGCQueryCompleted_t handle)
{
if (ugcPage == 1)
{
directories.Clear();
foreach (var s in SteamWorker.DownloadedMaps.GetDirectories())
{
directories.Add(s.Name);
}
}
for (uint i = 0; i < handle.m_unNumResultsReturned; i++)
{
SteamUGCDetails_t deets;
if (SteamUGC.GetQueryUGCResult(handle.m_handle, i, out deets))
{
directories.Remove(deets.m_nPublishedFileId.m_PublishedFileId.ToString());
if (deets.m_nConsumerAppID.m_AppId == Main.SteamAppID && deets.m_eFileType == EWorkshopFileType.k_EWorkshopFileTypeCommunity)
{
DownloadLevel(deets.m_nPublishedFileId);
}
}
}
if (handle.m_unTotalMatchingResults > handle.m_unNumResultsReturned && handle.m_unNumResultsReturned != 0)
queryResult = QuerySubscribed();
else
{
//This whole ordeal deletes folders in here that are not currently-subscribed workshop maps.
foreach (var dir in directories)
{
Directory.Delete(Path.Combine(DownloadedMaps.FullName, dir), true);
}
}
}
private void OnEnable() {
if (SteamManager.Initialized) {
m_NumberOfCurrentPlayers = CallResult<NumberOfCurrentPlayers_t>.Create(OnNumberOfCurrentPlayers);
}
}
public static CallResult<SteamUGCQueryCompleted_t> GetCreatedWorkShopEntries(Action<IEnumerable<SteamUGCDetails_t>> onResult)
{
var query = SteamUGC.CreateQueryUserUGCRequest(SteamUser.GetSteamID().GetAccountID(),
EUserUGCList.k_EUserUGCList_Published, EUGCMatchingUGCType.k_EUGCMatchingUGCType_UsableInGame,
EUserUGCListSortOrder.k_EUserUGCListSortOrder_LastUpdatedDesc, new AppId_t(Main.SteamAppID), new AppId_t(Main.SteamAppID),
1);
var call = SteamUGC.SendQueryUGCRequest(query);
var callResult = new CallResult<SteamUGCQueryCompleted_t>((t, failure) =>
{
if (onResult == null)
return;
List<SteamUGCDetails_t> ret = new List<SteamUGCDetails_t>();
for (uint i = 0; i < t.m_unNumResultsReturned; i++)
{
var deets = new SteamUGCDetails_t();
if (SteamUGC.GetQueryUGCResult(t.m_handle, i, out deets))
{
if (deets.m_nConsumerAppID.m_AppId == Main.SteamAppID && deets.m_eFileType == EWorkshopFileType.k_EWorkshopFileTypeCommunity)
{
ret.Add(deets);
}
}
}
onResult(ret);
});
callResult.Set(call);
return callResult;
}
private static void OnSubscribed(RemoteStoragePublishedFileSubscribed_t subscribed)
{
if (!SteamInitialized) return;
//Because Steam can be an idiot sometimes!
if (subscribed.m_nAppID.m_AppId != Main.SteamAppID) return;
downloadLevelResult = DownloadLevel(subscribed.m_nPublishedFileId);
}
private static CallResult<SteamUGCQueryCompleted_t> QuerySubscribed()
{
ugcPage++;
var query = SteamUGC.CreateQueryUserUGCRequest(SteamUser.GetSteamID().GetAccountID(),
EUserUGCList.k_EUserUGCList_Subscribed, EUGCMatchingUGCType.k_EUGCMatchingUGCType_UsableInGame,
EUserUGCListSortOrder.k_EUserUGCListSortOrder_SubscriptionDateDesc, new AppId_t(Main.SteamAppID), new AppId_t(Main.SteamAppID),
ugcPage);
var call = SteamUGC.SendQueryUGCRequest(query);
var callResult = new CallResult<SteamUGCQueryCompleted_t>((t, failure) =>
{
OnUGCQueryReturn(t);
});
callResult.Set(call);
return callResult;
}
bool findArgs(CallResult callResult)
{
var block = callResult.block;
var method = callResult.getMethodReference();
var methodArgs = DotNetUtils.getParameters(method);
int numArgs = methodArgs.Count;
var args = new object[numArgs];
int instrIndex = callResult.callEndIndex - 1;
for (int i = numArgs - 1; i >= 0; i--) {
object arg = null;
if (!getArg(method, block, ref arg, ref instrIndex))
return false;
if (arg is int)
arg = fixIntArg(methodArgs[i].ParameterType, (int)arg);
args[i] = arg;
}
callResult.args = args;
callResult.callStartIndex = instrIndex + 1;
return true;
}
public Response(WebResponse response)
{
m_status_code = (int) ((HttpWebResponse)response).StatusCode;
m_status_desc = ((HttpWebResponse)response).StatusDescription;
// Get the response.
Stream dataStream;
dataStream = response.GetResponseStream ();
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader (dataStream);
// Read the content.
m_response_text = reader.ReadToEnd ();
// Clean up the streams.
reader.Close();
dataStream.Close();
if (m_status_code==200) {
m_json_response = (JsonObject) JsonConvert.Import(m_response_text);
if ((string)m_json_response["type"]=="jsonwsp/description") {
m_jsonwsp_type = JsonWspType.Description;
m_call_result = CallResult.Success;
}
if ((string)m_json_response["type"]=="jsonwsp/response") {
m_jsonwsp_type = JsonWspType.Response;
m_call_result = CallResult.Success;
}
if ((string)m_json_response["type"]=="jsonwsp/fault") {
m_jsonwsp_type = JsonWspType.Fault;
m_call_result = CallResult.ServiceFault;
JsonObject jsonwsp_fault = (JsonObject) m_json_response["fault"];
m_fault = new Fault(jsonwsp_fault);
}
}
else {
m_jsonwsp_type = JsonWspType.NoType;
m_call_result = CallResult.NetworkFault;
}
}
public void Sync(string uuid, int score = 0)
{
#if STEAMWORKS
this.CancelCallbacks();
if (!SteamWorker.SteamInitialized)
{
this.OnLeaderboardError.Execute();
return;
}
this.leaderboardFindCall = new CallResult<LeaderboardFindResult_t>((found, foundFailure) =>
{
this.leaderboardFindCall = null;
if (foundFailure)
this.OnLeaderboardError.Execute();
else
{
if (score > 0)
{
this.leaderboardUploadCall = new CallResult<LeaderboardScoreUploaded_t>(delegate(LeaderboardScoreUploaded_t uploaded, bool uploadedFailure)
{
this.leaderboardUploadCall = null;
if (uploadedFailure)
this.OnLeaderboardError.Execute();
else
this.download(found.m_hSteamLeaderboard);
});
this.leaderboardUploadCall.Set(SteamUserStats.UploadLeaderboardScore(found.m_hSteamLeaderboard, ELeaderboardUploadScoreMethod.k_ELeaderboardUploadScoreMethodKeepBest, score, new int[] {}, 0));
}
else
this.download(found.m_hSteamLeaderboard);
}
});
this.leaderboardFindCall.Set(SteamUserStats.FindOrCreateLeaderboard(uuid, ELeaderboardSortMethod.k_ELeaderboardSortMethodAscending, ELeaderboardDisplayType.k_ELeaderboardDisplayTypeTimeMilliSeconds));
#endif
}
bool FindArgs(CallResult callResult) {
var block = callResult.block;
var method = callResult.GetMethodRef();
var methodArgs = DotNetUtils.GetArgs(method);
int numArgs = methodArgs.Count;
var args = new object[numArgs];
int instrIndex = callResult.callEndIndex - 1;
for (int i = numArgs - 1; i >= 0; i--) {
object arg = null;
if (!GetArg(method, block, ref arg, ref instrIndex))
return false;
if (arg is int)
arg = FixIntArg(methodArgs[i], (int)arg);
else if (arg is long)
arg = FixIntArg(methodArgs[i], (long)arg);
args[i] = arg;
}
callResult.args = args;
callResult.callStartIndex = instrIndex + 1;
return true;
}
private void download(SteamLeaderboard_t leaderboard)
{
#if STEAMWORKS
this.globalLeaderboardDownloadCall = new CallResult<LeaderboardScoresDownloaded_t>((downloaded, downloadedFailure) =>
{
this.globalLeaderboardDownloadCall = null;
if (downloadedFailure)
this.OnLeaderboardError.Execute();
else
{
if (downloaded.m_cEntryCount == 0)
{
// We're not ranked
// Get the top global list
this.globalLeaderboardDownloadCall = new CallResult<LeaderboardScoresDownloaded_t>((downloaded2, downloadedFailure2) =>
{
if (downloadedFailure2)
this.OnLeaderboardError.Execute();
else
{
this.globalScoresDownloaded = true;
this.globalScores = downloaded2;
this.checkLeaderboardsDownloaded();
}
});
this.globalLeaderboardDownloadCall.Set(SteamUserStats.DownloadLeaderboardEntries(leaderboard, ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobal, 0, this.before + this.after));
}
else
{
this.globalScoresDownloaded = true;
this.globalScores = downloaded;
this.checkLeaderboardsDownloaded();
}
}
});
this.globalLeaderboardDownloadCall.Set(SteamUserStats.DownloadLeaderboardEntries(leaderboard, ELeaderboardDataRequest.k_ELeaderboardDataRequestGlobalAroundUser, -this.before, this.after));
this.friendLeaderboardDownloadCall = new CallResult<LeaderboardScoresDownloaded_t>((downloaded, downloadedFailure) =>
{
this.friendLeaderboardDownloadCall = null;
if (downloadedFailure)
this.OnLeaderboardError.Execute();
else
{
this.friendScoresDownloaded = true;
this.friendScores = downloaded;
this.checkLeaderboardsDownloaded();
}
});
this.friendLeaderboardDownloadCall.Set(SteamUserStats.DownloadLeaderboardEntries(leaderboard, ELeaderboardDataRequest.k_ELeaderboardDataRequestFriends, -this.friendsBefore, this.friendsAfter));
#endif
}
