/** * Removes the non-consumable item with the given <code>nonConsItemId</code> from the * non-consumable items storage. * * @param nonConsItemId the non-consumable to be removed to the database * @throws VirtualItemNotFoundException * @throws ClassCastException */ public static void removeNonConsumableItem(String nonConsItemId) { NonConsumableItem nonConsumableItem = (NonConsumableItem)StoreInfo.getVirtualItem(nonConsItemId); StorageManager.getNonConsumableItemsStorage().remove(nonConsumableItem); }
/** * Buys the virtual item with other virtual items. * * @throws com.soomla.store.exceptions.InsufficientFundsException */ public override void buy(String payload) { SoomlaUtils.LogDebug(TAG, "Trying to buy a " + getAssociatedItem().getName() + " with " + mAmount + " pieces of " + mTargetItemId); VirtualItem item = null; try { item = StoreInfo.getVirtualItem(mTargetItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "Target virtual item doesn't exist !" + " " + e.Message); return; } StoreEvents.GetInstance().PostItemPurchaseStartedEvent(getAssociatedItem()); VirtualItemStorage storage = StorageManager.getVirtualItemStorage(item); Debug.Assert(storage != null); int balance = storage.getBalance(item); if (balance < mAmount) { throw new InsufficientFundsException(mTargetItemId); } storage.remove(item, mAmount); getAssociatedItem().give(1); //BusProvider.getInstance().post(new OnItemPurchasedEvent(getAssociatedItem(), payload)); StoreEvents.GetInstance().PostItemPurchasedEvent(getAssociatedItem(), payload); }
/** NON CONSUMABLES **/ /** * Checks if the non-consumable with the given <code>nonConsItemId</code> exists. * * @param nonConsItemId the non-consumable to check if exists in the database * @return true if non-consumable item with nonConsItemId exists, false otherwise * @throws VirtualItemNotFoundException * @throws ClassCastException */ public static bool nonConsumableItemExists(String nonConsItemId) { NonConsumableItem nonConsumableItem = (NonConsumableItem)StoreInfo.getVirtualItem(nonConsItemId); return(StorageManager.getNonConsumableItemsStorage().nonConsumableItemExists( nonConsumableItem)); }
/** * Equips the current <code>EquippableVG</code>. * The equipping is done according to the equipping model ('GLOBAL', 'CATEGORY', or 'LOCAL'). * * @param notify if true post event to bus * @throws NotEnoughGoodsException */ public void equip(bool notify) { // only if the user has bought this EquippableVG, the EquippableVG is equipped. if (StorageManager.getVirtualGoodsStorage().getBalance(this) > 0) { if (mEquippingModel == EquippingModel.CATEGORY) { VirtualCategory category = null; try { category = StoreInfo.getCategory(getItemId()); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "Tried to unequip all other category VirtualGoods but there was no " + "associated category. virtual good itemId: " + getItemId() + " " + e.Message); return; } foreach (String goodItemId in category.getGoodsItemIds()) { EquippableVG equippableVG = null; try { equippableVG = (EquippableVG)StoreInfo.getVirtualItem(goodItemId); if (equippableVG != null && equippableVG != this) { equippableVG.unequip(notify); } } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "On equip, couldn't find one of the itemIds " + "in the category. Continuing to the next one. itemId: " + goodItemId + " " + e.Message); } catch (InvalidCastException ex) { SoomlaUtils.LogDebug(TAG, "On equip, an error occurred. It's a debug " + "message b/c the VirtualGood may just not be an EquippableVG. " + "itemId: " + goodItemId + " " + ex.Message); } } } else if (mEquippingModel == EquippingModel.GLOBAL) { foreach (VirtualGood good in StoreInfo.getGoods()) { if (good != this && good is EquippableVG) { ((EquippableVG)good).unequip(notify); } } } StorageManager.getVirtualGoodsStorage().equip(this, notify); } else { throw new NotEnoughGoodsException(getItemId()); } }
/** * Upgrades the good with the given <code>upgradeItemId</code> for FREE (you are GIVING him/her * the upgrade). In case that the good is not an upgradeable item, an error message will be * produced. <code>forceUpgrade()</code> is different than <code>upgradeVirtualGood()<code> * because <code>forceUpgrade()</code> is a FREE upgrade. * * @param upgradeItemId id of the virtual good who we want to force an upgrade upon * @throws VirtualItemNotFoundException */ public static void forceUpgrade(String upgradeItemId) { try { UpgradeVG upgradeVG = (UpgradeVG)StoreInfo.getVirtualItem(upgradeItemId); upgradeVG.give(1); } catch (InvalidCastException ex) { SoomlaUtils.LogError("SOOMLA StoreInventory", "The given itemId was of a non UpgradeVG VirtualItem. Can't force it." + " " + ex.Message); } }
/** * Retrieves the itemId of the current upgrade of the virtual good with the given * <code>goodItemId</code>. * * @param goodItemId id of the virtual good whose upgrade id we want to know * @return upgrade id if exists, or empty string otherwise * @throws VirtualItemNotFoundException */ public static String getGoodCurrentUpgrade(String goodItemId) { VirtualGood good = (VirtualGood)StoreInfo.getVirtualItem(goodItemId); UpgradeVG upgradeVG = StorageManager.getVirtualGoodsStorage().getCurrentUpgrade(good); if (upgradeVG == null) { return(""); } return(upgradeVG.getItemId()); }
/** VIRTUAL GOODS **/ /** * Equips the virtual good with the given <code>goodItemId</code>. * Equipping means that the user decides to currently use a specific virtual good. * For more details and examples see {@link com.soomla.store.domain.virtualGoods.EquippableVG}. * * @param goodItemId id of the virtual good to be equipped * @throws VirtualItemNotFoundException * @throws ClassCastException * @throws NotEnoughGoodsException */ public static void equipVirtualGood(String goodItemId) { EquippableVG good = (EquippableVG)StoreInfo.getVirtualItem(goodItemId); try { good.equip(); } catch (NotEnoughGoodsException e) { SoomlaUtils.LogError("StoreInventory", "UNEXPECTED! Couldn't equip something"); throw e; } }
/** * Removes all upgrades from the virtual good with the given <code>goodItemId</code>. * * @param goodItemId id of the virtual good we want to remove all upgrades from * @throws VirtualItemNotFoundException */ public static void removeUpgrades(String goodItemId) { List <UpgradeVG> upgrades = StoreInfo.getGoodUpgrades(goodItemId); foreach (UpgradeVG upgrade in upgrades) { StorageManager.getVirtualGoodsStorage().remove(upgrade, 1, true); } VirtualGood good = (VirtualGood)StoreInfo.getVirtualItem(goodItemId); StorageManager.getVirtualGoodsStorage().removeUpgrades(good); }
/** * @{inheritDoc} */ public override int take(int amount, bool notify) { SingleUseVG good = null; try { good = (SingleUseVG)StoreInfo.getVirtualItem(mGoodItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "SingleUseVG with itemId: " + mGoodItemId + " doesn't exist! Can't take this pack. " + e.Message); return(0); } return(StorageManager.getVirtualGoodsStorage().remove(good, mGoodAmount * amount, notify)); }
/** * @{inheritDoc} */ public override int give(int amount, bool notify) { VirtualCurrency currency = null; try { currency = (VirtualCurrency)StoreInfo.getVirtualItem(mCurrencyItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "VirtualCurrency with itemId: " + mCurrencyItemId + " doesn't exist! Can't give this pack." + " " + e.Message); return(0); } return(StorageManager.getVirtualCurrencyStorage().add( currency, mCurrencyAmount * amount, notify)); }
/** * Takes upgrade from the user, or in other words DOWNGRADES the associated * <code>VirtualGood</code> (mGood). * Checks if the current Upgrade is really associated with the <code>VirtualGood</code> and: * * if YES - downgrades to the previous upgrade (or remove upgrades in case of null). * if NO - returns 0 (does nothing). * * @param amount is NOT USED HERE! * @param notify see parent * @return see parent */ public override int take(int amount, bool notify) { VirtualGood good = null; try { good = (VirtualGood)StoreInfo.getVirtualItem(mGoodItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "VirtualGood with itemId: " + mGoodItemId + " doesn't exist! Can't downgrade." + " " + e.Message); return(0); } UpgradeVG upgradeVG = StorageManager.getVirtualGoodsStorage().getCurrentUpgrade(good); // Case: Upgrade is not assigned to this Virtual Good if (upgradeVG != this) { SoomlaUtils.LogError(TAG, "You can't take an upgrade that's not currently assigned." + "The UpgradeVG " + getName() + " is not assigned to " + "the VirtualGood: " + good.getName()); return(0); } if (!String.IsNullOrEmpty(mPrevItemId)) { UpgradeVG prevUpgradeVG = null; // Case: downgrade is not possible because previous upgrade does not exist try { prevUpgradeVG = (UpgradeVG)StoreInfo.getVirtualItem(mPrevItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "Previous UpgradeVG with itemId: " + mPrevItemId + " doesn't exist! Can't downgrade." + " " + e.Message); return(0); } // Case: downgrade is successful! SoomlaUtils.LogDebug(TAG, "Downgrading " + good.getName() + " to: " + prevUpgradeVG.getName()); StorageManager.getVirtualGoodsStorage().assignCurrentUpgrade(good, prevUpgradeVG, notify); } // Case: first Upgrade in the series - so we downgrade to NO upgrade. else { SoomlaUtils.LogDebug(TAG, "Downgrading " + good.getName() + " to NO-UPGRADE"); StorageManager.getVirtualGoodsStorage().removeUpgrades(good, notify); } return(base.take(amount, notify)); }
/** * Assigns the current upgrade to the associated <code>VirtualGood</code> (mGood). * * NOTE: This action doesn't check anything! It just assigns the current UpgradeVG to the * associated mGood. * * @param amount is NOT USED HERE! * @return 1 if the user was given the good, 0 otherwise */ public override int give(int amount, bool notify) { SoomlaUtils.LogDebug(TAG, "Assigning " + getName() + " to: " + mGoodItemId); VirtualGood good = null; try { good = (VirtualGood)StoreInfo.getVirtualItem(mGoodItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "VirtualGood with itemId: " + mGoodItemId + " doesn't exist! Can't upgrade. " + e.Message); return(0); } StorageManager.getVirtualGoodsStorage().assignCurrentUpgrade(good, this, notify); return(base.give(amount, notify)); }
/** * Determines if the user is in a state that allows him/her to buy an <code>UpgradeVG</code> * This method enforces allowing/rejecting of upgrades here so users won't buy them when * they are not supposed to. * If you want to give your users free upgrades, use the <code>give</code> function. * * @return true if can buy, false otherwise */ protected override bool CanBuy() { VirtualGood good = null; try { good = (VirtualGood)StoreInfo.getVirtualItem(mGoodItemId); } catch (VirtualItemNotFoundException e) { SoomlaUtils.LogError(TAG, "VirtualGood with itemId: " + mGoodItemId + " doesn't exist! Returning NO (can't buy)." + " " + e.Message); return(false); } UpgradeVG upgradeVG = StorageManager.getVirtualGoodsStorage().getCurrentUpgrade(good); return(((upgradeVG == null && String.IsNullOrEmpty(mPrevItemId)) || (upgradeVG != null && ((upgradeVG.getNextItemId() == getItemId()) || (upgradeVG.getPrevItemId() == getItemId())))) && base.CanBuy()); }
/** * Retrieves the upgrade level of the virtual good with the given <code>goodItemId</code>. * * For Example: * Let's say there's a strength attribute to one of the characters in your game and you provide * your users with the ability to upgrade that strength on a scale of 1-3. * This is what you've created: * 1. <code>SingleUseVG</code> for "strength" * 2. <code>UpgradeVG</code> for strength 'level 1'. * 3. <code>UpgradeVG</code> for strength 'level 2'. * 4. <code>UpgradeVG</code> for strength 'level 3'. * In the example, this function will retrieve the upgrade level for "strength" (1, 2, or 3). * * @param goodItemId id of the virtual good whose upgrade level we want to know * @return upgrade level of the good with the given id * @throws VirtualItemNotFoundException */ public static int getGoodUpgradeLevel(String goodItemId) { VirtualGood good = (VirtualGood)StoreInfo.getVirtualItem(goodItemId); UpgradeVG upgradeVG = StorageManager.getVirtualGoodsStorage().getCurrentUpgrade(good); if (upgradeVG == null) { return(0); //no upgrade } UpgradeVG first = StoreInfo.getGoodFirstUpgrade(goodItemId); int level = 1; while (!first.Equal(upgradeVG)) { first = (UpgradeVG)StoreInfo.getVirtualItem(first.getNextItemId()); level++; } return(level); }
private void buildShop() { foreach (VirtualCurrencyPack vc in StoreInfo.getCurrencyPacks()) { buildShopLine(vc); } foreach (NonConsumableItem nci in StoreInfo.getNonConsumableItems()) { buildShopLine(nci); } foreach (string id in StoreAssets.BOOTS_CATEGORY.getGoodsItemIds()) { buildShopLine(StoreInfo.getVirtualItem(id)); } foreach (string id in StoreAssets.GLOVE_CATEGORY.getGoodsItemIds()) { buildShopLine(StoreInfo.getVirtualItem(id)); } }
/** * Upgrades the virtual good with the given <code>goodItemId</code> by doing the following: * 1. Checks if the good is currently upgraded or if this is the first time being upgraded. * 2. If the good is currently upgraded, upgrades to the next upgrade in the series, or in * other words, <code>buy()</code>s the next upgrade. In case there are no more upgrades * available(meaning the current upgrade is the last available), the function returns. * 3. If the good has never been upgraded before, the function upgrades it to the first * available upgrade, or in other words, <code>buy()</code>s the first upgrade in the series. * * @param goodItemId the id of the virtual good to be upgraded * @throws VirtualItemNotFoundException * @throws InsufficientFundsException */ public static void upgradeVirtualGood(String goodItemId) { VirtualGood good = (VirtualGood)StoreInfo.getVirtualItem(goodItemId); UpgradeVG upgradeVG = StorageManager.getVirtualGoodsStorage().getCurrentUpgrade(good); if (upgradeVG != null) { String nextItemId = upgradeVG.getNextItemId(); if (String.IsNullOrEmpty(nextItemId)) { return; } UpgradeVG vgu = (UpgradeVG)StoreInfo.getVirtualItem(nextItemId); vgu.buy(""); } else { UpgradeVG first = StoreInfo.getGoodFirstUpgrade(goodItemId); if (first != null) { first.buy(""); } } }
/** * Buys the item with the given <code>itemId</code>. * * @param itemId id of item to be purchased * @param payload a string you want to be assigned to the purchase. This string * is saved in a static variable and will be given bacl to you when the * purchase is completed. * @throws InsufficientFundsException * @throws VirtualItemNotFoundException */ public static void buy(String itemId, String payload) { PurchasableVirtualItem pvi = (PurchasableVirtualItem)StoreInfo.getVirtualItem(itemId); pvi.buy(payload); }
/** * Checks if the virtual good with the given <code>goodItemId</code> is currently equipped. * * @param goodItemId id of the virtual good who we want to know if is equipped * @return true if the virtual good is equipped, false otherwise * @throws VirtualItemNotFoundException * @throws ClassCastException */ public static bool isVirtualGoodEquipped(String goodItemId) { EquippableVG good = (EquippableVG)StoreInfo.getVirtualItem(goodItemId); return(StorageManager.getVirtualGoodsStorage().isEquipped(good)); }
/** * Unequips the virtual good with the given <code>goodItemId</code>. Unequipping means that the * user decides to stop using the virtual good he/she is currently using. * For more details and examples see {@link com.soomla.store.domain.virtualGoods.EquippableVG}. * * @param goodItemId id of the virtual good to be unequipped * @throws VirtualItemNotFoundException * @throws ClassCastException */ public static void unEquipVirtualGood(String goodItemId) { EquippableVG good = (EquippableVG)StoreInfo.getVirtualItem(goodItemId); good.unequip(); }
/** VIRTUAL ITEMS **/ /** * Retrieves the balance of the virtual item with the given <code>itemId</code>. * * @param itemId id of the virtual item to be fetched. * @return balance of the virtual item with the given <code>itemId</code>. * @throws VirtualItemNotFoundException */ public static int getVirtualItemBalance(String itemId) { VirtualItem item = StoreInfo.getVirtualItem(itemId); return(StorageManager.getVirtualItemStorage(item).getBalance(item)); }
/** * Takes from your user the given amount of the virtual item with the given <code>itemId</code>. * For example, when your user requests a refund you need to TAKE the item he/she is returning. * * @param itemId id of the virtual item to be taken * @param amount amount of the item to be given * @throws VirtualItemNotFoundException */ public static void takeVirtualItem(String itemId, int amount) { VirtualItem item = StoreInfo.getVirtualItem(itemId); item.take(amount); }