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