def _populate(self):
super(CyberSportUnitsListView, self)._populate()
self.addListener(CSVehicleSelectEvent.VEHICLE_SELECTED, self.__onVehiclesSelectedTeams)
self.updateSelectedVehicles()
unit_ext.initListReq(self._selectedVehicles).start(self.__onUnitsListUpdated)
g_clientUpdateManager.addCallbacks({'inventory.1': self.__onVehiclesChanged})
self.as_setSearchResultTextS(i18n.makeString(CYBERSPORT.WINDOW_UNITLISTVIEW_FOUNDTEAMS))
settings = self.unitFunctional.getRosterSettings()
self._updateVehiclesLabel(int2roman(settings.getMinLevel()), int2roman(settings.getMaxLevel()))
def __makeData(self):
self.__makeMainVO()
self.__setReadyStatus()
self.__setTimerDelta()
self.__updateDirections()
self.__updateHeaderTeamSection()
self.__requestMineClanEmblem()
self.__requestEnemyClanEmblem()
self._updateVehiclesLabel(int2roman(1), int2roman(self.__battle.additionalData.division))
def _populate(self):
super(StaticFormationUnitView, self)._populate()
self.startClubListening(self.__clubDBID)
settings = self.unitFunctional.getRosterSettings()
self._updateVehiclesLabel(int2roman(settings.getMinLevel()), int2roman(settings.getMaxLevel()))
self.__updateHeader()
_, unit = self.unitFunctional.getUnit()
self.as_setLegionnairesCountS(False, _ms(CYBERSPORT.STATICFORMATION_UNITVIEW_LEGIONNAIRESTOTAL, cur=unit.getLegionaryCount(), max=unit.getLegionaryMaxCount()))
self._updateVehiclesLabel(int2roman(settings.getMinLevel()), int2roman(settings.getMaxLevel()))
def _populate(self):
super(CyberSportRespawnForm, self)._populate()
self.startMyClubListening()
self.__updateHeader()
self.__updateTimer()
self.__updateWarning()
self.__updateTotal()
settings = self.unitFunctional.getRosterSettings()
self._updateVehiclesLabel(int2roman(settings.getMinLevel()), int2roman(settings.getMaxLevel()))
def _populate(self):
super(StaticFormationUnitView, self)._populate()
self.startClubListening(self.__clubDBID)
settings = self.unitFunctional.getRosterSettings()
self._updateVehiclesLabel(int2roman(settings.getMinLevel()), int2roman(settings.getMaxLevel()))
self.__updateHeader()
_, unit = self.unitFunctional.getUnit()
self.as_setLegionnairesCountS(False, self.__makeLegionnairesCountString(unit))
self._updateVehiclesLabel(int2roman(settings.getMinLevel()), int2roman(settings.getMaxLevel()))
self.clubsCtrl.getAvailabilityCtrl().onStatusChanged += self.onStatusChanged
def _initialize(self, *args, **kwargs):
super(BuyVehicleView, self)._initialize()
self._blur = GUI.WGUIBackgroundBlur()
self._blur.enable = True
self.__addListeners()
isElite = self.__vehicle.isElite
vehType = self.__vehicle.type.replace('-', '_')
isRestoreAvailable = self.__vehicle.isRestoreAvailable()
with self.viewModel.transaction() as model:
model.setTankType(
'{}_elite'.format(vehType) if isElite else vehType)
vehicleTooltip = i18n.makeString(
getTypeUserName(self.__vehicle.type, isElite))
noCrewLabelPath = R.strings.store.buyVehicleWindow.checkBox
model.setVehicleNameTooltip(vehicleTooltip)
model.setNation(nations.NAMES[self.__vehicle.nationID])
model.setNoCrewCheckboxLabel(
noCrewLabelPath.restore.withoutCrew
if isRestoreAvailable else noCrewLabelPath.buy.withoutCrew)
model.setTankLvl(int2roman(self.__vehicle.level))
model.setTankName(self.__vehicle.shortUserName)
model.setCountCrew(len(self.__vehicle.crew))
model.setBuyVehicleIntCD(self.__vehicle.intCD)
model.setIsToggleBtnVisible(self.__isTradeIn()
and self.__vehicle.hasRentPackages)
model.setIsElite(isElite)
model.setIsRentVisible(self.__isRentVisible)
model.setIsInBootcamp(self.__isBootcampBuyVehicle())
model.setIsMovingTextEnabled(constants.IS_CHINA
and GUI_SETTINGS.movingText.show)
if self.__vehicle.hasCrew:
model.setWithoutCommanderAltText(
R.strings.store.buyVehicleWindow.crewInVehicle)
equipmentBlock = model.equipmentBlock
equipmentBlock.setIsRentVisible(self.__isRentVisible)
equipmentBlock.setTradeInIsEnabled(self.__isTradeIn())
emtySlotAvailable = self.itemsCache.items.inventory.getFreeSlots(
self.__stats.vehicleSlots) > 0
equipmentBlock.setEmtySlotAvailable(emtySlotAvailable)
equipmentBlock.setIsRestore(isRestoreAvailable)
if self.__vehicle.hasRentPackages and not isRestoreAvailable:
self.__selectedRentIdx = 0
self.__selectedRentTerm = self.__vehicle.rentPackages[
self.__selectedRentIdx]['days']
tankPriceArray = model.tankPrice.getItems()
self.__addVMsInActionPriceList(tankPriceArray,
self.__vehicle.buyPrices.itemPrice)
self.__updateTankPrice()
self.__updateCommanderCards()
self.__updateSlotPrice()
self.__updateAmmoPrice()
self.__updateTradeInInfo()
self.__updateRentInfo()
self.__updateBuyBtnLabel()
totalPriceArray = equipmentBlock.totalPrice.getItems()
self.__addVMsInActionPriceList(
totalPriceArray,
ItemPrice(price=Money(credits=0, gold=0),
defPrice=Money(credits=0, gold=0)))
self.__updateTotalPrice()
def onPlayerStateChanged(self, entity, roster, playerInfo):
team, assigned = decodeRoster(roster)
data = {'dbID': playerInfo.dbID,
'state': playerInfo.state,
'igrType': playerInfo.igrType,
'icon': '',
'vShortName': '',
'vLevel': '',
'vType': '',
'isCurrentPayer': playerInfo.isCurrentPlayer()}
if playerInfo.isVehicleSpecified():
moduleName = ''
vehicle = playerInfo.getVehicle()
badgeVisibility = playerInfo.getEnhancementVisibility()
if badgeVisibility:
moduleName = MODULE_NAME_SEPARATOR.join([ self.__craftmacineConrtoller.getModuleName(module) for module in playerInfo.getEnhancementModules() ])
data.update({'icon': vehicle.iconContour,
'vShortName': vehicle.shortUserName,
'vLevel': int2roman(vehicle.level),
'vType': vehicle.type,
'isExperimentalModule': bool(badgeVisibility),
'experimentalModuleName': moduleName})
self.as_setPlayerStateS(team, assigned, data)
if playerInfo.isCurrentPlayer():
self.as_toggleReadyBtnS(not playerInfo.isReady())
else:
chat = self.chat
if chat:
chat.as_addMessageS(messages.getPlayerStateChangedMessage(self.__prbName, playerInfo))
def __packMainBlock(self):
header = backport.text(
R.strings.tooltips.battleTypes.battleRoyale.header())
body = backport.text(
R.strings.tooltips.battleTypes.battleRoyale.body2())
currentSeason = self._battleController.getCurrentSeason()
if currentSeason:
cycleNumber = self._battleController.getCurrentOrNextActiveCycleNumber(
currentSeason)
seasonResID = R.strings.battle_royale.season.num(
currentSeason.getSeasonID())
seasonName = backport.text(
seasonResID.name()) if seasonResID else None
scheduleStr = backport.text(
R.strings.menu.headerButtons.battle.types.battleRoyale.extra.
currentCycle(),
season=seasonName,
cycle=int2roman(cycleNumber))
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)
def packEpicBattleInfoBlock(epicController=None):
descLvl = text_styles.stats(
backport.text(
R.strings.epic_battle.selectorTooltip.epicBattle.bodyVehicleLevel(
),
level=toRomanRangeString(epicController.getValidVehicleLevels())))
season = epicController.getCurrentSeason()
cycle = None
cycleNumber = None
if season is not None and not season.isSingleCycleSeason():
hasActiveCycle = season.hasActiveCycle(
time_utils.getCurrentLocalServerTimestamp())
if epicController.isEnabled() and hasActiveCycle:
cycle = season.getCycleInfo()
else:
cycle = season.getNextByTimeCycle(
time_utils.getCurrentLocalServerTimestamp())
if cycle is not None:
cycleNumber = cycle.getEpicCycleNumber()
if cycleNumber:
titleStr = R.strings.epic_battle.tooltips.common.titleWithCycle()
else:
titleStr = R.strings.epic_battle.tooltips.common.title()
return formatters.packTitleDescBlock(
title=text_styles.middleTitle(
backport.text(titleStr, season=int2roman(cycleNumber))),
desc=text_styles.main(
backport.text(
R.strings.epic_battle.selectorTooltip.epicBattle.body(),
bodyVehicleLevel=descLvl)),
padding=formatters.packPadding(top=20, left=20, right=20),
descPadding=formatters.packPadding(right=30))
def getChainVehTypeAndLevelRestrictions(operation, chainID):
_eventsCache = dependency.instance(IEventsCache)
pmCache = _eventsCache.getPersonalMissions()
minLevel, maxLevel = pmCache.getVehicleLevelRestrictions(operation.getID())
vehType = _ms(
QUESTS.getAddBottomVehType(
operation.getChainClassifier(chainID).classificationAttr))
if operation.getBranch() == PM_BRANCH.PERSONAL_MISSION_2:
nations = getNationsForChain(operation, chainID)
nationsText = []
for nation in GUI_NATIONS:
if nation in nations:
nationsText.append(getNationText(nation))
vehType = _ms(vehType, nations=', '.join(nationsText))
return (vehType, int2roman(minLevel), int2roman(maxLevel))
def _getDisabledFunRandomTooltip(tooltipStr, funRandomCtrl=None):
availableLevels = funRandomCtrl.getModeSettings().levels
minLevel, maxLevel = min(availableLevels), max(availableLevels)
levels = int2roman(
minLevel) if minLevel == maxLevel else toRomanRangeString(
availableLevels)
return backport.text(tooltipStr, levels=levels)
def __getAlertStatusText(self, timeLeft, hasAvailableServers):
rAlertMsgBlock = R.strings.epic_battle.widgetAlertMessageBlock
alertStr = ''
if hasAvailableServers:
alertStr = backport.text(rAlertMsgBlock.somePeripheriesHalt(), serverName=self.__connectionMgr.serverUserNameShort)
else:
currSeason = self.__eventProgression.getCurrentSeason()
currTime = time_utils.getCurrentLocalServerTimestamp()
primeTime = self.__eventProgression.getPrimeTimes().get(self.__connectionMgr.peripheryID)
isCycleNow = currSeason and currSeason.hasActiveCycle(currTime) and primeTime and primeTime.getPeriodsBetween(currTime, currSeason.getCycleEndDate())
if isCycleNow:
if self.__connectionMgr.isStandalone():
key = rAlertMsgBlock.singleModeHalt
else:
key = rAlertMsgBlock.allPeripheriesHalt
timeLeftStr = time_utils.getTillTimeString(timeLeft, EPIC_BATTLE.STATUS_TIMELEFT, removeLeadingZeros=True)
alertStr = backport.text(key(), time=timeLeftStr)
else:
nextSeason = currSeason or self.__eventProgression.getNextSeason()
if nextSeason is not None:
nextCycle = nextSeason.getNextByTimeCycle(currTime)
if nextCycle is not None:
cycleNumber = nextCycle.getEpicCycleNumber()
timeLeftStr = time_utils.getTillTimeString(nextCycle.startDate - currTime, EPIC_BATTLE.STATUS_TIMELEFT, removeLeadingZeros=True)
alertStr = backport.text(rAlertMsgBlock.startIn(), cycle=int2roman(cycleNumber), time=timeLeftStr)
if not alertStr:
prevSeason = currSeason or self.__eventProgression.getPreviousSeason()
if prevSeason is not None:
prevCycle = prevSeason.getLastActiveCycleInfo(currTime)
if prevCycle is not None:
cycleNumber = prevCycle.getEpicCycleNumber()
alertStr = backport.text(rAlertMsgBlock.noCycleMessage(), cycle=int2roman(cycleNumber))
return text_styles.vehicleStatusCriticalText(alertStr)
def __onChanged(self, changedData):
"""
gui.game_control.VehComparisonBasket.onChange event handler
:param changedData: instance of gui.game_control.veh_comparison_basket._ChangedData
"""
comparisonBasket = getVehicleComparisonBasketCtrl()
if changedData.addedCDs:
cMgr = self.__getContainerManager()
if not cMgr.isViewAvailable(
ViewTypes.LOBBY_SUB,
{POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.VEHICLE_COMPARE}):
if comparisonBasket.getVehiclesCount() == 1:
self.__view.as_openVehicleCompareCartPopoverS(True)
else:
vehicle = g_itemsCache.items.getItemByCD(
changedData.addedCDs[-1])
vehName = ' '.join(
[int2roman(vehicle.level), vehicle.shortUserName])
vehTypeIcon = RES_ICONS.maps_icons_vehicletypes_gold(
vehicle.type + '.png')
self.__view.as_showAddVehicleCompareAnimS({
'vehName':
vehName,
'vehType':
vehTypeIcon
})
if changedData.addedCDs or changedData.removedCDs:
self.__updateBtnVisibility(comparisonBasket)
def onPlayerStateChanged(self, entity, roster, accountInfo):
stateString = formatters.getPlayerStateString(accountInfo.state)
vContourIcon = ''
vShortName = ''
vLevel = ''
if accountInfo.isVehicleSpecified():
vehicle = accountInfo.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
if roster == PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1:
self.as_setPlayerStateInTeam1S(accountInfo.dbID, stateString,
vContourIcon, vShortName, vLevel,
accountInfo.igrType)
elif roster == PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2:
self.as_setPlayerStateInTeam2S(accountInfo.dbID, stateString,
vContourIcon, vShortName, vLevel,
accountInfo.igrType)
else:
self.as_setPlayerStateInOtherS(accountInfo.dbID, stateString,
vContourIcon, vShortName, vLevel,
accountInfo.igrType)
creator = self.__getCreatorFromRosters()
if accountInfo.dbID == creator.dbID:
self.__showSettings(entity)
self.__updateStartButton(entity)
def showMarathonReward(vehicleCD, videoShownKey):
from gui.impl.lobby.marathon.marathon_reward_view import MarathonRewardViewWindow
uiLoader = dependency.instance(IGuiLoader)
itemsCache = dependency.instance(IItemsCache)
vehicle = itemsCache.items.getItemByCD(vehicleCD)
if vehicle is not None:
vehicleType = formatEliteVehicle(vehicle.isElite, vehicle.type)
congratsSourceId = str(vehicle.intCD)
sourceName = Vehicle.getIconResourceName(getVehicleStrID(vehicle.name))
if sourceName and congratsSourceId is not None:
specialRewardData = SpecialRewardData(
sourceName=sourceName,
congratsSourceId=congratsSourceId,
vehicleName=vehicle.userName,
vehicleIsElite=vehicle.isElite,
vehicleLvl=int2roman(vehicle.level),
vehicleType=vehicleType,
goToVehicleBtn=vehicle.isInInventory,
videoShownKey=videoShownKey)
viewID = R.views.lobby.marathon.marathon_reward_view.MarathonRewardView(
)
if uiLoader.windowsManager.findViews(loadedViewPredicate(viewID)):
return
window = MarathonRewardViewWindow(specialRewardData)
window.load()
return
def _constructHeader(self, block, skillID, level):
skillLevel = self._epicMetaGameCtrl.getSkillInformation(
)[skillID].levels[level]
title = skillLevel.name
icon = skillLevel.icon
romanLvl = int2roman(level)
desc = i18n.makeString(EPIC_BATTLE.METAABILITYSCREEN_ABILITY_LEVEL,
lvl=romanLvl)
imgPaddingLeft = 20
imgPaddingTop = 0
txtOffset = 85
highlightPath = None
overlayPath = None
padding = formatters.packPadding(
top=SLOT_HIGHLIGHT_TYPES.EQUIPMENT_PLUS_PADDING_TOP,
left=SLOT_HIGHLIGHT_TYPES.EQUIPMENT_PLUS_PADDING_LEFT)
block.append(
formatters.packItemTitleDescBlockData(
title=text_styles.highTitle(title),
desc=text_styles.standard(desc),
img=RES_ICONS.getEpicBattlesSkillIcon('43x43', icon),
imgPadding=formatters.packPadding(left=imgPaddingLeft,
top=imgPaddingTop),
txtGap=-3,
txtOffset=txtOffset,
padding=formatters.packPadding(top=0, bottom=0),
overlayPath=overlayPath,
overlayPadding=padding,
highlightPath=highlightPath,
highlightPadding=padding))
block.append(
formatters.packTextBlockData(
text_styles.standard(skillLevel.shortDescr),
padding=formatters.packPadding(left=txtOffset, top=0)))
return
def getTooltip(self):
eventType = self._event.getType()
limits = self._event.getLimits()
if eventType == _et.NATION:
nationsList = limits.getNations()
full = set(NationNames) == set(nationsList)
nations = ', \n'.join([
getNationText(value) for value in GUI_NATIONS
if value in nationsList
])
result = TOOLTIPS.elen_task_eventtype_full(
eventType) if full else _ms(
TOOLTIPS.elen_task_eventtype_notfull(eventType),
nations=nations)
elif eventType == _et.CLASS:
typeList = limits.getVehiclesClasses()
full = set(VEHICLE_CLASS_NAME.ALL()) == set(typeList)
types = ', \n'.join([vehicleTypeText(value) for value in typeList])
result = TOOLTIPS.elen_task_eventtype_full(
eventType) if full else _ms(
TOOLTIPS.elen_task_eventtype_notfull(eventType),
classes=types)
elif eventType == _et.LEVEL:
levelList = limits.getVehiclesLevels()
full = set(LEVELS_RANGE) == set(limits.getVehiclesLevels())
levels = ', '.join([int2roman(value) for value in levelList])
result = TOOLTIPS.elen_task_eventtype_full(
eventType) if full else _ms(
TOOLTIPS.elen_task_eventtype_notfull(eventType),
levels=levels)
else:
result = _ms(TOOLTIPS.elen_task_eventtype_notfull(eventType))
return makeTooltip(body=result)
def _vehicleHeaderCreator(vehicleCDStr):
itemsCache = dependency.instance(IItemsCache)
vehicle = itemsCache.items.getItemByCD(int(vehicleCDStr))
title = vehicle.shortUserName
iconPath = getTypeBigIconPath(vehicle.type, vehicle.isPremium)
txtLevel = int2roman(vehicle.level)
return (title, iconPath, txtLevel)
def __makeSeasonTimeText(self, timeStamp, seasonNum):
day, month = self.__getDayMonth(timeStamp)
return backport.text(_rBattlePass.progression.seasonText(),
seasonNum=int2roman(seasonNum),
endDay=str(day),
endMonth=backport.text(
R.strings.menu.dateTime.months.num(month)()))
def __updateOffSeason(self):
prevSeasonStats = self.__battlePassController.getLastFinishedSeasonStats(
)
if prevSeasonStats is None:
self.__showDummy()
_logger.warning('There is not previous season stats')
return
else:
prevOtherStats = prevSeasonStats.otherStats
prevSeasonHistory = getSeasonHistory(prevSeasonStats.seasonID)
if prevSeasonHistory is None:
self.__showDummy()
_logger.warning('There is not previous season %r history',
prevSeasonStats.seasonID)
return
sumPoints = sum(prevSeasonStats.vehPoints)
seasonName = backport.text(_rBattlePass.offSeason.title(),
season=int2roman(
prevSeasonHistory.seasonNum))
state, currentLevel = getLevelFromStats(prevOtherStats,
prevSeasonHistory)
with self.viewModel.transaction() as tx:
tx.setShowOffSeason(True)
offSeason = tx.offSeason
offSeason.setLevel(currentLevel + 1)
offSeason.setSeasonName(seasonName)
offSeason.setHasBattlePass(
self.__battlePassController.isBought(
prevSeasonStats.seasonID))
offSeason.setIsPostProgression(state != BattlePassState.BASE)
offSeason.setIsPostProgressionCompleted(
state == BattlePassState.COMPLETED)
offSeason.setIsEnabled(sumPoints > 0)
return
def __makeAccountsData(self, accounts):
result = []
isPlayerSpeaking = self.app.voiceChatManager.isPlayerSpeaking
accounts = sorted(accounts, cmp=getPlayersComparator())
getUser = self.usersStorage.getUser
for account in accounts:
vContourIcon = ''
vShortName = ''
vLevel = ''
dbID = account.dbID
user = getUser(dbID)
if account.isVehicleSpecified():
vehicle = account.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
result.append({'accID': account.accID,
'uid': account.dbID,
'userName': account.name,
'fullName': account.getFullName(),
'himself': account.isCurrentPlayer(),
'stateString': formatters.getPlayerStateString(account.state),
'icon': vContourIcon,
'vShortName': vShortName,
'vLevel': vLevel,
'chatRoster': user.getRoster() if user else 0,
'isPlayerSpeaking': bool(isPlayerSpeaking(account.dbID))})
return result
def __showCongratulations(self):
if self.viewStatus != ViewStatus.LOADED:
_logger.warning(
'Can not show congratulations! The view is not loaded anymore.'
)
return
else:
self.viewModel.setIsContentHidden(True)
with self.viewModel.congradulationAnim.transaction() as model:
vehicleType = '{}_elite'.format(
self.__vehicle.type
) if self.__vehicle.isElite else self.__vehicle.type
image = self.__vehicle.getShopIcon(
size=STORE_CONSTANTS.ICON_SIZE_LARGE)
defaultImage = RES_SHOP.getVehicleIcon(
STORE_CONSTANTS.ICON_SIZE_LARGE, 'empty_tank')
model.setIsElite(self.__vehicle.isElite)
model.setVehicleType(vehicleType)
model.setLvl(int2roman(self.__vehicle.level))
model.setVName(self.__vehicle.userName)
model.setImage(image if image is not None else defaultImage)
model.setImageAlt(defaultImage)
model.setTitle(R.strings.store.congradulationAnim.titleLabel)
model.setBtnLbl(
R.strings.store.congradulationAnim.showPreviewBtn)
return
def _vehicleHeaderCreator(vehicleCDStr):
vehicleCD = int(vehicleCDStr)
vehicle = getVehicleType(vehicleCD)
title = vehicle.shortUserString
iconPath = 'premium' if bool('premium' in vehicle.tags) else 'simple'
txtLevel = int2roman(vehicle.level)
return (title, iconPath, txtLevel)
def _update(self, onlyMoneyUpdate=False):
if g_currentVehicle.isPresent():
hangarMessage = g_currentVehicle.getHangarMessage()
if onlyMoneyUpdate and self.__hangarMessage == hangarMessage:
return
vehicle = g_currentVehicle.item
self.__hangarMessage = hangarMessage
statusId, msg, msgLvl = hangarMessage
rentAvailable = False
if statusId in (Vehicle.VEHICLE_STATE.RENTAL_IS_OVER, Vehicle.VEHICLE_STATE.RENTABLE_AGAIN):
canBuyOrRent, _ = vehicle.mayObtainForMoney(self.itemsCache.items.stats.money)
rentAvailable = vehicle.isRentable and canBuyOrRent
if msgLvl == Vehicle.VEHICLE_STATE_LEVEL.RENTABLE:
msgLvl = Vehicle.VEHICLE_STATE_LEVEL.INFO
msg, msgLvl = self.__applyGamemodeOverrides(statusId, i18n.makeString(msg), msgLvl)
msgString = ''
if statusId != Vehicle.VEHICLE_STATE.UNDAMAGED or msgLvl == Vehicle.VEHICLE_STATE_LEVEL.ACTIONS_GROUP:
msgString = makeHtmlString('html_templates:vehicleStatus', msgLvl, {'message': msg})
roleID = ROLE_TYPE.NOT_DEFINED
if msgLvl == Vehicle.VEHICLE_STATE_LEVEL.ACTIONS_GROUP:
roleID = vehicle.role
self.__applyCustomizationNewCounter(vehicle)
self.__updateDevices(vehicle)
self.as_updateVehicleStatusS({'message': msgString,
'rentAvailable': rentAvailable,
'isElite': vehicle.isElite,
'tankType': '{}_elite'.format(vehicle.type) if vehicle.isElite else vehicle.type,
'vehicleLevel': '{}'.format(int2roman(vehicle.level)),
'vehicleName': '{}'.format(vehicle.shortUserName),
'actionGroupId': roleID})
def _showOwnDeathInfo(self):
if self._deathAlreadySet:
self.as_showDeadReasonS()
else:
deathInfo = self.getDeathInfo()
if deathInfo:
killerVehID = deathInfo['killerVehicle']
battleCtx = self.sessionProvider.getCtx()
if killerVehID and not battleCtx.isCurrentPlayer(killerVehID) and battleCtx.getArenaDP().getVehicleInfo(killerVehID).vehicleType.compactDescr:
showVehicle = True
vInfoVO = battleCtx.getArenaDP().getVehicleInfo(killerVehID)
vTypeInfoVO = vInfoVO.vehicleType
vehLvl = int2roman(vTypeInfoVO.level)
vehImg = _VEHICLE_SMALL_ICON_RES_PATH.format(vTypeInfoVO.iconName)
vehClass = Vehicle.getTypeBigIconPath(vTypeInfoVO.classTag, False)
vehName = vTypeInfoVO.shortNameWithPrefix
else:
showVehicle = False
vehLvl = vehImg = vehClass = vehName = None
reason = self.__makeReasonInfo(deathInfo)
self.as_setDeadReasonInfoS(reason, showVehicle, vehLvl, vehImg, vehClass, vehName)
self._deathAlreadySet = True
else:
self.as_setDeadReasonInfoS('', False, None, None, None, None)
return
def makeEventBoardsTableDataVO(rewardCategories, method):
rewardsFormatter = QuestsBonusComposer(getEventBoardsAwardPacker())
data = []
stripes = []
for categoryNumber, category in rewardCategories.iteritems():
players = category.get('players')
if not players:
continue
rewards = category['rewards']
isIndividual = len(
rewards) > 1 and categoryNumber == EVENT_BOARDS_GROUP_TYPES.GOLD
stripeVO = {
'rendererLinkage':
EVENTBOARDS_ALIASES.AWARD_STRIPE_RENDERER,
'id':
categoryNumber,
'groupIcon':
RES_ICONS.getEventBoardGroup(categoryNumber),
'tooltip':
_ms(TOOLTIPS.ELEN_ANCOR_ALLGROUPS_HEADER,
group=int2roman(categoryNumber),
min=category.get('rank_min'),
max=category.get('rank_max'))
}
if not isIndividual and rewards:
stripeVO['icons'] = rewardsFormatter.getFormattedBonuses(
rewards[0])
data.append(stripeVO)
stripes.append(stripeVO)
for currentPlayerData in players:
name = currentPlayerData.getName()
clanAbbrev = currentPlayerData.getClanTag()
clanColor = currentPlayerData.getClanColor()
rank = currentPlayerData.getRank()
formattedParameters = formatParameters(
method, (currentPlayerData.getP1(), currentPlayerData.getP2(),
currentPlayerData.getP3()))
player = {
'position': rank,
'value1': formattedParameters[0],
'value2': formattedParameters[1],
'value3': formattedParameters[2],
'userVO': {
'dbID': currentPlayerData.getSpaId(),
'fullName': getFullName(name, clanAbbrev, clanColor),
'userName': name,
'clanAbbrev': getClanTag(clanAbbrev, clanColor)
}
}
if isIndividual:
player['icons'] = rewardsFormatter.getFormattedBonuses(
rewards[min(rank, len(rewards)) - 1])
player[
'rendererLinkage'] = EVENTBOARDS_ALIASES.TOP_PLAYER_AWARD_RENDERER
else:
player[
'rendererLinkage'] = EVENTBOARDS_ALIASES.BASE_PLAYER_AWARD_RENDERER
data.append(player)
return ({'tableDP': data}, {'tableDP': stripes})
def __onChanged(self, changedData):
if changedData.addedCDs:
cMgr = self.__getContainerManager()
if not cMgr.isViewAvailable(
ViewTypes.LOBBY_SUB,
{POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.VEHICLE_COMPARE}):
vehCmpData = self.comparisonBasket.getVehicleAt(
changedData.addedIDXs[-1])
if not vehCmpData.isFromCache():
if self.comparisonBasket.getVehiclesCount() == 1:
self.__view.as_openVehicleCompareCartPopoverS(True)
else:
vehicle = self.itemsCache.items.getItemByCD(
vehCmpData.getVehicleCD())
vehName = ' '.join(
[int2roman(vehicle.level), vehicle.shortUserName])
vehTypeIcon = RES_ICONS.maps_icons_vehicletypes_gold(
vehicle.type + '.png')
self.__view.as_showAddVehicleCompareAnimS({
'vehName':
vehName,
'vehType':
vehTypeIcon
})
if changedData.addedCDs or changedData.removedCDs:
self.__updateBtnVisibility()
def __getScheduleStr(self):
if self.__isFrozen:
return backport.text(R.strings.menu.headerButtons.battle.types.
battleRoyale.extra.frozen())
else:
currentSeason = self.__battleRoyaleController.getCurrentSeason()
if currentSeason is not None and currentSeason.hasActiveCycle(
time_utils.getCurrentLocalServerTimestamp()):
seasonResID = R.strings.battle_royale.season.num(
currentSeason.getSeasonID())
seasonName = backport.text(
seasonResID.name()) if seasonResID else None
scheduleStr = backport.text(
R.strings.menu.headerButtons.battle.types.battleRoyale.
extra.currentCycle(),
season=seasonName,
cycle=int2roman(currentSeason.getCycleOrdinalNumber()))
return text_styles.main(scheduleStr)
currentOrNextSeason = currentSeason or self.__battleRoyaleController.getNextSeason(
)
if currentOrNextSeason is not None:
nextCycle = currentOrNextSeason.getNextByTimeCycle(
time_utils.getCurrentLocalServerTimestamp())
if nextCycle:
scheduleStr = backport.text(
R.strings.menu.headerButtons.battle.types.battleRoyale.
extra.startsAt(),
time=backport.getDateTimeFormat(nextCycle.startDate))
return text_styles.main(scheduleStr)
scheduleStr = backport.text(R.strings.menu.headerButtons.battle.
types.battleRoyale.extra.finished())
return text_styles.main(scheduleStr)
def quest(self):
data = []
player_quest = None
for player_quests in g_eventsCache.potapov.getSelectedQuests(
).itervalues():
if g_currentVehicle.item.type in player_quests.getVehicleClasses():
player_quest = player_quests
if player_quest:
quest_level = player_quest.getVehMinLevel()
if g_currentVehicle.item.level >= quest_level:
format_str = {}
if config.data['config'].get('show_quest_title_string'):
data.extend(self.pack('', config.language['quest_title']))
if 'quest-name' in config.language['text_quest_info']:
format_str['quest-name'] = '%s' % player_quest.getUserName(
).decode('utf-8-sig')
if 'quest-min-level' in config.language['text_quest_info']:
format_str['quest-min-level'] = '%s' % quest_level
if 'quest-min-level-roman' in config.language[
'text_quest_info']:
format_str['quest-min-level-roman'] = '%s' % int2roman(
quest_level).decode('utf-8-sig')
data.extend(
self.pack(
'', config.language['text_quest_info'].format(
**format_str)))
if config.data['config'].get('show_conditions_string'):
data.extend(
self.mark_text_main(
player_quest.getUserMainCondition()))
data.extend(
self.mark_text_seq(player_quest.getUserAddCondition()))
return data
def __convertCompensationTooltip(cls, bonusComp, vehicle, tooltipData):
specialArgs = {
'iconBefore':
backport.image(
R.images.gui.maps.shop.vehicles.c_180x135.dyn(
getIconResourceName(getNationLessName(vehicle.name)))()),
'labelBefore':
'',
'iconAfter':
backport.image(R.images.gui.maps.icons.quests.bonuses.big.gold()),
'labelAfter':
bonusComp.getIconLabel(),
'bonusName':
bonusComp.getName(),
'vehicleName':
vehicle.shortUserName,
'vehicleType':
formatEliteVehicle(vehicle.isElite, vehicle.type),
'isElite':
vehicle.isElite,
'vehicleLvl':
int2roman(vehicle.level)
}
return createTooltipData(tooltip=tooltipData.tooltip,
specialAlias=VEH_COMP_R_ID,
specialArgs=specialArgs)
def __makeAccountsData(self, accounts, label = None):
listData = []
isPlayerSpeaking = self.bwProto.voipController.isPlayerSpeaking
accounts = sorted(accounts, cmp=getPlayersComparator())
getUser = self.usersStorage.getUser
for account in accounts:
vContourIcon = ''
vShortName = ''
vLevel = ''
dbID = account.dbID
user = getUser(dbID)
if account.isVehicleSpecified():
vehicle = account.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
listData.append({'accID': account.accID,
'dbID': account.dbID,
'userName': account.name,
'fullName': account.getFullName(),
'stateString': formatters.getPlayerStateString(account.state),
'icon': vContourIcon,
'vShortName': vShortName,
'vLevel': vLevel,
'tags': list(user.getTags()) if user else [],
'isPlayerSpeaking': bool(isPlayerSpeaking(account.dbID)),
'clanAbbrev': account.clanAbbrev,
'region': g_lobbyContext.getRegionCode(account.dbID),
'igrType': account.igrType})
if label is not None:
label = text_styles.main(i18n.makeString(label, total=text_styles.stats(str(len(listData)))))
result = {'listData': listData,
'teamLabel': label}
return result
def _getFalloutVehLevelStr(self):
if self._extra is None:
return
else:
config = g_eventsCache.getFalloutConfig(self._extra.eventType)
requiredLevelStr = int2roman(config.vehicleLevelRequired)
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTLEVEL, {'level': requiredLevelStr})
def formatVehicleNameWithTypeIcon(vehicle, path):
icon = icons.makeImageTag(
Vehicle.getTypeSmallIconPath(vehicle.type, vehicle.isPremium))
level = int2roman(vehicle.level)
key = 'vehicle_prem' if vehicle.isPremium else 'vehicle'
return makeHtmlString(
path, key, {'msg': '{} {}{}'.format(level, icon, vehicle.userName)})
def onPlayerStateChanged(self, entity, roster, playerInfo):
team, assigned = decodeRoster(roster)
data = {
'dbID': playerInfo.dbID,
'state': playerInfo.state,
'igrType': playerInfo.igrType,
'icon': '',
'vShortName': '',
'vLevel': '',
'vType': ''
}
if playerInfo.isVehicleSpecified():
vehicle = playerInfo.getVehicle()
data.update({
'icon': vehicle.iconContour,
'vShortName': vehicle.shortUserName,
'vLevel': int2roman(vehicle.level),
'vType': vehicle.type
})
self.as_setPlayerStateS(team, assigned, data)
if playerInfo.isCurrentPlayer():
self.as_toggleReadyBtnS(not playerInfo.isReady())
else:
chat = self.chat
if chat:
chat.as_addMessageS(
messages.getPlayerStateChangedMessage(
self.__prbName, playerInfo))
def __getMultiselectionStatus(self):
if self.__multiselectionMode:
falloutCfg = self.__falloutCtrl.getConfig()
messageTemplate = '#fallout:multiselectionSlot/%d' % self.__falloutCtrl.getBattleType(
)
if not falloutCfg.hasRequiredVehicles():
return (False,
i18n.makeString(
messageTemplate + '/topTierVehicleRequired',
level=int2roman(falloutCfg.vehicleLevelRequired)))
if self.__falloutCtrl.getSelectedVehicles():
return (
True,
main(
i18n.makeString(
FALLOUT.MULTISELECTIONSLOT_SELECTIONSTATUS)) +
'\n' + standard(
i18n.makeString(
FALLOUT.MULTISELECTIONSLOT_SELECTIONREQUIREMENTS,
level=toRomanRangeString(
list(falloutCfg.allowedLevels), 1))))
if falloutCfg.getAllowedVehicles():
return (
False,
main(i18n.makeString(messageTemplate +
'/descriptionTitle')) + '\n' +
standard(
i18n.makeString(messageTemplate + '/message',
level=toRomanRangeString(
list(falloutCfg.allowedLevels),
1))))
return (False, '')
def _makeAccountsData(self, accounts):
result = []
isPlayerSpeaking = self.bwProto.voipController.isPlayerSpeaking
getUser = self.usersStorage.getUser
getColors = g_settings.getColorScheme('rosters').getColors
accounts = sorted(accounts, cmp=prb_items.getPlayersComparator())
for account in accounts:
vContourIcon = ''
vShortName = ''
vLevel = ''
vType = ''
user = getUser(account.dbID)
if user is not None:
key = user.getGuiType()
else:
key = USER_GUI_TYPE.OTHER
if account.isVehicleSpecified():
vehicle = account.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
vType = vehicle.type
result.append({
'accID':
account.accID,
'dbID':
account.dbID,
'userName':
account.name,
'clanAbbrev':
account.clanAbbrev,
'region':
self.lobbyContext.getRegionCode(account.dbID),
'fullName':
account.getFullName(),
'igrType':
account.igrType,
'time':
account.time,
'isCreator':
account.isCreator,
'state':
account.state,
'icon':
vContourIcon,
'vShortName':
vShortName,
'vLevel':
vLevel,
'vType':
vType,
'tags':
list(user.getTags()) if user else [],
'isPlayerSpeaking':
isPlayerSpeaking(account.dbID),
'colors':
getColors(key)
})
return result
def __makeAccountsData(self, accounts):
result = []
isPlayerSpeaking = self.app.voiceChatManager.isPlayerSpeaking
accounts = sorted(accounts, cmp=getPlayersComparator())
getUser = self.usersStorage.getUser
for account in accounts:
vContourIcon = ''
vShortName = ''
vLevel = ''
dbID = account.dbID
user = getUser(dbID)
if account.isVehicleSpecified():
vehicle = account.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
result.append({'accID': account.accID,
'dbID': account.dbID,
'userName': account.name,
'fullName': account.getFullName(),
'himself': account.isCurrentPlayer(),
'stateString': formatters.getPlayerStateString(account.state),
'icon': vContourIcon,
'vShortName': vShortName,
'vLevel': vLevel,
'chatRoster': user.getRoster() if user else 0,
'isPlayerSpeaking': bool(isPlayerSpeaking(account.dbID)),
'clanAbbrev': account.clanAbbrev,
'region': g_lobbyContext.getRegionCode(account.dbID),
'igrType': account.igrType})
return result
def onPlayerStateChanged(self, functional, roster, accountInfo):
stateString = formatters.getPlayerStateString(accountInfo.state)
vContourIcon = ""
vShortName = ""
vLevel = ""
if accountInfo.isVehicleSpecified():
vehicle = accountInfo.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
if roster == PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1:
self.as_setPlayerStateInTeam1S(
accountInfo.dbID, stateString, vContourIcon, vShortName, vLevel, accountInfo.igrType
)
elif roster == PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2:
self.as_setPlayerStateInTeam2S(
accountInfo.dbID, stateString, vContourIcon, vShortName, vLevel, accountInfo.igrType
)
else:
self.as_setPlayerStateInOtherS(
accountInfo.dbID, stateString, vContourIcon, vShortName, vLevel, accountInfo.igrType
)
creator = self.__getCreatorFromRosters()
if accountInfo.dbID == creator.dbID:
self.__showSettings(functional)
self.__updateStartButton(functional)
def quest(self):
data = []
player_quest = {}
battle_type = game_control.g_instance.fallout.getBattleType()
for player_quests in g_eventsCache.potapov.getSelectedQuests().itervalues():
quest_class = player_quests.getVehicleClasses()
if not quest_class or g_currentVehicle.item.type in quest_class:
player_quest[player_quests.getID()] = player_quests
if player_quest:
for quest in player_quest:
quest_level = player_quest[quest].getVehMinLevel()
quest_type = player_quest[quest].getAddQuestID()
if 'fallout_5_2' in quest_type and battle_type is not 1:
continue
if 'fallout_5_1' in quest_type and battle_type is not 2:
continue
if not battle_type and 'fallout' in quest_type:
continue
if battle_type and 'fallout' not in quest_type:
continue
if g_currentVehicle.item.level >= quest_level:
format_str = {}
if config.data['config'].get('show_quest_title_string'):
data.extend(self.pack('', config.language['quest_title']))
if 'quest-name' in config.language['text_quest_info']:
format_str['quest-name'] = '%s' % player_quest[quest].getUserName().decode('utf-8-sig')
if 'quest-min-level' in config.language['text_quest_info']:
format_str['quest-min-level'] = '%s' % quest_level
if 'quest-min-level-roman' in config.language['text_quest_info']:
format_str['quest-min-level-roman'] = '%s' % int2roman(quest_level).decode('utf-8-sig')
data.extend(self.pack('', config.language['text_quest_info'].format(**format_str)))
if config.data['config'].get('show_conditions_string'):
data.extend(self.mark_text_main(player_quest[quest].getUserMainCondition()))
data.extend(self.mark_text_seq(player_quest[quest].getUserAddCondition()))
return data
def packGroupByLevelConditions(
level, counterValue=None, inrow=False, conditions=None, isCompleted=False, counterDescr=None
):
return _packGroupByConditionsBlock(
i18n.makeString("#quests:details/conditions/groupBy/levelLabel", int2roman(level)),
counterValue=counterValue,
conditions=conditions,
isCompleted=isCompleted,
counterDescr=counterDescr,
)
def construct(self):
tier = self.item.name.split('tier')
if len(tier) > 1:
_, level = tier
desc = _ms('#fortifications:orderType/battleConsumable', level=int2roman(int(level)))
else:
desc = _ms('#fortifications:orderType/battleConsumable_no_level')
block = []
title = self.item.userName
block.append(formatters.packImageTextBlockData(title=text_styles.highTitle(title), desc=text_styles.main(desc), img=self.item.icon, imgPadding=formatters.packPadding(left=12), txtGap=-4, txtOffset=100 - self.leftPadding))
return block
def __makeDetailsData(self, clientIdx):
result = self._searchDP.getUnitVO(clientIdx)
cache = self.fortCtrl.getFortBattlesCache()
maxVehicleLevel = FORT_BATTLE_DIVISIONS.ABSOLUTE.maxVehicleLevel
if cache is not None:
item, battleItem = cache.getItem(cache.getSelectedID())
if battleItem is not None:
maxVehicleLevel = battleItem.additionalData.division
isCreated = bool(result)
isInBattle = False
isBegin = False
if battleItem:
startTimeLeft = battleItem.getRoundStartTimeLeft()
else:
startTimeLeft = item.getStartTimeLeft()
if time_utils.QUARTER_HOUR > startTimeLeft > 0 or item.isHot():
isBegin = True
elif startTimeLeft == 0 or item.isInProgress():
isInBattle = True
isCreationAvailable = not isCreated and isBegin
result['titleText'] = text_styles.promoSubTitle(i18n.makeString(FORTIFICATIONS.FORTCLANBATTLELIST_DETAILS_CREATIONTITLE))
result['buttonLbl'] = FORTIFICATIONS.SORTIE_LISTVIEW_CREATE
result['isCreationAvailable'] = not isCreated
_, clanAbbrev, _ = item.getOpponentClanInfo()
isDefence = item.getType() == BATTLE_ITEM_TYPE.DEFENCE
localeStr = FORTIFICATIONS.FORTCLANBATTLELIST_DETAILS_TITLE if isDefence else FORTIFICATIONS.FORTCLANBATTLELIST_DETAILS_ATTACK_TITLE
result['detailsTitle'] = text_styles.highTitle(i18n.makeString(localeStr, clanName='[%s]' % clanAbbrev))
result['description'] = text_styles.main(i18n.makeString(FORTIFICATIONS.FORTCLANBATTLELIST_DETAILS_DESCRIPTION, directionName=i18n.makeString('#fortifications:General/directionName%d' % item.getDirection())))
result['isEnableBtn'] = isCreationAvailable
if isCreationAvailable:
descrText = FORTIFICATIONS.FORTCLANBATTLELIST_DETAILS_CREATIONDESCR
else:
descrText = FORTIFICATIONS.FORTCLANBATTLELIST_DETAILS_CREATIONDESCR_DISABLE
result['descrText'] = text_styles.main(i18n.makeString(descrText))
if isCreated and isInBattle:
for slot in result['slots']:
slot['canBeTaken'] = False
self.as_setDetailsS(result)
self._updateVehiclesLabel(int2roman(1), int2roman(maxVehicleLevel))
return
def buildList(self):
self.clear()
config = self._falloutCtrl.getConfig()
for slotIdx, vehicleInvId in enumerate(
self._falloutCtrl.getSelectedSlots()):
vehicle = self._itemsCache.items.getVehicle(vehicleInvId)
isSlotRequired = slotIdx in self._falloutCtrl.getRequiredSlots()
if self._falloutCtrl.mustSelectRequiredVehicle():
status = i18n.makeString(
FALLOUT.
MULTISELECTIONSLOT_DOMINATION_REQUIREDVEHICLENOTACTIVATED,
level=int2roman(config.vehicleLevelRequired))
else:
status = i18n.makeString(
FALLOUT.MULTISELECTIONSLOT_DOMINATION_VEHICLENOTACTIVATED)
if isSlotRequired:
style = text_styles.alert
else:
style = text_styles.standard
data = {
'indexStr':
i18n.makeString(
FALLOUT.MULTISELECTIONSLOT_INDEX, index=slotIdx + 1),
'isActivated':
False,
'formattedStatusStr':
style(status),
'stateLevel':
'',
'showAlert':
isSlotRequired,
'alertTooltip':
TOOLTIPS.MULTISELECTION_ALERT
}
if vehicle is not None:
vState, vStateLvl = vehicle.getState()
data.update({
'isActivated': True,
'formattedStatusStr': _getStatusString(vState),
'inventoryId': vehicle.invID,
'vehicleName': vehicle.shortUserName,
'vehicleIcon': vehicle.iconSmall,
'vehicleType': vehicle.type,
'vehicleLevel': vehicle.level,
'isElite': vehicle.isElite,
'stat': vState,
'stateLevel': vStateLvl,
'showAlert': False
})
self._list.append(data)
self.refresh()
return
def construct(self):
block = []
headerBlocks = []
if self.vehicle.isElite:
vehicleType = TOOLTIPS.tankcaruseltooltip_vehicletype_elite(self.vehicle.type)
bgLinkage = BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_ELITE_VEHICLE_BG_LINKAGE
else:
vehicleType = TOOLTIPS.tankcaruseltooltip_vehicletype_normal(self.vehicle.type)
bgLinkage = BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_NORMAL_VEHICLE_BG_LINKAGE
nameStr = text_styles.highTitle(self.vehicle.userName)
typeStr = text_styles.main(vehicleType)
levelStr = text_styles.concatStylesWithSpace(text_styles.stats(int2roman(self.vehicle.level)), text_styles.standard(_ms(TOOLTIPS.VEHICLE_LEVEL)))
icon = '../maps/icons/vehicleTypes/big/' + self.vehicle.type + ('_elite.png' if self.vehicle.isElite else '.png')
headerBlocks.append(formatters.packImageTextBlockData(title=nameStr, desc=text_styles.concatStylesToMultiLine(levelStr + ' ' + typeStr, ''), img=icon, imgPadding=formatters.packPadding(left=10, top=-15), txtGap=-2, txtOffset=99, padding=formatters.packPadding(top=15, bottom=-15 if self.vehicle.isFavorite else -21)))
if self.vehicle.isFavorite:
headerBlocks.append(formatters.packImageTextBlockData(title=text_styles.neutral(TOOLTIPS.VEHICLE_FAVORITE), img=RES_ICONS.MAPS_ICONS_TOOLTIP_MAIN_TYPE, imgPadding=formatters.packPadding(top=-15), imgAtLeft=False, txtPadding=formatters.packPadding(left=10), txtAlign=BLOCKS_TOOLTIP_TYPES.ALIGN_RIGHT, padding=formatters.packPadding(top=-28, bottom=-27)))
block.append(formatters.packBuildUpBlockData(headerBlocks, stretchBg=False, linkage=bgLinkage, padding=formatters.packPadding(left=-self.leftPadding)))
return block
def fmtParts(self, elems, chapters):
elems = filter(lambda e: e.get("included") == "True", elems)
parts = []
for elem in elems:
text = self.fmtPart.wrap(
self.fmtChapters(elem.find("childs"), chapters),
{
"name": elem.find("name").text,
"num": int2roman(self.partNum),
}
)
parts.append(text)
self.partNum += 1
return self.fmtPartList.wrap(parts)
def __makeQuestDetailsInfo(self, questID):
quest = events_helpers.getPotapovQuestsCache().getQuests()[questID]
questInfoData = events_helpers.getEventInfoData(quest)
self._navInfo.selectPotapovQuest(self.__tile.getID(), questID)
vehMinLevel, vehClasses = quest.getVehMinLevel(), quest.getVehicleClasses()
if vehMinLevel > 1:
reqsHeader = text_styles.middleTitle(_ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS))
if quest.getQuestBranch() == PQ_BRANCH.REGULAR:
reqs = _ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS_TEXT, level=int2roman(vehMinLevel), vehType=', '.join([ Vehicle.getTypeShortUserName(vc) for vc in vehClasses ]))
elif vehMinLevel < 10:
reqs = _ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS_MORE8LVL)
else:
reqs = _ms(QUESTS.QUESTTASKDETAILSVIEW_REQUIREMENTS_ONLY10LVL)
else:
reqsHeader = reqs = ''
condition = makeHtmlString('html_templates:lobby/quests/potapov', 'questDetails', ctx={'mainCondHeader': text_styles.middleTitle(_ms(QUESTS.QUESTTASKDETAILSVIEW_MAINCONDITIONS)),
'mainCond': quest.getUserMainCondition(),
'addCondHeader': text_styles.middleTitle(_ms(QUESTS.QUESTTASKDETAILSVIEW_ADDITIONALCONDITIONS)),
'addCond': quest.getUserAddCondition(),
'requirementsHeader': reqsHeader,
'requirements': reqs,
'adviseHeader': text_styles.middleTitle(_ms(QUESTS.QUESTTASKDETAILSVIEW_DESCRIPTION)),
'advise': quest.getUserAdvice(),
'descr': quest.getUserDescription()})
if not quest.isUnlocked():
btnInfo = _makeSelectBtn(QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_BEGIN, enabled=False, descr=text_styles.error(icons.notAvailableRed() + ' ' + _ms(self._lockedMessageStrKey)))
elif quest.needToGetReward():
btnInfo = _makeSelectBtn(QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_TAKEAWARD, TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_RECEIVETHEAWARD, _ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_TAKEAWARD))
elif quest.isInProgress():
btnInfo = _makeRefuseBtn(QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_CANCEL, TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_ABORT, _ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_INPROGRESS))
elif quest.isFullCompleted():
btnInfo = _makeNoBtn(text_styles.success(icons.checkmark() + _ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_EXCELLENTDONE)))
elif quest.isMainCompleted():
btnInfo = _makeSelectBtn(QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_REPEAT, TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_REPEAT, text_styles.success(icons.checkmark() + _ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_DONE)))
else:
btnInfo = _makeSelectBtn(QUESTS.QUESTTASKDETAILSVIEW_BTNLABEL_BEGIN, TOOLTIPS.PRIVATEQUESTS_ACTIONPANNEL_PERFORM, _ms(QUESTS.QUESTTASKDETAILSVIEW_TASKDESCRIPTION_AVAILABLE))
mainAwards, addAwards = questInfoData._getBonuses(events_helpers.getPotapovQuestsCache().getQuests().values())
result = {'taskID': questID,
'headerText': text_styles.highTitle(quest.getUserName()),
'conditionsText': condition,
'mainAwards': mainAwards,
'addAwards': addAwards}
result.update(btnInfo._asdict())
return result
def __onChanged(self, changedData):
"""
gui.game_control.VehComparisonBasket.onChange event handler
:param changedData: instance of gui.game_control.veh_comparison_basket._ChangedData
"""
comparisonBasket = getVehicleComparisonBasketCtrl()
if changedData.addedCDs:
cMgr = self.__getContainerManager()
if not cMgr.isViewAvailable(ViewTypes.LOBBY_SUB, {POP_UP_CRITERIA.VIEW_ALIAS: VIEW_ALIAS.VEHICLE_COMPARE}):
if comparisonBasket.getVehiclesCount() == 1:
self.__view.as_openVehicleCompareCartPopoverS(True)
else:
vehicle = g_itemsCache.items.getItemByCD(changedData.addedCDs[-1])
vehName = ' '.join([int2roman(vehicle.level), vehicle.shortUserName])
vehTypeIcon = RES_ICONS.maps_icons_vehicletypes_gold(vehicle.type + '.png')
self.__view.as_showAddVehicleCompareAnimS({'vehName': vehName,
'vehType': vehTypeIcon})
if changedData.addedCDs or changedData.removedCDs:
self.__updateBtnVisibility(comparisonBasket)
def _makeAccountsData(self, accounts):
result = []
isPlayerSpeaking = self.app.voiceChatManager.isPlayerSpeaking
getUser = self.usersStorage.getUser
getColors = g_settings.getColorScheme('rosters').getColors
accounts = sorted(accounts, cmp=prb_items.getPlayersComparator())
for account in accounts:
vContourIcon = ''
vShortName = ''
vLevel = ''
vType = ''
user = getUser(account.dbID)
if user is not None:
key = user.getGuiType()
else:
key = USER_GUI_TYPE.OTHER
if account.isVehicleSpecified():
vehicle = account.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
vType = vehicle.type
result.append({'accID': account.accID,
'dbID': account.dbID,
'userName': account.name,
'clanAbbrev': account.clanAbbrev,
'region': g_lobbyContext.getRegionCode(account.dbID),
'fullName': account.getFullName(),
'igrType': account.igrType,
'time': account.time,
'himself': account.isCurrentPlayer(),
'isCreator': account.isCreator,
'state': account.state,
'icon': vContourIcon,
'vShortName': vShortName,
'vLevel': vLevel,
'vType': vType,
'chatRoster': user.getRoster() if user else 0,
'isPlayerSpeaking': isPlayerSpeaking(account.dbID),
'colors': getColors(key)})
return result
def construct(self):
block = []
if self.vehicle.isElite:
vehicleType = TOOLTIPS.tankcaruseltooltip_vehicletype_elite(self.vehicle.type)
bgLinkage = BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_ELITE_VEHICLE_FAVORITE_BG_LINKAGE if self.vehicle.isFavorite else BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_ELITE_VEHICLE_BG_LINKAGE
else:
vehicleType = TOOLTIPS.tankcaruseltooltip_vehicletype_normal(self.vehicle.type)
bgLinkage = BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_NORMAL_VEHICLE_FAVORITE_BG_LINKAGE if self.vehicle.isFavorite else BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_NORMAL_VEHICLE_BG_LINKAGE
nameStr = text_styles.highTitle(self.vehicle.userName)
typeStr = text_styles.main(vehicleType)
levelStr = text_styles.concatStylesWithSpace(text_styles.stats(int2roman(self.vehicle.level)), text_styles.standard(_ms(TOOLTIPS.VEHICLE_LEVEL)))
icon = '../maps/icons/vehicleTypes/big/' + self.vehicle.type + ('_elite.png' if self.vehicle.isElite else '.png')
imgOffset = 4
textOffset = 82
if self.vehicle.type == 'heavyTank':
imgOffset = 11
textOffset = 99
iconBlock = formatters.packImageTextBlockData(title=nameStr, desc=text_styles.concatStylesToMultiLine(typeStr, levelStr), img=icon, imgPadding={'left': imgOffset,
'top': -15}, txtGap=-2, txtOffset=textOffset, padding=formatters.packPadding(top=15, bottom=-15))
block.append(formatters.packBuildUpBlockData([iconBlock], stretchBg=False, linkage=bgLinkage, padding=formatters.packPadding(left=-19 + self.leftPadding, top=-1)))
return block
def onPlayerStateChanged(self, functional, roster, playerInfo):
team, assigned = decodeRoster(roster)
data = {'uid': playerInfo.dbID,
'state': playerInfo.state,
'icon': '',
'vShortName': '',
'vLevel': '',
'vType': ''}
if playerInfo.isVehicleSpecified():
vehicle = playerInfo.getVehicle()
data.update({'icon': vehicle.iconContour,
'vShortName': vehicle.shortUserName,
'vLevel': int2roman(vehicle.level),
'vType': vehicle.type})
self.as_setPlayerStateS(team, assigned, data)
if playerInfo.isCurrentPlayer():
self.as_toggleReadyBtnS(not playerInfo.isReady())
else:
chat = self.chat
if chat:
chat.as_addMessageS(messages.getPlayerStateChangedMessage(self.__prbName, playerInfo))
def __makeAccountsData(self, accounts, label=None):
listData = []
isPlayerSpeaking = self.app.voiceChatManager.isPlayerSpeaking
accounts = sorted(accounts, cmp=getPlayersComparator())
getUser = self.usersStorage.getUser
for account in accounts:
vContourIcon = ""
vShortName = ""
vLevel = ""
dbID = account.dbID
user = getUser(dbID)
if account.isVehicleSpecified():
vehicle = account.getVehicle()
vContourIcon = vehicle.iconContour
vShortName = vehicle.shortUserName
vLevel = int2roman(vehicle.level)
listData.append(
{
"accID": account.accID,
"dbID": account.dbID,
"userName": account.name,
"fullName": account.getFullName(),
"stateString": formatters.getPlayerStateString(account.state),
"icon": vContourIcon,
"vShortName": vShortName,
"vLevel": vLevel,
"tags": list(user.getTags()) if user else [],
"isPlayerSpeaking": bool(isPlayerSpeaking(account.dbID)),
"clanAbbrev": account.clanAbbrev,
"region": g_lobbyContext.getRegionCode(account.dbID),
"igrType": account.igrType,
}
)
if label is not None:
label = text_styles.main(i18n.makeString(label, total=text_styles.stats(str(len(listData)))))
result = {"listData": listData, "teamLabel": label}
return result
def quest(self):
data = []
player_quest = None
for player_quests in g_eventsCache.potapov.getSelectedQuests().itervalues():
if g_currentVehicle.item.type in player_quests.getVehicleClasses():
player_quest = player_quests
if player_quest:
quest_level = player_quest.getVehMinLevel()
if g_currentVehicle.item.level >= quest_level:
format_str = {}
if config.data['config'].get('show_quest_title_string'):
data.extend(self.pack('', config.language['quest_title']))
if 'quest-name' in config.language['text_quest_info']:
format_str['quest-name'] = '%s' % player_quest.getUserName().decode('utf-8-sig')
if 'quest-min-level' in config.language['text_quest_info']:
format_str['quest-min-level'] = '%s' % quest_level
if 'quest-min-level-roman' in config.language['text_quest_info']:
format_str['quest-min-level-roman'] = '%s' % int2roman(quest_level).decode('utf-8-sig')
data.extend(self.pack('', config.language['text_quest_info'].format(**format_str)))
if config.data['config'].get('show_conditions_string'):
data.extend(self.mark_text_main(player_quest.getUserMainCondition()))
data.extend(self.mark_text_seq(player_quest.getUserAddCondition()))
return data
def __showOwnDeathInfo(self):
if self.__deathAlreadySet:
self.as_showDeadReasonS()
else:
deathInfo = self.getDeathInfo()
if deathInfo:
reason = self.__makeReasonInfo(deathInfo)
killerVehID = deathInfo['killerVehicle']
battleCtx = g_sessionProvider.getCtx()
if killerVehID and not battleCtx.isCurrentPlayer(killerVehID) and battleCtx.getArenaDP().getVehicleInfo(killerVehID).vehicleType.compactDescr:
showVehicle = True
vTypeInfoVO = battleCtx.getArenaDP().getVehicleInfo(killerVehID).vehicleType
vehLvl = int2roman(vTypeInfoVO.level)
vehImg = _VEHICLE_SMALL_ICON_RES_PATH.format(vTypeInfoVO.iconName)
vehClass = Vehicle.getTypeBigIconPath(vTypeInfoVO.classTag, False)
vehName = vTypeInfoVO.shortNameWithPrefix
else:
showVehicle = False
vehLvl = vehImg = vehClass = vehName = None
self.as_setDeadReasonInfoS(reason, showVehicle, vehLvl, vehImg, vehClass, vehName)
self.__deathAlreadySet = True
else:
self.as_setDeadReasonInfoS('', False, None, None, None, None)
return
def makeLvlStr(lvl):
return i18n.makeString(QUESTS.TOOLTIP_PROGRESS_GROUPBY_NOTE_LEVEL, int2roman(lvl))
def _populate(self):
super(VehicleSellDialog, self)._populate()
g_clientUpdateManager.addCallbacks({'stats.gold': self.onSetGoldHndlr})
g_itemsCache.onSyncCompleted += self.__shopResyncHandler
items = g_itemsCache.items
vehicle = items.getVehicle(self.vehInvID)
sellPrice = vehicle.sellPrice
sellForGold = sellPrice.gold > 0
priceTextColor = CURRENCIES_CONSTANTS.GOLD_COLOR if sellForGold else CURRENCIES_CONSTANTS.CREDITS_COLOR
priceTextValue = _ms(DIALOGS.VEHICLESELLDIALOG_PRICE_SIGN_ADD) + _ms(BigWorld.wg_getIntegralFormat(sellPrice.gold if sellForGold else sellPrice.credits))
currencyIcon = CURRENCIES_CONSTANTS.GOLD if sellForGold else CURRENCIES_CONSTANTS.CREDITS
invVehs = items.getVehicles(REQ_CRITERIA.INVENTORY)
if vehicle.isPremium or vehicle.level >= 3:
self.as_visibleControlBlockS(True)
self.__initCtrlQuestion()
else:
self.as_visibleControlBlockS(False)
modules = items.getItems(criteria=REQ_CRITERIA.VEHICLE.SUITABLE([vehicle]) | REQ_CRITERIA.INVENTORY).values()
shells = items.getItems(criteria=REQ_CRITERIA.VEHICLE.SUITABLE([vehicle], [GUI_ITEM_TYPE.SHELL]) | REQ_CRITERIA.INVENTORY).values()
otherVehsShells = set()
for invVeh in invVehs.itervalues():
if invVeh.invID != self.vehInvID:
for shot in invVeh.descriptor.gun['shots']:
otherVehsShells.add(shot['shell']['compactDescr'])
vehicleAction = None
if sellPrice != vehicle.defaultSellPrice:
vehicleAction = packItemActionTooltipData(vehicle, False)
if vehicle.isElite:
description = TOOLTIPS.tankcaruseltooltip_vehicletype_elite(vehicle.type)
else:
description = DIALOGS.vehicleselldialog_vehicletype(vehicle.type)
levelStr = text_styles.concatStylesWithSpace(text_styles.stats(int2roman(vehicle.level)), text_styles.main(_ms(DIALOGS.VEHICLESELLDIALOG_VEHICLE_LEVEL)))
restoreController = getRestoreController()
tankmenGoingToBuffer, deletedTankmen = restoreController.getTankmenDeletedBySelling(vehicle)
deletedCount = len(deletedTankmen)
if deletedCount > 0:
recoveryBufferFull = True
deletedStr = formatDeletedTankmanStr(deletedTankmen[0])
maxCount = restoreController.getMaxTankmenBufferLength()
currCount = len(restoreController.getDismissedTankmen())
if deletedCount == 1:
crewTooltip = text_styles.concatStylesToMultiLine(text_styles.middleTitle(_ms(TOOLTIPS.VEHICLESELLDIALOG_CREW_ALERTICON_RECOVERY_HEADER)), text_styles.main(_ms(TOOLTIPS.VEHICLESELLDIALOG_CREW_ALERTICON_RECOVERY_BODY, maxVal=maxCount, curVal=currCount, sourceName=tankmenGoingToBuffer[-1].fullUserName, targetInfo=deletedStr)))
else:
crewTooltip = text_styles.concatStylesToMultiLine(text_styles.middleTitle(_ms(TOOLTIPS.VEHICLESELLDIALOG_CREW_ALERTICON_RECOVERY_HEADER)), text_styles.main(_ms(TOOLTIPS.DISMISSTANKMANDIALOG_BUFFERISFULLMULTIPLE_BODY, deletedStr=deletedStr, extraCount=deletedCount - 1, maxCount=maxCount, currCount=currCount)))
else:
crewTooltip = None
recoveryBufferFull = False
barracksDropDownData = [{'label': _ms(MENU.BARRACKS_BTNUNLOAD)}, {'label': _ms(MENU.BARRACKS_BTNDISSMISS)}]
sellVehicleData = {'intCD': vehicle.intCD,
'userName': vehicle.userName,
'icon': vehicle.icon,
'level': vehicle.level,
'isElite': vehicle.isElite,
'isPremium': vehicle.isPremium,
'type': vehicle.type,
'nationID': vehicle.nationID,
'sellPrice': sellPrice,
'priceTextValue': priceTextValue,
'priceTextColor': priceTextColor,
'currencyIcon': currencyIcon,
'action': vehicleAction,
'hasCrew': vehicle.hasCrew,
'isRented': vehicle.isRented,
'description': description,
'levelStr': levelStr,
'priceLabel': _ms(DIALOGS.VEHICLESELLDIALOG_VEHICLE_EMPTYSELLPRICE),
'crewLabel': _ms(DIALOGS.VEHICLESELLDIALOG_CREW_LABEL),
'crewTooltip': crewTooltip,
'barracksDropDownData': barracksDropDownData,
'crewRecoveryBufferFull': recoveryBufferFull}
onVehicleOptionalDevices = []
for o in vehicle.optDevices:
if o is not None:
action = None
if o.sellPrice != o.defaultSellPrice:
action = packItemActionTooltipData(o, False)
data = {'intCD': o.intCD,
'isRemovable': o.isRemovable,
'userName': o.userName,
'sellPrice': o.sellPrice,
'toInventory': True,
'action': action}
onVehicleOptionalDevices.append(data)
onVehicleoShells = []
for shell in vehicle.shells:
if shell is not None:
action = None
if shell.sellPrice != shell.defaultSellPrice:
action = packItemActionTooltipData(shell, False)
data = {'intCD': shell.intCD,
'count': shell.count,
'sellPrice': shell.sellPrice,
'userName': shell.userName,
'kind': shell.type,
'toInventory': shell in otherVehsShells or shell.isPremium,
'action': action}
onVehicleoShells.append(data)
onVehicleEquipments = []
for equipmnent in vehicle.eqs:
if equipmnent is not None:
action = None
if equipmnent.sellPrice != equipmnent.defaultSellPrice:
action = packItemActionTooltipData(equipmnent, False)
data = {'intCD': equipmnent.intCD,
'userName': equipmnent.userName,
'sellPrice': equipmnent.sellPrice,
'toInventory': True,
'action': action}
onVehicleEquipments.append(data)
inInventoryModules = []
for m in modules:
inInventoryModules.append({'intCD': m.intCD,
'inventoryCount': m.inventoryCount,
'toInventory': True,
'sellPrice': m.sellPrice})
inInventoryShells = []
for s in shells:
action = None
if s.sellPrice != s.defaultSellPrice:
action = packItemActionTooltipData(s, False)
inInventoryShells.append({'intCD': s.intCD,
'count': s.inventoryCount,
'sellPrice': s.sellPrice,
'userName': s.userName,
'kind': s.type,
'toInventory': s in otherVehsShells or s.isPremium,
'action': action})
removePrice = items.shop.paidRemovalCost
removePrices = Money(gold=removePrice)
defRemovePrice = Money(gold=items.shop.defaults.paidRemovalCost)
removeAction = None
if removePrices != defRemovePrice:
removeAction = packActionTooltipData(ACTION_TOOLTIPS_TYPE.ECONOMICS, 'paidRemovalCost', True, removePrices, defRemovePrice)
settings = self.getDialogSettings()
isSlidingComponentOpened = settings['isOpened']
self.as_setDataS({'accountGold': items.stats.gold,
'sellVehicleVO': sellVehicleData,
'optionalDevicesOnVehicle': onVehicleOptionalDevices,
'shellsOnVehicle': onVehicleoShells,
'equipmentsOnVehicle': onVehicleEquipments,
'modulesInInventory': inInventoryModules,
'shellsInInventory': inInventoryShells,
'removeActionPrice': removeAction,
'removePrice': removePrice,
'isSlidingComponentOpened': isSlidingComponentOpened})
return
def _getFalloutVehMinStr(self):
config = getFalloutCtrl().getConfig()
allowedLevelsList = list(config.allowedLevels)
if len(allowedLevelsList) > 1:
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTMIN_LEVELRANGE, {'level': toRomanRangeString(allowedLevelsList, 1)})
else:
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTMIN_REQUIREDLEVEL, {'level': int2roman(config.vehicleLevelRequired)})
def _getFalloutVehLevelStr(self):
config = getFalloutCtrl().getConfig()
requiredLevelStr = int2roman(config.vehicleLevelRequired)
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTLEVEL, {'level': requiredLevelStr})
def onSortieUnitReceived(self, clientIdx):
result = self._searchDP.getUnitVO(clientIdx)
self._searchDP.refresh()
self.as_setDetailsS(result)
self._updateVehiclesLabel(int2roman(1), int2roman(self._searchDP.getUnitMaxLevel(clientIdx)))
def __getFightBtnTooltipData(self, state):
falloutCtrl = getFalloutCtrl()
config = falloutCtrl.getConfig()
if state == PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutOnly/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutOnly/body')
elif state == PREBATTLE_RESTRICTION.FALLOUT_NOT_SELECTED:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotSelected/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotSelected/body')
elif state == PREBATTLE_RESTRICTION.VEHICLE_GROUP_IS_NOT_READY:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotReady/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotReady/body')
elif state == UNIT_RESTRICTION.FALLOUT_NOT_ENOUGH_PLAYERS:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotEnoughPlayer/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotEnoughPlayer/body')
elif state in (UNIT_RESTRICTION.FALLOUT_VEHICLE_LEVEL_REQUIRED, PREBATTLE_RESTRICTION.VEHICLE_GROUP_REQUIRED):
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/body', level=int2roman(config.vehicleLevelRequired))
elif state in (UNIT_RESTRICTION.FALLOUT_VEHICLE_MIN, PREBATTLE_RESTRICTION.VEHICLE_GROUP_MIN):
allowedLevelsList = list(config.allowedLevels)
if len(allowedLevelsList) > 1:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehMin/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehMin/body', min=str(config.minVehiclesPerPlayer), level=toRomanRangeString(allowedLevelsList, 1))
else:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/body', level=int2roman(config.vehicleLevelRequired))
else:
return None
return {makeTooltip(header, body)}
