protected void bindPreloading(List <FlooredAdProvider> placements) { if (placements.Count != 0) { ReactiveProperty <bool> highestFloorHasAd = placements.First().AdsReady; ReadOnlyReactiveProperty <long> source = (from r in highestFloorHasAd where !r select r into _ select ServerTimeService.NowTicks()).ToReadOnlyReactiveProperty(); UniRx.IObservable <long> source2 = (from _ in source select Observable.Return(0L).Concat(Observable.Interval(TimeSpan.FromSeconds(preloadNotAvailableWaitingPeriod))).TakeUntil(from r in highestFloorHasAd where r select r)).Switch(); FlooredAdProvider backFiller = placements.Last(); (from _ in source2 where !backFiller.AdsReady.Value select _).Subscribe(delegate { preload(backFiller); }).AddTo(_disposable); FlooredAdProvider[] flooredPlacements = (from p in placements where p != backFiller select p).ToArray(); if (flooredPlacements.Length > 0) { (from _ in source2 select(from p in flooredPlacements select UniRx.Tuple.Create(p, flooredPlacements.TakeWhile((FlooredAdProvider pr) => pr != p))).ToObservable().SelectMany((UniRx.Tuple <FlooredAdProvider, IEnumerable <FlooredAdProvider> > pair) => Observable.Return(pair).Delay(TimeSpan.FromSeconds(waitTimeForTheNextProvider * pair.Item2.Count())).SelectMany((UniRx.Tuple <FlooredAdProvider, IEnumerable <FlooredAdProvider> > p) => Observable.Return(p).TakeUntil(previousOrMeGotReady(pair.Item1, pair.Item2))))).Switch().Subscribe(delegate(UniRx.Tuple <FlooredAdProvider, IEnumerable <FlooredAdProvider> > p) { preload(p.Item1); }).AddTo(_disposable); } } }
private void GetClosestTournamentDay() { List <DayOfWeek> list = new List <DayOfWeek>(); for (int i = 0; i < PersistentSingleton <GameSettings> .Instance.TournamentDays.Count; i++) { if (Enum.IsDefined(typeof(DayOfWeek), PersistentSingleton <GameSettings> .Instance.TournamentDays[i])) { list.Add((DayOfWeek)Enum.Parse(typeof(DayOfWeek), PersistentSingleton <GameSettings> .Instance.TournamentDays[i], ignoreCase: true)); } } m_closestTournamentDay = int.MaxValue; int num = m_closestTournamentDay; for (int j = 0; j < list.Count; j++) { int num2 = list[j] - ServerTimeService.UtcNow().DayOfWeek + ((ServerTimeService.UtcNow().DayOfWeek > list[j]) ? 7 : 0); if (num2 < m_closestTournamentDay) { num = ((num != m_closestTournamentDay) ? m_closestTournamentDay : (num2 + 7)); m_closestTournamentDay = num2; } } if (CheckIfDifferentDevice() && PlayerData.Instance.TournamentTimeStamp.Value + 10000000L * (long)PersistentSingleton <GameSettings> .Instance.TournamentDurationSeconds > ServerTimeService.NowTicks()) { m_closestTournamentDay = num; } }
private List <Message> GenerateLocalNotifications() { List <Message> list = new List <Message>(); List <Message> bundleNotifications = BundleNotifications; foreach (Message item in bundleNotifications) { TimeSpan timeSpan = item.Delay - TimeSpan.FromTicks(ServerTimeService.NowTicks()); if (timeSpan > TimeSpan.FromMinutes(10.0)) { list.Add(new Message(timeSpan, item.Text)); } } list.AddRange(WelcomeBackNotifications); List <Message> collection = CreateDrillNotifications(); list.AddRange(collection); List <Message> collection2 = CreateFortunePodsNotification(); list.AddRange(collection2); List <Message> collection3 = CreateTournamentNotifications(); list.AddRange(collection3); List <Message> collection4 = CreateRetentionNotifications(); list.AddRange(collection4); return(list); }
public TimeSpan GetNextTimeToShowAd(AdPlacement adPlacement) { List <AdHistory> adsWatched24H = PlayerData.Instance.GetAdsWatched24H(); AdFrequencyConfig adFrequencyConfig = PersistentSingleton <Economies> .Instance.AdFrequencies.Find((AdFrequencyConfig s) => s.Placement == adPlacement); double num = (from adh in adsWatched24H where adh.Placement == adPlacement select adh into ad select TimeSpan.FromTicks(ServerTimeService.NowTicks() - ad.TimeStamp).TotalSeconds).LastOrDefault(); if (num == 0.0) { return(TimeSpan.Zero); } int num2 = adsWatched24H.Count((AdHistory s) => s.Placement == adPlacement); if (num2 < adFrequencyConfig.DailyCap) { return(TimeSpan.FromSeconds((double)(adFrequencyConfig.Cooldown * 60) - num)); } double num3 = (from adh in adsWatched24H.ToList() where adh.Placement == adPlacement select adh into ad select TimeSpan.FromTicks(ServerTimeService.NowTicks() - ad.TimeStamp).TotalMinutes).FirstOrDefault(); return(TimeSpan.FromMinutes(1440.0 - num3)); }
private IEnumerator LoadMainSceneWithDelay() { yield return(new WaitForSeconds(1f)); PlayerData.Instance.WelcomebackTimeStamp.Value = ServerTimeService.NowTicks(); SceneLoadHelper.LoadMainScene(); }
public void SaveTournamentRuns(List <LeaderboardEntry> entries, int tournamentID) { JSONObject jSONObject = new JSONObject(JSONObject.Type.OBJECT); JSONObject jSONObject2 = new JSONObject(JSONObject.Type.OBJECT); jSONObject2.AddField("Date", (int)TimeSpan.FromTicks(ServerTimeService.NowTicks()).TotalDays); jSONObject.Add(jSONObject2); for (int i = 0; i < entries.Count; i++) { JSONObject jSONObject3 = new JSONObject(JSONObject.Type.OBJECT); jSONObject3.AddField("PlayerId", entries[i].PlayerId.Value); jSONObject3.AddField("DisplayName", entries[i].DisplayName.Value); jSONObject3.AddField("Variation", UnityEngine.Random.Range(0, PersistentSingleton <GameSettings> .Instance.TournamentVariationSeconds)); for (int j = 0; j < entries[i].Tags.Value.Count; j++) { string a = entries[i].Tags.Value[j].Substring(7 + PersistentSingleton <GameSettings> .Instance.PlayFabTitleId.Length, 2); if (a == "CC") { jSONObject3.AddField("Region", entries[i].Tags.Value[j].Substring(9 + PersistentSingleton <GameSettings> .Instance.PlayFabTitleId.Length, entries[i].Tags.Value[j].Length - (9 + PersistentSingleton <GameSettings> .Instance.PlayFabTitleId.Length))); } else if (a == "T" + tournamentID) { jSONObject3.AddField("Run", entries[i].Tags.Value[j].Substring(9 + PersistentSingleton <GameSettings> .Instance.PlayFabTitleId.Length, entries[i].Tags.Value[j].Length - (9 + PersistentSingleton <GameSettings> .Instance.PlayFabTitleId.Length))); } } jSONObject.Add(jSONObject3); } SaveTournamentRuns(jSONObject); }
public void PostInit() { SceneLoader instance = SceneLoader.Instance; (from chunk in (from prestiges in PlayerData.Instance.LifetimePrestiges select(prestiges != 0) ? Observable.Never <int>() : PlayerData.Instance.MainChunk.AsObservable()).Switch().Pairwise() where chunk.Current == 17 && chunk.Previous == 16 select chunk).Subscribe(delegate { SetNewBundle(); ShowOfferPopup.SetValueAndForceNotify(value: true); }).AddTo(instance); (from current in PlayerData.Instance.CurrentBundleEnum where current >= -1 select current).Subscribe(delegate(int num) { InitializeBundleRunner(num); }).AddTo(instance); (from iap in Singleton <IAPRunner> .Instance.IAPCompleted where iap.Config.Type == IAPType.BundleConsumable || iap.Config.Type == IAPType.BundleDurable select iap).Subscribe(delegate { PlayerData.Instance.LifetimeBundles.Value++; PlayerData.Instance.BundleTimeStamp.Value = ServerTimeService.NowTicks(); PlayerData.Instance.CurrentBundleEnum.Value = -1; PlayerData.Instance.CurrentBundleGearIndex.Value = -1; SecondsLeft.Value = 0; }).AddTo(instance); }
public List <AdHistory> GetAdsWatched24H() { long yesterday = ServerTimeService.NowTicks() - TimeSpan.FromHours(24.0).Ticks; return((from adh in AdsWatched.ToList() where adh.TimeStamp >= yesterday select adh).ToList()); }
public void CreateNewData(BaseData data) { JSONObject j = new JSONObject(); PlayerDataLoader.Instance().FillBaseData(j, data); data.SetupNewData(ServerTimeService.NowTicks()); Save(data, "Initial"); }
public long TicksSinceLastSave() { if (PlayerData.Instance.LastSaved > 0) { return(new TimeSpan(ServerTimeService.NowTicks() - PlayerData.Instance.LastSaved).Ticks); } return(0L); }
public void SetBundleIAP(int bundleNum) { List <BundleTierConfig> bundleTiers = PersistentSingleton <Economies> .Instance.BundleTiers; PlayerData.Instance.BundleTimeStamp.Value = ServerTimeService.NowTicks(); PlayerData.Instance.CurrentBundleEnum.SetValueAndForceNotify((int)bundleTiers[bundleNum].ProductEnum); PlayerData.Instance.CurrentBundleGearIndex.Value = 0; }
public void ActivateSkill() { if (!Active.Value) { m_skillState.ElapsedTime.Value = 0L; m_skillState.CooldownTimeStamp.Value = ServerTimeService.NowTicks() + TimeSpan.FromSeconds(MaxDuration.Value).Ticks; m_skillState.LifetimeUsed.Value++; } }
private void LoadTournamentEndedValues() { if (TournamentRuns.Value == null) { TournamentRuns.SetValueAndForceNotify(LoadTournamentRuns()); } PlayerData.Instance.TournamentLastPointOnline.Value = ServerTimeService.NowTicks() - PlayerData.Instance.TournamentTimeStamp.Value; UpdateTournamentLeaderboard(); }
public void UpdateCooldown() { if (ServerTimeService.NowTicks() - m_skillState.CooldownTimeStamp.Value < 0) { m_skillState.CooldownTimeStamp.Value = ServerTimeService.NowTicks(); } int b = m_skillConfig.CoolDownSeconds - (int)TimeSpan.FromTicks(ServerTimeService.NowTicks() - m_skillState.CooldownTimeStamp.Value).TotalSeconds; CooldownSeconds.Value = Mathf.Max(0, b); }
public void Save(BaseData baseData, string reason) { JSONObject jSONObject = DataToJSON(baseData); jSONObject.SetField("AppVersion", Application.version); jSONObject.SetField("LastSaved", ServerTimeService.NowTicks()); jSONObject.SetField("LastSavedBy", reason); baseData.LastSaved = ServerTimeService.NowTicks(); baseData.LastSavedBy = reason; Save(jSONObject); PersistentSingleton <FacebookAPIService> .Instance.SaveFBData(); }
protected UniRx.IObservable <long> beginningsOfLoadingCycle(UniRx.IObservable <bool> adReadies) { ReadOnlyReactiveProperty <long> source = (from r in adReadies where !r select r into _ select ServerTimeService.NowTicks()).ToReadOnlyReactiveProperty(); return((from _ in source select Observable.Return(0L).Concat(Observable.Interval(TimeSpan.FromSeconds(preloadNotAvailableWaitingPeriod))).TakeUntil(from r in adReadies where r select r)).Switch()); }
public void DebugSaveTo(BaseData data, string filename, string reason) { data.LastSaved = ServerTimeService.NowTicks(); data.LastSavedBy = reason; try { File.WriteAllText(PersistentDataPath.Get() + filename, Encryptor.Encrypt(DataToJSON(data).ToString())); } catch (IOException) { ShowDiskFullDialog(); } }
private void DrillAdFinished() { if (PlayerData.Instance.DrillTimeStamp.Value == 0) { PlayerData.Instance.DrillTimeStamp.Value = ServerTimeService.NowTicks(); } long num = Math.Max(PlayerData.Instance.DrillTimeStamp.Value - ServerTimeService.NowTicks(), 0L); PlayerData.Instance.DrillTimeStamp.Value = ServerTimeService.NowTicks() + num + TimeSpan.FromSeconds(PersistentSingleton <GameSettings> .Instance.DrillDuration).Ticks; PlayerData.Instance.DrillLevel.Value++; UpdateTimer.SetValueAndForceNotify(value: true); BindingManager.Instance.DrillSuccessParent.ShowInfo(); }
private void TryToFetchTournament() { List <TournamentRunStruct> list = LoadTournamentRuns(); if (TotalDaysSinceStart.Value == (int)TimeSpan.FromTicks(ServerTimeService.NowTicks()).TotalDays&& list != null) { TournamentFetched.SetValueAndForceNotify(value: true); } else if (LoggedInPlayfab.Value) { FetchTournamentRuns(); } }
private long GetTimeTillTournament() { GetClosestTournamentDay(); if (m_closestTournamentDay == 0) { return(0L); } DateTime d = ServerTimeService.UtcNow(); DateTime d2 = ServerTimeService.UtcNow().Date.AddDays(m_closestTournamentDay); long val = (long)(d2 - d).TotalSeconds; return(Math.Max(0L, val)); }
private static IEnumerator TickRoutine(Subject <long> subject, float interval, float maxInterval) { long time = ServerTimeService.NowTicks(); while (true) { yield return(new WaitForSeconds(interval)); long delta = ServerTimeService.NowTicks() - time; long t = Math.Max(0L, Math.Min(delta, (long)maxInterval * 10000000)); subject.OnNext(t); time = ServerTimeService.NowTicks(); } }
public void PleaseSave(string reason, bool cloud = true) { Saving.OnNext(value: true); PersistentSingleton <SaveLoad> .Instance.Save(PlayerData.Instance, reason); if (ServerTimeService.NowTicks() - m_lastCallTime >= 20000000) { m_lastCallTime = ServerTimeService.NowTicks(); if (Singleton <CloudSyncRunner> .Instance != null) { Singleton <CloudSyncRunner> .Instance.CloudSync(reason); } } }
private void UpdateTournamentRun() { PlayerData.Instance.TournamentLastPointOnline.Value = ServerTimeService.NowTicks() - PlayerData.Instance.TournamentTimeStamp.Value; if (PlayerData.Instance.TournamentLastPointOnline.Value < PlayerData.Instance.TournamentTimeStamp.Value + 10000000L * (long)PersistentSingleton <GameSettings> .Instance.TournamentDurationSeconds) { short[] value = PlayerData.Instance.TournamentRun.Value; for (int i = GetNextPoint(TimeSpan.FromTicks(PlayerData.Instance.TournamentLastPointOnline.Value).TotalSeconds); i < value.Length; i++) { if ((short)PlayerData.Instance.MainChunk.Value > value[i]) { value[i] = (short)PlayerData.Instance.MainChunk.Value; } } PlayerData.Instance.TournamentRun.Value = value; } UpdateTournamentLeaderboard(); }
private List <Message> CreateDrillNotifications() { List <Message> list = new List <Message>(); List <string> list2 = new List <string>(); TimeSpan delay = TimeSpan.FromSeconds(0.0); if (PlayerData.Instance.DrillTimeStamp.Value > 0) { delay = TimeSpan.FromTicks(PlayerData.Instance.DrillTimeStamp.Value - ServerTimeService.NowTicks()); } for (int i = 1; i <= 4; i++) { list2.Add(PersistentSingleton <LocalizationService> .Instance.Text("LocalNotification.Drill.Notif" + i)); } if (list2.Count != 0 && delay.TotalSeconds > 1.0) { list.Add(new Message(delay, list2[UnityEngine.Random.Range(0, list2.Count)])); } return(list); }
private static IEnumerator ResetGameRoutine() { SceneManager.LoadScene("Empty"); yield return(null); PersistentSingleton <SaveLoad> .Instance.DebugResetData(PlayerData.Instance); ServerTimeService.ResetDebug(); MainInstaller.ReleaseAll(); PersistentSingleton <StringCache> .Instance.Clear(); yield return(null); Resources.UnloadUnusedAssets(); GC.Collect(); GC.WaitForPendingFinalizers(); yield return(null); LoadInitSceneNow(); }
public void StartUp() { if (!base.Inited) { newSession = from _ in PlayerData.Instance.SessionNumber.Skip(1) select true; appComesForeground = from q in (from p in Observable.EveryApplicationPause() where !p select p).Merge(Observable.Return(value: false)).DelayFrame(1) select !q; newUser = from sessionNumber in PlayerData.Instance.SessionNumber.Skip(1) select sessionNumber == 0; (from _ in appComesForeground select new TimeSpan(ServerTimeService.NowTicks() - PlayerData.Instance.LastSaved).TotalSeconds into awaySecs where awaySecs >= 600.0 || PlayerData.Instance.SessionNumber.Value == -1 select awaySecs).Subscribe(delegate { SessionWillStart(); }); base.Inited = true; } }
private void SessionWillStart() { if (PlayerData.Instance.SessionNumber.Value == -1) { SendNewUserEvents(); } PlayerData instance = PlayerData.Instance; long num = ServerTimeService.NowTicks(); int num2 = (int)new TimeSpan(num - instance.InstallTime).TotalDays; int num3 = (int)new TimeSpan(num - instance.LastSaved).TotalDays; int hours = new TimeSpan(num - instance.LastSaved).Hours; int num4 = Math.Max(0, (int)new TimeSpan(instance.LastSaved - instance.LastSessionStart.Value).TotalMinutes); instance.MinutesInGame += num4; instance.LastSessionStart.Value = num; instance.SumOfPreviousSessionTimes.Value += Math.Max(0L, new TimeSpan(instance.LastSaved - instance.LastSessionStart.Value).Ticks); if (num2 > instance.DaysRetained.Value) { instance.DaysRetained.Value = num2; SendAppleWatchEventIfOwned(); } instance.SessionNumber.Value++; }
public void UploadSaveToCloud(PlayerData playerData, string reason, Action <JSONObject> callback, Action <string> errorCallback) { long time = ServerTimeService.NowTicks(); JSONObject jSONObject = PersistentSingleton <SaveLoad> .Instance.DataToJSON(playerData); jSONObject.SetField("LastSavedToCloud", time); Dictionary <string, JSONObject> dictionary = new Dictionary <string, JSONObject>(); dictionary.Add("Base", jSONObject); Dictionary <string, JSONObject> saveData = dictionary; Dictionary <string, int> stats = CreateStatistics(playerData); Action <JSONObject> callback2 = delegate(JSONObject json) { playerData.LastSavedToCloud.Value = time; PersistentSingleton <SaveLoad> .Instance.Save(playerData, reason); if (callback != null) { callback(json); } }; PersistentSingleton <PlayFabService> .Instance.UpdatePlayerData(saveData, stats, 4L, callback2, errorCallback); }
public void OnLoadGamblingFromMain() { PlayerData.Instance.GamblingTimeStamp.Value = ServerTimeService.NowTicks(); BindingManager.Instance.SceneTransition.SetActive(value: true); BindingManager.Instance.StartCoroutine(LoadGamblingSceneWithDelay()); }
public static long OldestThatCounts() { return(new DateTime(ServerTimeService.NowTicks()).Subtract(TimeSpan.FromHours(24.0)).Ticks); }