def __getRules(self):
topWinNum = self.rankedController.getRanksChanges(
isLoser=False).count(1)
topLoserNum = self.rankedController.getRanksChanges(
isLoser=True).count(1)
teamStr = text_styles.bonusAppliedText(
RANKED_BATTLES.WELCOMESCREEN_POSITIVE_TEAM)
descr = text_styles.hightlight(
RANKED_BATTLES.WELCOMESCREEN_POSITIVE_BODY)
rulePositive = {
'image': RES_ICONS.getRankedPostBattleTopIcon(topWinNum),
'description': descr.format(team=teamStr, topNumber=topWinNum)
}
if topLoserNum:
teamStr = text_styles.error(
RANKED_BATTLES.WELCOMESCREEN_NEGATIVE_TEAM)
descr = text_styles.hightlight(
RANKED_BATTLES.WELCOMESCREEN_NEGATIVE_BODY)
ruleNegative = {
'image': RES_ICONS.getRankedPostBattleLoseIcon(topLoserNum),
'description': descr.format(team=teamStr,
topNumber=topLoserNum)
}
else:
ruleNegative = None
return (rulePositive, ruleNegative)
def __getData(self):
stateFlags = self.__getShowStateFlags()
isCompleted = stateFlags['isRankedWelcomeViewStarted']
stateFlags['isRankedWelcomeViewStarted'] = True
self.__setShowStateFlags(stateFlags)
rulePositive, ruleNegative = self.__getRules()
self.rankedController.getRanksChain()
ranks = [ rank.getIcon('big') for rank in self.rankedController.getRanksChain() if rank.getID() > 0 ]
return {'header': text_styles.superPromoTitle(RANKED_BATTLES.WELCOMESCREEN_HEADER),
'rules': [{'image': RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKEDBATTESVIEW_ICN_TANKS,
'description': text_styles.hightlight(RANKED_BATTLES.WELCOMESCREEN_LEFTRULE),
'tooltip': makeTooltip(RANKED_BATTLES.WELCOMESCREEN_LEFTRULETOOLTIP_HEADER, RANKED_BATTLES.WELCOMESCREEN_LEFTRULETOOLTIP_BODY)}, {'image': RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKEDBATTESVIEW_ICN_CREW,
'description': text_styles.hightlight(RANKED_BATTLES.WELCOMESCREEN_CENTERRULE),
'tooltip': makeTooltip(RANKED_BATTLES.WELCOMESCREEN_CENTERRULETOOLTIP_HEADER, RANKED_BATTLES.WELCOMESCREEN_CENTERRULETOOLTIP_BODY)}, {'image': RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKEDBATTESVIEW_AWARD,
'description': text_styles.hightlight(RANKED_BATTLES.WELCOMESCREEN_RIGHTRULE),
'tooltip': makeTooltip(RANKED_BATTLES.WELCOMESCREEN_RIGHTRULETOOLTIP_HEADER, RANKED_BATTLES.WELCOMESCREEN_RIGHTRULETOOLTIP_BODY)}],
'ranks': ranks,
'rulePositive': rulePositive,
'ruleNegative': ruleNegative,
'rankDescription': text_styles.superPromoTitle(RANKED_BATTLES.WELCOMESCREEN_RANKDESCR),
'ranksDescription': text_styles.promoSubTitle(RANKED_BATTLES.WELCOMESCREEN_RANKSDESCR),
'equalityText': RANKED_BATTLES.WELCOMESCREEN_EQUALITYTEXT,
'rulesDelimeterText': text_styles.promoSubTitle(RANKED_BATTLES.WELCOMESCREEN_RULESDELIMETER),
'btnLbl': RANKED_BATTLES.WELCOMESCREEN_BTN,
'btnTooltip': makeTooltip(RANKED_BATTLES.RANKEDBATTLEVIEW_NOTRANKEDBLOCK_OKTOOLTIP_HEADER, RANKED_BATTLES.RANKEDBATTLEVIEW_NOTRANKEDBLOCK_OKTOOLTIP_BODY),
'closeLbl': RANKED_BATTLES.WELCOMESCREEN_CLOSEBTN,
'closeBtnTooltip': makeTooltip(RANKED_BATTLES.WELCOMESCREEN_CLOSEBTNTOOLTIP_HEADER, RANKED_BATTLES.WELCOMESCREEN_CLOSEBTNTOOLTIP_BODY),
'bgImage': RES_ICONS.MAPS_ICONS_RANKEDBATTLES_BG_RANK_BLUR,
'isComplete': bool(isCompleted)}
def _packNotRecievedBlock(self, *args, **kwargs):
block = []
totalPlayers = self.rankedController.getRanksTops(isLoser=False)
winnersBattlesNum = totalPlayers - self.rankedController.getRanksTops(
isLoser=False, notRecieved=True)
losersBattlesNum = self.rankedController.getRanksTops(isLoser=True,
notRecieved=True)
block.append(
formatters.packTextBlockData(
text_styles.highTitle(
RANKED_BATTLES.TOOLTIP_STEP_NOTCHARGED_HEADER),
padding=formatters.packPadding(bottom=7)))
if losersBattlesNum:
loseIcon = RES_ICONS.getRankedTooltipLoseIcon(losersBattlesNum)
block.append(
formatters.packImageTextBlockData(text_styles.standard(
_ms(RANKED_BATTLES.TOOLTIP_STEP_NOTCHARGEDLOSE_DESCRIPTION,
battlesNum=losersBattlesNum)),
img=loseIcon,
txtPadding=formatters.
packPadding(left=17)))
if winnersBattlesNum and losersBattlesNum:
block.append(
formatters.packTextBlockData(
text_styles.hightlight(RANKED_BATTLES.TOOLTIP_STEP_OR),
padding=formatters.packPadding(left=70)))
if winnersBattlesNum:
block.append(
formatters.packTextBlockData(
text_styles.standard(
_ms(RANKED_BATTLES.TOOLTIP_STEP_NOTCHARGED_DESCRIPTION,
battlesNum=winnersBattlesNum)),
padding=formatters.packPadding(left=70)))
return formatters.packBuildUpBlockData(block, 0)
def getRankedAwardVOs(self,
iconSize='small',
withCounts=False,
withKey=False):
result = []
for item, data in zip(self.getCustomizations(), self.getList()):
itemTypeName = item.get('custType')
itemID = item.get('id')
itemTypeID = GUI_ITEM_TYPE_INDICES.get(itemTypeName)
c11nItem = self.c11n.getItemByID(itemTypeID, itemID)
count = item.get('value', 1)
itemData = {
'imgSource':
RES_ICONS.getBonusIcon(iconSize, c11nItem.itemTypeName),
'label':
text_styles.hightlight('x{}'.format(count)),
'align':
TEXT_ALIGN.RIGHT
}
itemData.update(self.__itemTooltip(data, isReceived=False))
if withKey:
itemData['itemKey'] = 'customization_{}'.format(
item.get('custType'))
if withCounts:
itemData['count'] = count
result.append(itemData)
return result
def _getFirstRankReachiveStateData(self,
currentRank,
nextRank,
newStepsState=None,
changeAcquired=False):
state = RANKEDBATTLES_ALIASES.FIRST_RANK_REACHIVE_STATE
steps = self._buildProgress(currentRank)
infoText = ''
if not self._isHuge():
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_INITTEXT,
battles=str(len(steps))))
nextInfoText = ''
rankRightVO = self._buildRankVO(currentRank, True)
newRankVO = self._buildRankVO(nextRank)
newSteps = self._buildProgress(nextRank,
newStepsState=newStepsState,
changeAcquired=changeAcquired)
return self._buildVO(
state,
infoText=infoText,
rankRightVO=rankRightVO,
newRankVO=newRankVO,
steps=steps,
newSteps=newSteps,
nextInfoText=nextInfoText,
finalState=self._buildFinalState(
state,
rankLeftVO=self._buildRankVO(currentRank, True),
rankRightVO=self._buildRankVO(nextRank),
steps=self._buildProgress(nextRank,
newStepsState=newStepsState,
changeAcquired=changeAcquired)))
def __formatBonusVO(bonusesDict):
result = []
for bonusVO in bonusesDict.values():
bonusVO['label'] = text_styles.hightlight('x{}'.format(
bonusVO.pop('count')))
bonusVO['align'] = TEXT_ALIGN.RIGHT
result.append(bonusVO)
return result
def _getFirstRankReceiveStateData(self, currentRank):
state = RANKEDBATTLES_ALIASES.FIRST_RANK_RECEIVE_STATE
steps = self._buildProgress(currentRank)
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_INITTEXT,
battles=str(len(steps))))
nextInfoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_NEWRANKCONGRAT))
rankLeftVO = self._buildRankVO(currentRank, True)
return self._buildVO(state,
infoText=infoText,
rankLeftVO=rankLeftVO,
steps=steps,
nextInfoText=nextInfoText,
finalState=self._buildFinalState(
state,
rankLeftVO=self._buildRankVO(
currentRank, True),
steps=self._buildProgress(currentRank)))
def __getCommonAwardsVOs(self,
item,
count,
iconSize='small',
align=TEXT_ALIGN.RIGHT,
withCounts=False):
itemData = {
'imgSource': RES_ICONS.getBonusIcon(iconSize, item.boosterGuiType),
'label': text_styles.hightlight('x{}'.format(count)),
'align': align
}
itemData.update(self.__itemTooltip(item))
if withCounts:
itemData['count'] = count
return itemData
def getRankedAwardVOs(self, iconSize = 'small', withCounts = False, withKey = False):
result = []
for booster, count in self.getBoosters().iteritems():
if booster is not None:
itemData = {'imgSource': RES_ICONS.getBonusIcon(iconSize, booster.boosterGuiType),
'label': text_styles.hightlight('x{}'.format(count)),
'align': TEXT_ALIGN.RIGHT}
itemData.update(self.__itemTooltip(booster))
if withKey:
itemData['itemKey'] = 'booster_{}'.format(booster.boosterID)
if withCounts:
itemData['count'] = count
result.append(itemData)
return result
def getRankedAwardVOs(self, iconSize = 'small', withCounts = False, withKey = False):
result = []
for item, data in zip(self.getCustomizations(), self.getList(defaultSize=128)):
count = item.get('value', 1)
itemData = {'imgSource': RES_ICONS.getBonusIcon(iconSize, item.get('custType')),
'label': text_styles.hightlight('x{}'.format(count)),
'align': TEXT_ALIGN.RIGHT}
itemData.update(self.__itemTooltip(data, isReceived=False))
if withKey:
itemData['itemKey'] = 'customization_{}'.format(item.get('custType'))
if withCounts:
itemData['count'] = count
result.append(itemData)
return result
def _getRankReceiveForFirstTimeData(self, lastRank, currentRank):
state = RANKEDBATTLES_ALIASES.RANK_RECEIVE_FOR_FIRST_TIME_STATE
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_NEWRANKCONGRAT))
steps = self._buildProgress(currentRank)
rankLeftVO = self._buildRankVO(lastRank, True)
rankRightVO = self._buildRankVO(currentRank)
return self._buildVO(state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
infoText=infoText,
steps=steps,
finalState=self._buildFinalState(
state,
rankLeftVO=self._buildRankVO(lastRank, True),
rankRightVO=self._buildRankVO(currentRank),
steps=self._buildProgress(currentRank)))
def __getCommonAwardsVOs(self,
item,
data,
iconSize='small',
align=TEXT_ALIGN.RIGHT,
withCounts=False):
c11nItem = self.__getC11nItem(item)
count = item.get('value', 1)
itemData = {
'imgSource': RES_ICONS.getBonusIcon(iconSize,
c11nItem.itemTypeName),
'label': text_styles.hightlight('x{}'.format(count)),
'align': align
}
itemData.update(self.__itemTooltip(data))
if withCounts:
itemData['count'] = count
return itemData
def _getFirstRankReachiveStateData(self,
currentRank,
nextRank,
newStepsState=None,
changeAcquired=False):
"""
Return VO of first rank with was reachieved by player
:param currentRank:
:param nextRank:
:param newStepsState: newSteps state override
:param changeAcquired: apply newStepsState only to acquired steps
:return:
"""
state = RANKEDBATTLES_ALIASES.FIRST_RANK_REACHIVE_STATE
steps = self._buildProgress(currentRank)
infoText = ''
if not self._isHuge():
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_INITTEXT,
battles=str(len(steps))))
nextInfoText = ''
rankRightVO = self._buildRankVO(currentRank, True)
newRankVO = self._buildRankVO(nextRank)
newSteps = self._buildProgress(nextRank,
newStepsState=newStepsState,
changeAcquired=changeAcquired)
return self._buildVO(
state,
infoText=infoText,
rankRightVO=rankRightVO,
newRankVO=newRankVO,
steps=steps,
newSteps=newSteps,
nextInfoText=nextInfoText,
finalState=self._buildFinalState(
state,
rankLeftVO=self._buildRankVO(currentRank, True),
rankRightVO=self._buildRankVO(nextRank),
steps=self._buildProgress(nextRank,
newStepsState=newStepsState,
changeAcquired=changeAcquired)))
def _packConditionsBlock(self, *args, **kwargs):
block = []
winnersBattlesNum = self.rankedController.getRanksTops(isLoser=False,
earned=True)
losersBattlesNum = self.rankedController.getRanksTops(isLoser=True,
earned=True)
block.append(
formatters.packTextBlockData(
text_styles.middleTitle(
RANKED_BATTLES.TOOLTIP_STEP_CONDITIONS_HEADER),
padding=formatters.packPadding(bottom=7)))
if winnersBattlesNum:
winIcon = RES_ICONS.getRankedTooltipTopIcon(winnersBattlesNum)
block.append(
formatters.packImageTextBlockData(
desc=text_styles.main(
_ms(RANKED_BATTLES.TOOLTIP_STEP_CONDITIONS,
battlesNum=winnersBattlesNum,
team=text_styles.statInfo(
RANKED_BATTLES.TOOLTIP_STEP_WINNERS))),
img=winIcon,
txtPadding=formatters.packPadding(left=17)))
if winnersBattlesNum and losersBattlesNum:
block.append(
formatters.packTextBlockData(
text_styles.hightlight(RANKED_BATTLES.TOOLTIP_STEP_OR),
padding=formatters.packPadding(left=70, bottom=10)))
if losersBattlesNum:
loseIcon = RES_ICONS.getRankedTooltipTopIcon(losersBattlesNum)
block.append(
formatters.packImageTextBlockData(
desc=text_styles.main(
_ms(RANKED_BATTLES.TOOLTIP_STEP_CONDITIONS,
battlesNum=losersBattlesNum,
team=text_styles.critical(
RANKED_BATTLES.TOOLTIP_STEP_LOSERS))),
img=loseIcon,
txtPadding=formatters.packPadding(left=17)))
return formatters.packBuildUpBlockData(
block, 0,
BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE)
def __getCommonAwardsVOs(self,
item,
data,
iconSize='small',
align=TEXT_ALIGN.RIGHT,
withCounts=False):
itemTypeName = item.get('custType')
itemID = item.get('id')
itemTypeID = GUI_ITEM_TYPE_INDICES.get(itemTypeName)
c11nItem = self.c11n.getItemByID(itemTypeID, itemID)
count = item.get('value', 1)
itemData = {
'imgSource': RES_ICONS.getBonusIcon(iconSize,
c11nItem.itemTypeName),
'label': text_styles.hightlight('x{}'.format(count)),
'align': align
}
itemData.update(self.__itemTooltip(data, isReceived=False))
if withCounts:
itemData['count'] = count
return itemData
def __packAwards(self, detailedData):
awards = detailedData.getAwards(extended=self._awardListReturned)
result = []
keys = []
if self._mainReward:
keys.append('awards')
if self._addReward or self._awardListReturned:
keys.append('awardsFullyCompleted')
for key in keys:
for item in awards.get(key, []):
label = item['label'] if item['label'] is not None else ''
result.append({
'imgSource': item['imgSource'],
'label': text_styles.hightlight(label),
'align': item['align'],
'tooltip': item['tooltip'],
'isSpecial': item['isSpecial'],
'specialAlias': item['specialAlias'],
'specialArgs': item['specialArgs']
})
return result
def __packLeagueAwardsRow(self, cohortData):
cohortNumber = cohortData['cohortNumber']
if cohortNumber < 4:
icon = RES_ICONS.getRankedLeagueCohortIcon(cohortNumber)
count = '{}%'.format(cohortData['playersPercent'])
if cohortNumber == 1:
description = _ms(
RANKED_BATTLES.RANKEDBATTLESCYCLESVIEW_FINAL_FIRST,
count=count)
else:
description = _ms(
RANKED_BATTLES.RANKEDBATTLESCYCLESVIEW_FINAL_INTERMEDIATE,
count=count)
else:
icon = ''
description = _ms(
RANKED_BATTLES.RANKEDBATTLESCYCLESVIEW_FINAL_LAST)
return {
'icon': icon,
'iconDescr': text_styles.hightlight(description),
'awards': cohortData['awards']
}
def _getOrBlock(self, padding = None):
return formatters.packTextBlockData(text_styles.hightlight(RANKED_BATTLES.TOOLTIP_STEP_OR), padding=padding)
def __getData(self):
filters = self.__getFilters()
isCompleted = filters['isRankedWelcomeViewStarted']
filters['isRankedWelcomeViewStarted'] = True
self.__setFilters(filters)
rulePositive, ruleNegative = self.__getRules()
ranks = [RES_ICONS.getRankIcon('114x160', i) for i in xrange(1, 6)]
ranks.append(
RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKS_114X160_RANKVEHMASTER)
return {
'header':
text_styles.superPromoTitle(RANKED_BATTLES.WELCOMESCREEN_HEADER),
'rules': [{
'image':
RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKEDBATTESVIEW_ICN_TANKS,
'description':
text_styles.hightlight(RANKED_BATTLES.WELCOMESCREEN_LEFTRULE),
'tooltip':
makeTooltip(
RANKED_BATTLES.WELCOMESCREEN_LEFTRULETOOLTIP_HEADER,
RANKED_BATTLES.WELCOMESCREEN_LEFTRULETOOLTIP_BODY)
}, {
'image':
RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKEDBATTESVIEW_ICN_CREW,
'description':
text_styles.hightlight(
RANKED_BATTLES.WELCOMESCREEN_CENTERRULE),
'tooltip':
makeTooltip(
RANKED_BATTLES.WELCOMESCREEN_CENTERRULETOOLTIP_HEADER,
RANKED_BATTLES.WELCOMESCREEN_CENTERRULETOOLTIP_BODY)
}, {
'image':
RES_ICONS.MAPS_ICONS_RANKEDBATTLES_RANKEDBATTESVIEW_AWARD,
'description':
text_styles.hightlight(RANKED_BATTLES.WELCOMESCREEN_RIGHTRULE),
'tooltip':
makeTooltip(
RANKED_BATTLES.WELCOMESCREEN_RIGHTRULETOOLTIP_HEADER,
RANKED_BATTLES.WELCOMESCREEN_RIGHTRULETOOLTIP_BODY)
}],
'ranks':
ranks,
'rulePositive':
rulePositive,
'ruleNegative':
ruleNegative,
'ranksDescription':
text_styles.promoSubTitle(RANKED_BATTLES.WELCOMESCREEN_RANKSDESCR),
'equalityText':
RANKED_BATTLES.WELCOMESCREEN_EQUALITYTEXT,
'rulesDelimeterText':
text_styles.promoSubTitle(
RANKED_BATTLES.WELCOMESCREEN_RULESDELIMETER),
'btnLbl':
RANKED_BATTLES.WELCOMESCREEN_BTN,
'btnTooltip':
makeTooltip(
RANKED_BATTLES.
RANKEDBATTLEVIEW_NOTRANKEDBLOCK_OKTOOLTIP_HEADER,
RANKED_BATTLES.RANKEDBATTLEVIEW_NOTRANKEDBLOCK_OKTOOLTIP_BODY),
'closeLbl':
RANKED_BATTLES.WELCOMESCREEN_CLOSEBTN,
'closeBtnTooltip':
makeTooltip(RANKED_BATTLES.WELCOMESCREEN_CLOSEBTNTOOLTIP_HEADER,
RANKED_BATTLES.WELCOMESCREEN_CLOSEBTNTOOLTIP_BODY),
'bgImage':
RES_ICONS.MAPS_ICONS_RANKEDBATTLES_BG_RANK_BLUR,
'isComplete':
bool(isCompleted)
}
def _buildData(self, ranks, currentRank, lastRank):
currentRankID = currentRank.getID()
lastRankID = lastRank.getID()
if currentRankID == 0:
state = RANKEDBATTLES_ALIASES.RANK_INIT_STATE
nextRank = ranks[currentRankID + 1]
steps = self._buildProgress(nextRank)
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_INITTEXT,
battles=str(len(steps))))
rankLeftVO = self._buildRankVO(nextRank)
return [
self._buildVO(state,
infoText=infoText,
rankLeftVO=rankLeftVO,
steps=steps,
finalState=self._buildFinalState(
state,
self._buildRankVO(nextRank),
steps=self._buildProgress(nextRank)))
]
else:
maxAccRankID = self.rankedController.getAccRanksTotal()
skipNewRankCheck = currentRankID == 1 and self.rankedController.wasAwardWindowShown(
) and not self._isHuge()
if currentRank.isNewForPlayer() and not skipNewRankCheck:
if lastRank.isAcquired():
isJumpOverRank = currentRankID - lastRankID > 1
if currentRankID > maxAccRankID:
return [
self._getLadderPointReceiveData(
maxRank=ranks[maxAccRankID],
vehRank=ranks[currentRankID + 1],
currentRank=currentRank)
]
if currentRankID == 1:
if self._isHuge() or currentRank.isRewardClaimed():
return [
self._getFirstRankReachiveStateData(
currentRank=ranks[1], nextRank=ranks[2])
]
return [
self._getFirstRankReceiveStateData(
currentRank=currentRank)
]
if not self._checkClaim() or currentRank.isRewardClaimed():
states = []
if isJumpOverRank:
tmpRankID = lastRankID + 1
while tmpRankID <= currentRankID:
if tmpRankID == 1:
states.append(
self._getFirstRankReachiveStateData(
currentRank=ranks[1],
nextRank=ranks[2],
newStepsState=RANKEDBATTLES_ALIASES
.STEP_RECEIVED_BLINK_STATE,
changeAcquired=True))
else:
states.append(
self._getReachievedReceiveStateData(
lastRank=ranks[tmpRankID - 1],
currentRank=ranks[tmpRankID],
nextRank=ranks[tmpRankID + 1],
stepsState=RANKEDBATTLES_ALIASES.
STEP_RECEIVED_STATE,
newStepsState=RANKEDBATTLES_ALIASES
.STEP_RECEIVED_BLINK_STATE,
changeAcquired=tmpRankID ==
currentRankID))
tmpRankID += 1
return states
return [
self._getReachievedReceiveStateData(
lastRank=lastRank,
currentRank=currentRank,
nextRank=ranks[currentRankID + 1])
]
if isJumpOverRank:
states = []
tmpRankID = lastRankID + 1
while tmpRankID <= currentRankID:
if tmpRankID == currentRankID:
states.append(
self._getRankReceiveForFirstTimeData(
lastRank=ranks[tmpRankID - 1],
currentRank=ranks[tmpRankID]))
elif tmpRankID == 1:
states.append(
self._getFirstRankReachiveStateData(
currentRank=ranks[1],
nextRank=ranks[2],
newStepsState=RANKEDBATTLES_ALIASES.
STEP_RECEIVED_BLINK_STATE,
changeAcquired=True))
else:
states.append(
self._getReachievedReceiveStateData(
lastRank=ranks[tmpRankID - 1],
currentRank=ranks[tmpRankID],
nextRank=ranks[tmpRankID + 1],
stepsState=RANKEDBATTLES_ALIASES.
STEP_RECEIVED_STATE,
newStepsState=RANKEDBATTLES_ALIASES.
STEP_RECEIVED_BLINK_STATE))
tmpRankID += 1
return states
return [
self._getRankReceiveForFirstTimeData(
lastRank=lastRank, currentRank=currentRank)
]
if lastRank.isLost():
if lastRank.getType(
) == RANK_TYPES.VEHICLE and lastRank.isMax():
nextRank = ranks[lastRank.getID()]
else:
nextRank = ranks[lastRank.getID() + 1]
state = RANKEDBATTLES_ALIASES.RANK_LOST_STATE
steps = self._buildProgress(nextRank)
newSteps = self._buildProgress(lastRank)
rankLeftVO = self._buildRankVO(lastRank, True)
rankRightVO = self._buildRankVO(nextRank)
newRankVO = self._buildRankVO(currentRank, True)
return [
self._buildVO(
state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
newRankVO=newRankVO,
steps=steps,
newSteps=newSteps,
finalState=self._buildFinalState(
state,
rankLeftVO=self._buildRankVO(
currentRank, True),
rankRightVO=self._buildRankVO(lastRank),
steps=self._buildProgress(lastRank)))
]
if self._checkClaim() and not currentRank.isRewardClaimed():
state = RANKEDBATTLES_ALIASES.NEW_RANK_CONGRAT_STATE
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_NEWRANKCONGRAT))
rankLeftVO = self._buildRankVO(currentRank, True)
return [
self._buildVO(state,
infoText=infoText,
rankLeftVO=rankLeftVO,
finalState=self._buildFinalState(
state,
rankLeftVO=self._buildRankVO(
currentRank, True)))
]
nextRank = ranks[currentRankID + 1]
steps = self._buildProgress(nextRank)
shieldStatus = self.rankedController.getShieldStatus(currentRank)
if shieldStatus is not None:
prevShieldHP, shiedHP, maxHP, shieldState, _ = shieldStatus
if shieldState == RANKEDBATTLES_ALIASES.SHIELD_ENABLED:
if shiedHP < maxHP:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_NOT_FULL
else:
state = RANKEDBATTLES_ALIASES.RANK_IDLE_STATE
elif shieldState == RANKEDBATTLES_ALIASES.SHIELD_RENEW:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_RENEW
elif shieldState == RANKEDBATTLES_ALIASES.SHIELD_FULL_RENEW:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_FULL_RENEW
elif shieldState == RANKEDBATTLES_ALIASES.SHIELD_LOSE:
if prevShieldHP == maxHP:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_LOSE_FROM_FULL
else:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_LOSE
elif shieldState == RANKEDBATTLES_ALIASES.SHIELD_LOSE_STEP:
if prevShieldHP == maxHP:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_LOSE_STEP_FROM_FULL
else:
state = RANKEDBATTLES_ALIASES.ANIM_SHIELD_LOSE_STEP
else:
state = RANKEDBATTLES_ALIASES.RANK_IDLE_STATE
else:
state = RANKEDBATTLES_ALIASES.RANK_IDLE_STATE
if RANKEDBATTLES_ALIASES.RANK_IDLE_STATE and currentRankID >= maxAccRankID:
ladderPoints = (self.rankedController.getLadderPoints(), None)
rankLeftVO = self._buildRankVO(ranks[maxAccRankID],
True,
showLadderPoints=True,
ladderPoints=ladderPoints)
finalLeftVO = self._buildRankVO(ranks[maxAccRankID],
True,
showLadderPoints=True,
ladderPoints=ladderPoints)
rankRightVO = self._buildRankVO(ranks[maxAccRankID + 1])
finalRightVO = self._buildRankVO(ranks[maxAccRankID + 1])
else:
rankLeftVO = self._buildRankVO(currentRank, True)
finalLeftVO = self._buildRankVO(currentRank, True)
rankRightVO = self._buildRankVO(nextRank)
finalRightVO = self._buildRankVO(nextRank)
isShieldOneRankState = state in RANKEDBATTLES_ALIASES.ANIM_SHIELD_ONE_RANK_STATES
return [
self._buildVO(state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
steps=steps,
finalState=self._buildFinalState(
state,
rankLeftVO=finalLeftVO,
rankRightVO=None
if isShieldOneRankState else finalRightVO,
steps=None if isShieldOneRankState else
self._buildProgress(nextRank)))
]
def makeRankedNickNameHugeValue(name):
return text_styles.hightlight(name)
def __onUpdateBoosters(self, *args):
activeBoostersCount = len(
self._goodiesCache.getBoosters(
criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values())
totalBoostersCount = len(
self._goodiesCache.getBoosters(
criteria=REQ_CRITERIA.BOOSTER.IN_ACCOUNT).values())
filteredBoostersCount = 0
criteria = REQ_CRITERIA.BOOSTER.IN_ACCOUNT | REQ_CRITERIA.BOOSTER.ENABLED
criteria |= getCriteriaFromFilterMask(self.__filterMask)
boosters = self._goodiesCache.getBoosters(criteria=criteria).values()
dataProviderValues = []
showDummyScreen = False
filterWarningVO = None
if boosters:
for booster in sorted(boosters, cmp=self.__sort):
influence = backport.text(
R.strings.menu.booster.influence.dyn(
booster.boosterGuiType)())
limitResource = R.strings.menu.booster.limit.dyn(
booster.boosterGuiType)
if limitResource:
additionalInfo = text_styles.alert(
backport.text(limitResource()))
else:
additionalInfo = ''
vo = createStorageDefVO(
booster.boosterID,
text_styles.hightlight(
_ms(MENU.BOOSTER_DESCRIPTION_EFFECTVALUETIME,
effectValue=booster.getFormattedValue(),
effectTime=booster.getEffectTimeStr(
hoursOnly=True))),
text_styles.main(influence),
booster.count,
getItemPricesVO(booster.getSellPrice())[0],
func_utils.makeFlashPath(
booster.getShopIcon(STORE_CONSTANTS.ICON_SIZE_SMALL)),
func_utils.makeFlashPath(booster.getShopIcon()),
'altimage',
enabled=booster.isReadyToActivate,
available=booster.isAvailable,
active=booster.state,
contextMenuId=CONTEXT_MENU_HANDLER_TYPE.
STORAGE_PERSONAL_RESERVE_ITEM,
additionalInfo=additionalInfo)
dataProviderValues.append(vo)
filteredBoostersCount += 1
elif totalBoostersCount == 0:
showDummyScreen = True
else:
filterWarningVO = self._makeFilterWarningVO(
STORAGE.FILTER_WARNINGMESSAGE,
STORAGE.FILTER_NORESULTSBTN_LABEL,
TOOLTIPS.STORAGE_FILTER_NORESULTSBTN)
self._dataProvider.buildList(dataProviderValues)
self.__updateFilterCounter(filteredBoostersCount, totalBoostersCount)
self.__updateActiveBoostersCounter(activeBoostersCount,
totalBoostersCount)
self.as_showFilterWarningS(filterWarningVO)
self.as_showDummyScreenS(showDummyScreen)
return
def _buildData(self, ranks, currentRank, lastRank):
currentRankID = currentRank.getID()
if currentRankID == 0:
state = RANKEDBATTLES_ALIASES.RANK_INIT_STATE
nextRank = ranks[currentRankID + 1]
steps = self._buildProgress(nextRank)
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_INITTEXT,
battles=str(len(steps))))
countText = self._getCountLabel(nextRank)
rankLeftVO = self._buildRankVO(nextRank)
return self._buildVO(state,
infoText=infoText,
rankLeftVO=rankLeftVO,
steps=steps,
countText=countText)
else:
skipNewRankCheck = currentRankID == 1 and self.rankedController.wasAwardWindowShown(
) and not self._isHuge()
if currentRank.isNewForPlayer() and not skipNewRankCheck:
if lastRank.isAcquired():
self._addSoundEvent(
RANKEDBATTLES_ALIASES.RANK_RECEIVE_STATE, currentRank)
if currentRankID == 1 and not self._isHuge():
state = RANKEDBATTLES_ALIASES.FIRST_RANK_RECEIVE_STATE
steps = self._buildProgress(currentRank)
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_INITTEXT,
battles=str(len(steps))))
nextInfoText = text_styles.hightlight(
_ms(RANKED_BATTLES.
RANKEDBATTLESWIDGET_NEWRANKCONGRAT))
rankLeftVO = self._buildRankVO(currentRank, True)
return self._buildVO(state,
infoText=infoText,
rankLeftVO=rankLeftVO,
steps=steps,
nextInfoText=nextInfoText)
if not self._checkClaim() or currentRank.isRewardClaimed(
) or self._isHuge() and currentRankID == 1:
nextRank = ranks[currentRankID + 1]
if self._isHuge():
state = RANKEDBATTLES_ALIASES.RANK_RECEIVE_HUGE_STATE
steps = self._buildProgress(nextRank)
countText = ''
nextCountText = nextRank.getProgress(
).getNewUserStr()
rankLeftVO = self._buildRankVO(currentRank, True)
rankRightVO = self._buildRankVO(currentRank, True)
else:
state = RANKEDBATTLES_ALIASES.RANK_RECEIVE_STATE
steps = self._buildProgress(currentRank)
countText = currentRank.getProgress().getUserStr()
nextCountText = currentRank.getProgress(
).getNewUserStr()
rankLeftVO = self._buildRankVO(lastRank, True)
rankRightVO = self._buildRankVO(currentRank)
newSteps = self._buildProgress(nextRank)
newCountText = nextRank.getProgress().getUserStr()
newRankVO = self._buildRankVO(nextRank)
return self._buildVO(state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
newRankVO=newRankVO,
steps=steps,
newSteps=newSteps,
countText=countText,
nextCountText=nextCountText,
newCountText=newCountText)
state = RANKEDBATTLES_ALIASES.RANK_RECEIVE_FOR_FIRST_TIME_STATE
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_NEWRANKCONGRAT))
steps = self._buildProgress(currentRank)
countText = currentRank.getProgress().getUserStr()
nextCountText = currentRank.getProgress().getNewUserStr()
rankLeftVO = self._buildRankVO(lastRank, True)
rankRightVO = self._buildRankVO(currentRank)
return self._buildVO(state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
infoText=infoText,
steps=steps,
countText=countText,
nextCountText=nextCountText)
if lastRank.isLost():
self._addSoundEvent(RANKEDBATTLES_ALIASES.RANK_LOST_STATE)
if lastRank.getType(
) == RANK_TYPES.VEHICLE and lastRank.isMax():
nextRank = ranks[lastRank.getID()]
else:
nextRank = ranks[lastRank.getID() + 1]
if self._isHuge():
state = RANKEDBATTLES_ALIASES.RANK_LOST_HUGE_STATE
steps = self._buildProgress(lastRank)
countText = ''
nextCountText = lastRank.getProgress().getNewUserStr()
else:
state = RANKEDBATTLES_ALIASES.RANK_LOST_STATE
steps = self._buildProgress(nextRank)
countText = nextRank.getProgress().getUserStr()
nextCountText = nextRank.getProgress().getNewUserStr()
newSteps = self._buildProgress(lastRank)
newCountText = lastRank.getProgress().getUserStr()
rankLeftVO = self._buildRankVO(lastRank, True)
rankRightVO = self._buildRankVO(nextRank)
newRankVO = self._buildRankVO(currentRank, True)
return self._buildVO(state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
newRankVO=newRankVO,
steps=steps,
newSteps=newSteps,
countText=countText,
nextCountText=nextCountText,
newCountText=newCountText)
if self._checkClaim() and not currentRank.isRewardClaimed():
state = RANKEDBATTLES_ALIASES.NEW_RANK_CONGRAT_STATE
infoText = text_styles.hightlight(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_NEWRANKCONGRAT))
rankLeftVO = self._buildRankVO(currentRank, True)
return self._buildVO(state,
infoText=infoText,
rankLeftVO=rankLeftVO,
steps=None)
state = RANKEDBATTLES_ALIASES.RANK_IDLE_STATE
nextRank = ranks[currentRankID + 1]
steps = self._buildProgress(nextRank)
showText = True
for step in steps:
if step['state'] in [
RANKEDBATTLES_ALIASES.STEP_JUST_LOST_STATE,
RANKEDBATTLES_ALIASES.STEP_JUST_RECEIVED_STATE,
RANKEDBATTLES_ALIASES.STEP_JUST_RECEIVED_SHORT_STATE
]:
showText = False
countText = nextRank.getProgress().getUserStr()
if self._isHuge():
if not showText:
countText = ''
else:
countText = text_styles.stats(
_ms(RANKED_BATTLES.RANKEDBATTLESWIDGET_NOCHANGES))
rankLeftVO = self._buildRankVO(currentRank, True)
rankRightVO = self._buildRankVO(nextRank)
return self._buildVO(state,
rankLeftVO=rankLeftVO,
rankRightVO=rankRightVO,
steps=steps,
countText=countText)
def getIconLabel(self):
return text_styles.hightlight(self.getValue())
def getIconLabel(self):
"""
returns label which is displayed near icon. Originally used in ranked battles
@return: styled label str
"""
return text_styles.hightlight('x{}'.format(self.getValue()))
def makeRankedPointHugeValue(pointsValue):
return makeHtmlString('html_templates:lobby/battle_results',
'xp_small_label',
{'value': text_styles.hightlight(pointsValue)})
def _getOrBlock(self, padding=None):
return formatters.packTextBlockData(text_styles.hightlight(
backport.text(R.strings.ranked_battles.tooltip.step.c_or())),
padding=padding)
