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})
