def __getRankedOverrides(self, quest):
header = body = ''
isLeagues = self.__rankedController.isAccountMastered()
isAnyPrimeNow = self.__rankedController.hasAvailablePrimeTimeServers()
isAnyPrimeLeftTotal = self.__rankedController.hasPrimeTimesTotalLeft()
isAnyPrimeLeftNext = self.__rankedController.hasPrimeTimesNextDayLeft()
if not isAnyPrimeLeftTotal or not isAnyPrimeLeftNext and quest.isCompleted() and quest.bonusCond.isDaily():
header = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.header.seasonEnd())
body = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.body.seasonEnd.default())
season = self.__rankedController.getCurrentSeason()
if season is not None:
seasonEnd = time_utils.getTimeDeltaFromNowInLocal(time_utils.makeLocalServerTime(season.getEndDate()))
timeRes = R.strings.ranked_battles.quests.tooltip.unavailable.body.seasonEnd
body = backport.getTillTimeStringByRClass(seasonEnd, timeRes)
elif not isLeagues:
header = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.header.notInLeagues())
body = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.body.notInLeagues())
elif not isAnyPrimeNow:
header = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.header.allServersPrime())
body = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.body.allServersPrime())
if body and header:
body = text_styles.main(body)
bullet = backport.text(R.strings.tooltips.quests.unavailable.bullet())
return [formatters.packTextBlockData(text=text_styles.highTitle(header)), formatters.packBuildUpBlockData(self.__getList([{'text': body,
'bullet': bullet}]), linkage=BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE), self.__getBootom(backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.bottom()))]
else:
return []
def getRankedMainSeasonOnHeader(season, itemID):
title = backport.text(R.strings.ranked_battles.rankedBattle.title())
leftSideText = ''
rightSideText = ''
tooltip = TOOLTIPS_CONSTANTS.RANKED_CALENDAR_DAY_INFO
if itemID in _EMPTY_WEB_PAGES:
title = ''
tooltip = ''
elif itemID == RANKEDBATTLES_CONSTS.RANKED_BATTLES_INFO_ID:
leftSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.infoPage.header())
tooltip = ''
elif season is not None:
startDate = season.getStartDate()
endDate = season.getEndDate()
timeDelta = time_utils.getTimeDeltaFromNowInLocal(
time_utils.makeLocalServerTime(endDate))
if timeDelta > time_utils.ONE_WEEK:
leftSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.date.period(),
start=backport.getLongDateFormat(startDate),
finish=backport.getLongDateFormat(endDate))
else:
leftSideText = backport.getTillTimeStringByRClass(
timeDelta, R.strings.ranked_battles.rankedBattleMainView.date)
rightSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.season(),
season=season.getUserName())
return {
'title': title,
'leftSideText': leftSideText,
'rightSideText': rightSideText,
'tooltip': tooltip
}
def _buildTooltip(self, peripheryID):
if not self.getTimeLeft():
tooltipStr = text_styles.expText(
backport.text(R.strings.mapbox.primeTimeView.endOfCycle(),
server=self.getName()))
else:
timeStr = text_styles.neutral(
backport.getTillTimeStringByRClass(
self.getTimeLeft(),
R.strings.menu.Time.timeValueShort.noLeadingZeroes))
if self._getIsAvailable():
tooltipStr = text_styles.expText(
backport.text(
R.strings.mapbox.primeTimeView.serverTooltip(),
server=self.getName(),
time=timeStr))
else:
tooltipStr = text_styles.expText(
backport.text(R.strings.mapbox.primeTimeView.
serverUnavailableTooltip(),
time=timeStr,
server=self.getName()))
return {
'tooltip': tooltipStr,
'specialArgs': [],
'specialAlias': None,
'isSpecial': None
}
def __getTimeText(self, serverInfo):
if serverInfo is None:
return ''
else:
controller = self._getController()
timeLeft = serverInfo.getTimeLeft()
isAvailable = serverInfo.isAvailable()
serverName = serverInfo.getShortName()
currentSeason = controller.getCurrentSeason()
if currentSeason and not timeLeft:
return backport.text(
R.strings.mapbox.primeTimeView.status.seasonDisabled(),
season=controller.getCurrentSeason().getUserName(),
server=serverName)
timeLeftStr = backport.getTillTimeStringByRClass(
timeLeft, R.strings.menu.Time.timeValueShort.noLeadingZeroes)
if isAvailable:
resId = R.strings.mapbox.primeTimeView.status.primeIsAvailable(
)
else:
resId = R.strings.mapbox.primeTimeView.status.primeWillBeAvailable(
)
return backport.text(resId,
time=text_styles.neutral(timeLeftStr),
server=serverName)
def _getTillEndBlock(self, timeLeft):
return formatters.packTextBlockData(
text_styles.main(
backport.text(
R.strings.ranked_battles.selectorTooltip.tillEnd())) +
' ' + text_styles.stats(
backport.getTillTimeStringByRClass(
timeLeft, R.strings.menu.headerButtons.battle.types.ranked.
availability)))
def __getTillEndBlock(self, timeLeft):
res = ''.join([
text_styles.main(
backport.text(
R.strings.ranked_battles.selectorTooltip.tillEnd())), ' ',
text_styles.stats(
backport.getTillTimeStringByRClass(
timeLeft, R.strings.menu.headerButtons.battle.types.ranked.
availability))
])
return formatters.packTextBlockData(
text=res, blockWidth=self.__TOOLTIP_MIN_WIDTH)
def getTillBlock(isSeasonStarted, tillEnd, timeLeft, leftPadding=0):
if isSeasonStarted:
tillStartStr = R.strings.tooltips.battleTypes.battleRoyale.tillStart
tillEndStr = R.strings.tooltips.battleTypes.battleRoyale.tillEnd
else:
tillStartStr = R.strings.tooltips.battleTypes.battleRoyale.tillStartCycle
tillEndStr = R.strings.tooltips.battleTypes.battleRoyale.tillEndCycle
return formatters.packTextBlockData(
text_styles.main(
backport.text(tillEndStr() if tillEnd else tillStartStr())) + ' ' +
text_styles.stats(
backport.getTillTimeStringByRClass(
timeLeft, R.strings.menu.headerButtons.battle.types.ranked.
availability)),
padding=formatters.packPadding(left=leftPadding))
def __packDescription(self, quests, season, isLeagues, isAnyPrimeNow,
isAnyPrimeLeftTotal):
resShortCut = R.strings.ranked_battles.questsTooltip
isAllCompleted = all((q.isCompleted() for q in quests))
isAnyPrimeLeftNextDay = self.__rankedController.hasPrimeTimesNextDayLeft(
)
icon = icons.markerBlocked()
timeDelta = time_utils.getTimeDeltaFromNowInLocal(
time_utils.makeLocalServerTime(season.getEndDate()))
timeDeltaStr = text_styles.stats(
backport.getTillTimeStringByRClass(timeDelta,
resShortCut.available))
text = text_styles.main(
backport.text(resShortCut.available(), timeDelta=timeDeltaStr))
if not isAnyPrimeLeftTotal:
text = text_styles.error(
backport.getTillTimeStringByRClass(
timeDelta, resShortCut.unavailable.seasonEnd))
elif not isLeagues:
text = text_styles.error(
backport.text(resShortCut.unavailable.notInLeagues()))
elif not isAllCompleted:
if isAnyPrimeNow:
icon = icons.inProgress(vspace=-3)
else:
text = text_styles.error(
backport.text(resShortCut.unavailable.allServersPrime()))
elif not isAnyPrimeLeftNextDay:
icon = icons.inProgress(vspace=-3)
else:
icon = icons.clockGold()
timeDelta = EventInfoModel.getDailyProgressResetTimeDelta()
text = text_styles.tutorial(
backport.getTillTimeStringByRClass(timeDelta,
resShortCut.cooldown))
return text_styles.concatStylesWithSpace(icon, text)
def __updateTimer(self):
timeTill = self.__rankedController.getTimer()
if self.__state == RANKEDBATTLES_CONSTS.INTRO_STATE_BEFORE_SEASON:
self.as_setBeforeSeasonBlockDataS({
'title':
text_styles.highlightText(
backport.text(R.strings.ranked_battles.introPage.alert.
beforeSeason())),
'time':
text_styles.highlightText(
backport.getTillTimeStringByRClass(
timeTill,
R.strings.ranked_battles.introPage.timeLeft)),
'iconSrc':
backport.image(R.images.gui.maps.icons.library.ClockIcon_1())
})
def __getTimer(self, timeLeft):
timer = ''
if self.__notifierState == NotifierStates.ACTIVE_PHASE_FINISH:
timer = getTillTimeStringByRClass(timeLeft, R.strings.ten_year_countdown.entry_point.finish_timer)
elif self.__notifierState in (NotifierStates.NEXT_ACTIVE_PHASE_START, NotifierStates.EVENT_FINISH):
if self.__notifierState == NotifierStates.NEXT_ACTIVE_PHASE_START:
timerClass = R.strings.ten_year_countdown.entry_point.start_timer
else:
timerClass = R.strings.ten_year_countdown.entry_point.event_finish_timer
if timeLeft >= time_utils.ONE_DAY:
timeLeft = time.gmtime(timeLeft - time_utils.ONE_DAY).tm_yday
timerRes = timerClass.days()
else:
timeLeft = time.gmtime(timeLeft).tm_hour
timerRes = timerClass.lessDay()
timer = backport.text(timerRes, value=timeLeft)
return timer
def __initControls(self):
headers = [packHeaderColumnData('nationID', 40, 40, tooltip=DIALOGS.TRADEINPOPOVER_SORTING_NATION, icon=RES_ICONS.MAPS_ICONS_FILTERS_NATIONS_ALL, enabled=True),
packHeaderColumnData('typeIndex', 40, 40, tooltip=DIALOGS.TRADEINPOPOVER_SORTING_VEHTYPE, icon=RES_ICONS.MAPS_ICONS_FILTERS_TANKS_ALL, enabled=True),
packHeaderColumnData('level', 40, 40, tooltip=DIALOGS.TRADEINPOPOVER_SORTING_VEHLVL, icon=RES_ICONS.MAPS_ICONS_FILTERS_LEVELS_LEVEL_ALL, enabled=True),
packHeaderColumnData('shortUserName', 152, 40, label=DIALOGS.TRADEINPOPOVER_SORTING_VEHNAME_HEADER, tooltip=DIALOGS.TRADEINPOPOVER_SORTING_VEHNAME, enabled=True, verticalTextAlign='center', showSeparator=False)]
if not self._nyController.isPostEvent():
description = ''
cooldown = self.__slot.getDefaultSlotCooldown()
if cooldown > 0:
timeLeft = backport.getTillTimeStringByRClass(cooldown, R.strings.menu.Time.timeValueShort)
description = backport.text(R.strings.ny.vehiclesView.selectVehiclePopover.description(), time=text_styles.stats(timeLeft))
else:
description = backport.text(R.strings.ny.vehiclesView.selectVehiclePopover.postEvent.description())
self.as_setInitDataS({'title': backport.text(R.strings.ny.vehiclesView.selectVehiclePopover.header(), level=self.__slot.getLevelStr()),
'description': description,
'defaultSortField': 'level',
'defaultSortDirection': 'descending',
'tableHeaders': headers,
'filters': self.initFilters()})
def getDisplayableData(self, peripheryID):
hostsList = g_preDefinedHosts.getSimpleHostsList(g_preDefinedHosts.hostsWithRoaming(), withShortName=True)
serverName = ''
for _, serverData in enumerate(hostsList):
_, serverName, _, _, pID = serverData
if pID == peripheryID:
break
timeLeftStr = '-'
isNow = False
primeTime = self.__rankedController.getPrimeTimes().get(peripheryID)
if primeTime:
currentCycleEnd = self.__rankedController.getCurrentSeason().getCycleEndDate()
isNow, timeLeft = primeTime.getAvailability(time_utils.getCurrentLocalServerTimestamp(), currentCycleEnd)
timeLeftStr = backport.getTillTimeStringByRClass(timeLeft, R.strings.ranked_battles.status.timeLeft)
formatedTime = text_styles.neutral(timeLeftStr)
if isNow:
descriptionID = R.strings.ranked_battles.primeTime.tooltip.server.available.untill()
else:
descriptionID = R.strings.ranked_battles.primeTime.tooltip.server.unavailable.inTime()
sName = backport.text(R.strings.ranked_battles.primeTime.tooltip.server.onServer(), server=serverName)
description = backport.text(descriptionID, time=formatedTime)
return {'body': '{}\n{}'.format(sName, description)}
def _getAlertMessage():
rankedController = dependency.instance(IRankedBattlesController)
if not rankedController.hasSuitableVehicles():
minLvl, maxLvl = rankedController.getSuitableVehicleLevels()
alertStr = backport.text(R.strings.ranked_battles.alertMessage.unsuitableVehicles(), levels=toRomanRangeString(range(minLvl, maxLvl + 1)))
return _AlertMessage(AlertTypes.VEHICLE, alertStr, True)
connectionMgr = dependency.instance(IConnectionManager)
hasAvailableServers = rankedController.hasAvailablePrimeTimeServers()
hasConfiguredServers = rankedController.hasConfiguredPrimeTimeServers()
status, _, _ = rankedController.getPrimeTimeStatus()
if hasAvailableServers:
if status in (PrimeTimeStatus.NOT_SET, PrimeTimeStatus.FROZEN):
alertStr = backport.text(R.strings.ranked_battles.alertMessage.unsuitablePeriphery(), serverName=connectionMgr.serverUserNameShort)
return _AlertMessage(AlertTypes.PRIME, alertStr, True)
alertStr = backport.text(R.strings.ranked_battles.alertMessage.somePeripheriesHalt(), serverName=connectionMgr.serverUserNameShort)
return _AlertMessage(AlertTypes.PRIME, alertStr, True)
currSeason = rankedController.getCurrentSeason()
currTime = time_utils.getCurrentLocalServerTimestamp()
if currSeason:
if status in (PrimeTimeStatus.NOT_SET, PrimeTimeStatus.FROZEN):
alertStr = backport.text(R.strings.ranked_battles.alertMessage.unsuitablePeriphery(), serverName=connectionMgr.serverUserNameShort)
return _AlertMessage(AlertTypes.PRIME, alertStr, hasConfiguredServers)
timeLeft = rankedController.getTimer()
timeLeftStr = backport.getTillTimeStringByRClass(timeLeft, R.strings.ranked_battles.status.timeLeft)
seasonsChangeTime = currSeason.getEndDate()
if seasonsChangeTime and currTime + timeLeft >= seasonsChangeTime:
alertStr = backport.text(R.strings.ranked_battles.alertMessage.seasonFinished(), seasonName=currSeason.getUserName())
return _AlertMessage(AlertTypes.SEASON, alertStr, False)
if connectionMgr.isStandalone():
key = R.strings.ranked_battles.alertMessage.singleModeHalt()
else:
key = R.strings.ranked_battles.alertMessage.allPeripheriesHalt()
alertStr = backport.text(key, time=timeLeftStr)
return _AlertMessage(AlertTypes.PRIME, alertStr, False)
_logger.warning('This codepoint should not be reached')
return _AlertMessage(AlertTypes.SEASON, '', False)
def statusDeltaFormatter(cls, delta):
return backport.getTillTimeStringByRClass(delta,
cls._RES_ROOT.timeLeft)
def deltaFormatter(cls, delta):
return text_styles.neutral(
backport.getTillTimeStringByRClass(delta, cls._RES_ROOT.timeLeft))
def __packMainBlock(self):
header = backport.text(R.strings.tooltips.battleTypes.battleRoyale.header())
body = backport.text(R.strings.tooltips.battleTypes.battleRoyale.body2())
currentCycleInfo = self._battleController.getCurrentCycleInfo()
if currentCycleInfo[1]:
timeLeft = time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(currentCycleInfo[0]))
scheduleStr = ' '.join((backport.text(R.strings.tooltips.battleTypes.battleRoyale.tillEnd()), backport.getTillTimeStringByRClass(timeLeft, R.strings.menu.headerButtons.battle.types.ranked.availability)))
body = '{}\n\n\n{}'.format(scheduleStr, backport.text(R.strings.tooltips.battleTypes.battleRoyale.body2()))
background = backport.image(R.images.gui.maps.icons.battleRoyale.backgrounds.widget_tooltip_background())
return formatters.packImageTextBlockData(title=text_styles.middleTitle(header), txtPadding=formatters.packPadding(top=16, left=20), desc=text_styles.main(body), descPadding=formatters.packPadding(top=16, left=20), txtOffset=1, txtGap=-1, img=background)