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 _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 _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 __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 _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 _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 _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 _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 __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 __collectPredefinedRoleData(self):
criteria = self.__getNationsCriteria()
maxResLevels = self.itemsCache.items.stats.getMaxResearchedLevelByNations(
)
selectedNationsIds = []
if self.__hasPredefinedNations():
selectedNationsIds = self.__predefinedNationsIdxs
else:
for nId in nations.INDICES.itervalues():
selectedNationsIds.append(nId)
criteria |= REQ_CRITERIA.NATIONS(selectedNationsIds)
criteria |= REQ_CRITERIA.CUSTOM(
lambda i: not i.isCollectible or i.level <= maxResLevels.get(
i.nationID, constants.MIN_VEHICLE_LEVEL
) or i.inventoryCount > 0)
if not constants.IS_IGR_ENABLED:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if constants.IS_DEVELOPMENT:
criteria |= ~REQ_CRITERIA.VEHICLE.IS_BOT
criteria |= ~(REQ_CRITERIA.SECRET
| ~REQ_CRITERIA.INVENTORY_OR_UNLOCKED)
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 getGroupCriteria(cls):
return REQ_CRITERIA.CUSTOM(cls.__hasProgress)
def _getRequestCriteria(self, invVehicles):
criteria = REQ_CRITERIA.CUSTOMIZATION.FULL_INVENTORY
if invVehicles:
criteria |= REQ_CRITERIA.CUSTOM(
_getCustomizationCriteria(_VehiclesFilter(invVehicles)))
return criteria
