def init(self):
super(BattleRoyaleController, self).init()
self.__voControl = BRVoiceOverController()
self.__voControl.init()
self.__urlMacros = URLMacros()
self.addNotificator(SimpleNotifier(self.getTimer, self.__timerUpdate))
self.addNotificator(PeriodicNotifier(self.getTimer, self.__timerTick))
def __init__(self):
super(PromoController, self).__init__()
self.__urlMacros = URLMacros()
self.__externalCloseCallback = None
self.__isLobbyInited = False
self.__pendingPromo = None
self.__promoCount = 0
self.__lastUpdateTimeMark = 0
self.__promoData = None
self.__waitingForWebBridgeData = False
self.__battlesFromLastTeaser = 0
self.__wasInBattle = False
self.__hasPendingTeaser = False
self.__isPromoOpen = False
self.__browserCreationCallbacks = {}
self.__browserWatchers = {}
self.__isInHangar = False
self.__isTeaserOpen = False
self.__checkIntervalInBattles = GUI_SETTINGS.checkPromoFrequencyInBattles
self.__em = EventManager()
self.onNewTeaserReceived = Event(self.__em)
self.onPromoCountChanged = Event(self.__em)
self.onTeaserShown = Event(self.__em)
self.onTeaserClosed = Event(self.__em)
return
def __init__(self):
self.__urlMacros = URLMacros()
self.__isEnabled = False
self.__isFrontLine = False
self.__isSteelHunter = False
self.__url = ''
self.__actualRewardPoints = 0
self.__seasonRewardPoints = 0
self.__maxRewardPoints = 0
self.__rewardPointsTokenID = ''
self.__seasonPointsTokenID = ''
self.__rewardVehicles = []
self.__currentMode = None
self.__questCardLevelTxtId = 0
self.__progressionNameCycleTxtId = 0
self.__progressionIconId = 0
self.__selectorLabelTxtId = 0
self.__selectorRibbonResId = 0
self.__allCyclesWasEndedResId = 0
self.__selectorData = 0
self.__selectorType = 0
self.__selectorQueueType = 0
self.__questPrefix = ''
self.__activeQuestIDs = []
self.__primeTimeTitle = ''
self.__primeTimeBg = ''
return
def __init__(self, skipConfirm=False):
super(VehiclePreviewBuyingPanel, self).__init__()
heroTankCD = self._heroTanks.getCurrentTankCD()
self._vehicleCD = g_currentPreviewVehicle.item.intCD
self._vehicleLevel = g_currentPreviewVehicle.item.level
self._actionType = None
self._skipConfirm = skipConfirm
self._disableBuyButton = False
self._marathonEvent = None
self.__previewDP = DefaultVehPreviewDataProvider()
self.__isHeroTank = heroTankCD and heroTankCD == self._vehicleCD
self.__price = None
self.__title = None
self.__description = None
self.__items = None
self.__offers = None
self.__currentOffer = None
self.__styleByGroup = {}
self.__vehicleByGroup = {}
self.__endTime = None
self.__oldPrice = MONEY_UNDEFINED
self.__buyParams = None
self.__backAlias = None
self.__backCallback = None
self.__timeCallbackID = None
self.__timeLeftIcon = icons.makeImageTag(
RES_ICONS.MAPS_ICONS_LIBRARY_TIME_ICON, 16, 16)
self.__cachedVehiclesVOs = None
self.__cachedItemsVOs = None
self.__cachedCollapsedItemsVOs = None
self.__couponInfo = None
self.__hasSSEDiscount = False
self.__urlMacros = URLMacros()
g_techTreeDP.load()
return
def init(self):
super(EpicBattleMetaGameController, self).init()
self.__urlMacros = URLMacros()
self.addNotificator(SimpleNotifier(self.getTimer, self.__timerUpdate))
self.addNotificator(PeriodicNotifier(self.getTimer, self.__timerTick))
self.__eventEndedNotifier = SimpleNotifier(self.getEventTimeLeft,
self.__onEventEnded)
self.addNotificator(self.__eventEndedNotifier)
def showBuyItemWebView(url, itemId, source=None, origin=None, alias=VIEW_ALIAS.OVERLAY_WEB_STORE):
url = yield URLMacros().parse(url)
params = {}
if source:
params['source'] = source
if origin:
params['origin'] = origin
url = yield URLMacros().parse(url=_makeBuyItemUrl(url, itemId), params=params)
g_eventBus.handleEvent(events.LoadViewEvent(alias, ctx={'url': url}), EVENT_BUS_SCOPE.LOBBY)
def __init__(self):
super(MarathonEvent, self).__init__()
self.__isEnabled = False
self.__isAvailable = False
self.__rewardObtained = False
self.__state = ''
self.__suspendFlag = False
self.__quest = None
self.__group = None
self.__urlMacros = URLMacros()
return
def __init__(self):
super(BrowserController, self).__init__()
self.__browsers = {}
self.__browsersCallbacks = {}
self.__browserCreationCallbacks = {}
self.__browserIDGenerator = SequenceIDGenerator()
self.__eventMgr = Event.EventManager()
self.onBrowserAdded = Event.Event(self.__eventMgr)
self.onBrowserDeleted = Event.Event(self.__eventMgr)
self.__urlMacros = URLMacros()
self.__pendingBrowsers = {}
self.__creatingBrowserID = None
self.__filters = _getGlobalFilters()
return
def init(self):
self.__urlMacros = URLMacros()
addListener = g_eventBus.addListener
for eventType, handlerName in _LISTENERS.iteritems():
handler = getattr(self, handlerName, None)
if not handler:
_logger.error('Handler is not found %s %s', eventType, handlerName)
continue
if not callable(handler):
_logger.error('Handler is invalid %s %s %r', eventType, handlerName, handler)
continue
addListener(eventType, handler)
return
def getShopProductInfo(productID, callback=None, webCtrl=None):
productInfo = None
accessTokenData = yield webCtrl.getAccessTokenData(force=False)
loginUrl = yield URLMacros().parse(url=getLoginUrl())
productUrl = yield URLMacros().parse(url=getProductsUrl(productID))
reqTimeoutSeconds = 10.0
if accessTokenData is not None and loginUrl and productUrl:
authHeader = ('Authorization: Basic {}'.format(str(accessTokenData.accessToken)),)
authResponse = yield _fetchUrl(loginUrl, authHeader, reqTimeoutSeconds, 'POST')
if 200 <= authResponse.responseCode < 300:
getProductHeader = authHeader + ('Cookie: {}'.format(authResponse.headers().get('Set-Cookie')), 'Accept-Language: {}'.format(getClientLanguage()))
productResponse = yield _fetchUrl(productUrl, getProductHeader, reqTimeoutSeconds, 'GET')
productInfo = _tryParseProductInfo(productResponse.body)
if callback:
callback(productInfo)
return
def showBuyGoldWebOverlay(params=None, parent=None):
url = helpers.getBuyMoreGoldUrl()
if url:
url = yield URLMacros().parse(url, params=params)
g_eventBus.handleEvent(
events.LoadViewEvent(SFViewLoadParams(VIEW_ALIAS.OVERLAY_WEB_STORE,
parent=parent),
ctx={'url': url}), EVENT_BUS_SCOPE.LOBBY)
def __init__(self, layoutID, c11nView, *args, **kwargs):
settings = ViewSettings(layoutID)
settings.args = args
settings.kwargs = kwargs
settings.flags = ViewFlags.LOBBY_TOP_SUB_VIEW
settings.model = ProgressiveItemsViewModel()
super(ProgressiveItemsView, self).__init__(settings)
self._itemsProgressData = None
self._possibleItems = None
self._vehicle = None
self.__blur = CachedBlur()
self.__layoutID = layoutID
self.__c11nView = c11nView
self.__urlMacros = URLMacros()
self.__guiSettings = GUI_SETTINGS.progressiveItems.get(
'tutorialVideo', {})
return
def __init__(self, _=None):
LobbySelectableView.__init__(self, 0)
self.__currentCarouselAlias = None
self.__isSpaceReadyForC11n = False
self.__isVehicleReadyForC11n = False
self.__isVehicleCameraReadyForC11n = False
self.__urlMacros = URLMacros()
self.__teaser = None
self.__seniorityAwardsIsActive = False
return
def showGetVehiclePage(vehicle, params=None):
if vehicle.isInInventory and not vehicle.isRented:
showInventoryMsg('already_exists',
vehicle,
msgType=SystemMessages.SM_TYPE.Warning)
event_dispatcher.selectVehicleInHangar(vehicle.intCD)
return
url = helpers.getObtainVehicleURL()
if url:
url = yield URLMacros().parse(url, params=params)
showReferralProgramWindow(url)
def _showBlurredWebOverlay(url,
params=None,
parent=None,
isClientCloseControl=False):
url = yield URLMacros().parse(url, params)
ctx = {'url': url, 'allowRightClick': False}
if isClientCloseControl:
ctx.update(helpers.getClientControlledCloseCtx())
g_eventBus.handleEvent(
events.LoadViewEvent(SFViewLoadParams(VIEW_ALIAS.WEB_VIEW_TRANSPARENT,
parent=parent),
ctx=ctx), EVENT_BUS_SCOPE.LOBBY)
def _showOverlayWebStoreDefault(url, params=None):
if url:
url = yield URLMacros().parse(url, params=params)
g_eventBus.handleEvent(
events.LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.OVERLAY_WEB_STORE),
ctx={
'url':
url,
'browserParams':
makeBrowserParams(R.strings.waiting.updating(), True, True,
0.5)
}), EVENT_BUS_SCOPE.LOBBY)
def showRentVehicleOverlay(params=None):
url = helpers.getVehicleUrl()
if url:
url = yield URLMacros().parse(url, params=params)
g_eventBus.handleEvent(
events.LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.OVERLAY_WEB_STORE),
ctx={
'url':
url,
'browserParams':
makeBrowserParams(R.strings.waiting.updating(), True, True,
0.5)
}), EVENT_BUS_SCOPE.LOBBY)
def __init__(self, _=None):
LobbySelectableView.__init__(self, 0)
self.__currentCarouselAlias = None
self.__isSpaceReadyForC11n = False
self.__isVehicleReadyForC11n = False
self.__isVehicleCameraReadyForC11n = False
self.__isUnitJoiningInProgress = False
self.__urlMacros = URLMacros()
self.__teaser = None
self.__timer = None
self.__wotPlusInfo = BigWorld.player().renewableSubscription
self.__updateDogTagsState()
self.__updateWotPlusState()
return
class OpenBrowserOnClickComponent(CGFComponent):
urlProvider = ComponentProperty(type=CGFMetaTypes.STRING,
editorName='url provider',
value='MARATHON_VIDEO_URL_PROVIDER')
def __init__(self):
super(OpenBrowserOnClickComponent, self).__init__()
self.__urlParser = URLMacros()
def doAction(self):
self.__openBrowser()
@process
def __openBrowser(self):
getterFunc = URL_PROVIDERS[self.urlProvider]
unparsedUrl = getterFunc()
url = yield self.__urlParser.parse(unparsedUrl)
showBrowserOverlayView(url, alias=VIEW_ALIAS.BROWSER_OVERLAY)
def __init__(self):
self.prefix = 'event_marathon'
self.tokenPrefix = 'event_marathon'
self.styleTokenPostfix = ''
self.urlName = 'marathonUrl'
self.marathonCompleteUrlAdd = 'overlay/'
self.vehicleName = ''
self.suspendPrefix = ':suspend'
self.completedTokenPostfix = '_PASS'
self.hangarFlagName = 'flag_italy'
self.questsInChain = 10
self.minVehicleLevel = 6
self.awardTokensPostfix = ('complete', 'ps_stop')
self.awardPostTokensPostfix = ('post_complete', )
self.showFlagTooltipBottom = True
self.flagTooltip = TOOLTIPS_CONSTANTS.MARATHON_QUESTS_PREVIEW
self.disabledFlagTooltip = TOOLTIPS.MARATHON_OFF
self.marathonTooltipHeader = 'marathonTooltipHeader'
self.bodyAddInfo = R_TITLE_TOOLTIP.body.addInfo
self.doesShowRewardScreen = False
self.doesShowRewardVideo = False
self.doesShowInPostBattle = True
self.questsPerStep = 2
self.isEnabled = False
self.isAvailable = False
self.rewardObtained = False
self.postRewardObtained = False
self.state = MarathonState.UNKNOWN
self.suspendFlag = False
self.quest = None
self.group = None
self.vehicleID = 0
self.awardTokens = None
self.postAwardTokens = None
self.tabTooltip = None
self.infoBody = None
self.label = ''
self.backBtnLabel = ''
self.tooltips = None
self.icons = None
self.urlMacros = URLMacros()
self._override()
self._initialize()
return
def invoke(self, notID, actor=None):
processedUrl = yield URLMacros().parse(self._url)
try:
BigWorld.wg_openWebBrowser(processedUrl)
except (AttributeError, TypeError):
LOG_CURRENT_EXCEPTION()
class EpicBattleMetaGameController(Notifiable, SeasonProvider,
IEpicBattleMetaGameController,
IGlobalListener):
bootcampController = dependency.descriptor(IBootcampController)
__itemsCache = dependency.descriptor(IItemsCache)
__eventsCache = dependency.descriptor(IEventsCache)
__settingsCore = dependency.descriptor(ISettingsCore)
__lobbyContext = dependency.descriptor(ILobbyContext)
__battleResultsService = dependency.descriptor(IBattleResultsService)
__offersProvider = dependency.descriptor(IOffersDataProvider)
MAX_STORED_ARENAS_RESULTS = 20
DAILY_QUEST_ID = 'front_line'
FINAL_BADGE_QUEST_ID = 'epicmetagame:progression_finish'
def __init__(self):
super(EpicBattleMetaGameController, self).__init__()
self.onUpdated = Event.Event()
self.onPrimeTimeStatusUpdated = Event.Event()
self.onEventEnded = Event.Event()
self.onGameModeStatusTick = Event.Event()
self.__skillData = {}
self.__playerMaxLevel = 0
self.__levelProgress = tuple()
self.__abilityPointsForLevel = list()
self.__performanceGroup = None
self.__isEpicSoundMode = False
self.__rankSettings = {}
self.__showedResultsForArenas = []
self.__eventEndedNotifier = None
self.__urlMacros = None
return
def init(self):
super(EpicBattleMetaGameController, self).init()
self.__urlMacros = URLMacros()
self.addNotificator(SimpleNotifier(self.getTimer, self.__timerUpdate))
self.addNotificator(PeriodicNotifier(self.getTimer, self.__timerTick))
self.__eventEndedNotifier = SimpleNotifier(self.getEventTimeLeft,
self.__onEventEnded)
self.addNotificator(self.__eventEndedNotifier)
def fini(self):
del self.__showedResultsForArenas[:]
self.onUpdated.clear()
self.onPrimeTimeStatusUpdated.clear()
self.onGameModeStatusTick.clear()
self.onEventEnded.clear()
self.clearNotification()
self.stopGlobalListening()
self.__urlMacros = None
super(EpicBattleMetaGameController, self).fini()
return
def onLobbyInited(self, ctx):
self.__lobbyContext.getServerSettings(
).onServerSettingsChange += self.__updateEpicMetaGameSettings
g_currentVehicle.onChanged += self.__invalidateBattleAbilities
self.__itemsCache.onSyncCompleted += self.__invalidateBattleAbilities
g_clientUpdateManager.addCallbacks({
'epicMetaGame': self.__updateEpic,
'inventory': self.__onInventoryUpdate,
'tokens': self.__onTokensUpdate
})
self.startGlobalListening()
self.__setData()
self.__invalidateBattleAbilities()
self.startNotification()
if self.getPerformanceGroup() == EPIC_PERF_GROUP.HIGH_RISK:
self.__lobbyContext.addFightButtonConfirmator(
self.__confirmFightButtonPressEnabled)
self.__isEpicSoundMode = False
if self.prbEntity is not None:
enableSound = bool(self.prbEntity.getModeFlags()
& FUNCTIONAL_FLAG.EPIC)
self.__updateSounds(enableSound)
return
def onDisconnected(self):
self.__clear()
def onPrbEntitySwitching(self):
if self.prbEntity is None:
return
else:
switchedFromEpic = bool(self.prbEntity.getModeFlags()
& FUNCTIONAL_FLAG.EPIC)
if switchedFromEpic:
self.__updateSounds(False)
return
def onPrbEntitySwitched(self):
self.__invalidateBattleAbilities()
if self.prbEntity is None:
return
else:
isEpicSoundMode = bool(self.prbEntity.getModeFlags()
& FUNCTIONAL_FLAG.EPIC)
if isEpicSoundMode:
self.__updateSounds(True)
return
def onAccountBecomePlayer(self):
self.__battleResultsService.onResultPosted += self.__showBattleResults
def onAvatarBecomePlayer(self):
self.__clear()
self.__battleResultsService.onResultPosted -= self.__showBattleResults
def getModeSettings(self):
return self.__lobbyContext.getServerSettings().epicBattles
def isEnabled(self):
return self.getModeSettings().isEnabled
def isEpicPrbActive(self):
return False if self.prbEntity is None else bool(
self.prbEntity.getModeFlags() & FUNCTIONAL_FLAG.EPIC)
def isCurrentCycleActive(self):
season = self.getCurrentSeason()
return season.hasActiveCycle(time_utils.getCurrentLocalServerTimestamp(
)) if season is not None else False
def isUnlockVehiclesInBattleEnabled(self):
return any(self.getUnlockableInBattleVehLevels())
def isDailyQuestsUnlocked(self):
currrentLevel, _ = self.getPlayerLevelInfo()
return currrentLevel >= self.getMaxPlayerLevel()
def isDailyQuestsRefreshAvailable(self):
if self.hasPrimeTimesLeftForCurrentCycle():
return True
primeTimePeriodsForDay = self.getPrimeTimesForDay(
time_utils.getCurrentLocalServerTimestamp())
if primeTimePeriodsForDay:
_, periodTimeEnd = max(primeTimePeriodsForDay.values(),
key=itemgetter(1))
periodTimeLeft = periodTimeEnd - time_utils.getCurrentLocalServerTimestamp(
)
return periodTimeLeft > time_utils.getDayTimeLeft()
return False
def getPerformanceGroup(self):
if not self.__performanceGroup:
self.__analyzeClientSystem()
_logger.debug('Current performance group %s',
self.__performanceGroup)
return self.__performanceGroup
def getMaxPlayerLevel(self):
return self.__playerMaxLevel
def getStageLimit(self):
return self.__stageLimit
def getAbilityPointsForLevel(self):
return self.__abilityPointsForLevel
def getValidVehicleLevels(self):
return self.getModeSettings().validVehicleLevels
def getUnlockableInBattleVehLevels(self):
return self.getModeSettings().unlockableInBattleVehLevels
def getSuitableForQueueVehicleLevels(self):
return set(self.getValidVehicleLevels()) - set(
self.getUnlockableInBattleVehLevels())
def getPointsProgressForLevel(self, level):
return self.__levelProgress[level]
def getPointsForLevel(self, level):
return sum(
(self.__levelProgress[level] for level in xrange(level - 1)))
def getLevelProgress(self):
return self.__levelProgress
def getLevelForPoints(self, points):
lvl = 0
while points >= 0 and lvl <= self.__playerMaxLevel:
points -= self.__levelProgress[lvl]
lvl += 1
return lvl - 1
def getAllSkillsInformation(self):
return self.__skillData
def getPlayerLevelInfo(self):
return self.__itemsCache.items.epicMetaGame.playerLevelInfo
def getPlayerRanksInfo(self):
if not self.__rankSettings:
famePtsByRank = self.__metaSettings.metaLevel.get(
'famePtsByRank', {})
rankSettings = getRankSettings()
self.__rankSettings = {
rankLvl:
(extraFamePts, rankSettings.bonus.factor100ByRank[rankLvl])
for rankLvl, extraFamePts in famePtsByRank.iteritems()
}
return self.__rankSettings
def getSeasonData(self):
return self.__itemsCache.items.epicMetaGame.seasonData
def getSkillPoints(self):
return self.__itemsCache.items.epicMetaGame.skillPoints
def getSkillLevels(self):
return self.__itemsCache.items.epicMetaGame.skillLevels
def getSelectedSkills(self, vehicleCD):
selected = self.__itemsCache.items.epicMetaGame.selectedSkills(
vehicleCD)
numSlots = self.getNumAbilitySlots(vehicles.getVehicleType(vehicleCD))
while len(selected) < numSlots:
selected.append(-1)
return selected
def hasSuitableVehicles(self):
requiredLevel = self.getModeSettings().validVehicleLevels
v = self.__itemsCache.items.getVehicles(
REQ_CRITERIA.INVENTORY
| REQ_CRITERIA.VEHICLE.LEVELS(requiredLevel))
return len(v) > 0
def increaseSkillLevel(self, skillID):
BigWorld.player().epicMetaGame.increaseAbility(skillID)
def changeEquippedSkills(self,
skillIDArray,
vehicleCD,
callback=None,
classVehs=False):
if classVehs:
if callback is None:
BigWorld.player().epicMetaGame.setSelectedAbilitiesVehsClass(
skillIDArray, vehicleCD)
else:
BigWorld.player().epicMetaGame.setSelectedAbilitiesVehsClass(
skillIDArray, vehicleCD, callback)
elif callback is None:
BigWorld.player().epicMetaGame.setSelectedAbilities(
skillIDArray, vehicleCD)
else:
BigWorld.player().epicMetaGame.setSelectedAbilities(
skillIDArray, vehicleCD, callback)
return
def getCycleInfo(self, cycleID=None):
season = self.getCurrentSeason()
if season is not None:
return season.getCycleInfo(cycleID)
else:
_logger.warning('No current season')
return
def getCycleOrdinalNumber(self, cycleID):
cycleInfo = self.getCycleInfo(cycleID)
return cycleInfo.ordinalNumber if cycleInfo else None
def getSeasonTimeRange(self):
season = self.getCurrentSeason() or self.getNextSeason()
if season is not None:
cycles = season.getAllCycles()
if cycles:
cycles = list(
sorted(cycles.values(), key=lambda c: c.ordinalNumber))
return (cycles[0].startDate, cycles[-1].endDate)
return (0, 0)
def getAllUnlockedSkillInfoBySkillId(self):
return {
skillID: skill.getSkillInfo()
for skillID, skill in self.__skillData.iteritems()
if skill.isActivated
}
def getUnlockedAbilityIds(self):
return (skill.getSkillInfo().eqID
for skill in self.getAllSkillsInformation().itervalues()
if skill.isActivated and skill.getSkillInfo() is not None)
def getStoredEpicDiscount(self):
return BigWorld.player().epicMetaGame.getStoredDiscount()
def getEventTimeLeft(self):
timeLeft = self.getSeasonTimeRange(
)[1] - time_utils.getCurrentLocalServerTimestamp()
return timeLeft + 1 if timeLeft > 0 else time_utils.ONE_MINUTE
def getStats(self):
return self.__itemsCache.items.epicMetaGame
@process
def openURL(self, url=None):
requestUrl = url or self.getModeSettings().url
if requestUrl:
parsedUrl = yield self.__urlMacros.parse(requestUrl)
if parsedUrl:
self.__showBrowserView(parsedUrl)
def showCustomScreen(self, screen):
if self.getModeSettings().url and EpicBattleScreens.hasValue(screen):
self.openURL('/'.join((self.getModeSettings().url.strip('/'),
screen.value.strip('/'))))
def getNumAbilitySlots(self, vehicleType):
vehClass = getVehicleClassFromVehicleType(vehicleType)
return self.__metaSettings.defaultSlots.get(vehClass, 0)
def getAbilitySlotsOrder(self, vehicleType):
vehClass = getVehicleClassFromVehicleType(vehicleType)
return self.__metaSettings.slots.get(vehClass, (0, 0, 0))
def getAbilitySlotsUnlockOrder(self, vehicleType):
vehClass = getVehicleClassFromVehicleType(vehicleType)
return self.__metaSettings.inBattleReservesByRank.get(
'slotActions').get(vehClass, [[0], [0], [0]])
def getAllLevelRewards(self):
rewardsData = dict()
allQuests = self.__eventsCache.getAllQuests()
for questKey, questData in allQuests.iteritems():
if LEVELUP_TOKEN_TEMPLATE in questKey:
_, _, questNum = questKey.partition(LEVELUP_TOKEN_TEMPLATE)
if questNum:
questLvl = int(questNum)
rewardsData[questLvl] = questData
return rewardsData
def isNeedToTakeReward(self):
currentLevel, _ = self.getPlayerLevelInfo()
rewardsData = self.getAllLevelRewards()
for bonuses in (rewards.getBonuses()
for level, rewards in rewardsData.iteritems()
if level <= currentLevel):
for bonus in bonuses:
if bonus.getName() == EPIC_SELECT_BONUS_NAME:
for tokenID in bonus.getTokens().iterkeys():
if self.__itemsCache.items.tokens.getToken(tokenID):
return True
return False
def getNotChosenRewardCount(self):
count = 0
for token in self.__itemsCache.items.tokens.getTokens().iterkeys():
if not token.startswith(EPIC_CHOICE_REWARD_OFFER_GIFT_TOKENS):
continue
if not self.__offersProvider.getOfferByToken(
token.replace('_gift', '')):
continue
if self.__itemsCache.items.tokens.isTokenAvailable(token):
count += self.__itemsCache.items.tokens.getTokenCount(token)
return count
def hasAnyOfferGiftToken(self):
return any((token.startswith(EPIC_CHOICE_REWARD_OFFER_GIFT_TOKENS)
for token in
self.__itemsCache.items.tokens.getTokens().iterkeys()))
def replaceOfferByGift(self, bonuses):
result = []
for bonus in bonuses:
gift = self.__getReceivedGift(bonus)
if gift:
result.extend(gift.bonuses)
result.append(bonus)
return result
def replaceOfferByReward(self, bonuses):
result = []
for bonus in bonuses:
if bool(self.__getReceivedGift(bonus)):
bonus.updateContext({'isReceived': True})
result.append(bonus)
return result
def __getReceivedGift(self, bonus):
if bonus.getName() == EPIC_SELECT_BONUS_NAME:
bonus.updateContext({'isReceived': False})
for tokenID in bonus.getTokens().iterkeys():
offer = self.__offersProvider.getOfferByToken(
tokenID.replace('_gift', ''))
if offer:
receivedGifts = self.__offersProvider.getReceivedGifts(
offer.id)
if receivedGifts:
for giftId, count in receivedGifts.iteritems():
if count > 0:
return offer.getGift(giftId)
return None
def __invalidateBattleAbilities(self, *_):
if not self.__itemsCache.isSynced():
return
self.__invalidateBattleAbilityItems()
self.__invalidateBattleAbilitiesForVehicle()
def __setData(self):
self.__skillData = {}
skills = self.__metaSettings.rewards.get('combatReserves', {})
maxSkillLvl = self.__metaSettings.maxCombatReserveLevel
eqs = vehicles.g_cache.equipments()
if skills != {}:
for key, value in skills.iteritems():
self.__skillData[key] = EpicMetaGameSkill(
key, maxSkillLvl, value.get('tags'), value.get('price', 0))
lvls = value['levels']
lvlAmount = len(lvls)
found = 0
for eq in eqs.values():
if eq.name in lvls:
lvl = lvls.index(eq.name) + 1
self.__skillData[key].levels[
lvl] = EpicMetaGameSkillLevel(
lvl, eq.id[1], i18n.makeString(eq.userString),
i18n.makeString(eq.shortDescription),
i18n.makeString(eq.longDescription),
i18n.makeString(eq.shortFilterAlert),
i18n.makeString(eq.longFilterAlert),
eq.icon[0])
found += 1
if found == lvlAmount:
break
metaLevel = self.__metaSettings.metaLevel
self.__playerMaxLevel = metaLevel.get('maxLevel', 0)
self.__stageLimit = metaLevel.get('stageLimit', -1)
self.__abilityPointsForLevel = metaLevel.get('abilityPointsForLevel',
[])
levelProgress = metaLevel.get('famePtsToProgress', [])[:]
levelProgress.insert(0, 0)
self.__levelProgress = tuple(levelProgress)
def __clear(self):
self.stopNotification()
self.stopGlobalListening()
self.__lobbyContext.getServerSettings(
).onServerSettingsChange -= self.__updateEpicMetaGameSettings
g_currentVehicle.onChanged -= self.__invalidateBattleAbilities
self.__itemsCache.onSyncCompleted -= self.__invalidateBattleAbilities
g_clientUpdateManager.removeObjectCallbacks(self)
if self.getPerformanceGroup() == EPIC_PERF_GROUP.HIGH_RISK:
self.__lobbyContext.deleteFightButtonConfirmator(
self.__confirmFightButtonPressEnabled)
def __updateEpic(self, diff):
changes = set(diff.keys())
self.__invalidateBattleAbilities()
if changes:
self.onUpdated(diff)
def __updateEpicMetaGameSettings(self, diff):
if 'epic_config' in diff:
self.__setData()
self.onUpdated(diff['epic_config'])
self.__resetTimer()
def __resetTimer(self):
self.startNotification()
self.__timerUpdate()
self.__timerTick()
def __timerUpdate(self):
status, _, _ = self.getPrimeTimeStatus()
self.onPrimeTimeStatusUpdated(status)
def __timerTick(self):
self.onGameModeStatusTick()
def __onEventEnded(self):
self.onEventEnded()
self.__eventEndedNotifier.stopNotification()
self.__eventEndedNotifier.clear()
def __showBattleResults(self, reusableInfo, _, resultsWindow):
if reusableInfo.common.arenaBonusType == ARENA_BONUS_TYPE.EPIC_BATTLE:
arenaUniqueID = reusableInfo.arenaUniqueID
if arenaUniqueID not in self.__showedResultsForArenas:
self.__showedResultsForArenas.append(arenaUniqueID)
self.__showedResultsForArenas = self.__showedResultsForArenas[
-self.MAX_STORED_ARENAS_RESULTS:]
extensionInfo = reusableInfo.personal.avatar.extensionInfo
levelUpInfo = {
'metaLevel': extensionInfo.get('metaLevel'),
'prevMetaLevel': extensionInfo.get('prevMetaLevel'),
'playerRank': extensionInfo.get('playerRank'),
'originalFlXP': extensionInfo.get('originalFlXP'),
'boosterFlXP': extensionInfo.get('boosterFlXP')
}
event_dispatcher.showEpicBattlesAfterBattleWindow(
levelUpInfo, resultsWindow)
def __isInValidPrebattle(self):
if g_prbLoader and g_prbLoader.getDispatcher(
) and g_prbLoader.getDispatcher().getEntity():
currentPrbEntity = g_prbLoader.getDispatcher().getEntity(
).getEntityType()
return currentPrbEntity in (QUEUE_TYPE.EPIC, PREBATTLE_TYPE.EPIC,
PREBATTLE_TYPE.EPIC_TRAINING)
else:
return None
def __invalidateBattleAbilityItems(self):
data = self.__itemsCache.items.getItems(GUI_ITEM_TYPE.BATTLE_ABILITY,
REQ_CRITERIA.EMPTY)
vehicle = g_currentVehicle.item
for item in data.values():
if self.__isInValidPrebattle():
item.isUnlocked = item.innationID in self.getUnlockedAbilityIds(
)
if vehicle is not None:
mayInstall, _ = item.mayInstall(vehicle)
if not mayInstall:
item.isUnlocked = False
item.isUnlocked = False
return
def __invalidateBattleAbilitiesForVehicle(self):
vehicle = g_currentVehicle.item
if vehicle is None or vehicle.descriptor.type.level not in self.__lobbyContext.getServerSettings(
).epicBattles.validVehicleLevels or not self.__isInValidPrebattle():
return
else:
amountOfSlots = self.getNumAbilitySlots(vehicle.descriptor.type)
selectedItems = [None] * amountOfSlots
skillInfo = self.getAllSkillsInformation()
selectedSkills = self.getSelectedSkills(vehicle.intCD)
battleAbilities = self.__itemsCache.items.getItems(
GUI_ITEM_TYPE.BATTLE_ABILITY, REQ_CRITERIA.EMPTY)
for item in battleAbilities.values():
for index, skillID in enumerate(selectedSkills):
if skillID is not None and skillID >= 0:
if skillInfo[skillID].getSkillInfo(
) and item.innationID == skillInfo[
skillID].getSkillInfo().eqID:
selectedItems[index] = item
vehicle.battleAbilities.setLayout(*selectedItems)
vehicle.battleAbilities.setInstalled(*selectedItems)
return
def __analyzeClientSystem(self):
stats = BigWorld.wg_getClientStatistics()
stats['graphicsEngine'] = self.__settingsCore.getSetting(
GRAPHICS.RENDER_PIPELINE)
self.__performanceGroup = EPIC_PERF_GROUP.LOW_RISK
for groupName, conditions in PERFORMANCE_GROUP_LIMITS.iteritems():
for currentLimit in conditions:
condValid = True
systemStats = currentLimit.get(
EPIC_META_GAME_LIMIT_TYPE.SYSTEM_DATA, {})
for key, limit in systemStats.iteritems():
currValue = stats.get(key, None)
if currValue is None or currValue != limit:
condValid = False
hardwareParams = currentLimit.get(
EPIC_META_GAME_LIMIT_TYPE.HARDWARE_PARAMS, {})
for key, limit in hardwareParams.iteritems():
currValue = BigWorld.getAutoDetectGraphicsSettingsScore(
key)
if currValue >= limit:
condValid = False
if condValid:
self.__performanceGroup = groupName
return
return
def __onInventoryUpdate(self, invDiff):
items = {
GUI_ITEM_TYPE.VEHICLE, GUI_ITEM_TYPE.BATTLE_ABILITY,
GUI_ITEM_TYPE.CUSTOMIZATION
}
if items.intersection(invDiff):
self.__invalidateBattleAbilities()
def __updateSounds(self, isEpicSoundMode):
if isEpicSoundMode != self.__isEpicSoundMode:
_FrontLineSounds.onChange(isEpicSoundMode)
self.__isEpicSoundMode = isEpicSoundMode
@async
@process
def __confirmFightButtonPressEnabled(self, callback):
if not self.__isInValidPrebattle():
callback(True)
return
defaults = AccountSettings.getFilterDefault(GUI_START_BEHAVIOR)
filters = self.__settingsCore.serverSettings.getSection(
GUI_START_BEHAVIOR, defaults)
isEpicPerformanceWarningEnabled = not AccountSettings.getSettings(
'isEpicPerformanceWarningClicked')
if isEpicPerformanceWarningEnabled:
result, checkboxChecked = yield DialogsInterface.showI18nCheckBoxDialog(
'epicBattleConfirmDialog')
filters['isEpicPerformanceWarningClicked'] = checkboxChecked
AccountSettings.setSettings('isEpicPerformanceWarningClicked',
checkboxChecked)
else:
result = True
callback(result)
def __showBrowserView(self, url):
from gui.Scaleform.daapi.view.lobby.epicBattle.web_handlers import createFrontlineWebHandlers
webHandlers = createFrontlineWebHandlers()
alias = VIEW_ALIAS.BROWSER_VIEW
g_eventBus.handleEvent(
events.LoadViewEvent(SFViewLoadParams(alias,
getUniqueViewName(alias)),
ctx={
'url':
url,
'webHandlers':
webHandlers,
'returnAlias':
VIEW_ALIAS.LOBBY_HANGAR,
'onServerSettingsChange':
self.__serverSettingsChangeBrowserHandler
}), EVENT_BUS_SCOPE.LOBBY)
def __serverSettingsChangeBrowserHandler(self, browser, diff):
if not diff.get(Configs.EPIC_CONFIG.value, {}).get('isEnabled'):
browser.onCloseView()
@property
def __metaSettings(self):
return self.__lobbyContext.getServerSettings().epicMetaGame
def __onTokensUpdate(self, diff):
if any((key.startswith(EPIC_CHOICE_REWARD_OFFER_GIFT_TOKENS)
for key in diff.keys())):
pass
class ExternalLinksHandler(IExternalLinksController):
def __init__(self):
super(ExternalLinksHandler, self).__init__()
self.__urlMacros = None
return
def init(self):
self.__urlMacros = URLMacros()
addListener = g_eventBus.addListener
for eventType, handlerName in _LISTENERS.iteritems():
handler = getattr(self, handlerName, None)
if not handler:
LOG_ERROR('Handler is not found', eventType, handlerName)
continue
if not callable(handler):
LOG_ERROR('Handler is invalid', eventType, handlerName,
handler)
continue
addListener(eventType, handler)
return
def fini(self):
if self.__urlMacros is not None:
self.__urlMacros.clear()
self.__urlMacros = None
removeListener = g_eventBus.removeListener
for eventType, handlerName in _LISTENERS.iteritems():
handler = getattr(self, handlerName, None)
if handler:
removeListener(eventType, handler)
super(ExternalLinksHandler, self).fini()
return
def open(self, url):
if not url:
LOG_ERROR('URL is empty', url)
return
try:
BigWorld.wg_openWebBrowser(url)
except Exception:
LOG_ERROR('There is error while opening web browser at page:', url)
LOG_CURRENT_EXCEPTION()
@async
@process
def getURL(self, name, params=None, callback=lambda *args: None):
urlSettings = GUI_SETTINGS.lookup(name)
if urlSettings:
url = yield self.__urlMacros.parse(str(urlSettings), params)
else:
url = yield lambda callback: callback('')
callback(url)
def _handleSpecifiedURL(self, event):
self.open(event.url)
@process
def __openParsedUrl(self, urlName, params=None):
parsedUrl = yield self.getURL(urlName, params)
self.open(parsedUrl)
def _handleParsedURL(self, event):
self.__openParsedUrl(event.url)
def _handleOpenRegistrationURL(self, _):
self.__openParsedUrl('registrationURL')
def _handleOpenRecoveryPasswordURL(self, _):
self.__openParsedUrl('recoveryPswdURL')
def _handleOpenPaymentURL(self, _):
self.__openParsedUrl('paymentURL')
def _handleSecuritySettingsURL(self, _):
self.__openParsedUrl('securitySettingsURL')
def _handleSupportURL(self, _):
self.__openParsedUrl('supportURL')
def _handleMigrationURL(self):
self.__openParsedUrl('migrationURL')
def _handleFortDescription(self, _):
self.__openParsedUrl('fortDescription')
def _handleClanSearch(self, _):
self.__openParsedUrl('clanSearch')
def _handleClanCreate(self, _):
self.__openParsedUrl('clanCreate')
def _handleInvitesManagementURL(self, _):
self.__openParsedUrl('invitesManagementURL')
def _handleGmSummaryURL(self, _):
self.__openParsedUrl('globalMapSummary')
def _handleGmPromoSummaryURL(self, _):
self.__openParsedUrl('globalMapPromoSummary')
def _handleGmCapURL(self, _):
self.__openParsedUrl('globalMapCap')
def _handleGmPromoURL(self, _):
self.__openParsedUrl('globalMapPromo')
def _handleOpenPremShopURL(self, _):
self.__openParsedUrl('premShopURL')
def _handleFrontlineChangesURL(self, _):
self.__openParsedUrl('frontlineChangesURL')
def _handleTokenShopURL(self, event):
self.__openParsedUrl('tokenShopURL', event.params)
def _handleTechTreeNewsURL(self, event):
self.__openParsedUrl('techTreeUpdateNewsURL', event.params)
class PromoController(IPromoController):
__browserCtrl = dependency.descriptor(IBrowserController)
__notificationsCtrl = dependency.descriptor(IEventsNotificationsController)
__webController = dependency.descriptor(IWebController)
__settingsCore = dependency.descriptor(ISettingsCore)
__lobbyContext = dependency.descriptor(ILobbyContext)
__logger = dependency.descriptor(IPromoLogger)
__bootcamp = dependency.descriptor(IBootcampController)
def __init__(self):
super(PromoController, self).__init__()
self.__urlMacros = URLMacros()
self.__externalCloseCallback = None
self.__isLobbyInited = False
self.__pendingPromo = None
self.__promoCount = 0
self.__lastUpdateTimeMark = 0
self.__promoData = None
self.__waitingForWebBridgeData = False
self.__battlesFromLastTeaser = 0
self.__wasInBattle = False
self.__hasPendingTeaser = False
self.__isPromoOpen = False
self.__browserCreationCallbacks = {}
self.__browserWatchers = {}
self.__isInHangar = False
self.__isTeaserOpen = False
self.__checkIntervalInBattles = GUI_SETTINGS.checkPromoFrequencyInBattles
self.__em = EventManager()
self.onNewTeaserReceived = Event(self.__em)
self.onPromoCountChanged = Event(self.__em)
self.onTeaserShown = Event(self.__em)
self.onTeaserClosed = Event(self.__em)
return
@sf_lobby
def app(self):
pass
def fini(self):
self.__stop()
self.__pendingPromo = None
self.__urlMacros.clear()
self.__urlMacros = None
self.__externalCloseCallback = None
self.__em.clear()
g_eventBus.removeListener(BrowserEvent.BROWSER_CREATED,
self.__handleBrowserCreated)
self.__browserCreationCallbacks = {}
self.__browserWatchers = {}
super(PromoController, self).fini()
return
def onLobbyInited(self, event):
if not isPlayerAccount():
return
g_eventBus.addListener(BrowserEvent.BROWSER_CREATED,
self.__handleBrowserCreated)
self.__isLobbyInited = True
if self.__needToGetTeasersInfo():
self.__updateWebBrgData()
elif self.__hasPendingTeaser:
self.__tryToShowTeaser()
self.__notificationsCtrl.onEventNotificationsChanged += self.__onEventNotification
if not isPopupsWindowsOpenDisabled():
self.__processPromo(
self.__notificationsCtrl.getEventsNotifications())
self.app.loaderManager.onViewLoaded += self.__onViewLoaded
@property
def checkIntervalInBattles(self):
return self.__checkIntervalInBattles
def setNewTeaserData(self, teaserData):
timestamp = teaserData['timestamp']
if self.__lastUpdateTimeMark < timestamp and not self.__isPromoOpen and not self.__isTeaserOpen:
self.__updateTeaserData(teaserData)
def showFieldPost(self):
url = GUI_SETTINGS.promoscreens
loadingCallback = self.__logger.getLoggingFuture(
action=PromoLogActions.OPEN_FROM_MENU,
type=PromoLogSubjectType.INDEX,
url=url)
self.__showBrowserView(url, loadingCallback, soundSpaceID='field_post')
@process
def showLastTeaserPromo(self):
rowUrl = self.__promoData.get('url', '')
loadingCallback = self.__logger.getLoggingFuture(
self.__promoData,
action=PromoLogActions.OPEN_FROM_TEASER,
type=PromoLogSubjectType.PROMO_SCREEN,
url=rowUrl)
url = yield self.__addAuthParams(rowUrl)
self.__showBrowserView(url, loadingCallback)
def setUnreadPromoCount(self, count):
self.__updatePromoCount(count)
def isTeaserOpen(self):
return self.__isTeaserOpen
def onAvatarBecomePlayer(self):
if self.__isLobbyInited:
self.__battlesFromLastTeaser += 1
self.__stop()
def onDisconnected(self):
self.__stop()
def isActive(self):
return self.__lobbyContext.getServerSettings().isFieldPostEnabled(
) and not self.__bootcamp.isInBootcamp()
def getPromoCount(self):
return self.__promoCount
def showPromo(self, url, closeCallback=None, source=None):
if self.__isLobbyInited:
if not self.__isPromoOpen and not self.__waitingForWebBridgeData:
self.__registerAndShowPromoBrowser(
url, closeCallback,
self.__logger.getLoggingFuture(
action=PromoLogActions.OPEN_IN_OLD,
type=PromoLogSubjectType.PROMO_SCREEN,
source=source,
url=url))
else:
self.__pendingPromo = _PromoData(url, closeCallback, source)
def __needToGetTeasersInfo(self):
return True if self.__battlesFromLastTeaser == 0 else self.__checkIntervalInBattles > 0 and self.__battlesFromLastTeaser % self.__checkIntervalInBattles == 0
def __onTeaserClosed(self, byUser=False):
self.__isTeaserOpen = False
self.onTeaserClosed()
if byUser:
self.__showBubbleTooltip()
def __showBubbleTooltip(self):
storageData = self.__settingsCore.serverSettings.getUIStorage()
if not storageData.get(UI_STORAGE_KEYS.FIELD_POST_HINT_IS_SHOWN):
showBubbleTooltip(i18n.makeString(TOOLTIPS.HEADER_VERSIONINFOHINT))
self.__settingsCore.serverSettings.saveInUIStorage(
{UI_STORAGE_KEYS.FIELD_POST_HINT_IS_SHOWN: True})
@process
def __updateWebBrgData(self):
ctx = PromoGetTeaserRequestCtx()
if self.__battlesFromLastTeaser == 0:
sourceType = PromoLogSourceType.FIRST_LOGIN
else:
sourceType = PromoLogSourceType.AFTER_BATTLE
answerCallback = self.__logger.getLoggingFuture(
action=PromoLogActions.GET_MOST_IMPORTANT, source=sourceType)
self.__waitingForWebBridgeData = True
response = yield self.__webController.sendRequest(ctx=ctx)
self.__waitingForWebBridgeData = False
if response.isSuccess():
self.__updateTeaserData(ctx.getDataObj(response.getData()))
elif self.__hasPendingTeaser:
self.__tryToShowTeaser()
if answerCallback:
answerCallback(success=response.extraCode)
def __onPromoClosed(self, **kwargs):
self.__isPromoOpen = False
self.__showBubbleTooltip()
if self.__externalCloseCallback:
self.__externalCloseCallback()
self.__requestPromoCount()
actionType = PromoLogActions.CLOSED_BY_USER if kwargs.get(
'byUser') else PromoLogActions.KILLED_BY_SYSTEM
self.__logger.logAction(action=actionType,
type=PromoLogSubjectType.PROMO_SCREEN_OR_INDEX,
url=kwargs.get('url'))
@process
def __requestPromoCount(self):
if not self.isActive():
_logger.warning(
'Trying to request unread promos count when promo functionality is disabled'
)
return
ctx = PromoGetUnreadCountRequestCtx()
response = yield self.__webController.sendRequest(ctx=ctx)
if response.isSuccess():
self.__updatePromoCount(ctx.getCount(response))
def __updatePromoCount(self, count):
countChanged = count != self.__promoCount
self.__promoCount = count
if countChanged:
self.onPromoCountChanged()
def __updateTeaserData(self, teaserData):
self.__lastUpdateTimeMark = teaserData['timestamp']
self.__promoData = teaserData['lastPromo']
self.__updatePromoCount(teaserData['count'])
if self.__promoData.get('url'):
self.__tryToShowTeaser()
def __showTeaser(self):
if self.isActive():
self.__battlesFromLastTeaser = 0
self.__hasPendingTeaser = False
self.onNewTeaserReceived(self.__promoData, self.__onTeaserShown,
self.__onTeaserClosed)
else:
_logger.warning(
'Impossible to show teaser, functionality is disabled')
@process
def __onTeaserShown(self, promoID):
self.__isTeaserOpen = True
self.onTeaserShown()
yield self.__webController.sendRequest(
PromoSendTeaserShownRequestCtx(promoID))
def __tryToShowTeaser(self):
if self.__isLobbyInited and self.__isInHangar and not self.__waitingForWebBridgeData:
self.__showTeaser()
else:
self.__hasPendingTeaser = True
def __stop(self):
if self.app and self.app.loaderManager:
self.app.loaderManager.onViewLoaded -= self.__onViewLoaded
self.__isLobbyInited = False
self.__isInHangar = False
self.__isPromoOpen = False
self.__externalCloseCallback = None
self.__isTeaserOpen = False
self.__notificationsCtrl.onEventNotificationsChanged -= self.__onEventNotification
g_eventBus.removeListener(BrowserEvent.BROWSER_CREATED,
self.__handleBrowserCreated)
self.__browserCreationCallbacks = {}
watcherKeys = self.__browserWatchers.keys()
for browserID in watcherKeys:
self.__clearWatcher(browserID)
return
def __processPromo(self, promos):
if not self.__isPromoOpen and not self.__waitingForWebBridgeData:
logData = {
'action': PromoLogActions.OPEN_IN_OLD,
'type': PromoLogSubjectType.PROMO_SCREEN
}
if self.__pendingPromo is not None:
promoData = self.__pendingPromo
logData.update({
'source': promoData.source,
'url': promoData.url
})
loadingCallback = self.__logger.getLoggingFuture(**logData)
self.__registerAndShowPromoBrowser(promoData.url,
promoData.closeCallback,
loadingCallback)
self.__pendingPromo = None
return
promo = findFirst(
lambda item: item.eventType.startswith(
gc_constants.PROMO.TEMPLATE.ACTION), promos)
if promo:
logData.update({
'source': PromoLogSourceType.SSE,
'url': promo.data
})
self.__showBrowserView(
promo.data, self.__logger.getLoggingFuture(**logData))
return
def __onEventNotification(self, added, _):
self.__processPromo(added)
def __registerAndShowPromoBrowser(self, url, closeCallback,
loadingCallback):
self.__externalCloseCallback = closeCallback
self.__showBrowserView(url, loadingCallback)
@process
def __showBrowserView(self, url, loadingCallback=None, soundSpaceID=None):
promoUrl = yield self.__urlMacros.parse(url)
self.__registerLoadingCallback(promoUrl, loadingCallback)
_showBrowserView(promoUrl,
self.__onPromoClosed,
soundSpaceID=soundSpaceID)
self.__isPromoOpen = True
def __registerLoadingCallback(self, url, callback):
if callback is not None:
self.__browserCreationCallbacks[url] = callback
return
def __handleBrowserCreated(self, event):
url = event.ctx.get('url')
if url in self.__browserCreationCallbacks:
callback = self.__browserCreationCallbacks.pop(url)
browserID = event.ctx.get('browserID')
browser = self.__browserCtrl.getBrowser(browserID)
if browser is None:
return
def callbackWrapper(clbUrl, _, statusCode):
if clbUrl == url:
callback(url=url, success=statusCode)
self.__clearWatcher(browserID)
browser.onLoadEnd += callbackWrapper
self.__browserWatchers[browserID] = callbackWrapper
return
def __clearWatcher(self, browserID):
if browserID in self.__browserWatchers:
watcher = self.__browserWatchers.pop(browserID)
browser = self.__browserCtrl.getBrowser(browserID)
if browser is not None:
browser.onLoadEnd -= watcher
return
@async
@process
def __addAuthParams(self, url, callback):
if not url or not self.__webController:
callback(url)
accessTokenData = yield self.__webController.getAccessTokenData(
force=True)
params = {
'access_token': str(accessTokenData.accessToken),
'spa_id': BigWorld.player().databaseID
}
callback(url_formatters.addParamsToUrlQuery(url, params))
def __onViewLoaded(self, pyView, _):
if self.__isLobbyInited:
if pyView.alias == VIEW_ALIAS.LOBBY_HANGAR:
self.__isInHangar = True
if self.__hasPendingTeaser:
self.__tryToShowTeaser()
elif pyView.viewType == ViewTypes.LOBBY_SUB:
self.__isInHangar = False
class ExternalLinksHandler(IExternalLinksController):
__loginManager = dependency.descriptor(ILoginManager)
def __init__(self):
super(ExternalLinksHandler, self).__init__()
self.__urlMacros = None
self.__linksHandlers = None
return
def init(self):
self.__urlMacros = URLMacros()
addListener = g_eventBus.addListener
for eventType, handlerName in _LISTENERS.iteritems():
handler = getattr(self, handlerName, None)
if not handler:
_logger.error('Handler is not found %s %s', eventType,
handlerName)
continue
if not callable(handler):
_logger.error('Handler is invalid %s %s %r', eventType,
handlerName, handler)
continue
addListener(eventType, handler)
return
def fini(self):
if self.__urlMacros is not None:
self.__urlMacros.clear()
self.__urlMacros = None
removeListener = g_eventBus.removeListener
for eventType, handlerName in _LISTENERS.iteritems():
handler = getattr(self, handlerName, None)
if handler:
removeListener(eventType, handler)
super(ExternalLinksHandler, self).fini()
return
def open(self, url):
if not url:
_logger.error('URL is empty %r', url)
return
handled = False
for handler in self._getHandlers():
handled = handler.handle(url)
if handled:
break
if not handled:
_logger.error('Cant handle external link: %s', url)
@async
@process
def getURL(self, name, params=None, callback=lambda *args: None):
urlSettings = GUI_SETTINGS.lookup(name)
if urlSettings:
url = yield self.__urlMacros.parse(str(urlSettings), params)
else:
url = yield lambda callback: callback('')
callback(url)
def externalAllowed(self, url):
for handler in self._getHandlers():
result = handler.checkHandle(url)
if result.handled:
return result.externalAllowed
return False
def _handleSpecifiedURL(self, event):
self.open(event.url)
@process
def __openParsedUrl(self, urlName, params=None):
parsedUrl = yield self.getURL(urlName, params)
self.open(parsedUrl)
def _handleParsedURL(self, event):
self.__openParsedUrl(event.url)
def _handleOpenRegistrationURL(self, _):
self.__openParsedUrl('registrationURL')
def _handleOpenRecoveryPasswordURL(self, _):
self.__openParsedUrl('recoveryPswdURL')
def _handleOpenPaymentURL(self, _):
self.__openParsedUrl('paymentURL')
def _handleSecuritySettingsURL(self, _):
self.__openParsedUrl('securitySettingsURL')
def _handleClanRulesURL(self, _):
self.__openParsedUrl('clanRulesURL')
def _handleSupportURL(self, _):
self.__openParsedUrl('supportURL')
def _handleMigrationURL(self):
self.__openParsedUrl('migrationURL')
def _handleFortDescription(self, _):
self.__openParsedUrl('fortDescription')
def _handleClanSearch(self, _):
self.__openParsedUrl('clanSearch')
def _handleClanCreate(self, _):
self.__openParsedUrl('clanCreate')
def _handleInvitesManagementURL(self, _):
self.__openParsedUrl('invitesManagementURL')
def _handleGmSummaryURL(self, _):
self.__openParsedUrl('globalMapSummary')
def _handleGmPromoSummaryURL(self, _):
self.__openParsedUrl('globalMapPromoSummary')
def _handleGmCapURL(self, _):
self.__openParsedUrl('globalMapCap')
def _handleGmPromoURL(self, _):
self.__openParsedUrl('globalMapPromo')
def _handleOpenPremShopURL(self, _):
self.__openParsedUrl('premShopURL')
def _handleFrontlineChangesURL(self, _):
self.__openParsedUrl('frontlineChangesURL')
def _handleTokenShopURL(self, event):
self.__openParsedUrl('tokenShopURL', event.params)
def _getHandlers(self):
if not self.__linksHandlers:
self.__linksHandlers = []
if self.__loginManager.isWgcSteam:
self.__linksHandlers.append(external.PremShopLinksHandler())
self.__linksHandlers.append(
external.AddPlatformTagLinksHandler())
self.__linksHandlers.append(
external.PremShopLinksForArgsUrlHandler())
self.__linksHandlers.append(
external.AddPlatformTagLinksToArgsUrlHandler())
self.__linksHandlers.append(external.OpenBrowserHandler())
return self.__linksHandlers
def __init__(self, ctx):
super(PersonalMissionFirstEntryView, self).__init__(ctx)
self.__urlMacros = URLMacros()
self.__settings = GUI_SETTINGS.personalMissions.get('welcomeVideo', {})
self.__cardsLen = len(self.__CARDS)
class PersonalMissionFirstEntryView(LobbySubView,
PersonalMissionFirstEntryViewMeta):
_COMMON_SOUND_SPACE = PERSONAL_MISSIONS_SOUND_SPACE
__settingsCore = dependency.descriptor(ISettingsCore)
__CARDS = (3, 3, 4, 4)
__R_PERSONAL_MISSION_FIRST_ENTRY_VIEW = R.strings.personal_missions.PersonalMissionFirstEntryView
def __init__(self, ctx):
super(PersonalMissionFirstEntryView, self).__init__(ctx)
self.__urlMacros = URLMacros()
self.__settings = GUI_SETTINGS.personalMissions.get('welcomeVideo', {})
self.__cardsLen = len(self.__CARDS)
def playVideo(self):
if self.__settings.get('isEnabled', False):
self.__showVideo()
def backBtnClicked(self):
self.fireEvent(events.LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.LOBBY_PERSONAL_MISSIONS)),
scope=EVENT_BUS_SCOPE.LOBBY)
def onViewClose(self, isAcceptBtnClick=False):
if isAcceptBtnClick:
self.__settingsCore.serverSettings.saveInUIStorage(
{PM_TUTOR_FIELDS.GREETING_SCREEN_SHOWN: True})
self.fireEvent(events.LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.LOBBY_PERSONAL_MISSIONS)),
scope=EVENT_BUS_SCOPE.LOBBY)
else:
self.fireEvent(events.LoadViewEvent(
SFViewLoadParams(VIEW_ALIAS.LOBBY_HANGAR)),
scope=EVENT_BUS_SCOPE.LOBBY)
def onCardClick(self, cardIndex):
self.__updateDetailedData(cardIndex)
def onNextCardClick(self, cardIndex):
self.__updateDetailedData(cardIndex + 1)
def onPrevCardClick(self, cardIndex):
self.__updateDetailedData(cardIndex - 1)
def _populate(self):
super(PersonalMissionFirstEntryView, self)._populate()
infoBlocks = [
self.__makeTileData(cardIndex)
for cardIndex in xrange(0, self.__cardsLen)
]
firstEntry = not self.__settingsCore.serverSettings.getUIStorage().get(
PM_TUTOR_FIELDS.GREETING_SCREEN_SHOWN)
self.as_setInitDataS({
'titleLabel':
PERSONAL_MISSIONS.PERSONALMISSIONFIRSTENTRYVIEW_TITLE,
'bigBtnLabel':
PERSONAL_MISSIONS.PERSONALMISSIONFIRSTENTRYVIEW_ACKNOWLEDGEBTN,
'playVideoBtnLabel':
text_styles.concatStylesToSingleLine(
icons.makeImageTag(
RES_ICONS.MAPS_ICONS_PERSONALMISSIONS_PLAYICON,
width=14,
height=15,
vSpace=-2),
i18n.makeString(PERSONAL_MISSIONS.
PERSONALMISSIONFIRSTENTRYVIEW_VIDEOBTNLABEL)),
'playVideoBtnVisible':
self.__settings.get('isEnabled', False),
'bgSource':
RES_ICONS.MAPS_ICONS_PERSONALMISSIONS_INFOSCREENBG,
'infoBlocks':
infoBlocks,
'backBtnLabel':
PERSONAL_MISSIONS.HEADER_BACKBTN_LABEL,
'isFirstEntry':
firstEntry
})
self.soundManager.setRTPC(SOUNDS.RTCP_OVERLAY,
SOUNDS.MAX_MISSIONS_ZOOM)
def _dispose(self):
self.soundManager.setRTPC(SOUNDS.RTCP_OVERLAY,
SOUNDS.MIN_MISSIONS_ZOOM)
super(PersonalMissionFirstEntryView, self)._dispose()
def __updateDetailedData(self, cardIndex):
cardIndex = self.__normalizeSlotIndex(cardIndex)
blocksLen = self.__CARDS[cardIndex]
blocks = []
for blockIndex in xrange(0, blocksLen):
blocks.append({
'title':
PERSONAL_MISSIONS.getBlockTitle(cardIndex, blockIndex),
'description':
PERSONAL_MISSIONS.getBlockDescription(cardIndex, blockIndex),
'image':
RES_ICONS.getBlockImageByStep(cardIndex, blockIndex)
})
item = self.__R_PERSONAL_MISSION_FIRST_ENTRY_VIEW.dyn(
'item{}'.format(cardIndex))
data = {
'index':
cardIndex,
'icon':
RES_ICONS.getInfoIcon(cardIndex),
'title':
PERSONAL_MISSIONS.getCardHeader(cardIndex),
'description':
PERSONAL_MISSIONS.getCardInnerDescription(cardIndex),
'blocks':
blocks,
'notificationIcon':
RES_ICONS.MAPS_ICONS_LIBRARY_WARNINGICON_1,
'notificationLabel':
backport.text(item.warning())
if item and 'warning' in item.keys() else ''
}
self.as_setDetailedCardDataS(data)
@process
def __showVideo(self):
url = yield self.__urlMacros.parse(self.__settings.get('url'))
webHandlers = webApiCollection(ui_web_api.CloseViewWebApi,
sound_web_api.SoundWebApi,
sound_web_api.HangarSoundWebApi)
ctx = {
'url': url,
'webHandlers': webHandlers,
'returnAlias': self.alias
}
showPersonalMissionBrowserView(ctx)
@staticmethod
def __makeTileData(cardIndex):
return {
'index': cardIndex,
'iconSource': RES_ICONS.getInfoIcon(cardIndex),
'titleLabel': PERSONAL_MISSIONS.getCardHeader(cardIndex),
'descriptionLabel': PERSONAL_MISSIONS.getCardDescription(cardIndex)
}
def __normalizeSlotIndex(self, slotIndex):
if slotIndex >= self.__cardsLen:
return 0
return self.__cardsLen - 1 if slotIndex < 0 else slotIndex
def __init__(self):
super(OpenBrowserOnClickComponent, self).__init__()
self.__urlParser = URLMacros()
class BattleRoyaleController(Notifiable, SeasonProvider,
IBattleRoyaleController, IGlobalListener):
__lobbyContext = dependency.descriptor(ILobbyContext)
__eventsCache = dependency.descriptor(IEventsCache)
__itemsCache = dependency.descriptor(IItemsCache)
__hangarsSpace = dependency.descriptor(IHangarSpace)
__settingsCore = dependency.descriptor(ISettingsCore)
__hangarSpacesSwitcher = dependency.descriptor(IHangarSpacesSwitcher)
__hangarSpaceReloader = dependency.descriptor(IHangarSpaceReloader)
__notificationsCtrl = dependency.descriptor(IEventsNotificationsController)
__sessionProvider = dependency.descriptor(IBattleSessionProvider)
__c11nService = dependency.descriptor(ICustomizationService)
__connectionMgr = dependency.descriptor(IConnectionManager)
__battleRoyaleTournamentController = dependency.descriptor(
IBattleRoyaleTournamentController)
__bootcamp = dependency.descriptor(IBootcampController)
TOKEN_QUEST_ID = 'token:br:title:'
MAX_STORED_ARENAS_RESULTS = 20
def __init__(self):
super(BattleRoyaleController, self).__init__()
self.onUpdated = Event.Event()
self.onPrimeTimeStatusUpdated = Event.Event()
self.onSpaceUpdated = Event.Event()
self.__clientValuesInited = False
self.__clientShields = {}
self.__performanceGroup = None
self.__serverSettings = None
self.__battleRoyaleSettings = None
self.__wasInLobby = False
self.__equipmentCount = {}
self.__equipmentSlots = tuple()
self.__voControl = None
self.__defaultHangars = {}
self.__c11nVisible = False
self.__urlMacros = None
self.__isNeedToUpdateHeroTank = False
return
def init(self):
super(BattleRoyaleController, self).init()
self.__voControl = BRVoiceOverController()
self.__voControl.init()
self.__urlMacros = URLMacros()
self.addNotificator(SimpleNotifier(self.getTimer, self.__timerUpdate))
def fini(self):
self.__voControl.fini()
self.__voControl = None
self.__equipmentCount = None
self.__defaultHangars = None
self.__urlMacros = None
self.onUpdated.clear()
self.onPrimeTimeStatusUpdated.clear()
self.clearNotification()
super(BattleRoyaleController, self).fini()
return
def wasInLobby(self):
return self.__wasInLobby
def onLobbyInited(self, event):
super(BattleRoyaleController, self).onLobbyInited(event)
if not self.__clientValuesInited:
self.__clientValuesInited = True
g_clientUpdateManager.addCallbacks(
{'battleRoyale': self.__updateRoyale})
self.startNotification()
self.startGlobalListening()
self.__hangarsSpace.onSpaceChangedByAction += self.__onSpaceChanged
self.__hangarsSpace.onSpaceChanged += self.__onSpaceChanged
self.__hangarsSpace.onVehicleChanged += self.__onVehicleChanged
self.__c11nService.onVisibilityChanged += self.__onC11nVisibilityChanged
self.__notificationsCtrl.onEventNotificationsChanged += self.__onEventNotification
self.__onEventNotification(
self.__notificationsCtrl.getEventsNotifications())
self.__battleRoyaleTournamentController.onSelectBattleRoyaleTournament += self.__selectBattleRoyaleTournament
self.__updateMode()
self.__wasInLobby = True
if not self.__hangarsSpace.spaceInited or self.__hangarsSpace.spaceLoading(
):
self.__hangarsSpace.onSpaceCreate += self.__onSpaceCreate
else:
self.__updateSpace()
nextTick(self.__eventAvailabilityUpdate)()
def __onEventNotification(self, added, removed=()):
for evNotification in removed:
if evNotification.eventType in (SERVER_CMD_CHANGE_HANGAR,
SERVER_CMD_CHANGE_HANGAR_PREM):
self.__defaultHangars[evNotification.eventType ==
SERVER_CMD_CHANGE_HANGAR_PREM] = None
for evNotification in added:
if evNotification.eventType in (SERVER_CMD_CHANGE_HANGAR,
SERVER_CMD_CHANGE_HANGAR_PREM):
try:
data = json.loads(evNotification.data)
path = data['hangar']
except Exception:
path = evNotification.data
self.__defaultHangars[evNotification.eventType ==
SERVER_CMD_CHANGE_HANGAR_PREM] = path
return
def onDisconnected(self):
self.__wasInLobby = False
self.__clearClientValues()
self.__clear()
super(BattleRoyaleController, self).onDisconnected()
def onAccountBecomePlayer(self):
self.__onServerSettingsChanged(self.__lobbyContext.getServerSettings())
super(BattleRoyaleController, self).onAccountBecomePlayer()
def onAvatarBecomePlayer(self):
self.__clear()
if self.__sessionProvider.arenaVisitor.getArenaBonusType(
) in ARENA_BONUS_TYPE.BATTLE_ROYALE_RANGE:
self.__voControl.activate()
else:
self.__voControl.deactivate()
self.__voControl.onAvatarBecomePlayer()
super(BattleRoyaleController, self).onAvatarBecomePlayer()
def getModeSettings(self):
return self.__lobbyContext.getServerSettings().battleRoyale
def isEnabled(self):
return self.getModeSettings().isEnabled
def getEndTime(self):
return self.getCurrentSeason().getCycleEndDate()
def getPerformanceGroup(self):
if not self.__performanceGroup:
self.__analyzeClientSystem()
_logger.debug('Current performance group %s',
self.__performanceGroup)
return self.__performanceGroup
def getDefaultAmmoCount(self, itemKey, intCD=None, vehicleName=None):
if itemKey in AmmoTypes.SHELLS or itemKey in AmmoTypes.CHARGES:
return self.__equipmentCount.get(itemKey, 0)
else:
if itemKey == AmmoTypes.ITEM:
if intCD is None:
_logger.error(
'Cannot get count of equipment. Equipment id not specified'
)
return 0
if vehicleName is None:
_logger.error(
"Cannot get count of '%r' equipment. Vehicle not specified",
intCD)
return 0
vehiclesSlotsConfig = self.getModeSettings(
).vehiclesSlotsConfig
if vehicleName not in vehiclesSlotsConfig:
_logger.error(
"Cannot get count of '%r' equipment. Vehicle '%r' not found",
intCD, vehicleName)
return 0
for chargeId, equipmentId in vehiclesSlotsConfig[
vehicleName].iteritems():
if equipmentId == intCD:
return self.getDefaultAmmoCount(chargeId)
else:
_logger.warning(
"Can't get default ammo count. Unknown item key: '%r'.",
itemKey)
return 0
def getVehicleSlots(self):
return self.__equipmentSlots
def getBrVehicleEquipmentIds(self, vehicleName):
vehiclesSlotsConfig = self.getModeSettings().vehiclesSlotsConfig
if vehicleName not in vehiclesSlotsConfig:
_logger.error(
"Get equipment for vehicle '%r' failed. Vehicle not found. Slots config %s",
vehicleName, vehiclesSlotsConfig)
return None
else:
vehiclesSlots = vehiclesSlotsConfig[vehicleName]
result = []
for chargeName in sorted(vehiclesSlots.keys()):
result.append(vehiclesSlots[chargeName])
return result
@staticmethod
def getBrCommanderSkills():
result = []
if g_currentVehicle.isPresent():
vehicle = g_currentVehicle.item
for _, tankman in vehicle.crew:
if tankman is not None:
for skill in tankman.skills:
result.append(skill)
return result
def isActive(self):
_, isCycleActive = self.getCurrentCycleInfo()
return self.isEnabled() and self.getCurrentSeason(
) is not None and isCycleActive
def isBattleRoyaleMode(self):
if self.prbDispatcher is None:
return False
else:
state = self.prbDispatcher.getFunctionalState()
return self.__isBattleRoyaleMode(
state) or self.__isBattleRoyaleTournamentMode(state)
def __isBattleRoyaleMode(self, state):
return state.isInPreQueue(
queueType=QUEUE_TYPE.BATTLE_ROYALE) or state.isInUnit(
PREBATTLE_TYPE.BATTLE_ROYALE)
def __isBattleRoyaleTournamentMode(self, state):
return state.isInPreQueue(
queueType=QUEUE_TYPE.BATTLE_ROYALE_TOURNAMENT) or state.isInUnit(
PREBATTLE_TYPE.BATTLE_ROYALE_TOURNAMENT)
def isBattlePassAvailable(self, bonusType):
battlePassConfig = self.__lobbyContext.getServerSettings(
).getBattlePassConfig()
return battlePassConfig.isEnabled(
) and battlePassConfig.isGameModeEnabled(bonusType)
def isInBattleRoyaleSquad(self):
dispatcher = self.prbDispatcher
if dispatcher is not None:
state = dispatcher.getFunctionalState()
return state.isInUnit(PREBATTLE_TYPE.BATTLE_ROYALE)
else:
return False
def onPrbEntitySwitched(self):
self.__updateMode()
self.__updateSpace()
def selectRoyaleBattle(self):
if not self.isEnabled():
return
self.__selectRoyaleBattle()
def setDefaultHangarEntryPoint(self):
if self.__battleRoyaleTournamentController.isSelected():
self.__battleRoyaleTournamentController.leaveBattleRoyaleTournament(
isChangingToBattleRoyaleHangar=True)
def isGeneralHangarEntryPoint(self):
return not self.__battleRoyaleTournamentController.isSelected()
def selectRandomBattle(self):
dispatcher = g_prbLoader.getDispatcher()
if dispatcher is None:
_logger.error('Prebattle dispatcher is not defined')
return
else:
self.__doSelectRandomPrb(dispatcher)
return
def getPlayerLevelInfo(self):
return self.__itemsCache.items.battleRoyale.accTitle
def getStats(self):
return self.__itemsCache.items.battleRoyale
@process
def openURL(self, url=None):
requestUrl = url or self.__battleRoyaleSettings.url
if requestUrl:
parsedUrl = yield self.__urlMacros.parse(requestUrl)
if parsedUrl:
self.__showBrowserView(parsedUrl)
def getQuests(self):
_, isCycleActive = self.getCurrentCycleInfo()
return {
k: v
for k, v in self.__eventsCache.getQuests().items()
if v.getGroupID() == BATTLE_ROYALE_GROUPS_ID
and self.__tokenIsValid(v)
} if self.isGeneralHangarEntryPoint() and isCycleActive else {}
def isDailyQuestsRefreshAvailable(self):
if self.hasPrimeTimesLeftForCurrentCycle():
return True
serversPeriodsMapping = self.getPrimeTimesForDay(
time_utils.getCurrentLocalServerTimestamp())
periods = []
for _, dayPeriods in serversPeriodsMapping.items():
periods.append(max([periodEnd for _, periodEnd in dayPeriods]))
if periods:
periodTimeLeft = max(
periods) - time_utils.getCurrentLocalServerTimestamp()
return periodTimeLeft > time_utils.getDayTimeLeft()
return False
def __selectRoyaleBattle(self):
dispatcher = g_prbLoader.getDispatcher()
if dispatcher is None:
_logger.error('Prebattle dispatcher is not defined')
return
else:
self.__doSelectBattleRoyalePrb(dispatcher)
return
def __selectBattleRoyaleTournament(self):
dispatcher = g_prbLoader.getDispatcher()
if dispatcher is None:
_logger.error('Prebattle dispatcher is not defined')
return
else:
self.__doSelectBattleRoyaleTournamentPrb(dispatcher)
return
def __showBrowserView(self, url):
webHandlers = createBattleRoyaleWebHanlders()
alias = VIEW_ALIAS.BROWSER_VIEW
g_eventBus.handleEvent(
events.LoadViewEvent(SFViewLoadParams(alias,
getUniqueViewName(alias)),
ctx={
'url':
url,
'webHandlers':
webHandlers,
'returnAlias':
VIEW_ALIAS.LOBBY_HANGAR,
'onServerSettingsChange':
self.__serverSettingsChangeBrowserHandler
}), EVENT_BUS_SCOPE.LOBBY)
def __serverSettingsChangeBrowserHandler(self, browser, diff):
if not diff.get(Configs.BATTLE_ROYALE_CONFIG.value,
{}).get('isEnabled'):
browser.onCloseView()
def _createSeason(self, cycleInfo, seasonData):
return BattleRoyaleSeason(cycleInfo, seasonData)
def __onSpaceChanged(self):
switchItems = self.__hangarSpacesSwitcher.itemsToSwitch
if self.isBattleRoyaleMode(
) and self.__hangarSpacesSwitcher.currentItem != switchItems.BATTLE_ROYALE:
self.selectRandomBattle()
def __eventAvailabilityUpdate(self, *_):
if g_prbLoader.getDispatcher() is None:
return
elif self.__battleRoyaleTournamentController.isSelected():
return
else:
battleRoyaleEnabled = self.isEnabled() and self.getCurrentSeason(
) is not None
isSelectRandom = not battleRoyaleEnabled and self.isBattleRoyaleMode(
)
if battleRoyaleEnabled and not self.isActive():
currTime = time_utils.getCurrentLocalServerTimestamp()
cycle = self.getCurrentSeason().getNextByTimeCycle(currTime)
isSelectRandom = cycle is None
if isSelectRandom:
self.selectRandomBattle()
return
def __onSpaceCreate(self):
nextTick(self.__updateSpace)()
def __updateSpace(self):
if not self.__c11nVisible and self.__hangarsSpace.spaceInited and not self.__hangarsSpace.spaceLoading(
):
switchItems = self.__hangarSpacesSwitcher.itemsToSwitch
isBrSpace = self.__hangarSpacesSwitcher.currentItem == switchItems.BATTLE_ROYALE
isBrMode = self.isBattleRoyaleMode()
if isBrMode and not isBrSpace:
g_eventBus.handleEvent(events.HangarSpacesSwitcherEvent(
events.HangarSpacesSwitcherEvent.SWITCH_TO_HANGAR_SPACE,
ctx={'switchItemName': switchItems.BATTLE_ROYALE}),
scope=EVENT_BUS_SCOPE.LOBBY)
self.__isNeedToUpdateHeroTank = True
elif not isBrMode and isBrSpace:
defaultHangarPath = self.__defaultHangars.get(
self.__hangarsSpace.isPremium)
if defaultHangarPath is not None:
self.__hangarSpaceReloader.changeHangarSpace(
defaultHangarPath)
else:
g_eventBus.handleEvent(events.HangarSpacesSwitcherEvent(
events.HangarSpacesSwitcherEvent.
SWITCH_TO_HANGAR_SPACE,
ctx={'switchItemName': switchItems.DEFAULT}),
scope=EVENT_BUS_SCOPE.LOBBY)
self.onSpaceUpdated()
return
def __updateMode(self):
if self.isBattleRoyaleMode():
self.__enableRoyaleMode()
elif not self.__bootcamp.isInBootcamp():
self.__disableRoyaleMode()
def __enableRoyaleMode(self):
royaleVehicleID = AccountSettings.getFavorites(ROYALE_VEHICLE)
if not royaleVehicleID or self.__itemsCache.items.getVehicle(
royaleVehicleID) is None:
criteria = REQ_CRITERIA.VEHICLE.HAS_TAGS(
[VEHICLE_TAGS.BATTLE_ROYALE]) | REQ_CRITERIA.INVENTORY
vehicles = self.__itemsCache.items.getVehicles
royaleVehicle = first(
sorted(vehicles(criteria=criteria).values(),
key=lambda item: item.intCD))
if royaleVehicle:
royaleVehicleID = royaleVehicle.invID
if self.__c11nVisible:
pass
elif royaleVehicleID:
g_currentVehicle.selectVehicle(royaleVehicleID)
else:
g_currentVehicle.selectNoVehicle()
self.__voControl.activate()
return
def __disableRoyaleMode(self):
storedVehInvID = AccountSettings.getFavorites(CURRENT_VEHICLE)
if not storedVehInvID:
criteria = REQ_CRITERIA.INVENTORY | ~REQ_CRITERIA.VEHICLE.HAS_TAGS(
[VEHICLE_TAGS.BATTLE_ROYALE])
vehicle = first(
self.__itemsCache.items.getVehicles(
criteria=criteria).values())
if vehicle:
storedVehInvID = vehicle.invID
if storedVehInvID:
g_currentVehicle.selectVehicle(storedVehInvID)
else:
g_currentVehicle.selectNoVehicle()
self.__voControl.deactivate()
@process
def __doSelectBattleRoyaleTournamentPrb(self, dispatcher):
yield dispatcher.doSelectAction(
PrbAction(PREBATTLE_ACTION_NAME.BATTLE_ROYALE_TOURNAMENT))
@process
def __doSelectBattleRoyalePrb(self, dispatcher):
yield dispatcher.doSelectAction(
PrbAction(PREBATTLE_ACTION_NAME.BATTLE_ROYALE))
@process
def __doSelectRandomPrb(self, dispatcher):
yield dispatcher.doSelectAction(PrbAction(
PREBATTLE_ACTION_NAME.RANDOM))
@process
def fightClick(self):
dispatcher = g_prbLoader.getDispatcher()
if not dispatcher:
return
lobbyContext = dependency.instance(ILobbyContext)
navigationPossible = yield lobbyContext.isHeaderNavigationPossible()
fightButtonPressPossible = yield lobbyContext.isFightButtonPressPossible(
)
if navigationPossible and fightButtonPressPossible:
if dispatcher:
dispatcher.doAction(
PrbAction(PREBATTLE_ACTION_NAME.BATTLE_ROYALE))
else:
_logger.error('Prebattle dispatcher is not defined')
@process
def _doLeaveBattleRoyalePrb(self, dispatcher):
if dispatcher is None:
return
else:
yield dispatcher.doLeaveAction(LeavePrbAction())
return
def __getBattleRoyaleSettings(self):
generalSettings = self.__serverSettings.battleRoyale
cycleID = None
now = time_utils.getCurrentLocalServerTimestamp()
_, cycleInfo = season_common.getSeason(generalSettings.asDict(), now)
if cycleInfo:
_, _, _, cycleID = cycleInfo
for season in generalSettings.seasons.values():
if cycleID in season.get('cycles', {}):
return generalSettings.replace(season).replace(
season['cycles'][cycleID])
return generalSettings
def __getCachedSettings(self):
return self.__battleRoyaleSettings
def __timerUpdate(self):
status, _, _ = self.getPrimeTimeStatus()
self.onPrimeTimeStatusUpdated(status)
self.__eventAvailabilityUpdate()
def __resetTimer(self):
self.startNotification()
self.__timerUpdate()
def __onServerSettingsChanged(self, serverSettings):
if self.__serverSettings is not None:
self.__serverSettings.onServerSettingsChange -= self.__updateRoyaleSettings
self.__serverSettings = serverSettings
self.__battleRoyaleSettings = self.__getBattleRoyaleSettings()
self.__updateEquipmentCount()
self.__serverSettings.onServerSettingsChange += self.__updateRoyaleSettings
return
def __updateRoyaleSettings(self, diff):
if Configs.BATTLE_ROYALE_CONFIG.value not in diff:
return
else:
self.__eventAvailabilityUpdate()
self.__battleRoyaleSettings = self.__getBattleRoyaleSettings()
self.__updateEquipmentCount()
self.__divisions = None
self.onUpdated()
self.__resetTimer()
return
def __clear(self):
self.stopNotification()
self.stopGlobalListening()
self.__hangarsSpace.onSpaceChangedByAction -= self.__onSpaceChanged
self.__hangarsSpace.onSpaceChanged -= self.__onSpaceChanged
self.__hangarsSpace.onSpaceCreate -= self.__onSpaceCreate
self.__hangarsSpace.onVehicleChanged -= self.__onVehicleChanged
self.__notificationsCtrl.onEventNotificationsChanged -= self.__onEventNotification
self.__c11nService.onVisibilityChanged -= self.__onC11nVisibilityChanged
self.__battleRoyaleTournamentController.onSelectBattleRoyaleTournament -= self.__selectBattleRoyaleTournament
self.__defaultHangars = {}
g_clientUpdateManager.removeObjectCallbacks(self)
def __clearClientValues(self):
if self.__serverSettings is not None:
self.__serverSettings.onServerSettingsChange -= self.__updateRoyaleSettings
self.__serverSettings = None
self.__clientValuesInited = False
return
def __updateRoyale(self, _):
self.onUpdated()
self.__resetTimer()
def __analyzeClientSystem(self):
stats = BigWorld.wg_getClientStatistics()
stats['graphicsEngine'] = self.__settingsCore.getSetting(
GRAPHICS.RENDER_PIPELINE)
self.__performanceGroup = BattleRoyalePerfProblems.LOW_RISK
for groupName, conditions in PERFORMANCE_GROUP_LIMITS.iteritems():
for currentLimit in conditions:
condValid = True
systemStats = currentLimit.get(
BATTLE_ROYALE_GAME_LIMIT_TYPE.SYSTEM_DATA, {})
for key, limit in systemStats.iteritems():
currValue = stats.get(key, None)
if currValue is None or currValue != limit:
condValid = False
hardwareParams = currentLimit.get(
BATTLE_ROYALE_GAME_LIMIT_TYPE.HARDWARE_PARAMS, {})
for key, limit in hardwareParams.iteritems():
currValue = BigWorld.getAutoDetectGraphicsSettingsScore(
key)
if currValue >= limit:
condValid = False
if condValid:
self.__performanceGroup = groupName
return
return
def __updateEquipmentCount(self):
if self.__equipmentCount:
self.__equipmentCount = None
self.__equipmentCount = {}
items = self.__battleRoyaleSettings.defaultAmmo
for itemGroup in items:
groupKey, groupItems = itemGroup
self.__equipmentCount[groupKey] = groupItems[0]
return
def __onC11nVisibilityChanged(self, isVisible):
self.__c11nVisible = isVisible
self.__updateSpace()
def __onVehicleChanged(self):
if self.__isNeedToUpdateHeroTank:
self.__hangarsSpace.onHeroTankReady()
self.__isNeedToUpdateHeroTank = False
def __tokenIsValid(self, quest):
tokens = quest.accountReqs.getTokens()
return False if tokens and not tokens[0].isAvailable() else True
class ProgressiveItemsView(ViewImpl):
__slots__ = ('__c11nView', '_itemsProgressData', '_possibleItems',
'_vehicle', '__blur', '__layoutID', '__urlMacros',
'__guiSettings')
__lobbyContext = dependency.descriptor(ILobbyContext)
__itemsCache = dependency.descriptor(IItemsCache)
__customizationService = dependency.descriptor(ICustomizationService)
__appLoader = dependency.descriptor(IAppLoader)
__settingsCore = dependency.descriptor(ISettingsCore)
def __init__(self, layoutID, c11nView, *args, **kwargs):
settings = ViewSettings(layoutID)
settings.args = args
settings.kwargs = kwargs
settings.flags = ViewFlags.LOBBY_TOP_SUB_VIEW
settings.model = ProgressiveItemsViewModel()
super(ProgressiveItemsView, self).__init__(settings)
self._itemsProgressData = None
self._possibleItems = None
self._vehicle = None
self.__blur = CachedBlur()
self.__layoutID = layoutID
self.__c11nView = c11nView
self.__urlMacros = URLMacros()
self.__guiSettings = GUI_SETTINGS.progressiveItems.get(
'tutorialVideo', {})
return
def createToolTip(self, event):
if event.contentID == R.views.common.tooltip_window.backport_tooltip_content.BackportTooltipContent(
):
intCD = int(event.getArgument('id'))
level = int(event.getArgument('level'))
window = BackportTooltipWindow(
self.__getTooltipData(intCD, event.getArgument('tooltip'),
level), self.getParentWindow())
window.load()
return window
return super(ProgressiveItemsView, self).createToolTip(event)
@property
def viewModel(self):
return super(ProgressiveItemsView, self).getViewModel()
def _initialize(self, *args, **kwargs):
super(ProgressiveItemsView, self)._initialize(*args, **kwargs)
if self.__c11nView is not None:
self.__c11nView.changeVisible(False)
self.viewModel.onSelectItem += self._onSelectItem
self.viewModel.tutorial.showVideo += self._showVideoPage
return
def _finalize(self):
super(ProgressiveItemsView, self)._finalize()
if self.__c11nView is not None:
self.__c11nView.changeVisible(True)
self.__c11nView = None
self.__blur.fini()
self.viewModel.onSelectItem -= self._onSelectItem
self.viewModel.tutorial.showVideo -= self._showVideoPage
return
def _onLoading(self, *args, **kwargs):
self._vehicle = g_currentVehicle.item
self._possibleItems = self._getPossibleItemsForVehicle()
self._itemsProgressData = self.__itemsCache.items.inventory.getC11nProgressionDataForVehicle(
self._vehicle.intCD)
itemIntCD = kwargs.get('itemIntCD')
with self.getViewModel().transaction() as model:
model.setTankName(self._vehicle.userName)
model.setTankLevel(int2roman(self._vehicle.level))
model.setTankType(self._vehicle.typeBigIconResource())
self.__setItems(model)
model.setIsRendererPipelineDeferred(isRendererPipelineDeferred())
model.setItemToScroll(0 if itemIntCD is None else itemIntCD)
return
def _onLoaded(self, *args, **kwargs):
self.__blur.enable()
self.__settingsCore.serverSettings.setOnceOnlyHintsSettings(
{OnceOnlyHints.C11N_PROGRESSION_VIEW_HINT: HINT_SHOWN_STATUS})
def _onSelectItem(self, args=None):
if args is not None:
intCD = int(args['intCD'])
level = int(args['level'])
item = self.__customizationService.getItemByCD(intCD)
ctx = self.__customizationService.getCtx()
def changeTabAndGetItemToHand():
ctx.changeModeWithProgressionDecal(intCD)
ctx.events.onGetItemBackToHand(item, level, scrollToItem=True)
noveltyCount = self._vehicle.getC11nItemNoveltyCounter(
proxy=self.__itemsCache.items, item=item)
if noveltyCount:
BigWorld.callback(
0.0, lambda: ctx.resetItemsNovelty([item.intCD]))
BigWorld.callback(0.0, changeTabAndGetItemToHand)
self.destroyWindow()
return
def _showVideoPage(self, args=None):
self.__showVideo()
@process
def __showVideo(self):
url = yield self.__urlMacros.parse(self.__guiSettings.get('url'))
webHandlers = webApiCollection(ui_web_api.CloseViewWebApi,
sound_web_api.SoundWebApi,
sound_web_api.HangarSoundWebApi)
ctx = {'url': url, 'webHandlers': webHandlers}
showProgressiveItemsBrowserView(ctx)
def _getPossibleItemsForVehicle(self):
customizationCache = vehicles.g_cache.customization20()
vehicleType = self._vehicle.descriptor.type
sortedItems = sorted(
customizationCache.customizationWithProgression.itervalues(),
key=lambda i: i.id)
return [
item.compactDescr for item in sortedItems
if item.filter.matchVehicleType(vehicleType)
]
def __setItems(self, model):
for intCD in self._possibleItems:
itemModel = ItemModel()
item = self.__customizationService.getItemByCD(intCD)
itemModel.setItemId(intCD)
itemModel.setItemUserString(item.userName)
itemModel.setMaxLevel(item.getMaxProgressionLevel())
itemModel.setScaleFactor(item.formfactor)
latestOpenedLevel = item.getLatestOpenedProgressionLevel(
self._vehicle)
itemModel.setCurrentLevel(1 if latestOpenedLevel ==
-1 else latestOpenedLevel + 1)
self.__setEachLevelInfo(itemModel, item)
model.progressiveItems.addViewModel(itemModel)
def __setEachLevelInfo(self, model, item):
for level in xrange(1, model.getMaxLevel() + 1):
levelInfo = ItemLevelInfoModel()
levelInfo.setLevel(level)
levelInfo.setLevelText(getProgressionItemStatusText(level))
levelInfo.setUnlocked(level < model.getCurrentLevel())
icon = item.iconUrlByProgressionLevel(
level, _PREVIEW_ICON_SIZE,
_PREVIEW_ICON_INNER_SIZE.get(item.formfactor))
levelInfo.setIcon(icon)
if level == model.getCurrentLevel():
levelInfo.setInProgress(True)
levelInfo.progressBlock.setUnlockCondition(
_ms(
item.progressionConditions.get(level, {})[0].get(
'description', '')))
currProgress = int(
item.getCurrentProgressOnCurrentLevel(self._vehicle))
currProgress = currProgress if currProgress > 0 else 0
maxProgress = int(
item.progressionConditions.get(level,
{})[0].get('value', '1'))
if maxProgress > 1:
levelInfo.progressBlock.setProgressionVal(currProgress)
levelInfo.progressBlock.setMaxProgressionVal(maxProgress)
else:
levelInfo.progressBlock.setHideProgressBarAndString(True)
model.eachLevelInfo.addViewModel(levelInfo)
@staticmethod
def __getTooltipData(intCD, tooltip, level):
return createTooltipData(isSpecial=True,
specialAlias=tooltip,
specialArgs=CustomizationTooltipContext(
itemCD=intCD,
level=level,
showOnlyProgressBlock=True))
