private BuyItemResult BuyItemByCostArray(string itemId, IEnumerable <GameElementData> costs)
{
if (!restrictionVerifier.VerifyRestrictions(itemConfigModel.GetRestrictions(itemId)))
{
Debug.Log("StoreManager.BuyItemByCostArray - Restrictions not met for item - " + itemId);
return(new BuyItemResult(BuyItemResultCode.RestrictionsNotMet));
}
else if (!currencyStateModel.SufficientCurrency(costs))
{
Debug.Log("StoreManager.BuyItemByCostArray - Insufficient currency for item - " + itemId);
return(new BuyItemResult(BuyItemResultCode.InsufficientCurrency));
}
currencyStateModel.DecreaseCurrency(costs);
ItemConfigData itemData = itemConfigModel.GetItem(itemId);
GameElementData ge = itemConfigModel.ToGameElement(itemData);
var items = new List <GameElementData> {
ge
};
collectGameElementsSignal.Dispatch(items);
if (itemData.itemType == ItemType.Reward)
{
rewardItemBoughtSignal.Dispatch(itemData);
}
return(new BuyItemResult(BuyItemResultCode.Success));
}
public override void Execute()
{
logger.Log(Tag, "Execute");
foreach (GameElementData gameElement in gameElements)
{
logger.Log(Tag, "<color=green>Collecting game element :</color> " + gameElement);
switch (gameElement.type)
{
case GameElementType.Currency:
currencyStateModel.IncreaseCurrency(gameElement);
break;
case GameElementType.Item:
//TODO: Expand to support:
// 1. Automatic upgrade of items
// 2. Automatic setting the item to be in use
ItemConfigData itemData = itemConfigModel.GetItem(gameElement.key);
if (itemData.itemType == ItemType.Currency)
{
currencyStateModel.IncreaseCurrency(itemConfigModel.ToGameElement(itemData));
}
else
{
inventoryStateModel.IncreaseQuantity(gameElement);
}
break;
case GameElementType.State:
progressStateModel.IncreaseProgress(gameElement);
break;
}
}
}
public bool SetQuantity(string itemConfigId, int amount)
{
int index = GetIndex(itemConfigId);
if (index != -1)
{
_data.items [index].quantity = amount;
}
else
{
ItemData newItem = new ItemData();
newItem.itemConfigId = itemConfigId;
newItem.inUse = false;
newItem.quantity = amount;
ItemConfigData itemConfigData = itemConfigModel.GetItem(itemConfigId);
if (itemConfigData == null)
{
Debug.LogError("Attempted to access non existing item config");
return(false);
}
newItem.category = itemConfigData.category;
_data.items.Add(newItem);
}
return(Save());
}
private void BuyItemPack(ItemGroupConfigData itemGroupData, Promise <BuyItemResult> promise)
{
if (itemGroupData.items.Count == 0)
{
logger.LogError(Tag, "BuyItemPack - Group contains no items");
promise.Resolve(new BuyItemResult(BuyItemResultCode.Error));
return;
}
string itemIdToBuy = itemGroupData.items[0];
// For item groups with more than
if (itemGroupData.items.Count > 1)
{
ItemConfigData packCost = itemGroupConfigModel.GetPackCost(itemGroupData.id);
if (packCost == null)
{
logger.LogError(Tag, "Cannot find Pack cost - item groups with more than one item require a pack cost item");
promise.Resolve(new BuyItemResult(BuyItemResultCode.Error));
return;
}
itemIdToBuy = packCost.id;
}
// Pay the costs, then give the player the rest of the items in the group
BuyItem(itemIdToBuy).Done(buyItemResult => {
if (buyItemResult.resultCode.Equals(BuyItemResultCode.Success))
{
foreach (string itemId in itemGroupConfigModel.GetItemIds(itemGroupData.id))
{
ItemConfigData item = itemConfigModel.GetItem(itemId);
if (item.itemType == ItemType.PackCost)
{
continue;
}
GameElementData ge = itemConfigModel.ToGameElement(item);
var items = new List <GameElementData> {
ge
};
collectGameElementsSignal.Dispatch(items);
}
}
else
{
logger.Log(Tag, "BuyItemPack - Will not collect game elements since buy attempt failed. Result code: " + buyItemResult.resultCode);
}
promise.Resolve(buyItemResult);
});
}
private bool HasSufficientCurrencyForItem(ItemConfigData item)
{
if (item.costs.Count > 0 && currencyStateModel.SufficientCurrency(item.costs) ||
item.alternativeCosts.Count > 0 && currencyStateModel.SufficientCurrency(item.alternativeCosts))
{
return(true);
}
else
{
return(false);
}
}
private BuyItemResult BuyItemWithVC(ItemConfigData itemConfigData)
{
var result = new BuyItemResult(BuyItemResultCode.Error);
if (itemConfigData.costs.Count > 0)
{
result = BuyItemByCosts(itemConfigData);
}
else if (itemConfigData.alternativeCosts.Count > 0)
{
result = BuyItemByAlternativeCosts(itemConfigData);
}
return(result);
}
public IConfigData Clone()
{
ItemConfigData c = new ItemConfigData();
c.id = id;
c.name = name;
c.iapConfigId = iapConfigId;
c.quantity = quantity;
c.category = category;
c.index = index;
c.currencyKey = currencyKey;
c.itemType = itemType;
c.itemTypeKey = itemTypeKey;
c.costs = new List <GameElementData>(costs.Clone());
c.alternativeCosts = new List <GameElementData>(alternativeCosts.Clone());
c.restrictions = new List <GameElementData>(restrictions.Clone());
c.assets = new List <AssetData>(assets.Clone());
c.properties = new List <GenericPropertyData>(properties.Clone());
return(c);
}
protected override void OnRegister()
{
base.OnRegister();
itemConfig = itemConfigModel.GetItem(itemID);
_iapConfigId = itemConfigModel.GetIAPConfigID(itemConfig.id);
if (!_iapConfigId.IsNullOrEmpty())
{
_storeSpecificId = iapConfigModel.GetIAPId(iapConfigModel.GetIAP(_iapConfigId));
}
if (!IsItemPurchased())
{
UpdatePrice();
}
RefreshButtonUI();
}
public IPromise <BuyItemResult> BuyItem(string itemId, CurrencyType currencyType = CurrencyType.AutoDetect)
{
var promise = new Promise <BuyItemResult>();
ItemConfigData itemData = itemConfigModel.GetItem(itemId);
if (currencyType == CurrencyType.HardCurrency)
{
BuyItemByIAP(itemId, promise);
return(promise);
}
if (currencyType == CurrencyType.VirtualCurrency)
{
BuyItemResult result = BuyItemWithVC(itemData);
promise.Resolve(result);
return(promise);
}
// Auto detect virtual currency or hard currency;
if (itemConfigModel.HasAnyCosts(itemData))
{
BuyItemResult result = BuyItemWithVC(itemData);
promise.Resolve(result);
}
else if (itemConfigModel.IsInAppItem(itemData))
{
BuyItemByIAP(itemId, promise);
}
else
{
Debug.LogError("Attempted to purchase an item with no defined costs");
promise.Resolve(new BuyItemResult(BuyItemResultCode.Error));
}
return(promise);
}
public override void Execute()
{
_iapId = purchaseResult.purchasedItem.id;
logger.Log(Tag, "IAP id: " + _iapId);
if (purchaseResult.result == PurchaseIAPResultCode.Success)
{
IAPConfigData iapConfig = iapConfigModel.GetIAPByPurchaseId(_iapId);
_purchasedItem = itemConfigModel.GetItemByIapConfigId(iapConfig.id);
if (_purchasedItem == null)
{
logger.LogError(Tag, "Could not find item config id for iap + " + _iapId);
Fail();
return;
}
CollectPurchasedItem();
if (DidPurchasedNoAds())
{
logger.Log(Tag, "PurchaseNoAdsCommand of " + _purchasedItem);
settingsStateModel.SetNoAds();
bannerAds.Hide();
}
EnablePromotionEligibility();
}
else
{
logger.Log(Tag, "Purchase failed");
Fail();
}
iapPurchaseDoneSignal.Dispatch(purchaseResult);
}
private void BuyItemByIAP(string itemId, Promise <BuyItemResult> promise)
{
ItemConfigData itemData = itemConfigModel.GetItem(itemId);
IAPConfigData iapData = iapConfigModel.GetIAP(itemData.iapConfigId);
if (iapData == null)
{
logger.LogError(Tag, ".PurchaseItemByIAP - Could not find iap data for item : " + itemData.id);
promise.Resolve(new BuyItemResult(BuyItemResultCode.Error));
}
if (IsPurchaseInProgress)
{
logger.Log(Tag, ".PurchaseItemByIAP - Purchase is in progress - ignoring new purchase request for item : " + itemData.id);
promise.Resolve(new BuyItemResult(BuyItemResultCode.Error));
}
else
{
iapPurchaseDoneSignal.AddOnce(iapResult => HandleIapResult(iapResult, promise));
requestPurchaseInAppItemSignal.Dispatch(iapData);
}
}
private BuyItemResult BuyItemByAlternativeCosts(ItemConfigData itemConfigData)
{
return(BuyItemByCostArray(itemConfigData.id, itemConfigData.alternativeCosts));
}
private BuyItemResult BuyItemByCosts(ItemConfigData itemConfigData)
{
return(BuyItemByCostArray(itemConfigData.id, itemConfigData.costs));
}
