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 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 _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 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 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 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 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 __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 _getRequestCriteria(self):
criteria = ~REQ_CRITERIA.SECRET | ~REQ_CRITERIA.HIDDEN
if 'nation' in self._params:
criteria |= REQ_CRITERIA.NATIONS([nations.INDICES[self._params['nation']]])
if 'levelEqual' in self._params:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS([int(self._params['levelEqual'])])
else:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS(range(int(self._params.get('levelMoreThan', 0)) + 1, int(self._params.get('levelLessThan', constants.MAX_VEHICLE_LEVEL + 1))))
if 'vehClass' in self._params:
criteria |= REQ_CRITERIA.VEHICLE.CLASSES([self._params['vehClass']])
return criteria
def updateNationDropdown(self):
vehsItems = g_itemsCache.items.getVehicles(self.__getNationsCriteria())
data = [{'id': None, 'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW}]
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:
data.append({'id': nationIdx, 'label': MENU.nations(name)})
self.flashObject.as_setNations(data)
return
def __getVehicles(self, nation=_ALL_NATIONS, vehicleType='none'):
criteria = ~REQ_CRITERIA.IN_OWNERSHIP | ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR | REQ_CRITERIA.VEHICLE.LEVELS(
self.__levelsRange) | ~REQ_CRITERIA.VEHICLE.PREMIUM
if nation != _ALL_NATIONS:
criteria |= REQ_CRITERIA.NATIONS([self.__filters['nation']])
if vehicleType != 'none':
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(
[self.__filters['vehicleType']])
vehicles = self.itemsCache.items.getVehicles(criteria)
return [
makeVehicleBasicVO(v, self.__levelsRange, VEHICLE_CLASSES)
for v in vehicles.itervalues()
]
def getCriteria(self):
criteria = self.getDefaultCriteria()
if self._filters['nation'] != -1 and self._filters['nation'] != IGR_FILTER_ID:
nationIndex = nations.INDICES.get(GUI_NATIONS[self._filters['nation']])
criteria |= REQ_CRITERIA.NATIONS([nationIndex])
if self._filters['nation'] == IGR_FILTER_ID:
criteria |= REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if self._filters['vehicleType'] != -1:
vehicleIndex = constants.VEHICLE_CLASS_INDICES.get(VEHICLE_TYPES_ORDER[self._filters['vehicleType']])
criteria |= REQ_CRITERIA.VEHICLE.CLASSES([constants.VEHICLE_CLASSES[vehicleIndex]])
if self._filters['favoriteSelected']:
criteria |= REQ_CRITERIA.VEHICLE.FAVORITE
return criteria
def getFilterCriteria(self, data):
types, nations, levels, classes = self._parseFilters(data)
defaultCriteria = self._getDefaultCriteria()
if types:
criteria = REQ_CRITERIA.VEHICLE.SPECIFIC_BY_CD(types)
else:
criteria = REQ_CRITERIA.EMPTY
if nations:
criteria |= REQ_CRITERIA.NATIONS(nations)
if levels:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS(levels)
if classes:
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(classes)
return self._postProcessCriteria(defaultCriteria, criteria)
def update(self, filters):
super(BasicCriteriesGroup, self).update(filters)
selectedNationsIds = []
for nation, nId in nations.INDICES.iteritems():
if filters[nation]:
selectedNationsIds.append(nId)
if selectedNationsIds:
self._criteria |= REQ_CRITERIA.NATIONS(selectedNationsIds)
selectedVehiclesIds = []
for vehicleType, _ in constants.VEHICLE_CLASS_INDICES.iteritems():
if filters[vehicleType]:
selectedVehiclesIds.append(vehicleType)
if selectedVehiclesIds:
self._criteria |= REQ_CRITERIA.VEHICLE.CLASSES(selectedVehiclesIds)
selectedLevels = []
for level in VEHICLE_LEVELS:
if filters['level_%d' % level]:
selectedLevels.append(level)
if selectedLevels:
self._criteria |= REQ_CRITERIA.VEHICLE.LEVELS(selectedLevels)
if filters['elite'] and not filters['premium']:
self._criteria |= REQ_CRITERIA.VEHICLE.ELITE | ~REQ_CRITERIA.VEHICLE.PREMIUM
elif filters['elite'] and filters['premium']:
self._criteria |= REQ_CRITERIA.VEHICLE.ELITE
elif filters['premium']:
self._criteria |= REQ_CRITERIA.VEHICLE.PREMIUM
if filters['igr'] and constants.IS_KOREA:
self._criteria |= REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if filters['rented'] and filters['clanRented']:
self._criteria |= REQ_CRITERIA.VEHICLE.RENT
elif filters['clanRented']:
self._criteria |= REQ_CRITERIA.VEHICLE.CLAN_WARS
elif not filters['rented']:
self._criteria |= ~REQ_CRITERIA.VEHICLE.RENT ^ REQ_CRITERIA.VEHICLE.CLAN_WARS
if filters['bonus']:
self._criteria |= REQ_CRITERIA.VEHICLE.HAS_XP_FACTOR
if filters['favorite']:
self._criteria |= REQ_CRITERIA.VEHICLE.FAVORITE
if filters['crystals']:
self._criteria |= REQ_CRITERIA.VEHICLE.EARN_CRYSTALS
if filters['searchNameVehicle']:
self._criteria |= REQ_CRITERIA.VEHICLE.NAME_VEHICLE(
makeSearchableString(filters['searchNameVehicle']))
if NY_FILTER in filters and filters[NY_FILTER]:
self._criteria |= REQ_CRITERIA.VEHICLE.SPECIFIC_BY_INV_ID(
set(self.itemsCache.items.festivity.getVehicleBranch()))
def __getVehicles(self, nation=_ALL_NATIONS, vehicleType='none'):
criteria = REQ_CRITERIA.VEHICLE.LEVELS(self.__levelsRange)
for crit in _EXCLUDED_VEHICLE_CRITERIA:
criteria |= crit
if nation != _ALL_NATIONS:
criteria |= REQ_CRITERIA.NATIONS([self.__filters['nation']])
if vehicleType != 'none':
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(
[self.__filters['vehicleType']])
vehicles = self.itemsCache.items.getVehicles(criteria)
return [
makeVehicleBasicVO(v, self.__levelsRange, VEHICLE_CLASSES)
for v in vehicles.itervalues()
]
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 _setData(self):
eventData = self.__opener.eventData
eventType = eventData.getType()
criteria = REQ_CRITERIA.EMPTY
if eventType == EVENT_TYPE.VEHICLE:
vehicleIds = [veh for _, veh in eventData.getLeaderboards()]
title = _ms(EVENT_BOARDS.VEHICLES_VEHICLE)
bgPath = None
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']])
else:
vehicleIds = eventData.getLimits().getVehicles(self.__lid)
leaderboard = eventData.getLeaderboard(self.__lid)
if eventType == EVENT_TYPE.NATION:
title = _ms('#menu:nation_tree/title/{}'.format(leaderboard))
bgPath = '../maps/icons/eventBoards/flagsOverlay/{}.png'.format(
leaderboard)
elif eventType == EVENT_TYPE.LEVEL:
title = _ms(EVENT_BOARDS.VEHICLES_LEVEL,
level=int2roman(leaderboard))
bgPath = None
elif eventType == EVENT_TYPE.CLASS:
title = _ms('#quests:classes/{}'.format(leaderboard))
bgPath = None
else:
title = None
bgPath = None
allVehicles = self.itemsCache.items.getVehicles(
REQ_CRITERIA.IN_CD_LIST(vehicleIds))
vehicles = allVehicles.filter(criteria).values()
vehicles.sort(key=lambda v: v.isInInventory, reverse=True)
vehiclesVO = [makeVehicleVO(vehicle) for vehicle in vehicles]
data = {'title': title, 'bgPath': bgPath, 'vehicles': vehiclesVO}
self.as_setVehiclesS(data)
return
def update(self, filters):
super(_ShortNameVehiclesCriteriesGroup, self).update(filters)
selectedNationsIds = []
for nation, nId in nations.INDICES.iteritems():
if filters[nation]:
selectedNationsIds.append(nId)
if selectedNationsIds:
self._criteria |= REQ_CRITERIA.NATIONS(selectedNationsIds)
selectedVehiclesIds = []
for vehicleType, _ in constants.VEHICLE_CLASS_INDICES.iteritems():
if filters[vehicleType]:
selectedVehiclesIds.append(vehicleType)
if selectedVehiclesIds:
self._criteria |= REQ_CRITERIA.VEHICLE.CLASSES(selectedVehiclesIds)
selectedLevels = []
for level in VEHICLE_LEVELS:
if filters['level_%d' % level]:
selectedLevels.append(level)
if selectedLevels:
self._criteria |= REQ_CRITERIA.VEHICLE.LEVELS(selectedLevels)
if filters['elite'] and not filters['premium']:
self._criteria |= REQ_CRITERIA.VEHICLE.ELITE | ~REQ_CRITERIA.VEHICLE.PREMIUM
elif filters['elite'] and filters['premium']:
self._criteria |= REQ_CRITERIA.VEHICLE.ELITE
elif filters['premium']:
self._criteria |= REQ_CRITERIA.VEHICLE.PREMIUM
if filters['igr'] and constants.IS_KOREA:
self._criteria |= REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if not filters['rented']:
self._criteria |= ~REQ_CRITERIA.VEHICLE.RENT
if filters['bonus']:
self._criteria |= REQ_CRITERIA.VEHICLE.HAS_XP_FACTOR
if filters['favorite']:
self._criteria |= REQ_CRITERIA.VEHICLE.FAVORITE
if filters['searchNameVehicle']:
searchableString = makeSearchableString(
filters['searchNameVehicle'])
self._criteria |= REQ_CRITERIA.VEHICLE.NAME_VEHICLE_WITH_SHORT(
searchableString)
def getCriteria(self):
criteria = self.getDefaultCriteria()
selectedNationsIds = []
for nation, nId in nations.INDICES.items():
if self._filters[nation]:
selectedNationsIds.append(nId)
if selectedNationsIds:
criteria |= REQ_CRITERIA.NATIONS(selectedNationsIds)
selectedVehiclesIds = []
for vehicleType, vId in constants.VEHICLE_CLASS_INDICES.items():
if self._filters[vehicleType]:
selectedVehiclesIds.append(vehicleType)
if selectedVehiclesIds:
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(selectedVehiclesIds)
selectedLevels = []
for level in VEHICLE_LEVELS:
if self._filters['level_%d' % level]:
selectedLevels.append(level)
if selectedLevels:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS(selectedLevels)
if self._filters['elite'] and not self._filters['premium']:
criteria |= REQ_CRITERIA.VEHICLE.ELITE | ~REQ_CRITERIA.VEHICLE.PREMIUM
elif self._filters['elite'] and self._filters['premium']:
criteria |= REQ_CRITERIA.VEHICLE.ELITE
elif self._filters['premium']:
criteria |= REQ_CRITERIA.VEHICLE.PREMIUM
if self._filters['igr'] and constants.IS_KOREA:
criteria |= REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
if self._filters['hideRented']:
criteria |= ~REQ_CRITERIA.VEHICLE.RENT
if self._filters['bonus']:
criteria |= REQ_CRITERIA.VEHICLE.HAS_XP_FACTOR
if self._filters['favorite']:
criteria |= REQ_CRITERIA.VEHICLE.FAVORITE
return criteria
def __getClassesCriteria(self, nationID):
return self.__getNationsCriteria() | REQ_CRITERIA.NATIONS([nationID])
def getCollectibleVehicles(nationID=ALL_NATIONS_INDEX, itemsCache=None):
criteria = REQ_CRITERIA.COLLECTIBLE if nationID == ALL_NATIONS_INDEX else REQ_CRITERIA.NATIONS(
(nationID, )) | REQ_CRITERIA.COLLECTIBLE | ~REQ_CRITERIA.HIDDEN
items = itemsCache.items.getVehicles(criteria)
return items
