def _getRequestCriteria(self, invVehicles):
criteria = REQ_CRITERIA.INVENTORY
if self._currentTabId in (STORAGE_CONSTANTS.INVENTORY_TAB_ALL, STORAGE_CONSTANTS.INVENTORY_TAB_MODULES):
criteria |= REQ_CRITERIA.TYPE_CRITERIA(GUI_ITEM_TYPE.VEHICLE_MODULES, REQ_CRITERIA.VEHICLE.SUITABLE(invVehicles))
if self._currentTabId in (STORAGE_CONSTANTS.INVENTORY_TAB_ALL, STORAGE_CONSTANTS.INVENTORY_TAB_SHELLS):
criteria |= REQ_CRITERIA.TYPE_CRITERIA((GUI_ITEM_TYPE.SHELL,), storage_helpers.getStorageShellsCriteria(self._itemsCache, invVehicles, True))
return criteria
def _getRequestCriteria(self, invVehicles):
requestCriteria = super(InventoryShellTab,
self)._getRequestCriteria(invVehicles)
requestCriteria |= REQ_CRITERIA.INVENTORY
requestCriteria |= REQ_CRITERIA.CUSTOM(
lambda item: item.type in self._filterData['itemTypes'])
fitsType = self._filterData['fitsType']
if fitsType == 'myVehicleGun':
vehicle = self._items.getItemByCD(
int(self._filterData['vehicleCD']))
shellsList = [x.intCD for x in vehicle.gun.defaultAmmo]
requestCriteria |= REQ_CRITERIA.IN_CD_LIST(shellsList)
elif fitsType == 'myVehiclesInventoryGuns':
shellsList = set()
myGuns = self._items.getItems(GUI_ITEM_TYPE.GUN,
REQ_CRITERIA.INVENTORY).values()
for gun in myGuns:
shellsList.update((x.intCD for x in gun.defaultAmmo))
for vehicle in invVehicles:
shellsList.update((x.intCD for x in vehicle.gun.defaultAmmo))
requestCriteria |= REQ_CRITERIA.IN_CD_LIST(shellsList)
else:
shellsList = set()
myGuns = self._items.getItems(GUI_ITEM_TYPE.GUN,
REQ_CRITERIA.INVENTORY).values()
for gun in myGuns:
shellsList.update((x.intCD for x in gun.defaultAmmo))
for vehicle in invVehicles:
shellsList.update((x.intCD for x in vehicle.gun.defaultAmmo))
requestCriteria |= ~REQ_CRITERIA.IN_CD_LIST(shellsList)
return requestCriteria
def _getExtraCriteria(self, extra, requestCriteria, invVehicles):
if 'brocken' not in extra:
requestCriteria |= ~REQ_CRITERIA.CUSTOM(lambda item: item.repairCost > 0)
if 'locked' not in extra:
requestCriteria |= ~REQ_CRITERIA.VEHICLE.LOCKED
if 'premiumIGR' not in extra:
requestCriteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if IS_RENTALS_ENABLED and 'rentals' not in extra:
requestCriteria |= ~REQ_CRITERIA.CUSTOM(lambda item: item.isRented and not item.isPremiumIGR)
return requestCriteria
def canPlayerParticipate(self):
criteria = REQ_CRITERIA.INVENTORY
criteria |= ~REQ_CRITERIA.VEHICLE.EPIC_BATTLE
criteria |= REQ_CRITERIA.CUSTOM(
lambda veh: not self.hasMaxPointsOnVehicle(veh.intCD))
criteria |= REQ_CRITERIA.CUSTOM(
lambda veh: self.isProgressionOnVehiclePossible(veh.intCD))
availableVehiclesToProgression = self.__itemsCache.items.getVehicles(
criteria)
return len(availableVehiclesToProgression) > 0
def __getVehiclesData(self, nationID, nativeVehicleCD):
items = []
criteria = REQ_CRITERIA.NATIONS([nationID]) | REQ_CRITERIA.UNLOCKED
vehicles = self.__items.getVehicles(criteria)
vehiclesData = vehicles.values()
if nativeVehicleCD not in vehicles:
vehiclesData.append(self.__items.getItemByCD(nativeVehicleCD))
for vehicle in sorted(vehiclesData):
vDescr = vehicle.descriptor
if isVehicleObserver(vDescr.type.compactDescr):
continue
items.append({
'id': vehicle.intCD,
'type': vehicle.type,
'name': vehicle.shortUserName
})
return {
'items':
items,
'nativeVehicleId':
nativeVehicleCD,
'currentVehicleId':
self.__currentVehicleCD if self.__currentVehicleCD != None else -1
}
def submit(self, gold, xpToExchange, callback=None):
criteria = REQ_CRITERIA.VEHICLE.ELITE | ~REQ_CRITERIA.IN_CD_LIST(
[self._parentCD])
eliteVehicles = self._items.getVehicles(criteria).keys()
result = yield FreeXPExchanger(xpToExchange, eliteVehicles).request()
if callback is not None:
callback(result)
def _getRequestCriteria(self, invVehicles):
criteria = REQ_CRITERIA.INVENTORY
criteria |= REQ_CRITERIA.TYPE_CRITERIA(
(GUI_ITEM_TYPE.SHELL, ),
storage_helpers.getStorageShellsCriteria(self._itemsCache,
invVehicles, True))
return criteria
def __startRestoreTimeNotifyCallback(self):
self.__vehiclesForUpdate = []
criteria = REQ_CRITERIA.CUSTOM(
lambda item: item.hasRestoreCooldown() or item.hasLimitedRestore())
restoreVehicles = self.itemsCache.items.getVehicles(criteria).values()
notificationList = []
for vehicle in restoreVehicles:
if vehicle.hasRestoreCooldown():
delta = vehicle.restoreInfo.getRestoreCooldownTimeLeft()
else:
delta = vehicle.restoreInfo.getRestoreTimeLeft()
if delta > 0:
if delta > time_utils.ONE_DAY:
period = time_utils.ONE_DAY
elif delta > time_utils.ONE_HOUR:
period = time_utils.ONE_HOUR
else:
period = delta
notificationList.append((vehicle.intCD, delta % period
or period))
if len(notificationList) > 0:
_, nextRestoreNotification = min(notificationList,
key=itemgetter(1))
for vehCD, timeDelta in notificationList:
if timeDelta == nextRestoreNotification:
self.__vehiclesForUpdate.append(vehCD)
nextRestoreNotification = max(nextRestoreNotification, 0)
else:
return
self.__restoreNotifyTimeCallback = BigWorld.callback(
nextRestoreNotification, self.__notifyRestoreTime)
def __getVehiclesData(self, nationID, nativeVehicleCD):
items = []
criteria = REQ_CRITERIA.NATIONS([nationID])
criteria |= REQ_CRITERIA.UNLOCKED
criteria |= ~REQ_CRITERIA.VEHICLE.BATTLE_ROYALE
criteria |= ~REQ_CRITERIA.VEHICLE.MAPS_TRAINING
criteria |= ~(REQ_CRITERIA.SECRET
| ~REQ_CRITERIA.INVENTORY_OR_UNLOCKED)
if not constants.IS_IGR_ENABLED:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if constants.IS_DEVELOPMENT:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_BOT
vehicles = self.itemsCache.items.getVehicles(criteria)
vehiclesData = vehicles.values()
if nativeVehicleCD not in vehicles:
vehiclesData.append(
self.itemsCache.items.getItemByCD(nativeVehicleCD))
for vehicle in sorted(vehiclesData):
vDescr = vehicle.descriptor
if isVehicleObserver(vDescr.type.compactDescr):
continue
items.append({
'id': vehicle.intCD,
'type': vehicle.type,
'name': vehicle.shortUserName
})
return {
'items': items,
'nativeVehicleId': nativeVehicleCD,
'currentVehicleId': self.__currentVehicleCD or -1
}
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)) | ~REQ_CRITERIA.INVENTORY)
return criteria
def submit(self, gold, xpToExchange, callback=None):
vehiclesCriteria = REQ_CRITERIA.VEHICLE.FULLY_ELITE | REQ_CRITERIA.VEHICLE.ACTIVE_IN_NATION_GROUP
criteria = vehiclesCriteria | ~REQ_CRITERIA.IN_CD_LIST([self._parentCD])
eliteVehicles = self.itemsCache.items.getVehicles(criteria).keys()
result = yield FreeXPExchanger(xpToExchange, eliteVehicles).request()
if callback is not None:
callback(result)
return
def _getRequestCriteria(self, invVehicles):
criteria = super(InventoryCategoryStorageView,
self)._getRequestCriteria(invVehicles)
criteria |= REQ_CRITERIA.INVENTORY
tabID = self.__currentTabId
if tabID in (STORAGE_CONSTANTS.INVENTORY_TAB_ALL,
STORAGE_CONSTANTS.INVENTORY_TAB_MODULES):
criteria |= REQ_CRITERIA.TYPE_CRITERIA(
GUI_ITEM_TYPE.VEHICLE_MODULES,
REQ_CRITERIA.VEHICLE.SUITABLE(invVehicles))
if tabID in (STORAGE_CONSTANTS.INVENTORY_TAB_ALL,
STORAGE_CONSTANTS.INVENTORY_TAB_SHELLS):
criteria |= REQ_CRITERIA.TYPE_CRITERIA(
(GUI_ITEM_TYPE.SHELL, ),
storage_helpers.getStorageShellsCriteria(
self.itemsCache, invVehicles, True))
return criteria
def getAllVehiclePossibleXP(self, nodeCD, unlockStats):
criteria = REQ_CRITERIA.VEHICLE.FULLY_ELITE | ~REQ_CRITERIA.IN_CD_LIST([nodeCD])
eliteVehicles = self.itemsCache.items.getVehicles(criteria)
dirtyResult = sum(map(operator.attrgetter('xp'), eliteVehicles.values()))
exchangeRate = self.itemsCache.items.shop.freeXPConversion[0]
result = min(int(dirtyResult / exchangeRate) * exchangeRate, self.itemsCache.items.stats.gold * exchangeRate)
result += unlockStats.getVehTotalXP(nodeCD)
return result
def _getExtraCriteria(self, extra, requestCriteria, invVehicles):
if 'onVehicle' in extra:
requestCriteria |= ~REQ_CRITERIA.CUSTOM(
lambda item: not item.getInstalledVehicles(
invVehicles) and item.inventoryCount == 0)
else:
requestCriteria |= REQ_CRITERIA.INVENTORY
return requestCriteria
def _getRequestCriteria(self, invVehicles):
requestCriteria = super(InventoryVehicleTab, self)._getRequestCriteria(invVehicles)
requestCriteria |= REQ_CRITERIA.INVENTORY
vehicleType = self._filterData['vehicleType']
extra = self._filterData['extra']
if vehicleType != 'all':
requestCriteria |= REQ_CRITERIA.CUSTOM(lambda item: item.type.lower() == vehicleType.lower())
return self._getExtraCriteria(extra, requestCriteria, invVehicles)
def __setNationsData(self):
vehsItems = self.itemsCache.items.getVehicles(
self.__getNationsCriteria())
data = []
if self.__hasPredefinedNations():
if vehsItems.filter(
REQ_CRITERIA.NATIONS(self.__predefinedNationsIdxs)):
for i, nation in zip(self.__predefinedNationsIdxs,
self.__predefinedNations):
data.append(_packItemVO(i, MENU.nations(nation)))
else:
data.append(_packItemVO(DEFAULT_NATION, ''))
_logger.error('Wrong nation set as default!')
self.as_setNationsDataS(
self.__getSendingData(data,
len(data) > 1, 0))
else:
selectedNationIndex = 0
counter = 0
if self.__filteredNations is not None:
data = self.__filteredNations.values()
for nationData in data:
if self.__selectedNationIdx == DEFAULT_NATION:
self.__selectedNationIdx = nationData['id']
if nationData['id'] == self.__selectedNationIdx:
selectedNationIndex = counter
counter += 1
else:
for name in GUI_NATIONS:
nationIdx = nations.INDICES[name]
if name in nations.AVAILABLE_NAMES and vehsItems.filter(
REQ_CRITERIA.NATIONS([nationIdx])):
if self.__selectedNationIdx == DEFAULT_NATION:
self.__selectedNationIdx = nationIdx
data.append(_packItemVO(nationIdx, MENU.nations(name)))
if nationIdx == self.__selectedNationIdx:
selectedNationIndex = counter
counter += 1
self.as_setNationsDataS(
self.__getSendingData(data,
len(data) > 1, selectedNationIndex))
return
def _BasicCriteriesGroup_update(base, self, filters):
(premium, elite) = (filters[PREFS.PREMIUM], filters[PREFS.ELITE])
(filters[PREFS.PREMIUM], filters[PREFS.ELITE]) = (False, False)
base(self, filters)
(filters[PREFS.PREMIUM], filters[PREFS.ELITE]) = (premium, elite)
vehicles_stats = g_itemsCache.items.getAccountDossier().getRandomStats(
).getVehicles()
self._criteria |= REQ_CRITERIA.CUSTOM(
lambda x: _applyXvmFilter(x, filters, vehicles_stats))
def _BasicCriteriesGroup_update(base, self, filters):
(premium, elite) = (filters[PREFS.PREMIUM], filters[PREFS.ELITE])
(filters[PREFS.PREMIUM], filters[PREFS.ELITE]) = (False, False)
base(self, filters)
(filters[PREFS.PREMIUM], filters[PREFS.ELITE]) = (premium, elite)
itemsCache = dependency.instance(IItemsCache)
total_stats = itemsCache.items.getAccountDossier().getTotalStats()
vehicles_stats = total_stats.getVehicles()
self._criteria |= REQ_CRITERIA.CUSTOM(lambda x: _applyXvmFilter(x, filters, total_stats, vehicles_stats))
def __collectPredefinedRoleData(self):
criteria = self.__getNationsCriteria()
selectedNationsIds = []
if self.__hasPredefinedNations():
selectedNationsIds = self.__predefinedNationsIdxs
else:
for nId in nations.INDICES.itervalues():
selectedNationsIds.append(nId)
criteria |= REQ_CRITERIA.NATIONS(selectedNationsIds)
if not constants.IS_IGR_ENABLED:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if constants.IS_DEVELOPMENT:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_BOT
modulesAll = self.itemsCache.items.getVehicles(
criteria=criteria).values()
modulesAll.sort()
self.__filteredNations = dict()
self.__filteredVehClasses = dict()
self.__filteredVehClasses.setdefault(
DEFAULT_NATION, [self.__getVehicleClassEmptyRow()])
self.__filteredVehicles = dict()
filteredVehClassesByNation = dict()
count = 0
for module in modulesAll:
roleFound = False
for role in module.descriptor.type.crewRoles:
if not roleFound and role[0] in self.__predefinedTmanRoles:
roleFound = True
nationID, _ = module.descriptor.type.id
self.__filteredNations.setdefault(
nationID,
_packItemVO(nationID,
MENU.nations(nations.NAMES[nationID])))
vehicleClassesSet = filteredVehClassesByNation.setdefault(
nationID, set())
self.__filteredVehClasses.setdefault(
DEFAULT_NATION, [self.__getVehicleClassEmptyRow()])
currentType = module.type
if currentType not in vehicleClassesSet:
vehicleClassesSet.add(module.type)
vehClasses = self.__filteredVehClasses.setdefault(
nationID, [self.__getVehicleClassEmptyRow()])
vehClasses.append(
_packItemVO(
currentType,
DIALOGS.recruitwindow_vehicleclassdropdown(
currentType)))
vehicles = self.__filteredVehicles.setdefault(
(nationID, currentType), [self.__getVehicleEmptyRow()])
vehicles.append(
_packItemVO(module.innationID, module.shortUserName))
count += 1
if count < 1:
_logger.error('Something wrong with recruit tankman default role!')
self.__clearFilteredData()
def _getFilteredCriteria(self):
criteria = super(StorageCategoryCustomizationView,
self)._getFilteredCriteria()
typeIds = []
for bit in _TYPE_BIT_TO_CUSTOMIZATION_TYPE_MAP.iterkeys():
if self._filterMask & bit:
typeIds += _TYPE_BIT_TO_CUSTOMIZATION_TYPE_MAP[bit]
if typeIds:
criteria |= REQ_CRITERIA.ITEM_TYPES(*typeIds)
return criteria
def _getRequestCriteria(self, invVehicles):
requestCriteria = super(InventoryVehicleTab,
self)._getRequestCriteria(invVehicles)
requestCriteria |= REQ_CRITERIA.INVENTORY
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 _getFilteredCriteria(self):
criteria = super(ModulesTabView, self)._getFilteredCriteria()
typeIds = [
_TYPE_ID_BIT_TO_TYPE_ID_MAP[bit]
for bit in _TYPE_ID_BIT_TO_TYPE_ID_MAP.iterkeys()
if self._filterMask & bit
]
if typeIds:
criteria |= REQ_CRITERIA.ITEM_TYPES(*typeIds)
if self._selectedVehicle:
criteria |= REQ_CRITERIA.VEHICLE.SUITABLE([self._selectedVehicle])
return criteria
def __checkLimitedRestoreNotification(self):
criteria = REQ_CRITERIA.CUSTOM(lambda item: item.hasLimitedRestore())
vehicles = g_itemsCache.items.getVehicles(criteria).values()
lastRestoreNotification = AccountSettings.getSettings(LAST_RESTORE_NOTIFICATION)
if lastRestoreNotification is None:
showMessage = True
else:
showMessage = time_utils.getTimeDeltaTilNow(lastRestoreNotification) >= time_utils.ONE_DAY
if len(vehicles) and showMessage and not self.__checkForNotify:
AccountSettings.setSettings(LAST_RESTORE_NOTIFICATION, time.time())
SystemMessages.g_instance.pushI18nMessage('#system_messages:restoreController/hasLimitedRestoreVehicles', type=SystemMessages.SM_TYPE.Warning)
self.__checkForNotify = True
return
def isOn(self):
conditionVar = self.getVar()
itemsList = conditionVar.get('items', [])
itemType = conditionVar.get('itemType', None)
criteria = REQ_CRITERIA.EMPTY
if itemsList:
criteria = REQ_CRITERIA.IN_CD_LIST(itemsList)
vehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY).values()
items = g_itemsCache.items.getItems(itemTypeID=GUI_ITEM_TYPE_INDICES[itemType], criteria=criteria).values()
for item in items:
if len(item.getInstalledVehicles(vehicles)) > 0:
return True
return False
def submit(self, gold, xpToExchange, callback=None):
"""
Submit exchange operation, send request to exchange and call callback after response received
:param gold: <int> gold value
:param xpToExchange: <int> xp value to exchange
:param callback: <function>
"""
criteria = REQ_CRITERIA.VEHICLE.FULLY_ELITE | ~REQ_CRITERIA.IN_CD_LIST(
[self._parentCD])
eliteVehicles = self.itemsCache.items.getVehicles(criteria).keys()
result = yield FreeXPExchanger(xpToExchange, eliteVehicles).request()
if callback is not None:
callback(result)
return
def _getRequestCriteria(self, invVehicles):
requestCriteria = super(InventoryModuleTab, self)._getRequestCriteria(invVehicles)
extra = self._filterData['extra']
fitsType = self._filterData['fitsType']
requestTypeIds = self._getItemTypeID()
if fitsType == 'myVehicle':
vehicle = self._items.getItemByCD(int(self._filterData['vehicleCD']))
requestCriteria |= REQ_CRITERIA.VEHICLE.SUITABLE([vehicle], requestTypeIds)
if not vehicle.hasTurrets:
requestCriteria |= ~REQ_CRITERIA.IN_CD_LIST([vehicle.turret.intCD])
elif fitsType == 'myVehicles':
requestCriteria |= REQ_CRITERIA.VEHICLE.SUITABLE(invVehicles, requestTypeIds)
else:
requestCriteria |= ~REQ_CRITERIA.VEHICLE.SUITABLE(invVehicles, requestTypeIds)
return self._getExtraCriteria(extra, requestCriteria, invVehicles)
def getStorageShellsCriteria(itemsCache, invVehicles, compatible):
shellsList = set()
criteria = REQ_CRITERIA.INVENTORY | REQ_CRITERIA.VEHICLE.SUITABLE(invVehicles)
myGuns = itemsCache.items.getItems(GUI_ITEM_TYPE.GUN, criteria).values()
for gun in myGuns:
shellsList.update((x.intCD for x in gun.defaultAmmo))
for vehicle in invVehicles:
shellsList.update((x.intCD for x in vehicle.gun.defaultAmmo))
requestCriteria = REQ_CRITERIA.INVENTORY
cdListCriteria = REQ_CRITERIA.IN_CD_LIST(shellsList)
if compatible:
requestCriteria |= cdListCriteria
else:
requestCriteria |= ~cdListCriteria
return requestCriteria
def __setNationsData(self):
vehsItems = self.itemsCache.items.getVehicles(
self.__getNationsCriteria())
data = []
selectedNationIndex = 0
counter = 0
for name in GUI_NATIONS:
nationIdx = nations.INDICES[name]
vehiclesAvailable = len(
vehsItems.filter(REQ_CRITERIA.NATIONS([nationIdx]))) > 0
if name in nations.AVAILABLE_NAMES and vehiclesAvailable:
if self.__selectedNation == DEFAULT_NATION:
self.__selectedNation = nationIdx
data.append({'id': nationIdx, 'label': MENU.nations(name)})
if nationIdx == self.__selectedNation:
selectedNationIndex = counter
counter = counter + 1
self.as_setNationsDataS(
self.__getSendingData(data,
len(data) > 1, selectedNationIndex))
def setNationsData(self, nationID=None, enabled=True, showEmptyRow=True):
self.__selectedNation = nationID
vehsItems = g_itemsCache.items.getVehicles(self.__getNationsCriteria())
data = [self.__getNationEmptyRow()] if showEmptyRow else []
selectedNationIndex = 0
counter = 0
for name in GUI_NATIONS:
nationIdx = nations.INDICES[name]
vehiclesAvailable = len(
vehsItems.filter(REQ_CRITERIA.NATIONS([nationIdx]))) > 0
if name in nations.AVAILABLE_NAMES and vehiclesAvailable:
if self.__selectedNation is None:
self.__selectedNation = nationIdx
data.append({'id': nationIdx, 'label': MENU.nations(name)})
if nationIdx == self.__selectedNation:
selectedNationIndex = counter
counter = counter + 1
self.as_setNationsDataS(
self.__getSendingData(data, enabled, selectedNationIndex))
self.onDataChange(self.__selectedNation, self.__selectedVehClass,
self.__selectedVehicle, self.__selectedTmanRole)
def __getRoleCriteria(self, nationID, vclass, typeID):
return self.__getVehicleTypeCriteria(
nationID, vclass) | REQ_CRITERIA.INNATION_IDS([typeID])
