Пример #1
0
    def __setData(self, *args):
        items = g_itemsCache.items
        tankman = items.getTankman(self.tmanInvID)
        if tankman is None:
            self.onWindowClose()
            return
        else:
            dropSkillsCost = []
            for k in sorted(items.shop.dropSkillsCost.keys()):
                skillCost = items.shop.dropSkillsCost[k]
                defaultSkillCots = items.shop.defaults.dropSkillsCost[k]
                price = Money(**skillCost)
                defaultPrice = Money(**defaultSkillCots)
                action = None
                if price != defaultPrice:
                    key = '{}DropSkillsCost'.format(price.getCurrency(byWeight=True))
                    action = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, key, True, price, defaultPrice)
                skillCost['action'] = action
                dropSkillsCost.append(skillCost)

            skills_count = list(tankmen.ACTIVE_SKILLS)
            availableSkillsCount = len(skills_count) - len(tankman.skills)
            hasNewSkills = tankman.roleLevel == tankmen.MAX_SKILL_LEVEL and availableSkillsCount and (tankman.descriptor.lastSkillLevel == tankmen.MAX_SKILL_LEVEL or not len(tankman.skills))
            self.as_setDataS({'money': items.stats.money,
             'tankman': packTankman(tankman, isCountPermanentSkills=False),
             'dropSkillsCost': dropSkillsCost,
             'hasNewSkills': hasNewSkills,
             'newSkills': tankman.newSkillCount,
             'defaultSavingMode': 0,
             'texts': self.__getTexts()})
            return
Пример #2
0
 def __getSlotPrice(self):
     if self.__frozenSlotPrice is not None:
         return self.__frozenSlotPrice
     else:
         price = g_itemsCache.items.shop.getVehicleSlotsPrice(g_itemsCache.items.stats.vehicleSlots)
         if self.__hasDiscounts:
             self.__frozenSlotPrice = Money(gold=price)
         return Money(gold=price)
Пример #3
0
    def __getConversionPrice(self, xp):
        def computeCost(xp, rate, cost):
            return round(cost * xp / rate)

        rate, cost = self.itemsCache.items.shop.freeXPConversionWithDiscount
        defRate, defCost = self.itemsCache.items.shop.defaults.freeXPConversion
        return ItemPrice(Money(gold=computeCost(xp, rate, cost)),
                         Money(gold=computeCost(xp, defRate, defCost)))
 def getVehicleSlotsItemPrice(self, currentSlotsCount):
     defPrice = self.defaults.getVehicleSlotsPrice(currentSlotsCount)
     price = self.getVehicleSlotsPrice(currentSlotsCount)
     slotGoodies = self.personalSlotDiscounts
     if slotGoodies:
         bestGoody = self.bestGoody(slotGoodies)
         price = getPriceWithDiscount(price, bestGoody.resource)
     return ItemPrice(price=Money.makeFrom(Currency.GOLD, price), defPrice=Money.makeFrom(Currency.GOLD, defPrice))
Пример #5
0
 def __getPriceWithDiscount(price, resourceData):
     resourceType, _, _ = resourceData
     if resourceType == GOODIE_RESOURCE_TYPE.CREDITS:
         return Money(
             credits=getPriceWithDiscount(price.credits, resourceData))
     return Money(
         gold=getPriceWithDiscount(price.gold, resourceData)
     ) if resourceType == GOODIE_RESOURCE_TYPE.GOLD else MONEY_UNDEFINED
Пример #6
0
 def __getAction(self, cost, defaultCost, period):
     if cost != defaultCost:
         return packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS,
                                      'premiumPacket%dCost' % period, True,
                                      Money(gold=cost),
                                      Money(gold=defaultCost))
     else:
         return None
Пример #7
0
    def _getByuContentData(self, vehicle, stats, isTradeIn):
        shop = self.itemsCache.items.shop
        shopDefaults = shop.defaults
        tankMenCount = len(vehicle.crew)
        vehiclePricesActionData = self._getItemPriceActionData(vehicle)
        ammoPrice = ITEM_PRICE_EMPTY
        for shell in vehicle.gun.defaultAmmo:
            ammoPrice += shell.buyPrices.itemPrice * shell.defaultCount

        ammoActionPriceData = None
        if ammoPrice.isActionPrice():
            ammoActionPriceData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.AMMO, str(vehicle.intCD), True, ammoPrice.price, ammoPrice.defPrice)
        slotPrice = shop.getVehicleSlotsPrice(stats.vehicleSlots)
        slotDefaultPrice = shopDefaults.getVehicleSlotsPrice(stats.vehicleSlots)
        slotActionPriceData = None
        if slotPrice != slotDefaultPrice:
            slotActionPriceData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'slotsPrices', True, Money(gold=slotPrice), Money(gold=slotDefaultPrice))
        tankmenTotalLabel = i18n.makeString(DIALOGS.BUYVEHICLEWINDOW_TANKMENTOTALLABEL, count=str(tankMenCount))
        studyData = []
        for index, (tCost, defTCost, typeID) in enumerate(zip(shop.tankmanCostWithGoodyDiscount, shopDefaults.tankmanCost, ('free', 'school', 'academy'))):
            if tCost['isPremium']:
                currency = Currency.GOLD
            else:
                currency = Currency.CREDITS
            price = tCost[currency] * tankMenCount
            defPrice = defTCost[currency] * tankMenCount
            totalPrice = Money.makeFrom(currency, price)
            totalDefPrice = Money.makeFrom(currency, defPrice)
            if typeID == 'free':
                formatedPrice = i18n.makeString(MENU.TANKMANTRAININGWINDOW_FREE_PRICE)
            else:
                formatedPrice = moneyWithIcon(totalPrice, currType=currency)
            studyPriceActionData = None
            if price != defPrice:
                studyPriceActionData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, '%sTankmanCost' % currency, True, totalPrice, totalDefPrice)
            studyData.insert(0, {'id': typeID,
             'price': price,
             'crewType': index,
             'actionPrice': studyPriceActionData,
             'label': '%d%% - %s' % (tCost['roleLevel'], formatedPrice)})

        initData = {'tankmenTotalLabel': tankmenTotalLabel,
         'vehiclePrices': self._getVehiclePrice(vehicle).toMoneyTuple(),
         'vehiclePricesActionData': vehiclePricesActionData,
         'isRentable': vehicle.isRentable,
         'rentDataDD': self._getRentData(vehicle, vehiclePricesActionData),
         'ammoPrice': ammoPrice.price.getSignValue(Currency.CREDITS),
         'ammoActionPriceData': ammoActionPriceData,
         'slotPrice': slotPrice,
         'slotActionPriceData': slotActionPriceData,
         'isStudyDisabled': vehicle.hasCrew,
         'isNoAmmo': not vehicle.hasShells,
         'studyData': studyData,
         'nation': self.nationID}
        initData.update(self._getContentFields(vehicle))
        if isTradeIn:
            initData.update(self.__getTradeInContentFields(vehicle))
        return initData
Пример #8
0
 def __init__(self, intCompactDescr, proxy=None, isBoughtForAltPrice=False):
     """
     Ctr.
     
     :param intCompactDescr: item's int compact descriptor
     :param proxy: instance of ItemsRequester
     :param isBoughtForAltPrice: indicates whether the item has been bought for credits(alt price)
     """
     GUIItem.__init__(self, proxy)
     HasIntCD.__init__(self, intCompactDescr)
     self._isBoughtForAltPrice = isBoughtForAltPrice
     self._rentInfo = RentalInfoProvider()
     self._restoreInfo = None
     self._personalDiscountPrice = None
     if proxy is not None and proxy.isSynced():
         self._mayConsumeWalletResources = proxy.stats.mayConsumeWalletResources
         defaultPrice = proxy.shop.defaults.getItemPrice(self.intCD)
         if defaultPrice is None:
             defaultPrice = MONEY_UNDEFINED
         buyPrice, self._isHidden = proxy.shop.getItem(self.intCD)
         if buyPrice is None:
             buyPrice = MONEY_UNDEFINED
         altPrice = self._getAltPrice(buyPrice, proxy.shop)
         defaultAltPrice = self._getAltPrice(defaultPrice,
                                             proxy.shop.defaults)
         self._buyPrices = ItemPrices(
             itemPrice=ItemPrice(price=buyPrice, defPrice=defaultPrice),
             itemAltPrice=ItemPrice(price=altPrice,
                                    defPrice=defaultAltPrice))
         defaultSellPrice = Money.makeFromMoneyTuple(
             BigWorld.player().shop.getSellPrice(
                 defaultPrice,
                 proxy.shop.defaults.sellPriceModifiers(intCompactDescr),
                 self.itemTypeID))
         sellPrice = Money.makeFromMoneyTuple(
             BigWorld.player().shop.getSellPrice(
                 buyPrice, proxy.shop.sellPriceModifiers(intCompactDescr),
                 self.itemTypeID))
         self._sellPrices = ItemPrices(itemPrice=ItemPrice(
             price=sellPrice, defPrice=defaultSellPrice),
                                       itemAltPrice=ITEM_PRICE_EMPTY)
         self._inventoryCount = proxy.inventory.getItems(
             self.itemTypeID, self.intCD)
         if self._inventoryCount is None:
             self._inventoryCount = 0
         self._isUnlocked = self.intCD in proxy.stats.unlocks
         self._isInitiallyUnlocked = self.intCD in proxy.stats.initialUnlocks
         self._fullyConfigured = True
     else:
         self._buyPrices = ITEM_PRICES_EMPTY
         self._sellPrices = ITEM_PRICES_EMPTY
         self._isHidden = False
         self._inventoryCount = 0
         self._isUnlocked = False
         self._mayConsumeWalletResources = False
         self._isInitiallyUnlocked = False
         self._fullyConfigured = False
     return
 def tankmenRestoreConfig(self):
     config = self.__getRestoreConfig().get('tankmen', {})
     if IS_CHINA:
         duration = config.get('goldDuration', 0)
         price = Money(gold=config.get('goldCost', 0))
     else:
         duration = config.get('creditsDuration', 0)
         price = Money(credits=config.get('creditsCost', 0))
     return _TankmenRestoreConfig(config.get('freeDuration', 0), duration, price, config.get('limit', 100))
 def __init__(self,
              intCompactDescr,
              proxy=None,
              isBoughtForAltPrice=False,
              strCD=None):
     super(FittingItem, self).__init__(intCD=HasIntCD(intCompactDescr),
                                       strCD=strCD)
     self._isBoughtForAltPrice = isBoughtForAltPrice
     self._rentInfo = RentalInfoProvider(None, None, None, None, None, None)
     self._restoreInfo = None
     self._personalDiscountPrice = None
     self._descriptor = self._getDescriptor()
     if proxy is not None and proxy.inventory.isSynced(
     ) and proxy.stats.isSynced() and proxy.shop.isSynced():
         self._mayConsumeWalletResources = proxy.stats.mayConsumeWalletResources
         defaultPrice = proxy.shop.defaults.getItemPrice(self.intCD)
         if defaultPrice is None:
             defaultPrice = MONEY_UNDEFINED
         buyPrice, self._isHidden = proxy.shop.getItem(self.intCD)
         if buyPrice is None:
             buyPrice = MONEY_UNDEFINED
         altPrice = self._getAltPrice(buyPrice, proxy.shop)
         defaultAltPrice = self._getAltPrice(defaultPrice,
                                             proxy.shop.defaults)
         self._buyPrices = ItemPrices(
             itemPrice=ItemPrice(price=buyPrice, defPrice=defaultPrice),
             itemAltPrice=ItemPrice(price=altPrice,
                                    defPrice=defaultAltPrice))
         defaultSellPrice = Money.makeFromMoneyTuple(
             BigWorld.player().shop.getSellPrice(
                 defaultPrice,
                 proxy.shop.defaults.sellPriceModifiers(intCompactDescr),
                 self.itemTypeID))
         sellPrice = Money.makeFromMoneyTuple(
             BigWorld.player().shop.getSellPrice(
                 buyPrice, proxy.shop.sellPriceModifiers(intCompactDescr),
                 self.itemTypeID))
         self._sellPrices = ItemPrices(itemPrice=ItemPrice(
             price=sellPrice, defPrice=defaultSellPrice),
                                       itemAltPrice=ITEM_PRICE_EMPTY)
         self._inventoryCount = proxy.inventory.getItems(
             self.itemTypeID, self.intCD)
         if self._inventoryCount is None:
             self._inventoryCount = 0
         self._isUnlocked = self.intCD in proxy.stats.unlocks
         self._isInitiallyUnlocked = self.intCD in proxy.stats.initialUnlocks
         self._fullyConfigured = True
     else:
         self._buyPrices = ITEM_PRICES_EMPTY
         self._sellPrices = ITEM_PRICES_EMPTY
         self._isHidden = False
         self._inventoryCount = 0
         self._isUnlocked = False
         self._mayConsumeWalletResources = False
         self._isInitiallyUnlocked = False
         self._fullyConfigured = False
     return
Пример #11
0
 def _initialize(self, *args, **kwargs):
     super(BuyVehicleView, self)._initialize()
     self._blur = GUI.WGUIBackgroundBlur()
     self._blur.enable = True
     self.__addListeners()
     isElite = self.__vehicle.isElite
     vehType = self.__vehicle.type.replace('-', '_')
     with self.viewModel.transaction() as model:
         model.setTankType(
             '{}_elite'.format(vehType) if isElite else vehType)
         vehicleTooltip = i18n.makeString(
             getTypeUserName(self.__vehicle.type, isElite))
         model.setVehicleNameTooltip(vehicleTooltip)
         model.setNation(nations.NAMES[self.__vehicle.nationID])
         model.setTankLvl(int2roman(self.__vehicle.level))
         model.setTankName(self.__vehicle.shortUserName)
         model.setCountCrew(len(self.__vehicle.crew))
         model.setBuyVehicleIntCD(self.__vehicle.intCD)
         model.setIsToggleBtnVisible(self.__isTradeIn()
                                     and self.__vehicle.hasRentPackages)
         model.setIsElite(isElite)
         model.setIsRentVisible(self.__isRentVisible)
         model.setIsInBootcamp(self.__isBootcampBuyVehicle())
         model.setIsMovingTextEnabled(constants.IS_CHINA
                                      and GUI_SETTINGS.movingText.show)
         if self.__vehicle.hasCrew:
             model.setWithoutCommanderAltText(
                 R.strings.store.buyVehicleWindow.crewInVehicle)
         equipmentBlock = model.equipmentBlock
         equipmentBlock.setIsRentVisible(self.__isRentVisible)
         equipmentBlock.setTradeInIsEnabled(self.__isTradeIn())
         emtySlotAvailable = self.itemsCache.items.inventory.getFreeSlots(
             self.__stats.vehicleSlots) > 0
         equipmentBlock.setEmtySlotAvailable(emtySlotAvailable)
         equipmentBlock.setIsRestore(self.__vehicle.isRestoreAvailable())
         if self.__vehicle.hasRentPackages and not self.__vehicle.isRestoreAvailable(
         ):
             self.__selectedRentIdx = 0
             self.__selectedRentTerm = self.__vehicle.rentPackages[
                 self.__selectedRentIdx]['days']
         tankPriceArray = model.getTankPrice()
         self.__addVMsInActionPriceList(tankPriceArray,
                                        self.__vehicle.buyPrices.itemPrice)
         self.__updateTankPrice()
         self.__updateCommanderCards()
         self.__updateSlotPrice()
         self.__updateAmmoPrice()
         self.__updateTradeInInfo()
         self.__updateRentInfo()
         self.__updateBuyBtnLabel()
         totalPriceArray = equipmentBlock.getTotalPrice()
         self.__addVMsInActionPriceList(
             totalPriceArray,
             ItemPrice(price=Money(credits=0, gold=0),
                       defPrice=Money(credits=0, gold=0)))
         self.__updateTotalPrice()
def getCouponDiscountForItemPack(itemsPack, price=maxint):
    discount = 0
    if itemsPack is None:
        return Money(gold=discount)
    else:
        for item in itemsPack:
            if item.type in ItemPackTypeGroup.DISCOUNT:
                discount += item.count

        return Money(gold=min(discount, price))
Пример #13
0
 def __getPriceWithDiscount(price, resourceData):
     """
     Translates goodie value into the final price in Money
     """
     resourceType, _, _ = resourceData
     if resourceType == GOODIE_RESOURCE_TYPE.CREDITS:
         return Money(credits=getPriceWithDiscount(price.credits, resourceData))
     if resourceType == GOODIE_RESOURCE_TYPE.GOLD:
         return Money(gold=getPriceWithDiscount(price.gold, resourceData))
     return MONEY_UNDEFINED
 def _initialize(self, *args, **kwargs):
     super(BuyVehicleView, self)._initialize()
     self._blur = CachedBlur(enabled=True)
     self.__addListeners()
     isElite = self.__vehicle.isElite
     vehType = self.__vehicle.type.replace('-', '_')
     isRestore = self.__vehicle.isRestoreAvailable()
     if self.__showOnlyCongrats:
         self.viewModel.setIsContentHidden(True)
     with self.viewModel.transaction() as vm:
         vm.setIsRestore(isRestore)
         vm.setBgSource(
             R.images.gui.maps.icons.store.shop_2_background_arsenal())
         vm.setTankType('{}_elite'.format(vehType) if isElite else vehType)
         vehicleTooltip = i18n.makeString(
             getTypeUserName(self.__vehicle.type, isElite))
         noCrewLabelPath = R.strings.store.buyVehicleWindow.checkBox
         vm.setVehicleNameTooltip(vehicleTooltip)
         vm.setNation(nations.NAMES[self.__vehicle.nationID])
         vm.setNoCrewCheckboxLabel(noCrewLabelPath.restore.withoutCrew(
         ) if isRestore else noCrewLabelPath.buy.withoutCrew())
         vm.setTankLvl(int2roman(self.__vehicle.level))
         vm.setTankName(self.__vehicle.shortUserName)
         vm.setCountCrew(len(self.__vehicle.crew))
         vm.setBuyVehicleIntCD(self.__vehicle.intCD)
         vm.setIsElite(isElite)
         if self.__vehicle.hasCrew:
             vm.setWithoutCommanderAltText(
                 R.strings.store.buyVehicleWindow.crewInVehicle())
         equipmentBlock = vm.equipmentBlock
         equipmentBlock.setIsRentVisible(self.__isRentVisible)
         equipmentBlock.setTradeInIsEnabled(self.__isTradeIn())
         emtySlotAvailable = self.__itemsCache.items.inventory.getFreeSlots(
             self.__stats.vehicleSlots) > 0
         equipmentBlock.setEmtySlotAvailable(emtySlotAvailable)
         equipmentBlock.setIsRestore(isRestore)
         if self.__vehicle.hasRentPackages and (
                 not isRestore
                 or self.__actionType == VehicleBuyActionTypes.RENT
         ) and self.__actionType != VehicleBuyActionTypes.BUY:
             self.__selectedRentIdx = 0
             self.__selectedRentID = self.__vehicle.rentPackages[
                 self.__selectedRentIdx]['rentID']
         self.__updateCommanderCards()
         self.__updateSlotPrice()
         self.__updateAmmoPrice()
         self.__updateTradeInInfo()
         self.__updateRentInfo()
         self.__updateBuyBtnLabel()
         totalPriceArray = equipmentBlock.totalPrice.getItems()
         self.__addVMsInActionPriceList(
             totalPriceArray,
             ItemPrice(price=Money(credits=0, gold=0),
                       defPrice=Money(credits=0, gold=0)))
         self.__updateTotalPrice()
Пример #15
0
 def getRemovalPrice(self, proxy=None):
     if not self.isRemovable and proxy is not None:
         if self.isDeluxe():
             cost = proxy.shop.paidDeluxeRemovalCost
             defaultCost = proxy.shop.defaults.paidDeluxeRemovalCost
             return ItemPrice(price=cost, defPrice=defaultCost)
         cost = proxy.shop.paidRemovalCost
         defaultCost = proxy.shop.defaults.paidRemovalCost
         return ItemPrice(price=Money(gold=cost), defPrice=Money(gold=defaultCost))
     else:
         return super(OptionalDevice, self).getRemovalPrice(proxy)
def getStylePurchaseItems(style, modifiedOutfits, c11nService=None, prolongRent=False, progressionLevel=-1):
    purchaseItems = []
    vehicle = g_currentVehicle.item
    vehicleCD = vehicle.descriptor.makeCompactDescr()
    isStyleInstalled = c11nService.getCurrentOutfit(SeasonType.SUMMER).id == style.id
    inventoryCounts = __getInventoryCounts(modifiedOutfits, vehicleCD)
    styleCount = style.fullInventoryCount(vehicle.intCD)
    isFromInventory = not prolongRent and (styleCount > 0 or isStyleInstalled)
    if style.isProgressive:
        totalPrice = ItemPrice(Money(), Money())
        currentProgressionLvl = style.getLatestOpenedProgressionLevel(vehicle)
        progressivePrice = style.getUpgradePrice(currentProgressionLvl, progressionLevel)
        if style.isProgressionPurchasable(progressionLevel):
            totalPrice = progressivePrice
        if not style.isHidden and not isFromInventory:
            totalPrice += style.getBuyPrice()
        isFromInventory = False if progressionLevel > currentProgressionLvl else isFromInventory
        purchaseItem = PurchaseItem(style, totalPrice, areaID=None, slotType=None, regionIdx=None, selected=True, group=AdditionalPurchaseGroups.STYLES_GROUP_ID, isFromInventory=isFromInventory, locked=True, progressionLevel=progressionLevel)
        purchaseItems.append(purchaseItem)
    else:
        purchaseItem = PurchaseItem(style, style.getBuyPrice(), areaID=None, slotType=None, regionIdx=None, selected=True, group=AdditionalPurchaseGroups.STYLES_GROUP_ID, isFromInventory=isFromInventory, locked=True)
        purchaseItems.append(purchaseItem)
    for season in SeasonType.COMMON_SEASONS:
        modifiedOutfit = modifiedOutfits[season]
        if style.isProgressive:
            modifiedOutfit = c11nService.removeAdditionalProgressionData(outfit=modifiedOutfit, style=style, vehCD=vehicleCD, season=season)
        baseOutfit = style.getOutfit(season, vehicleCD)
        for intCD, component, regionIdx, container, _ in modifiedOutfit.itemsFull():
            item = c11nService.getItemByCD(intCD)
            itemTypeID = item.itemTypeID
            slotType = ITEM_TYPE_TO_SLOT_TYPE.get(itemTypeID)
            if slotType is None:
                continue
            slotId = C11nId(container.getAreaID(), slotType, regionIdx)
            modifiedSlotData = SlotData(intCD, component)
            baseSlotData = getSlotDataFromSlot(baseOutfit, slotId)
            isEdited = baseSlotData.intCD != modifiedSlotData.intCD
            if isEdited:
                if slotId != correctSlot(slotId):
                    continue
                price = item.getBuyPrice()
                isFromInventory = inventoryCounts[intCD] > 0 or item.isStyleOnly
                locked = bool(style.getDependenciesIntCDs()) and itemTypeID in EDITABLE_STYLE_IRREMOVABLE_TYPES and itemTypeID != GUI_ITEM_TYPE.CAMOUFLAGE
            else:
                price = ItemPrice(Money(credits=0), Money())
                isFromInventory = True
                locked = isPurchaseItemLocked(item, style)
            purchaseItem = PurchaseItem(item, price=price, areaID=slotId.areaId, slotType=slotId.slotType, regionIdx=slotId.regionIdx, selected=True, group=season, isFromInventory=isFromInventory, component=component, locked=locked, isEdited=isEdited)
            purchaseItems.append(purchaseItem)
            inventoryCounts[intCD] -= 1

    return purchaseItems
def packDropSkill(tankman,
                  itemsCache=None,
                  goodiesCache=None,
                  lobbyContext=None):
    items = itemsCache.items
    vehicle = items.getItemByCD(tankman.vehicleNativeDescr.type.compactDescr)
    currentMoney = items.stats.money
    prices = items.shop.dropSkillsCost.values()
    trainingCosts = [
        Money(credits=price[Currency.CREDITS] or None,
              gold=price[Currency.GOLD] or None) for price in prices
    ]
    defaultCosts = [
        Money(credits=price[Currency.CREDITS] or None,
              gold=price[Currency.GOLD] or None)
        for price in items.shop.defaults.dropSkillsCost.itervalues()
    ]
    states = [
        cost <= currentMoney or cost.get(Currency.GOLD) is not None
        for cost in trainingCosts
    ]
    factors = [price['xpReuseFraction'] for price in prices]
    tankmanLevels = [
        math.floor(tankman.efficiencyRoleLevel * factor) for factor in factors
    ]
    result = [{
        'level':
        '{}%'.format(int(lvl)),
        'enabled':
        state,
        'price': [cost.getCurrency(),
                  cost.getSignValue(cost.getCurrency())],
        'isMoneyEnough':
        cost <= currentMoney,
        'isNativeVehicle':
        True,
        'nation':
        vehicle.nationName,
        'showAction':
        cost != defCost
    } for lvl, state, cost, defCost in zip(tankmanLevels, states,
                                           trainingCosts, defaultCosts)]
    rfo = copy.deepcopy(result[0])
    rfo['level'] = '100%'
    recertificationFormGoodie = goodiesCache.getRecertificationForm(
        currency='gold')
    rfo['enabled'] = SwitchState.ENABLED.value == lobbyContext.getServerSettings(
    ).recertificationFormState(
    ) and recertificationFormGoodie.enabled and recertificationFormGoodie.count > 0
    result.append(rfo)
    return result
Пример #18
0
 def __init__(self,
              vehicle,
              item,
              slotIdx,
              install=True,
              isUseGold=False,
              conflictedEqs=None):
     """
     Ctor.
     
     @param vehicle: vehicle
     @param item: module to install
     @param slotIdx: vehicle equipment slot index to install
     @param install: flag to designated process
     @param conflictedEqs: conflicted items
     """
     super(OptDeviceInstaller,
           self).__init__(vehicle, item, (GUI_ITEM_TYPE.OPTIONALDEVICE, ),
                          slotIdx, install, conflictedEqs)
     self.cost = g_itemsCache.items.shop.paidRemovalCost
     defaultCost = g_itemsCache.items.shop.defaults.paidRemovalCost
     action = None
     if self.cost != defaultCost:
         action = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS,
                                        'paidRemovalCost', True,
                                        Money(gold=self.cost),
                                        Money(gold=defaultCost))
     addPlugins = []
     if install:
         addPlugins += (plugins.MessageConfirmator(
             'installConfirmationNotRemovable',
             ctx={'name': item.userName},
             isEnabled=not item.isRemovable), )
     else:
         addPlugins += (plugins.DemountDeviceConfirmator(
             'removeConfirmationNotRemovableGold',
             ctx={
                 'name': item.userName,
                 'price': self.cost,
                 'action': action
             },
             isEnabled=not item.isRemovable and isUseGold),
                        plugins.DestroyDeviceConfirmator(
                            'removeConfirmationNotRemovable',
                            itemName=item.userName,
                            isEnabled=not item.isRemovable
                            and not isUseGold))
     self.addPlugins(addPlugins)
     self.useGold = isUseGold
     return
Пример #19
0
 def getUpgradePrice(self, proxy=None):
     if self.isUpgradable and proxy is not None:
         price = proxy.shop.getOperationPrices().get(
             ITEM_OPERATION.UPGRADE, {}).get(
                 (self.intCD,
                  self.descriptor.upgradeInfo.upgradedCompDescr), None)
         defaultPrice = proxy.shop.defaults.getOperationPrices().get(
             ITEM_OPERATION.UPGRADE, {}).get(
                 (self.intCD,
                  self.descriptor.upgradeInfo.upgradedCompDescr), None)
         return ItemPrice(price=Money(**price),
                          defPrice=Money(**defaultPrice))
     else:
         return ITEM_PRICE_EMPTY
Пример #20
0
def calcRentPackages(vehicle, proxy):
    result = []
    if proxy is not None and vehicle.isRentable:
        rentCost = proxy.shop.getVehicleRentPrices().get(vehicle.intCD, {})
        defaultRentCost = proxy.shop.defaults.getVehicleRentPrices().get(vehicle.intCD, {})
        if len(rentCost) and len(defaultRentCost) is not None:
            for key in sorted(rentCost.keys()):
                rentPrice = Money.makeFromMoneyTuple(rentCost[key].get('cost', ()))
                defaultRentPrice = Money.makeFromMoneyTuple(defaultRentCost.get(key, {}).get('cost', rentPrice))
                result.append({'days': key,
                 'rentPrice': rentPrice,
                 'defaultRentPrice': defaultRentPrice})

    return result
Пример #21
0
 def _buildSupplyItems(self):
     self._supplyItems = []
     items = self._itemsCache.items
     slots = items.stats.vehicleSlots
     vehicles = self.getTotalVehiclesCount()
     slotPrice = items.shop.getVehicleSlotsPrice(slots)
     defaultSlotPrice = items.shop.defaults.getVehicleSlotsPrice(slots)
     if slotPrice != defaultSlotPrice:
         discount = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS,
                                          'slotsPrices', True,
                                          Money(gold=slotPrice),
                                          Money(gold=defaultSlotPrice))
     else:
         discount = None
     self._emptySlotsCount = slots - vehicles
     smallBuySlotString, buySlotString = getStatusStrings('buySlot')
     smallBuyTankString, buyTankString = getStatusStrings('buyTank')
     smallEmptySlotsString, emptySlotsString = getStatusStrings(
         'buyTankEmptyCount',
         style=text_styles.main,
         ctx={'count': self._emptySlotsCount})
     self._supplyItems.append({
         'buyTank':
         True,
         'smallInfoText':
         text_styles.concatStylesToMultiLine(smallBuyTankString,
                                             smallEmptySlotsString),
         'infoText':
         text_styles.concatStylesToMultiLine(buyTankString,
                                             emptySlotsString),
         'icon':
         RES_ICONS.MAPS_ICONS_LIBRARY_TANKITEM_BUY_TANK,
         'tooltip':
         TOOLTIPS.TANKS_CAROUSEL_BUY_VEHICLE_NEW
         if isIngameShopEnabled() else TOOLTIPS.TANKS_CAROUSEL_BUY_VEHICLE
     })
     buySlotVO = {
         'buySlot': True,
         'slotPrice': slotPrice,
         'icon': RES_ICONS.MAPS_ICONS_LIBRARY_TANKITEM_BUY_SLOT,
         'infoText': buySlotString,
         'smallInfoText': smallBuySlotString,
         'hasSale': discount is not None,
         'tooltip': TOOLTIPS.TANKS_CAROUSEL_BUY_SLOT
     }
     if discount is not None:
         buySlotVO.update({'slotPriceActionData': discount})
     self._supplyItems.append(buySlotVO)
     return
    def __setRepairPrice(self):
        vehicle = g_currentVehicle.item
        if isIncorrectVehicle(vehicle):
            return
        items = self.viewModel.repairPrice.getItems()
        items.clear()
        repairCost = vehicle.repairCost
        itemPrice = ItemPrice(price=Money(credits=repairCost),
                              defPrice=Money(credits=repairCost))
        actionPriceModels = getItemPricesViewModel(
            self.__itemsCache.items.stats.money, itemPrice)[0]
        for model in actionPriceModels:
            items.addViewModel(model)

        items.invalidate()
Пример #23
0
 def _errorHandler(self, code, errStr='', ctx=None):
     needed = Money(credits=self._repairCost.credits -
                    self.itemsCache.items.stats.credits)
     return makeI18nError('vehicle_repair/%s' % errStr,
                          defaultSysMsgKey='vehicle_repair/server_error',
                          vehName=self.item.userName,
                          needed=formatPrice(needed))
Пример #24
0
 def _getLevelPrice(level):
     levelDescr = self.descriptor.progression.levels.get(level)
     if levelDescr is not None:
         price = Money(**levelDescr['price'])
         return ItemPrice(price=price, defPrice=price)
     else:
         return ITEM_PRICE_EMPTY
Пример #25
0
    def compensation(self):
        bonuses = []
        substitutes = []
        cache = vehicles.g_cache.customization20()
        for customizationItem in self._value:
            c11nItem = self.__getC11nItem(customizationItem)
            itemType, itemId = cc.splitIntDescr(c11nItem.intCD)
            c11nComponent = cache.itemTypes[itemType][itemId]
            count = customizationItem.get('value')
            inventoryCount = c11nItem.inventoryCount
            maxNumber = c11nComponent.maxNumber
            compensationCount = count - max(0, maxNumber - inventoryCount)
            if compensationCount > 0 and maxNumber != 0:
                realCount = count - compensationCount
                if realCount > 0:
                    substituteItem = copy.deepcopy(customizationItem)
                    substituteItem['value'] = realCount
                    substitutes.append(substituteItem)
                compensation = customizationItem.get('customCompensation')
                money = Money.makeMoney(compensation)
                for currency, value in money.iteritems():
                    if value:
                        cls = _BONUSES.get(currency)
                        bonuses.append(
                            cls(currency,
                                value * compensationCount,
                                isCompensation=True))

            substitutes.append(copy.deepcopy(customizationItem))

        bonuses.insert(0, CustomizationsBonus('customizations', substitutes))
        return bonuses
Пример #26
0
 def __init__(self, intCompactDescr, proxy = None, isBoughtForCredits = False):
     GUIItem.__init__(self, proxy)
     HasIntCD.__init__(self, intCompactDescr)
     self.defaultPrice = ZERO_MONEY
     self._buyPrice = ZERO_MONEY
     self.sellPrice = ZERO_MONEY
     self.defaultSellPrice = ZERO_MONEY
     self.altPrice = None
     self.defaultAltPrice = None
     self.sellActionPrc = 0
     self.isHidden = False
     self.inventoryCount = 0
     self.sellForGold = False
     self.isUnlocked = False
     self.isBoughtForCredits = isBoughtForCredits
     self.rentInfo = RentalInfoProvider()
     if proxy is not None and proxy.isSynced():
         self.defaultPrice = proxy.shop.defaults.getItemPrice(self.intCompactDescr)
         if self.defaultPrice is None:
             self.defaultPrice = ZERO_MONEY
         self._buyPrice, self.isHidden, self.sellForGold = proxy.shop.getItem(self.intCompactDescr)
         if self._buyPrice is None:
             self._buyPrice = ZERO_MONEY
         self.defaultSellPrice = Money(*BigWorld.player().shop.getSellPrice(self.defaultPrice, proxy.shop.defaults.sellPriceModifiers(intCompactDescr), self.itemTypeID))
         self.sellPrice = Money(*BigWorld.player().shop.getSellPrice(self.buyPrice, proxy.shop.sellPriceModifiers(intCompactDescr), self.itemTypeID))
         self.inventoryCount = proxy.inventory.getItems(self.itemTypeID, self.intCompactDescr)
         if self.inventoryCount is None:
             self.inventoryCount = 0
         self.isUnlocked = self.intCD in proxy.stats.unlocks
         self.isInitiallyUnlocked = self.intCD in proxy.stats.initialUnlocks
         self.altPrice = self._getAltPrice(self.buyPrice, proxy.shop)
         self.defaultAltPrice = self._getAltPrice(self.defaultPrice, proxy.shop.defaults)
         self.sellActionPrc = -1 * getActionPrc(self.sellPrice, self.defaultSellPrice)
     return
Пример #27
0
 def tankmenRestoreConfig(self):
     config = self.__getRestoreConfig().get('tankmen', {})
     return _TankmenRestoreConfig(
         config.get('freeDuration', 0), config.get('creditsDuration', 0),
         config.get('goldDuration', 0),
         Money(credits=config.get('creditsCost', 0)),
         config.get('limit', 100))
Пример #28
0
 def _successHandler(self, code, ctx=None):
     msgType = SM_TYPE.FinancialTransactionWithGold
     vehicle = self.itemsCache.items.getItemByCD(self.__vehTypeCompDescr)
     additionalMsgs = []
     if self.__compensationRequired:
         additionalMsgs.append(
             makeCrewSkinCompensationMessage(
                 self.__compensationPriceObject))
     if ctx == EQUIP_TMAN_CODE.OK:
         additionalMsgs.append(
             makeI18nSuccess(sysMsgKey='change_tankman_role/installed',
                             vehicle=vehicle.shortUserName))
     elif ctx == EQUIP_TMAN_CODE.NO_FREE_SLOT:
         roleStr = Tankman.getRoleUserName(SKILL_NAMES[self.__roleIdx])
         additionalMsgs.append(
             makeI18nSuccess(sysMsgKey='change_tankman_role/slot_is_taken',
                             vehicle=vehicle.shortUserName,
                             role=roleStr))
     else:
         additionalMsgs.append(
             makeI18nSuccess(sysMsgKey='change_tankman_role/no_vehicle'))
     return makeI18nSuccess('change_tankman_role/success',
                            money=formatPrice(
                                Money(gold=self.__changeRoleCost)),
                            type=msgType,
                            auxData=additionalMsgs)
 def _successHandler(self, code, ctx=None):
     msgType = self.__getTankmanSysMsgType(self.dropSkillCostIdx)
     price = self.itemsCache.items.shop.dropSkillsCost.get(
         self.dropSkillCostIdx)
     return makeI18nSuccess('drop_tankman_skill/success',
                            money=formatPrice(Money(**price)),
                            type=msgType)
Пример #30
0
    def changeRetrainType(self, operationId):
        operationId = int(operationId)
        items = g_itemsCache.items
        vehicle = g_currentVehicle.item
        shopPrices = items.shop.tankmanCost
        currentSelection = shopPrices[operationId]
        crewInfo = []
        for idx, tMan in vehicle.crew:
            if tMan is not None:
                if tMan.vehicleNativeDescr.type.compactDescr != tMan.vehicleDescr.type.compactDescr:
                    crewInfo.append(self.__getTankmanRoleInfo(tMan))
                elif tMan.roleLevel != tankmen.MAX_SKILL_LEVEL and tMan.efficiencyRoleLevel < currentSelection[
                        'roleLevel']:
                    crewInfo.append(self.__getTankmanRoleInfo(tMan))

        crewSize = len(crewInfo)
        price = crewSize * Money(**currentSelection)
        self.as_setCrewDataS({
            'price':
            price,
            'crew':
            crewInfo,
            'crewMembersText':
            text_styles.concatStylesWithSpace(
                _ms(RETRAIN_CREW.LABEL_CREWMEMBERS),
                text_styles.middleTitle(crewSize))
        })
        return
Пример #31
0
def calcVehicleRestorePrice(defaultPrice, proxy):
    exchangeRate = proxy.exchangeRate
    sellPriceFactor = proxy.sellPriceModif
    restorePriceModif = proxy.vehiclesRestoreConfig.restorePriceModif
    return Money.makeFromMoneyTuple(
        getVehicleRestorePrice(defaultPrice, exchangeRate, sellPriceFactor,
                               restorePriceModif))
    def as_setDataS(self, data):
        for shell in data['shells']:
            shell['prices'] = Money(credits=0).toMoneyTuple()

        if self.__isLesson:
            data['autoEquipVisible'] = False
        super(BCTechnicalMaintenanceMeta, self).as_setDataS(data)
Пример #33
0
    def getTankmanCostWithDefaults(self):
        """
        @return: tankman studying cost
                        tmanCost, action -  ( tmanCostType, ), ( actionData, ) where
                        tmanCostType = {
                                        'roleLevel' : minimal role level after operation,
                                        'credits' : cost in credits,
                                        'defCredits' : cost in credits,
                                        'gold' : default cost in gold,
                                        'defGold' : default cost in gold,
                                        'baseRoleLoss' : float in [0, 1], fraction of role to drop,
                                        'classChangeRoleLoss' : float in [0, 1], fraction of role to drop
                                        additionally if
                                                classes of self.vehicleTypeID and newVehicleTypeID are different,
                                        'isPremium' : tankman becomes premium,
                                        }.
                                List is sorted by role level.
                        actionData = Action data for each level of retraining
        """
        from gui.shared.tooltips import ACTION_TOOLTIPS_TYPE
        from gui.shared.tooltips.formatters import packActionTooltipData
        shopPrices = self.tankmanCost
        defaultPrices = self.defaults.tankmanCost
        action = []
        tmanCost = []
        for idx, price in enumerate(shopPrices):
            data = price.copy()
            shopPrice = Money(**price)
            defaultPrice = Money(**defaultPrices[idx])
            actionData = None
            if shopPrice != defaultPrice:
                key = '{}TankmanCost'.format(shopPrice.getCurrency(byWeight=True))
                actionData = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, key, True, shopPrice, defaultPrice)
            tmanCost.append(data)
            action.append(actionData)

        return (tmanCost, action)
Пример #34
0
class FittingItem(GUIItem, HasIntCD):

    class TARGETS(object):
        CURRENT = 1
        IN_INVENTORY = 2
        OTHER = 3

    def __init__(self, intCompactDescr, proxy = None, isBoughtForCredits = False):
        GUIItem.__init__(self, proxy)
        HasIntCD.__init__(self, intCompactDescr)
        self.defaultPrice = ZERO_MONEY
        self._buyPrice = ZERO_MONEY
        self.sellPrice = ZERO_MONEY
        self.defaultSellPrice = ZERO_MONEY
        self.altPrice = None
        self.defaultAltPrice = None
        self.sellActionPrc = 0
        self.isHidden = False
        self.inventoryCount = 0
        self.sellForGold = False
        self.isUnlocked = False
        self.isBoughtForCredits = isBoughtForCredits
        self.rentInfo = RentalInfoProvider()
        if proxy is not None and proxy.isSynced():
            self.defaultPrice = proxy.shop.defaults.getItemPrice(self.intCompactDescr)
            if self.defaultPrice is None:
                self.defaultPrice = ZERO_MONEY
            self._buyPrice, self.isHidden, self.sellForGold = proxy.shop.getItem(self.intCompactDescr)
            if self._buyPrice is None:
                self._buyPrice = ZERO_MONEY
            self.defaultSellPrice = Money(*BigWorld.player().shop.getSellPrice(self.defaultPrice, proxy.shop.defaults.sellPriceModifiers(intCompactDescr), self.itemTypeID))
            self.sellPrice = Money(*BigWorld.player().shop.getSellPrice(self.buyPrice, proxy.shop.sellPriceModifiers(intCompactDescr), self.itemTypeID))
            self.inventoryCount = proxy.inventory.getItems(self.itemTypeID, self.intCompactDescr)
            if self.inventoryCount is None:
                self.inventoryCount = 0
            self.isUnlocked = self.intCD in proxy.stats.unlocks
            self.isInitiallyUnlocked = self.intCD in proxy.stats.initialUnlocks
            self.altPrice = self._getAltPrice(self.buyPrice, proxy.shop)
            self.defaultAltPrice = self._getAltPrice(self.defaultPrice, proxy.shop.defaults)
            self.sellActionPrc = -1 * getActionPrc(self.sellPrice, self.defaultSellPrice)
        return

    def _getAltPrice(self, buyPrice, proxy):
        return None

    @property
    def buyPrice(self):
        return self._buyPrice

    @property
    def rentOrBuyPrice(self):
        price = self.altPrice or self.buyPrice
        minRentPricePackage = self.getRentPackage()
        if minRentPricePackage:
            return minRentPricePackage['rentPrice']
        return price

    @property
    def actionPrc(self):
        return getActionPrc(self.altPrice or self.buyPrice, self.defaultAltPrice or self.defaultPrice)

    @property
    def isSecret(self):
        return False

    @property
    def isPremium(self):
        return self.buyPrice.isSet(Currency.GOLD)

    @property
    def isPremiumIGR(self):
        return False

    @property
    def isRentable(self):
        return False

    @property
    def isRented(self):
        return False

    @property
    def descriptor(self):
        return vehicles.getDictDescr(self.intCompactDescr)

    @property
    def isRemovable(self):
        return True

    @property
    def minRentPrice(self):
        return None

    @property
    def rentLeftTime(self):
        return 0

    def isPreviewAllowed(self):
        return False

    @property
    def userType(self):
        return getTypeInfoByName(self.itemTypeName)['userString']

    @property
    def userName(self):
        return self.descriptor.get('userString', '')

    @property
    def longUserName(self):
        return self.userType + ' ' + self.userName

    @property
    def shortUserName(self):
        return self.descriptor.get('shortUserString', '')

    @property
    def shortDescription(self):
        return getShortDescr(self.descriptor.get('description', ''))

    @property
    def fullDescription(self):
        return stripShortDescrTags(self.descriptor.get('description', ''))

    @property
    def name(self):
        return self.descriptor.get('name', '')

    @property
    def level(self):
        return self.descriptor.get('level', 0)

    @property
    def isInInventory(self):
        return self.inventoryCount > 0

    def _getShortInfo(self, vehicle = None, expanded = False):
        try:
            description = i18n.makeString('#menu:descriptions/' + self.itemTypeName + ('Full' if expanded else ''))
            vehicleDescr = vehicle.descriptor if vehicle is not None else None
            params = params_helper.getParameters(self, vehicleDescr)
            formattedParametersDict = dict(formatters.getFormattedParamsList(self.descriptor, params))
            if self.itemTypeName == vehicles._VEHICLE:
                formattedParametersDict['caliber'] = BigWorld.wg_getIntegralFormat(self.descriptor.gun['shots'][0]['shell']['caliber'])
            result = description % formattedParametersDict
            return result
        except Exception:
            LOG_CURRENT_EXCEPTION()
            return ''

        return

    def getShortInfo(self, vehicle = None, expanded = False):
        if not GUI_SETTINGS.technicalInfo:
            return ''
        return self._getShortInfo(vehicle, expanded)

    def getParams(self, vehicle = None):
        return dict(params_helper.get(self, vehicle.descriptor if vehicle is not None else None))

    def getRentPackage(self, days = None):
        return None

    def getGUIEmblemID(self):
        return 'notFound'

    @property
    def icon(self):
        return _ICONS_MASK % {'type': self.itemTypeName,
         'subtype': '',
         'unicName': self.name.replace(':', '-')}

    @property
    def iconSmall(self):
        return _ICONS_MASK % {'type': self.itemTypeName,
         'subtype': 'small/',
         'unicName': self.name.replace(':', '-')}

    def getBuyPriceCurrency(self):
        if self.altPrice is not None:
            if self.altPrice.gold and not self.isBoughtForCredits:
                return Currency.GOLD
        elif self.buyPrice.gold:
            return Currency.GOLD
        return Currency.CREDITS

    def getSellPriceCurrency(self):
        return self.sellPrice.getCurrency()

    def isInstalled(self, vehicle, slotIdx = None):
        return False

    def mayInstall(self, vehicle, slotIdx = None):
        return vehicle.descriptor.mayInstallComponent(self.intCD)

    def mayRemove(self, vehicle):
        return (True, '')

    def mayRent(self, money):
        return (False, '')

    def mayRentOrBuy(self, money):
        return self.mayPurchase(money)

    def mayPurchaseWithExchange(self, money, exchangeRate):
        price = self.altPrice or self.buyPrice
        money = money.exchange(Currency.GOLD, Currency.CREDITS, exchangeRate)
        return price <= money

    def isPurchaseEnabled(self, money, exchangeRate):
        canBuy, buyReason = self.mayPurchase(money)
        canRentOrBuy, rentReason = self.mayRentOrBuy(money)
        canBuyWithExchange = self.mayPurchaseWithExchange(money, exchangeRate)
        return canRentOrBuy or canBuy or canBuyWithExchange and buyReason == 'credits_error'

    def mayPurchase(self, money):
        if getattr(BigWorld.player(), 'isLongDisconnectedFromCenter', False):
            return (False, 'center_unavailable')
        if self.itemTypeID not in (GUI_ITEM_TYPE.EQUIPMENT, GUI_ITEM_TYPE.OPTIONALDEVICE, GUI_ITEM_TYPE.SHELL) and not self.isUnlocked:
            return (False, 'unlock_error')
        if self.isHidden:
            return (False, 'isHidden')
        price = self.altPrice or self.buyPrice
        if not price:
            return (True, '')
        for c in price.getSetCurrencies():
            if money.get(c) >= price.get(c):
                return (True, '')

        return (False, '%s_error' % Currency.BY_WEIGHT[-1])

    def getTarget(self, vehicle):
        if self.isInstalled(vehicle):
            return self.TARGETS.CURRENT
        if self.isInInventory:
            return self.TARGETS.IN_INVENTORY
        return self.TARGETS.OTHER

    def getConflictedEquipments(self, vehicle):
        return ()

    def getInstalledVehicles(self, vehs):
        return set()

    def _sortByType(self, other):
        return 0

    def __cmp__(self, other):
        if other is None:
            return 1
        res = HasIntCD.__cmp__(self, other)
        if res:
            return res
        res = self._sortByType(other)
        if res:
            return res
        res = self.level - other.level
        if res:
            return res
        res = self.buyPrice.gold - other.buyPrice.gold
        if res:
            return res
        res = self.buyPrice.credits - other.buyPrice.credits
        if res:
            return res
        else:
            return cmp(self.userName, other.userName)

    def __eq__(self, other):
        if other is None:
            return False
        else:
            return self.intCompactDescr == other.intCompactDescr

    def __repr__(self):
        return '%s<intCD:%d, type:%s, nation:%d>' % (self.__class__.__name__,
         self.intCD,
         self.itemTypeName,
         self.nationID)
Пример #35
0
 def construct(self):
     xp = self.configuration.xp
     dailyXP = self.configuration.dailyXP
     buyPrice = self.configuration.buyPrice
     sellPrice = self.configuration.sellPrice
     unlockPrice = self.configuration.unlockPrice
     techTreeNode = self.configuration.node
     minRentPrice = self.configuration.minRentPrice
     rentals = self.configuration.rentals
     paddings = formatters.packPadding(left=-4)
     neededValue = 0
     actionPrc = 0
     if buyPrice and sellPrice:
         LOG_ERROR('You are not allowed to use buyPrice and sellPrice at the same time')
         return
     else:
         block = []
         isUnlocked = self.vehicle.isUnlocked
         isInInventory = self.vehicle.isInInventory
         isNextToUnlock = False
         parentCD = None
         if techTreeNode is not None:
             isNextToUnlock = bool(int(techTreeNode.state) & NODE_STATE.NEXT_2_UNLOCK)
             parentCD = techTreeNode.unlockProps.parentID
         if xp:
             xpValue = self.vehicle.xp
             if xpValue:
                 xPText = text_styles.expText(_int(xpValue))
                 icon = ICON_TEXT_FRAMES.FREE_XP if self.vehicle.isPremium else ICON_TEXT_FRAMES.XP
                 block.append(formatters.packTextParameterWithIconBlockData(name=text_styles.main(TOOLTIPS.VEHICLE_XP), value=xPText, icon=icon, valueWidth=self._valueWidth, padding=paddings))
         if dailyXP:
             attrs = g_itemsCache.items.stats.attributes
             if attrs & constants.ACCOUNT_ATTR.DAILY_MULTIPLIED_XP and self.vehicle.dailyXPFactor > 0:
                 dailyXPText = text_styles.main(text_styles.expText('x' + _int(self.vehicle.dailyXPFactor)))
                 block.append(formatters.packTextParameterWithIconBlockData(name=text_styles.main(TOOLTIPS.VEHICLE_DAILYXPFACTOR), value=dailyXPText, icon=ICON_TEXT_FRAMES.DOUBLE_XP_FACTOR, valueWidth=self._valueWidth, padding=paddings))
         if unlockPrice:
             isAvailable, cost, need = getUnlockPrice(self.vehicle.intCD, parentCD)
             if cost > 0:
                 neededValue = None
                 if isAvailable and not isUnlocked and need > 0 and techTreeNode is not None:
                     neededValue = need
                 block.append(makePriceBlock(cost, CURRENCY_SETTINGS.UNLOCK_PRICE, neededValue, valueWidth=self._valueWidth))
         if buyPrice and not (self.vehicle.isDisabledForBuy or self.vehicle.isPremiumIGR or self.vehicle.isTelecom):
             price = self.vehicle.buyPrice
             money = g_itemsCache.items.stats.money
             actionPrc = self.vehicle.actionPrc
             defaultPrice = self.vehicle.defaultPrice
             currency = price.getCurrency()
             buyPriceText = price.get(currency)
             oldPrice = defaultPrice.get(currency)
             neededValue = price.get(currency) - money.get(currency)
             neededValue = neededValue if neededValue > 0 else None
             if isInInventory or not isInInventory and not isUnlocked and not isNextToUnlock:
                 neededValue = None
             block.append(makePriceBlock(buyPriceText, CURRENCY_SETTINGS.getBuySetting(currency), neededValue, oldPrice, actionPrc, valueWidth=self._valueWidth))
         if sellPrice and not self.vehicle.isTelecom:
             sellPrice = self.vehicle.sellPrice
             if sellPrice.isSet(Currency.GOLD):
                 sellPriceText = text_styles.gold(_int(sellPrice.gold))
                 sellPriceIcon = ICON_TEXT_FRAMES.GOLD
             else:
                 sellPriceText = text_styles.credits(_int(sellPrice.credits))
                 sellPriceIcon = ICON_TEXT_FRAMES.CREDITS
             block.append(formatters.packTextParameterWithIconBlockData(name=text_styles.main(TOOLTIPS.VEHICLE_SELL_PRICE), value=sellPriceText, icon=sellPriceIcon, valueWidth=self._valueWidth, padding=paddings))
         if minRentPrice and not self.vehicle.isPremiumIGR:
             minRentPricePackage = self.vehicle.getRentPackage()
             if minRentPricePackage:
                 minRentPriceValue = Money(*minRentPricePackage['rentPrice'])
                 minDefaultRentPriceValue = Money(*minRentPricePackage['defaultRentPrice'])
                 actionPrc = self.vehicle.getRentPackageActionPrc(minRentPricePackage['days'])
                 money = g_itemsCache.items.stats.money
                 currency = minRentPriceValue.getCurrency()
                 price = minRentPriceValue.get(currency)
                 oldPrice = minDefaultRentPriceValue.get(currency)
                 neededValue = minRentPriceValue.get(currency) - money.get(currency)
                 neededValue = neededValue if neededValue > 0 else None
                 block.append(makePriceBlock(price, CURRENCY_SETTINGS.getRentSetting(currency), neededValue, oldPrice, actionPrc, valueWidth=self._valueWidth))
         if rentals and not self.vehicle.isPremiumIGR:
             rentFormatter = RentLeftFormatter(self.vehicle.rentInfo)
             rentLeftInfo = rentFormatter.getRentLeftStr('#tooltips:vehicle/rentLeft/%s', formatter=lambda key, countType, count, _ = None: {'left': count,
              'descr': i18n.makeString(key % countType)})
             if rentLeftInfo:
                 block.append(formatters.packTextParameterWithIconBlockData(name=text_styles.main(rentLeftInfo['descr']), value=text_styles.main(rentLeftInfo['left']), icon=ICON_TEXT_FRAMES.RENTALS, valueWidth=self._valueWidth, padding=formatters.packPadding(left=-4, bottom=-16)))
         notEnoughMoney = neededValue > 0
         hasAction = actionPrc > 0
         return (block, notEnoughMoney or hasAction)
Пример #36
0
 def construct(self):
     xp = self.configuration.xp
     dailyXP = self.configuration.dailyXP
     buyPrice = self.configuration.buyPrice
     sellPrice = self.configuration.sellPrice
     unlockPrice = self.configuration.unlockPrice
     techTreeNode = self.configuration.node
     minRentPrice = self.configuration.minRentPrice
     rentals = self.configuration.rentals
     futureRentals = self.configuration.futureRentals
     paddings = formatters.packPadding(left=-4)
     neededValue = 0
     actionPrc = 0
     if buyPrice and sellPrice:
         LOG_ERROR("You are not allowed to use buyPrice and sellPrice at the same time")
         return
     else:
         block = []
         isUnlocked = self.vehicle.isUnlocked
         isInInventory = self.vehicle.isInInventory
         isNextToUnlock = False
         parentCD = None
         if techTreeNode is not None:
             isNextToUnlock = bool(int(techTreeNode.state) & NODE_STATE_FLAGS.NEXT_2_UNLOCK)
             parentCD = techTreeNode.unlockProps.parentID
         if xp:
             xpValue = self.vehicle.xp
             if xpValue:
                 xPText = text_styles.expText(_int(xpValue))
                 icon = ICON_TEXT_FRAMES.FREE_XP if self.vehicle.isPremium else ICON_TEXT_FRAMES.XP
                 block.append(
                     formatters.packTextParameterWithIconBlockData(
                         name=text_styles.main(TOOLTIPS.VEHICLE_XP),
                         value=xPText,
                         icon=icon,
                         valueWidth=self._valueWidth,
                         padding=paddings,
                     )
                 )
         if dailyXP:
             attrs = g_itemsCache.items.stats.attributes
             if attrs & constants.ACCOUNT_ATTR.DAILY_MULTIPLIED_XP and self.vehicle.dailyXPFactor > 0:
                 dailyXPText = text_styles.main(text_styles.expText("x" + _int(self.vehicle.dailyXPFactor)))
                 block.append(
                     formatters.packTextParameterWithIconBlockData(
                         name=text_styles.main(TOOLTIPS.VEHICLE_DAILYXPFACTOR),
                         value=dailyXPText,
                         icon=ICON_TEXT_FRAMES.DOUBLE_XP_FACTOR,
                         valueWidth=self._valueWidth,
                         padding=paddings,
                     )
                 )
         if unlockPrice:
             isAvailable, cost, need = getUnlockPrice(self.vehicle.intCD, parentCD)
             if cost > 0:
                 neededValue = None
                 if isAvailable and not isUnlocked and need > 0 and techTreeNode is not None:
                     neededValue = need
                 block.append(
                     makePriceBlock(cost, CURRENCY_SETTINGS.UNLOCK_PRICE, neededValue, valueWidth=self._valueWidth)
                 )
         if buyPrice:
             if self.vehicle.isRestorePossible():
                 price = self.vehicle.restorePrice
                 defaultPrice = price
                 currency = price.getCurrency()
                 buyPriceText = price.get(currency)
                 oldPrice = defaultPrice.get(currency)
                 neededValue = _getNeedValue(price, currency)
                 if isInInventory or not isInInventory and not isUnlocked and not isNextToUnlock:
                     neededValue = None
                 block.append(
                     makePriceBlock(
                         buyPriceText,
                         CURRENCY_SETTINGS.RESTORE_PRICE,
                         neededValue,
                         oldPrice,
                         actionPrc,
                         valueWidth=self._valueWidth,
                     )
                 )
                 if self.vehicle.hasLimitedRestore():
                     timeKey, formattedTime = getTimeLeftInfo(self.vehicle.restoreInfo.getRestoreTimeLeft(), None)
                     block.append(
                         formatters.packTextParameterWithIconBlockData(
                             name=text_styles.main("#tooltips:vehicle/restoreLeft/%s" % timeKey),
                             value=text_styles.main(formattedTime),
                             icon=ICON_TEXT_FRAMES.ALERT if timeKey == "hours" else ICON_TEXT_FRAMES.EMPTY,
                             valueWidth=self._valueWidth,
                             padding=formatters.packPadding(left=-4),
                         )
                     )
             elif not (self.vehicle.isDisabledForBuy or self.vehicle.isPremiumIGR or self.vehicle.isTelecom):
                 price = self.vehicle.buyPrice
                 actionPrc = self.vehicle.actionPrc
                 defaultPrice = self.vehicle.defaultPrice
                 currency = price.getCurrency()
                 buyPriceText = price.get(currency)
                 oldPrice = defaultPrice.get(currency)
                 neededValue = _getNeedValue(price, currency)
                 if isInInventory or not isInInventory and not isUnlocked and not isNextToUnlock:
                     neededValue = None
                 block.append(
                     makePriceBlock(
                         buyPriceText,
                         CURRENCY_SETTINGS.getBuySetting(currency),
                         neededValue,
                         oldPrice,
                         0,
                         valueWidth=self._valueWidth,
                     )
                 )
         if sellPrice and not self.vehicle.isTelecom:
             sellPrice = self.vehicle.sellPrice
             if sellPrice.isSet(Currency.GOLD):
                 sellPriceText = text_styles.gold(_int(sellPrice.gold))
                 sellPriceIcon = ICON_TEXT_FRAMES.GOLD
             else:
                 sellPriceText = text_styles.credits(_int(sellPrice.credits))
                 sellPriceIcon = ICON_TEXT_FRAMES.CREDITS
             block.append(
                 formatters.packTextParameterWithIconBlockData(
                     name=text_styles.main(TOOLTIPS.VEHICLE_SELL_PRICE),
                     value=sellPriceText,
                     icon=sellPriceIcon,
                     valueWidth=self._valueWidth,
                     padding=paddings,
                 )
             )
         if minRentPrice and not self.vehicle.isPremiumIGR:
             minRentPricePackage = self.vehicle.getRentPackage()
             if minRentPricePackage:
                 minRentPriceValue = Money(*minRentPricePackage["rentPrice"])
                 minDefaultRentPriceValue = Money(*minRentPricePackage["defaultRentPrice"])
                 actionPrc = self.vehicle.getRentPackageActionPrc(minRentPricePackage["days"])
                 currency = minRentPriceValue.getCurrency()
                 price = minRentPriceValue.get(currency)
                 oldPrice = minDefaultRentPriceValue.get(currency)
                 neededValue = _getNeedValue(minRentPriceValue, currency)
                 block.append(
                     makePriceBlock(
                         price,
                         CURRENCY_SETTINGS.getRentSetting(currency),
                         neededValue,
                         oldPrice,
                         actionPrc,
                         valueWidth=self._valueWidth,
                     )
                 )
                 if not self.vehicle.isRented or self.vehicle.rentalIsOver:
                     block.append(
                         formatters.packTextParameterWithIconBlockData(
                             name=text_styles.main("#tooltips:vehicle/rentAvailable"),
                             value="",
                             icon=ICON_TEXT_FRAMES.RENTALS,
                             valueWidth=self._valueWidth,
                             padding=paddings,
                         )
                     )
         if rentals and not self.vehicle.isPremiumIGR:
             if futureRentals:
                 rentLeftKey = "#tooltips:vehicle/rentLeftFuture/%s"
                 rentInfo = RentalInfoProvider(time=self._rentExpiryTime, isRented=True)
             else:
                 rentLeftKey = "#tooltips:vehicle/rentLeft/%s"
                 rentInfo = self.vehicle.rentInfo
             rentFormatter = RentLeftFormatter(rentInfo)
             rentLeftInfo = rentFormatter.getRentLeftStr(
                 rentLeftKey,
                 formatter=lambda key, countType, count, _=None: {
                     "left": count,
                     "descr": i18n.makeString(key % countType),
                 },
             )
             if rentLeftInfo:
                 block.append(
                     formatters.packTextParameterWithIconBlockData(
                         name=text_styles.main(rentLeftInfo["descr"]),
                         value=text_styles.main(rentLeftInfo["left"]),
                         icon=ICON_TEXT_FRAMES.RENTALS,
                         valueWidth=self._valueWidth,
                         padding=formatters.packPadding(left=-4, bottom=-16),
                     )
                 )
         notEnoughMoney = neededValue > 0
         hasAction = actionPrc > 0
         return (block, notEnoughMoney or hasAction)