public void AddBerry(int amount, int heroIndex, string reason)
{
PlayerData.Instance.LifetimeBerries.Value += amount;
HeroState orCreateHeroState = HeroStateFactory.GetOrCreateHeroState(heroIndex);
orCreateHeroState.UnusedBerries.Value += amount;
if (PersistentSingleton <GameAnalytics> .Instance != null)
{
PersistentSingleton <GameAnalytics> .Instance.BerryTransaction.Value = new BerryTransaction(amount, heroIndex, reason);
}
}
public void AddFirebaseParameters(Dictionary <string, string> p)
{
PlayerData instance = PlayerData.Instance;
SessionService instance2 = PersistentSingleton <SessionService> .Instance;
p.Add("Ads_Lifetime", instance.AdsInLifetime.ToString());
p.Add("Ads_Session", instance.AdsInSession.ToString());
p.Add("Purchases", instance.PurchasesMade.ToString());
p.Add("InvalidPurchases", instance.InvalidPurchasesMade.ToString());
p.Add("Current_Gems", instance.Gems.Value.ToString());
p.Add("Session_Number", instance.SessionNumber.Value.ToString());
p.Add("Prestiges", instance.LifetimePrestiges.Value.ToString());
p.Add("Lifetime_Gems", instance.LifetimeGems.Value.ToString());
p.Add("Max_Chunk", instance.LifetimeChunk.Value.ToString());
p.Add("Lifetime_Money_Exponent", instance.LifetimeCoins.Value.exponent.ToString());
p.Add("Max_Companions_Unlocked", instance.LifetimeCreatures.Value.ToString());
p.Add("Minutes_In_Lifetime", ((int)TimeSpan.FromTicks(instance2.TicksPlayedInLifetime()).TotalMinutes).ToString());
p.Add("Minutes_In_Session", ((int)TimeSpan.FromTicks(instance2.TicksInCurrentSession()).TotalMinutes).ToString());
p.Add("Max_Hero_Level", HeroStateFactory.GetOrCreateHeroState(0).LifetimeLevel.Value.ToString());
p.Add("Lifetime_Gears", instance.LifetimeGears.Value.ToString());
p.Add("Lifetime_Gear_Levels", instance.LifetimeGearLevels.Value.ToString());
}
public void InitializeGameAnalytics()
{
if (!base.Inited)
{
AnalyticsService analytics = PersistentSingleton <AnalyticsService> .Instance;
IAPService instance = PersistentSingleton <IAPService> .Instance;
AdService instance2 = PersistentSingleton <AdService> .Instance;
SessionService sessionService = PersistentSingleton <SessionService> .Instance;
PlayerData playerData = PlayerData.Instance;
instance.IAPCompleted.Subscribe(delegate(IAPTransactionState iapCompleted)
{
analytics.TrackEvent("IAP_Complete", iapCompleted.asDictionary(), string.Empty);
});
instance.IAPNotCompleted.Subscribe(delegate(IAPNotCompleted iapNotCompleted)
{
analytics.TrackEvent("IAP_Not_Complete", iapNotCompleted.asDictionary(), string.Empty);
});
instance.IAPValidated.Subscribe(delegate(IAPTransactionState iapValidated)
{
analytics.TrackEvent("IAP_Validated", iapValidated.asDictionary(), string.Empty);
});
instance2.AdStarted.Subscribe(delegate(AdWatched adStarted)
{
analytics.TrackEvent("Ad_Started", adStarted.asDictionary(), string.Empty);
});
(from adResult in instance2.AdResults
where adResult.result == AdService.V2PShowResult.Finished
select adResult).Subscribe(delegate(AdWatched adWatched)
{
analytics.TrackEvent("Ad_Watched", adWatched.asDictionary(), "fb_mobile_content_view");
});
(from adResult in instance2.AdResults
where adResult.result == AdService.V2PShowResult.Failed || adResult.result == AdService.V2PShowResult.Skipped
select adResult).Subscribe(delegate(AdWatched adFailed)
{
analytics.TrackEvent("Ad_Failed", adFailed.asDictionary(), string.Empty);
});
(from a in instance2.AdLoadRequests
select a.asDictionary(ServerTimeService.NowTicks())).Subscribe(delegate(Dictionary <string, string> adLoadRequest)
{
analytics.TrackEvent("Ad_Load", adLoadRequest, string.Empty);
});
(from isNewUser in sessionService.newUser
where isNewUser
select isNewUser).Subscribe(delegate
{
analytics.TrackEvent("New_User", new Dictionary <string, string>(), string.Empty);
});
playerData.SessionNumber.Subscribe(delegate
{
analytics.TrackEvent("Session_Started", new Dictionary <string, string>
{
{
"LastSavedBy",
playerData.LastSavedBy
},
{
"HoursSinceLastSession",
((int)TimeSpan.FromTicks(sessionService.TicksSinceLastSave()).TotalHours).ToString()
},
{
"Lifetime_BlocksDestroyed",
CountLifetimeBlocksDestroyed()
}
}, string.Empty);
});
playerData.SessionNumber.Subscribe(delegate
{
analytics.TrackEvent("Session_Balance", new Dictionary <string, string>
{
{
"Material_Grass",
playerData.BlocksCollected[0].Value.ToString()
},
{
"Material_Dirt",
playerData.BlocksCollected[1].Value.ToString()
},
{
"Material_Wood",
playerData.BlocksCollected[2].Value.ToString()
},
{
"Material_Stone",
playerData.BlocksCollected[3].Value.ToString()
},
{
"Material_Metal",
playerData.BlocksCollected[4].Value.ToString()
},
{
"Material_Gold",
playerData.BlocksCollected[5].Value.ToString()
},
{
"Material_Jelly",
playerData.BlocksCollected[6].Value.ToString()
}
}, string.Empty);
});
(from ord in PrestigeTriggered
where ord == PrestigeOrder.PrestigeStart
select ord).Subscribe(delegate
{
analytics.TrackEvent("Prestige", new Dictionary <string, string>
{
{
"Material_Grass",
((double)playerData.BlocksInBackpack[0].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[13].Value.ToDouble()).ToString()
},
{
"Material_Dirt",
((double)playerData.BlocksInBackpack[1].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[14].Value.ToDouble()).ToString()
},
{
"Material_Wood",
((double)playerData.BlocksInBackpack[2].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[15].Value.ToDouble()).ToString()
},
{
"Material_Stone",
((double)playerData.BlocksInBackpack[3].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[16].Value.ToDouble()).ToString()
},
{
"Material_Metal",
((double)playerData.BlocksInBackpack[4].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[17].Value.ToDouble()).ToString()
},
{
"Material_Gold",
((double)playerData.BlocksInBackpack[5].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[18].Value.ToDouble()).ToString()
},
{
"Material_Jelly",
((double)playerData.BlocksInBackpack[6].Value * Singleton <CumulativeBonusRunner> .Instance.BonusMult[19].Value.ToDouble()).ToString()
}
}, string.Empty);
});
playerData.TutorialStep.Skip(1).Subscribe(delegate(int step)
{
analytics.TrackEvent("FTUE_Stage_Done", new Dictionary <string, string>
{
{
"FTUE_Stage",
Singleton <TutorialGoalCollectionRunner> .Instance.GetOrCreatePlayerGoalRunner(step - 1).GoalConfig.ID
},
{
"FTUE_Stage_ID",
(step - 1).ToString()
}
}, (step < Singleton <EconomyHelpers> .Instance.GetTutorialGoalAmount() - 1) ? string.Empty : "fb_mobile_tutorial_completion");
});
playerData.TutorialStep.Skip(1).Subscribe(delegate(int step)
{
Analytics.CustomEvent("FTUE_Stage_Done", new Dictionary <string, object>
{
{
"FTUE_Stage",
Singleton <TutorialGoalCollectionRunner> .Instance.GetOrCreatePlayerGoalRunner(step - 1).GoalConfig.ID
},
{
"FTUE_Stage_ID",
(step - 1).ToString()
}
});
});
GemTransactions.Subscribe(delegate(GemTransaction transaction)
{
analytics.TrackEvent("Gem_Transaction", transaction.asDictionary(), (!(transaction.transaction == "spendFunds")) ? string.Empty : "fb_mobile_spent_credits", transaction.amount);
});
ChestTransactions.Subscribe(delegate(ChestTransaction transaction)
{
analytics.TrackEvent("Chest_Transaction", transaction.asDictionary(), string.Empty);
});
KeyTransactions.Subscribe(delegate(KeyTransaction transaction)
{
analytics.TrackEvent("Key_Added", transaction.asDictionary(), string.Empty);
});
BerryTransaction.Subscribe(delegate(BerryTransaction transaction)
{
analytics.TrackEvent("Berry_Added", transaction.asDictionary(), string.Empty);
});
PopupDecisions.Subscribe(delegate(PopupDecision decision)
{
analytics.TrackEvent("Popup_Decision", decision.asDictionary(), string.Empty);
});
(from coins in playerData.LifetimeCoins.Pairwise()
where coins.Previous.exponent != coins.Current.exponent
select coins).Subscribe(delegate
{
analytics.TrackEvent("New_LTE_Digit", new Dictionary <string, string>(), string.Empty);
});
playerData.LifetimeChunk.Skip(1).Subscribe(delegate
{
analytics.TrackEvent("New_Max_Chunk", new Dictionary <string, string>(), string.Empty);
});
playerData.LifetimeCreatures.Skip(1).Subscribe(delegate
{
analytics.TrackEvent("New_Max_Companions", new Dictionary <string, string>(), string.Empty);
});
HeroStateFactory.GetOrCreateHeroState(0).LifetimeLevel.Skip(1).Subscribe(delegate
{
analytics.TrackEvent("New_Max_Hero_Level", new Dictionary <string, string>(), string.Empty);
});
GoalCompleted.Subscribe(delegate(PlayerGoalRunner goal)
{
analytics.TrackEvent("Achievement_Completed", new Dictionary <string, string>
{
{
"Goal_ID",
goal.GoalConfig.ID
}
}, "fb_mobile_achievement_unlocked");
});
NewBundle.Subscribe(delegate(IAPProductEnum bundle)
{
analytics.TrackEvent("Offer_Given", new Dictionary <string, string>
{
{
"Offer",
bundle.ToString()
}
}, string.Empty);
});
GearUpgraded.Subscribe(delegate(GearRunner gear)
{
analytics.TrackEvent("Gear_Upgrade", new Dictionary <string, string>
{
{
"GearLevel",
gear.Level.ToString()
},
{
"GearID",
gear.GearIndex.ToString()
}
}, string.Empty);
});
SkillUsed.Subscribe(delegate(SkillsEnum skill)
{
analytics.TrackEvent("Skill_Used", new Dictionary <string, string>
{
{
"Skill",
skill.ToString()
},
{
"Lifetime_Used",
playerData.SkillStates[(int)skill].LifetimeUsed.Value.ToString()
}
}, string.Empty);
});
BossBattleResult.Skip(1).Subscribe(delegate(bool result)
{
analytics.TrackEvent("BossBattleResult", new Dictionary <string, string>
{
{
"Result",
result.ToString()
},
{
"Current_Chunk",
playerData.MainChunk.Value.ToString()
}
}, string.Empty);
});
ObjectTapped.Subscribe(delegate(string obj)
{
analytics.TrackEvent("Object_Tapped", new Dictionary <string, string>
{
{
"Object_Tapped",
obj
}
}, string.Empty);
});
/*XPromoPlugin.XPromoActions.Subscribe(delegate(XPromoAction XPromoAction)
* {
* analytics.TrackEvent("X_Promo_Action", XPromoAction.asDictionary(), string.Empty);
* });*/
PersistentSingleton <ARService> .Instance.LevelEditorEvent.Subscribe(delegate(string editorEvent)
{
analytics.TrackEvent("Level_Editor", new Dictionary <string, string>
{
{
"Event",
editorEvent
}
}, string.Empty);
});
PersistentSingleton <AnalyticsService> .Instance.FortunePodsResult.Subscribe(delegate(FortunePodResult result)
{
analytics.TrackEvent("Fortune_Pod_Result", result.asDictionary(), string.Empty);
});
(from chunk in playerData.MainChunk.Skip(1)
where chunk == 22 && PlayerData.Instance.LifetimePrestiges.Value == 0 && !Singleton <QualitySettingsRunner> .Instance.LowFPS.Value
select chunk).Subscribe(delegate
{
SceneLoader.Instance.StartCoroutine(TrackFpsRuotine());
});
(from hr in playerData.HasReviewed.Skip(1)
where hr
select hr).Subscribe(delegate
{
analytics.TrackEvent("fb_mobile_rate", new Dictionary <string, string>
{
{
"fb_max_rating_value",
"5"
}
}, "fb_mobile_rate", 5f);
});
playerData.Trophies.Skip(1).Subscribe(delegate(int trophies)
{
AnalyticsService analyticsService = analytics;
Dictionary <string, string> dictionary = new Dictionary <string, string>();
Dictionary <string, string> dictionary2 = dictionary;
TournamentTier tournamentTier = (TournamentTier)trophies;
dictionary2.Add("RewardType", tournamentTier.ToString());
analyticsService.TrackEvent("TournamentReward", dictionary, string.Empty);
});
(from tour in TournamentEvent
where tour
select tour).Subscribe(delegate
{
analytics.TrackEvent("TournamentStarted", new Dictionary <string, string>
{
{
"Current_Chunk",
playerData.MainChunk.Value.ToString()
}
}, string.Empty);
});
(from tour in TournamentEvent
where !tour
select tour).Subscribe(delegate
{
analytics.TrackEvent("TournamentEnded", new Dictionary <string, string>
{
{
"Current_Chunk",
playerData.MainChunk.Value.ToString()
},
{
"Highest_Chunk_Reached",
Singleton <TournamentRunner> .Instance.PlayerHighestWorld.Value.ToString()
},
{
"Position",
Singleton <TournamentRunner> .Instance.PlayerRank.Value.ToString()
}
}, string.Empty);
});
(from p in Observable.EveryApplicationPause()
where !p && FB.IsInitialized
select p).Subscribe(delegate
{
FB.ActivateApp();
});
FirebaseAnalytics.SetUserId(playerData.PlayerId);
FirebaseAnalytics.SetUserProperty("AppGenuine", (!Application.genuineCheckAvailable) ? "N/A" : Application.genuine.ToString());
FirebaseAnalytics.SetUserProperty("Build_Number", Application.version);
subscribeToUserProperty("Days_Retained", playerData.DaysRetained);
// FirebaseAnalytics.SetUserProperty("Games_Installed", XPromoPlugin.InstalledApps());
FirebaseAnalytics.SetUserProperty("Friends_Giftable", PersistentSingleton <FacebookAPIService> .Instance.FBPlayers.Count.ToString());
FirebaseAnalytics.SetUserProperty("Friends_Playing", PersistentSingleton <FacebookAPIService> .Instance.FBPlayers.Values.Count((FBPlayer p) => p.Playing).ToString());
subscribeToUserProperty("Has_Reviewed", playerData.HasReviewed);
FirebaseAnalytics.SetUserProperty("Hours_In_Lifetime", ((int)TimeSpan.FromTicks(sessionService.TicksPlayedInLifetime()).TotalHours).ToString());
FirebaseAnalytics.SetUserProperty("Segments", string.Join(",", PersistentSingleton <GameSettings> .Instance.Segments.ToArray()));
subscribeToUserProperty("Music", MusicVolume);
subscribeToUserProperty("Notifications_Decided", playerData.NotificationDecision);
subscribeToUserProperty("Online", ConnectivityService.InternetConnectionAvailable);
subscribeToUserProperty("Review_State", playerData.ReviewState);
subscribeToUserProperty("Sound", SFXVolume);
subscribeToUserProperty("AR_Editor_Supported", ARSupported);
FirebaseAnalytics.SetUserProperty("Language", playerData.Language);
FirebaseAnalytics.SetUserProperty("PFID", playerData.PFId.Value);
FirebaseAnalytics.SetUserProperty("FBID", playerData.FBId.Value);
base.Inited = true;
}
}
public HeroRunner(int heroIndex)
{
SceneLoader instance = SceneLoader.Instance;
UIIngameNotifications IngameNotifications = BindingManager.Instance.IngameNotifications;
HeroIndex = heroIndex;
BerryIndex.SetValueAndForceNotify(HeroIndex % 5);
m_heroConfig = PersistentSingleton <Economies> .Instance.Heroes[HeroIndex];
m_heroState = HeroStateFactory.GetOrCreateHeroState(HeroIndex);
Level = m_heroState.Level;
LifetimeLevel = m_heroState.LifetimeLevel;
Tier = m_heroState.Tier;
Berries = m_heroState.Berries;
UnusedBerries = m_heroState.UnusedBerries;
(from lvl in Level
where lvl > LifetimeLevel.Value
select lvl).Subscribe(delegate(int lvl)
{
LifetimeLevel.Value = lvl;
}).AddTo(instance);
Rank = (from tier in Tier
select(int) Singleton <EconomyHelpers> .Instance.GetRank(tier)).TakeUntilDestroy(instance).ToReactiveProperty();
LocalizedName = new ReactiveProperty <string>(PersistentSingleton <LocalizationService> .Instance.Text("Companion.Name." + HeroIndex));
LocalizedNameDesc = new ReactiveProperty <string>(PersistentSingleton <LocalizationService> .Instance.Text("Companion.Name.Desc." + HeroIndex));
MiniMilestoneTitle = new ReactiveProperty <string>(LocalizedName + " " + PersistentSingleton <LocalizationService> .Instance.Text("Attribute.Milestone") + "!");
ChunkIndex = new ReactiveProperty <int>(m_heroConfig.UnlockAtChunk);
FoundOnce = (from level in LifetimeLevel
select level >= 1).TakeUntilDestroy(instance).ToReactiveProperty();
Found = (from level in Level
select level >= 1).TakeUntilDestroy(instance).ToReactiveProperty();
IsNextLevelMilestone = (from lvl in Level
select Singleton <EconomyHelpers> .Instance.IsMilestone(heroIndex, lvl + 1)).TakeUntilDestroy(instance).ToReactiveProperty();
UnlockedPerkCount = (from heroLevel in Level
select Singleton <EconomyHelpers> .Instance.GetUnlockedPerkCount(heroLevel)).TakeUntilDestroy(instance).ToReactiveProperty();
PerkUnlockTriggered = (from pair in UnlockedPerkCount.Pairwise()
where pair.Previous != pair.Current
where pair.Current > 0
select new PerkUnlockedInfo(HeroIndex, pair.Current - 1)).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
if (heroIndex > 0)
{
(from _ in PerkUnlockTriggered
where LifetimeLevel.Value > Level.Value
select _).Subscribe(delegate(PerkUnlockedInfo perk)
{
IngameNotifications.InstantiatePerkNotification(perk);
}).AddTo(instance);
}
MiniMilestoneTriggered = (from lvl in Level.Pairwise()
select Singleton <EconomyHelpers> .Instance.GetMiniMilestoneOrNull(HeroIndex, lvl.Previous, lvl.Current) into cfg
where cfg != null
select cfg).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
MiniMilestoneText = MiniMilestoneTriggered.Select(delegate(BonusMultConfig cfg)
{
if (IngameNotifications.CurrentHeroIndex == HeroIndex && IngameNotifications.CurrentNotification != null && IngameNotifications.CurrentNotification.activeSelf)
{
m_currentMiniMilestoneMultiplier *= cfg.Amount;
return(GetMilestoneString(cfg.BonusType, m_currentMiniMilestoneMultiplier));
}
m_currentMiniMilestoneMultiplier = cfg.Amount;
return(GetMilestoneString(cfg.BonusType, m_currentMiniMilestoneMultiplier));
}).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
MiniMilestoneText.Subscribe(delegate
{
IngameNotifications.InstantiateMiniMilestoneNotification(this);
}).AddTo(instance);
HeroTierUpgradeTriggered = (from pair in Tier.Pairwise()
where pair.Previous != pair.Current
select HeroIndex).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
MilestoneProgress = (from level in Level
select Singleton <EconomyHelpers> .Instance.GetMilestoneProgress(level)).TakeUntilDestroy(instance).ToReactiveProperty();
BerryProgress = (from tier_berry in Tier.CombineLatest(Berries, (int tier, int berries) => new
{
tier,
berries
})
select Singleton <EconomyHelpers> .Instance.GetBerryProgress(tier_berry.tier, tier_berry.berries)).TakeUntilDestroy(instance).ToReactiveProperty();
BerryRequirement = (from tier_berry in Tier.CombineLatest(Berries, (int tier, int berries) => new
{
tier,
berries
})
select Singleton <EconomyHelpers> .Instance.GetBerryRequirementText(tier_berry.tier, tier_berry.berries)).TakeUntilDestroy(instance).ToReactiveProperty();
TierUpAvailable = (from berry_tier in Berries.CombineLatest(UnusedBerries, (int berries, int unused) => berries + unused).CombineLatest(Tier, (int berries, int tier) => new
{
berries,
tier
})
select berry_tier.berries >= Singleton <EconomyHelpers> .Instance.GetTierBerryDeltaReq(berry_tier.tier)).TakeUntilDestroy(instance).ToReactiveProperty();
NextMilestoneText = (from lvl in Level
where lvl >= 1
select Singleton <EconomyHelpers> .Instance.GetNextMilestoneText(HeroIndex, lvl)).TakeUntilDestroy(instance).ToReactiveProperty();
}
