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 }