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)