def triggerEffect(self): setting = self.getTarget() if setting is None: LOG_ERROR('Tutorial setting is not found', self._effect.getTargetID()) return else: AccountSettings.setSettings(setting.getSettingName(), setting.getSettingValue()) return
def setDialogSettings(self, isOpened): """ Saving given dialog settings. Called from flash. @param isOpened: <bool> is dialog opened by default """ settings = self.getDialogSettings() settings['isOpened'] = isOpened AccountSettings.setSettings('vehicleSellDialog', settings)
def __checkDefHourConditions(self): canChangeSettings = self.fortCtrl.getPermissions().canChangeSettings() if not canChangeSettings or self.__currentMode != FORTIFICATION_ALIASES.MODE_COMMON: return if self.__settingsClanDB != self.__clanDBID and self.__isClanConditionsSuccess(): fortSettings = dict(AccountSettings.getSettings('fortSettings')) fortSettings['clanDBID'] = self.__clanDBID AccountSettings.setSettings('fortSettings', fortSettings) self.__settingsClanDB = self.__clanDBID if not self.fortCtrl.getFort().isDefenceHourEnabled(): self.fireEvent(events.LoadViewEvent(FORTIFICATION_ALIASES.FORT_PERIOD_DEFENCE_WINDOW_ALIAS), EVENT_BUS_SCOPE.LOBBY)
def _saveNewInventoryItemsOnFileSystem(self, inventoryItems): newInventoryItems = AccountSettings.getSettings('customization') if newInventoryItems is None or not isinstance(newInventoryItems, tuple): newInventoryItems = ({}, {}, {}) for cType in CUSTOMIZATION_TYPE.ALL: for itemID in inventoryItems[cType].keys(): if self._currentVehicle.item.intCD not in newInventoryItems[cType]: newInventoryItems[cType][self._currentVehicle.item.intCD] = {} if itemID not in newInventoryItems[cType][self._currentVehicle.item.intCD]: newInventoryItems[cType][self._currentVehicle.item.intCD][itemID] = True AccountSettings.setSettings('customization', newInventoryItems) return
def __checkLimitedRestoreNotification(self): criteria = REQ_CRITERIA.CUSTOM(lambda item: item.hasLimitedRestore()) vehicles = g_itemsCache.items.getVehicles(criteria).values() lastRestoreNotification = AccountSettings.getSettings(LAST_RESTORE_NOTIFICATION) if lastRestoreNotification is None: showMessage = True else: showMessage = time_utils.getTimeDeltaTilNow(lastRestoreNotification) >= time_utils.ONE_DAY if len(vehicles) and showMessage and not self.__checkForNotify: AccountSettings.setSettings(LAST_RESTORE_NOTIFICATION, time.time()) SystemMessages.g_instance.pushI18nMessage('#system_messages:restoreController/hasLimitedRestoreVehicles', type=SystemMessages.SM_TYPE.Warning) self.__checkForNotify = True return
def clearStoredCustomizationData(): storedItems = dict(AccountSettings.getSettings('customization')) clearStoredItems = {} for key, storedTypedItems in storedItems.iteritems(): typedNewStoredItems = [] inventoryItems = getInventoryItemsFor(key) for item in inventoryItems: for storedItem in storedTypedItems: if key == CUSTOMIZATION_ITEM_TYPE.EMBLEM_TYPE and storedItem[1] == item.get('id') or key != CUSTOMIZATION_ITEM_TYPE.EMBLEM_TYPE and storedItem[1] == item.get('nationId') and storedItem[2] == item.get('id'): typedNewStoredItems.append(storedItem) clearStoredItems[key] = typedNewStoredItems AccountSettings.setSettings('customization', clearStoredItems)
def swap(self): if AccountSettings.getSettings(DEFAULT_QUEUE) == QUEUE_TYPE.SANDBOX: isSelected = True dossier = g_itemsCache.items.getAccountDossier() if dossier is not None: isSelected = True count = dossier.getRandomStats().getBattlesCount() if count >= BATTLES_TO_SELECT_RANDOM_MIN_LIMIT: AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) isSelected = False else: isSelected = False self._isSelected = isSelected return
def visitQuestsGUI(quest): if quest is None: return else: s = dict(AccountSettings.getSettings('quests')) settings = ['naVisited'] if quest.isAvailable(): settings.append('visited') for setting in settings: s[setting] = tuple(set(s[setting]) | set([quest.getID()])) s['lastVisitTime'] = time.time() AccountSettings.setSettings('quests', s) g_eventBus.handleEvent(events.LobbySimpleEvent(events.LobbySimpleEvent.QUESTS_UPDATED)) return
def updateVisitedItems(customizationName, visitedIds): if not g_currentVehicle.isPresent(): return storedItems = dict(AccountSettings.getSettings('customization')) if not isinstance(visitedIds, set): LOG_WARNING('visitedIds will be in an list') updatedVisitedIds = [] for item in visitedIds: if isinstance(item, int): updatedVisitedIds.append((g_currentVehicle.item.intCD, item)) else: updatedVisitedIds.append((g_currentVehicle.item.intCD,) + item) curItems = {customizationName: updatedVisitedIds} curTypeItems = __integrateDicts(curItems, storedItems) AccountSettings.setSettings('customization', curTypeItems)
def _dispose(self): vStateCtrl = self.sessionProvider.shared.vehicleState crosshairCtrl = self.sessionProvider.shared.crosshair keyboardSetting = self.settingsCore.options.getSetting( CONTROLS.KEYBOARD) keyboardSetting.onKeyBindingsChanged -= self.__onKeyBindingsChanged if crosshairCtrl is not None: crosshairCtrl.onCrosshairPositionChanged -= self.__onCrosshairPositionChanged crosshairCtrl.onCrosshairScaleChanged -= self.__onCrosshairPositionChanged if vStateCtrl is not None: vStateCtrl.onVehicleStateUpdated -= self.__onVehicleStateUpdated vStateCtrl.onVehicleControlling -= self.__onVehicleControlling vStateCtrl.onPostMortemSwitched -= self.__onPostMortemSwitched vStateCtrl.onRespawnBaseMoving -= self.__onRespawnBaseMoving self._switchTimeTable.clear() self._siegeComponent.clear() self._siegeComponent = None AccountSettings.setSettings('siegeModeHintCounter', self._hintsLeft) return
def swap(self): if AccountSettings.getSettings(DEFAULT_QUEUE) == QUEUE_TYPE.SANDBOX: isSelected = True dossier = g_itemsCache.items.getAccountDossier() criteria = REQ_CRITERIA.INVENTORY | REQ_CRITERIA.VEHICLE.LEVELS(range(3, 10)) | ~REQ_CRITERIA.VEHICLE.EXPIRED_RENT | ~REQ_CRITERIA.VEHICLE.EVENT_BATTLE vehicles = sorted(g_itemsCache.items.getVehicles(criteria=criteria).values(), key=lambda item: item.level) vehicle = findFirst(None, vehicles) if vehicle is not None: AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) isSelected = False if dossier is not None and isSelected: count = dossier.getRandomStats().getBattlesCount() if count >= BATTLES_TO_SELECT_RANDOM_MIN_LIMIT: AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) isSelected = False else: isSelected = False self._isSelected = isSelected return
def clearStoredCustomizationData(): storedItems = dict(AccountSettings.getSettings('customization')) clearStoredItems = {} for key, storedTypedItems in storedItems.iteritems(): typedNewStoredItems = [] inventoryItems = getInventoryItemsFor(key) for item in inventoryItems: for storedItem in storedTypedItems: if key == CUSTOMIZATION_ITEM_TYPE.EMBLEM_TYPE and storedItem[ 1] == item.get( 'id' ) or key != CUSTOMIZATION_ITEM_TYPE.EMBLEM_TYPE and storedItem[ 1] == item.get('nationId') and storedItem[ 2] == item.get('id'): typedNewStoredItems.append(storedItem) clearStoredItems[key] = typedNewStoredItems AccountSettings.setSettings('customization', clearStoredItems)
def _processPromo(self, promo): yield lambda callback: callback(True) if self.isPatchPromoAvailable() and self.isPatchChanged() and self.isPromoAutoViewsEnabled() and not self._isPromoShown: LOG_DEBUG('Showing patchnote promo:', self.__currentVersionPromoUrl) AccountSettings.setSettings(LAST_PROMO_PATCH_VERSION, self.__getClientMainVersion()) self.__currentVersionBrowserShown = True self._isPromoShown = True self.showPatchPromo(isAsync=True) return actionsPromo = [ item for item in promo if item.eventType.startswith(gc_constants.PROMO.TEMPLATE.ACTION) ] for actionPromo in actionsPromo: promoUrl = yield self.__urlMacros.parse(actionPromo.data) promoTitle = actionPromo.text if promoUrl not in self.__promoShown and not self._isPromoShown and promoUrl != self.__currentVersionPromoUrl: LOG_DEBUG('Showing action promo:', promoUrl) self.__promoShown.add(promoUrl) self.__savePromoShown() self._isPromoShown = True yield self.__showPromoBrowser(promoUrl, promoTitle) return
def _processPromo(self, promo): yield lambda callback: callback(True) if self.isPatchPromoAvailable() and self.isPatchChanged() and self.isPromoAutoViewsEnabled() and not self._isPromoShown: LOG_DEBUG('Showing patchnote promo:', self.__currentVersionPromoUrl) AccountSettings.setSettings(LAST_PROMO_PATCH_VERSION, getClientMainVersion()) self.__currentVersionBrowserShown = True self._isPromoShown = True self.showCurrentVersionPatchPromo(isAsync=True) return actionsPromo = [ item for item in promo if item.eventType.startswith(gc_constants.PROMO.TEMPLATE.ACTION) ] for actionPromo in actionsPromo: promoUrl = yield self.__urlMacros.parse(actionPromo.data) promoTitle = actionPromo.text if promoUrl not in self.__promoShown and not self._isPromoShown and promoUrl != self.__currentVersionPromoUrl: LOG_DEBUG('Showing action promo:', promoUrl) self.__promoShown.add(promoUrl) self.__savePromoShown() self._isPromoShown = True yield self.__showPromoBrowser(promoUrl, promoTitle) return
def __checkConflicts(self): localConfig = AccountSettings.getSettings(BATTLE_PASS_VIDEOS_CONFIG) localVideosIDs = self.__getVideoIndexAndIDFromConfig(localConfig) serverVideosIDs = self.__getVideoIndexAndIDFromConfig( self.__videosConfig) if not localConfig: AccountSettings.setSettings(BATTLE_PASS_VIDEOS_CONFIG, self.__videosConfig) localVideosIDs = self.__getVideoIndexAndIDFromConfig( self.__videosConfig) for videoIdx in serverVideosIDs.keys(): localVideoID = localVideosIDs.get(videoIdx) serverVideoID = serverVideosIDs[videoIdx] if localVideoID is None or localVideoID != serverVideoID: self.__resetShownVideoInStorage(serverVideoID) localConfig.pop(localVideoID, None) localConfig[serverVideoID] = self.__videosConfig[serverVideoID] AccountSettings.setSettings(BATTLE_PASS_VIDEOS_CONFIG, localConfig) return
def destroy(self): if not self.__isStarted: self.__vehiclesWaitStart = [] return else: while len(self.__aoiToFarCallbacks): _, callbackID = self.__aoiToFarCallbacks.popitem() if callbackID is not None: BigWorld.cancelCallback(callbackID) self.__isStarted = False self.__entries = {} self.__cameraHandle = None self.__marks = None self.__backMarkers.clear() setattr(self.__parentUI.component, 'minimap', None) from account_helpers.SettingsCore import g_settingsCore g_settingsCore.onSettingsChanged -= self.setupMinimapSettings AccountSettings.setSettings('minimapSize', self.__mapSizeIndex) self.__parentUI = None g_repeatKeyHandlers.remove(self.handleRepeatKeyEvent) return
def onApply(self, diff): diff = flashObject2Dict(diff) AccountSettings.setSettings(COLOR_SETTINGS_TAB_IDX, self.__selectedTabIdx) if self.__selectedTabIdx == TABS.CUSTOM: if self.__hasChangesInSettings( settings_constants.GRAPHICS.getCustomColorSettings(), diff): diff.update({ settings_constants.GRAPHICS.COLOR_GRADING_TECHNIQUE: COLOR_GRADING_TECHNIQUE_DEFAULT }) diff[COLOR_SETTINGS.COLOR_GRADING_TECHNIQUE] = 0 diff[COLOR_SETTINGS.COLOR_FILTER_INTENSITY] = 25 self.settingsCore.applySettings(diff) lastAppliedSettings = AccountSettings.getSettings( APPLIED_COLOR_SETTINGS) lastAppliedSettings[self.__selectedTabIdx] = diff AccountSettings.setSettings(APPLIED_COLOR_SETTINGS, lastAppliedSettings) BigWorld.commitPendingGraphicsSettings() self.destroy()
def destroy(self): if not self.__isStarted: self.__vehiclesWaitStart = [] return else: while len(self.__aoiToFarCallbacks): _, callbackID = self.__aoiToFarCallbacks.popitem() if callbackID is not None: BigWorld.cancelCallback(callbackID) self.__isStarted = False self.__entries = {} self.__cameraHandle = None self.__marks = None self.__backMarkers.clear() setattr(self.__parentUI.component, 'minimap', None) from account_helpers.SettingsCore import g_settingsCore g_settingsCore.onSettingsChanged -= self.setupMinimapSettings AccountSettings.setSettings('minimapSize', self.__mapSizeIndex) self.__parentUI = None g_repeatKeyHandlers.remove(self.handleRepeatKeyEvent) return
def __sentSuffixBadgesVO(self): suffixBadgesVO = [] lastSelectedSuffixBadgeID = AccountSettings.getSettings( LAST_SELECTED_SUFFIX_BADGE_ID) selectedItemIdx = None lastSelectedItemIdx = None if self.__badgesCollector.getSuffixAchivedBadges(): for i, badge in enumerate( self.__badgesCollector.getSuffixAchivedBadges()): self.__deselectNotSelectedBadge(badge) suffixBadgesVO.append(makeSuffixBadgeVO(badge)) if badge.isSelected: selectedItemIdx = i if lastSelectedSuffixBadgeID is not None and lastSelectedSuffixBadgeID == badge.badgeID: lastSelectedItemIdx = i if selectedItemIdx is not None: self.__selectedItemIdx = selectedItemIdx AccountSettings.setSettings( LAST_SELECTED_SUFFIX_BADGE_ID, self.badgesController.getSuffix().badgeID) elif lastSelectedItemIdx is not None: self.__selectedItemIdx = lastSelectedItemIdx self.as_setBadgeSuffixS({ 'checkboxLabel': backport.text( R.strings.badge.badgesPage.header.suffixSetting.label()), 'checkboxTooltip': makeTooltip(TOOLTIPS.BADGEINFO_TITLE, TOOLTIPS.BADGEINFO_TEXT), 'checkboxSelected': self.badgesController.getSuffix() is not None, 'selectedItemIdx': self.__selectedItemIdx, 'items': suffixBadgesVO }) return
def _onDataChanged(self, diff): accountSetting = CHRISTMAS_BOXES actualItems = self._cny.boxes savedBoxes = AccountSettings.getSettings(accountSetting) self._count = 0 for bCount in actualItems.itervalues(): self._count += bCount addedCount = 0 removedCount = 0 addedInfo = defaultdict(int) for boxId, newCount in diff.iteritems(): nDiff = newCount - savedBoxes.get(boxId, 0) if nDiff > 0: addedCount += nDiff addedInfo[boxId] += nDiff elif nDiff < 0: removedCount += abs(nDiff) if addedCount > 0 or removedCount > 0: self.onCountChanged(addedCount, removedCount, addedInfo) if savedBoxes != actualItems: LOG_DEBUG('New account settings "{}" storing: {}'.format(accountSetting, actualItems)) AccountSettings.setSettings(accountSetting, actualItems)
def swap(self): if AccountSettings.getSettings(DEFAULT_QUEUE) == QUEUE_TYPE.SANDBOX: isSelected = True dossier = g_itemsCache.items.getAccountDossier() criteria = REQ_CRITERIA.INVENTORY | REQ_CRITERIA.VEHICLE.LEVELS( range(3, 10) ) | ~REQ_CRITERIA.VEHICLE.EXPIRED_RENT | ~REQ_CRITERIA.VEHICLE.EVENT_BATTLE vehicles = sorted( g_itemsCache.items.getVehicles(criteria=criteria).values(), key=lambda item: item.level) vehicle = findFirst(None, vehicles) if vehicle is not None: AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) isSelected = False if dossier is not None and isSelected: count = dossier.getRandomStats().getBattlesCount() if count >= BATTLES_TO_SELECT_RANDOM_MIN_LIMIT: AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) isSelected = False else: isSelected = False self._isSelected = isSelected return
def onParamClick(self, paramID): isOpened = not self._expandedGroups[paramID] AccountSettings.setSettings(paramID, isOpened) self._expandedGroups[paramID] = isOpened self._setDPUseAnimAndRebuild(False)
def __update(self): newElements = AccountSettings.getSettings("customization") newElementsSubset = newElements[self.__currentType].get(self.__currentVehicle.item.intCD, {}) installedItems = defaultdict(list) purchasedItems = defaultdict(list) otherItems = defaultdict(list) allItems = [installedItems, purchasedItems, otherItems] currentSlotElement = self.__slots.getCurrentSlotData()["element"] installedSlotElement = self.__slots.getInstalledSlotData()["element"] currentCarouselItem = None self.__hasAppliedItem = False for elementID, element in self.__displayedElements[self.__currentType].iteritems(): installedInCurrentSlot = False if installedSlotElement is not None: installedInCurrentSlot = elementID == installedSlotElement.getID() if self.__filter.check(element, installedInCurrentSlot): appliedToCurrentSlot = False if currentSlotElement is not None: appliedToCurrentSlot = elementID == currentSlotElement.getID() and not installedInCurrentSlot if not self.__hasAppliedItem and appliedToCurrentSlot: self.__hasAppliedItem = True if elementID in newElementsSubset: isNewElement = newElementsSubset[elementID] newElementsSubset[elementID] = False else: isNewElement = False carouselItem = { "element": element, "appliedToCurrentSlot": appliedToCurrentSlot, "duration": self.__currentDuration, "isNewElement": isNewElement, "installedInCurrentSlot": installedInCurrentSlot, } if installedInCurrentSlot: group = installedItems[element.getGroup()] elif element.isInDossier: group = purchasedItems[element.getGroup()] else: group = otherItems[element.getGroup()] if element.isFeatured: group.insert(0, carouselItem) else: group.append(carouselItem) if appliedToCurrentSlot: currentCarouselItem = carouselItem AccountSettings.setSettings("customization", newElements) previousItemsCount = len(self.__carouselItems) del self.__carouselItems[:] for groupedItems in allItems: self.__carouselItems += chain(*groupedItems.values()) currentItemsCount = len(self.__carouselItems) if currentCarouselItem is not None: self.__goToIndex = self.__carouselItems.index(currentCarouselItem) else: self.__goToIndex = -1 if previousItemsCount == currentItemsCount else 0 if self.__currentType == CUSTOMIZATION_TYPE.CAMOUFLAGE: unfilteredLength = len(self.__carouselItems) else: unfilteredLength = len(self.__displayedElements[self.__currentType]) self.__events.onCarouselUpdated( { "items": self.__carouselItems, "rendererWidth": _RENDERER_WIDTH[self.__currentType], "goToIndex": self.__goToIndex, "unfilteredLength": unfilteredLength, "hasAppliedItem": self.__hasAppliedItem, } ) return
def save(self): return AccountSettings.setSettings(self._getSettingName(), self._asdict())
def getRosterIntroWindowSetting(type): settings = dict(AccountSettings.getSettings('fortSettings')) if ROSTER_INTRO_WINDOW not in settings: settings[ROSTER_INTRO_WINDOW] = {} AccountSettings.setSettings('fortSettings', settings) return settings[ROSTER_INTRO_WINDOW].get(type)
def _writeVersionForCurrentPlayer(cls): AccountSettings.setSettings('ingameHelpVersion', IngameHelp.__version)
def _writeVersionForCurrentPlayer(cls): AccountSettings.setSettings('ingameHelpVersion', IngameHelp.__version)
def __markAsVisited(cls, buildTypeID): fortSettings = dict(AccountSettings.getSettings('fortSettings')) if 'visitedBuildings' not in fortSettings: fortSettings['visitedBuildings'] = DEFAULT_VALUES['settings']['fortSettings']['visitedBuildings'] fortSettings['visitedBuildings'].add(buildTypeID) AccountSettings.setSettings('fortSettings', fortSettings)
def __setShowTimestamp(self, tstamp): AccountSettings.setSettings(LAST_CALENDAR_SHOW_TIMESTAMP, str(tstamp))
def storeSettings(self, expanded): AccountSettings.setSettings(VEHICLE_BUY_WINDOW_SETTINGS, expanded)
def setRosterIntroWindowSetting(type, value = True): settings = dict(AccountSettings.getSettings('fortSettings')) if ROSTER_INTRO_WINDOW not in settings: settings[ROSTER_INTRO_WINDOW] = {} settings[ROSTER_INTRO_WINDOW][type] = value AccountSettings.setSettings('fortSettings', settings)
def getRosterIntroWindowSetting(type): settings = dict(AccountSettings.getSettings('fortSettings')) if ROSTER_INTRO_WINDOW not in settings: settings[ROSTER_INTRO_WINDOW] = {} AccountSettings.setSettings('fortSettings', settings) return settings[ROSTER_INTRO_WINDOW].get(type)
def onCloseView(self): AccountSettings.setSettings(LAST_BADGES_VISIT, getServerUTCTime()) showHangar()
def __setCurrentLevelState(self, model=None): currentChapter = self.__battlePassController.getCurrentChapter() pointsBeforeChapterStart = self.__battlePassController.getFullChapterPoints( self.__chosenChapter, False) minLevel, maxLevel = self.__battlePassController.getChapterLevelInterval( self.__chosenChapter) if self.__chosenChapter == currentChapter: previousTotalPoints = AccountSettings.getSettings( LAST_BATTLE_PASS_POINTS_SEEN) currentTotalPoints = self.__battlePassController.getCurrentPoints() AccountSettings.setSettings(LAST_BATTLE_PASS_POINTS_SEEN, currentTotalPoints) elif self.__chosenChapter < currentChapter: previousTotalPoints = currentTotalPoints = self.__battlePassController.getFullChapterPoints( self.__chosenChapter, True) else: previousTotalPoints = currentTotalPoints = pointsBeforeChapterStart _, previousLevel = self.__battlePassController.getLevelByPoints( previousTotalPoints) previousPoints, _ = self.__battlePassController.getProgressionByPoints( previousTotalPoints, previousLevel) previousLevel += 1 _, currentLevel = self.__battlePassController.getLevelByPoints( currentTotalPoints) currentLevel += 1 if previousTotalPoints > currentTotalPoints or previousLevel > currentLevel: previousLevel = minLevel previousTotalPoints = pointsBeforeChapterStart previousLevel = min(max(previousLevel, minLevel - 1), maxLevel + 1) currentLevel = min(max(currentLevel, minLevel - 1), maxLevel + 1) previousTotalPoints = max( 0, previousTotalPoints - pointsBeforeChapterStart) currentTotalPoints -= pointsBeforeChapterStart isBattlePassBought = self.__battlePassController.isBought( chapter=self.__chosenChapter) chapterConfig = self.__battlePassController.getChapterConfig() model.setChapterCount(len(chapterConfig)) model.setChapterStep(first(chapterConfig, default=0)) model.setChosenChapter(self.__chosenChapter) model.setCurrentChapter(currentChapter) model.setPointsBeforeStart(pointsBeforeChapterStart) chapterText = backport.text( _rBattlePass.progression.chapterText(), chapter=backport.text( _rBattlePass.chapter.name.num(self.__chosenChapter)()), chapterName=backport.text( _rBattlePass.chapter.fullName.num(self.__chosenChapter)())) model.setChapterText(chapterText) model.setPreviousAllPoints(previousTotalPoints) model.setPreviousPoints(previousPoints) model.setPreviousLevel(previousLevel) model.setCurrentAllPoints(currentTotalPoints) currentPoints, levelPoints = self.__battlePassController.getLevelProgression( ) if self.__chosenChapter != currentChapter: currentPoints = 0 currentLevel = self.__battlePassController.getCurrentLevel() + 1 currentLevel = min(currentLevel, self.__battlePassController.getMaxLevel()) model.setCurrentPoints(currentPoints) model.setTotalPoints(levelPoints) model.setCurrentLevel(currentLevel) model.setIsBattlePassPurchased(isBattlePassBought) model.setIsPaused(self.__battlePassController.isPaused()) model.setSeasonTimeLeft( getFormattedTimeLeft( self.__battlePassController.getSeasonTimeLeft())) if self.__battlePassController.isSeasonFinished(): model.setSeasonText( backport.text(_rBattlePass.commonProgression.body.ended())) else: seasonNum = self.__battlePassController.getSeasonNum() timeEnd = self.__battlePassController.getSeasonFinishTime() model.setSeasonText(self.__makeSeasonTimeText(timeEnd, seasonNum)) self.__updateRewardSelectButton(model=model)
def _checkBattleConsumesIntro(fort): settings = dict(AccountSettings.getSettings('fortSettings')) if not settings.get('battleConsumesIntroShown') and not fort.isStartingScriptNotStarted(): fort_events.showBattleConsumesIntro() settings['battleConsumesIntroShown'] = True AccountSettings.setSettings('fortSettings', settings)
def _save(self, value): settings = value if self.subKey is not None: settings = dict(self.__getSettings()) settings[self.subKey] = value return AccountSettings.setSettings(self.settingName, settings)
def setBattleTypeAsKnown(bType): selectorKnownBattles = set( AccountSettings.getSettings(KNOWN_SELECTOR_BATTLES)) selectorKnownBattles.add(bType) AccountSettings.setSettings(KNOWN_SELECTOR_BATTLES, selectorKnownBattles)
def setIntroductionValue(cls, introName): settingName = cls.SETTINGS.get(introName) if settingName is not None: AccountSettings.setSettings(settingName, False) return
def setBattleTypeAsKnown(bType): selectorKnownBattles = set(AccountSettings.getSettings(KNOWN_SELECTOR_BATTLES)) selectorKnownBattles.add(bType) AccountSettings.setSettings(KNOWN_SELECTOR_BATTLES, selectorKnownBattles)
def onClanMembersListChanged(self): self.updateData() if len(g_clanCache.clanMembers) == fortified_regions.g_cache.defenceConditions.minClanMembers and self.__fortSettings['showDefHourArrow']: self.__defenceHourArrowVisible = self.__setTutorialArrowToDefenseHourSettingsVisibility() self.__fortSettings['showDefHourArrow'] = False AccountSettings.setSettings('fortSettings', self.__fortSettings)
def triggerEffect(self): setting = self.getTarget() if setting is None: LOG_ERROR('Tutorial setting is not found', self._effect.getTargetID()) return AccountSettings.setSettings(setting.getSettingName(), setting.getSettingValue())
def _save(self, value): settings = value if self.subKey is not None: settings = dict(self.__getSettings()) settings[self.subKey] = value return AccountSettings.setSettings(self.settingName, settings)
def setRosterIntroWindowSetting(type, value=True): settings = dict(AccountSettings.getSettings('fortSettings')) if ROSTER_INTRO_WINDOW not in settings: settings[ROSTER_INTRO_WINDOW] = {} settings[ROSTER_INTRO_WINDOW][type] = value AccountSettings.setSettings('fortSettings', settings)
def __setHintVisited(): return AccountSettings.setSettings(SHOW_OPT_DEVICE_HINT, False)
def suspend(self): AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) self.clear()
def onParamClick(self, paramID): isOpened = not self._expandedGroups[paramID] AccountSettings.setSettings(paramID, isOpened) self._expandedGroups[paramID] = isOpened self._setDPUseAnimAndRebuild(False)
def save(self): return AccountSettings.setSettings(self._getSettingName(), self._asdict())
def suspend(self): AccountSettings.setSettings(DEFAULT_QUEUE, QUEUE_TYPE.RANDOMS) self.clear()
def _checkBattleConsumesIntro(): settings = dict(AccountSettings.getSettings('fortSettings')) if not settings.get('battleConsumesIntroShown'): fort_events.showBattleConsumesIntro() settings['battleConsumesIntroShown'] = True AccountSettings.setSettings('fortSettings', settings)
def __markAsVisited(cls, buildTypeID): fortSettings = dict(AccountSettings.getSettings('fortSettings')) if 'visitedBuildings' not in fortSettings: fortSettings['visitedBuildings'] = DEFAULT_VALUES['settings']['fortSettings']['visitedBuildings'] fortSettings['visitedBuildings'].add(buildTypeID) AccountSettings.setSettings('fortSettings', fortSettings)
def onClanMembersListChanged(self): self.updateData() if len(g_clanCache.clanMembers) == fortified_regions.g_cache.defenceConditions.minClanMembers and self.__fortSettings['showDefHourArrow']: self.__defenceHourArrowVisible = self.__setTutorialArrowToDefenseHourSettingsVisibility() self.__fortSettings['showDefHourArrow'] = False AccountSettings.setSettings('fortSettings', self.__fortSettings)
def _setSetting(self, value): settings = self._getSetting() settings[self.settingFieldName] = value AccountSettings.setSettings(CheckBoxConfirmator.__ACC_SETT_MAIN_KEY, settings)
def updateQuestSettings(quests): s = dict(AccountSettings.getSettings('quests')) completed = set((q.getID() for q in quests.itervalues() if q.isCompleted())) s['visited'] = tuple(set(s.get('visited', [])).difference(completed)) s['naVisited'] = tuple(set(s.get('naVisited', [])).difference(completed)) AccountSettings.setSettings('quests', s)
def storeMinimapSize(self): AccountSettings.setSettings('minimapSize', self.__mapSizeIndex)
def setDialogSettings(self, isOpened): settings = self.getDialogSettings() settings['isOpened'] = isOpened AccountSettings.setSettings('vehicleSellDialog', settings)
def __update(self): newElements = AccountSettings.getSettings('customization') newElementsSubset = newElements[self.__currentType].get( self.__currentVehicle.item.intCD, {}) installedItems = defaultdict(list) purchasedItems = defaultdict(list) otherItems = defaultdict(list) allItems = [installedItems, purchasedItems, otherItems] currentSlotElement = self.__slots.getCurrentSlotData()['element'] installedSlotElement = self.__slots.getInstalledSlotData()['element'] currentCarouselItem = None self.__hasAppliedItem = False for elementID, element in self.__displayedElements[ self.__currentType].iteritems(): installedInCurrentSlot = False if installedSlotElement is not None: installedInCurrentSlot = elementID == installedSlotElement.getID( ) if self.__filter.check(element, installedInCurrentSlot): appliedToCurrentSlot = False if currentSlotElement is not None: appliedToCurrentSlot = elementID == currentSlotElement.getID( ) and not installedInCurrentSlot if not self.__hasAppliedItem and appliedToCurrentSlot: self.__hasAppliedItem = True if elementID in newElementsSubset: isNewElement = newElementsSubset[elementID] newElementsSubset[elementID] = False else: isNewElement = False carouselItem = { 'element': element, 'appliedToCurrentSlot': appliedToCurrentSlot, 'duration': self.__currentDuration, 'isNewElement': isNewElement, 'installedInCurrentSlot': installedInCurrentSlot } if installedInCurrentSlot: group = installedItems[element.getGroup()] elif element.isInDossier: group = purchasedItems[element.getGroup()] else: group = otherItems[element.getGroup()] if element.isFeatured: group.insert(0, carouselItem) else: group.append(carouselItem) if appliedToCurrentSlot: currentCarouselItem = carouselItem AccountSettings.setSettings('customization', newElements) previousItemsCount = len(self.__carouselItems) del self.__carouselItems[:] for groupedItems in allItems: self.__carouselItems += chain(*groupedItems.values()) currentItemsCount = len(self.__carouselItems) if currentCarouselItem is not None: self.__goToIndex = self.__carouselItems.index(currentCarouselItem) else: self.__goToIndex = -1 if previousItemsCount == currentItemsCount else 0 if self.__currentType == CUSTOMIZATION_TYPE.CAMOUFLAGE: unfilteredLength = len(self.__carouselItems) else: unfilteredLength = len( self.__displayedElements[self.__currentType]) self.__events.onCarouselUpdated({ 'items': self.__carouselItems, 'rendererWidth': _RENDERER_WIDTH[self.__currentType], 'goToIndex': self.__goToIndex, 'unfilteredLength': unfilteredLength, 'hasAppliedItem': self.__hasAppliedItem }) return
def storeSettings(self, expanded): AccountSettings.setSettings(VEHICLE_BUY_WINDOW_SETTINGS, expanded)
def _setSetting(self, value): settings = self._getSetting() settings[self.settingFieldName] = value AccountSettings.setSettings(CheckBoxConfirmator.__ACC_SETT_MAIN_KEY, settings)
def _checkBattleConsumesIntro(fort): settings = dict(AccountSettings.getSettings('fortSettings')) if not settings.get('battleConsumesIntroShown') and not fort.isStartingScriptNotStarted(): fort_events.showBattleConsumesIntro() settings['battleConsumesIntroShown'] = True AccountSettings.setSettings('fortSettings', settings)
def apply(self, restartApproved, callbackId, settings): restartClient = False import VOIP ppSettings = dict(AccountSettings.getSettings('players_panel')) ppSettings['showTypes'] = settings['ppShowTypes'] if (not self.resolutions.isVideoWindowed or settings['fullScreen']) and (settings['monitor'] != self.resolutions.realMonitorIndex or self.resolutions.monitorChanged): restartClient = True AccountSettings.setSettings('players_panel', ppSettings) g_settingsCore.applySetting('ppShowLevels', settings['ppShowLevels']) g_settingsCore.applySetting('replayEnabled', settings['replayEnabled']) g_settingsCore.applySetting('fpsPerfomancer', settings['fpsPerfomancer']) AccountSettings.setSettings('nationalVoices', settings['nationalVoices']) AccountSettings.setSettings('isColorBlind', settings['isColorBlind']) g_settingsCore.applySetting('useServerAim', settings['useServerAim']) g_settingsCore.applySetting('showVehiclesCounter', settings['showVehiclesCounter']) g_settingsCore.applySetting('minimapAlpha', settings['minimapAlpha']) arcade = g_settingsCore.options.getSetting('arcade').fromAccountSettings(settings['arcade']) sniper = g_settingsCore.options.getSetting('sniper').fromAccountSettings(settings['sniper']) g_settingsCore.applySetting('arcade', arcade) g_settingsCore.applySetting('sniper', sniper) g_settingsCore.applySetting('enemy', settings['markers']['enemy']) g_settingsCore.applySetting('dead', settings['markers']['dead']) g_settingsCore.applySetting('ally', settings['markers']['ally']) g_settingsCore.applySetting('dynamicCamera', settings['dynamicCamera']) g_settingsCore.applySetting('horStabilizationSnp', settings['horStabilizationSnp']) if self.__altVoiceSetting.isOptionEnabled(): altVoices = settings.get('alternativeVoices') if altVoices is not None: self.__altVoiceSetting.apply(altVoices) vManager = VibroManager.g_instance vManager.setGain(settings['vibroGain'] / 100.0) vEffGroups = vManager.getGroupsSettings() for groupName, newValue in [('engine', settings['vibroEngine']), ('acceleration', settings['vibroAcceleration']), ('shots', settings['vibroShots']), ('hits', settings['vibroHits']), ('collisions', settings['vibroCollisions']), ('damage', settings['vibroDamage']), ('gui', settings['vibroGUI'])]: if groupName in vEffGroups: vEffGroups[groupName].gain = newValue / 100.0 vEffGroups[groupName].enabled = newValue > 0 vManager.setGroupsSettings(vEffGroups) self.__voiceChatEnable(settings['enableVoIP']) self.__changeCaptureDevice(settings[Settings.KEY_VOIP_DEVICE]) g_settingsCore.applySetting('enablePostMortemEffect', settings['enablePostMortemEffect']) self.uiHolder.clearCommands() keyboard = settings['controls']['keyboard'] keyboardMapping = {} keysLayout = dict(g_settingsCore.options.getSetting('keyboard').KEYS_LAYOUT) layout = list(itertools.chain(*keysLayout.values())) for i in xrange(len(self.KEYBOARD_MAPPING_BLOCKS)): group_name = keyboard[i]['id'] for j in xrange(len(self.KEYBOARD_MAPPING_BLOCKS[group_name])): key_name = keyboard[i]['commands'][j]['id'] value = keyboard[i]['commands'][j]['key'] cmd = self.KEYBOARD_MAPPING_COMMANDS[group_name][key_name] for item in layout: key, command = item[0], item[1] if command == cmd: keyboardMapping[key] = value break g_settingsCore.applySetting('keyboard', keyboardMapping) self.uiHolder.bindCommands() player = BigWorld.player() mouse = settings['controls']['mouse'] if hasattr(player.inputHandler, 'ctrls'): player.inputHandler.ctrls['arcade'].camera.setUserConfigValue('sensitivity', mouse['arcadeSens']['value']) player.inputHandler.ctrls['sniper'].camera.setUserConfigValue('sensitivity', mouse['sniperSens']['value']) player.inputHandler.ctrls['strategic'].camera.setUserConfigValue('sensitivity', mouse['artSens']['value']) else: ds = Settings.g_instance.userPrefs[Settings.KEY_CONTROL_MODE] if ds: ds['arcadeMode/camera'].writeFloat('sensitivity', mouse['arcadeSens']['value']) ds['sniperMode/camera'].writeFloat('sensitivity', mouse['sniperSens']['value']) ds['strategicMode/camera'].writeFloat('sensitivity', mouse['artSens']['value']) g_settingsCore.applySetting('mouseHorzInvert', bool(mouse['horInvert']['value'])) g_settingsCore.applySetting('mouseVertInvert', bool(mouse['vertInvert']['value'])) g_settingsCore.applySetting('backDraftInvert', bool(mouse['backDraftInvert']['value'])) self.resolutions.applyChanges(settings['fullScreen'], settings['vertSync'], settings['tripleBuffered'], settings['windowSize'] if not settings['fullScreen'] else settings['resolution'], settings['aspectRatio'], settings['multisampling'], settings['customAA'], settings['gamma'], settings['monitor']) if round(SoundGroups.g_instance.getVolume('masterVivox') * 100) != settings['masterVivoxVolume']: VOIP.getVOIPManager().setMasterVolume(settings['masterVivoxVolume']) if round(SoundGroups.g_instance.getVolume('micVivox') * 100) != settings['micVivoxVolume']: VOIP.getVOIPManager().setMicrophoneVolume(settings['micVivoxVolume']) SoundGroups.g_instance.setMasterVolume(float(settings['masterVolume']) / 100) SoundGroups.g_instance.setVolume('music', float(settings['musicVolume']) / 100) SoundGroups.g_instance.setVolume('voice', float(settings['voiceVolume']) / 100) SoundGroups.g_instance.setVolume('vehicles', float(settings['vehiclesVolume']) / 100) SoundGroups.g_instance.setVolume('effects', float(settings['effectsVolume']) / 100) SoundGroups.g_instance.setVolume('gui', float(settings['guiVolume']) / 100) SoundGroups.g_instance.setVolume('ambient', float(settings['ambientVolume']) / 100) SoundGroups.g_instance.setVolume('masterVivox', float(settings['masterVivoxVolume']) / 100) SoundGroups.g_instance.setVolume('micVivox', float(settings['micVivoxVolume']) / 100) SoundGroups.g_instance.setVolume('masterFadeVivox', float(settings['masterFadeVivoxVolume']) / 100) if len(VOIP.getVOIPManager().captureDevices): device = VOIP.getVOIPManager().captureDevices[0] if len(VOIP.getVOIPManager().captureDevices) > settings['captureDevice']: device = VOIP.getVOIPManager().captureDevices[settings['captureDevice']] VOIP.getVOIPManager().setCaptureDevice(device) g_settingsCore.applySetting('showDateMessage', settings['datetimeIdx'] & 1) g_settingsCore.applySetting('showTimeMessage', settings['datetimeIdx'] & 2) g_settingsCore.applySetting('enableOlFilter', settings['enableOlFilter']) g_settingsCore.applySetting('enableSpamFilter', settings['enableSpamFilter']) g_windowsStoredData.start() g_settingsCore.applySetting('enableStoreMws', settings['enableStoreChatMws']) g_settingsCore.applySetting('enableStoreCws', settings['enableStoreChatCws']) g_windowsStoredData.stop() g_settingsCore.applySetting('invitesFromFriendsOnly', settings['invitesFromFriendsOnly']) g_settingsCore.applySetting('storeReceiverInBattle', settings['storeReceiverInBattle']) gameplayKeys = filter(lambda item: item.startswith(self.GAMEPLAY_PREFIX) and bool(settings[item]), settings.keys()) prefixLen = len(self.GAMEPLAY_PREFIX) gameplay_ctx.setMaskByNames(map(lambda key: str(key[prefixLen:]), gameplayKeys)) qualitySettings = settings['quality'] applyPresets = self.graphicsPresets.checkApplyGraphicsPreset(int(settings['graphicsQuality']), qualitySettings) if applyPresets: self.graphicsPresets.applyGraphicsPresets(int(settings['graphicsQuality']), qualitySettings) if applyPresets == 'restartNeeded': BigWorld.commitPendingGraphicsSettings() restartClient = True elif applyPresets == 'hasPendingSettings': BigWorld.commitPendingGraphicsSettings() g_settingsCore.applyStorages() g_postProcessing.refresh() if restartClient: BigWorld.savePreferences() if restartApproved: from BattleReplay import g_replayCtrl if g_replayCtrl.isPlaying and g_replayCtrl.playbackSpeed == 0: g_replayCtrl.setPlaybackSpeedIdx(5) BigWorld.callback(0.3, BigWorld.restartGame) else: BigWorld.callback(0.0, partial(BigWorld.changeVideoMode, -1, BigWorld.isVideoWindowed())) return