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 = 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 _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 __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 __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 _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 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 __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 _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 __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 _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 _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 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 _getItemCriteria(self): invVehicles = self._itemsCache.items.getVehicles( REQ_CRITERIA.INVENTORY) installedSet = set( (booster for veh in invVehicles.itervalues() for booster in veh.battleBoosters.installed.getIntCDs())) return REQ_CRITERIA.CUSTOM(lambda item: not item.isCrewBooster() and (not item.isHidden or item.isInInventory or item.intCD in installedSet))
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)
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 _getCriteria(self): skillItemIDs = [] allSkills = self.__epicMetaGameCtrl.getAllSkillsInformation().values() for skillInfo in allSkills: skillExample = skillInfo.getMaxUnlockedSkillLevel( ) or skillInfo.levels[skillInfo.maxLvl] skillItemIDs.append(skillExample.eqID) return REQ_CRITERIA.CUSTOM( lambda item: item.innationID in skillItemIDs)
def _getOptionalDeviceCD(name, itemsCache=None): if name is None or itemsCache is None: return else: opts = itemsCache.items.getItems(GUI_ITEM_TYPE.OPTIONALDEVICE, REQ_CRITERIA.CUSTOM(lambda opt: name in opt.name)) if opts: result, _ = opts.popitem() else: result = None return result
def _getEquipmentForCreditsCD(tag, itemsCache=None): if tag is None or itemsCache is None: return else: equipments = itemsCache.items.getItems(GUI_ITEM_TYPE.EQUIPMENT, REQ_CRITERIA.CUSTOM(lambda eq: tag in eq.tags and eq.buyPrices.hasPriceIn(Currency.CREDITS))) if equipments: result, _ = equipments.popitem() else: result = None return result
def _getItemCriteria(self): invVehicles = self._itemsCache.items.getVehicles( REQ_CRITERIA.INVENTORY) installedSet = set( (optDevice for veh in invVehicles.itervalues() for optDevice in veh.optDevices.setupLayouts.getIntCDs())) return REQ_CRITERIA.CUSTOM(lambda item: item.isTrophy and ( item.isInInventory or item.intCD in installedSet) or item.isDeluxe and (not item.isHidden or item.isInInventory or item.intCD in installedSet))
def _buildCustomizationItems(self): seasonID = self._seasonID tabIndex = self._tabIndex builtAllCustomizationItems = self._builtAllCustomizationItems if seasonID not in builtAllCustomizationItems or tabIndex not in builtAllCustomizationItems[ seasonID]: allCustomizationItems = {} builtAllCustomizationItems.setdefault( seasonID, {})[tabIndex] = allCustomizationItems requirement = self._createBaseRequestCriteriaBySeason(seasonID) if not self._proxy.isBuy: requirement |= REQ_CRITERIA.CUSTOM( partial(self.isItemSuitableForTab, self._tabIndex)) allCustomizationItems.update( self.itemsCache.items.getItems( TABS_ITEM_TYPE_MAPPING[tabIndex], requirement, onlyWithPrices=self._proxy.isBuy)) items = self._builtCustomizationItems if seasonID not in items or tabIndex not in items[seasonID]: filteredItems = self._applyFilter( builtAllCustomizationItems[seasonID][tabIndex], self._seasonID) customizationItems = [] customizationBookmarks = [] itemSizeData = [] isBuy = self._proxy.isBuy lastGroup = None for item in sorted(filteredItems.itervalues(), key=self.CSComparisonKey): groupName = getGroupName(item, isBuy) group = item.groupID if isBuy else groupName if group != lastGroup: lastGroup = group customizationBookmarks.append( CustomizationBookmarkVO( groupName, len(customizationItems)).asDict()) customizationItems.append(item.intCD) itemSizeData.append(item.isWide()) self._customizationItems = customizationItems self._customizationBookmarks = customizationBookmarks self._itemSizeData = itemSizeData items.setdefault(self._seasonID, {})[self._tabIndex] = (customizationItems, customizationBookmarks, itemSizeData) else: self._customizationItems, self._customizationBookmarks, self._itemSizeData = items[ self._seasonID][self._tabIndex] self._selectedIdx = -1 if self._selectIntCD in self._customizationItems: self._selectedIdx = self._customizationItems.index( self._selectIntCD) self._proxy.setCarouselItems(self.collection)
def _getRequestCriteria(self, invVehicles): requestCriteria = super(ShopVehicleTab, self)._getRequestCriteria(invVehicles) requestCriteria = requestCriteria | ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR requestType = self.filterData['requestType'] extra = self.filterData['extra'] if 'all' not in requestType: requestType = map(lambda x: x.lower(), requestType) requestCriteria |= REQ_CRITERIA.CUSTOM( lambda item: item.type.lower() in requestType) return self._getExtraCriteria(extra, requestCriteria, invVehicles)
def __getBoosterReplaceCriteria(self, vehInvID): vehicleToInstall = self.__itemsCache.items.getVehicle(vehInvID) skillLearn = REQ_CRITERIA.CUSTOM( lambda item: not item.isAffectedSkillLearnt(vehicleToInstall)) return { ItemHighlightTypes.BATTLE_BOOSTER_REPLACE: REQ_CRITERIA.BATTLE_BOOSTER.CREW_EFFECT | skillLearn, ItemHighlightTypes.BATTLE_BOOSTER: (REQ_CRITERIA.BATTLE_BOOSTER.CREW_EFFECT | ~skillLearn) ^ REQ_CRITERIA.BATTLE_BOOSTER.OPTIONAL_DEVICE_EFFECT }
def _createBaseRequirements(self, season=None, includeApplied=True): appliedItems = self._proxy.getAppliedItems() vehicle = self._currentVehicle.item season = season or SeasonType.ALL progress = self.eventsCache.randomQuestsProgress criteria = REQ_CRITERIA.CUSTOM( lambda item: item.mayInstall(vehicle) and item.season & season and (not item.isHidden or item.fullInventoryCount(vehicle) > 0 or includeApplied and item.intCD in appliedItems) and (not item.requiredToken or progress.getTokenCount( item.requiredToken) > 0)) return criteria
def _getItemCriteria(self): invVehicles = self._itemsCache.items.getVehicles( REQ_CRITERIA.INVENTORY) trophySet = set() for veh in invVehicles.itervalues(): for optDevice in veh.optDevices.installed.getItems(): if optDevice.isTrophy: trophySet.add(optDevice.intCD) return REQ_CRITERIA.CUSTOM(lambda item: item.isTrophy and ( item.isInInventory or item.intCD in trophySet) ) ^ REQ_CRITERIA.OPTIONAL_DEVICE.DELUXE
def createCustomizationBaseRequestCriteria(vehicle, progress, appliedItems, season=None, itemTypeID=None): season = season or SeasonType.ALL criteria = REQ_CRITERIA.CUSTOM( lambda item: item.mayInstall(vehicle) and item.season & season and (not item.isHidden or item.fullInventoryCount(vehicle) > 0 or appliedItems and item.intCD in appliedItems) and (not item.requiredToken or progress.getTokenCount(item.requiredToken) > 0) and (not itemTypeID or item.itemTypeID == itemTypeID)) return criteria
def _getEquipmentForCreditsCD(tag): if tag is None: return else: equipments = g_itemsCache.items.getItems( GUI_ITEM_TYPE.EQUIPMENT, REQ_CRITERIA.CUSTOM( lambda eq: tag in eq.tags and eq.buyPrice.credits > 0)) if equipments: result, _ = equipments.popitem() else: result = None return result
def __createFilterCriteria(self): requirement = REQ_CRITERIA.EMPTY groupIdx = self.__getSelectedGroupIdx() if groupIdx is not None and groupIdx != -1: itemsData = self.__carouselCache.getItemsData() groupId = itemsData.groups.keys()[groupIdx] groupName = itemsData.groups[groupId] requirement |= REQ_CRITERIA.CUSTOMIZATION.ONLY_IN_GROUP(groupName) for carouselFilter in self.__carouselFilters.itervalues(): if carouselFilter.isEnabled(): requirement |= carouselFilter.criteria slotId = self.__ctx.mode.selectedSlot if slotId is not None and slotId.slotType == GUI_ITEM_TYPE.PROJECTION_DECAL: slot = g_currentVehicle.item.getAnchorBySlotId( slotId.slotType, slotId.areaId, slotId.regionIdx) requirement |= REQ_CRITERIA.CUSTOM( lambda item: item.formfactor in slot.formfactors) if self.__dependentItems: requirement |= REQ_CRITERIA.CUSTOM( lambda item: not (ItemTags.HIDE_IF_INCOMPATIBLE in item.tags and item.intCD not in self.__dependentItems)) if self.__ctx.mode.modeId == CustomizationModes.CUSTOM: requirement |= REQ_CRITERIA.CUSTOM( lambda item: not item.isStyleOnly) if self.__ctx.mode.modeId == CustomizationModes.EDITABLE_STYLE and self.__ctx.mode.tabId == CustomizationTabs.PROJECTION_DECALS: baseOutfit = self.__ctx.mode.baseOutfits.get( self.__ctx.mode.season) if baseOutfit: baseComponent = baseOutfit.pack() taggedDecals = [ decal.id for decal in baseComponent.projection_decals if decal.matchingTag ] requirement |= REQ_CRITERIA.CUSTOM( lambda item: item.id not in taggedDecals) return requirement
def _update(self): if g_currentPreviewVehicle.isPresent(): self.as_setModulesEnabledS(True) vehicle = g_currentPreviewVehicle.item devices = [] self.as_setModulesEnabledS(True) self.as_setVehicleHasTurretS(vehicle.hasTurrets) for slotType in _MODULE_SLOTS: data = g_itemsCache.items.getItems( GUI_ITEM_TYPE_INDICES[slotType], REQ_CRITERIA.CUSTOM( lambda item: item.isInstalled(vehicle))).values() devices.append(FittingSlotVO(data, vehicle, slotType)) self.as_setDataS({'devices': devices})