def _applyCamouflageTTC(self):
if self.isPresent():
camo = first(self._c11nService.getCamouflages(vehicle=self.item).itervalues())
if camo:
outfit = self._itemsFactory.createOutfit(vehicleCD=self.item.descriptor.makeCompactDescr())
outfit.hull.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE).set(camo.intCD)
self.item.setCustomOutfit(first(camo.seasons), outfit)
def getConditionsData(self, main, add):
result = {}
if self._storage:
headerProgresses = self._storage.getHeaderProgresses()
bodyProgresses = self._storage.getBodyProgresses()
mainBodyProgresses, addBodyProgresses = [], []
if bodyProgresses:
for progress in bodyProgresses.itervalues():
if progress.isMain():
mainBodyProgresses.append(progress)
addBodyProgresses.append(progress)
if headerProgresses:
mainIterateProgressData, addIterateProgressData = {}, {}
mainHeaderProgress = findFirst(lambda p: p.isMain(),
headerProgresses.itervalues())
addHeaderProgress = findFirst(lambda p: not p.isMain(),
headerProgresses.itervalues())
if mainHeaderProgress:
mainIterateProgressData = self._getIterateData(
mainHeaderProgress, first(mainBodyProgresses))
if addHeaderProgress:
addIterateProgressData = self._getIterateData(
addHeaderProgress, first(addBodyProgresses))
if main and mainIterateProgressData:
result[self.MAIN_PROGRESS_DATA] = mainIterateProgressData
if add and addIterateProgressData:
result[self.ADD_PROGRESS_DATA] = addIterateProgressData
if main and self.MAIN_PROGRESS_DATA not in result:
result[self.MAIN_VALUE_DATA] = self._getValueData(
mainBodyProgresses)
if add and self.ADD_PROGRESS_DATA not in result:
result[self.ADD_VALUE_DATA] = self._getValueData(
addBodyProgresses)
return result
def _substituteBonuses(self, mainQuest=None):
if not self.event.isCompensationPossible():
return self.event.getBonuses()
else:
if mainQuest is None:
mainQuest = first(self.eventsCache.getQuests(lambda q: isMarathon(q.getID()) and q.getGroupID() == self.event.getGroupID()).values())
if mainQuest:
bonuses = self.event.getBonuses()
toCompensate = []
for token in mainQuest.accountReqs.getTokens():
if token.isAvailable():
toCompensate.append(token.getID())
if not toCompensate:
return bonuses
resultBonus = []
for bonus in bonuses:
if bonus.getName() == 'battleToken':
tokenID = first(bonus.getTokens())
if tokenID in toCompensate:
compensation = self.eventsCache.getCompensation(tokenID)
if compensation:
resultBonus.extend(compensation)
continue
resultBonus.append(bonus)
return resultBonus
return self.event.getBonuses()
return
def headerFormat(self, isMain=None):
result = []
if self._storage:
if isMain is not None:
progresses = self._storage.getHeaderProgresses(isMain)
if progresses:
result.append(first(progresses.values()).getHeaderData())
else:
result.append(self.__addDummyHeaderProgress(isMain))
else:
progresses = self._storage.getHeaderProgresses()
mainProgresses, addProgresses = [], []
for progress in progresses.itervalues():
if progress.isMain():
mainProgresses.append(progress)
addProgresses.append(progress)
if mainProgresses:
result.append(first(mainProgresses).getHeaderData())
else:
result.append(self.__addDummyHeaderProgress(isMain=True))
if addProgresses:
result.append(first(addProgresses).getHeaderData())
else:
result.append(self.__addDummyHeaderProgress(isMain=False))
return result
def _packTooltip(cls, bonus, vehicle, vehInfo):
compensation = bonus.compensation(vehicle, bonus)
return first(cls._packCompensationTooltip(
first(compensation), vehicle)) if bonus.compensation(
vehicle, bonus) else super(NYVehiclesBonusUIPacker,
cls)._packTooltip(
bonus, vehicle, vehInfo)
def getValue(cls, bonus, _):
value = bonus.getValue()
if isinstance(value, list):
value = first(value)
keys = value.keys()
value = str(first(keys))
return value
def _getCustomCrewComment(self):
crew = [tMan for _, tMan in sorted(self.__customCrew)]
crewLevel = first(crew).roleLevel
skills = [(tMan.skills[:] +
[_SimpleSkill()] if tMan.hasNewSkill else tMan.skills[:])
for tMan in crew]
notEmptySkills = [s for s in skills if s]
if not notEmptySkills:
return (_ms(
TOOLTIPS.VEHICLEPREVIEW_VEHICLEPANEL_INFO_HEADER_WITHCREW,
crewLevel), '', '')
if all((len(s) <= 1 for s in skills)):
firstSkill = first(notEmptySkills)[0]
icon = firstSkill.bigIconPath
skillName = ''
if _isSabatonBrotherhood(firstSkill):
skillName = 'sabaton_brotherhood'
elif _isOffspringBrotherhood(firstSkill):
skillName = 'offspring_brotherhood'
elif not firstSkill.name == 'new':
skillName = firstSkill.name
notEmptySkillsLen = len(notEmptySkills)
if notEmptySkillsLen == 1:
role = first((tMan.role for tMan in crew if tMan.hasNewSkill
)) if firstSkill.name == 'new' else first(
(tMan.role for tMan in crew if tMan.skills))
return (getCrewComment(firstSkill, crewLevel, role,
True), icon, skillName)
if notEmptySkillsLen == len(skills) and all(
(firstSkill.name == s[0].name for s in notEmptySkills)):
return (getCrewComment(firstSkill, crewLevel, '',
False), icon, skillName)
return (_ms(
TOOLTIPS.VEHICLEPREVIEW_VEHICLEPANEL_INFO_HEADER_CREW_ANYSKILLS,
crewLevel), '', '')
def getFrontLineSkills():
epicMetaGameCtrl = dependency.instance(IEpicBattleMetaGameController)
equipments = vehicles.g_cache.equipments()
result = []
for skillID, skillData in epicMetaGameCtrl.getAllSkillsInformation().iteritems():
skillInfo = dict()
firstSkill = first(skillData.levels.itervalues())
skillInfo['icon'] = firstSkill.icon
skillInfo['longDescr'] = firstSkill.longDescr
skillInfo['name'] = firstSkill.name
skillInfo['shortDescr'] = firstSkill.shortDescr
skillInfo['skillID'] = skillID
skillInfo['longFilterAlert'] = firstSkill.longFilterAlert
skillInfo['price'] = skillData.price
skillInfo['category'] = first(SlotCategories.ALL.intersection(skillData.tags))
skillInfo['params'] = dict()
for _, skillLevelData in skillData.levels.iteritems():
skillInfo.setdefault('levels', []).append(skillLevelData.eqID)
curLvlEq = equipments[skillLevelData.eqID]
for tooltipIdentifier in curLvlEq.tooltipIdentifiers:
paramName = _EPIC_GAME_PARAMS.get(skillLevelData.icon, {}).get(tooltipIdentifier)
if not paramName:
_logger.error('[ERROR] getFrontLineSkills: Failed to find tooltipInfo %(ttid)s.', {'ttid': tooltipIdentifier})
continue
param = createEpicParam(curLvlEq, tooltipIdentifier)
if param:
skillInfo['params'].setdefault(paramName, []).append(param)
skillInfo['params'].setdefault(paramName, [])
result.append(skillInfo)
return result
def getValue(cls, bonus):
giftTokenName = first(bonus.getTokens().keys())
offer = cls.__offersProvider.getOfferByToken(getOfferTokenByGift(giftTokenName))
if offer is None:
return bonus.getCount()
else:
gift = first(offer.getAllGifts())
return bonus.getCount() if gift is None else gift.giftCount * bonus.getCount()
def _generateOptions(self, ctx=None):
item = self.itemsCache.items.getItemByCD(self._intCD)
buyPriceVO = getItemPricesVO(item.getBuyPrice())
sellPriceVO = getItemPricesVO(item.getSellPrice())
inventoryCount = self._c11nView.getItemInventoryCount(item)
availableForSale = inventoryCount > 0 and item.getSellPrice(
) != ITEM_PRICE_EMPTY and not item.isRentable and not item.isHidden
style = self._c11nView.getModifiedStyle()
removeFromTankEnabled = style.intCD == item.intCD if style is not None else False
for outfit in (self._c11nView.getModifiedOutfit(season)
for season in SeasonType.COMMON_SEASONS):
if outfit.has(item):
removeFromTankEnabled = True
break
accountMoney = self.itemsCache.items.stats.money
availableForPurchase = not item.isHidden and not item.getBuyPrice(
) == ITEM_PRICE_EMPTY and item.getBuyPrice().price <= accountMoney
showAlert = len(sellPriceVO[0]) > 1
tooltipVO = None
if showAlert:
tooltipVO = packActionTooltipData(
ACTION_TOOLTIPS_TYPE.ITEM, str(item.intCD), False,
item.sellPrices.getSum().price,
item.sellPrices.getSum().defPrice)
price = sellPriceVO[0]['price']
sellPriceVO[0] = {}
sellPriceVO[0]['price'] = price
return [
self._makeItem(
CustomizationOptions.BUY,
MENU.cst_item_ctx_menu(CustomizationOptions.BUY), {
'data': {
'price': first(buyPriceVO)
} if availableForPurchase else None,
'enabled': availableForPurchase
}, None, 'CurrencyContextMenuItem'),
self._makeSeparator(),
self._makeItem(
CustomizationOptions.SELL,
MENU.cst_item_ctx_menu(CustomizationOptions.SELL), {
'data': {
'price': first(sellPriceVO)
} if availableForSale else None,
'enabled': availableForSale,
'showAlert': showAlert,
'tooltipVO': tooltipVO
}, None, 'CurrencyContextMenuItem'),
self._makeSeparator(),
self._makeItem(
CustomizationOptions.REMOVE_FROM_TANK,
MENU.cst_item_ctx_menu(CustomizationOptions.REMOVE_FROM_TANK),
{'enabled': removeFromTankEnabled})
]
def __onPick(self, args):
rewardModel = self.viewModel.rewards.getItem(int(args['index']))
selectableCrewbook = first([
item for item in self.__reward
if item.getName() == 'selectableCrewbook'
])
reward = first([
item for item in selectableCrewbook.getItems()
if item.name == rewardModel.getName()
])
showMapboxRewardChoice(reward)
def updateVisibleTabsList(self, visibleTabs):
for seasonType in SeasonType.COMMON_SEASONS:
self.__visibleTabs[seasonType] = sorted(
list(visibleTabs[seasonType]),
key=lambda it: TYPES_ORDER.index(TABS_ITEM_MAPPING[it]))
if self._mode == C11nMode.STYLE:
tabIndex = C11nTabs.STYLE
self._lastTab = first(self.visibleTabs, -1)
else:
tabIndex = first(self.visibleTabs, -1)
self._lastTab = tabIndex
self.tabChanged(tabIndex)
def getLobbyHeaderTabCounter(self):
counterValue = None
alias = None
def containsLobbyHeaderTabCounter(a):
return any((step.get('name') == 'LobbyHeaderTabCounterModification'
for step in a.getData().get('steps', [])))
action = first(self.getActions(containsLobbyHeaderTabCounter).values())
if action is not None:
counterValue = first(
(m.getCounterValue() for m in action.getModifiers()))
alias = first((m.getAlias() for m in action.getModifiers()))
return (alias, counterValue)
def __updateData(self, club):
seasonFilters = []
seasonFilters.extend(map(attrgetter('name'), self._seasons))
achievements = _makeAchievements(club.getTotalDossier(), club)
self.as_setDataS({
'awardsText':
text_styles.highTitle(CYBERSPORT.STATICFORMATIONSTATSVIEW_AWARDS),
'noAwardsText':
text_styles.main(CYBERSPORT.STATICFORMATIONSTATSVIEW_NOAWARDS),
'achievements':
achievements,
'statsGroupWidth':
_STATS_GROUP_WIDTH,
'seasonFilterName':
text_styles.main(CYBERSPORT.STATICFORMATIONSTATSVIEW_SEASONFILTER),
'selectedSeason':
0,
'seasonFilters':
seasonFilters,
'seasonFilterEnable':
len(seasonFilters) > 1,
'noAwards':
len(achievements) < 1
})
self.__setStats(first(self._seasons).dossier.getTotalStats())
def getProgectionDecalAspect(slotDescriptor):
formfactor = first((tag for tag in slotDescriptor.tags
if tag.startswith(ProjectionDecalFormTags.PREFIX)))
if formfactor not in FORMFACTOR_ASPECT_RATIO:
_logger.warning('Missing aspect ratio for forfactor: %s', formfactor)
return 1.0
return FORMFACTOR_ASPECT_RATIO[formfactor]
def _getLastFutureCycleRentInfo(self):
now = time_utils.getCurrentLocalServerTimestamp()
for seasonType, rentTypes in self.seasonRent.iteritems():
currentSeason = self.seasonsController.getCurrentSeason(seasonType)
if currentSeason:
currentCycleID = currentSeason.getCycleID(
) or currentSeason.getLastActiveCycleID(now)
futureCycleRents = first(
sorted([
item[0] for item in rentTypes
if item[1] == SeasonRentDuration.SEASON_CYCLE
and item[0] > currentCycleID
],
reverse=True))
if futureCycleRents:
lastFutureCycleRentID = futureCycleRents
cycleInfo = currentSeason.getCycleInfo(
lastFutureCycleRentID)
if cycleInfo:
return SeasonRentInfo(seasonType,
lastFutureCycleRentID,
SeasonRentDuration.SEASON_CYCLE,
cycleInfo.endDate)
return None
def __init__(self, *args, **kwargs):
settings = ViewSettings(R.views.lobby.battle_royale.BattleResultView())
settings.flags = ViewFlags.LOBBY_TOP_SUB_VIEW
settings.model = BattleResultViewModel()
settings.args = args
settings.kwargs = kwargs
super(BrBattleResultsViewInLobby, self).__init__(settings)
self.__arenaUniqueID = kwargs.get('ctx', {}).get('arenaUniqueID')
if self.__arenaUniqueID is None:
raise SoftException(
'There is not arenaUniqueID in battleResults context')
self.__data = self.__battleResults.getResultsVO(self.__arenaUniqueID)
if not self.__data:
raise SoftException('There is not battleResults')
commonData = self.__data.get(BRSections.COMMON)
if commonData is None:
raise SoftException('There is no common info in battle results')
vehicleInfo = first(commonData.get('playerVehicles', []))
self.__isObserverResult = vehicleInfo.get(
'isObserver', False) if vehicleInfo else False
self.__arenaBonusType = self.__data[BRSections.COMMON].get(
'arenaBonusType', 0)
self.__tooltipsData = {}
self.__tooltipParametersCreator = self.__getTooltipParametersCreator()
return
def validateAnswers(self, answers, oldAnswers):
groupsAnswers = self.__answers.responseGroups if self.__answers is not None else None
if groupsAnswers is None:
return answers
else:
newChoices = first(answers, {}).get('choices', [])
if any(
[set(newChoices).issubset(group) for group in groupsAnswers]):
return answers
newChoice = set(newChoices) - set(
first(oldAnswers, {}).get('choices', []))
requiredGroup = findFirst(
lambda group: newChoice.issubset(set(group)), groupsAnswers,
[])
answers[0]['choices'] = set(requiredGroup).intersection(newChoices)
return answers
def getFormattedValue(self, formatter=None):
valuesSet = set(self.effectValue)
if len(valuesSet) == 1:
strValue = '{}%'.format(first(valuesSet))
else:
strValue = '{}%-{}%'.format(min(valuesSet), max(valuesSet))
return formatter(strValue) if formatter is not None else strValue
def __getFinalQuestAwardsVO(self, quest):
tokenAward = findFirst(lambda q: q.getName() == 'completionTokens',
quest.getBonuses(isMain=True))
formatter = getPersonalMissionAwardsFormatter()
mainAwards = formatter.getFormattedBonuses(
(tokenAward, ),
size=COMPLETION_TOKENS_SIZES.HUGE,
obtainedImage=RES_ICONS.
MAPS_ICONS_PERSONALMISSIONS_OPERATIONS_STATES_COMPLETED,
obtainedImageOffset=0)
chainID = self.getChainID()
operationID = self.getOperationID()
mainAwardTextID = chainID
if self.getBranch() == PM_BRANCH.REGULAR:
if chainID == HT_CHAIN_ID and (operationID == OPERATION_ID_T55A
or operationID
== OPERATION_ID_OBJECT_260):
mainAwardTextID = MAIN_AWARD_TEXT_ID_HULL
mainAwardText = _ms(_MAIN_AWARD_TEXT[mainAwardTextID])
else:
if chainID == ALLIANCE_CHAIN_ID and (
operationID == OPERATION_ID_CHIMERA
or operationID == OPERATION_ID_OBJECT_279):
mainAwardTextID = MAIN_AWARD_TEXT_PM2_ID_HULL
mainAwardText = _ms(_MAIN_AWARD_TEXT_PM2[mainAwardTextID])
return {'mainAwardText': mainAwardText, 'mainAward': first(mainAwards)}
def getQuestByTokenAndBonus(quests, tokenFinder=None, bonusFinder=None):
"""
Finds first quest that matches finder requirements
"""
return first(
getQuestsByTokenAndBonus(quests, tokenFinder,
bonusFinder).itervalues())
def compose(self):
"""
returns result of composition. Result is list, because theoretically collection can be composed in couple of
actions. But mostly in this list will be one action. By default we just return first action. It works fine if
actions appear on UI looking completely the same, so we can't distinguish between them.
"""
return [first(self._actions)]
def _markVisited(self, tabIdx, model):
if not self.__proxyMissionsPage or self.__proxyMissionsPage.getCurrentTabAlias(
) != QUESTS_ALIASES.MISSIONS_PREMIUM_VIEW_PY_ALIAS:
return
seenQuests = []
if tabIdx == DailyTabs.QUESTS:
dailyQuests = self.eventsCache.getDailyQuests().values()
seenQuests = dailyQuests
elif tabIdx == DailyTabs.PREMIUM_MISSIONS:
if _isPremiumPlusAccount():
premiumQuests = self.eventsCache.getPremiumQuests().values()
seenQuests = premiumQuests
with settings.dailyQuestSettings() as dq:
if isPremiumQuestsEnable(
) and not dq.premMissionsTabDiscovered:
dq.onPremMissionsTabDiscovered()
model.setPremMissionsTabDiscovered(
dq.premMissionsTabDiscovered)
for seenQuest in seenQuests:
self.eventsCache.questsProgress.markQuestProgressAsViewed(
seenQuest.getID())
if isEpicQuestEnabled():
epicQuest = self.eventsCache.getDailyEpicQuest()
if epicQuest:
seenQuests.append(epicQuest)
dqToken = first(
(token for token in epicQuest.accountReqs.getTokens()
if token.isDailyQuest()))
if dqToken:
self.itemsCache.items.tokens.markTokenProgressAsViewed(
dqToken.getID())
settings.visitEventsGUI(seenQuests)
self.__updateMissionsNotification()
def getIconApplied(self, component):
if component:
palette = self.palettes[component.palette]
else:
palette = first(self.palettes)
return camoIconTemplate(self.texture, _CAMO_SWATCH_WIDTH,
_CAMO_SWATCH_HEIGHT, palette)
def notifyNonRecruitCount(self):
if self.__bootCampController.isInBootcamp():
return
recruits = getAllRecruitsInfo(sortByExpireTime=True)
recruitsCount = len(recruits)
if recruitsCount == self._cachedRecruitCount:
return
self._cachedRecruitCount = recruitsCount
time = ''
message = ''
rMessage = R.strings.messenger.serviceChannelMessages
if recruitsCount <= 0:
if self._isFirstShow:
self._isFirstShow = False
return
message = rMessage.recruitReminderNotRemain.text()
else:
time = first(recruits).getExpiryTime()
if time:
message = rMessage.recruitReminder.text()
else:
message = rMessage.recruitReminderTermless.text()
msgPrLevel = NotificationPriorityLevel.LOW
lc = self.__loginManager.getPreference('loginCount')
if lc == _INCREASE_LIMIT_LOGIN:
msgPrLevel = NotificationPriorityLevel.MEDIUM
msgType = SystemMessages.SM_TYPE.RecruitReminder
SystemMessages.pushMessage(
backport.text(message, count=recruitsCount, date=time), msgType,
msgPrLevel)
self._isFirstShow = False
def invalidateArenaInfo(self):
isPersonalMissionsEnabled = self.lobbyContext.getServerSettings().isPersonalMissionsEnabled
if not self.__isInited:
lastSelectedBranch = AccountSettings.getSettings(LAST_SELECTED_PM_BRANCH)
personalMissions = self.eventsCache.getPersonalMissions()
selectedMissionsIDs = self.__battleCtx.getSelectedQuestIDs()
selectedMissionsInfo = self.__battleCtx.getSelectedQuestInfo() or {}
if selectedMissionsIDs:
missions = personalMissions.getAllQuests()
for missionID in selectedMissionsIDs:
mission = missions.get(missionID)
if mission and not mission.isDisabled() and isPersonalMissionsEnabled(mission.getQuestBranch()):
pqState = selectedMissionsInfo.get(missionID, (0, PM_STATE.NONE))[1]
mission.updatePqStateInBattle(pqState)
self.__inProgressQuests[missionID] = mission
generalQuestID = mission.getGeneralQuestID()
if mission.getPMType().branch == lastSelectedBranch:
self.__selectedQuest = mission
self.__storage[generalQuestID] = BattleProgressStorage(generalQuestID, mission.getConditionsConfig(), mission.getConditionsProgress(), mission.isOneBattleQuest())
if self.__selectedQuest is None:
self.__selectedQuest = first(self.__inProgressQuests.itervalues())
self.__updateTimerConditions(sendDiff=False)
self.__isInited = True
if self.__selectedQuest:
self.__lastSelectedQuestID = self.__selectedQuest.getID()
self.onQuestProgressInited()
return
def _packBlocks(self, operationID, vehicleType):
pmController = dependency.instance(IEventsCache).personalMissions
operation = pmController.getOperations()[operationID]
chainID, _ = operation.getChainByVehicleType(vehicleType)
finalQuest = operation.getFinalQuests()[chainID]
bonus = findFirst(lambda q: q.getName() == 'completionTokens',
finalQuest.getBonuses('tokens'))
formattedBonus = first(CompletionTokensBonusFormatter().format(bonus))
operationTitle = str(operation.getVehicleBonus().userName).replace(
' ', ' ')
if finalQuest.isCompleted():
statusText = self.__getObtainedStatus()
elif pmController.mayPawnQuest(finalQuest):
statusText = self.__getAvailableStatus(finalQuest.getPawnCost())
else:
statusText = self.__getNotObtainedStatus()
vehIcon = RES_ICONS.vehicleTypeInactiveOutline(vehicleType)
blocks = [
formatters.packImageTextBlockData(
title=text_styles.highTitle(formattedBonus.userName),
desc=text_styles.standard(
_ms(PERSONAL_MISSIONS.OPERATIONTITLE_TITLE,
title=operationTitle)),
img=formattedBonus.getImage(AWARDS_SIZES.BIG),
imgPadding=formatters.packPadding(right=20),
txtPadding=formatters.packPadding(top=10)),
formatters.packBuildUpBlockData(
[
formatters.packImageTextBlockData(
title=text_styles.main(
_ms(PERSONAL_MISSIONS.TANKMODULETOOLTIPDATA_INFO,
vehName=text_styles.neutral(operationTitle))),
img=RES_ICONS.MAPS_ICONS_LIBRARY_ATTENTIONICONFILLED,
imgPadding=formatters.packPadding(
left=8, right=10, top=2))
],
linkage=BLOCKS_TOOLTIP_TYPES.
TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE,
padding=formatters.packPadding(top=-7, bottom=-3))
]
if not finalQuest.isCompleted():
blocks.append(
formatters.packBuildUpBlockData([
formatters.packTextBlockData(text_styles.middleTitle(
PERSONAL_MISSIONS.TANKMODULETOOLTIPDATA_HELP_TITLE),
padding=formatters.
packPadding(bottom=4)),
formatters.packImageTextBlockData(title=text_styles.main(
_ms(PERSONAL_MISSIONS.TANKMODULETOOLTIPDATA_HELP_BODY,
vehType=_ms(
PERSONAL_MISSIONS.chainNameByVehicleType(
vehicleType)))),
img=vehIcon,
imgPadding=formatters.
packPadding(right=2))
]))
blocks.append(
formatters.packAlignedTextBlockData(
text=statusText, align=BLOCKS_TOOLTIP_TYPES.ALIGN_CENTER))
return blocks
def __canBeSelected(cls, toyType, isSelected):
megaDecoration = first(cls.__nyController.getToysByType(toyType))
hasDecoration = megaDecoration is not None and megaDecoration.getCount() > 0
currentCount = cls.__itemsCache.items.festivity.getShardsCount()
craftCost = cls.__craftCtrl.calculateMegaToyCraftCost()
ableToCraft = currentCount >= craftCost
return (hasDecoration or ableToCraft) and not isSelected
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 __getPreviewOutfitByStyle(self, style):
return style.getOutfit(
first(style.seasons),
vehicleCD=self.item.descriptor.makeCompactDescr(
)) if self.isPresent(
) and not self.item.isOutfitLocked and style.mayInstall(
self.item) else None
def __updateData(self, club):
seasonFilters = []
seasonFilters.extend(map(attrgetter('name'), self._seasons))
achievements = _makeAchievements(club.getTotalDossier(), club)
self.as_setDataS({'awardsText': text_styles.highTitle(CYBERSPORT.STATICFORMATIONSTATSVIEW_AWARDS),
'noAwardsText': text_styles.main(CYBERSPORT.STATICFORMATIONSTATSVIEW_NOAWARDS),
'achievements': achievements,
'statsGroupWidth': _STATS_GROUP_WIDTH,
'seasonFilterName': text_styles.main(CYBERSPORT.STATICFORMATIONSTATSVIEW_SEASONFILTER),
'selectedSeason': 0,
'seasonFilters': seasonFilters,
'seasonFilterEnable': len(seasonFilters) > 1,
'noAwards': len(achievements) < 1})
self.__setStats(first(self._seasons).dossier.getTotalStats())
def __getBattleQuestsVO(self, vehicle):
""" Get part of VO responsible for battle quests flag.
"""
bqState, quests = _findBattleQuestsState(self._eventsCache, vehicle)
if bqState == WIDGET_BQ_STATE.AVAILABLE:
labelState = LABEL_STATE.ACTIVE
self._battleQuestId = first(quests).getID()
else:
labelState = LABEL_STATE.INACTIVE
self._battleQuestId = None
ctx = {'total': len(quests)}
return {'commonQuestsLabel': _ms(MENU.hangarHeaderBattleQuestsLabel(labelState), **ctx),
'commonQuestsIcon': RES_ICONS.questsStateIconOutline(bqState),
'commonQuestsTooltip': _getBattleQuestsTooltip(bqState, **ctx),
'commonQuestsEnable': bqState == WIDGET_BQ_STATE.AVAILABLE}
def isRequestValid(self, requestTypeID):
if requestTypeID in self.__restrictions:
return error(first(self.__restrictions[requestTypeID]).getReasonString())
return success()
def selectedPQType(self):
if self.__selectedPQType not in getEnabledPQTabs():
self.__selectedPQType = first(getEnabledPQTabs(), None)
return self.__selectedPQType
def getNumberOfTeam(self, enemy = False):
if enemy:
return first(self.getEnemyTeams())
else:
return self.__playerTeam
