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);
}
