def updateAccountAttrs(self):
accAttrs = yield StatsRequester().getAccountAttrs()
denunciations = yield StatsRequester().getDenunciations()
isPremium = account_helpers.isPremiumAccount(accAttrs)
premiumExpiryTime = 0
if isPremium:
premiumExpiryTime = yield StatsRequester().getPremiumExpiryTime()
self.setAccountsAttrs(accAttrs, premiumExpiryTime=premiumExpiryTime)
self.setDenunciationsCount(denunciations)
def __startDataCollect(self):
self._data._xps = yield StatsRequester().getVehicleTypeExperiences()
self._data._unlocks = yield StatsRequester().getUnlocks()
self._data._elite = yield StatsRequester().getEliteVehicles()
self._data._accFreeXP = g_itemsCache.items.stats.actualFreeXP
self._data._accCredits = g_itemsCache.items.stats.credits
self._data._accGold = g_itemsCache.items.stats.gold
accDossier = yield StatsRequester().getAccountDossier()
if accDossier and accDossier['a15x15Cut']:
self._data._wereInBattle = set(accDossier['a15x15Cut'].keys())
self.__requestVehiclesFromInv()
def setClanInfo(self, clanInfo):
name = BigWorld.player().name
isTeamKiller = yield StatsRequester().isTeamKiller()
clanDBID = yield StatsRequester().getClanDBID()
self.as_nameResponseS(g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo), isTeamKiller, clanInfo is not None)
if clanDBID is not None and clanDBID != 0:
tID = 'clanInfo' + name
success = yield StatsRequester().getClanEmblemTextureID(clanDBID, False, tID)
if success:
self.as_setClanEmblemS(tID)
return
def __checkPremiumAccountExpiry(self, ctx=None):
expiryUTCTime = yield StatsRequester().getPremiumExpiryTime()
delta = account_helpers.getPremiumExpiryDelta(expiryUTCTime)
if delta.days == 0 and expiryUTCTime and not self.__expirationShown:
self.proto.serviceChannel.pushClientMessage(
expiryUTCTime, SCH_CLIENT_MSG_TYPE.PREMIUM_ACCOUNT_EXPIRY_MSG)
self.__expirationShown = True
def fetchresult(arenaUID):
if arenaUID:
print "[WTR]: fetchresult"
proxy = partial(__onGetResponse, StatsRequester()._valueResponse)
BigWorld.player()._doCmdInt3(AccountCommands.CMD_REQ_BATTLE_RESULTS, arenaUID, 0, 0, proxy)
else:
return
def __init__(self):
super(ItemsCache, self).__init__()
goodies = GoodiesRequester()
self.__items = ItemsRequester.ItemsRequester(InventoryRequester(), StatsRequester(), DossierRequester(), goodies, ShopRequester(goodies), RecycleBinRequester(), VehicleRotationRequester(), RankedRequester(), BattleRoyaleRequester(), BadgesRequester(), EpicMetaGameRequester(), TokensRequester(), dependency.instance(IFestivityFactory).getRequester(), BlueprintsRequester(), SessionStatsRequester(), AnonymizerRequester(), GiftSystemRequester())
self.__compatVehiclesCache = CompatVehiclesCache()
self.__waitForSync = False
self.__syncFailed = False
self.onSyncStarted = Event()
self.onSyncCompleted = Event()
self.onSyncFailed = Event()
def __init__(self):
super(ItemsCache, self).__init__()
goodies = GoodiesRequester()
self.__items = ItemsRequester.ItemsRequester(
InventoryRequester(), StatsRequester(), DossierRequester(),
goodies, ShopRequester(goodies), RecycleBinRequester(),
VehicleRotationRequester(), RankedRequester())
self.__waitForSync = False
self.onSyncStarted = Event()
self.onSyncCompleted = Event()
def onCurrentVehicleChanged(self):
if g_currentVehicle.isPresent():
xps = yield StatsRequester().getVehicleTypeExperiences()
xp = xps.get(g_currentVehicle.item.intCD, 0)
self.as_setEarnedXPS(xp)
self.as_setEliteS(g_currentVehicle.item.isElite)
else:
self.as_setEarnedXPS(0)
self.as_setEliteS(False)
yield lambda callback = None: callback
return
def __getInitialData(self):
credits, gold = g_itemsCache.items.stats.money
upgradeParams = yield StatsRequester().getTankmanCost()
data = {
'credits': credits,
'gold': gold,
'schoolUpgrade': round(upgradeParams[1]['credits']),
'academyUpgrade': round(upgradeParams[2]['gold']),
'data': self._initData,
'menuEnabled': self._menuEnabled
}
self.flashObject.as_initData(data)
def __processSyncEBankData(self):
self.balance, self.error = yield StatsRequester().ebankGetBalance()
if _VcoinGetBalanceRequester.CACHE_ENABLED:
self.__isCached = not len(self.error)
self.__isWaitForSync = False
self.__updateBalanceCooldown()
items = len(self.error) == 0 and (yield ItemsRequester().request())
self.goldBalance = items.stats.actualGold
self.exchangeRate = items.shop.ebankVCoinExchangeRate
self.minTransactVal = items.shop.ebankMinTransactionValue
self.maxTransactVal = items.shop.ebankMaxTransactionValue
self.onEbankGetBalanceComplete(self.error)
def onShowRecruitWindow(self, callbackID):
credits, gold = g_itemsCache.items.stats.money
upgradeParams = yield StatsRequester().getTankmanCost()
data = [
credits, gold,
round(upgradeParams[1]['credits']), upgradeParams[2]['gold'],
len(ROLES)
]
for role in ROLES:
data.append(role)
data.append(convert(getSkillsConfig()[role]['userString']))
unlocks = yield StatsRequester().getUnlocks()
modulesAll = yield Requester('vehicle').getFromShop()
modulesAll.sort()
for module in modulesAll:
compdecs = module.descriptor.type.compactDescr
if compdecs in unlocks:
data.append(module.type)
data.append(module.descriptor.type.id[0])
data.append(module.descriptor.type.id[1])
data.append(module.descriptor.type.shortUserString)
def _populate(self):
self.__currentLockedView = None
super(FightButton, self)._populate()
g_currentVehicle.onChanged += self.update
self.app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE,
self.__handleFightButtonUpdate,
scope=EVENT_BUS_SCOPE.LOBBY)
g_clientUpdateManager.addCallbacks(
{'account.attrs': self.updateDemonstratorButton})
accountAttrs = yield StatsRequester().getAccountAttrs()
self.updateDemonstratorButton(accountAttrs)
return
def __premiumDataRequest(self):
stats = yield StatsRequesterr().request()
premiumCost = yield StatsRequester().getPremiumCost()
premiumCost = sorted(premiumCost.items(), reverse=True)
args = []
for period, cost in premiumCost:
args.append({'days': period, 'price': cost, 'discountPrice': cost})
gold = stats.gold
isPremiumAccount = account_helpers.isPremiumAccount(stats.attributes)
self.as_setCostsS(args)
self.as_setPremiumS(isPremiumAccount)
self.as_setGoldS(gold)
def __upgradeToPremium(self, days):
Waiting.show('loadStats')
attrs = yield StatsRequester().getAccountAttrs()
isPremium = account_helpers.isPremiumAccount(attrs)
success = yield StatsRequester().upgradeToPremium(days)
if success:
premiumCost = yield StatsRequester().getPremiumCost()
if premiumCost:
if isPremium:
successMessage = SYSTEM_MESSAGES.PREMIUM_CONTINUESUCCESS
else:
successMessage = SYSTEM_MESSAGES.PREMIUM_BUYINGSUCCESS
SystemMessages.pushI18nMessage(
successMessage,
days,
formatPrice((0, premiumCost[int(days)])),
type=SystemMessages.SM_TYPE.PurchaseForGold)
self.fireEvent(LobbySimpleEvent(
LobbySimpleEvent.UPDATE_TANK_PARAMS),
scope=EVENT_BUS_SCOPE.LOBBY)
else:
self.__systemErrorMessage(SYSTEM_MESSAGES.PREMIUM_SERVER_ERROR,
days, SystemMessages.SM_TYPE.Error)
Waiting.hide('loadStats')
def updateVehicleTypeDropdown(self, nationID, vclass):
Waiting.show('updating')
unlocks = yield StatsRequester().getUnlocks()
modulesAll = yield Requester('vehicle').getFromShop()
data = [{'id': None, 'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW}]
modulesAll.sort()
for module in modulesAll:
compdecs = module.descriptor.type.compactDescr
if compdecs in unlocks and module.descriptor.type.id[
0] == nationID and module.type == vclass:
data.append({
'id': module.descriptor.type.id[1],
'label': module.descriptor.type.shortUserString
})
self.flashObject.as_setVehicleTypeDropdown(data)
Waiting.hide('updating')
return
def updateAllDropdowns(self, nationID, tankType, typeID, roleType):
nationsDP = [{
'id': None,
'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW
}, {
'id': nationID,
'label': MENU.nations(nations.NAMES[int(nationID)])
}]
classesDP = [{
'id': None,
'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW
}, {
'id':
tankType,
'label':
DIALOGS.recruitwindow_vehicleclassdropdown(tankType)
}]
typesDP = [{'id': None, 'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW}]
rolesDP = [{'id': None, 'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW}]
unlocks = yield StatsRequester().getUnlocks()
modulesAll = yield Requester('vehicle').getFromShop()
for module in modulesAll:
compdecs = module.descriptor.type.compactDescr
if compdecs in unlocks and module.descriptor.type.id[
0] == nationID and module.descriptor.type.id[1] == typeID:
typesDP.append({
'id': module.descriptor.type.id[1],
'label': module.descriptor.type.shortUserString
})
for role in module.descriptor.type.crewRoles:
if role[0] == roleType:
rolesDP.append({
'id':
role[0],
'label':
convert(getSkillsConfig()[role[0]]['userString'])
})
break
self.flashObject.as_setAllDropdowns(nationsDP, classesDP, typesDP,
rolesDP)
return
def updateVehicleClassDropdown(self, nationID):
Waiting.show('updating')
unlocks = yield StatsRequester().getUnlocks()
modulesAll = yield Requester('vehicle').getFromShop()
classes = []
data = [{'id': None, 'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW}]
modulesAll.sort()
for module in modulesAll:
compdecs = module.descriptor.type.compactDescr
if compdecs in unlocks and module.descriptor.type.id[
0] == nationID and module.type not in classes:
classes.append(module.type)
data.append({
'id':
module.type,
'label':
DIALOGS.recruitwindow_vehicleclassdropdown(module.type)
})
self.flashObject.as_setVehicleClassDropdown(data)
Waiting.hide('updating')
return
def updateRoleDropdown(self, nationID, vclass, typeID):
Waiting.show('updating')
unlocks = yield StatsRequester().getUnlocks()
modulesAll = yield Requester('vehicle').getFromShop()
roles = []
data = [{'id': None, 'label': DIALOGS.RECRUITWINDOW_MENUEMPTYROW}]
modulesAll.sort()
for module in modulesAll:
compdecs = module.descriptor.type.compactDescr
if compdecs in unlocks and module.descriptor.type.id[
0] == nationID and module.descriptor.type.id[1] == typeID:
for role in module.descriptor.type.crewRoles:
if role[0] not in roles:
roles.append(role[0])
data.append({
'id':
role[0],
'label':
convert(getSkillsConfig()[role[0]]['userString'])
})
self.flashObject.as_setRoleDropdown(data)
Waiting.hide('updating')
return
def __updateTankmen(self, *args):
tankmen = yield Requester('tankman').getFromInventory()
vcls = yield Requester('vehicle').getFromInventory()
slots = yield StatsRequester().getTankmenBerthsCount()
berths = yield StatsRequester().getTankmenBerthsCount()
berthsPrices = yield StatsRequester().getBerthsPrices()
berthPrice = BigWorld.player().shop.getNextBerthPackPrice(
berths, berthsPrices)
tankmenList = list()
tankmenInBarracks = 0
TANKMEN_ROLES_ORDER = {
'commander': 0,
'gunner': 1,
'driver': 2,
'radioman': 3,
'loader': 4
}
def tankmenSortFunc(first, second):
if first is None or second is None:
return 1
res = nationCompareByIndex(first.nation, second.nation)
if res:
return res
elif first.isInTank and not second.isInTank:
return -1
elif not first.isInTank and second.isInTank:
return 1
if first.isInTank and second.isInTank:
tman1vehicle, tman2vehicle = (None, None)
for vcl in vcls:
if vcl.inventoryId == first.vehicleID:
tman1vehicle = vcl
if vcl.inventoryId == second.vehicleID:
tman2vehicle = vcl
if tman1vehicle is not None and tman2vehicle is not None:
break
if tman1vehicle is not None and tman2vehicle is not None:
res = tman1vehicle.__cmp__(tman2vehicle)
if res:
return res
if TANKMEN_ROLES_ORDER[
first.descriptor.role] < TANKMEN_ROLES_ORDER[
second.descriptor.role]:
return -1
if TANKMEN_ROLES_ORDER[
first.descriptor.role] > TANKMEN_ROLES_ORDER[
second.descriptor.role]:
return 1
if first.lastname < second.lastname:
return -1
elif first.lastname > second.lastname:
return 1
else:
return 1
tankmen.sort(tankmenSortFunc)
for tankman in tankmen:
if not tankman.isInTank:
tankmenInBarracks += 1
if self.filter['nation'] != -1 and tankman.nation != self.filter[
'nation'] or self.filter[
'role'] != 'None' and tankman.descriptor.role != self.filter[
'role'] or self.filter[
'tankType'] != 'None' and tankman.vehicleType != self.filter[
'tankType'] or self.filter[
'location'] == 'tanks' and tankman.isInTank != True or self.filter[
'location'] == 'barracks' and tankman.isInTank == True or self.filter[
'nationID'] is not None and (
self.filter['location'] !=
str(tankman.vehicle.type.
id[1])
or self.filter['nationID']
!= str(tankman.nation)):
continue
slot, vehicleID, vehicle = (None, None, None)
if tankman.isInTank:
for vcl in vcls:
if vcl.inventoryId == tankman.vehicleID:
vehicle = vcl
vehicleID = vehicle.inventoryId
break
if vehicle is None:
LOG_ERROR('Cannot find vehicle for tankman: ', tankman,
tankman.descriptor.role, tankman.vehicle.name,
tankman.firstname, tankman.lastname)
continue
for i in range(len(vehicle.crew)):
if vehicle.crew[i] == tankman.inventoryId:
slot = i
break
isLocked, msg = self.getTankmanLockMessage(
vehicle) if tankman.isInTank else (False, '')
isInCurrentTank = tankman.vehicleID == g_currentVehicle.invID if tankman.isInTank and g_currentVehicle.isPresent(
) else False
tankmenList.append({
'firstname':
tankman.firstname,
'lastname':
tankman.lastname,
'rank':
tankman.rank,
'specializationLevel':
tankman.roleLevel,
'role':
tankman.role,
'vehicleType':
tankman.vehicle.type.shortUserString,
'iconFile':
tankman.icon,
'rankIconFile':
tankman.iconRank,
'roleIconFile':
'%s/%s' % (Tankman.ROLE_ICON_PATH_BIG, tankman.iconRole),
'contourIconFile':
tankman.vehicleIconContour,
'tankmanID':
tankman.inventoryId,
'nationID':
tankman.nation,
'typeID':
tankman.vehicle.type.id[1],
'slot':
slot,
'roleType':
tankman.descriptor.role,
'tankType':
tankman.vehicleType,
'inTank':
tankman.isInTank,
'inCurrentTank':
isInCurrentTank,
'vehicleID':
vehicleID,
'compact':
tankman.pack(),
'locked':
isLocked,
'lockMessage':
msg,
'vehicleBroken':
vehicle.repairCost > 0 if tankman.isInTank else None,
'isInSelfVehicleClass':
vehicle.type == tankman.vehicleType
if tankman.isInTank else True,
'isInSelfVehicleType':
vehicle.shortName == tankman.vehicle.type.shortUserString
if tankman.isInTank else True
})
self.as_setTankmenS(len(tankmen), slots, tankmenInBarracks,
BigWorld.wg_getGoldFormat(berthPrice),
berthsPrices[1], tankmenList)
return
def updateXPInfo(self):
freeXP = yield StatsRequester().getFreeExperience()
self.setFreeXP(freeXP)
def requestTableData(self, nation, type, filter):
Waiting.show('updateShop')
AccountSettings.setFilter('shop_current', (nation, type))
AccountSettings.setFilter('shop_' + type, filter)
nation = int(nation) if nation >= 0 else None
if nation is not None:
nation = getNationIndex(nation)
filter = list(filter)
requestType = [type]
checkFits = None
checkFitsArtefacts = None
checkExtra = False
modulesFits = {}
vehicleFits = []
extra = []
modulesAllVehicle = []
if type == self._MODULE:
typeSize = int(filter.pop(0))
requestType = filter[0:typeSize]
filter = filter[typeSize:]
fitsType = filter.pop(0)
compact = filter.pop(0)
if compact == '0':
LOG_ERROR('compact value has invalid value: ', compact)
Waiting.hide('updateShop')
return
fitsVehicle = getItemByCompact(compact)
checkExtra = True
extra = filter[:]
checkFits = True if fitsType != 'otherVehicles' else None
myVehicles = yield Requester(self._VEHICLE).getFromInventory()
modulesAllVehicle = VehicleItemsRequester(myVehicles).getItems(
requestType)
if fitsType == 'myVehicle':
for rType in requestType:
modulesFits.update(
_getComponentsByType(fitsVehicle,
ITEM_TYPE_INDICES[rType]))
elif fitsType != 'otherVehicles':
for vehicle in myVehicles:
for rType in requestType:
modulesFits.update(
_getComponentsByType(vehicle,
ITEM_TYPE_INDICES[rType]))
filter = requestType
elif type == self._SHELL:
filterSize = int(filter.pop(0))
fitsType = filter.pop(filterSize)
compact = filter.pop(filterSize)
if compact == '0':
LOG_ERROR('compact value has invalid value: ', compact)
Waiting.hide('updateShop')
return
fitsVehicle = getItemByCompact(compact)
checkFits = True if fitsType != 'otherGuns' else None
if fitsType == 'myVehicleGun':
for shoot in fitsVehicle.descriptor.gun['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
elif fitsType == 'myInventoryGuns':
myGuns = yield Requester('vehicleGun').getFromInventory()
for gun in myGuns:
for shoot in gun.descriptor['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
elif fitsType != 'otherGuns':
myGuns = yield Requester('vehicleGun').getFromInventory()
for gun in myGuns:
for shoot in gun.descriptor['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
myVehicles = yield Requester(self._VEHICLE).getFromInventory()
for vehicle in myVehicles:
for shoot in vehicle.descriptor.gun['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
elif type == self._VEHICLE:
filterSize = int(filter.pop(0))
extra = filter[filterSize:]
checkExtra = True
filter = filter[0:filterSize]
else:
fitsType = filter.pop(0)
compact = filter.pop(0)
if compact == '0':
LOG_ERROR('compact value has invalid value: ', compact)
Waiting.hide('updateShop')
return
fitsVehicle = getItemByCompact(compact)
extra = filter
checkExtra = type in (self._OPTIONAL_DEVICE, self._EQUIPMENT)
checkFitsArtefacts = True if fitsType != 'otherVehicles' else None
myVehicles = yield Requester(self._VEHICLE).getFromInventory()
modulesAllVehicle = VehicleItemsRequester(myVehicles).getItems(
requestType)
if fitsType == 'myVehicle':
vehicleFits = [fitsVehicle]
elif fitsType != 'otherVehicles':
vehicleFits = [v for v in myVehicles if v.nation == nation
] if nation != None else myVehicles
filter = requestType
filter = map(lambda w: w.lower(), filter)
modulesAll = list()
modulesAllInventory = list()
for rType in requestType:
inv = yield Requester(rType).getFromInventory()
modulesAllInventory.extend(inv)
shp = yield Requester(rType).getFromShop(nation=nation)
modulesAll.extend(shp)
unlocks = yield StatsRequester().getUnlocks()
shopRqs = yield ShopRequester().request()
self.__clearTableData()
self.__tableData = [type]
modulesAll.sort()
for module in modulesAll:
extraModuleInfo = None
if module.hidden:
continue
if module.type.lower() not in filter:
continue
if checkFits is not None:
if (module.compactDescr in modulesFits.keys()) != checkFits:
continue
if checkFitsArtefacts is not None:
for veh in vehicleFits:
if module.descriptor.checkCompatibilityWithVehicle(
veh.descriptor)[0] == checkFitsArtefacts:
break
else:
continue
if module.isClipGun():
extraModuleInfo = CLIP_ICON_PATH
inventoryCount = 0
vehicleCount = 0
installedIn = ''
if module in modulesAllInventory:
inventoryCount = 1
if type != self._VEHICLE:
inventoryModule = modulesAllInventory[
modulesAllInventory.index(module)]
inventoryCount = inventoryModule.count
if type in (self._MODULE, self._OPTIONAL_DEVICE,
self._EQUIPMENT) and module in modulesAllVehicle:
vehModule = modulesAllVehicle[modulesAllVehicle.index(module)]
vehicleCount = vehModule.count
installedIn = ', '.join(
[v.shortName for v in vehModule.vehicles])
if checkExtra:
if 'locked' not in extra:
if type == self._VEHICLE:
compdecs = module.descriptor.type.compactDescr
if compdecs not in unlocks:
continue
elif type not in (self._SHELL, self._OPTIONAL_DEVICE,
self._EQUIPMENT
) and module.compactDescr not in unlocks:
continue
if 'inHangar' not in extra and type not in (
self._OPTIONAL_DEVICE, self._EQUIPMENT):
if inventoryCount > 0:
continue
if 'onVehicle' not in extra:
if vehicleCount > 0:
continue
disabled = ''
if type == self._VEHICLE:
if BigWorld.player().isLongDisconnectedFromCenter:
disabled = MENU.SHOP_ERRORS_CENTERISDOWN
if inventoryCount > 0:
disabled = MENU.SHOP_ERRORS_INHANGAR
else:
compdecs = module.descriptor.type.compactDescr
if compdecs not in unlocks:
disabled = MENU.SHOP_ERRORS_UNLOCKNEEDED
elif type not in (
self._SHELL, self._OPTIONAL_DEVICE,
self._EQUIPMENT) and module.compactDescr not in unlocks:
disabled = MENU.SHOP_ERRORS_UNLOCKNEEDED
if not (shopRqs.isEnabledBuyingGoldShellsForCredits
and module.itemTypeName == 'shell'):
goldAmmoForCredits = shopRqs.isEnabledBuyingGoldEqsForCredits and module.itemTypeName == 'equipment'
module.priceOrder = goldAmmoForCredits and (
module.priceOrder[0] +
module.priceOrder[1] * shopRqs.exchangeRateForShellsAndEqs,
module.priceOrder[1])
valueElement = {
'id':
compactItem(module),
'name':
module.name if type in (self._OPTIONAL_DEVICE,
self._EQUIPMENT) else module.longName,
'desc':
getShortDescr(module.tableName),
'inventoryId':
None,
'inventoryCount':
inventoryCount,
'vehicleCount':
vehicleCount,
'credits':
module.priceOrder[0],
'gold':
module.priceOrder[1],
'price':
module.priceOrder,
'currency':
'credits' if module.priceOrder[1] == 0 else 'gold',
'level':
module.level,
'nation':
module.nation,
'type':
module.itemTypeName
if type not in (self._VEHICLE, self._OPTIONAL_DEVICE,
self._SHELL, self._EQUIPMENT) else module.icon,
'disabled':
disabled,
'statusLevel':
InventoryVehicle.STATE_LEVEL.WARNING,
'removable':
module.descriptor['removable']
if type == self._OPTIONAL_DEVICE else True,
'tankType':
module.type if type == self._VEHICLE else type,
'isPremium':
module.isPremium if type == self._VEHICLE else False,
'isElite':
self.app.tooltipManager.isVehicleElite(module)
if type == self._VEHICLE else False,
'itemTypeName':
module.itemTypeName,
'goldShellsForCredits':
shopRqs.isEnabledBuyingGoldShellsForCredits,
'goldEqsForCredits':
shopRqs.isEnabledBuyingGoldEqsForCredits,
EXTRA_MODULE_INFO:
extraModuleInfo
}
self.__tableData.append(valueElement)
requester = yield StatsRequesterr().request()
self._table.as_setGoldS(requester.gold)
self._table.as_setCreditsS(requester.credits)
self._table.as_setTableS(self.__tableData)
Waiting.hide('updateShop')
return
def requestTableData(self, nation, type, filter):
Waiting.show('updateInventory')
AccountSettings.setFilter('inventory_current', (nation, type))
AccountSettings.setFilter('inventory_' + type, filter)
nation = int(nation) if nation >= 0 else None
if nation is not None:
nation = getNationIndex(nation)
filter = list(filter)
requestType = [type]
checkFits = None
checkFitsArtefacts = None
checkExtra = False
modulesFits = {}
vehicleFits = []
extra = []
modulesAllVehicle = []
if type == self._MODULE:
typeSize = int(filter.pop(0))
requestType = filter[0:typeSize]
filter = filter[typeSize:]
fitsType = filter.pop(0)
fitsVehicle = getItemByCompact(filter.pop(0))
checkExtra = True
extra = filter[:]
checkFits = True if fitsType != 'otherVehicles' else False
myVehicles = yield Requester(self._VEHICLE).getFromInventory()
modulesAllVehicle = VehicleItemsRequester(myVehicles).getItems(requestType)
if fitsType == 'myVehicle':
if fitsVehicle:
for rType in requestType:
modulesFits.update(_getComponentsByType(fitsVehicle, ITEM_TYPE_INDICES[rType]))
else:
for vehicle in myVehicles:
for rType in requestType:
modulesFits.update(_getComponentsByType(vehicle, ITEM_TYPE_INDICES[rType]))
filter = requestType
elif type == self._SHELL:
filterSize = int(filter.pop(0))
fitsType = filter.pop(filterSize)
fitsVehicle = getItemByCompact(filter.pop(filterSize))
checkFits = True if fitsType != 'otherGuns' else False
if fitsType == 'myVehicleGun':
for shoot in fitsVehicle.descriptor.gun['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
elif fitsType == 'myInventoryGuns':
myGuns = yield Requester('vehicleGun').getFromInventory()
for gun in myGuns:
for shoot in gun.descriptor['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
else:
myGuns = yield Requester('vehicleGun').getFromInventory()
for gun in myGuns:
for shoot in gun.descriptor['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
myVehicles = yield Requester(self._VEHICLE).getFromInventory()
for vehicle in myVehicles:
for shoot in vehicle.descriptor.gun['shots']:
modulesFits[shoot[self._SHELL]['compactDescr']] = True
elif type == self._VEHICLE:
filterSize = int(filter.pop(0))
extra = filter[filterSize:]
checkExtra = True
filter = filter[0:filterSize]
else:
fitsType = filter.pop(0)
compact = filter.pop(0)
fitsVehicle = getItemByCompact(compact)
extra = filter
checkExtra = type in (self._OPTIONAL_DEVICE, self._EQUIPMENT)
checkFitsArtefacts = True if fitsType != 'otherVehicles' else False
myVehicles = yield Requester(self._VEHICLE).getFromInventory()
modulesAllVehicle = VehicleItemsRequester(myVehicles).getItems(requestType)
if fitsType == 'myVehicle':
vehicleFits = [fitsVehicle]
else:
vehicleFits = myVehicles
filter = requestType
filter = map(lambda w: w.lower(), filter)
modulesAll = list()
modulesShop = list()
for rType in requestType:
inv = yield Requester(rType).getFromInventory()
shp = yield Requester(rType).getFromShop()
modulesShop.extend(shp)
modulesAll.extend(inv)
vehPrices = {}
if type == self._VEHICLE:
compactDescrs = [ v.compactDescr for v in modulesAll ]
vehPrices = yield StatsRequester().getVehiclesPrices(compactDescrs)
vehPrices = dict(zip(compactDescrs, vehPrices))
if type in (self._MODULE, self._OPTIONAL_DEVICE, self._EQUIPMENT):
for vehModule in modulesAllVehicle:
if vehModule not in modulesAll:
if modulesShop.count(vehModule) != 0:
modulesAll.append(vehModule)
self.__clearTableData()
self.__tableData = [type]
excludeModules = []
for module in modulesAll:
if modulesShop.count(module) != 0:
module.priceOrder = modulesShop[modulesShop.index(module)].priceOrder
elif constants.IS_DEVELOPMENT:
excludeModules.append(module)
LOG_ERROR("Not found module %s '%s' (%r) in shop." % (module.type, module.unicName, module.compactDescr))
modulesAll.sort()
shopRqs = yield ShopRequester().request()
for module in modulesAll:
extraModuleInfo = None
if module in excludeModules:
continue
if nation is not None:
if module.nation != nation and module.nation != nations.NONE_INDEX:
continue
if module.type.lower() not in filter:
continue
if checkFits is not None:
if (module.compactDescr in modulesFits.keys()) != checkFits:
continue
if module.isClipGun():
extraModuleInfo = CLIP_ICON_PATH
if checkFitsArtefacts is not None:
compatible = False
for veh in vehicleFits:
if nation is not None and veh.nation != nation:
continue
compatible |= module.descriptor.checkCompatibilityWithVehicle(veh.descriptor)[0]
if compatible != checkFitsArtefacts:
continue
inventoryCount = 0
vehicleCount = 0
if isinstance(module, VehicleItem):
vehicleCount = module.count
else:
inventoryCount = module.count
if type in (self._MODULE, self._OPTIONAL_DEVICE, self._EQUIPMENT) and module in modulesAllVehicle:
vehModule = modulesAllVehicle[modulesAllVehicle.index(module)]
vehicleCount = vehModule.count
if checkExtra:
if type == self._VEHICLE and 'brocken' not in extra:
if module.repairCost > 0:
continue
if type == self._VEHICLE and 'locked' not in extra:
if module.lock != 0:
continue
if 'onVehicle' not in extra:
if vehicleCount > 0 and inventoryCount == 0:
continue
disable = ''
if type == self._VEHICLE and not module.canSell:
disable = makeString(MENU.tankcarousel_vehiclestates(module.getState()))
elif type in (self._MODULE, self._OPTIONAL_DEVICE, self._EQUIPMENT) and isinstance(module, VehicleItem):
if type == self._OPTIONAL_DEVICE:
if not module.descriptor['removable']:
disable = makeString(MENU.INVENTORY_DEVICE_ERRORS_NOT_REMOVABLE)
else:
disable = makeString(MENU.INVENTORY_DEVICE_ERRORS_RESERVED)
else:
disable = makeString(MENU.INVENTORY_ERRORS_RESERVED)
sellPrice = isinstance(module, InventoryVehicle) and vehPrices.get(module.compactDescr, (0, 0))
else:
sellPrice = (0, 0)
item = g_itemsCache.items.getItemByCD(module.compactDescr)
if item is not None:
sellPrice = item.sellPrice
valueElement = {'id': compactItem(module),
'name': module.name if type in (self._OPTIONAL_DEVICE, self._EQUIPMENT) else module.longName,
'desc': getShortDescr(module.tableName),
'inventoryId': module.inventoryId if isinstance(module, InventoryVehicle) else None,
'inventoryCount': inventoryCount,
'vehicleCount': vehicleCount,
'credits': sellPrice[0],
'gold': sellPrice[1],
'price': sellPrice,
'currency': 'credits' if sellPrice[1] == 0 else 'gold',
'level': module.level,
'nation': module.nation,
'type': module.itemTypeName if type not in (self._VEHICLE,
self._OPTIONAL_DEVICE,
self._SHELL,
self._EQUIPMENT) else module.icon,
'disabled': disable,
'statusLevel': module.getStateLevel() if isinstance(module, InventoryVehicle) else InventoryVehicle.STATE_LEVEL.INFO,
'removable': module.descriptor['removable'] if type == self._OPTIONAL_DEVICE else True,
'tankType': module.type if type == self._VEHICLE else type,
'isPremium': module.isPremium if type == self._VEHICLE else False,
'isElite': self.app.tooltipManager.isVehicleElite(module) if type == self._VEHICLE else False,
'itemTypeName': module.itemTypeName,
'goldShellsForCredits': shopRqs.isEnabledBuyingGoldShellsForCredits,
'goldEqsForCredits': shopRqs.isEnabledBuyingGoldEqsForCredits,
EXTRA_MODULE_INFO: extraModuleInfo}
self.__tableData.append(valueElement)
requester = yield StatsRequesterr().request()
self._table.as_setGoldS(requester.gold)
self._table.as_setCreditsS(requester.credits)
self._table.as_setTableS(self.__tableData)
Waiting.hide('updateInventory')
return
def updateClanInfo(self):
clanInfo = yield StatsRequester().getClanInfo()
self.setClanInfo(clanInfo)
def __requestAvailableItems(self, type):
myVehicles = yield Requester('vehicle').getFromInventory()
modulesAllVehicle = VehicleItemsRequester(myVehicles).getItems([type])
oldStyleVehicle = None
for v in myVehicles:
if v.inventoryId == g_currentVehicle.invID:
oldStyleVehicle = v
break
newStyleVehicle = g_currentVehicle.item
modulesAllInventory = yield Requester(type).getFromInventory()
data = yield AvailableItemsRequester(oldStyleVehicle, type).request()
if type in AmmunitionPanel.__ARTEFACTS_SLOTS:
unlocks = [ m for m in data if m.isCurrent ]
else:
unlocks = yield StatsRequester().getUnlocks()
data.sort(reverse=True)
if type in AmmunitionPanel.__ARTEFACTS_SLOTS:
dataProvider = [[], [], []]
else:
dataProvider = []
credits, gold = g_itemsCache.items.stats.money
for module in data:
price = yield module.getPrice()
inventoryCount, vehicleCount = self.__getModuleInventoryAndVehicleCounts(modulesAllVehicle, modulesAllInventory, module, type)
moduleData = {'id': gui_items.compactItem(module),
'type': type,
'name': module.name if type in AmmunitionPanel.__ARTEFACTS_SLOTS else module.longName,
'desc': module.getTableName(oldStyleVehicle),
'target': 2 if type == ITEM_TYPE_NAMES[3] and not oldStyleVehicle.hasTurrets else module.target,
'price': price[0] if price[1] == 0 else price[1],
'currency': 'credits' if price[1] == 0 else 'gold',
'icon': module.icon if type in AmmunitionPanel.__ARTEFACTS_SLOTS else module.level,
'inventoryCount': inventoryCount,
'vehicleCount': vehicleCount}
if type == ITEM_TYPE_NAMES[4]:
if module.isClipGun(oldStyleVehicle.descriptor):
moduleData[EXTRA_MODULE_INFO] = CLIP_ICON_PATH
if type in AmmunitionPanel.__ARTEFACTS_SLOTS:
moduleData['removable'] = module.isRemovable
moduleData['slotIndex'] = module.index
for i in xrange(3):
md = moduleData.copy()
fits = isModuleFitVehicle(module, newStyleVehicle, price, (credits, gold), unlocks, i)
if md.get('target') == 1:
md['status'] = MENU.MODULEFITS_WRONG_SLOT if i != md.get('slotIndex') else fits[1]
md['isSelected'] = i == md.get('slotIndex')
else:
md['status'] = fits[1]
md['isSelected'] = False
md['slotIndex'] = i
dataProvider[i].append(md)
else:
fits = isModuleFitVehicle(module, newStyleVehicle, price, (credits, gold), unlocks)
moduleData['removable'] = True
moduleData['isSelected'] = moduleData.get('target') == 1
moduleData['status'] = fits[1]
dataProvider.append(moduleData)
self.as_setDataS(dataProvider, type)
return
def onAccountShowGUI(self):
clanInfo = yield StatsRequester().getClanInfo()
self._setClanInfo(clanInfo)
g_clientUpdateManager.addCallbacks(
{'stats.clanInfo': self._setClanInfo})
def __buyGold(self, vcoin):
self.__buyCallback = None
success, errStr = yield StatsRequester().ebankBuyGold(vcoin)
self.__updateBuyingCooldown()
self.onEbankUpdateBalanceComplete(errStr, vcoin)
return
def onLoaded(self):
dossier = yield StatsRequester().getAccountDossier()
self.call(
'logitech.setStatsData',
dossiers_utils.getDossierTotalBlocksSummary(dossier,
isCompact=True))