def stop(self):
if not self.isActive():
return
else:
g_eventBus.removeListener(GameEvent.SHOW_BTN_HINT,
self.__handleShowBtnHint,
scope=EVENT_BUS_SCOPE.GLOBAL)
g_eventBus.removeListener(GameEvent.HELP_DETAILED,
self.__handlePressHelpBtn,
scope=EVENT_BUS_SCOPE.BATTLE)
g_eventBus.removeListener(GameEvent.FULL_STATS_QUEST_PROGRESS,
self.__handlePressQuestBtn,
scope=EVENT_BUS_SCOPE.BATTLE)
vStateCtrl = self.sessionProvider.shared.vehicleState
if vStateCtrl is not None:
vStateCtrl.onVehicleControlling -= self.__onVehicleControlling
self.__callbackDelayer.destroy()
self.__isActive = False
prbHintSettings = dict()
prbHintSettings[
QUEST_PROGRESS_HINT_SECTION] = self.__questHintSettings
prbHintSettings[HELP_SCREEN_HINT_SECTION] = self.__helpHintSettings
prbHintSettings[IBC_HINT_SECTION] = self.__battleComHintSettings
AccountSettings.setSettings(PRE_BATTLE_HINT_SECTION,
prbHintSettings)
return
def __showStylePreview(self, styleID):
styledVehicleCD = None
minLvl, _ = self.__rankedController.getSuitableVehicleLevels()
if g_currentVehicle.isPresent() and g_currentVehicle.item.level >= minLvl:
styledVehicleCD = g_currentVehicle.item.intCD
else:
accDossier = self.__itemsCache.items.getAccountDossier()
vehicles = accDossier.getRankedStats().getVehicles()
if not vehicles:
vehicles = accDossier.getRandomStats().getVehicles()
if vehicles:
sortedVehicles = sorted(vehicles.items(), key=lambda vStat: vStat[1].battlesCount, reverse=True)
for vehicleCD, _ in sortedVehicles:
vehicleType = getVehicleType(vehicleCD)
if vehicleType.level >= minLvl:
styledVehicleCD = vehicleCD
break
if not styledVehicleCD:
vehiclesPool = AccountSettings.getSettings(RANKED_STYLED_VEHICLES_POOL)
if not vehiclesPool:
vehiclesPool = list(_DEFAULT_STYLED_VEHICLES)
vehicleName = vehiclesPool.pop(0)
styledVehicleCD = VehicleDescriptor(typeName=vehicleName).type.compactDescr
vehiclesPool.append(vehicleName)
AccountSettings.setSettings(RANKED_STYLED_VEHICLES_POOL, vehiclesPool)
styleDescr = self.__styleDescriptions.get(styleID, '')
style = first(self.__itemsCache.items.getStyles(REQ_CRITERIA.CUSTOM(lambda item: item.id == styleID)).values())
showStylePreview(styledVehicleCD, style, styleDescr, self._backToLeaguesCallback)
return
def updateBubble(self):
browserView = self.__getBrowserView()
if browserView:
return
AccountSettings.setCounters(REFERRAL_COUNTER,
self.getBubbleCount() + 1)
self.__updateBubbleEvent()
def __onReplayTimeWarpStart(self):
quest = self.sessionProvider.shared.questProgress.getSelectedQuest()
questID = None
if quest:
questID = quest.getID()
AccountSettings.setSettings(SELECTED_QUEST_IN_REPLAY, questID)
return
def setSelectedFilter(self, value):
sortingId = int(value)
if self.__currentSorting != sortingId:
self.__currentSorting = sortingId
AccountSettings.setSettings(CLAN_PREBATTLE_SORTING_KEY, sortingId)
rosters = self.prbEntity.getRosters()
self._setRosterList(rosters)
def _finalize(self):
self.viewModel.onGoToVehicleBtnClick -= self.__onGoToVehicle
self.viewModel.onViewRewardsBtnClick -= self.__onViewRewards
self.viewModel.onCloseBtnClick -= self.__onCloseWindow
self.viewModel.onVideoStarted -= self.__onVideoStarted
self.viewModel.onVideoStopped -= self.__onVideoStopped
onVideoDone()
AccountSettings.setUIFlag(self.__videoShownKey, True)
def markPageAsRead(self, pageId):
chapters = AccountSettings.getManualUnreadPages()
for chapter in chapters:
if pageId in chapter:
chapter.remove(pageId)
AccountSettings.setManualUnreadPages(chapters)
self.updatePaginator()
break
def __onEntitlementEvent(self):
currEventsCount = self.__rankedController.getEntitlementEvents()
oldEventsCount = AccountSettings.getCounters(RANKED_ENTITLEMENT_EVENTS_AMOUNT)
AccountSettings.setCounters(RANKED_ENTITLEMENT_EVENTS_AMOUNT, currEventsCount)
if currEventsCount > oldEventsCount:
AccountSettings.setCounters(RANKED_SHOP_COUNTER, 1)
self.__resetCounters(self._selectedItemID)
self.__updateCounters()
def _populateAfter(self):
blueprints = {}
defaults = AccountSettings.getFilterDefault(GUI_START_BEHAVIOR)
settings = self.__settingsCore.serverSettings.getSection(GUI_START_BEHAVIOR, defaults)
if self.__needShowTechTreeIntro(settings):
if settings[GuiSettingsBehavior.TECHTREE_INTRO_BLUEPRINTS_RECEIVED]:
blueprints = AccountSettings.getSettings(TECHTREE_INTRO_BLUEPRINTS)
shared_events.showTechTreeIntro(parent=self.getParentWindow(), blueprints=blueprints)
def markPreviousYearTabVisited(self, yearName, uiFlagKey):
yearNum = YEARS_INFO.convertYearToNum(yearName)
isMaxLevel = self._itemsCache.items.festivity.getMaxLevel(
) == new_year.CONSTS.MAX_ATMOSPHERE_LVL
isCurrentYearSelected = yearNum == YEARS_INFO.CURRENT_YEAR
if isMaxLevel and not isCurrentYearSelected:
oldCollectionsVisited = AccountSettings.getUIFlag(uiFlagKey)
oldCollectionsVisited[yearNum] = True
AccountSettings.setUIFlag(uiFlagKey, oldCollectionsVisited)
def setCounters(self, alias, count, isIncrement=False):
if not self.__enabled:
return
counters = self.getCounters()
if isIncrement:
count = counters.get(alias, 0) + count
counters[alias] = count if count >= 0 else 0
AccountSettings.setCounters(CLAN_NOTIFICATION_COUNTERS, counters)
self.onClanNotificationUpdated()
def dispose(self):
if self._watchedListDirty:
AccountSettings.setSettings(BECOME_ELITE_VEHICLES_WATCHED,
self._eliteWatchedList)
self._removeListeners()
self._eliteWatchedList = None
self._parentObj = None
self._vehicle = None
return
def addViewedItems(self, nationID):
if self.__needUpdate:
for bookType, count in self.__booksCountByNation.iteritems():
if bookType in CREW_BOOK_RARITY.NO_NATION_TYPES:
self.__viewedItems[bookType] = count
self.__viewedItems[bookType][nationID] = count[nationID]
AccountSettings.setSettings(CREW_BOOKS_VIEWED, self.__viewedItems)
self.__needUpdate = False
def stop(self):
vStateCtrl = self.sessionProvider.shared.vehicleState
if vStateCtrl is not None:
vStateCtrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated
vStateCtrl.onVehicleControlling -= self.__onVehicleControlling
vStateCtrl.onPostMortemSwitched -= self.__onPostMortemSwitched
vStateCtrl.onRespawnBaseMoving -= self.__onRespawnBaseMoving
AccountSettings.setSettings('siegeModeHintCounter', self.__hintsLeft)
return
def __processClanNewsNotification(self):
account = self.__clansCtrl.getAccountProfile()
notificationStartTime = self.__lobbyContext.getServerSettings(
).getClansConfig().get(ClansConfig.NOTIFICATION_START_TIME, 0)
if not account.isInClan(
) or account.getJoinedAt() > notificationStartTime:
return
if not AccountSettings.getNotifications(CLAN_NEWS_SEEN):
AccountSettings.setNotifications(CLAN_NEWS_SEEN, True)
self.setCounters(self.CLAN_NEWS_ALIAS, 1, isIncrement=True)
def stop(self):
if self._sessionProvider.dynamic.radar:
self._sessionProvider.dynamic.radar.removeRuntimeView(self)
vStateCtrl = self._sessionProvider.shared.vehicleState
self.__clearRadarCooldown()
if vStateCtrl:
vStateCtrl.onPostMortemSwitched -= self.__onPostMortemSwitched
vStateCtrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated
AccountSettings.setSettings(RADAR_HINT_SECTION, self.__settings)
self.destroy()
def setIsInHangarSelected(self, value):
storageId = self._getStorageId()
storedData = AccountSettings.getFilter(storageId)
storedData['isInHangarSelected'] = value
AccountSettings.setFilter(storageId, storedData)
if self._data is not None:
self.as_responseDossierS(
self._battlesType, self._getTechniqueListVehicles(self._data),
'', self.getEmptyScreenLabel())
return
def setSelectedVehicles(self, section, vehicles):
"""
Sets the list of selected vehicles
Args:
section: section to store
vehicles: vehicles intCDs
"""
settings = dict(AccountSettings.getSettings('unitWindow'))
settings[section] = vehicles
AccountSettings.setSettings('unitWindow', settings)
def __rememberGameMode(self):
currentCycleID = self.getCurrentCycleID()
rememberedCycleID = AccountSettings.getSettings(
FUN_RANDOM_LAST_CYCLE_ID)
if currentCycleID is not None and currentCycleID != rememberedCycleID:
AccountSettings.setSettings(FUN_RANDOM_LAST_CYCLE_ID,
currentCycleID)
SelectorBattleTypesUtils.setBattleTypeAsUnknown(
SELECTOR_BATTLE_TYPES.FUN_RANDOM)
return
def __onYearAwardPointsUpdate(self):
if not AccountSettings.getSettings(RANKED_AWARDS_BUBBLE_YEAR_REACHED):
points = self.__rankedController.getYearRewardPoints()
for minPoints, maxPoints in self.__rankedController.getYearAwardsPointsMap().itervalues():
if maxPoints >= points >= minPoints:
AccountSettings.setCounters(RANKED_AWARDS_COUNTER, 1)
AccountSettings.setSettings(RANKED_AWARDS_BUBBLE_YEAR_REACHED, True)
self.__resetCounters(self._selectedItemID)
self.__updateCounters()
break
def stop(self):
g_eventBus.removeListener(GameEvent.SHOW_BTN_HINT,
self.__handleShowBtnHint,
scope=EVENT_BUS_SCOPE.GLOBAL)
g_eventBus.removeListener(GameEvent.FULL_STATS_QUEST_PROGRESS,
self.__handlePressHintBtn,
scope=EVENT_BUS_SCOPE.BATTLE)
if self.__wasHintProcessed:
AccountSettings.setSettings(QUEST_PROGRESS_SHOWS_COUNT,
max(self.__hintsLeft - 1, 0))
def __widgetWasShown(self, _):
model = self._model()
if model is None:
return
else:
model.removeNotification(NOTIFICATION_TYPE.PROGRESSIVE_REWARD, ProgressiveRewardDecorator.ENTITY_ID)
if self.__seniorityAwardsIsActive():
AccountSettings.setCounters(SENIORITY_AWARDS_COUNTER, 1)
else:
AccountSettings.setNotifications(PROGRESSIVE_REWARD_VISITED, True)
return
def stop(self):
ctrl = self.sessionProvider.shared.crosshair
if ctrl is not None:
ctrl.onCrosshairViewChanged -= self.__onCrosshairViewChanged
ctrl.onStrategicCameraChanged -= self.__onStrategicCameraChanged
ctrl = self.sessionProvider.shared.vehicleState
if ctrl is not None:
ctrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated
if not self.sessionProvider.isReplayPlaying:
AccountSettings.setSettings(TRAJECTORY_VIEW_HINT_COUNTER, self.__hintsLeft)
return
def __setQualificationData(self, rank):
divisionID = rank.getDivision().getID()
smallImageSrc = rank.getIcon(RANKEDBATTLES_ALIASES.WIDGET_BIG)
bigImageSrc = rank.getIcon(RANKEDBATTLES_ALIASES.WIDGET_HUGE)
isFirstEntryMap = AccountSettings.getSettings(
IS_FIRST_ENTRY_BY_DIVISION_ID)
isFirstEntry = isFirstEntryMap.get(divisionID, True)
if isFirstEntry:
isFirstEntryMap[divisionID] = False
AccountSettings.setSettings(IS_FIRST_ENTRY_BY_DIVISION_ID,
isFirstEntryMap)
self.as_setQualificationDataS(smallImageSrc, bigImageSrc, isFirstEntry)
def __init__(self, ctx=None):
super(StoreView, self).__init__(ctx)
tabId = ctx.get('tabId')
component = ctx.get('component')
if tabId is not None:
self.__currentTab = _getTabIndex(tabId)
else:
self.__currentTab = AccountSettings.getFilter(STORE_TAB)
if component is not None:
nation, _ = AccountSettings.getFilter('shop_current')
AccountSettings.setFilter('shop_current', (nation, component))
return
def __init__(self, ctx = None):
super(StoreView, self).__init__(ctx)
tabId = ctx.get('tabId')
component = ctx.get('component')
if tabId is not None:
self.__currentTab = _getTabIndex(tabId)
else:
self.__currentTab = AccountSettings.getFilter(STORE_TAB)
if component is not None:
nation, _ = AccountSettings.getFilter('shop_current')
AccountSettings.setFilter('shop_current', (nation, component))
return
def stop(self):
vStateCtrl = self.sessionProvider.shared.vehicleState
if vStateCtrl is not None:
vStateCtrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated
vStateCtrl.onVehicleControlling -= self.__onVehicleControlling
vStateCtrl.onPostMortemSwitched -= self.__onPostMortemSwitched
vStateCtrl.onRespawnBaseMoving -= self.__onRespawnBaseMoving
AccountSettings.setSettings(SIEGE_HINT_SECTION, self.__settings[0])
AccountSettings.setSettings(WHEELED_MODE_HINT_SECTION,
self.__settings[1])
self.__callbackDelayer.destroy()
return
def setVehiclesInvIDs(self, vehicles):
vehiclesIntCDs = []
for invID in vehicles:
vehicle = g_itemsCache.items.getVehicle(invID)
if vehicle is None:
vehiclesIntCDs.append(INV_ID_CLEAR_VEHICLE)
else:
vehiclesIntCDs.append(vehicle.intCD)
self.__intCDs[self.getBattleType()] = vehiclesIntCDs
AccountSettings.setFavorites(FALLOUT_VEHICLES, self.__intCDs)
return
def stop(self):
ctrl = self.sessionProvider.shared.crosshair
if ctrl is not None:
ctrl.onCrosshairViewChanged -= self.__onCrosshairViewChanged
ctrl.onStrategicCameraChanged -= self.__onStrategicCameraChanged
ctrl = self.sessionProvider.shared.vehicleState
if ctrl is not None:
ctrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated
self.__callbackDelayer.destroy()
if not self.sessionProvider.isReplayPlaying:
AccountSettings.setSettings(TRAJECTORY_VIEW_HINT_SECTION,
self.__settings)
return
def __updateCounters(self):
awardsCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_AWARDS_COUNTER))
infoCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_INFO_COUNTER))
yearRatingCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_YEAR_RATING_COUNTER))
shopCounter = main_page_vos.getBubbleLabel(
AccountSettings.getCounters(RANKED_SHOP_COUNTER))
self.as_setCountersS(
main_page_vos.getCountersData(self.__rankedController,
awardsCounter, infoCounter,
yearRatingCounter, shopCounter))
def __updateActionState(self):
actions = self._eventsCache.getActions().keys()
for name in actions:
if _ACTION_POSTFIX in name:
self._isStarted = True
if not AccountSettings.getNotifications(BLUEPRINTS_CONVERT_SALE_STARTED_SEEN) and self._isEnabled:
AccountSettings.setNotifications(BLUEPRINTS_CONVERT_SALE_STARTED_SEEN, True)
self.__showNotification(BCSActionState.STARTED)
return
if self._isStarted:
self._isStarted = False
self.__showNotification(BCSActionState.END)
def validateSelectedVehicles(self):
maxVehs = self.getConfig().maxVehiclesPerPlayer
valid = [INV_ID_CLEAR_VEHICLE] * maxVehs
battleType = self.getBattleType()
vehicles = self.__invIDs.get(battleType, ())
vehGetter = g_itemsCache.items.getVehicle
for idx, invID in enumerate(vehicles[:maxVehs]):
invVehicle = vehGetter(invID)
if invVehicle is not None:
valid[idx] = invID
if valid != vehicles:
self.__invIDs[battleType] = valid
AccountSettings.setFavorites(FALLOUT_VEHICLES, self.__invIDs)
return True
else:
return False
def setSettings(self):
newSize = settings.clampMinimapSizeIndex(AccountSettings.getSettings(self.__currentSizeSettings))
if self.__sizeIndex != newSize:
self.__sizeIndex = newSize
self._parentObj.as_setSizeS(self.__sizeIndex)
value = int(g_settingsCore.getSetting(settings_constants.GAME.MINIMAP_ALPHA))
if value:
self._parentObj.as_setAlphaS(1 - value / 100.0)
def validateSelectedVehicles(self):
config = self.getConfig()
battleType = self.getBattleType()
vehicles = self.__intCDs.get(battleType, ())
if not config.hasRequiredVehicles():
valid = ()
else:
maxVehs = config.maxVehiclesPerPlayer
valid = [INV_ID_CLEAR_VEHICLE] * maxVehs
vehGetter = g_itemsCache.items.getItemByCD
for idx, intCD in enumerate(vehicles[:maxVehs]):
invVehicle = vehGetter(intCD)
if invVehicle is not None and invVehicle.isInInventory:
valid[idx] = intCD
if valid != vehicles:
self.__intCDs[battleType] = valid
AccountSettings.setFavorites(FALLOUT_VEHICLES, self.__intCDs)
return
def __init__(self, ctx = None):
super(StoreView, self).__init__(ctx)
self.__currentTab = AccountSettings.getFilter(STORE_TAB)
def __fullUpdate(self):
selectedTabInd = AccountSettings.getSettings(PREVIEW_INFO_PANEL_IDX)
self.__updateHeaderData()
self.as_updateInfoDataS(self.__getInfoData(selectedTabInd))
self.__updateBtnState()
self.__updateStatus()
def onOpenInfoTab(self, index):
AccountSettings.setSettings(PREVIEW_INFO_PANEL_IDX, index)
def setVehiclesInvIDs(self, vehicles):
self.__invIDs[self.getBattleType()] = vehicles
AccountSettings.setFavorites(FALLOUT_VEHICLES, self.__invIDs)
def swap(self):
self.__settings = g_settingsCore.serverSettings.getSection(SETTINGS_SECTIONS.FALLOUT, _SETTINGS_DEFAULTS)
self.__intCDs = AccountSettings.getFavorites(FALLOUT_VEHICLES)
self.validateSelectedVehicles()
def __setSettingsToStorage(value):
"""Set settings to accountSettings
"""
AccountSettings.setSettings(NEW_SETTINGS_COUNTER, value)
def __saveSettings(self):
AccountSettings.setSettings(self.__currentSizeSettings, self.__sizeIndex)
def __getSettingsFromStorage():
"""Get settings from accountSettings
"""
return AccountSettings.getSettings(NEW_SETTINGS_COUNTER)
def _dispose(self):
AccountSettings.setFilter(STORE_TAB, self.__currentTab)
super(StoreView, self)._dispose()
