def _getAllPossibleXP(self, nodeCD, unlockStats):
criteria = REQ_CRITERIA.VEHICLE.ELITE | ~REQ_CRITERIA.IN_CD_LIST([nodeCD])
eliteVehicles = g_itemsCache.items.getVehicles(criteria)
dirtyResult = sum(map(operator.attrgetter('xp'), eliteVehicles.values()))
exchangeRate = self._items.shop.freeXPConversion[0]
result = min(int(dirtyResult / exchangeRate) * exchangeRate, self._stats.gold * exchangeRate)
result += unlockStats.getVehTotalXP(nodeCD)
return result
def updateVehicles(self, vehicles=None, updateFallout=True):
isSet = vehicles is None
filterCriteria = REQ_CRITERIA.INVENTORY
if vehicles is not None:
filterCriteria |= REQ_CRITERIA.IN_CD_LIST(vehicles)
items = g_itemsCache.items
filteredVehs = items.getVehicles(filterCriteria)
if vehicles is None:
vehicles = filteredVehs.keys()
isSuitablePredicate = lambda vehIntCD: True
if self.preQueueFunctional.getQueueType(
) == constants.QUEUE_TYPE.HISTORICAL:
battle = self.preQueueFunctional.getItemData()
if battle is not None:
isSuitablePredicate = battle.canParticipateWith
hasEmptySlots = self.__multiselectionMode and len(
self.__falloutCtrl.getEmptySlots()) > 0
vehsData = {}
for intCD in vehicles:
vehicle = filteredVehs.get(intCD)
if vehicle is not None:
vState, vStateLvl = vehicle.getState()
isSuitableVeh = vState != Vehicle.VEHICLE_STATE.BATTLE and not isSuitablePredicate(
vehicle.intCD)
isSuitableVeh |= self.__multiselectionMode and not vehicle.isFalloutAvailable
if isSuitableVeh:
vState, vStateLvl = Vehicle.VEHICLE_STATE.NOT_SUITABLE, Vehicle.VEHICLE_STATE_LEVEL.WARNING
canSelect, tooltip = self.__falloutCtrl.canSelectVehicle(
vehicle)
rentInfoStr = RentLeftFormatter(
vehicle.rentInfo, vehicle.isPremiumIGR).getRentLeftStr()
vehsData[intCD] = self._getVehicleData(vehicle, vState,
vStateLvl, rentInfoStr,
hasEmptySlots,
canSelect, tooltip)
LOG_DEBUG('Updating carousel vehicles: ',
vehsData if not isSet else 'full sync')
self.as_updateVehiclesS(vehsData, isSet)
self.showVehicles()
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')
if updateFallout:
self._updateFallout()
def updateVehiclesList(self):
battle = g_eventsCache.getHistoricalBattles().get(self.selectedBattleID)
teamARoster = battle.getTeamRoster(HistoricalBattle.SIDES.A)
teamBRoster = battle.getTeamRoster(HistoricalBattle.SIDES.B)
teamAVehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.IN_CD_LIST(teamARoster)).itervalues()
teamBVehicles = g_itemsCache.items.getVehicles(REQ_CRITERIA.IN_CD_LIST(teamBRoster)).itervalues()
def sortFunction(a, b):
if a.isInInventory and not b.isInInventory:
return -1
if not a.isInInventory and b.isInInventory:
return 1
if a.isReadyToFight and not b.isReadyToFight:
return -1
if not a.isReadyToFight and b.isReadyToFight:
return 1
return 0
teamAVehicles = sorted(teamAVehicles, sortFunction)
teamBVehicles = sorted(teamBVehicles, sortFunction)
teamAData = map(self._makeVehicleListItemVO, teamAVehicles)
teamBData = map(self._makeVehicleListItemVO, teamBVehicles)
self.as_setTeamsDataS(teamAData, teamBData)
def _getRequestParameters(self, nation, type, filter):
checkExtra = False
extra = []
requestCriteria = super(Shop, self)._getRequestParameters(nation, type, filter)
inventoryVehicles = g_itemsCache.items.getVehicles(requestCriteria | REQ_CRITERIA.INVENTORY).values()
requestCriteria = requestCriteria | ~REQ_CRITERIA.HIDDEN
if type == self._MODULE:
typeSize = int(filter.pop(0))
requestType = filter[0:typeSize]
requestTypeIds = map(lambda x: ITEM_TYPE_INDICES[x], requestType)
filter = filter[typeSize:]
fitsType = filter.pop(0)
compact = filter.pop(0)
if not compact:
LOG_ERROR('compact value has invalid value: ', compact)
Waiting.hide('updateShop')
return
checkExtra = True
extra = filter[:]
itemTypeID = tuple(requestTypeIds)
if fitsType == 'myVehicle':
vehicle = g_itemsCache.items.getItemByCD(int(compact))
requestCriteria |= REQ_CRITERIA.VEHICLE.SUITABLE([vehicle], requestTypeIds)
elif fitsType != 'otherVehicles':
requestCriteria |= REQ_CRITERIA.VEHICLE.SUITABLE(inventoryVehicles, requestTypeIds)
elif type == self._SHELL:
filterSize = int(filter.pop(0))
requestType = filter[0:filterSize]
filter = filter[filterSize:]
fitsType = filter.pop(0)
compact = filter.pop(0)
if not compact:
LOG_ERROR('compact value has invalid value: ', compact)
Waiting.hide('updateShop')
return
itemTypeID = GUI_ITEM_TYPE.SHELL
requestCriteria |= REQ_CRITERIA.CUSTOM(lambda item: item.type in requestType)
if fitsType == 'myVehicleGun':
vehicle = g_itemsCache.items.getItemByCD(int(compact))
shellsList = map(lambda x: x.intCD, vehicle.gun.defaultAmmo)
requestCriteria |= REQ_CRITERIA.IN_CD_LIST(shellsList)
elif fitsType != 'otherGuns':
shellsList = set()
myGuns = g_itemsCache.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 inventoryVehicles:
shellsList.update(map(lambda x: x.intCD, vehicle.gun.defaultAmmo))
requestCriteria |= REQ_CRITERIA.IN_CD_LIST(shellsList)
elif type == self._VEHICLE:
requestCriteria |= ~REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
typeSize = int(filter.pop(0))
requestType = filter[0:typeSize]
extra = filter[typeSize:]
checkExtra = True
if 'all' not in requestType:
requestType = map(lambda x: x.lower(), requestType)
requestCriteria |= REQ_CRITERIA.CUSTOM(lambda item: item.type.lower() in requestType)
itemTypeID = GUI_ITEM_TYPE.VEHICLE
else:
fitsType = filter.pop(0)
compact = filter.pop(0)
if not compact:
LOG_ERROR('compact value has invalid value: ', compact)
Waiting.hide('updateShop')
return
extra = filter
checkExtra = type in (self._OPTIONAL_DEVICE, self._EQUIPMENT)
itemTypeID = GUI_ITEM_TYPE_INDICES[type]
if fitsType == 'myVehicle':
vehicle = g_itemsCache.items.getItemByCD(int(compact))
requestCriteria |= REQ_CRITERIA.VEHICLE.SUITABLE([vehicle], [itemTypeID])
elif fitsType != 'otherVehicles':
requestCriteria |= REQ_CRITERIA.VEHICLE.SUITABLE(inventoryVehicles, [itemTypeID])
return (itemTypeID,
requestCriteria,
inventoryVehicles,
checkExtra,
extra)
def getInventoryVehicles(self):
nodeCDs = map(lambda node: node['id'], self._getNodesToInvalidate())
LOG_DEBUG('getInventoryVehicles', nodeCDs)
vehicles = self._items.getVehicles(REQ_CRITERIA.INVENTORY | REQ_CRITERIA.IN_CD_LIST(nodeCDs))
return dict(map(lambda item: (item.inventoryID, item), vehicles.itervalues()))