def __setRewardsList(self, awardType, model):
model.clearItems()
bonuses = sorted(
self.__battlePassController.getAwardsList(awardType).iteritems(),
key=itemgetter(0))
curLevel = self.__battlePassController.getCurrentLevel()
curState = self.__battlePassController.getState()
isBattlePassBought = self.__battlePassController.isBought()
state = BattlePassState.POST if awardType == BattlePassConsts.REWARD_POST else BattlePassState.BASE
isBase = state == BattlePassState.BASE
for level, award in bonuses:
item = RewardLevelModel()
item.setLevel(level)
item.setLevelPoints(
self.__battlePassController.getLevelPoints(level - 1, isBase))
item.setIsRare(
self.__battlePassController.isRareLevel(level, isBase))
isReached = curLevel >= level and state == curState or curState > state
if awardType == BattlePassConsts.REWARD_PAID and not isBattlePassBought:
levelState = RewardLevelModel.DISABLED
else:
levelState = RewardLevelModel.REACHED if isReached else RewardLevelModel.NOT_REACHED
item.setState(levelState)
packBonusModelAndTooltipData(award, item.rewardItems,
self.__tooltipItems)
model.addViewModel(item)
model.invalidate()
def __setRewardsList(self, awardType, model):
model.clearItems()
minLevel, maxLevel = self.__battlePassController.getChapterLevelInterval(
self.__chosenChapter)
curLevel = self.__battlePassController.getCurrentLevel()
isBattlePassBought = self.__battlePassController.isBought(
chapter=self.__chosenChapter)
bonuses = sorted(self.__battlePassController.getAwardsInterval(
minLevel, maxLevel, awardType).iteritems(),
key=itemgetter(0))
for level, awards in bonuses:
item = RewardLevelModel()
item.setLevel(level)
item.setLevelPoints(
self.__battlePassController.getLevelPoints(level - 1))
item.setIsRare(self.__battlePassController.isRareLevel(level))
levelState, isNeedToTake, isChooseRewardEnabled = self.__getRewardLevelState(
awardType, curLevel, level, isBattlePassBought)
item.setState(levelState)
item.setNeedTake(isNeedToTake)
item.setIsRewardChoiceEnabled(isChooseRewardEnabled)
realAwards = self.__battlePassController.replaceOfferByReward(
awards)
packBonusModelAndTooltipData(realAwards, item.rewardItems,
self.__tooltipItems)
model.addViewModel(item)
model.invalidate()
def __resetRewardsInterval(self,
awardType,
model,
fromLevel,
toLevel,
chapter,
replaceRewards=False):
curLevel = self.__battlePassController.getCurrentLevel()
isBattlePassBought = self.__battlePassController.isBought()
startLevel, finalLevel = self.__battlePassController.getChapterLevelInterval(
chapter)
if fromLevel <= startLevel:
fromLevel = startLevel + 1
if toLevel > finalLevel:
toLevel = finalLevel
for level in range(fromLevel, toLevel + 1):
item = model.getItem(level - startLevel)
levelState, isNeedToTake, isChooseRewardEnabled = self.__getRewardLevelState(
awardType, curLevel, level, isBattlePassBought)
if replaceRewards and item.getNeedTake() and not isNeedToTake:
item.rewardItems.clearItems()
awards = self.__battlePassController.getSingleAward(
level, awardType)
realAwards = self.__battlePassController.replaceOfferByReward(
awards)
packBonusModelAndTooltipData(realAwards, item.rewardItems,
self.__tooltipItems)
self.__showReplaceRewardAnimations = True
item.setState(levelState)
item.setNeedTake(isNeedToTake)
item.setIsRewardChoiceEnabled(isChooseRewardEnabled)
model.invalidate()
def __updateConfirmAnyNumberModel(self, count):
self.__package.setLevels(int(count))
self.__clearTooltips()
with self.viewModel.confirmAnyNumber.transaction() as tx:
tx.setPrice(self.__package.getPrice())
tx.setLevelsSelected(self.__package.getLevelsCount() + self.__battlePassController.getCurrentLevel())
tx.rewards.clearItems()
packBonusModelAndTooltipData(self.__package.getNowAwards(), tx.rewards, self.__tooltipItems)
self.__updateDetailRewards()
def __addBadgeInfo(self):
badge = self.__battlePassController.getBadgeData()
if badge is None:
return
else:
tempStorage = Array()
packBonusModelAndTooltipData([badge], tempStorage,
self.__tooltipItems)
self.viewModel.setBadgeTooltipId(first(self.__tooltipItems.keys()))
return
def __setFinalReward(self, model):
finalLevel = self.__battlePassController.getMaxLevel()
freeReward, paidReward = self.__battlePassController.getSplitFinalAwards(
)
freeModel = model.freeRewards.getItem(finalLevel - 1)
paidModel = model.paidRewards.getItem(finalLevel - 1)
self.__removeMedals(freeModel)
packBonusModelAndTooltipData(freeReward, freeModel.rewardItems,
self.__tooltipItems)
packBonusModelAndTooltipData(paidReward, paidModel.rewardItems,
self.__tooltipItems)
def __setAwards(self, bonuses, isFinalReward):
rewards = BattlePassAwardsManager.composeBonuses(bonuses)
rewards = BattlePassAwardsManager.sortBonuses(
BattlePassAwardsManager.uniteTokenBonuses(rewards))
if not rewards:
return
mainRewards = self.__setMainRewards(rewards,
isFinalReward=isFinalReward)
rewards = [reward for reward in rewards if reward not in mainRewards]
packBonusModelAndTooltipData(rewards, self.viewModel.additionalRewards,
self.__tooltipItems)
def __updateDetailRewards(self):
curLevel = self.__battlePassController.getCurrentLevel()
fromLevel = curLevel
toLevel = curLevel + self.__package.getLevelsCount()
with self.viewModel.rewards.transaction() as tx:
tx.nowRewards.clearItems()
tx.futureRewards.clearItems()
tx.setFromLevel(fromLevel + 1)
tx.setToLevel(toLevel)
tx.setStatePackage(PackageItem.ANY_LEVELS_TYPE)
tx.setChapter(self.__chapter)
packBonusModelAndTooltipData(self.__package.getNowAwards(), self.viewModel.rewards.nowRewards, self.__tooltipItems)
def __getAwards(self, rewardsList, level, bonusType):
finalLevel = self.__battlePassController.getMaxLevel()
if level == finalLevel - 1 and bonusType != BattlePassConsts.REWARD_POST:
freeReward, paidReward = self.__battlePassController.getSplitFinalAwards(
)
if bonusType == BattlePassConsts.REWARD_FREE:
bonuses = freeReward
else:
bonuses = paidReward
else:
bonuses = self.__battlePassController.getSingleAward(
level + 1, bonusType)
packBonusModelAndTooltipData(bonuses, rewardsList)
def __updateViewModel(self):
with self.viewModel.transaction() as tx:
tx.setCurrentProgress(self.__currentBattles)
tx.setTotalProgress(self.__totalBattles)
battleBonuses = tx.getBattleBonuses()
battleBonuses.clear()
with battleBonuses.transaction() as bbtx:
for battle in self.__quests:
battleBonus = RankedQualificationRewardsBattleBonusModel()
battleBonus.setBattlesCount(battle)
bonusesModel = battleBonus.getBonuses()
packBonusModelAndTooltipData(
self.__quests[battle].getBonuses(), bonusesModel,
self.__tooltipItems)
bbtx.addViewModel(battleBonus)
def __updateDetailRewards(self):
curLevel = self.__package.getCurrentLevel()
fromLevel = curLevel
toLevel = curLevel + self.__package.getLevelsCount()
with self.viewModel.rewards.transaction() as tx:
tx.nowRewards.clearItems()
tx.setFromLevel(fromLevel + 1)
tx.setToLevel(toLevel)
tx.setPackageState(PackageType.ANYLEVELS)
tx.setChapterID(self.__chapterID)
tx.setFinalReward(
self.__battlePass.getRewardType(self.__chapterID).value)
packBonusModelAndTooltipData(self.__package.getNowAwards(),
self.viewModel.rewards.nowRewards,
self.__tooltipItems)
def __setBonuses(self, model):
bonuses = self._data[BRSections.PERSONAL][BRSections.REWARDS].get(
BRSections.BONUSES, {})
if not bonuses:
return
bonusesModel = model.getBonuses()
bonusesModel.clear()
bonuses = [
bonus for bonus in formatBonuses(bonuses)
if bonus.getName() not in self._CURRENCIES
]
packBonusModelAndTooltipData(bonuses,
bonusesModel,
tooltipData=self.__tooltipsData)
bonusesModel.invalidate()
def __setAwards(self, model):
bpController = self.__battlePass
self.__tooltipItems.clear()
self.__specialTooltipItems.clear()
if self.__battlePass.getRewardType(
self.__chapterID) == FinalReward.STYLE:
self.__setStyleWidget(model)
elif self.__battlePass.getRewardType(
self.__chapterID) == FinalReward.TANKMAN:
self.__setCharacterWidget(model)
model.levels.clearItems()
minLevel, maxLevel = bpController.getChapterLevelInterval(
self.__chapterID)
freeBonuses = sorted(bpController.getAwardsInterval(
self.__chapterID, minLevel, maxLevel,
BattlePassConsts.REWARD_FREE).iteritems(),
key=itemgetter(0))
paidBonuses = sorted(bpController.getAwardsInterval(
self.__chapterID, minLevel, maxLevel,
BattlePassConsts.REWARD_PAID).iteritems(),
key=itemgetter(0))
for (level, freeBonus), (_, paidBonus) in zip(freeBonuses,
paidBonuses):
isNeedToTakeFree, isChooseFreeRewardEnabled = self.__getRewardLevelState(
BattlePassConsts.REWARD_FREE, level)
isNeedToTakePaid, isChoosePaidRewardEnabled = self.__getRewardLevelState(
BattlePassConsts.REWARD_PAID, level)
levelModel = RewardLevelModel()
levelModel.setLevel(level)
levelModel.setIsRare(
bpController.isRareLevel(self.__chapterID, level))
levelModel.setIsFreeRewardChoiceEnabled(isChooseFreeRewardEnabled)
levelModel.setIsPaidRewardChoiceEnabled(isChoosePaidRewardEnabled)
levelModel.setLevelPoints(
bpController.getLevelPoints(self.__chapterID, level - 1))
levelModel.setNeedTakeFree(isNeedToTakeFree)
levelModel.setNeedTakePaid(isNeedToTakePaid)
realFreeAwards = self.__battlePass.replaceOfferByReward(freeBonus)
packBonusModelAndTooltipData(realFreeAwards,
levelModel.freeRewardItems,
self.__tooltipItems)
realPaidAwards = self.__battlePass.replaceOfferByReward(paidBonus)
packBonusModelAndTooltipData(realPaidAwards,
levelModel.paidRewardItems,
self.__tooltipItems)
model.levels.addViewModel(levelModel)
def __resetRewardsInterval(self,
model,
fromLevel,
toLevel,
replaceRewards=False):
startLevel, finalLevel = self.__battlePass.getChapterLevelInterval(
self.__chapterID)
if fromLevel == toLevel:
return
fromLevel += 1
if toLevel > finalLevel:
toLevel = finalLevel
for level in range(fromLevel, toLevel + 1):
levelData = model.levels.getItem(level - startLevel)
isNeedToTakeFree, isChooseFreeRewardEnabled = self.__getRewardLevelState(
BattlePassConsts.REWARD_FREE, level)
if replaceRewards and levelData.getNeedTakeFree(
) and not isNeedToTakeFree:
levelData.freeRewardItems.clearItems()
awards = self.__battlePass.getSingleAward(
self.__chapterID, level, BattlePassConsts.REWARD_FREE)
realAwards = self.__battlePass.replaceOfferByReward(awards)
packBonusModelAndTooltipData(realAwards,
levelData.freeRewardItems,
self.__tooltipItems)
self.__showReplaceRewardAnimations = True
isNeedToTakePaid, isChoosePaidRewardEnabled = self.__getRewardLevelState(
BattlePassConsts.REWARD_PAID, level)
if replaceRewards and levelData.getNeedTakePaid(
) and not isNeedToTakePaid:
levelData.paidRewardItems.clearItems()
awards = self.__battlePass.getSingleAward(
self.__chapterID, level, BattlePassConsts.REWARD_PAID)
realAwards = self.__battlePass.replaceOfferByReward(awards)
packBonusModelAndTooltipData(realAwards,
levelData.paidRewardItems,
self.__tooltipItems)
self.__showReplaceRewardAnimations = True
levelData.setNeedTakeFree(isNeedToTakeFree)
levelData.setNeedTakePaid(isNeedToTakePaid)
levelData.setIsFreeRewardChoiceEnabled(isChooseFreeRewardEnabled)
levelData.setIsPaidRewardChoiceEnabled(isChoosePaidRewardEnabled)
model.setShowReplaceRewardsAnimations(
self.__showReplaceRewardAnimations)
model.levels.invalidate()
def __setMedalReward(self, model):
maxLevel = self.__battlePassController.getMaxLevel()
freeRewards = self.__battlePassController.getSingleAward(maxLevel)
dossierBonus = findFirst(lambda b: b.getName() == 'dossier',
freeRewards)
if dossierBonus is None:
return
else:
randomStats = self.__itemsCache.items.getAccountDossier(
).getRandomStats()
achievements = dossierBonus.getAchievementsFromDossier(randomStats)
if not achievements:
return
model.setHaveMedalReward(achievements[-1].isInDossier())
model.medalReward.clearItems()
packBonusModelAndTooltipData([dossierBonus], model.medalReward,
self.__tooltipItems)
return
def __updateDetailRewards(self):
chapterID = self.__selectedPackage.getChapterID()
fromLevel = 1
toLevel = self.__selectedPackage.getCurrentLevel()
with self.viewModel.rewards.transaction() as tx:
tx.nowRewards.clearItems()
tx.futureRewards.clearItems()
tx.setFinalReward(self.__battlePass.getRewardType(chapterID).value)
tx.setFromLevel(fromLevel)
tx.setToLevel(toLevel)
tx.setChapterID(chapterID)
tx.setPackageState(PackageType.BATTLEPASS)
packBonusModelAndTooltipData(self.__selectedPackage.getNowAwards(),
self.viewModel.rewards.nowRewards,
self.__tooltipItems)
packBonusModelAndTooltipData(self.__selectedPackage.getFutureAwards(),
self.viewModel.rewards.futureRewards,
self.__tooltipItems)
def __updateDetailRewards(self):
fromLevel, maxLevelInChapter = self.__battlePassController.getChapterLevelInterval(
self.__selectedPackage.getChapter())
toLevel = min(maxLevelInChapter,
self.__battlePassController.getCurrentLevel())
with self.viewModel.rewards.transaction() as tx:
tx.nowRewards.clearItems()
tx.futureRewards.clearItems()
tx.setFromLevel(fromLevel)
tx.setToLevel(toLevel)
tx.setChapter(self.__selectedPackage.getChapter())
tx.setStatePackage(PackageItem.BATTLE_PASS_TYPE)
packBonusModelAndTooltipData(self.__selectedPackage.getNowAwards(),
self.viewModel.rewards.nowRewards,
self.__tooltipItems)
packBonusModelAndTooltipData(self.__selectedPackage.getFutureAwards(),
self.viewModel.rewards.futureRewards,
self.__tooltipItems)
def __setMainRewards(self, rewards, isFinalReward):
limit = MAIN_REWARDS_LIMIT if not isFinalReward else FINAL_REWARDS_LIMIT
mainRewards = []
for reward in rewards:
weight = self.__getRewardWeight(reward)
if limit >= weight > 0:
mainRewards.append(reward)
limit -= weight
if weight == WIDE_REWARD_SIZE:
self.viewModel.getWideRewardsIDs().addNumber(
len(mainRewards) - 1)
if limit <= 0:
break
with useBigAwardInjection():
packBonusModelAndTooltipData(mainRewards,
self.viewModel.mainRewards,
self.__tooltipItems)
return mainRewards
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 __updateDetailRewards(self):
if not isCurrentBattlePassStateBase():
curLevel = self.__battlePassController.getMaxLevel()
else:
curLevel = self.__battlePassController.getCurrentLevel()
if self.__selectedPackage.hasBattlePass():
fromLevel = 0
toLevel = curLevel
else:
fromLevel = curLevel
toLevel = curLevel + self.__selectedPackage.getLevelsCount()
with self.viewModel.rewards.transaction() as tx:
tx.nowRewards.clearItems()
tx.futureRewards.clearItems()
tx.setFromLevel(fromLevel + 1)
tx.setToLevel(toLevel)
tx.setStatePackage(self.__getTypePackage(self.__selectedPackage))
packBonusModelAndTooltipData(self.__selectedPackage.getNowAwards(),
self.viewModel.rewards.nowRewards,
self.__tooltipItems)
packBonusModelAndTooltipData(self.__selectedPackage.getFutureAwards(),
self.viewModel.rewards.futureRewards,
self.__tooltipItems)
def __getAwards(self, chapterID, rewardsList, level, bonusType):
bonuses = self.__battlePass.getSingleAward(chapterID, level + 1,
bonusType)
packBonusModelAndTooltipData(bonuses, rewardsList)
def __getAwards(self, rewardsList, level, bonusType):
bonuses = self.__battlePassController.getSingleAward(
level + 1, bonusType)
packBonusModelAndTooltipData(bonuses, rewardsList)
def __setAwards(self, bonuses, isPremiumPurchase, isFinalReward,
isPostProgression):
rewards = BattlePassAwardsManager.composeBonuses(bonuses)
if not rewards:
return
if isFinalReward:
if self.__battlePassController.isBought():
chosenRewards = [rewards[0], rewards[2]]
boughtRewards = [rewards[1]]
with finalAwardsInjection(self.__battlePassController.
getAlternativeVoteOption()):
packBonusModelAndTooltipData(boughtRewards,
self.viewModel.mainRewards,
self.__tooltipItems)
with finalAwardsInjection(
self.__battlePassController.getVoteOption()):
packBonusModelAndTooltipData(chosenRewards,
self.viewModel.mainRewards,
self.__tooltipItems)
rewards = rewards[3:]
else:
with finalAwardsInjection(
self.__battlePassController.getVoteOption()):
packBonusModelAndTooltipData([rewards.pop(1)],
self.viewModel.mainRewards,
self.__tooltipItems)
packBonusModelAndTooltipData(rewards[:2],
self.viewModel.mainRewards,
self.__tooltipItems)
rewards = rewards[2:]
elif not isPremiumPurchase:
if not isPostProgression or rewards[0].getName(
) == 'customizations':
reward = rewards.pop(0)
value = reward.getValue()
if reward.getName() == 'customizations' and value[0][
'custType'] == 'projection_decal':
with finalAwardsInjection(value[0]['id']):
packBonusModelAndTooltipData(
[reward], self.viewModel.mainRewards,
self.__tooltipItems)
else:
packBonusModelAndTooltipData([reward],
self.viewModel.mainRewards,
self.__tooltipItems)
packBonusModelAndTooltipData(rewards, self.viewModel.additionalRewards,
self.__tooltipItems)
