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
