public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs evt)
{
try
{
bool flag = false;
// CrossPlatformValidator crossPlatformValidator = new CrossPlatformValidator(GooglePlayTangle.Data(), AppleTangle.Data(), Application.identifier);
CrossPlatformValidator crossPlatformValidator = new CrossPlatformValidator(null, null, Application.identifier);
IPurchaseReceipt[] array = crossPlatformValidator.Validate(evt.purchasedProduct.receipt);
for (int i = 0; i < array.Count(); i++)
{
IPurchaseReceipt productReceipt = array[i];
if (productReceipt.productID == evt.purchasedProduct.definition.storeSpecificId && PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig iap) => iap.ProductID == productReceipt.productID) != null)
{
flag = true;
}
}
IAPConfig iAPConfig = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig iap) => iap.ProductID == evt.purchasedProduct.definition.storeSpecificId);
if (flag && iAPConfig != null)
{
IAPValidated.Value = new IAPTransactionState(iAPConfig, evt.purchasedProduct, evt.purchasedProduct.receipt);
}
if (!flag)
{
IAPInvalidated.SetValueAndForceNotify(value: true);
}
}
catch (Exception ex)
{
UnityEngine.Debug.LogWarning("Invalid receipt - " + ex.Message);
}
PurchaseInProgress.SetValueAndForceNotify(value: false);
GiveIAPToUser(evt.purchasedProduct);
return(PurchaseProcessingResult.Complete);
}
private void InitializeBundleRunner(int productIDNum)
{
if (productIDNum == -1)
{
if (PlayerData.Instance.BundleTimeStamp.Value != 0)
{
cycleOn.SetValueAndForceNotify(value: false);
PersistentSingleton <NotificationRunner> .Instance.CreateBundleNotification(deleteOld : true, TimeSpan.FromTicks(PlayerData.Instance.BundleTimeStamp.Value) + TimeSpan.FromSeconds(PersistentSingleton <GameSettings> .Instance.BundleTransitionTime), IAPProductEnum.bundleNew);
}
return;
}
ProductID.Value = (IAPProductEnum)productIDNum;
m_iapConfig = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig s) => s.ProductEnum == ProductID.Value);
Title.Value = PersistentSingleton <LocalizationService> .Instance.Text("IAPItem.Title." + ProductID.Value);
MainDescription.Value = PersistentSingleton <LocalizationService> .Instance.Text("IAPItem.Desc." + ProductID.Value);
MainRewardAmount.Value = m_iapConfig.Reward.Amount;
MainReward.SetValueAndForceNotify(m_iapConfig.Reward);
Extra1Reward.SetValueAndForceNotify(m_iapConfig.ExtraRewards[0]);
Extra2Reward.SetValueAndForceNotify(m_iapConfig.ExtraRewards[1]);
PriceString.SetValueAndForceNotify(m_iapConfig.GetLocalizedPriceStringOrDefault());
SaleString.SetValueAndForceNotify(PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig s) => s.ProductEnum == m_iapConfig.SaleEnum).GetLocalizedPriceStringOrEmpty());
cycleOn.SetValueAndForceNotify(value: true);
PersistentSingleton <NotificationRunner> .Instance.CreateBundleNotification(deleteOld : true, TimeSpan.FromTicks(PlayerData.Instance.BundleTimeStamp.Value) + TimeSpan.FromSeconds(PersistentSingleton <GameSettings> .Instance.BundleActiveTime - 1200), ProductID.Value);
PersistentSingleton <NotificationRunner> .Instance.CreateBundleNotification(deleteOld : false, TimeSpan.FromTicks(PlayerData.Instance.BundleTimeStamp.Value) + TimeSpan.FromSeconds(PersistentSingleton <GameSettings> .Instance.BundleActiveTime + PersistentSingleton <GameSettings> .Instance.BundleDeactiveTime), IAPProductEnum.bundleNew);
}
public override void AlwaysStart()
{
IAPConfig iap = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig cfg) => cfg.ProductEnum == m_bundle);
(from _ in PlayerData.Instance.PurchasedIAPBundleIDs.ObserveCountChanged(notifyCurrentCount: true)
select PlayerData.Instance.PurchasedIAPBundleIDs.Contains(iap.ProductID) into b
select b == m_activeOnTrue).SubscribeToActiveUntilNull(base.gameObject).AddTo(this);
}
public IAPItemRunner(IAPProductEnum productID)
{
SceneLoader instance = SceneLoader.Instance;
ProductID = productID;
m_iapConfig = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig s) => s.ProductEnum == ProductID);
RewardAmount.Value = m_iapConfig.Reward.Amount.ToInt();
Description.Value = PersistentSingleton <LocalizationService> .Instance.Text("IAPItem." + ProductID);
PriceString = (from fetched in PersistentSingleton <IAPService> .Instance.DataFetched
select(!fetched) ? PersistentSingleton <LocalizationService> .Instance.Text("IAPItem.DefaultButtonText") : m_iapConfig.GetLocalizedPriceStringOrDefault()).TakeUntilDestroy(instance).ToReactiveProperty();
}
public void InitiatePurchase(IAPConfig cfg)
{
PersistentSingleton <MainSaver> .Instance.PleaseSave("iap_started_" + cfg.ProductEnum);
if (m_storeController == null)
{
IAPNotCompleted.Value = new IAPNotCompleted(cfg, "Failed", "UnityIAPs not initialized.");
return;
}
m_currentlyActiveIAP = cfg;
PurchaseInProgress.SetValueAndForceNotify(value: true);
m_storeController.InitiatePurchase(cfg.ProductID);
}
private void RewardForPurchase(IAPConfig cnfg)
{
PurchaseRewards.Clear();
GiveOneReward(cnfg.Reward);
RewardData[] extraRewards = cnfg.ExtraRewards;
foreach (RewardData rewardData in extraRewards)
{
if (rewardData != null)
{
GiveOneReward(rewardData);
}
}
}
private void GiveIAPToUser(Product prod)
{
try
{
IAPConfig iAPConfig = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig iap) => iap.ProductID == prod.definition.storeSpecificId);
if (iAPConfig != null && (iAPConfig.Type != IAPType.BundleDurable || !PlayerData.Instance.PurchasedIAPBundleIDs.Contains(iAPConfig.ProductID)))
{
IAPCompleted.Value = new IAPTransactionState(iAPConfig, prod, null);
PersistentSingleton <MainSaver> .Instance.PleaseSave("iap_completed_" + iAPConfig.ProductEnum);
}
}
catch (Exception ex)
{
UnityEngine.Debug.LogError("IAPService Exception: " + ex.Message);
}
}
public IAPConfig GetSmallestGemPurchaseNeeded(int gemsMissing)
{
IAPConfig result = PersistentSingleton <Economies> .Instance.IAPs[0];
for (int i = 0; i < PersistentSingleton <Economies> .Instance.IAPs.Count; i++)
{
if (PersistentSingleton <Economies> .Instance.IAPs[i].Reward.Type == RewardEnum.AddToGems && PersistentSingleton <Economies> .Instance.IAPs[i].Type == IAPType.Consumable)
{
result = PersistentSingleton <Economies> .Instance.IAPs[i];
if (gemsMissing < PersistentSingleton <Economies> .Instance.IAPs[i].Reward.Amount)
{
return(PersistentSingleton <Economies> .Instance.IAPs[i]);
}
}
}
return(result);
}
public static List <IAPConfig> ParseIAPs(string text)
{
IEnumerable <string[]> source = TSVParser.Parse(text).Skip(1);
return(source.Select(delegate(string[] line)
{
IAPConfig iAPConfig = new IAPConfig
{
AppleID = line.asString(0, line.toError <string>()),
GoogleID = line.asString(1, line.toError <string>()),
Type = line.asEnum(2, line.toError <IAPType>()),
ProductEnum = line.asEnum(3, line.toError <IAPProductEnum>()),
Reward = ParseRewardOrNull(line[4])
};
iAPConfig.ExtraRewards[0] = ParseRewardOrNull(line[5]);
iAPConfig.ExtraRewards[1] = ParseRewardOrNull(line[6]);
iAPConfig.SaleEnum = line.asEnum(7, line.toError <IAPProductEnum>());
return iAPConfig;
}).ToList());
}
public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
{
m_storeController = controller;
m_extensionProvider = extensions;
m_extensionProvider.GetExtension <IAppleExtensions>().RegisterPurchaseDeferredListener(OnDeferred);
Product[] all = controller.products.all;
foreach (Product product in all)
{
IAPConfig iAPConfig = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig iap) => iap.ProductID == product.definition.storeSpecificId);
if (iAPConfig != null && product.availableToPurchase)
{
iAPConfig.StoreProduct = product.metadata;
}
else
{
UnityEngine.Debug.LogWarning("Product ID : " + product.definition.storeSpecificId + " does not exist in our configuration.");
}
}
DataFetched.Value = true;
}
public IAPStarted(IAPConfig cfg, string p)
{
Config = cfg;
Placement = p;
}
private void SetNewBundle()
{
List <BundleTierConfig> bundles = PersistentSingleton <Economies> .Instance.BundleTiers;
int value = PlayerData.Instance.LifetimeBundles.Value;
if (value == 0 || PlayerData.Instance.LifetimePrestiges.Value == 0)
{
bundles = PersistentSingleton <Economies> .Instance.BundleTiers.FindAll((BundleTierConfig s) => s.BundleTier == 1);
}
else
{
switch (value)
{
case 1:
bundles = PersistentSingleton <Economies> .Instance.BundleTiers.FindAll((BundleTierConfig s) => s.BundleTier == 2);
break;
case 2:
bundles = PersistentSingleton <Economies> .Instance.BundleTiers.FindAll((BundleTierConfig s) => s.BundleTier == 3);
break;
}
}
int currentBundle = (int)bundles[UnityEngine.Random.Range(0, bundles.Count)].ProductEnum;
if (PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig s) => s.ProductEnum == (IAPProductEnum)currentBundle).Reward.Type == RewardEnum.AddToGearLevel)
{
BundleTierConfig bundleTierConfig = PersistentSingleton <Economies> .Instance.BundleTiers.Find((BundleTierConfig s) => s.ProductEnum == m_iapConfig.ProductEnum);
List <GearSetRunner> list = new List <GearSetRunner>();
for (int j = 0; j < BundleTiersToGearSets.GetLength(1); j++)
{
if (BundleTiersToGearSets[bundleTierConfig.BundleTier - 1, j] != -1)
{
GearSetRunner orCreateGearSetRunner = Singleton <GearSetCollectionRunner> .Instance.GetOrCreateGearSetRunner(BundleTiersToGearSets[bundleTierConfig.BundleTier - 1, j]);
if (orCreateGearSetRunner != null)
{
list.Add(orCreateGearSetRunner);
}
}
}
GearRunner gearRunner = Singleton <GearSetCollectionRunner> .Instance.GetRandomUnlockableGear(list);
if (gearRunner == null)
{
gearRunner = Singleton <GearSetCollectionRunner> .Instance.GetRandomHighestGear(list);
}
if (gearRunner != null)
{
PlayerData.Instance.CurrentBundleGearIndex.Value = gearRunner.GearIndex;
}
else
{
int i;
for (i = bundles.Count - 1; i >= 0; i--)
{
IAPConfig iAPConfig = PersistentSingleton <Economies> .Instance.IAPs.Find((IAPConfig s) => s.ProductEnum == bundles[i].ProductEnum);
if (iAPConfig.Reward.Type == RewardEnum.AddToGearLevel)
{
bundles.Remove(bundles[i]);
}
}
if (bundles.Count == 0)
{
bundles.Add(PersistentSingleton <Economies> .Instance.BundleTiers.Find((BundleTierConfig s) => s.ProductEnum == IAPProductEnum.bundle1));
}
currentBundle = (int)bundles[UnityEngine.Random.Range(0, bundles.Count)].ProductEnum;
}
}
PlayerData.Instance.BundleTimeStamp.Value = ServerTimeService.NowTicks();
PlayerData.Instance.CurrentBundleEnum.SetValueAndForceNotify(currentBundle);
if (PersistentSingleton <GameAnalytics> .Instance != null)
{
PersistentSingleton <GameAnalytics> .Instance.NewBundle.Value = (IAPProductEnum)currentBundle;
}
}
public void BuyIAP(IAPConfig config, string placement)
{
IAPStarted.Value = new IAPStarted(config, placement);
PersistentSingleton <IAPService> .Instance.InitiatePurchase(config);
}
public IAPNotCompleted(IAPConfig cfg, string s, string e)
{
Config = cfg;
Status = s;
Error = e;
}
public IAPTransactionState(IAPConfig cfg, Product prod, string receipt)
{
Config = cfg;
Product = prod;
ReceiptRawData = receipt;
}
