def __composeBonuses(bonuses, alwaysVisibleBonuses, maxAwardCount):
bonuses = splitBonuses(bonuses)
alwaysVisibleBonuses = splitBonuses(alwaysVisibleBonuses)
if len(bonuses) + len(alwaysVisibleBonuses) > maxAwardCount:
bonusesLimit = max(0, maxAwardCount - len(alwaysVisibleBonuses) - 1)
mergedBonus = SimpleBonus(MERGED_BONUS_NAME, bonuses[bonusesLimit:])
return bonuses[:bonusesLimit] + alwaysVisibleBonuses + [mergedBonus]
return bonuses + alwaysVisibleBonuses
def _updateRewards(self, rewards, bonuses):
self._tooltips.clear()
packer = getNewYearBonusPacker()
bonuses = sorted(splitBonuses(bonuses), key=_keyBonusSortOrder)
rewards.clear()
packBonusModelAndTooltipData(bonuses, rewards, packer, self._tooltips)
rewards.invalidate()
def hideInvisible(cls, bonuses, needSplit=False):
if needSplit:
bonuses = mergeBonuses(bonuses)
bonuses = splitBonuses(bonuses)
bonuses = list(
filter(cls.__bonusesLayoutController.getIsVisible, bonuses))
return bonuses
def composeBonuses(rewards, ctx=None):
bonuses = []
for reward in rewards:
for key, value in reward.iteritems():
bonuses.extend(getNonQuestBonuses(key, value, ctx))
bonuses = mergeBonuses(bonuses)
bonuses = splitBonuses(bonuses)
return bonuses
def __makeRewardsGroup(self, renderer):
rewardModelsList = renderer.rewardsGroup.getItems()
rewardModelsList.clear()
self.__tooltips.clear()
self.__bonuses = copy.deepcopy(self.__levelInfo.getBonuses())
extendBonusesByLevel(self.__bonuses, self.__levelInfo.level())
self.__bonuses = splitBonuses(self.__bonuses)
self.__bonuses.sort(key=nyBonusGFSortOrder)
packBonusModelAndTooltipData(self.__bonuses, rewardModelsList,
getNewYearBonusPacker(), self.__tooltips)
def __getBonuses(self, level):
questsProgressData = self.__ctx[
'reusableInfo'].personal.getQuestsProgress()
bonuses = after_battle_reward_view_helpers.getQuestBonuses(
questsProgressData,
(self.__battleRoyaleController.TOKEN_QUEST_ID, ),
self.__battleRoyaleController.TOKEN_QUEST_ID + str(level))
bonuses = mergeBonuses(bonuses)
bonuses = splitBonuses(bonuses)
return bonuses
def __convertRewards(self, ctx):
self.__rewards = ctx.get('rewards', [])
self.__rewards = splitBonuses(self.__rewards)
crewRewards = ctx.get('crewRewards', None)
if crewRewards:
self.__rewards.append(crewRewards)
self.__rewards = self.__sortRewardsByPriority(self.__rewards)
formatter = getMarathonRewardScreenPacker()
self.__rewards = formatter.format(self.__rewards)
return
def __setRewards(self):
bonuses = self.__rewards[self.__currentLevel]
extendBonusesByLevel(bonuses, self.__currentLevel)
bonuses = splitBonuses(bonuses)
hugeBonuses, otherBonuses = _splitHugeBonuses(bonuses)
with self.getViewModel().transaction() as model:
self.__tooltips.clear()
self.__fillRewardsList(rewardsList=model.hugeRewards.getItems(),
bonuses=hugeBonuses,
sortMethod=_hugeBonusesSortOrder,
packer=getNewYearBonusPacker())
self.__fillRewardsList(rewardsList=model.rewards.getItems(),
bonuses=otherBonuses,
sortMethod=nyBonusGFSortOrder,
packer=getNewYearBonusPacker())
model.setLevel(self.__currentLevel)
def createToolTipContent(self, event, ctID):
if ctID == R.views.lobby.new_year.tooltips.NyVehicleSlotTooltip():
tooltipData = self.__tooltips.get(event.getArgument('tooltipId'))
if tooltipData is None:
return
return NyVehicleSlotTooltip(*tooltipData.specialArgs)
elif ctID == R.views.lobby.new_year.tooltips.NyShardsTooltip():
return NyShardsTooltip()
elif ctID == R.views.lobby.tooltips.AdditionalRewardsTooltip(
) and self.viewStatus == ViewStatus.LOADED:
showCount = int(event.getArgument('showedCount'))
bonuses = splitBonuses(self.__rewards[self.__currentLevel])
_, secondaryBonuses = _splitHugeBonuses(bonuses)
return AdditionalRewardsTooltip(
sorted(secondaryBonuses, key=nyBonusGFSortOrder)[showCount:],
getNewYearBonusPacker())
else:
return super(NyAtmosphereLevelUpView,
self).createToolTipContent(event, ctID)
def __setBonuses(self, model):
questsBonuses = self.__data[BRSections.PERSONAL][
BRSections.REWARDS].get(BRSections.BONUSES, [])
if not questsBonuses:
return
bonusesModel = model.getBonuses()
bonusesModel.clear()
bonuses = [
bonus for questBonuses in questsBonuses for bonus in questBonuses
]
bonuses = [
bonus for bonus in mergeBonuses(bonuses)
if bonus.getName() not in _CURRENCIES
]
bonuses = splitBonuses(bonuses)
packBonusModelAndTooltipData(bonuses,
bonusesModel,
tooltipData=self.__tooltipsData)
bonusesModel.invalidate()
def __getBonuses(self, prevLevel, currentLevel):
questsProgressData = self.__ctx[
'reusableInfo'].personal.getQuestsProgress()
if currentLevel == self.__epicController.getMaxPlayerLevel():
bonuses = getFinishBadgeBonuses(
questsProgressData, self.__epicController.FINAL_BADGE_QUEST_ID)
else:
bonuses = []
bonuses.extend(
getQuestBonuses(
questsProgressData, (self.__epicController.TOKEN_QUEST_ID, ),
self.__epicController.TOKEN_QUEST_ID + str(currentLevel)))
if self.__battlePass.getCurrentLevel(
) == self.__battlePass.getMaxLevel():
excluded = [BattleRewardItemModel.BATTLE_PASS_POINTS]
bonuses = [b for b in bonuses if b.getName() not in excluded]
for level in range(prevLevel + 1, currentLevel + 1):
bonuses.extend(self.__getAbilityPointsRewardBonus(level))
bonuses = mergeBonuses(bonuses)
bonuses = splitBonuses(bonuses)
return bonuses
def sortBonuses(cls, bonuses):
bonuses = mergeBonuses(bonuses)
bonuses = splitBonuses(bonuses)
bonuses.sort(key=cls.__bonusesLayoutController.getPriority,
reverse=True)
return bonuses
