class ProfileTechniqueWindow(ProfileTechnique):
def __init__(self, *args):
ProfileTechnique.__init__(self, *args)
self.__dataReceiver = QueuedVehicleDossierReceiver()
self.__currentlyRequestingVehicleId = None
self.__dataReceiver.onDataReceived += self.__requestedDataReceived
return
def __requestedDataReceived(self, databaseID, vehicleID):
if self.__currentlyRequestingVehicleId == vehicleID:
self._receiveVehicleDossier(vehicleID, databaseID)
def _populate(self):
super(ProfileTechniqueWindow, self)._populate()
def requestData(self, data):
self.as_responseVehicleDossierS(None)
self.__currentlyRequestingVehicleId = data.vehicleId
self.__dataReceiver.invoke(self._databaseID, self.__currentlyRequestingVehicleId)
return
def _dispose(self):
self.__dataReceiver.onDataReceived -= self.__requestedDataReceived
self.__dataReceiver.dispose()
self.__dataReceiver = None
super(ProfileTechniqueWindow, self)._dispose()
return
class ProfileTechniqueWindow(ProfileTechnique):
def __init__(self, *args):
ProfileTechnique.__init__(self, *args)
self.__dataReceiver = QueuedVehicleDossierReceiver()
self.__currentlyRequestingVehicleId = None
self.__dataReceiver.onDataReceived += self.__requestedDataReceived
return
def __requestedDataReceived(self, databaseID, vehicleID):
if self.__currentlyRequestingVehicleId == vehicleID:
self._receiveVehicleDossier(vehicleID, databaseID)
def _populate(self):
super(ProfileTechniqueWindow, self)._populate()
def requestData(self, data):
self.as_responseVehicleDossierS(None)
self.__currentlyRequestingVehicleId = data.vehicleId
self.__dataReceiver.invoke(self._databaseID,
self.__currentlyRequestingVehicleId)
return
def _dispose(self):
self.__dataReceiver.onDataReceived -= self.__requestedDataReceived
self.__dataReceiver.dispose()
self.__dataReceiver = None
super(ProfileTechniqueWindow, self)._dispose()
return
class ProfileTechniqueWindow(ProfileTechnique):
def __init__(self, *args):
super(ProfileTechniqueWindow, self).__init__(*args)
self.__dataReceiver = QueuedVehicleDossierReceiver()
self.__currentlyRequestingVehicleId = None
self.__dataReceiver.onDataReceived += self.__requestedDataReceived
return
def requestData(self, vehicleId):
self.as_responseVehicleDossierS(None)
self.__currentlyRequestingVehicleId = int(vehicleId)
self.__dataReceiver.invoke(self._databaseID,
self.__currentlyRequestingVehicleId)
return
def invokeUpdate(self):
super(ProfileTechniqueWindow, self).invokeUpdate()
if self._selectedVehicleIntCD is not None:
self._receiveVehicleDossier(self._selectedVehicleIntCD,
self._databaseID)
return
def _dispose(self):
self.__dataReceiver.onDataReceived -= self.__requestedDataReceived
self.__dataReceiver.dispose()
self.__dataReceiver = None
super(ProfileTechniqueWindow, self)._dispose()
return
def _setRatingButton(self):
self.as_setRatingButtonS({'enabled': False, 'visible': False})
def __requestedDataReceived(self, databaseID, vehicleID):
if self.__currentlyRequestingVehicleId == vehicleID:
self._receiveVehicleDossier(vehicleID, databaseID)
class _Dossier(object):
itemsCache = dependency.descriptor(IItemsCache)
lobbyContext = dependency.descriptor(ILobbyContext)
def __init__(self, *args):
self.__dataReceiver = QueuedVehicleDossierReceiver()
self.__dataReceiver.onDataReceived += self.__requestedDataReceived
self._cache = {}
def _dispose(self):
self.__dataReceiver.onDataReceived -= self.__requestedDataReceived
self.__dataReceiver.dispose()
self.__dataReceiver = None
def requestDossier(self, args):
(self._battlesType, accountDBID, vehCD) = args
if vehCD == 0 or self.__isVehicleDossierLoaded(accountDBID, vehCD):
self.__requestedDataReceived(accountDBID, vehCD)
else:
self.__dataReceiver.invoke(accountDBID, vehCD)
def __requestedDataReceived(self, accountDBID, vehCD):
# respond
res = self.getDossier(self._battlesType, accountDBID, vehCD)
as_xfw_cmd(XVM_COMMAND.AS_DOSSIER, accountDBID, vehCD, res)
def getAccountDossierValue(self, name):
return self.getDossier(PROFILE_DROPDOWN_KEYS.ALL).get(name, None)
def getDossier(self, battlesType, accountDBID=None, vehCD=0):
self._battlesType = battlesType
if accountDBID == 0:
accountDBID = None
if accountDBID is not None:
accountDBID = int(accountDBID)
if vehCD is None:
vehCD = 0
else:
vehCD = int(vehCD)
cache_key = "{}:{}:{}".format(battlesType, 0 if accountDBID is None else accountDBID, vehCD)
if vehCD == 0:
# account dossier
dossier = self.itemsCache.items.getAccountDossier(accountDBID)
cache_item = self._cache.get(cache_key, None)
if cache_item is not None and cache_item['totalBattles'] == dossier.getTotalStats().getBattlesCount():
return cache_item
res = self.__prepareAccountResult(accountDBID, dossier)
self._cache[cache_key] = res
return res
# vehicle dossier
vehicle = self.itemsCache.items.getItemByCD(vehCD)
rent = vehicle.isRented
multiNation = vehicle.hasNationGroup
outfit = vehicle.getOutfit(SeasonType.SUMMER)
summer_camo = outfit is not None and bool(outfit.hull.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).getItemCD()) # vehicle_outfit.MultiSlot
outfit = vehicle.getOutfit(SeasonType.WINTER)
winter_camo = outfit is not None and bool(outfit.hull.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).getItemCD())
outfit = vehicle.getOutfit(SeasonType.DESERT)
desert_camo = outfit is not None and bool(outfit.hull.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).getItemCD())
crystalEarned = self.itemsCache.items.stats.getWeeklyVehicleCrystals(vehCD)
if self.__isVehicleDossierLoaded(accountDBID, vehCD):
dossier = self.itemsCache.items.getVehicleDossier(vehCD, accountDBID)
totalBattles = dossier.getTotalStats().getBattlesCount()
randomBattles = dossier.getRandomStats().getBattlesCount()
else:
dossier = _DummyDossier()
totalBattles = 0
randomBattles = 0
cache_item = self._cache.get(cache_key, None)
if cache_item is not None and cache_item['totalBattles'] == totalBattles:
self.__updateCamouflageResult(cache_item, summer_camo, winter_camo, desert_camo)
return cache_item
xpVehs = self.itemsCache.items.stats.vehiclesXPs
earnedXP = xpVehs.get(vehCD, 0)
freeXP = self.itemsCache.items.stats.actualFreeXP
#log('vehCD: {0} pVehXp: {1}'.format(vehCD, earnedXP))
xpToElite = 0
unlocks = self.itemsCache.items.stats.unlocks
_, nID, invID = vehicles.parseIntCompactDescr(vehCD)
vType = vehicles.g_cache.vehicle(nID, invID)
for data in vType.unlocksDescrs:
if data[1] not in unlocks:
xpToElite += data[0]
# xTDB, xTE, WTR, xWTR
xtdb = -1
xte = -1
wtr = -1
xwtr = -1
if randomBattles > 0:
stats = self.__getStatsBlock(dossier)
dmg = stats.getDamageDealt()
frg = stats.getFragsCount()
if dmg >= 0 and frg >= 0:
curdmg = float(dmg) / randomBattles
curfrg = float(frg) / randomBattles
xtdb = vehinfo.calculateXTDB(vehCD, curdmg)
xte = vehinfo.calculateXTE(vehCD, curdmg, curfrg)
#TODO: how to get WTR value from dossier?
#wtr = stats.getWTR()
#if wtr is None:
# wtr = -1
#else:
# xwtr = vehinfo.calculateXvmScale('wtr', wtr)
res = self.__prepareVehicleResult(accountDBID, vehCD, dossier, xtdb, xte, wtr, xwtr, earnedXP, freeXP, xpToElite, rent, multiNation, crystalEarned)
self.__updateCamouflageResult(res, summer_camo, winter_camo, desert_camo)
self._cache[cache_key] = res
return res
# PRIVATE
# check vehicle dossier already loaded and cached
def __isVehicleDossierLoaded(self, accountDBID, vehCD):
if accountDBID is None or accountDBID == 0:
return True
container = self.itemsCache.items._ItemsRequester__itemsCache[GUI_ITEM_TYPE.VEHICLE_DOSSIER]
dossier = container.get((accountDBID, vehCD))
return dossier is not None
def __getStatsBlock(self, dossier):
if self._battlesType == PROFILE_DROPDOWN_KEYS.ALL:
return dossier.getRandomStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FALLOUT:
return dossier.getFalloutStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.HISTORICAL:
return dossier.getHistoricalStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.TEAM:
return dossier.getTeam7x7Stats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.STATICTEAM:
return dossier.getRated7x7Stats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS:
return dossier.getFortSortiesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.CLAN:
return dossier.getGlobalMapStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.STATICTEAM_SEASON:
currentSeasonID = self.lobbyContext.getServerSettings().eSportCurrentSeason.getID()
return dossier.getSeasonRated7x7Stats(currentSeasonID)
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS_BATTLES:
return dossier.getFortBattlesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS_SORTIES:
return dossier.getFortSortiesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.COMPANY:
return dossier.getCompanyStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.RANKED:
return dossier.getRankedStats()
raise ValueError('_Dossier: Unknown battle type: ' + self._battlesType)
def __prepareCommonResult(self, accountDBID, dossier):
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
return {
'accountDBID': 0 if accountDBID is None else accountDBID,
'battles': stats.getBattlesCount(),
'totalBattles': dossier.getTotalStats().getBattlesCount(),
'wins': stats.getWinsCount(),
'winrate': float(stats.getWinsCount()) / float(stats.getBattlesCount()) * 100.0 if stats.getBattlesCount() > 0 else None,
'losses': stats.getLossesCount(),
'xp': stats.getXP(),
'survived': stats.getSurvivedBattlesCount(),
'shots': stats.getShotsCount(),
'hits': stats.getHitsCount(),
'hitPercent': float(stats.getHitsCount()) / float(stats.getShotsCount()) * 100.0 if stats.getShotsCount() > 0 else None,
'spotted': stats.getSpottedEnemiesCount(),
'frags': stats.getFragsCount(),
'damageDealt': stats.getDamageDealt(),
'damageReceived': stats.getDamageReceived(),
'capture': stats.getCapturePoints(),
'defence': stats.getDroppedCapturePoints(),
'originalXP': stats.getOriginalXP(),
'damageAssistedTrack': stats.getDamageAssistedTrack(),
'damageAssistedRadio': stats.getDamageAssistedRadio(),
'shotsReceived': stats.getShotsReceived(),
'noDamageShotsReceived': stats.getNoDamageShotsReceived(),
'piercedReceived': stats.getPiercedReceived(),
'heHitsReceived': stats.getHeHitsReceived(),
'he_hits': stats.getHeHits(),
'pierced': stats.getPierced(),
'maxXP': stats.getMaxXp(),
'maxFrags': stats.getMaxFrags(),
'maxDamage': stats.getMaxDamage(),
'battleLifeTime': glob.getBattleLifeTime(),
'mileage': glob.getMileage(),
'treesCut': glob.getTreesCut()}
def __prepareAccountResult(self, accountDBID, dossier):
if dossier is None:
return {}
res = self.__prepareCommonResult(accountDBID, dossier)
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
lbt = glob.getLastBattleTime()
res.update({
'maxXPVehCD': stats.getMaxXpVehicle(),
'maxFragsVehCD': stats.getMaxFragsVehicle(),
'maxDamageVehCD': stats.getMaxDamageVehicle(),
'creationTime': glob.getCreationTime(),
'lastBattleTime': lbt,
'lastBattleTimeStr': makeString(MENU.PROFILE_HEADER_LASTBATTLEDATETITLE) + ' ' +
('%s %s' % (backport.getLongDateFormat(lbt), backport.getShortTimeFormat(lbt))),
'vehicles': {}})
vehicles = stats.getVehicles()
for (vehCD, vdata) in vehicles.iteritems():
res['vehicles'][str(vehCD)] = {
'battles': vdata.battlesCount,
'wins': vdata.wins,
'mastery': stats.getMarkOfMasteryForVehicle(vehCD),
'xp': vdata.xp}
# add tanks with 0 battles
vehicles = self.itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY)
for (vehCD, vdata) in vehicles.iteritems():
if str(vehCD) not in res['vehicles']:
res['vehicles'][str(vehCD)] = {
'battles': 0,
'wins': 0,
'mastery': 0,
'xp': 0}
return res
def __prepareVehicleResult(self, accountDBID, vehCD, dossier, xtdb, xte, wtr, xwtr, earnedXP, freeXP, xpToElite, rent, multiNation, crystalEarned):
res = self.__prepareCommonResult(accountDBID, dossier)
res.update({
'vehCD': vehCD,
'xtdb': xtdb,
'xte': xte,
'wtr': wtr,
'xwtr': xwtr,
'earnedXP': earnedXP,
'freeXP': freeXP,
'xpToElite': xpToElite,
'rent': 'rent' if rent else None,
'multiNation': 'multi' if multiNation else None,
'marksOnGun': int(dossier.getRecordValue(_AB.TOTAL, 'marksOnGun')),
'damageRating': dossier.getRecordValue(_AB.TOTAL, 'damageRating') / 100.0,
'crystalEarned': crystalEarned})
return res
def __updateCamouflageResult(self, res, summer_camo, winter_camo, desert_camo):
res.update({
'camouflageSummer': 'summer' if summer_camo else None,
'camouflageWinter': 'winter' if winter_camo else None,
'camouflageDesert': 'desert' if desert_camo else None,
'camouflageCount': int(summer_camo) + int(winter_camo) + int(desert_camo)})
class _Dossier(object):
def __init__(self, *args):
self.__dataReceiver = QueuedVehicleDossierReceiver()
self.__dataReceiver.onDataReceived += self.__requestedDataReceived
def _dispose(self):
self.__dataReceiver.onDataReceived -= self.__requestedDataReceived
self.__dataReceiver.dispose()
self.__dataReceiver = None
def requestDossier(self, args):
(self._battlesType, accountDBID, vehCD) = args
if vehCD == 0 or self.__isVehicleDossierCached(accountDBID, vehCD):
self.__requestedDataReceived(accountDBID, vehCD)
else:
self.__dataReceiver.invoke(accountDBID, vehCD)
def __requestedDataReceived(self, accountDBID, vehCD):
# respond
res = self.getDossier((self._battlesType, accountDBID, vehCD))
#log(res)
as_xfw_cmd(XVM_COMMAND.AS_DOSSIER, accountDBID, vehCD, res)
def getDossier(self, args):
#log(str(args))
(self._battlesType, self.accountDBID, self.vehCD) = args
if self.accountDBID == 0:
self.accountDBID = None
if self.vehCD == 0:
dossier = g_itemsCache.items.getAccountDossier(self.accountDBID)
res = self.__prepareAccountResult(dossier)
else:
vehCD = int(self.vehCD)
if not self.__isVehicleDossierCached(self.accountDBID, vehCD):
return None
dossier = g_itemsCache.items.getVehicleDossier(vehCD, self.accountDBID)
xpVehs = g_itemsCache.items.stats.vehiclesXPs
earnedXP = xpVehs.get(vehCD, 0)
freeXP = g_itemsCache.items.stats.actualFreeXP
#log('vehCD: {0} pVehXp: {1}'.format(vehCD, earnedXP))
xpToElite = 0
unlocks = g_itemsCache.items.stats.unlocks
_, nID, invID = vehicles.parseIntCompactDescr(vehCD)
vType = vehicles.g_cache.vehicle(nID, invID)
for data in vType.unlocksDescrs:
if data[1] not in unlocks:
xpToElite += data[0]
# xTDB & xTE
xtdb = -1
xte = -1
if dossier is not None:
stats = self.__getStatsBlock(dossier)
battles = stats.getBattlesCount()
dmg = stats.getDamageDealt()
frg = stats.getFragsCount()
if battles > 0 and dmg >= 0 and frg >= 0:
xtdb = vehinfo_xtdb.calculateXTDB(vehCD, float(dmg) / battles)
xte = vehinfo_xte.calculateXTE(vehCD, float(dmg) / battles, float(frg) / battles)
res = self.__prepareVehicleResult(dossier, xtdb, xte, earnedXP, freeXP, xpToElite)
return res
# PRIVATE
# check vehicle dossier already loaded and cached
def __isVehicleDossierCached(self, accountDBID, vehCD):
if accountDBID is None or accountDBID == 0:
return True
container = g_itemsCache.items._ItemsRequester__itemsCache[GUI_ITEM_TYPE.VEHICLE_DOSSIER]
dossier = container.get((accountDBID, vehCD))
return dossier is not None
def __getStatsBlock(self, dossier):
if self._battlesType == PROFILE_DROPDOWN_KEYS.ALL:
return dossier.getRandomStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FALLOUT:
return dossier.getFalloutStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.HISTORICAL:
return dossier.getHistoricalStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.TEAM:
return dossier.getTeam7x7Stats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.STATICTEAM:
return dossier.getRated7x7Stats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS:
return dossier.getFortSortiesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.CLAN:
return dossier.getGlobalMapStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.STATICTEAM_SEASON:
currentSeasonID = g_lobbyContext.getServerSettings().eSportCurrentSeason.getID()
return dossier.getSeasonRated7x7Stats(currentSeasonID)
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS_BATTLES:
return dossier.getFortBattlesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS_SORTIES:
return dossier.getFortSortiesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.COMPANY:
return dossier.getCompanyStats()
raise ValueError('_Dossier: Unknown battle type: ' + self._battlesType)
def __prepareCommonResult(self, dossier):
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
return {
'accountDBID': 0 if self.accountDBID is None else int(self.accountDBID),
'battles': stats.getBattlesCount(),
'wins': stats.getWinsCount(),
'losses': stats.getLossesCount(),
'xp': stats.getXP(),
'survived': stats.getSurvivedBattlesCount(),
'shots': stats.getShotsCount(),
'hits': stats.getHitsCount(),
'spotted': stats.getSpottedEnemiesCount(),
'frags': stats.getFragsCount(),
'damageDealt': stats.getDamageDealt(),
'damageReceived': stats.getDamageReceived(),
'capture': stats.getCapturePoints(),
'defence': stats.getDroppedCapturePoints(),
'originalXP': stats.getOriginalXP(),
'damageAssistedTrack': stats.getDamageAssistedTrack(),
'damageAssistedRadio': stats.getDamageAssistedRadio(),
'shotsReceived': stats.getShotsReceived(),
'noDamageShotsReceived': stats.getNoDamageShotsReceived(),
'piercedReceived': stats.getPiercedReceived(),
'heHitsReceived': stats.getHeHitsReceived(),
'he_hits': stats.getHeHits(),
'pierced': stats.getPierced(),
'maxXP': stats.getMaxXp(),
'maxFrags': stats.getMaxFrags(),
'maxDamage': stats.getMaxDamage(),
'battleLifeTime': glob.getBattleLifeTime(),
'mileage': glob.getMileage(),
'treesCut': glob.getTreesCut(),
}
def __prepareAccountResult(self, dossier):
res = {}
if dossier is None:
return res
res = self.__prepareCommonResult(dossier)
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
lbt = glob.getLastBattleTime()
res.update({
'maxXPVehCD': stats.getMaxXpVehicle(),
'maxFragsVehCD': stats.getMaxFragsVehicle(),
'maxDamageVehCD': stats.getMaxDamageVehicle(),
'creationTime': glob.getCreationTime(),
'lastBattleTime': lbt,
'lastBattleTimeStr': makeString(MENU.PROFILE_HEADER_LASTBATTLEDATETITLE) + ' ' +
('%s %s' % (BigWorld.wg_getLongDateFormat(lbt), BigWorld.wg_getShortTimeFormat(lbt))),
'vehicles': {}
})
vehicles = stats.getVehicles()
for (vehCD, vdata) in vehicles.iteritems():
res['vehicles'][str(vehCD)] = {
'battles': vdata.battlesCount,
'wins': vdata.wins,
'mastery': vdata.markOfMastery,
'xp': vdata.xp,
}
return res
def __prepareVehicleResult(self, dossier, xtdb, xte, earnedXP, freeXP, xpToElite):
res = {}
if dossier is None:
return res
res = self.__prepareCommonResult(dossier)
res.update({
'vehCD': int(self.vehCD),
'xtdb': xtdb,
'xte': xte,
'earnedXP': earnedXP,
'freeXP': freeXP,
'xpToElite': xpToElite,
'marksOnGun': int(dossier.getRecordValue(_AB.TOTAL, 'marksOnGun')),
'damageRating': dossier.getRecordValue(_AB.TOTAL, 'damageRating') / 100.0,
})
return res
class _Dossier(object):
def __init__(self, *args):
self.__dataReceiver = QueuedVehicleDossierReceiver()
self.__dataReceiver.onDataReceived += self.__requestedDataReceived
def _dispose(self):
self.__dataReceiver.onDataReceived -= self.__requestedDataReceived
self.__dataReceiver.dispose()
self.__dataReceiver = None
def requestDossier(self, args):
(self._battlesType, accountDBID, vehCD) = args
if vehCD == 0 or self.__isVehicleDossierCached(accountDBID, vehCD):
self.__requestedDataReceived(accountDBID, vehCD)
else:
self.__dataReceiver.invoke(accountDBID, vehCD)
def __requestedDataReceived(self, accountDBID, vehCD):
# respond
res = self.getDossier((self._battlesType, accountDBID, vehCD))
#log(res)
as_xfw_cmd(XVM_COMMAND.AS_DOSSIER, accountDBID, vehCD, res)
def getDossier(self, args):
#log(str(args))
(self._battlesType, self.accountDBID, self.vehCD) = args
if self.accountDBID == 0:
self.accountDBID = None
if self.vehCD == 0:
dossier = g_itemsCache.items.getAccountDossier(self.accountDBID)
res = self.__prepareAccountResult(dossier)
else:
vehCD = int(self.vehCD)
if not self.__isVehicleDossierCached(self.accountDBID, vehCD):
return None
dossier = g_itemsCache.items.getVehicleDossier(
vehCD, self.accountDBID)
xpVehs = g_itemsCache.items.stats.vehiclesXPs
earnedXP = xpVehs.get(vehCD, 0)
freeXP = g_itemsCache.items.stats.actualFreeXP
#log('vehCD: {0} pVehXp: {1}'.format(vehCD, earnedXP))
xpToElite = 0
unlocks = g_itemsCache.items.stats.unlocks
_, nID, invID = vehicles.parseIntCompactDescr(vehCD)
vType = vehicles.g_cache.vehicle(nID, invID)
for data in vType.unlocksDescrs:
if data[1] not in unlocks:
xpToElite += data[0]
# xTDB & xTE
xtdb = -1
xte = -1
if dossier is not None:
stats = self.__getStatsBlock(dossier)
battles = stats.getBattlesCount()
dmg = stats.getDamageDealt()
frg = stats.getFragsCount()
if battles > 0 and dmg >= 0 and frg >= 0:
xtdb = vehinfo_xtdb.calculateXTDB(vehCD,
float(dmg) / battles)
xte = vehinfo_xte.calculateXTE(vehCD,
float(dmg) / battles,
float(frg) / battles)
res = self.__prepareVehicleResult(dossier, xtdb, xte, earnedXP,
freeXP, xpToElite)
return res
# PRIVATE
# check vehicle dossier already loaded and cached
def __isVehicleDossierCached(self, accountDBID, vehCD):
if accountDBID is None or accountDBID == 0:
return True
container = g_itemsCache.items._ItemsRequester__itemsCache[
GUI_ITEM_TYPE.VEHICLE_DOSSIER]
dossier = container.get((accountDBID, vehCD))
return dossier is not None
def __getStatsBlock(self, dossier):
if self._battlesType == PROFILE_DROPDOWN_KEYS.ALL:
return dossier.getRandomStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FALLOUT:
return dossier.getFalloutStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.HISTORICAL:
return dossier.getHistoricalStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.TEAM:
return dossier.getTeam7x7Stats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.STATICTEAM:
return dossier.getRated7x7Stats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS:
return dossier.getFortSortiesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.CLAN:
return dossier.getGlobalMapStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.STATICTEAM_SEASON:
currentSeasonID = g_lobbyContext.getServerSettings(
).eSportCurrentSeason.getID()
return dossier.getSeasonRated7x7Stats(currentSeasonID)
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS_BATTLES:
return dossier.getFortBattlesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.FORTIFICATIONS_SORTIES:
return dossier.getFortSortiesStats()
elif self._battlesType == PROFILE_DROPDOWN_KEYS.COMPANY:
return dossier.getCompanyStats()
raise ValueError('_Dossier: Unknown battle type: ' + self._battlesType)
def __prepareCommonResult(self, dossier):
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
return {
'accountDBID':
0 if self.accountDBID is None else int(self.accountDBID),
'battles': stats.getBattlesCount(),
'wins': stats.getWinsCount(),
'losses': stats.getLossesCount(),
'xp': stats.getXP(),
'survived': stats.getSurvivedBattlesCount(),
'shots': stats.getShotsCount(),
'hits': stats.getHitsCount(),
'spotted': stats.getSpottedEnemiesCount(),
'frags': stats.getFragsCount(),
'damageDealt': stats.getDamageDealt(),
'damageReceived': stats.getDamageReceived(),
'capture': stats.getCapturePoints(),
'defence': stats.getDroppedCapturePoints(),
'originalXP': stats.getOriginalXP(),
'damageAssistedTrack': stats.getDamageAssistedTrack(),
'damageAssistedRadio': stats.getDamageAssistedRadio(),
'shotsReceived': stats.getShotsReceived(),
'noDamageShotsReceived': stats.getNoDamageShotsReceived(),
'piercedReceived': stats.getPiercedReceived(),
'heHitsReceived': stats.getHeHitsReceived(),
'he_hits': stats.getHeHits(),
'pierced': stats.getPierced(),
'maxXP': stats.getMaxXp(),
'maxFrags': stats.getMaxFrags(),
'maxDamage': stats.getMaxDamage(),
'battleLifeTime': glob.getBattleLifeTime(),
'mileage': glob.getMileage(),
'treesCut': glob.getTreesCut(),
}
def __prepareAccountResult(self, dossier):
res = {}
if dossier is None:
return res
res = self.__prepareCommonResult(dossier)
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
lbt = glob.getLastBattleTime()
res.update({
'maxXPVehCD':
stats.getMaxXpVehicle(),
'maxFragsVehCD':
stats.getMaxFragsVehicle(),
'maxDamageVehCD':
stats.getMaxDamageVehicle(),
'creationTime':
glob.getCreationTime(),
'lastBattleTime':
lbt,
'lastBattleTimeStr':
makeString(MENU.PROFILE_HEADER_LASTBATTLEDATETITLE) + ' ' +
('%s %s' % (BigWorld.wg_getLongDateFormat(lbt),
BigWorld.wg_getShortTimeFormat(lbt))),
'vehicles': {}
})
vehicles = stats.getVehicles()
for (vehCD, vdata) in vehicles.iteritems():
res['vehicles'][str(vehCD)] = {
'battles': vdata.battlesCount,
'wins': vdata.wins,
'mastery': vdata.markOfMastery,
'xp': vdata.xp,
}
return res
def __prepareVehicleResult(self, dossier, xtdb, xte, earnedXP, freeXP,
xpToElite):
res = {}
if dossier is None:
return res
res = self.__prepareCommonResult(dossier)
res.update({
'vehCD':
int(self.vehCD),
'xtdb':
xtdb,
'xte':
xte,
'earnedXP':
earnedXP,
'freeXP':
freeXP,
'xpToElite':
xpToElite,
'marksOnGun':
int(dossier.getRecordValue(_AB.TOTAL, 'marksOnGun')),
'damageRating':
dossier.getRecordValue(_AB.TOTAL, 'damageRating') / 100.0,
})
return res