def __fillToysBonuses(rewardValue, alwaysVisibleBonuses, bonuses,
postponeMegaToys):
toys, megaToys = __getToysSortedByRankAndCount(rewardValue)
rewardType = CurrentNYConstants.TOYS
toysBonuses = getNonQuestBonuses(rewardType, toys) if toys else []
megaToysBonuses = getNonQuestBonuses(rewardType,
megaToys) if megaToys else []
if postponeMegaToys:
bonuses += toysBonuses
alwaysVisibleBonuses += megaToysBonuses
else:
bonuses += megaToysBonuses + toysBonuses
def __getRewards(self, geometryID, stage):
config = self.mapsTrainingController.getConfig()
finalBonuses = []
mapRewardsConfig = config['rewards'][geometryID][stage]
for rewardName, rewardData in mapRewardsConfig.iteritems():
finalBonuses.extend(getNonQuestBonuses(rewardName, rewardData))
return finalBonuses
def getRewardsBonuses(rewards,
size='big',
awardsCount=_DEFAULT_DISPLAYED_AWARDS_COUNT):
formatter = BonusNameQuestsBonusComposer(awardsCount,
getPackRentVehiclesAwardPacker())
bonuses = []
if rewards:
for bonusType, bonusValue in rewards.iteritems():
if bonusType == 'vehicles' and isinstance(bonusValue, list):
for vehicleData in bonusValue:
bonuses.extend(getNonQuestBonuses(bonusType, vehicleData))
bonus = getNonQuestBonuses(bonusType, bonusValue)
bonuses.extend(bonus)
formattedBonuses = formatter.getFormattedBonuses(bonuses, size)
return formattedBonuses
def getFormattedBonusesForYearAwardsWindow(
rawRewards, maxRewardsCount=DEFAULT_REWARDS_COUNT):
bonuses = []
composer = _BonusNameRankedAwardsComposer(maxRewardsCount)
for name, value in rawRewards.iteritems():
bonuses.extend(getNonQuestBonuses(name, value))
return composer.getFormattedBonuses(
bonuses, AWARDS_SIZES.BIG, compareMethod=rankedYearAwardsSortFunction)
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 setRecord(self, result, reusable):
_, rewardsConfig, playerProgress = self._getScenarioData(
result, reusable)
bonus = getMapsTrainingAwards(
rewardsConfig, playerProgress['prevBest'], playerProgress['level'],
result['personal']['avatar']['mt_mapComplete'])
for rewardName, rewardData in bonus.iteritems():
for item in getNonQuestBonuses(rewardName, rewardData):
self.addNextComponent(base.DirectStatsItem('', item))
def _convertNonQuestBonuses(bonuses):
rewards = []
for bonus in bonuses:
items = []
for key, value in bonus.iteritems():
items.extend(getNonQuestBonuses(key, value))
rewards.extend(items)
return rewards
def getProgressiveRewardBonuses(rewards,
size='big',
maxAwardCount=_DEFAULT_DISPLAYED_AWARDS_COUNT,
packBlueprints=False,
ctx=None):
preparationRewardsCurrency(rewards)
if packBlueprints:
_packBlueprints(rewards)
specialRewardType = ''
formatter = LootBoxBonusComposer(maxAwardCount, getLootboxesAwardsPacker())
bonuses = []
alwaysVisibleBonuses = []
if rewards:
for bonusType, bonusValue in rewards.iteritems():
if bonusType == 'blueprints':
bonus = getNonQuestBonuses(bonusType,
bonusValue,
ctx={'isPacked': packBlueprints})
blueprintCongrats = _checkAndFillBlueprints(
bonus, alwaysVisibleBonuses, bonuses)
if blueprintCongrats:
specialRewardType = blueprintCongrats
if bonusType == 'premium' or bonusType == 'premium_plus':
splitDays = splitPremiumDays(bonusValue)
for day in splitDays:
bonus = getNonQuestBonuses(bonusType, day)
bonuses.extend(bonus)
if bonusType in (CrewBonusTypes.CREW_SKIN_BONUSES, 'vehicles'):
alwaysVisibleBonuses.extend(
getNonQuestBonuses(bonusType, bonusValue))
if bonusType == 'items':
bonus = getNonQuestBonuses(bonusType, bonusValue)
_checkAndFillItems(bonus, alwaysVisibleBonuses, bonuses)
bonus = getNonQuestBonuses(bonusType, bonusValue, ctx)
bonuses.extend(bonus)
bonuses.sort(key=_keySortOrder)
alwaysVisibleBonuses.sort(key=_keySortOrder)
formattedBonuses = formatter.getVisibleFormattedBonuses(
bonuses, alwaysVisibleBonuses, size)
return (formattedBonuses, specialRewardType)
def _getBonuses(self):
bonuses = []
if self.__bonuses is None:
return bonuses
else:
for key, value in self.__bonuses.items():
bonus = getNonQuestBonuses(key, value)
if bonus:
bonuses.extend(bonus)
return bonuses
def getRoyaleBonusesFromDict(rewards, size='big'):
alwaysVisibleBonuses = []
commonBonuses = []
for bonusType, bonusValue in rewards.iteritems():
commonBonuses.extend(getNonQuestBonuses(bonusType, bonusValue))
commonBonuses.sort(key=_keySortOrder)
alwaysVisibleBonuses.sort(key=_keySortOrder)
formatter = LootBoxBonusComposer(ROYALE_POSTBATTLE_REWARDS_COUNT,
getRoyaleAwardsPacker())
formattedBonuses = formatter.getVisibleFormattedBonuses(
commonBonuses, alwaysVisibleBonuses, size)
return formattedBonuses
def getFormattedBonusesForYearAwardsWindow(
rawRewards,
maxRewardsCount=DEFAULT_REWARDS_COUNT,
selectionsLeft=None):
bonuses = []
context = {
'selectionsLeft': selectionsLeft
} if selectionsLeft is not None else None
composer = _BonusNameRankedAwardsComposer(maxRewardsCount, context)
for name, value in rawRewards.iteritems():
bonuses.extend(getNonQuestBonuses(name, value))
return composer.getFormattedBonuses(
bonuses, AWARDS_SIZES.BIG, compareMethod=rankedYearAwardsSortFunction)
def wrap(data):
result = {}
for optionType, optionTypeItems in data.iteritems():
typeBonuses = {}
for optionID, optionItems in optionTypeItems.iteritems():
optionItemsList = []
items, limit = optionItems
for itemName, itemValue in items.iteritems():
optionItemsList.extend(getNonQuestBonuses(itemName, itemValue))
typeBonuses[optionID] = {'items': optionItemsList, 'limit': limit}
result[optionType] = typeBonuses
return result
def getSeniorityAwardsRewardsAndBonuses(
rewards,
size=AWARDS_SIZES.BIG,
maxAwardCount=_DEFAULT_DISPLAYED_AWARDS_COUNT,
excluded=(),
sortKey=None,
itemsCache=None):
preparationRewardsCurrency(rewards)
formatter = LootBoxBonusComposer(maxAwardCount, getSeniorityAwardsPacker())
alwaysVisibleBonuses = []
bonuses = []
vehicles = []
currencies = {}
if rewards:
for rewardType, rewardValue in rewards.iteritems():
if rewardType in excluded:
continue
if rewardType == 'vehicles':
vehicles = [
vehCD for vehiclesDict in rewardValue
for vehCD in vehiclesDict
if vehiclesDict[vehCD].get('compensatedNumber', 0) < 1
]
if rewardType == 'currencies':
currencies = {
name: value['count']
for name, value in rewardValue.items()
}
bonuses.extend(getNonQuestBonuses(rewardType, rewardValue))
formattedBonuses = formatter.getVisibleFormattedBonuses(
bonuses, alwaysVisibleBonuses, size, sortKey=sortKey)
orderedVehicles = []
for vehicleCD in vehicles:
vehicle = itemsCache.items.getItemByCD(vehicleCD)
orderedVehicles.append(
VehicleAward(vehicleCD, vehicle.level, vehicle.name,
vehicle.userName))
return SeniorityAwards(formattedBonuses, orderedVehicles, currencies)
def __getLootboxBonusesData(rewards, postponeMegaToys=False):
preparationRewardsCurrency(rewards)
specialRewardType = ''
bonuses = []
alwaysVisibleBonuses = []
for rewardType, rewardValue in rewards.iteritems():
if rewardType == 'vehicles' and isinstance(rewardValue, list):
for vehicleData in rewardValue:
bonus = getNonQuestBonuses(rewardType, vehicleData)
if checkAndFillVehicles(bonus,
alwaysVisibleBonuses,
bonuses,
onlyVideoVehicle=False):
specialRewardType = LootCongratsTypes.CONGRAT_TYPE_VEHICLE
if rewardType == 'customizations':
bonus = getNonQuestBonuses(rewardType, rewardValue)
if checkAndFillCustomizations(bonus, alwaysVisibleBonuses,
bonuses):
specialRewardType = LootCongratsTypes.CONGRAT_TYPE_STYLE
if rewardType == 'tokens':
bonus = getNonQuestBonuses(rewardType, rewardValue)
if checkAndFillTokens(bonus, alwaysVisibleBonuses, bonuses):
specialRewardType = LootCongratsTypes.CONGRAT_TYPE_TANKMAN
if rewardType == 'blueprints':
bonuses += getNonQuestBonuses(rewardType,
rewardValue,
ctx={'isPacked': True})
if rewardType == 'slots' and 'vehicles' in rewards:
alwaysVisibleBonuses += getNonQuestBonuses(rewardType, rewardValue)
if rewardType == CurrentNYConstants.TOYS:
__fillToysBonuses(rewardValue, alwaysVisibleBonuses, bonuses,
postponeMegaToys)
bonuses += getNonQuestBonuses(rewardType, rewardValue)
return (bonuses, alwaysVisibleBonuses, specialRewardType)
def awardsFactory(items):
bonuses = []
for key, value in items.iteritems():
bonuses.extend(getNonQuestBonuses(key, value))
return bonuses
def showAdditionalRewardsTooltip(self, cmd):
bonuses = []
for key, value in cmd.rewards.iteritems():
bonuses.extend(getNonQuestBonuses(key, value))
self.__getTooltipMgr().onCreateWulfTooltip(TC.ADDITIONAL_REWARDS, [bonuses], cmd.x, cmd.y)
