def _getRequestCriteria(self, invVehicles):
requestCriteria = super(ShopShellTab,
self)._getRequestCriteria(invVehicles)
itemTypes = self._filterData['itemTypes']
requestCriteria |= REQ_CRITERIA.CUSTOM(
lambda item: item.type in itemTypes)
fitsType = self._filterData['fitsType']
if fitsType == 'myVehicleGun':
vehicle = self._items.getItemByCD(
int(self._filterData['vehicleCD']))
shellsList = map(lambda x: x.intCD, vehicle.gun.defaultAmmo)
requestCriteria |= REQ_CRITERIA.IN_CD_LIST(shellsList)
elif fitsType != 'otherGuns':
shellsList = set()
myGuns = self._items.getItems(GUI_ITEM_TYPE.GUN,
REQ_CRITERIA.INVENTORY).values()
for gun in myGuns:
shellsList.update(map(lambda x: x.intCD, gun.defaultAmmo))
for vehicle in invVehicles:
shellsList.update(
map(lambda x: x.intCD, vehicle.gun.defaultAmmo))
requestCriteria |= REQ_CRITERIA.IN_CD_LIST(shellsList)
return requestCriteria
def updateVehicles(self, vehicles=None, filterCriteria=None):
isFullResync = vehicles is None and filterCriteria is None
filterCriteria = filterCriteria or REQ_CRITERIA.EMPTY
if vehicles:
filterCriteria |= REQ_CRITERIA.IN_CD_LIST(vehicles)
vehiclesCollection = self._itemsCache.items.getVehicles(
self._baseCriteria | filterCriteria)
isVehicleRemoved = not set(vehicles or
()).issubset(vehiclesCollection.viewkeys())
isVehicleAdded = not set(vehicles or ()).issubset(self._vehicles)
if isFullResync or isVehicleAdded or isVehicleRemoved:
self.buildList()
else:
updateIndices = []
updateVehicles = []
for intCD, newVehicle in vehiclesCollection.iteritems():
for idx, oldVehicle in enumerate(self._vehicles):
if oldVehicle.invID == newVehicle.invID:
self._vehicleItems[idx] = self._getVehicleDataVO(
newVehicle)
self._vehicles[idx] = newVehicle
updateIndices.append(idx)
updateVehicles.append(self._vehicleItems[idx])
self.flashObject.invalidateItems(updateIndices, updateVehicles)
self.applyFilter()
return
def setOpener(self, view):
self.__opener = view
eventData = self.__opener.eventData
leaderboards = eventData.getLeaderboards()
leaderboardID = leaderboards[0][0]
if eventData.getType() == EVENT_TYPE.VEHICLE:
currentVehicleCD = g_currentVehicle.item.intCD if g_currentVehicle.item else None
_leaderboardID = eventData.getLeaderboardID(currentVehicleCD)
if _leaderboardID is not None:
leaderboardID = _leaderboardID
elif leaderboards:
vehicleIds = [veh for _, veh in leaderboards]
allVehicles = self.itemsCache.items.getVehicles(
REQ_CRITERIA.IN_CD_LIST(vehicleIds))
fields = (('level', False), ('nations', True), ('type', True))
sortedVehicles = sortByFields(fields, allVehicles.itervalues(),
vehicleValueGetter)
leaderboardID = eventData.getLeaderboardID(
sortedVehicles[0].intCD)
else:
header = {
'filters':
makeFiltersVO(eventData.getType(),
leaderboards,
leaderboardID,
category='awards')
}
self.as_setHeaderS(header)
self._setData(leaderboardID)
return
def getInventoryVehicles(self):
nodeCDs = [node.getNodeCD() for node in self._getNodesToInvalidate()]
LOG_DEBUG('getInventoryVehicles', nodeCDs)
inventory_vehicles = self._items.getVehicles(
REQ_CRITERIA.INVENTORY | REQ_CRITERIA.IN_CD_LIST(nodeCDs))
return dict(
((item.invID, item) for item in inventory_vehicles.itervalues()))
def getInventoryVehicles(self):
nodeCDs = map(lambda node: node['id'], self._getNodesToInvalidate())
LOG_DEBUG('getInventoryVehicles', nodeCDs)
vehicles = self._items.getVehicles(REQ_CRITERIA.INVENTORY
| REQ_CRITERIA.IN_CD_LIST(nodeCDs))
return dict(
map(lambda item: (item.inventoryID, item), vehicles.itervalues()))
def updateVehicles(self,
vehiclesCDs=None,
filterCriteria=None,
forceUpdate=False):
rentalVehicles = self._wotPlusVehicles + self._telecomRentalsVehicles
changeInRentals = set(vehiclesCDs or ()).issubset(rentalVehicles)
filterCriteria = filterCriteria or REQ_CRITERIA.EMPTY
if vehiclesCDs:
filterCriteria |= REQ_CRITERIA.IN_CD_LIST(vehiclesCDs)
criteria = self._baseCriteria | filterCriteria | REQ_CRITERIA.VEHICLE.ACTIVE_IN_NATION_GROUP | REQ_CRITERIA.VEHICLE.WOTPLUS_RENT ^ REQ_CRITERIA.VEHICLE.TELECOM_RENT
newRentalsVehicles = self._itemsCache.items.getVehicles(
criteria).viewkeys()
isVehicleRemoved = not set(vehiclesCDs or
()).issubset(newRentalsVehicles)
isVehicleAdded = not set(vehiclesCDs or ()).issubset(rentalVehicles)
if changeInRentals or isVehicleRemoved or isVehicleAdded:
rentPendingVehCD = self._wotPlusInfo.getRentPending()
if isVehicleAdded and rentPendingVehCD in newRentalsVehicles:
self._wotPlusInfo.resetRentPending()
rentPendingVehCD = self._telecomRentals.getRentsPending()
rentPendingVehCD = rentPendingVehCD.intersection(
newRentalsVehicles)
if isVehicleAdded and rentPendingVehCD:
self._telecomRentals.resetRentsPending(rentPendingVehCD)
self.buildList()
return
super(HangarCarouselDataProvider,
self).updateVehicles(vehiclesCDs, filterCriteria, forceUpdate)
def updateData(self):
vehicleIds = [veh for _, veh in self.__eventData.getLeaderboards()]
allVehicles = self.itemsCache.items.getVehicles(
REQ_CRITERIA.IN_CD_LIST(vehicleIds))
vehicles = self._updateData(
allVehicles, compatiblePredicate=lambda vo: vo['inHangar'])
self._vehDP.buildList(vehicles, self.__selectedVehicleCD)
self.__updateSortField()
def getInventoryVehicles(self):
"""
Gets vehicles from inventory.
:return: dict( <inventoryID> : <gui item>, ... ).
"""
nodeCDs = map(lambda node: node['id'], self._getNodesToInvalidate())
LOG_DEBUG('getInventoryVehicles', nodeCDs)
inventory_vehicles = self._items.getVehicles(
REQ_CRITERIA.INVENTORY | REQ_CRITERIA.IN_CD_LIST(nodeCDs))
return dict(
map(lambda item: (item.inventoryID, item),
inventory_vehicles.itervalues()))
def invalidateVehicleStates(self, vehicles=None):
state = Vehicle.VEHICLE_STATE.UNSUITABLE_TO_UNIT
if vehicles:
criteria = REQ_CRITERIA.IN_CD_LIST(vehicles)
else:
criteria = REQ_CRITERIA.INVENTORY
vehicles = self.itemsCache.items.getVehicles(criteria)
updatedVehicles = [
intCD for intCD, v in vehicles.iteritems()
if self._updateVehicleState(v, state)
]
if updatedVehicles:
g_prbCtrlEvents.onVehicleClientStateChanged(updatedVehicles)
def updateVehicles(self, vehiclesCDs=None, filterCriteria=None):
isFullResync = vehiclesCDs is None and filterCriteria is None
filterCriteria = filterCriteria or REQ_CRITERIA.EMPTY
if vehiclesCDs:
filterCriteria |= REQ_CRITERIA.IN_CD_LIST(vehiclesCDs)
newVehiclesCollection = self._itemsCache.items.getVehicles(self._baseCriteria | filterCriteria)
oldVehiclesCDs = [ vehicle.intCD for vehicle in self._vehicles ]
isVehicleRemoved = not set(vehiclesCDs or ()).issubset(newVehiclesCollection.viewkeys())
isVehicleAdded = not set(vehiclesCDs or ()).issubset(oldVehiclesCDs)
if isFullResync or isVehicleAdded or isVehicleRemoved:
self.buildList()
else:
self._updateVehicleItems(newVehiclesCollection.values())
return
def invalidateVehicleStates(self, vehicles = None):
"""
Invalidates given vehicles states
Args:
vehicles: dict of items cache request result: intCD -> vehicle item
"""
state = Vehicle.VEHICLE_STATE.UNSUITABLE_TO_UNIT
if vehicles:
criteria = REQ_CRITERIA.IN_CD_LIST(vehicles)
else:
criteria = REQ_CRITERIA.INVENTORY
vehicles = g_itemsCache.items.getVehicles(criteria)
updatedVehicles = [ intCD for intCD, v in vehicles.iteritems() if self._updateVehicleState(v, state) ]
if updatedVehicles:
g_prbCtrlEvents.onVehicleClientStateChanged(updatedVehicles)
def _setData(self):
eventData = self.__opener.eventData
eventType = eventData.getType()
criteria = REQ_CRITERIA.EMPTY
if eventType == EVENT_TYPE.VEHICLE:
vehicleIds = [veh for _, veh in eventData.getLeaderboards()]
title = _ms(EVENT_BOARDS.VEHICLES_VEHICLE)
bgPath = None
if self.__filters['nation'] != -1:
criteria |= REQ_CRITERIA.NATIONS([self.__filters['nation']])
if self.__filters['vehicleType'] != 'none':
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(
[self.__filters['vehicleType']])
if self.__filters['isMain']:
criteria |= REQ_CRITERIA.VEHICLE.FAVORITE
if self.__filters['level'] != -1:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS(
[self.__filters['level']])
else:
vehicleIds = eventData.getLimits().getVehicles(self.__lid)
leaderboard = eventData.getLeaderboard(self.__lid)
if eventType == EVENT_TYPE.NATION:
title = _ms('#menu:nation_tree/title/{}'.format(leaderboard))
bgPath = '../maps/icons/eventBoards/flagsOverlay/{}.png'.format(
leaderboard)
elif eventType == EVENT_TYPE.LEVEL:
title = _ms(EVENT_BOARDS.VEHICLES_LEVEL,
level=int2roman(leaderboard))
bgPath = None
elif eventType == EVENT_TYPE.CLASS:
title = _ms('#quests:classes/{}'.format(leaderboard))
bgPath = None
else:
title = None
bgPath = None
allVehicles = self.itemsCache.items.getVehicles(
REQ_CRITERIA.IN_CD_LIST(vehicleIds))
vehicles = allVehicles.filter(criteria).values()
vehicles.sort(key=lambda v: v.isInInventory, reverse=True)
vehiclesVO = [makeVehicleVO(vehicle) for vehicle in vehicles]
data = {'title': title, 'bgPath': bgPath, 'vehicles': vehiclesVO}
self.as_setVehiclesS(data)
return
def _applyFilter(self, items, season):
isBuy = self._proxy.isBuy
requirement = REQ_CRITERIA.EMPTY
seasonAndTabData = self._allSeasonAndTabFilterData[
self._tabIndex][season]
allItemsGroup = len(seasonAndTabData.allGroups) - 1
if seasonAndTabData.selectedGroupIndex != allItemsGroup:
selectedGroup = seasonAndTabData.allGroups[
seasonAndTabData.selectedGroupIndex]
requirement |= REQ_CRITERIA.CUSTOM(
lambda item: selectedGroup in getGroupName(item, isBuy))
if self._historicOnlyItems:
requirement |= ~REQ_CRITERIA.CUSTOMIZATION.HISTORICAL
if self._onlyOwnedAndFreeItems:
requirement |= REQ_CRITERIA.CUSTOM(
lambda item: self._proxy.getItemInventoryCount(item) > 0)
sub = REQ_CRITERIA.IN_CD_LIST(
self._proxy.getAppliedItems(isOriginal=False))
if self._onlyAppliedItems:
requirement |= sub
else:
requirement ^= sub
if any(self._formfactorGroupsFilterByTabIndex[
self._tabIndex].itervalues()):
formfactors = [
formfactorGroup for formfactorGroup, value in self.
_formfactorGroupsFilterByTabIndex[self._tabIndex].iteritems()
if value
]
requirement |= REQ_CRITERIA.CUSTOM(lambda item: not hasattr(
item, 'formfactor') or item.formfactor in formfactors)
if self._propertySheetShow:
slot = self.__ctx.selectedAnchor
if slot.slotType == GUI_ITEM_TYPE.PROJECTION_DECAL:
anchor = self._currentVehicle.item.getAnchorBySlotId(
slot.slotType, slot.areaId, slot.regionIdx)
requirement |= REQ_CRITERIA.CUSTOM(
lambda item: not hasattr(item, 'formfactor') or item.
formfactor in anchor.formfactors)
requirement |= REQ_CRITERIA.CUSTOM(
lambda item: not self._proxy.isBuy or not item.isHiddenInUI())
filteredItems = {k: v for k, v in items.iteritems() if requirement(v)}
return filteredItems
def _buildSupplyItems(self):
self._supplyItems = []
items = self._itemsCache.items
inventory = self._itemsCache.items.inventory
slots = items.stats.vehicleSlots
slotPrice = items.shop.getVehicleSlotsPrice(slots)
defaultSlotPrice = items.shop.defaults.getVehicleSlotsPrice(slots)
self._emptySlotsCount = inventory.getFreeSlots(slots)
criteria = REQ_CRITERIA.IN_CD_LIST(items.recycleBin.getVehiclesIntCDs()) | REQ_CRITERIA.VEHICLE.IS_RESTORE_POSSIBLE
self._restorableVehiclesCount = len(items.getVehicles(criteria))
if slotPrice != defaultSlotPrice:
discount = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'slotsPrices', True, Money(gold=slotPrice), Money(gold=defaultSlotPrice))
else:
discount = None
smallBuySlotString, buySlotString = getStatusStrings('buySlot')
smallBuyTankString, buyTankString = getStatusStrings('buyTank')
smallRestoreTankString, restoreTankString = getStatusStrings('restoreTank')
smallRestoreTankCountString, restoreTankCountString = getStatusStrings('restoreTankCount', style=text_styles.main, ctx={'count': self._restorableVehiclesCount})
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})
self._supplyItems.append({'restoreTank': True,
'smallInfoText': text_styles.concatStylesToMultiLine(smallRestoreTankString, smallRestoreTankCountString),
'infoText': text_styles.concatStylesToMultiLine(restoreTankString, restoreTankCountString),
'icon': RES_ICONS.MAPS_ICONS_LIBRARY_TANKITEM_BUY_TANK,
'tooltip': TOOLTIPS.TANKS_CAROUSEL_RESTORE_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 __makeVO(self):
vehIdList = self.itemsCache.items.sessionStats.getStatsVehList(
ARENA_BONUS_TYPE.REGULAR)
vehiclesDict = self.itemsCache.items.getVehicles(
REQ_CRITERIA.IN_CD_LIST(vehIdList))
vehiclesData = []
vehiclesSortData = []
if vehiclesDict:
for intCD, vehicle in vehiclesDict.iteritems():
data = self.itemsCache.items.sessionStats.getVehiclesStats(
ARENA_BONUS_TYPE.REGULAR, intCD)
vehiclesSortData.append((intCD, (data.battleCnt, vehicle.level,
data.averageDamage.value)))
vehiclesData.append({
'intCD':
intCD,
'icon':
vehicle.iconSmall,
'label':
text_styles.main(vehicle.shortUserName),
'level':
vehicle.level,
'nationIcon':
getNationIcon(vehicle.nationID, width=155, height=31),
'type':
vehicle.type,
'total':
text_styles.stats(toNiceNumber(data.battleCnt)),
'damage':
text_styles.stats(toIntegral(data.averageDamage.value)),
'wtr':
text_styles.stats(toNiceNumber(data.wtr.value)),
'delta':
getDeltaAsData(data.wtr.delta)
})
else:
vehiclesData.append({
'intCD':
None,
'icon':
backport.image(R.images.gui.maps.icons.library.empty_veh()),
'total':
text_styles.stats(toNiceNumber(None)),
'damage':
text_styles.stats(toIntegral(None)),
'wtr':
text_styles.stats(toNiceNumber(None))
})
if vehiclesSortData:
vehiclesData = self._sortedVehiclesData(vehiclesSortData,
vehiclesData)
vehiclesData = vehiclesData[0:_VEH_LIST_LEN]
return {
'headerName':
text_styles.mainBig(
backport.text(R.strings.menu.inventory.menu.vehicle.name())),
'headerTotalIcon':
backport.image(R.images.gui.maps.icons.statistic.battles24()),
'headerTotalTooltip':
backport.text(
R.strings.session_stats.tooltip.header.battleCount()),
'headerDamageIcon':
backport.image(R.images.gui.maps.icons.statistic.avgDamage24()),
'headerDamageTooltip':
backport.text(R.strings.session_stats.tooltip.header.avgDamage()),
'headerWtrIcon':
backport.image(R.images.gui.maps.icons.library.wtrIcon_24()),
'headerWtrTooltip':
backport.text(R.strings.session_stats.tooltip.header.wtr()),
'vehicles':
vehiclesData
}
def getActiveTradeOffVehicle(self):
return first(self.itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY | REQ_CRITERIA.IN_CD_LIST([self.__activeTradeOffCD])).values()) if self.__activeTradeOffCD else None
def __getRewardVehicles(self):
rewardVehiclesIds = [intCD for intCD, _ in self.rewardVehicles]
rewardVehicles = self.__itemsCache.items.getVehicles(
REQ_CRITERIA.IN_CD_LIST(rewardVehiclesIds))
return [rewardVehicles[intCD] for intCD in rewardVehiclesIds]
def updateVehicles(self,
vehicles=None,
filterCriteria=None,
updateFallout=True):
isSet = vehicles is None and filterCriteria is None
filterCriteria = filterCriteria or REQ_CRITERIA.INVENTORY
if vehicles is not None:
filterCriteria |= REQ_CRITERIA.IN_CD_LIST(vehicles)
items = g_itemsCache.items
filteredVehs = items.getVehicles(filterCriteria)
if vehicles is None:
vehicles = filteredVehs.keys()
hasEmptySlots = self.__multiselectionMode and len(
self.__falloutCtrl.getEmptySlots()) > 0
hasRequiredVehicles = self.__falloutCtrl.getConfig(
).hasRequiredVehicles()
vehsData = {}
multiselectionsData = {}
for intCD in vehicles:
vehicle = filteredVehs.get(intCD)
vehData = None
if vehicle is not None:
vState, vStateLvl = vehicle.getState()
isNotSuitableVeh = not self.__falloutCtrl.isSuitableVeh(
vehicle)
if isNotSuitableVeh:
vState, vStateLvl = Vehicle.VEHICLE_STATE.NOT_SUITABLE, Vehicle.VEHICLE_STATE_LEVEL.WARNING
rentInfoStr = RentLeftFormatter(
vehicle.rentInfo, vehicle.isPremiumIGR).getRentLeftStr()
vehData = self._getVehicleData(vehicle, vState, vStateLvl,
rentInfoStr)
multiselectionsData[intCD] = self.__packMultiselectionFlags(
self.__multiselectionMode and vehicle.isFalloutSelected,
self.__falloutCtrl.canSelectVehicle(vehicle),
hasRequiredVehicles and hasEmptySlots
or vehicle.isFalloutSelected)
vehsData[intCD] = vehData
LOG_DEBUG('Updating carousel vehicles: {0}'.format(
vehsData if not isSet else 'full sync'))
self.as_updateVehiclesS(vehsData, isSet)
self.as_setMultiselectionButtonLabelsS(
FALLOUT.TANKCAROUSELSLOT_ACTIVATEBUTTON,
FALLOUT.TANKCAROUSELSLOT_DEACTIVATEBUTTON,
self.__falloutCtrl.carouselSelectionButtonTooltip())
self.as_updateMultiselectionDataS(multiselectionsData)
isVehTypeLock = sum(
(len(v) for v in items.stats.vehicleTypeLocks.itervalues()))
isGlobalVehLock = sum(
(len(v) for v in items.stats.globalVehicleLocks.itervalues()))
if self.__updateVehiclesTimerId is None and (isVehTypeLock
or isGlobalVehLock):
self.__updateVehiclesTimerId = BigWorld.callback(
_UPDATE_LOCKS_PERIOD, self.updateLockTimers)
LOG_DEBUG('Lock timer updated')
self._initializeFilters()
if self.__multiselectionMode and updateFallout and not isSet:
self._updateFallout()
else:
self.showVehicles()
return
def _makeCriteria(intCD):
return REQ_CRITERIA.INVENTORY | REQ_CRITERIA.IN_CD_LIST([intCD])
def getInventoryVehicles(self):
nodeCDs = [node.getNodeCD() for node in self._getNodesToInvalidate()]
_logger.debug('getInventoryVehicles: %r', nodeCDs)
inventoryVehicles = self._items.getVehicles(
REQ_CRITERIA.INVENTORY | REQ_CRITERIA.IN_CD_LIST(nodeCDs))
return {item.invID: item for item in inventoryVehicles.itervalues()}
