def _populate(self):
super(UseAwardSheetWindow, self)._populate()
self.as_setSettingsS({
'title': self.meta.getTitle(),
'submitBtnLabel': self.meta.getSubmitButtonLabel(),
'cancelBtnLabel': self.meta.getCancelButtonLabel()
})
icon = icons.makeImageTag(
RES_ICONS.MAPS_ICONS_LIBRARY_ATTENTIONICONFILLED, 16, 16, -3,
0) if self.meta.isAvailable() else icons.makeImageTag(
RES_ICONS.MAPS_ICONS_LIBRARY_ALERTICON, 16, 16, -4, 0)
text = text_styles.neutral(self.meta.getInfoText(
)) if self.meta.isAvailable() else text_styles.alert(
self.meta.getWarningText())
statusText = text_styles.concatStylesWithSpace(icon, text)
self.as_setDataS({
'neededLabel':
text_styles.highlightText(self.meta.getNeededText()),
'neededValue':
text_styles.highlightText(self.meta.getPawnCost()),
'totalLabel':
text_styles.main(self.meta.getTotalText()),
'totalValue':
text_styles.main(self.meta.getFreeSheets()),
'statusText':
statusText,
'icon':
self.meta.getIcon()
})
def __getTypes(self):
return [{'id': TABS.DEFAULT,
'label': text_styles.highlightText(SETTINGS.COLORSETTINGS_TAB_DEFAULT),
'icon': RES_ICONS.MAPS_ICONS_SETTINGS_COLORSETTINGS_DEFAULT}, {'id': TABS.FILTERS,
'label': text_styles.highlightText(SETTINGS.COLORSETTINGS_TAB_FILTERS),
'icon': RES_ICONS.MAPS_ICONS_SETTINGS_COLORSETTINGS_FILTERS}, {'id': TABS.CUSTOM,
'label': text_styles.highlightText(SETTINGS.COLORSETTINGS_TAB_CUSTOMSETTINGS),
'icon': RES_ICONS.MAPS_ICONS_SETTINGS_COLORSETTINGS_MANUAL}]
def _packMetaProgressVO(self, prestigeAllowed, maxRewardClaimed):
pPrestigeLevel, pMetaLevel, pFamePts = self.epicMetaGameCtrl.getPlayerLevelInfo(
)
famePtsToProgress = self.epicMetaGameCtrl.getPointsProgressForLevel(
pMetaLevel)
rewards = []
buttonLabel = ''
if maxRewardClaimed:
titleText = text_styles.highlightText(
i18n.makeString(
EPIC_BATTLE.INFOVIEW_PRESTIGE_CONGRATULATIONS).upper())
descriptionText = text_styles.main(
i18n.makeString(
EPIC_BATTLE.INFOVIEW_PRESTIGE_ENDGAMEDESCRIPTION))
else:
titleText = text_styles.highlightText(
i18n.makeString(EPIC_BATTLE.INFOVIEW_FAMEPOINTS_TITLE).upper())
if self.__canClaimFinalReward():
descriptionText = text_styles.highTitle(
i18n.makeString(
EPIC_BATTLE.INFOVIEW_PRESTIGE_FINALDESCRIPTION))
buttonLabel = i18n.makeString(
EPIC_BATTLE.INFOVIEW_PRESTIGE_FINALPRESTIGEBUTTONLABEL)
elif prestigeAllowed:
descriptionText = text_styles.highlightText(
i18n.makeString(EPIC_BATTLE.INFOVIEW_PRESTIGE_DESCRIPTION)
% pMetaLevel)
buttonLabel = i18n.makeString(
EPIC_BATTLE.INFOVIEW_PRESTIGE_BUTTONLABEL) % int2roman(
pPrestigeLevel + 2)
else:
descriptionText = text_styles.main(
i18n.makeString(
EPIC_BATTLE.INFOVIEW_FAMEPOINTS_DESCRIPTION))
rewards = self.__getPrestigeAwards(
pPrestigeLevel +
1) if prestigeAllowed else self.__getNextMetaLevelAwards(
pMetaLevel + 1)
return {
'titleHtmlText':
titleText,
'descriptionHtmlText':
descriptionText,
'buttonText':
buttonLabel,
'progressBarData': {
'value': pFamePts,
'maxValue': famePtsToProgress
},
'famePointsText':
self.__getFormatedProgressHtmlText(pFamePts, famePtsToProgress),
'canPrestige':
prestigeAllowed,
'isEndGameState':
maxRewardClaimed,
'awards':
rewards
}
def _getTabData():
return ({
'viewId':
BATTLEROYALE_ALIASES.VEH_MODULES_CONFIGURATOR_CMP,
'label':
backport.text(
R.strings.battle_royale.hangarVehicleInfo.moduleTreeTab()),
'linkage':
'VehModuleConfiguratorCmpUI',
'selected':
True,
'enabled':
True,
'tipText':
text_styles.highlightText(
backport.text(
R.strings.battle_royale.hangarVehicleInfo.moduleTreeTip(),
key=text_styles.neutral(
br_helpers.getHotKeyString(
CommandMapping.CMD_UPGRADE_PANEL_SHOW)))),
'tooltipComplexStr':
None,
'tooltipSpecialId':
TOOLTIPS_CONSTANTS.BATTLE_ROYALE_BATTLE_PROGRESSION
}, {
'viewId':
BATTLEROYALE_ALIASES.VEHICLE_WEAK_ZONES_CMP,
'label':
backport.text(
R.strings.battle_royale.hangarVehicleInfo.weakZonesTab()),
'linkage':
'VehicleWeakZonesCmpUI',
'selected':
False,
'enabled':
True,
'tipText':
text_styles.highlightText(
backport.text(
R.strings.battle_royale.hangarVehicleInfo.weakZonesTip())),
'tooltipComplexStr':
makeTooltip(
header=backport.text(R.strings.battle_royale.hangarVehicleInfo.
tooltips.weakZones.header()),
body=backport.text(R.strings.battle_royale.hangarVehicleInfo.
tooltips.weakZones.body())),
'tooltipSpecialId':
None
})
def _populate(self):
super(HangarVehicleInfo, self)._populate()
self.__battleRoyaleController.onUpdated += self.__onBattleRoyaleEnabledChanged
self.startGlobalListening()
self.as_setDataS({
'btnCloseLabel':
backport.text(
R.strings.battle_royale.hangarVehicleInfo.closeBtn()),
'infoIconSource':
backport.image(R.images.gui.maps.icons.library.info()),
'infoText':
text_styles.highlightText(
backport.text(
R.strings.battle_royale.hangarVehicleInfo.moduleTreeTip(),
key=text_styles.neutral(
br_helpers.getHotKeyString(
CommandMapping.CMD_UPGRADE_PANEL_SHOW)))),
'vehTitle':
text_styles.grandTitle(self.__vehicle.shortUserName),
'vehTypeIcon':
getTypeBigIconPath(self.__vehicle.type),
'tutorialText':
backport.text(
R.strings.battle_royale.hangarVehicleInfo.tutorialText())
})
def _packBlocks(self, *args, **kwargs):
items = super(CrewBookRestrictedTooltipDataBlock, self)._packBlocks()
bookVehicleContext = self.context.buildItem(*args, **kwargs)
vehicle = bookVehicleContext.vehicle
block = []
text = backport.text(
R.strings.tooltips.crewBooks.screen.invalidCrew.title())
block.append(
formatters.packTextBlockData(text=text_styles.highlightText(text)))
vehTypeCD = vehicle.descriptor.type.compactDescr
crew = [(tman.strCD if tman else None) for _, tman in vehicle.crew]
_, validationMssk, _, crewLists = tankmen.validateCrewToLearnCrewBook(
crew, vehTypeCD)
for mask in CREW_BOOK_PROPERTIES_MASKS.ALL:
if mask & validationMssk:
locSuffix = CREW_BOOK_RESTRICTIONS[mask]
names = ''
invalidTmen = crewLists[mask]
for slotID in invalidTmen:
_, tman = vehicle.crew[slotID]
names += tman.fullUserName
if slotID != invalidTmen[-1]:
names += ', '
text = backport.text(
R.strings.tooltips.crewBooks.screen.invalidCrew.dyn(
locSuffix)(),
name=names)
block.append(
formatters.packTextBlockData(text=u'\u2022 ' +
text_styles.main(text)))
items.append(formatters.packBuildUpBlockData(block))
return items
def _populate(self):
super(BoosterBuyWindow, self)._populate()
if self.__item.isCrewBooster():
isPerkReplace = not self.__item.isAffectedSkillLearnt(g_currentVehicle.item)
desc = self.__item.getCrewBoosterAction(isPerkReplace)
overlayType = SLOT_HIGHLIGHT_TYPES.BATTLE_BOOSTER_CREW_REPLACE if isPerkReplace else SLOT_HIGHLIGHT_TYPES.BATTLE_BOOSTER
else:
desc = self.__item.getOptDeviceBoosterDescription(g_currentVehicle.item)
overlayType = SLOT_HIGHLIGHT_TYPES.BATTLE_BOOSTER
self.as_setInitDataS({'windowTitle': MENU.BOOSTERBUYWINDOW_WINDOWTITLE,
'nameText': text_styles.highTitle(self.__item.userName),
'descText': text_styles.main(desc),
'countLabelText': text_styles.main(MENU.BOOSTERBUYWINDOW_BUYCOUNT),
'buyLabelText': text_styles.main(MENU.BOOSTERBUYWINDOW_TOTALPRICE),
'totalPriceLabelText': text_styles.highlightText(MENU.BOOSTERBUYWINDOW_TOTALLABEL),
'inHangarLabelText': text_styles.main(MENU.BOOSTERBUYWINDOW_INHANGARCOUNT),
'boosterSlot': self.__getItemSlotData(self.__item, overlayType),
'rearmCheckboxLabel': MENU.BOOSTERBUYWINDOW_REARMCHECKBOXLABEL,
'rearmCheckboxTooltip': '',
'submitBtnLabel': MENU.BOOSTERBUYWINDOW_BUYBUTTONLABEL,
'cancelBtnLabel': MENU.BOOSTERBUYWINDOW_CANCELBUTTONLABEL})
stats = self.itemsCache.items.stats
itemPrice = self.__getItemPrice()
currency = itemPrice.getCurrency(byWeight=True)
vehicle = g_currentVehicle.item
self.as_updateDataS({'actionPriceData': packItemActionTooltipData(self.__item, isBuying=True),
'itemPrice': itemPrice.price.getSignValue(currency),
'itemCount': self.__item.inventoryCount,
'currency': currency,
'currencyCount': stats.money.getSignValue(currency),
'rearmCheckboxValue': vehicle.isAutoBattleBoosterEquip() if vehicle is not None else False})
return
def __getCurrentCycleVehicleRankRow(self):
isMaxRank = self.rankedController.getCurrentRank(
g_currentVehicle.item) == self.rankedController.getMaxRank()
if self.rankedController.isAccountMastered() and not isMaxRank:
vehicleRank = self.rankedController.getCurrentRank(
g_currentVehicle.item)
else:
vehicleRank = first(
self.rankedController.getVehicleRanksChain(
g_currentVehicle.item))
rankIcon = {
'imageSrc': vehicleRank.getIcon('small'),
'isEnabled': vehicleRank.isAcquired(),
'rankID': str(vehicleRank.getID())
}
cycleColumnComment = text_styles.highlightText(
_ms(RANKED_BATTLES.
RANKEDBATTLESCYCLESVIEW_CURRENTCYCLE_VEHICLERANKPOINTS))
return {
'awardReceived': '',
'points': str(vehicleRank.getPoints()),
'rankIcon': rankIcon,
'rankDescr': '',
'rankAwards': vehicleRank.getAwardsVOs(),
'cycleAwards': [],
'masterDescr': cycleColumnComment
}
def _populate(self):
super(RankedBattlesStageCompleteView, self)._populate()
if self.__season is not None:
cycle = self.__season.getAllCycles()[self._quest.getCycleID()]
rank = self.rankedController.getRank(self._quest.getRank())
try:
proxy_currency_count = first(self._quest.getBonuses(Currency.CRYSTAL)).getValue()
except AttributeError:
proxy_currency_count = 0
self.as_setDataS({'rank': {'imageSrc': rank.getIcon('small'),
'smallImageSrc': None,
'isEnabled': True,
'isMaster': False,
'rankID': str(rank.getID()),
'rankCount': '-1'},
'boxImage': rank.getBoxIcon(),
'bestRankTitle': RANKED_BATTLES.SEASONCOMPLETE_BESTRANK,
'proxyCurrency': text_styles.highTitle(i18n.makeString(RANKED_BATTLES.SEASONCOMPLETE_PROXYCURRENCY, value=text_styles.superPromoTitle(proxy_currency_count))),
'scoresTitle': text_styles.highlightText(i18n.makeString(RANKED_BATTLES.SEASONCOMPLETE_SCORESEARNED, scores=text_styles.bonusLocalText(cycle.points))),
'congratulationTitle': i18n.makeString(RANKED_BATTLES.SEASONCOMPLETE_STAGECOMPLETE, stage=cycle.ordinalNumber),
'nextButtonLabel': RANKED_BATTLES.AWARDS_YES,
'bgSource': RES_ICONS.MAPS_ICONS_RANKEDBATTLES_BG_RANK_BLUR})
self.as_setRewardsDataS({'ribbonType': 'ribbon2',
'rendererLinkage': COMPONENTS_ALIASES.RIBBON_AWARD_ANIM_RENDERER,
'gap': 20,
'rendererWidth': 80,
'rendererHeight': 80,
'awards': self._packAwards()})
return
def __constructPrimeTimes(self, selectedTime):
items = []
serversPeriodsMapping = self.rankedController.getPrimeTimesForDay(
selectedTime, groupIdentical=True)
frmt = BigWorld.wg_getShortTimeFormat
for serverName in sorted(serversPeriodsMapping.keys()):
periodsStr = []
dayPeriods = serversPeriodsMapping[serverName]
if dayPeriods:
for periodStart, periodEnd in dayPeriods:
periodsStr.append(
i18n.makeString(RANKED_BATTLES.CALENDARDAY_TIME,
start=frmt(periodStart),
end=frmt(periodEnd)))
else:
periodsStr = i18n.makeString(COMMON.COMMON_DASH)
if dayPeriods:
items.append({
'serverNameText':
text_styles.highlightText(serverName),
'primeTimeText':
'\n'.join(periodsStr)
})
return items
def __updateTimer(self):
timeTill = self.__rankedController.getTimer()
if self.__state == RANKEDBATTLES_CONSTS.INTRO_STATE_BEFORE_SEASON:
self.as_setBeforeSeasonBlockDataS({
'title':
text_styles.highlightText(
backport.text(R.strings.ranked_battles.introPage.alert.
beforeSeason())),
'time':
text_styles.highlightText(
backport.getTillTimeStringByRClass(
timeTill,
R.strings.ranked_battles.introPage.timeLeft)),
'iconSrc':
backport.image(R.images.gui.maps.icons.library.ClockIcon_1())
})
def _packCombatReservesVO(self, availablePoints):
skillLvls = self.epicMetaGameCtrl.getSkillLevels()
allSkills = self.epicMetaGameCtrl.getAllSkillsInformation()
unlockedSkills = 0
for skillID in allSkills.iterkeys():
if skillLvls.get(skillID, 0) != 0:
unlockedSkills += 1
pointsStyleTemplate = _ACTIVE_SKILL_POINTS_HTML_TEMPLATE if availablePoints > 0 else _INACTIVE_SKILL_POINTS_HTML_TEMPLATE
return {
'titleHtmlText':
text_styles.highlightText(
i18n.makeString(
EPIC_BATTLE.INFOVIEW_COMBATRESERVES_TITLE).upper()),
'descriptionHtmlText':
text_styles.main(
i18n.makeString(
EPIC_BATTLE.INFOVIEW_COMBATRESERVES_DESCRIPTION)),
'progressHtmlText':
self.__getFormatedProgressHtmlText(unlockedSkills, len(allSkills)),
'buttonText':
EPIC_BATTLE.METAABILITYSCREEN_MANAGE_ABILITIES,
'unspentPoints':
availablePoints,
'unspentHtmlPointsText':
pointsStyleTemplate % availablePoints
}
def _populate(self):
super(GammaWizardView, self)._populate()
self._currentGammaValue = self._changeGammaValue = self._gammaWizard.gamma
self.as_initDataS({
'title':
text_styles.superPromoTitle(SETTINGS.GAMMAWIZARD_TITLE),
'header':
text_styles.highlightText(SETTINGS.GAMMAWIZARD_HEADER),
'description':
text_styles.main(SETTINGS.GAMMAWIZARD_DESCRIPTION),
'applyLabel':
SETTINGS.GAMMAWIZARD_APPLY,
'cancelLabel':
SETTINGS.GAMMAWIZARD_CANCEL,
'defaultLabel':
SETTINGS.GAMMAWIZARD_DEFAULT,
'currentValue':
self._currentGammaValue,
'gammaTooltip':
makeTooltip(SETTINGS.GAMMAWIZARD_TOOLTIP_HEADER,
SETTINGS.GAMMAWIZARD_TOOLTIP_BODY),
'minValue':
self.MIN_VALUE,
'maxValue':
self.MAX_VALUE,
'defaultValue':
self.DEFAULT_VALUE
})
def _getBonusBattlesDiffLabel(bonusBattlesDiff):
return text_styles.concatStylesWithSpace(
text_styles.highlightText(
backport.text(R.strings.ranked_battles.awards.bonusBattles.label(),
count=bonusBattlesDiff)),
icons.makeImageTag(backport.image(
R.images.gui.maps.icons.library.attentionIcon1()),
vSpace=-2))
def __getQuestImproveTitleData(quest):
return {
'nextQuestText':
text_styles.promoTitle(quest.getUserName()),
'nextQuestTitle':
text_styles.highlightText(
_PM.QUESTAWARDSCREEN_NEXTQUEST_TITLE_QUESTIMPROVE)
}
def makeStatusLabel(self):
"""
Returns status for RankedBattlesBattleResult
:return:
"""
isWin = self.__reusable.getPersonalTeam(
) == self.__reusable.common.winnerTeam
rankState = self.getState()
if rankState in self.__RESULTS_WITH_SHIELDS:
rankInfo = self.__reusable.personal.getRankInfo()
shieldState = rankInfo.shieldState
if shieldState is not None:
txt = '{}{}'
if shieldState == RANKEDBATTLES_ALIASES.SHIELD_LOSE:
return txt.format(
text_styles.highlightText(
RANKED_BATTLES.BATTLERESULT_STATUS_SHIELDLOSE),
text_styles.main(
RANKED_BATTLES.BATTLERESULT_STATUS_SHIELDWARNING))
if shieldState == RANKEDBATTLES_ALIASES.SHIELD_LOSE_STEP:
hpStr = text_styles.highTitle(rankInfo.shieldHP)
shieldCount = i18n.makeString(
RANKED_BATTLES.BATTLERESULT_STATUS_SHIELDCOUNT,
count=hpStr)
return txt.format(
text_styles.highlightText(
RANKED_BATTLES.BATTLERESULT_STATUS_SHIELDLOSESTEP),
text_styles.main(shieldCount))
if shieldState in RANKEDBATTLES_ALIASES.SHIELD_RENEW_STATES:
if rankState == RANK_CHANGE_STATES.STEP_EARNED:
return txt.format(
text_styles.highlightText(
RANKED_BATTLES.BATTLERESULT_STATUS_STAGEEARNED
),
text_styles.main(RANKED_BATTLES.
BATTLERESULT_STATUS_SHIELDRENEW))
if rankState == RANK_CHANGE_STATES.STEPS_EARNED:
return txt.format(
text_styles.highlightText(
RANKED_BATTLES.BATTLERESULT_STATUS_STAGESEARNED
),
text_styles.main(RANKED_BATTLES.
BATTLERESULT_STATUS_SHIELDRENEW))
return text_styles.highlightText(self.__STATUS_LABEL_MAP[rankState,
isWin])
def __packNextQuestTitleSection(self, isFinal):
dataVO = {}
if self._addReward:
if self._nextQuest:
nextQuestTitle = _PM.QUESTAWARDSCREEN_NEXTQUEST_TITLE_QUESTACCEPT
nextQuestText = self._nextQuest.getUserName()
dataVO.update({
'nextQuestText':
text_styles.promoTitle(nextQuestText),
'nextQuestTitle':
text_styles.highlightText(nextQuestTitle)
})
else:
chainName = getTypeShortUserName(
self._quest.getQuestClassifier().classificationAttr)
nextQuestTitle = _ms(_PM.STATUSPANEL_STATUS_ALLDONE,
vehicleClass=chainName)
dataVO.update({
'nextQuestTitle':
text_styles.highlightText(nextQuestTitle)
})
elif self._isAwardListUsed:
if isFinal:
dataVO.update({
'nextQuestTitle':
text_styles.highlightText(
QUESTS.PERSONALMISSION_STATUS_LASTDONEWITHPAWN)
})
elif self._quest.isInProgress():
dataVO.update({
'nextQuestText':
text_styles.promoTitle(self._quest.getUserName()),
'nextQuestTitle':
text_styles.highlightText(
_PM.QUESTAWARDSCREEN_NEXTQUEST_TITLE_QUESTIMPROVE)
})
else:
dataVO.update({
'nextQuestText':
text_styles.promoTitle(self._quest.getUserName()),
'nextQuestTitle':
text_styles.highlightText(
_PM.QUESTAWARDSCREEN_NEXTQUEST_TITLE_QUESTIMPROVE)
})
return dataVO
def __getMainAwards(self):
return {
'title':
text_styles.highlightText(
PERSONAL_MISSIONS.AWARDSVIEW_MAINAWARDS_TITLE),
'awards':
self.__mainAwardsFormatter.getFormattedBonuses(
self.getOperation(), AWARDS_SIZES.BIG)
}
def __getAdditionalAwards(self):
return {
'title':
text_styles.highlightText(
PERSONAL_MISSIONS.
PERSONALMISSIONAWARDVIEW_BOTTOMTABS_AWARDS_ADDITIONALAWARDS),
'awards':
self.__addAwardsFormatter.getFormattedBonuses(
self.getOperation(), AWARDS_SIZES.BIG)
}
def __setBottomPanelBillData(self, *_):
purchaseItems = self.__ctx.getPurchaseItems()
cartInfo = getTotalPurchaseInfo(purchaseItems)
totalPriceVO = getItemPricesVO(cartInfo.totalPrice)
if cartInfo.totalPrice != ITEM_PRICE_EMPTY:
label = _ms(VEHICLE_CUSTOMIZATION.COMMIT_BUY)
else:
label = _ms(VEHICLE_CUSTOMIZATION.COMMIT_APPLY)
tooltip = VEHICLE_CUSTOMIZATION.CUSTOMIZATION_BUYDISABLED_BODY
fromStorageCount = 0
toByeCount = 0
for item in purchaseItems:
if item.isFromInventory:
fromStorageCount += 1
if not item.isDismantling:
toByeCount += 1
if fromStorageCount > 0 or toByeCount > 0:
self.__showBill()
else:
self.__hideBill()
tooltip = VEHICLE_CUSTOMIZATION.CUSTOMIZATION_NOTSELECTEDITEMS
fromStorageCount = text_styles.stats('({})'.format(fromStorageCount))
toByeCount = text_styles.stats('({})'.format(toByeCount))
outfitsModified = self.__ctx.isOutfitsModified()
self.as_setBottomPanelPriceStateS({
'buyBtnEnabled':
outfitsModified,
'buyBtnLabel':
label,
'buyBtnTooltip':
tooltip,
'isHistoric':
self.__ctx.currentOutfit.isHistorical(),
'billVO': {
'title':
text_styles.highlightText(
_ms(VEHICLE_CUSTOMIZATION.BUYPOPOVER_RESULT)),
'priceLbl':
text_styles.main('{} {}'.format(
_ms(VEHICLE_CUSTOMIZATION.BUYPOPOVER_PRICE), toByeCount)),
'fromStorageLbl':
text_styles.main('{} {}'.format(
_ms(VEHICLE_CUSTOMIZATION.BUYPOPOVER_FROMSTORAGE),
fromStorageCount)),
'isEnoughStatuses':
getMoneyVO(
Money(outfitsModified, outfitsModified, outfitsModified)),
'pricePanel':
totalPriceVO[0]
}
})
def __setBottomPanelBillData(self, *_):
purchaseItems = self.__ctx.getPurchaseItems()
cartInfo = getTotalPurchaseInfo(purchaseItems)
totalPriceVO = getItemPricesVO(cartInfo.totalPrice)
label = _ms(CUSTOMIZATION.COMMIT_APPLY)
tooltip = CUSTOMIZATION.CUSTOMIZATION_NOTSELECTEDITEMS
fromStorageCount = 0
toBuyCount = 0
for item in purchaseItems:
if item.isFromInventory:
fromStorageCount += 1
if not item.isDismantling:
toBuyCount += 1
if cartInfo.totalPrice != ITEM_PRICE_EMPTY:
label = _ms(CUSTOMIZATION.COMMIT_BUY)
outfitsModified = self.__ctx.isOutfitsModified()
fromStorageCount = text_styles.stats('({})'.format(fromStorageCount))
toBuyCount = text_styles.stats('({})'.format(toBuyCount))
self.as_setBottomPanelPriceStateS({
'buyBtnEnabled':
outfitsModified,
'buyBtnLabel':
label,
'buyBtnTooltip':
tooltip,
'isHistoric':
self.__ctx.currentOutfit.isHistorical(),
'billVO': {
'title':
text_styles.highlightText(_ms(
CUSTOMIZATION.BUYPOPOVER_RESULT)),
'priceLbl':
text_styles.main('{} {}'.format(
_ms(CUSTOMIZATION.BUYPOPOVER_PRICE), toBuyCount)),
'fromStorageLbl':
text_styles.main('{} {}'.format(
_ms(CUSTOMIZATION.BUYPOPOVER_FROMSTORAGE),
fromStorageCount)),
'isEnoughStatuses':
getMoneyVO(Money(True, True, True)),
'pricePanel':
totalPriceVO[0]
}
})
self.as_setItemsPopoverBtnEnabledS(
any(i[1].isFilled() for i in self.__ctx.currentOutfit.itemsFull()))
if outfitsModified:
BigWorld.callback(0, self.__showBill)
else:
self.__hideBill()
def packTotalPropData(sessionStats, propId):
value = _ECONOMIC_DATA[propId]['value'](sessionStats)
detailsData = _ECONOMIC_DATA[propId]['detail'](sessionStats)
params = []
for paramName in detailsData._fields:
param = getattr(detailsData, paramName)
if param:
params.append({'label': text_styles.standard(backport.text(getattr(R.strings.session_stats.propertyInfo.total.label, paramName)())),
'value': _PROP_ID_TO_POSITIVE_VALUE_STYLE_MAP[propId](toIntegral(param)) if param > 0 else text_styles.error(toIntegral(param))})
return {'title': text_styles.promoSubTitle(backport.text(getattr(R.strings.session_stats.propertyInfo.total.label, propId)())),
'description': text_styles.main(backport.text(R.strings.session_stats.propertyInfo.total.descr())),
'params': params,
'icon': getSessionStatsPropImage(propId),
'total': {'label': text_styles.mainBig(backport.text(R.strings.session_stats.propertyInfo.total.total())),
'value': text_styles.highlightText(value)}}
def _populate(self):
super(GammaWizardView, self)._populate()
if self.app is not None:
self._savedBackgroundAlpha = self.app.getBackgroundAlpha()
self.app.setBackgroundAlpha(0)
self.addListener(GameEvent.ON_BACKGROUND_ALPHA_CHANGE, self.__onExternalBackgroundAlphaChange, EVENT_BUS_SCOPE.GLOBAL)
self._currentGammaValue = self._changeGammaValue = self._gammaWizard.gamma
self.as_initDataS({'title': text_styles.superPromoTitle(SETTINGS.GAMMAWIZARD_TITLE),
'header': text_styles.highlightText(SETTINGS.GAMMAWIZARD_HEADER),
'description': text_styles.main(SETTINGS.GAMMAWIZARD_DESCRIPTION),
'applyLabel': SETTINGS.GAMMAWIZARD_APPLY,
'cancelLabel': SETTINGS.GAMMAWIZARD_CANCEL,
'defaultLabel': SETTINGS.GAMMAWIZARD_DEFAULT,
'currentValue': self._currentGammaValue,
'gammaTooltip': makeTooltip(SETTINGS.GAMMAWIZARD_TOOLTIP_HEADER, SETTINGS.GAMMAWIZARD_TOOLTIP_BODY),
'minValue': self.MIN_VALUE,
'maxValue': self.MAX_VALUE,
'defaultValue': self.DEFAULT_VALUE})
return
def __getCommonBlocks(self):
settings = self.__currentSettings
inputs = []
for key in SESSION_STATS.getCommonBlock():
inputs.append({
'id': key,
'label': _COMMON_BLOCK[key]['label'],
'tooltip': _COMMON_BLOCK[key]['tooltip'],
'selected': bool(settings[key])
})
return {
'title':
text_styles.highlightText(
backport.text(
R.strings.session_stats.settings.commonSettings.header())),
'inputs':
inputs
}
def _populate(self):
super(RankedBattlesAwardsView, self)._populate()
if not self.__isDebug:
self.rankedController.setAwardWindowShown(self.__rankID)
rank = self.rankedController.getRank(self.__rankID,
vehicle=self.__vehicle)
if rank.getType() == RANK_TYPES.VEHICLE:
points = self.rankedController.getLadderPoints()
scoreTitle = RANKED_BATTLES.AWARDS_LADDERPOINTSTOTAL
rankID = 'max'
rankTitle = RANKED_BATTLES.AWARDS_GOTLADDERPOINT
else:
points = rank.getPoints()
scoreTitle = RANKED_BATTLES.AWARDS_NEXTRANKTITLE
rankID = self.__rankID
rankTitle = i18n.makeString(RANKED_BATTLES.AWARDS_GOTRANK,
rank=rankID)
rankVOs = {
'currentRank': {
'rankTitle':
rankTitle,
'rank':
buildRankVO(
rank=rank,
imageSize=RANKEDBATTLES_ALIASES.WIDGET_HUGE,
isEnabled=True,
shieldStatus=self.rankedController.getShieldStatus(rank)),
'congratulationTitle':
RANKED_BATTLES.AWARDS_CONGRATULATION,
'scoresTitle':
text_styles.highlightText(
i18n.makeString(scoreTitle,
scores=text_styles.promoSubTitle(points))),
'nextButtonLabel':
RANKED_BATTLES.AWARDS_YES,
'awards':
self.__getAllReceivedAwards()
}
}
self.as_setDataS(rankVOs)
SoundGroups.g_instance.playSound2D(
SOUND.getRankAwardAnimationEvent(rankID))
def requestMissionData(self, index):
isObtained = not self._bootcamp.needAwarding()
vehicleSelector = self.getComponent(QUESTS_ALIASES.MISSIONS_VEHICLE_SELECTOR_ALIAS)
if vehicleSelector is not None:
criteria = REQ_CRITERIA.VEHICLE.LEVELS([self._TANK_LEVEL]) | REQ_CRITERIA.IN_OWNERSHIP
vehicleSelector.setCriteria(criteria, [])
bTypesData = formatters.packMissionBonusTypeElements([ARENA_BONUS_TYPE.REGULAR])
bTypes = self._COMMA.join([ iconData.iconLabel for iconData in bTypesData ])
tooltipBody = makeString(QUESTS.MISSIONDETAILS_CONDITIONS_BATTLEBONUSTYPE_BODY, battleBonusTypes=bTypes)
missionData = {'title': text_styles.promoSubTitle(backport.text(R.strings.bootcamp.quest.title())),
'battleConditions': [{'rendererLinkage': MISSIONS_ALIASES.BATTLE_CONDITION,
'linkageBig': MISSIONS_ALIASES.ANG_GROUP_BIG_LINKAGE,
'isDetailed': True,
'data': [{'title': text_styles.promoSubTitle(backport.text(R.strings.bootcamp.quest.name())),
'description': text_styles.highlightText(backport.text(R.strings.bootcamp.quest.condition())),
'state': MISSIONS_ALIASES.NONE,
'icon': backport.image(R.images.gui.maps.icons.quests.battleCondition.c_128.icon_battle_condition_battles_128x128()),
'maxDescLines': self._LINES_IN_DESCR}],
'linkage': MISSIONS_ALIASES.ANG_GROUP_DETAILED_LINKAGE}],
'statusLabel': text_styles.concatStylesWithSpace(icons.inProgress(), text_styles.standard(backport.text(R.strings.quests.missionDetails.missionsComplete(), count=text_styles.stats(self._MISSIONS_DONE), total=text_styles.standard(self._MISSIONS_COUNT)))),
'awards': [{'label': text_styles.gold(backport.text(R.strings.menu.premium.packet.days3())),
'padding': self._AWARD_LABEL_PADDING,
'imgSource': backport.image(R.images.gui.maps.icons.quests.bonuses.big.premium_3()),
'align': LABEL_ALIGN.RIGHT,
'tooltip': TOOLTIPS.AWARDITEM_PREMIUM,
'obtainedImage': backport.image(R.images.gui.maps.icons.library.awardObtained()),
'isObtained': isObtained,
'obtainedImageOffset': self._OBTAINED_IMAGE_OFFSET}, {'label': text_styles.gold(self._GOLD_LABEL),
'padding': self._AWARD_LABEL_PADDING,
'imgSource': backport.image(R.images.gui.maps.icons.quests.bonuses.big.gold()),
'align': LABEL_ALIGN.RIGHT,
'tooltip': TOOLTIPS.AWARDITEM_GOLD,
'obtainedImage': backport.image(R.images.gui.maps.icons.library.awardObtained()),
'isObtained': isObtained,
'obtainedImageOffset': self._OBTAINED_IMAGE_OFFSET}],
'background': 'default',
'prebattleConditions': [formatters.packMissionPrebattleCondition(text_styles.main(bTypesData[0].iconLabel), ''.join([ iconData.icon for iconData in bTypesData ]), makeTooltip(QUESTS.MISSIONDETAILS_CONDITIONS_BATTLEBONUSTYPE, tooltipBody))],
'uiDecoration': backport.image(R.images.gui.maps.icons.quests.decorations.default_750x264()),
'statusTooltipData': {}}
self.as_setMissionDataS(missionData)
return
def getInfo(self):
top = self._top
reward = self._event.getRewardsByRank().getRewardByRank(self.__leaderboardId)
category = reward.getRewardCategoryNumber(top.getMyPosition())
return {'eventID': top.getEventID(),
'title': text_styles.highlightText(self.__getTitle()),
'isAvailable': True,
'ribbonTooltip': self.__getRibbonTooltip(),
'descriptionTooltip': self.__getDescriptionTooltip(),
'amountTooltip': self.__getAmountTooltip(),
'awards': None,
'ribbon': self.__getRibbon(),
'status': None,
'background': 'marathon' if category else 'default',
'amount': str(top.getMyValue()),
'type': self.__getRaitingType(),
'description1': self.__getMyPosititon(),
'description2': self.__getStatusValue(),
'uiDecoration': self.__getDecoration(),
'uiPicture': self.__getPicture(),
'cardID': str(top.getLeaderboardID())}
def __getEconomicsBlock(self):
settings = self.__currentSettings
inputs = []
for key in SESSION_STATS.getEconomicBlockView():
inputs.append({
'id': str(key),
'label': _ECONOMIC_BLOCK_VIEW[key]['label']
})
return {
'title':
text_styles.highlightText(
backport.text(
R.strings.session_stats.settings.economicBlock.header())),
'selectedRadioIndex':
settings[SESSION_STATS.ECONOMIC_BLOCK_VIEW],
'id':
SESSION_STATS.ECONOMIC_BLOCK_VIEW,
'inputs':
inputs
}
def getInfo(self):
return {
'eventID': self._top.getEventID(),
'title': text_styles.highlightText(self.__getTitle()),
'isAvailable': True,
'ribbonTooltip': self.__getRibbonTooltip(),
'descriptionTooltip': self.__getDescriptionTooltip(),
'amountTooltip': self.__getAmountTooltip(),
'awards': None,
'ribbon': self.__getRibbon(),
'status': None,
'background':
'marathon' if self._top.getMyPosition() else 'default',
'amount': str(self._top.getMyValue()),
'type': self.__getRaitingType(),
'description1': self.__getMyPosititon(),
'description2': self.__getStatusValue(),
'uiDecoration': self.__getDecoration(),
'uiPicture': self.__getPicture(),
'cardID': str(self._top.getLeaderboardID())
}
def __getBattlesBlock(self):
settings = self.__currentSettings
inputs = []
for key in SESSION_STATS.getEfficiencyBlock():
if key in SESSION_STATS.getImmutableEfficiencyBlockParameters():
continue
inputs.append({
'id': key,
'label': _EFFICIENCY_BLOCK[key]['label'],
'tooltip': _EFFICIENCY_BLOCK[key]['tooltip'],
'selected': bool(settings[key])
})
return {
'title':
text_styles.highlightText(
backport.text(R.strings.session_stats.settings.efficiencyBlock.
header())),
'inputs':
inputs
}
