public DelegateTask(InitializationHandler initialize, UpdateHandler update = null, SuccessHandler onSuccess = null, FailureHandler onFailure = null) { this.initialize = initialize; this.update = update ?? (() => true); /* * if (update != null) * this.update = update; * else * { * this.update = () => true; // = > * * this.update = () => * { * return true; * }; * * // this is the same as * * bool UpdateMethod() * { * return true; * } * * this.update = UpdateMethod; * }*/ this.onSuccess = onSuccess; this.onFailure = onFailure; }
public DelegateTask(InitializationHandler initialize, UpdateHandler update = null, SuccessHandler onSuccess = null, FailureHandler onFailure = null) { this.initialize = initialize; this.update = update ?? (() => true); if (update != null) { this.update = update; } else { this.update = () => true; // = > this.update = () => { return(true); }; // this is the same as bool UpdateMethod() { return(true); } this.update = UpdateMethod; } this.onSuccess = onSuccess; this.onFailure = onFailure; }
public static void FetchTournaments(SuccessHandler success, FriendlyErrorHandler failure) { fetchedTournamentsCallback = () => { success(); }; ArbiterBinding.FetchTournaments(FetchTournamentsSuccessHandler, failure); }
/// <summary> /// Loads data. /// </summary> /// <param name="success">Callback triggers on successful data load.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine LoadData(SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.loadData); www.OnSuccess += delegate { Hashtable result = www.result as Hashtable; if (result["data"] == null) { drDebug.LogWarning("No data exists in the data store to load"); return; } if (data == null) { data = new Dictionary<string, object>(); } StoreReturnData(result["data"] as Hashtable); drDebug.Log("Loaded data"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error loading data: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
public CallbackTuple(SuccessHandler success, ErrorHandler failure, FriendlyErrorHandler friendlyFailure, CodedErrorHandler codedFailure) { Success = success; Failure = failure; FriendlyFailure = friendlyFailure; CodedFailure = codedFailure; }
/// <summary> /// Awards an achievement. /// </summary> /// <param name="achievementName">The name of the achievement to award.</param> /// <param name="success">Callback triggers on successful award.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine AwardAchievement(string achievementName, SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.awardAchievement); www.AddField("name", achievementName); www.OnSuccess += delegate { if (!(bool)www.result) { // This should never occur, but the check is here just in case drDebug.LogWarning("Did not award achievement \"" + achievementName + "\""); return; } if (!_awardedAchievements.Contains(achievementName)) { _awardedAchievements.Add(achievementName); } drClient.RefreshCanvasComponent(drClient.CanvasComponent.Achievements); drDebug.Log("Awarded achievement " + achievementName); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error awarding achievement \"" + achievementName + "\": " + errorMessage); }; www.OnError += error; return www.Fetch(); }
public static void LoadTextureItem(string ID, SuccessHandler onSuccess, ErrorHandler onError, string directory = "") { if (TextureVault.Get(ID, directory)) { ID = TextureVault.GenerateIdentifier(ID); directory = TextureVault.GetDirectory(directory); string fileName = TextureVault.GetFilename(directory, ID); if (textureCache.ContainsKey(fileName)) { Touch(fileName); Debug.Log("From Cache " + fileName + " " + textureCache.Count); onSuccess(textureCache[fileName].texture); return; } byte[] data = File.ReadAllBytes(fileName); Texture2D texture2D = new Texture2D(2, 2); if (texture2D.LoadImage(data, true)) { textureCache.Add(fileName, new TextureVaultHistory(fileName, texture2D)); CleanupCache(); onSuccess(texture2D); return; } } onError(); }
public DelegateTask(InitializationHandler initialize, UpdateHandler update = null, SuccessHandler onSuccess = null, FailureHandler onFailure = null) { this.initialize = initialize; this.update = update ?? (() => true); this.onSuccess = onSuccess; this.onFailure = onFailure; }
public static void ShowUnviewedTournaments(SuccessHandler callback) { if (!UserExists) { Debug.LogWarning("Make sure user is logged in before showing their unviewed tournaments!"); return; } ArbiterBinding.ShowUnviewedTournaments(callback, defaultErrorHandler); }
public static void AcceptCashChallenge(string challengeId, SuccessHandler success, FriendlyErrorHandler failure) { SetCallbacksWithFriendlyErrors(ACCEPT_SCORE_CHALLENGE, success, failure); #if UNITY_EDITOR ReportIgnore("AcceptCashChallenge"); #elif UNITY_IOS _acceptCashChallenge(challengeId); #endif }
public static void ShowCashChallengeRules(string challengeId, SuccessHandler callback) { SetCallbacksWithErrors(SHOW_SCORE_CHALLENGE_RULES, callback, null); #if UNITY_EDITOR ReportIgnore("ShowCashChallengeRules"); #elif UNITY_IOS _showCashChallengeRules(challengeId); #endif }
public static void ShowWalkThrough(string walkThroughId, SuccessHandler callback) { SetCallbacksWithErrors(SHOW_WALK_THROUGH, callback, null); #if UNITY_EDITOR ReportIgnore("ShowWalkThrough"); #elif UNITY_IOS _showWalkThrough(walkThroughId); #endif }
private static void SetSimpleCallback(string key, SuccessHandler callback) { if (callback == null) { callback = () => {} } ; callbacks[key] = new CallbackTuple(callback, (e) => {}, (e, d) => {}); }
public void Publishes_to_multicast_handlers_with_interfaces_with_concrete_consumer() { var handler = new SuccessHandler(); var hub = new Hub(); hub.Subscribe(handler); hub.Publish(new InheritedEvent()); Assert.Equal(1, handler.Handled); }
public static void Logout(SuccessHandler success, ErrorHandler failure) { SetCallbacksWithErrors(LOGOUT, success, failure); #if UNITY_EDITOR ReportIgnore("Logout"); success(); #elif UNITY_IOS _logout(); #endif }
public static void ShowPreviousTournaments(SuccessHandler success, ErrorHandler failure) { SetCallbacksWithErrors(SHOW_PREIVOUS_TOURNAMENTS, success, failure); #if UNITY_EDITOR ReportIgnore("ViewPreviousTournaments"); success(); #elif UNITY_IOS _showPreviousTournaments(); #endif }
public static void ShowUnviewedTournaments(SuccessHandler success, ErrorHandler failure) { SetCallbacksWithErrors(SHOW_UNVIEWED_TOURNAMENTS, success, failure); #if UNITY_EDITOR ReportIgnore("ShowUnviewedTournaments"); success(); #elif UNITY_IOS _showUnviewedTournaments(); #endif }
public static void Init(string gameApiKey, string accessToken, SuccessHandler success, ErrorHandler failure) { SetCallbacksWithErrors(INIT, success, failure); #if UNITY_EDITOR ReportIgnore("Initialize"); success(); #elif UNITY_IOS _init(gameApiKey, accessToken); #endif }
private static void tryFetchWallet(SuccessHandler success, ErrorHandler failure) { if (!IsAuthenticated) { Debug.LogWarning("Cannot get an Arbiter Wallet without first logging in"); return; } ArbiterBinding.FetchWallet(success, failure); }
public static Habit AddLog(Habit h) { HabitResultHandler success = new SuccessHandler(new StreakSuccess()); HabitResultHandler fail = new FailHandler(new StreakFail()); h.Attach(success); h.Attach(fail); h.AddLogs(); return(h); }
public static void JoinTournament(string buyIn, Dictionary <string, string> filters, JoinTournamentCallback success, FriendlyErrorHandler failure) { Func <Tournament, bool> isScorableByCurrentUser = (tournament) => { return((tournament.Status == Tournament.StatusType.Initializing || tournament.Status == Tournament.StatusType.InProgress) && tournament.UserCanReportScore(user.Id)); }; TournamentsCallback gotTournamentsPollHelper = (tournaments) => { List <Tournament> joinableTournaments = tournaments.Where(iTourn => isScorableByCurrentUser(iTourn)).ToList(); if (joinableTournaments.Count > 0) { tournamentPoller.Stop(); success(joinableTournaments[0]); } // Else wait for the poller to call this anon func again... }; int retries = 0; const int MAX_RETRIES = 6; Action askAgain = () => { retries++; if (retries > MAX_RETRIES) { List <string> errors = new List <string>(); errors.Add("Tournament request limit exceeded. Ceasing new requests."); List <string> descriptions = new List <string>(); descriptions.Add("The tournament timed-out. Please try again later."); failure(errors, descriptions); tournamentPoller.Stop(); } else { ArbiterBinding.FetchTournaments(gotTournamentsPollHelper, failure); } }; SuccessHandler gotRequestResponse = () => { tournamentPoller.SetAction(askAgain); }; TournamentsCallback gotTournamentsFirstTimeHelper = (tournaments) => { List <Tournament> joinableTournaments = tournaments.Where(iTourn => isScorableByCurrentUser(iTourn)).ToList(); if (joinableTournaments.Count > 0) { success(joinableTournaments[0]); } else { RequestTournament(buyIn, filters, gotRequestResponse, failure); } }; ArbiterBinding.FetchTournaments(gotTournamentsFirstTimeHelper, failure); }
public static void ShowNativeDialog(string title, string message, SuccessHandler callback) { SetSimpleCallback(SHOW_NATIVE_DIALOG, callback); #if UNITY_EDITOR callback(); #elif UNITY_IOS _showNativeDialog(title, message); #else throw new PlatformNotSupportedException(); #endif }
public void Handlers_can_return_true_safely() { var handler = new SuccessHandler(); var hub = new Hub(); hub.Subscribe(handler); bool result = hub.Publish(new InheritedEvent()); Assert.Equal(1, handler.Handled); Assert.True(result); }
public async Task <Response> Handle(UpdateChosenDrink command) { var request = new UpdatePartyGuestRequest { Id = command.Id, ChosenDrinkId = command.ChosenDrinkId }; await _dataProvider.UpdatePartyGuest(request); return(SuccessHandler.ReturnUpdateSuccess(EntityName)); }
public async Task <Response> Handle(UpdateLocation command) { var request = new UpdatePartyRequest() { Id = command.Id, Location = command.Location }; await _dataProvider.UpdateParty(request); return(SuccessHandler.ReturnUpdateSuccess(EntityName)); }
public async Task <Response> Handle(UpdateFavouriteDrink command) { var request = new UpdatePersonRequest() { Id = command.Id, FavouriteDrinkId = command.FavouriteDrinkId }; await _dataProvider.UpdatePerson(request); return(SuccessHandler.ReturnUpdateSuccess(EntityName)); }
public async Task <Response> Handle(UpdateVipStatus command) { var request = new UpdatePartyGuestRequest { Id = command.Id, IsVIP = command.IsVip }; await _dataProvider.UpdatePartyGuest(request); return(SuccessHandler.ReturnUpdateSuccess(EntityName)); }
public static void FetchWallet(SuccessHandler success, ErrorHandler failure) { callbacks[FETCH_WALLET] = new CallbackTuple(success, failure, (e, d) => {}); #if UNITY_EDITOR ReportIgnore("FetchWallet"); Arbiter.wallet = new Wallet(); Arbiter.wallet.Balance = "12345"; success(); #elif UNITY_IOS _fetchWallet(); #endif }
public async Task <Response> Handle(UpdateEmail command) { var request = new UpdatePersonRequest() { Id = command.Id, Email = command.Email }; await _dataProvider.UpdatePerson(request); return(SuccessHandler.ReturnUpdateSuccess(EntityName)); }
public static void RejectCashChallenge(string challengeId, SuccessHandler callback) { SetSimpleCallback(REJECT_SCORE_CHALLENGE, callback); #if UNITY_EDITOR ReportIgnore("RejectCashChallenge"); if (callback != null) { callback(); } #elif UNITY_IOS _rejectCashChallenge(challengeId); #endif }
public static void SendPromoCredits(string amount, SuccessHandler success, ErrorHandler failure) { SetCallbacksWithErrors(SEND_PROMO_CREDITS, success, failure); #if UNITY_EDITOR ReportIgnore("SendPromoCredits"); if (success != null) { success(); } #elif UNITY_IOS _sendPromoCredits(amount); #endif }
public static void ShowTournamentDetailsPanel(string tournamentId, SuccessHandler callback) { SetSimpleCallback(SHOW_TOURNAMENT_PANEL, callback); #if UNITY_EDITOR ReportIgnore("ShowTournamentDetailsPanel"); if (callback != null) { callback(); } #elif UNITY_IOS _showTournamentDetailsPanel(tournamentId); #endif }
public void Get(string url, IDictionary<string, string> parameters, string expectedDataType, SuccessHandler onSuccess, ErrorHandler onError) { StringBuilder sb = new StringBuilder(); foreach (string k in parameters.Keys) { if (sb.Length > 0) sb.Append('&'); sb.Append(HttpUtility.UrlEncode(k + "=" + parameters[k])); } string u2; if (url.IndexOf('?') > 0) u2 = url + "&" + sb.ToString(); else u2 = url + "?" + sb.ToString(); HttpWebRequest wrq = (HttpWebRequest) HttpWebRequest.Create(u2); HttpWebResponse resp = (HttpWebResponse) wrq.GetResponse(); WebClient wc = new WebClient(); }
/// <summary> /// Submits a score to the leaderboard. /// </summary> /// <param name="score">The player's score.</param> /// <param name="success">Callback triggers on successful score submission.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine SubmitScore(int score, SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.submitScore); www.AddField("score", score); www.OnSuccess += delegate { if (!(bool)www.result) { drDebug.LogWarning("Score not recorded; it did not beat the user's current high score"); return; } drClient.RefreshCanvasComponent(drClient.CanvasComponent.Leaderboard); drClient.RefreshCanvasComponent(drClient.CanvasComponent.ActivityFeed); drDebug.Log("Submitted new score"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error submitting score: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// FeFetches the user's awarded achievements. /// </summary> /// <param name="success">Callback triggers on successful fetch.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine FetchAchievements(SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.fetchAchievements); www.OnSuccess += delegate { Hashtable result = www.result as Hashtable; Hashtable achievements = result["achievements"] as Hashtable; ArrayList awarded = achievements["awarded"] as ArrayList; ArrayList unawarded = achievements["unawarded"] as ArrayList; _awardedAchievements = new List<string>(); foreach (Hashtable achievement in awarded) { _awardedAchievements.Add(achievement["name"] as string); } drDebug.Log("Fetched " + awarded.Count + " awarded achievements of " + (awarded.Count + unawarded.Count) + " total"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error fetching achievements: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Fetches the server time. /// </summary> /// <param name="success">Callback triggers on successful time fetch.</param> public static Coroutine FetchServerTime(SuccessHandler success) { return FetchServerTime(success, null); }
/// <summary> /// Fetches the items in the inventory. /// </summary> /// <param name="success">Callback triggers on successful fetch.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine FetchItems(SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.fetchItems); www.OnSuccess += delegate { Hashtable result = www.result as Hashtable; _inventory = new List<Item>(); foreach (Hashtable item in result["items"] as ArrayList) { _inventory.Add(new Item(item)); } drDebug.Log("Fetched " + inventory.Length + " inventory items"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error fetching items: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Fetches the items in the inventory. /// </summary> /// <param name="success">Callback triggers on successful fetch.</param> public static Coroutine FetchItems(SuccessHandler success) { return FetchItems(success, null); }
/// <summary> /// Removes an item from the inventory. A common use for this is consumable items (health packs, powerups, etc.) that get used up. /// </summary> /// <param name="itemName">The name of the item.</param> /// <param name="quantity">The quantity of the item to remove.</param> /// <param name="success">Callback triggers on successful remove.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine RemoveItem(string itemName, int quantity, SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.removeItem); www.AddField("name", itemName); www.AddField("quantity", quantity); www.OnSuccess += delegate { if (!(bool)www.result) { drDebug.LogWarning("Item " + itemName + " not removed from inventory"); return; } Item itemToRemove = GetItem(itemName); if (itemToRemove == null) { drDebug.LogWarning("Item " + itemName + " is not contained in your inventory"); return; } itemToRemove.quantity -= quantity; if (itemToRemove.quantity < 0) { drDebug.LogWarning("Item " + itemName + " has a quantity less than " + quantity); } // Remove the item entirely if its quantity is zero if (itemToRemove.quantity <= 0) { _inventory.Remove(itemToRemove); } drClient.RefreshCanvasComponent(drClient.CanvasComponent.Inventory); drDebug.Log("Item " + itemName + " removed from inventory"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error removing item: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Fetches the user's awarded achievements. /// </summary> /// <param name="success">Callback triggers on successful fetch.</param> public static Coroutine FetchAchievements(SuccessHandler success) { return FetchAchievements(success, null); }
static IEnumerator SendCoroutine(string method, Dictionary<string, object> parameters, SuccessHandler successCallback, ErrorHandler errorCallback) { yield break; }
/// <summary> /// Loads data. /// </summary> /// <param name="success">Callback triggers on successful data load.</param> public static Coroutine LoadData(SuccessHandler success) { return LoadData(success, null); }
/// <summary> /// Saves data. /// </summary /// <param name="data">The data to save.</param> /// <param name="success">Callback triggers on successful data save.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine SaveData(Hashtable data, SuccessHandler success, ErrorHandler error) { string json = JSON.JsonEncode(data); drWWW www = new drWWW(drAPI.saveData); www.AddField("data", json); www.OnSuccess += delegate { if (!(bool)www.result) { drDebug.LogWarning("No data saved"); return; } StoreReturnData(data); drDebug.Log("Data saved"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error saving data: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Saves data with the specified key. /// </summary /// <param name="key">The key to save the data by.</param> /// <param name="data">The data to save.</param> /// <param name="success">Callback triggers on successful data save.</param> public static Coroutine SaveDataByKey(string key, object data, SuccessHandler success) { return SaveDataByKey(key, data, success, null); }
/// <summary> /// Submits an item to the activity feed. /// </summary> /// <param name="message">The text to display (140 character maximum).</param> /// <param name="success">Callback triggers on successful activity feed submission.</param> public static Coroutine SubmitActivity(string message, SuccessHandler success) { return SubmitActivity(message, success, null); }
/// <summary> /// Sends data to Lumos' servers. /// </summary> /// <param name="successCallback">Callback to run on successful response.</param> /// <param name="errorCallback">Callback to run on failed response.</param> static IEnumerator SendCoroutine(string method, Dictionary<string, object> parameters, SuccessHandler successCallback, ErrorHandler errorCallback) { if (Application.isEditor && !Lumos.instance.runInEditor) { yield break; } // Skip out early if there's no internet connection if (Application.internetReachability == NetworkReachability.NotReachable) { if (errorCallback != null) { errorCallback(); } yield break; } // Generate request parameters.Add("app_id", Lumos.appId); var json = LumosUtil.Json.Serialize(parameters); //var json = LitJson.JsonMapper.ToJson(parameters); var postData = Encoding.ASCII.GetBytes(json); var www = new WWW(url + method, postData, headers); // Send info to server yield return www; Lumos.Log("Request: " + json); Lumos.Log("Response: " + www.text); // Parse the response try { if (www.error != null) { throw new Exception(www.error); } var response = LumosUtil.Json.Deserialize(www.text) as IDictionary; lastResponse = response; // Display returned info if there is any if (response.Count != 0 && response.Contains("result")) { var result = response["result"]; Lumos.Log("Success: " + result); } if (successCallback != null) { successCallback(); } } catch (Exception e) { Lumos.LogError("Failure: " + e.Message); if (errorCallback != null) { errorCallback(); } } }
/// <summary> /// Sends data to Lumos' servers. /// </summary> /// <param name="successCallback">Callback to run on successful response.</param> /// <param name="errorCallback">Callback to run on failed response.</param> public static Coroutine Send(string method, Dictionary<string, object> parameters, SuccessHandler successCallback, ErrorHandler errorCallback) { return Lumos.RunRoutine(SendCoroutine(method, parameters, successCallback, errorCallback)); }
/// <summary> /// Fetches the server time. /// </summary> /// <param name="success">Callback triggers on successful session fetch.</param> public static Coroutine FetchSession(SuccessHandler success) { return FetchSession(success, null); }
/// <summary> /// Loads data with the specified key. /// </summary> /// <param name="key">The key to load the data by.</param> /// <param name="success">Callback triggers on successful data load.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine LoadDataByKey(string key, SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.loadDataByKey); www.AddField("key", key); www.OnSuccess += delegate { Hashtable result = www.result as Hashtable; if (result["data"] == null) { drDebug.LogWarning("No data with key " + key + " exists in the data store to load"); return; } StoreReturnData(result["data"] as Hashtable); drDebug.Log("Loaded data with key " + key); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error loading data with key " + key + ": " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Fetches the server time. /// </summary> /// <param name="success">Callback triggers on successful session fetch.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine FetchSession(SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.fetchSession); www.OnSuccess += delegate { Hashtable result = www.result as Hashtable; drClient.sessionId = result["_token"].ToString(); drDebug.Log("Fetched session " + drClient.sessionId); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error fetching session: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Saves data with the specified key. /// </summary /// <param name="key">The key to save the data by.</param> /// <param name="data">The data to save.</param> /// <param name="success">Callback triggers on successful data save.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine SaveDataByKey(string key, object data, SuccessHandler success, ErrorHandler error) { Hashtable dataTable = new Hashtable(); dataTable.Add("key", key); dataTable.Add("value", data); string json = JSON.JsonEncode(dataTable); drWWW www = new drWWW(drAPI.saveDataByKey); www.AddField("data", json); www.OnSuccess += delegate { if (!(bool)www.result) { drDebug.LogWarning("No data saved with key " + key); return; } Hashtable toSave = new Hashtable(); toSave.Add(key, data); StoreReturnData(toSave); drDebug.Log("Saved data with key " + key); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error saving data: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Submits an item to the activity feed. /// </summary> /// <param name="message">The text to display (140 character maximum).</param> /// <param name="success">Callback triggers on successful activity feed submission.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine SubmitActivity(string message, SuccessHandler success, ErrorHandler error) { if (message == null || message == "") { drDebug.LogWarning("Message not submitted to activity feed: a null or empty message was supplied"); return null; } else if (message.Length > 140) { drDebug.LogWarning("Message not submitted to activity feed: amessage have to be less than or equal to 140 characters"); return null; } drWWW www = new drWWW(drAPI.addCustomActivity); www.AddField("message", message); www.OnSuccess += delegate { if (!(bool)www.result) { // This should never occur, but the check is here just in case drDebug.LogWarning("Message not submitted to activity feed"); return; } drClient.RefreshCanvasComponent(drClient.CanvasComponent.ActivityFeed); drDebug.Log("Message submitted to activity feed"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error submitting to activity feed: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Submits a score to the leaderboard. /// </summary> /// <param name="score">The player's score.</param> /// <param name="success">Callback triggers on successful score submission.</param> public static Coroutine SubmitScore(int score, SuccessHandler success) { return SubmitScore(score, success, null); }
/// <summary> /// Fetches the server time. /// </summary> /// <param name="success">Callback triggers on successful time fetch.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine FetchServerTime(SuccessHandler success, ErrorHandler error) { drWWW www = new drWWW(drAPI.fetchServerTime); www.OnSuccess += delegate { serverTimeAtLastFetch = drUtil.ConvertFromUnixTimestamp((double)www.result); timeFetched = System.DateTime.Now; drDebug.Log("Fetched time from server"); }; www.OnSuccess += success; www.OnError += delegate (string errorMessage) { drDebug.LogError("Error fetching server time: " + errorMessage); }; www.OnError += error; return www.Fetch(); }
/// <summary> /// Saves data. /// </summary /// <param name="data">The data to save.</param> /// <param name="success">Callback triggers on successful data save.</param> public static Coroutine SaveData(Hashtable data, SuccessHandler success) { return SaveData(data, success, null); }
/// <summary> /// Removes an item from the inventory. A common use for this is consumable items (health packs, powerups, etc.) that get used up. /// </summary> /// <param name="itemName">The name of the item.</param> /// <param name="quantity">The quantity of the item to remove.</param> /// <param name="success">Callback triggers on successful remove.</param> public static Coroutine RemoveItem(string itemName, int quantity, SuccessHandler success) { return RemoveItem(itemName, quantity, success, null); }
/// <summary> /// Loads data with the specified key. /// </summary> /// <param name="key">The key to load the data by.</param> /// <param name="success">Callback triggers on successful data load.</param> public static Coroutine LoadDataByKey(string key, SuccessHandler success) { return LoadDataByKey(key, success, null); }
/// <summary> /// Removes an item from the inventory. A common use for this is consumable items (health packs, powerups, etc.) that get used up. /// </summary> /// <param name="itemName">The name of the item.</param> /// <param name="success">Callback triggers on successful remove.</param> /// <param name="error">Callback triggers on error.</param> public static Coroutine RemoveItem(string itemName, SuccessHandler success, ErrorHandler error) { return RemoveItem(itemName, 1, success, null); }
public void Post(string url, IDictionary<string, string> parameters, string expectedDataType, SuccessHandler onSuccess, ErrorHandler onError) { }
/// <summary> /// Awards an achievement. /// </summary> /// <param name="achievementName">The name of the achievement to award.</param> /// <param name="success">Callback triggers on successful award.</param> public static Coroutine AwardAchievement(string achievementName, SuccessHandler success) { return AwardAchievement(achievementName, success, null); }