def _buildCustomizationItems(self):
season = self._seasonID
requirement = createCustomizationBaseRequestCriteria(self._currentVehicle.item, self.eventsCache.questsProgress, self._proxy.getAppliedItems(), season)
seasonAndTabData = self._allSeasonAndTabFilterData[self._tabIndex][season]
allItemsGroup = len(seasonAndTabData.allGroups) - 1
if seasonAndTabData.selectedGroupIndex != allItemsGroup:
selectedGroup = seasonAndTabData.allGroups[seasonAndTabData.selectedGroupIndex]
requirement |= REQ_CRITERIA.CUSTOMIZATION.ONLY_IN_GROUP(selectedGroup)
if self._historicOnlyItems:
requirement |= ~REQ_CRITERIA.CUSTOMIZATION.HISTORICAL
if self._onlyOwnedAndFreeItems:
requirement |= REQ_CRITERIA.CUSTOM(lambda item: self._proxy.getItemInventoryCount(item) > 0)
if self._onlyAppliedItems:
appliedItems = self._proxy.getAppliedItems(isOriginal=False)
requirement |= REQ_CRITERIA.CUSTOM(lambda item: item.intCD in appliedItems)
allItems = self.itemsCache.items.getItems(TABS_ITEM_MAPPING[self._tabIndex], requirement)
self._customizationItems = []
self._customizationBookmarks = []
lastGroupID = None
for idx, item in enumerate(sorted(allItems.itervalues(), key=comparisonKey)):
if item.isHiddenInUI():
continue
groupID = item.groupID
if item.intCD == self._selectIntCD:
self._selectedIdx = len(self._customizationItems)
self._selectIntCD = None
if groupID != lastGroupID:
lastGroupID = groupID
self._customizationBookmarks.append(CustomizationBookmarkVO(item.groupUserName, idx).asDict())
self._customizationItems.append(item.intCD)
self._itemSizeData.append(item.isWide())
return
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 _getRequestCriteria(self, invVehicles):
requestCriteria = REQ_CRITERIA.EMPTY | ~REQ_CRITERIA.CUSTOM(lambda item: item.isHidden and not item.isRestorePossible()) | ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
vehicleType = self._filterData['vehicleType']
if vehicleType != 'all':
vehicleType = vehicleType.lower()
requestCriteria |= REQ_CRITERIA.CUSTOM(lambda item: item.type.lower() == vehicleType)
return self._getExtraCriteria(self._filterData['extra'], requestCriteria, invVehicles)
def _buildCustomizationItems(self):
season = self._seasonID
requirement = _createBaseRequirements(season) | REQ_CRITERIA.CUSTOM(
lambda i: self.isItemSuitableForTab(i, self._tabIndex))
seasonAndTabData = self._allSeasonAndTabFilterData[self._tabIndex][self._seasonID]
allItemsGroup = len(seasonAndTabData.allGroups) - 1
if seasonAndTabData.selectedGroupIndex != allItemsGroup:
selectedGroup = seasonAndTabData.allGroups[seasonAndTabData.selectedGroupIndex]
requirement |= REQ_CRITERIA.CUSTOMIZATION.ONLY_IN_GROUP(selectedGroup)
if self._historicOnlyItems:
requirement |= REQ_CRITERIA.CUSTOMIZATION.HISTORICAL
if self._onlyOwnedAndFreeItems:
requirement |= REQ_CRITERIA.CUSTOM(lambda x: self._proxy.getItemInventoryCount(x) > 0)
if self._onlyAppliedItems:
appliedItems = self._proxy.getAppliedItems(isOriginal=False)
requirement |= REQ_CRITERIA.CUSTOM(lambda x: x.intCD in appliedItems)
allItems = self._getAllItems(requirement)
self._customizationItems = []
self._customizationBookmarks = []
lastGroupName = None
for idx, item in enumerate(sorted(allItems.itervalues(), key=comparisonKey)):
groupName = getGroupName(item)
if item.intCD == self._selectIntCD:
self._selectedIdx = len(self._customizationItems)
self._selectIntCD = None
if groupName != lastGroupName:
lastGroupName = groupName
self._customizationBookmarks.append(CustomizationBookmarkVO(groupName, idx).asDict())
self._customizationItems.append(item.intCD)
self._itemSizeData.append(item.isWide())
def getRetrainingData(self, targetVehicle, callback):
items = self.itemsCache.items
tankman = items.getTankman(self.tmanInvID)
nativeVehicleCD = tankman.vehicleNativeDescr.type.compactDescr
maxResearchedLevel = items.stats.getMaxResearchedLevel(tankman.nationID)
criteria = ~(~REQ_CRITERIA.UNLOCKED | ~(REQ_CRITERIA.COLLECTIBLE | REQ_CRITERIA.VEHICLE.LEVELS(range(1, maxResearchedLevel + 1))))
criteria |= REQ_CRITERIA.NATIONS([tankman.nationID]) | ~REQ_CRITERIA.VEHICLE.OBSERVER
criteria |= ~REQ_CRITERIA.VEHICLE.IS_CREW_LOCKED
criteria |= ~(REQ_CRITERIA.SECRET | ~REQ_CRITERIA.INVENTORY_OR_UNLOCKED)
criteria |= ~REQ_CRITERIA.VEHICLE.BATTLE_ROYALE
if not constants.IS_IGR_ENABLED:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if constants.IS_DEVELOPMENT:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_BOT
vData = items.getVehicles(criteria)
tDescr = tankman.descriptor
vehiclesData = vData.values()
if nativeVehicleCD not in vData:
vehiclesData.append(items.getItemByCD(nativeVehicleCD))
result = []
for vehicle in sorted(vehiclesData):
vDescr = vehicle.descriptor
for role in vDescr.type.crewRoles:
if tDescr.role == role[0]:
result.append({'intCD': vehicle.intCD,
'vehicleType': vehicle.type,
'userName': vehicle.shortUserName})
break
callback({'vehicles': result,
'retrainButtonsData': packTraining(targetVehicle, [tankman])})
def _getRequestCriteria(self, invVehicles):
requestCriteria = REQ_CRITERIA.VEHICLE.IS_RESTORE_POSSIBLE
vehicleType = self._filterData['vehicleType']
if vehicleType != 'all':
vehicleType = vehicleType.lower()
requestCriteria |= REQ_CRITERIA.CUSTOM(lambda item: item.type.lower() == vehicleType)
return requestCriteria
def __initItemsData(self):
self.__itemsData.clear()
requirement = createCustomizationBaseRequestCriteria(
g_currentVehicle.item, self.__eventsCache.questsProgress,
self.__ctx.mode.getAppliedItems())
requirement |= REQ_CRITERIA.CUSTOM(
lambda item: not item.isHiddenInUI())
itemTypes = []
for tabId, slotType in CustomizationTabs.SLOT_TYPES.iteritems():
if vehicleHasSlot(slotType):
itemTypes.extend(CustomizationTabs.ITEM_TYPES[tabId])
allItems = self.__itemsCache.items.getItems(tuple(itemTypes),
requirement)
sortedItems = sorted(allItems.itervalues(), key=comparisonKey)
customModeTabs = CustomizationTabs.MODES[CustomizationModes.CUSTOM]
for item in sortedItems:
tabId = ITEM_TYPE_TO_TAB[item.itemTypeID]
modeId = CustomizationModes.CUSTOM if tabId in customModeTabs else CustomizationModes.STYLED
for season in SeasonType.COMMON_SEASONS:
if not item.season & season:
continue
itemsDataStorage = self.__itemsData[modeId][season]
if not itemsDataStorage or tabId != itemsDataStorage.keys(
)[-1]:
itemsDataStorage[tabId] = ItemsData()
itemsData = itemsDataStorage.values()[-1]
if not itemsData.groups or item.groupID != itemsData.groups.keys(
)[-1]:
itemsData.groups[item.groupID] = item.groupUserName
itemsData.items.append(item)
def __showStylePreview(self, styleID):
styledVehicleCD = None
minLvl, _ = self.__rankedController.getSuitableVehicleLevels()
if g_currentVehicle.isPresent() and g_currentVehicle.item.level >= minLvl:
styledVehicleCD = g_currentVehicle.item.intCD
else:
accDossier = self.__itemsCache.items.getAccountDossier()
vehicles = accDossier.getRankedStats().getVehicles()
if not vehicles:
vehicles = accDossier.getRandomStats().getVehicles()
if vehicles:
sortedVehicles = sorted(vehicles.items(), key=lambda vStat: vStat[1].battlesCount, reverse=True)
for vehicleCD, _ in sortedVehicles:
vehicleType = getVehicleType(vehicleCD)
if vehicleType.level >= minLvl:
styledVehicleCD = vehicleCD
break
if not styledVehicleCD:
vehiclesPool = AccountSettings.getSettings(RANKED_STYLED_VEHICLES_POOL)
if not vehiclesPool:
vehiclesPool = list(_DEFAULT_STYLED_VEHICLES)
vehicleName = vehiclesPool.pop(0)
styledVehicleCD = VehicleDescriptor(typeName=vehicleName).type.compactDescr
vehiclesPool.append(vehicleName)
AccountSettings.setSettings(RANKED_STYLED_VEHICLES_POOL, vehiclesPool)
styleDescr = self.__styleDescriptions.get(styleID, '')
style = first(self.__itemsCache.items.getStyles(REQ_CRITERIA.CUSTOM(lambda item: item.id == styleID)).values())
showStylePreview(styledVehicleCD, style, styleDescr, self._backToLeaguesCallback)
return
def getRetrainingData(self, targetVehicle, callback):
items = self.itemsCache.items
tankman = items.getTankman(self.tmanInvID)
nativeVehicleCD = tankman.vehicleNativeDescr.type.compactDescr
criteria = REQ_CRITERIA.NATIONS([
tankman.nationID
]) | REQ_CRITERIA.UNLOCKED | ~REQ_CRITERIA.VEHICLE.OBSERVER
if not constants.IS_IGR_ENABLED:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if constants.IS_DEVELOPMENT:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_BOT
vData = items.getVehicles(criteria)
tDescr = tankman.descriptor
vehiclesData = vData.values()
if nativeVehicleCD not in vData:
vehiclesData.append(items.getItemByCD(nativeVehicleCD))
result = []
for vehicle in sorted(vehiclesData):
vDescr = vehicle.descriptor
for role in vDescr.type.crewRoles:
if tDescr.role == role[0]:
result.append({
'intCD': vehicle.intCD,
'vehicleType': vehicle.type,
'userName': vehicle.shortUserName
})
break
callback({
'vehicles': result,
'retrainButtonsData': packTraining(targetVehicle, [tankman])
})
def getCollectibleVehiclesInInventory(nationID=ALL_NATIONS_INDEX, itemsCache=None):
if nationID == ALL_NATIONS_INDEX:
criteria = REQ_CRITERIA.COLLECTIBLE | REQ_CRITERIA.INVENTORY
else:
criteria = REQ_CRITERIA.NATIONS((nationID,)) | REQ_CRITERIA.COLLECTIBLE | REQ_CRITERIA.INVENTORY
items = itemsCache.items.getVehicles(criteria)
return items
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 _updateData(self,
allVehicles,
levelsRange,
vehicleTypes,
isVehicleRoster=False):
criteria = REQ_CRITERIA.EMPTY
criteria |= ~REQ_CRITERIA.VEHICLE.EXPIRED_IGR_RENT
criteria |= ~REQ_CRITERIA.VEHICLE.DISABLED_IN_PREM_IGR
if not self.showNotReadyVehicles:
criteria |= REQ_CRITERIA.VEHICLE.READY
if self.__filters:
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']])
filteredVehicles = allVehicles.filter(criteria)
if self.__filters.get('compatibleOnly', True):
predicate = lambda vo: vo.get('enabled')
else:
predicate = lambda vo: True
result = []
makeVehicleVOAction = makeVehicleBasicVO if isVehicleRoster else makeVehicleVO
for v in filteredVehicles.itervalues():
vo = makeVehicleVOAction(v, levelsRange, vehicleTypes)
if predicate(vo):
result.append(vo)
return result
def __fullUpdate(self):
self.__invVehsIntCD = []
invVehicles = self.itemsCache.items.getVehicles(
REQ_CRITERIA.CUSTOM(lambda item: item.inventoryCount > 0 or item.
isRestorePossible())).values()
for invVeh in invVehicles:
self.__invVehsIntCD.append(invVeh.intCD)
def __containsVehicle(self, vehicleCD):
def contains(i):
return i.intCD == vehicleCD and (i.inventoryCount > 0
or i.isRestorePossible())
return any(
self.itemsCache.items.getVehicles(REQ_CRITERIA.CUSTOM(contains)))
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 __updateDevices(self, vehicle):
devices = []
self.__updateAmmo()
self.as_setModulesEnabledS(True)
self.as_setVehicleHasTurretS(vehicle.hasTurrets)
for slotType in AmmunitionPanel.__FITTING_SLOTS:
data = g_itemsCache.items.getItems(
GUI_ITEM_TYPE_INDICES[slotType],
REQ_CRITERIA.CUSTOM(
lambda item: item.isInstalled(vehicle))).values()
if slotType in AmmunitionPanel.__ARTEFACTS_SLOTS:
for slotId in xrange(self.OPTIONAL_DEVICE_SLOTS_COUNT):
devices.append(
FittingSlotVO(data, vehicle, slotType, slotId,
TOOLTIPS_CONSTANTS.HANGAR_MODULE))
else:
devices.append(
FittingSlotVO(
data,
vehicle,
slotType,
tooltipType=TOOLTIPS_CONSTANTS.HANGAR_MODULE))
self.as_setDataS({'devices': devices})
def getRetrainingData(self, callback):
items = g_itemsCache.items
tankman = items.getTankman(self.tmanInvID)
nativeVehicleCD = tankman.vehicleNativeDescr.type.compactDescr
criteria = REQ_CRITERIA.NATIONS([tankman.nationID]) | REQ_CRITERIA.UNLOCKED
vData = items.getVehicles(criteria)
tDescr = tankman.descriptor
vehiclesData = vData.values()
if nativeVehicleCD not in vData:
vehiclesData.append(items.getItemByCD(nativeVehicleCD))
result = []
for vehicle in sorted(vehiclesData):
vDescr = vehicle.descriptor
if isVehicleObserver(vDescr.type.compactDescr):
continue
for role in vDescr.type.crewRoles:
if tDescr.role == role[0]:
result.append({'innationID': vehicle.innationID,
'vehicleType': vehicle.type,
'userName': vehicle.shortUserName})
break
shopPrices, action = items.shop.getTankmanCostWithDefaults()
callback({'money': items.stats.money,
'tankmanCost': shopPrices,
'action': action,
'vehicles': result})
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 isVehicleCanBeCustomized(vehicle, itemTypeID, itemsFilter=None):
if itemTypeID not in C11N_ITEM_TYPE_MAP:
_logger.error(
'Failed to get customization item from cache. Wrong itemTypeID: %s',
itemTypeID)
return False
else:
cType = C11N_ITEM_TYPE_MAP[itemTypeID]
customizationCache = g_cache.customization20().itemTypes
if cType not in customizationCache:
_logger.error(
'Failed to get customization item from cache. Wrong cType: %s',
cType)
return False
for areaId in Area.ALL:
if any(vehicle.getAnchors(itemTypeID, areaId)):
break
else:
return False
customizationService = dependency.instance(ICustomizationService)
eventsCache = dependency.instance(IEventsCache)
requirement = createCustomizationBaseRequestCriteria(
vehicle, eventsCache.questsProgress, set(), itemTypeID=itemTypeID)
if itemsFilter is not None:
requirement |= REQ_CRITERIA.CUSTOM(itemsFilter)
for itemID in customizationCache[cType]:
item = customizationService.getItemByID(itemTypeID, itemID)
if requirement(item):
return True
return False
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 getRetrainingData(self, callback):
items = self.itemsCache.items
tankman = items.getTankman(self.tmanInvID)
nativeVehicleCD = tankman.vehicleNativeDescr.type.compactDescr
criteria = REQ_CRITERIA.NATIONS([
tankman.nationID
]) | REQ_CRITERIA.UNLOCKED | ~REQ_CRITERIA.VEHICLE.OBSERVER
if not constants.IS_IGR_ENABLED:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if constants.IS_DEVELOPMENT:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_BOT
vData = items.getVehicles(criteria)
tDescr = tankman.descriptor
vehiclesData = vData.values()
if nativeVehicleCD not in vData:
vehiclesData.append(items.getItemByCD(nativeVehicleCD))
result = []
for vehicle in sorted(vehiclesData):
vDescr = vehicle.descriptor
for role in vDescr.type.crewRoles:
if tDescr.role == role[0]:
result.append({
'innationID': vehicle.innationID,
'vehicleType': vehicle.type,
'userName': vehicle.shortUserName
})
break
shopPrices, action = items.shop.getTankmanCostWithDefaults()
callback({
'money': items.stats.money.toMoneyTuple(),
'tankmanCost': shopPrices,
'action': action,
'vehicles': result
})
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 _updateData(self, allVehicles, compatiblePredicate=lambda vo: vo.get('enabled')):
criteria = REQ_CRITERIA.EMPTY | REQ_CRITERIA.VEHICLE.ACTIVE_OR_MAIN_IN_NATION_GROUP
criteria |= ~REQ_CRITERIA.VEHICLE.EXPIRED_IGR_RENT
criteria |= ~REQ_CRITERIA.VEHICLE.DISABLED_IN_PREM_IGR
if not self.showNotReadyVehicles:
criteria |= REQ_CRITERIA.VEHICLE.READY
if self.__filters:
nations, levels, classes = self._parseFilters()
if nations:
criteria |= REQ_CRITERIA.NATIONS(nations)
if classes:
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(classes)
if self.__filters['isMain']:
criteria |= REQ_CRITERIA.VEHICLE.FAVORITE
if levels:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS(levels)
filteredVehicles = allVehicles.filter(criteria)
if self.__filters.get('compatibleOnly', True):
predicate = compatiblePredicate
else:
predicate = lambda vo: True
result = []
for v in filteredVehicles.itervalues():
vo = self._makeVehicleVOAction(v)
if predicate(vo):
result.append(vo)
return result
def __buildCriteria(self):
criteria = REQ_CRITERIA.EMPTY
if self.filter['nation'] != -1:
criteria |= REQ_CRITERIA.NATIONS([self.filter['nation']])
if self.filter['role'] != 'None':
criteria |= REQ_CRITERIA.TANKMAN.ROLES(self.filter['role'])
if self.filter['tankType'] != 'None':
criteria |= REQ_CRITERIA.CUSTOM(lambda tankman: tankman.vehicleNativeType == self.filter['tankType'])
if self.filter['location'] == BARRACKS_CONSTANTS.LOCATION_FILTER_TANKS or self.filter['location'] == '':
criteria |= REQ_CRITERIA.TANKMAN.IN_TANK
elif self.filter['location'] == BARRACKS_CONSTANTS.LOCATION_FILTER_BARRACKS:
criteria |= ~REQ_CRITERIA.TANKMAN.IN_TANK
if self.filter['nationID'] is not None:
vehicle = g_itemsCache.items.getItem(GUI_ITEM_TYPE.VEHICLE, int(self.filter['nationID']), int(self.filter['location']))
criteria |= REQ_CRITERIA.TANKMAN.NATIVE_TANKS([vehicle.intCD])
return criteria
def _getExtraCriteria(self, extra, requestCriteria, invVehicles):
if 'locked' not in extra:
requestCriteria |= REQ_CRITERIA.UNLOCKED
if 'inHangar' not in extra:
requestCriteria |= ~REQ_CRITERIA.INVENTORY
if 'onVehicle' not in extra:
requestCriteria |= ~REQ_CRITERIA.CUSTOM(lambda item: item.getInstalledVehicles(invVehicles))
return requestCriteria
def _getExtraCriteria(self, extra, requestCriteria, invVehicles):
if 'locked' not in extra:
requestCriteria |= REQ_CRITERIA.UNLOCKED
if 'inHangar' not in extra:
requestCriteria |= ~REQ_CRITERIA.CUSTOM(lambda item: item.inventoryCount > 0 and not item.isRented)
if 'rentals' not in extra:
requestCriteria |= ~REQ_CRITERIA.VEHICLE.RENT
return requestCriteria
def __getClassesCriteria(self, nationID):
maxResearchedLevel = self.itemsCache.items.stats.getMaxResearchedLevel(
nationID)
criteria = self.__getNationsCriteria() | REQ_CRITERIA.NATIONS(
[nationID])
criteria |= ~(REQ_CRITERIA.COLLECTIBLE | ~REQ_CRITERIA.VEHICLE.LEVELS(
range(1, maxResearchedLevel + 1)))
return criteria
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 checkVehClassForBattle():
vehicles = g_itemsCache.items.getVehicles(
REQ_CRITERIA.CUSTOM(
lambda v: v.type == g_currentVehicle.item.type)).values()
for vehicle in vehicles:
if vehicle.isInBattle():
return False
return True
def _getRequestCriteria(self, invVehicles):
requestCriteria = REQ_CRITERIA.EMPTY | ~REQ_CRITERIA.CUSTOM(
lambda item: item.isHidden and not item.isRestorePossible(
)) | ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
requestCriteria |= self._getVehicleRiterias(
self._filterData['selectedTypes'],
self._filterData['selectedLevels'])
return self._getExtraCriteria(self._filterData['extra'],
requestCriteria, invVehicles)
