def showVehicles(self):
filterCriteria = REQ_CRITERIA.INVENTORY
if self.__vehiclesFilter['nation'] != -1:
if self.__vehiclesFilter['nation'] == 100:
filterCriteria |= REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
else:
filterCriteria |= REQ_CRITERIA.NATIONS(
[self.__vehiclesFilter['nation']])
if self.__vehiclesFilter['tankType'] != 'none':
filterCriteria |= REQ_CRITERIA.VEHICLE.CLASSES(
[self.__vehiclesFilter['tankType']])
if self.__vehiclesFilter['ready']:
filterCriteria |= REQ_CRITERIA.VEHICLE.FAVORITE
if self.__vehiclesFilter[
'gameModeFilter'] and self.__multiselectionMode:
filterCriteria |= REQ_CRITERIA.VEHICLE.FALLOUT.AVAILABLE
items = g_itemsCache.items
filteredVehs = items.getVehicles(filterCriteria)
def sorting(v1, v2):
if v1.isFavorite and not v2.isFavorite:
return -1
if not v1.isFavorite and v2.isFavorite:
return 1
return v1.__cmp__(v2)
vehsCDs = map(attrgetter('intCD'),
sorted(filteredVehs.values(), sorting))
LOG_DEBUG('Showing carousel vehicles: ', vehsCDs)
self.as_showVehiclesS(vehsCDs)
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.credits, items.stats.gold),
'tankmanCost': shopPrices,
'action': action,
'vehicles': result
})
def getRetrainingData(self, callback):
items = g_itemsCache.items
tankman = items.getTankman(self.tmanInvID)
criteria = REQ_CRITERIA.NATIONS([tankman.nationID
]) | REQ_CRITERIA.UNLOCKED
vData = items.getVehicles(criteria)
tDescr = tankman.descriptor
vehiclesData = sorted(vData.values())
result = []
for vehicle in 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
callback({
'money': (items.stats.credits, items.stats.gold),
'tankmanCost': items.shop.tankmanCost,
'vehicles': result
})
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)
def updateNationDropdown(self):
try:
vehsItems = g_itemsCache.items.getVehicles(REQ_CRITERIA.UNLOCKED)
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)
except Exception:
LOG_ERROR(
'There is exception while setting data to the recruit window')
LOG_CURRENT_EXCEPTION()
return
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 _parse(self):
criteria = ~REQ_CRITERIA.SECRET | self._getCustomFilter()
if 'types' in self._value:
criteria |= REQ_CRITERIA.VEHICLE.SPECIFIC_BY_CD(
self._value['types']['value'])
else:
if 'nations' in self._value:
criteria |= REQ_CRITERIA.NATIONS(
self._value['nations']['value'])
if 'levels' in self._value:
criteria |= REQ_CRITERIA.VEHICLE.LEVELS(
self._value['levels']['value'])
if 'classes' in self._value:
classes = [
name
for name, index in constants.VEHICLE_CLASS_INDICES.items()
if index in self._value['classes']['value']
]
criteria |= REQ_CRITERIA.VEHICLE.CLASSES(classes)
return sorted(g_itemsCache.items.getVehicles(criteria).itervalues())
def __getClassesCriteria(self, nationID):
return self.__getNationsCriteria() | REQ_CRITERIA.NATIONS([nationID])
def updateVehicles(self, resetPos = False):
Waiting.show('updateMyVehicles')
filterCriteria = REQ_CRITERIA.INVENTORY
if self.vehiclesFilter['nation'] != -1:
filterCriteria |= REQ_CRITERIA.NATIONS([self.vehiclesFilter['nation']])
if self.vehiclesFilter['tankType'] != 'none':
filterCriteria |= REQ_CRITERIA.VEHICLE.CLASSES([self.vehiclesFilter['tankType']])
if self.vehiclesFilter['ready']:
filterCriteria |= REQ_CRITERIA.VEHICLE.FAVORITE
items = g_itemsCache.items
newVehs = items.getVehicles(REQ_CRITERIA.INVENTORY)
filteredVehs = items.getVehicles(filterCriteria)
vehsData = []
def sorting(v1, v2):
if v1.isFavorite and not v2.isFavorite:
return -1
if not v1.isFavorite and v2.isFavorite:
return 1
return v1.__cmp__(v2)
for vehicle in sorted(filteredVehs.itervalues(), sorting):
try:
vState, vStateLvl = vehicle.getState()
v = {'id': vehicle.invID,
'inventoryId': vehicle.invID,
'label': vehicle.userName,
'image': vehicle.icon,
'nation': vehicle.nationID,
'level': vehicle.level,
'stat': vState,
'stateLevel': vStateLvl,
'doubleXPReceived': vehicle.dailyXPFactor,
'compactDescr': vehicle.intCD,
'favorite': vehicle.isFavorite,
'canSell': vehicle.canSell,
'clanLock': vehicle.clanLock,
'elite': vehicle.isElite,
'premium': vehicle.isPremium,
'tankType': vehicle.type,
'exp': vehicle.xp,
'current': 0,
'enabled': True}
except Exception:
LOG_ERROR("Exception while '%s' vehicle processing" % vehicle.descriptor.type.name)
LOG_CURRENT_EXCEPTION()
continue
vehsData.append(v)
self.as_vehiclesResponseS({'slotPrice': items.shop.getVehicleSlotsPrice(items.stats.vehicleSlots),
'availableSlotsForBuy': items.stats.vehicleSlots - len(newVehs),
'allTanksCount': len(newVehs),
'selectedTankID': g_currentVehicle.invID,
'slots': vehsData})
isVehTypeLock = sum((len(v) for v in items.stats.vehicleTypeLocks.itervalues()))
isGlobalVehLock = sum((len(v) for v in items.stats.globalVehicleLocks.itervalues()))
if self.__updateVehiclesTimerId is None and (isVehTypeLock or isGlobalVehLock):
self.__updateVehiclesTimerId = BigWorld.callback(self.UPDATE_LOCKS_PERIOD, self.updateLockTimers)
LOG_DEBUG('Lock timer updated')
Waiting.hide('updateMyVehicles')
return