Example #1
1
    def apply(self, restartApproved, callbackId, settings):
        restartClient = False
        interfaceScaled = False
        g_settingsCore.isDeviseRecreated = False
        import VOIP

        if (not self.resolutions.isVideoWindowed or settings["fullScreen"]) and (
            settings["monitor"] != self.resolutions.realMonitorIndex or self.resolutions.monitorChanged
        ):
            restartClient = True
        if g_settingsCore.getSetting("interfaceScale") != settings["interfaceScale"]:
            interfaceScaled = True
        g_settingsCore.applySetting("ppShowTypes", settings["ppShowTypes"])
        g_settingsCore.applySetting("ppShowLevels", settings["ppShowLevels"])
        g_settingsCore.applySetting("replayEnabled", settings["replayEnabled"])
        g_settingsCore.applySetting("fpsPerfomancer", settings["fpsPerfomancer"])
        g_settingsCore.applySetting("colorFilterIntensity", settings["colorFilterIntensity"])
        g_settingsCore.applySetting("fov", settings["fov"])
        g_settingsCore.applySetting("dynamicFov", settings["dynamicFov"])
        g_settingsCore.applySetting("enableOpticalSnpEffect", settings["enableOpticalSnpEffect"])
        g_settingsCore.applySetting("nationalVoices", settings["nationalVoices"])
        g_settingsCore.applySetting("isColorBlind", settings["isColorBlind"])
        g_settingsCore.applySetting("useServerAim", settings["useServerAim"])
        g_settingsCore.applySetting("showVehiclesCounter", settings["showVehiclesCounter"])
        g_settingsCore.applySetting("showMarksOnGun", settings["showMarksOnGun"])
        g_settingsCore.applySetting("minimapAlpha", settings["minimapAlpha"])
        g_settingsCore.applySetting("showVectorOnMap", settings["showVectorOnMap"])
        g_settingsCore.applySetting("showSectorOnMap", settings["showSectorOnMap"])
        g_settingsCore.applySetting("showVehModelsOnMap", settings["showVehModelsOnMap"])
        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("interfaceScale", settings["interfaceScale"])
        if "showBattleEfficiencyRibbons" in settings:
            g_settingsCore.applySetting("showBattleEfficiencyRibbons", settings["showBattleEfficiencyRibbons"])
        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"])
        g_settingsCore.applySetting(SOUND.CAPTURE_DEVICES, settings[Settings.KEY_VOIP_DEVICE])
        g_settingsCore.applySetting("enablePostMortemEffect", settings["enablePostMortemEffect"])
        g_settingsCore.applySetting("enablePostMortemDelay", settings["enablePostMortemDelay"])
        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"]))
        g_settingsCore.applySetting("monitor", settings["monitor"])
        isFullScreen = bool(settings["fullScreen"])
        if isFullScreen:
            g_settingsCore.applySetting("refreshRate", settings["refreshRate"])
            g_settingsCore.applySetting("resolution", settings["resolution"])
            g_settingsCore.applySetting("aspectRatio", settings["aspectRatio"])
            g_settingsCore.applySetting("gamma", settings["gamma"])
        else:
            g_settingsCore.applySetting("windowSize", settings["windowSize"])
        g_settingsCore.applySetting("fullScreen", isFullScreen)
        g_settingsCore.applySetting("multisampling", settings["multisampling"])
        g_settingsCore.applySetting("customAA", settings["customAA"])
        g_settingsCore.applySetting("vertSync", settings["vertSync"])
        g_settingsCore.applySetting("tripleBuffered", settings["tripleBuffered"])
        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)
        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("receiveFriendshipRequest", settings["receiveFriendshipRequest"])
        g_settingsCore.applySetting("receiveInvitesInBattle", settings.get("receiveInvitesInBattle"))
        g_windowsStoredData.stop()
        g_settingsCore.applySetting("invitesFromFriendsOnly", settings["invitesFromFriendsOnly"])
        g_settingsCore.applySetting("storeReceiverInBattle", settings["storeReceiverInBattle"])
        g_settingsCore.applySetting("disableBattleChat", settings["disableBattleChat"])
        g_settingsCore.applySetting("chatContactsListOnly", settings["chatContactsListOnly"])
        gameplayKeys = filter(lambda item: item.startswith(self.GAMEPLAY_PREFIX), settings.keys())
        for key in gameplayKeys:
            g_settingsCore.applySetting(key, settings[key])

        qualitySettings = settings["quality"]
        applyMethod = g_settingsCore.options.getApplyMethod(qualitySettings)
        for key in GraphicsPresets.GRAPHICS_QUALITY_SETTINGS:
            value = qualitySettings.get(key)
            if value is not None:
                g_settingsCore.applySetting(key, value)

        g_settingsCore.applySetting("dynamicRenderer", settings["dynamicRenderer"])
        if applyMethod == APPLY_METHOD.RESTART:
            BigWorld.commitPendingGraphicsSettings()
            restartClient = True
        elif applyMethod == APPLY_METHOD.DELAYED:
            BigWorld.commitPendingGraphicsSettings()
        confirmators = g_settingsCore.applyStorages(restartClient)
        for confirmation, revert in confirmators:
            if confirmation is not None:
                if confirmation == "graphicsChangeConfirmation":

                    def callback(isConfirmed):
                        if not isConfirmed:
                            g_settingsCore.isChangesConfirmed = False
                            revert()

                    self.graphicsChangeConfirmationRevert = revert
                    self.call("SettingsDialog.ApplySettings", [confirmation])

        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, self.__restartGame)
            elif g_settingsCore.isDeviseRecreated:
                g_settingsCore.isDeviseRecreated = False
            else:
                BigWorld.callback(0.0, partial(BigWorld.changeVideoMode, -1, BigWorld.isVideoWindowed()))
        if interfaceScaled:
            self.__settingsUI.buildGraphicsData(self.__getVideoSettings())
        return
    def __call__(self):
        if self.__needReboot:
            return
        WWISE.WW_onMemoryCritical()
        self.__selfCheckInProgress = False
        self.__needReboot = True
        self.__loweredSettings = [ t for t in BigWorld.graphicsSettings() if t[0] == 'TEXTURE_QUALITY' ]
        texQuality = BigWorld.getGraphicsSetting('TEXTURE_QUALITY')
        pipelineType = BigWorld.getGraphicsSetting('RENDER_PIPELINE')
        textureSettings = [ t for t in self.__loweredSettings if t[0] == 'TEXTURE_QUALITY' ][0][2]
        textureMinQuality = len(textureSettings) - 1
        if textureSettings[textureMinQuality][0] == 'OFF':
            textureMinQuality -= 1
        while 1:
            (textureSettings[textureMinQuality][1] is False or pipelineType == 1 and textureSettings[textureMinQuality][2] is True) and textureMinQuality -= 1

        if textureMinQuality < texQuality:
            textureMinQuality = texQuality
        if texQuality < textureMinQuality:
            if self.__originTexQuality == -1 and texQuality < textureMinQuality:
                self.__originTexQuality = texQuality
        else:
            message = (1, 'insufficient_memory_please_reboot')
            self.__messages.append(message)
            self.onMemCrit(message)
            LOG_NOTE("The free memory is too low, We can't do anything. Please, reboot the game.")
            return
        message = (0, 'tex_was_lowered_to_min')
        self.onMemCrit(message)
        message = (1, 'insufficient_memory_please_reboot')
        self.__messages.append(message)
        if texQuality < textureMinQuality:
            BigWorld.setGraphicsSetting('TEXTURE_QUALITY', textureMinQuality)
            LOG_NOTE('To save the memory the texture quality setting was force lowered to <%s>.' % textureSettings[textureMinQuality][0])
        BigWorld.commitPendingGraphicsSettings()
    def restore(self):
        toRestore = []
        if self.__originTexQuality != -1:
            toRestore.append(('TEXTURE_QUALITY', self.__originTexQuality))
        if self.__originFloraQuality != -1:
            toRestore.append(('FLORA_QUALITY', self.__originFloraQuality))
        if self.__originTerrainQuality != -1:
            toRestore.append(('TERRAIN_QUALITY', self.__originTerrainQuality))
        commit = False
        for label, originalIndex in toRestore:
            if self.__setGraphicsSetting(label, self.__originTexQuality):
                commit = True
                LOG_NOTE('The setting was restored to the original value.',
                         label,
                         self.__getLoweredOptionLabel(label, originalIndex))
            LOG_ERROR('The setting was not restored to the original value.',
                      label,
                      self.__getLoweredOptionLabel(label, originalIndex),
                      BigWorld.getGraphicsSetting(label),
                      self.__getLoweredOption(label))

        if commit:
            BigWorld.commitPendingGraphicsSettings()
            self.__originTexQuality = -1
            self.__originFloraQuality = -1
            self.__originTerrainQuality = -1
            self.__needReboot = False
            self.__messages = []
 def __call__(self):
     if self.__needReboot:
         return
     texQuality = BigWorld.getGraphicsSetting('TEXTURE_QUALITY')
     if texQuality < 2:
         texQuality += 1
         if self.__originQuality == -1:
             self.__originQuality = texQuality - 1
         LOG_NOTE(
             'To save the memory the texture quality setting was force lowered to <%s>.'
             % self.QUALITY_MAP[texQuality])
     else:
         message = (1, 'insufficient_memory_please_reboot')
         self.__messages.append(message)
         self.__event(message)
         LOG_NOTE(
             "The free memory is too low, We can't do anything. Please, reboot the game."
         )
         self.__needReboot = True
         return
     message = (0, 'tex_was_lowered_to_' + self.QUALITY_MAP[texQuality])
     self.__messages.append(message)
     self.__event(message)
     BigWorld.setGraphicsSetting('TEXTURE_QUALITY', texQuality)
     BigWorld.commitPendingGraphicsSettings()
    def __call__(self):
        if self.__needReboot:
            return 
        self.__needReboot = True
        self.__loweredSettings = [ t for t in BigWorld.graphicsSettings() if t[0] == 'TEXTURE_QUALITY' or t[0] == 'FLORA_QUALITY' or t[0] == 'TERRAIN_QUALITY' ]
        texQuality = BigWorld.getGraphicsSetting('TEXTURE_QUALITY')
        floraQuality = BigWorld.getGraphicsSetting('FLORA_QUALITY')
        terrainQuality = BigWorld.getGraphicsSetting('TERRAIN_QUALITY')
        pipelineType = BigWorld.getGraphicsSetting('RENDER_PIPELINE')
        textureSettings = [ t for t in self.__loweredSettings if t[0] == 'TEXTURE_QUALITY' ][0][2]
        floraSettings = [ t for t in self.__loweredSettings if t[0] == 'FLORA_QUALITY' ][0][2]
        terrainSettings = [ t for t in self.__loweredSettings if t[0] == 'TERRAIN_QUALITY' ][0][2]
        textureMinQuality = len(textureSettings) - 1
        floraMinQuality = len(floraSettings) - 1
        terrainMinQuality = len(terrainSettings) - 1
        if textureSettings[textureMinQuality][0] == 'OFF':
            textureMinQuality -= 1
        while textureSettings[textureMinQuality][1] == False or pipelineType == 1 and textureSettings[textureMinQuality][2] == True:
            textureMinQuality -= 1

        if textureMinQuality < texQuality:
            textureMinQuality = texQuality
        while floraSettings[floraMinQuality][1] == False or pipelineType == 1 and floraSettings[floraMinQuality][2] == True:
            floraMinQuality -= 1

        if floraMinQuality < floraQuality:
            floraMinQuality = floraQuality
        while terrainSettings[terrainMinQuality][1] == False or pipelineType == 1 and terrainSettings[terrainMinQuality][2] == True:
            terrainMinQuality -= 1

        if terrainMinQuality < terrainQuality:
            terrainMinQuality = terrainQuality
        if texQuality < textureMinQuality or floraQuality < floraMinQuality or terrainQuality < terrainMinQuality:
            if self.__originTexQuality == -1 and texQuality < textureMinQuality:
                self.__originTexQuality = texQuality
            if self.__originFloraQuality == -1 and floraQuality < floraMinQuality:
                self.__originFloraQuality = floraQuality
            if self.__originTerrainQuality == -1 and terrainQuality < terrainMinQuality:
                self.__originTerrainQuality = terrainQuality
        else:
            message = (1, 'insufficient_memory_please_reboot')
            self.__messages.append(message)
            self.__event(message)
            LOG_NOTE("The free memory is too low, We can't do anything. Please, reboot the game.")
            return 
        message = (0, 'tex_was_lowered_to_min')
        self.__event(message)
        message = (1, 'insufficient_memory_please_reboot')
        self.__messages.append(message)
        if texQuality < textureMinQuality:
            BigWorld.setGraphicsSetting('TEXTURE_QUALITY', textureMinQuality)
            LOG_NOTE('To save the memory the texture quality setting was force lowered to <%s>.' % textureSettings[textureMinQuality][0])
        if floraQuality < floraMinQuality:
            BigWorld.setGraphicsSetting('FLORA_QUALITY', floraMinQuality)
            LOG_NOTE('To save the memory the flora quality setting was force lowered to <%s>.' % floraSettings[floraMinQuality][0])
        if terrainQuality < terrainMinQuality:
            BigWorld.setGraphicsSetting('TERRAIN_QUALITY', terrainMinQuality)
            LOG_NOTE('To save the memory the terrain quality setting was force lowered to <%s>.' % terrainSettings[terrainMinQuality][0])
        BigWorld.commitPendingGraphicsSettings()
Example #6
0
 def apply(self, diff):
     diff = self.__settingsDiffPreprocessing(diff)
     applyMethod = self.getApplyMethod(diff)
     self.SETTINGS.apply(diff)
     g_settingsCore.applyStorages()
     if len(set(graphics.GRAPHICS_SETTINGS.ALL()) & set(diff.keys())):
         BigWorld.commitPendingGraphicsSettings()
     return applyMethod == options.APPLY_METHOD.RESTART
Example #7
0
 def apply(self, diff, restartApproved):
     diff = self.__settingsDiffPreprocessing(diff)
     applyMethod = self.getApplyMethod(diff)
     g_settingsCore.applySettings(diff)
     confirmators = g_settingsCore.applyStorages(restartApproved)
     g_settingsCore.confirmChanges(confirmators)
     if len(set(graphics.GRAPHICS_SETTINGS.ALL()) & set(diff.keys())):
         BigWorld.commitPendingGraphicsSettings()
     return applyMethod == options.APPLY_METHOD.RESTART
Example #8
0
 def apply(self, diff, restartApproved):
     diff = self.__settingsDiffPreprocessing(diff)
     applyMethod = self.getApplyMethod(diff)
     g_settingsCore.applySettings(diff)
     confirmators = g_settingsCore.applyStorages(restartApproved)
     g_settingsCore.confirmChanges(confirmators)
     if len(set(graphics.GRAPHICS_SETTINGS.ALL()) & set(diff.keys())):
         BigWorld.commitPendingGraphicsSettings()
     return applyMethod == options.APPLY_METHOD.RESTART
 def restore(self):
     if self.__originQuality != -1:
         BigWorld.setGraphicsSetting('TEXTURE_QUALITY',
                                     self.__originQuality)
         BigWorld.commitPendingGraphicsSettings()
         LOG_NOTE(
             'The texture quality setting was restored to the original value <%s>.'
             % self.QUALITY_MAP[self.__originQuality])
         self.__originQuality = -1
         self.__needReboot = False
         self.__messages = []
Example #10
0
 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()
Example #11
0
 def apply(self, diff, restartApproved):
     """
     Applies given settings diff
     
     :param diff: [dict(settingName->settingValue)] settings values
     :param restartApproved: was restart approved
     :return: restart needed flag
     """
     diff = self.__settingsDiffPreprocessing(diff)
     applyMethod = self.getApplyMethod(diff)
     g_settingsCore.applySettings(diff)
     confirmators = g_settingsCore.applyStorages(restartApproved)
     g_settingsCore.confirmChanges(confirmators)
     if len(set(graphics.GRAPHICS_SETTINGS.ALL()) & set(diff.keys())):
         BigWorld.commitPendingGraphicsSettings()
     return applyMethod == options.APPLY_METHOD.RESTART
Example #12
0
 def apply(self, diff, restartApproved):
     """
     Applies given settings diff
     
     :param diff: [dict(settingName->settingValue)] settings values
     :param restartApproved: was restart approved
     :return: restart needed flag
     """
     diff = self.__settingsDiffPreprocessing(diff)
     applyMethod = self.getApplyMethod(diff)
     g_settingsCore.applySettings(diff)
     confirmators = g_settingsCore.applyStorages(restartApproved)
     g_settingsCore.confirmChanges(confirmators)
     if len(set(graphics.GRAPHICS_SETTINGS.ALL()) & set(diff.keys())):
         BigWorld.commitPendingGraphicsSettings()
     return applyMethod == options.APPLY_METHOD.RESTART
Example #13
0
    def restore(self):
        toRestore = []
        commit = False
        for label, originalIndex in toRestore:
            if self.__setGraphicsSetting(label, originalIndex):
                commit = True
                LOG_NOTE('The setting was restored to the original value.',
                         label,
                         self.__getLoweredOptionLabel(label, originalIndex))
            LOG_ERROR('The setting was not restored to the original value.',
                      label,
                      self.__getLoweredOptionLabel(label, originalIndex),
                      BigWorld.getGraphicsSetting(label),
                      self.__getLoweredOption(label))

        if commit:
            BigWorld.commitPendingGraphicsSettings()
            self.__needReboot = False
            self.__messages = []
 def restore(self):
     if self.__originTexQuality != -1 or self.__originFloraQuality != -1 or self.__originTerrainQuality != -1:
         if self.__originTexQuality != -1:
             BigWorld.setGraphicsSetting('TEXTURE_QUALITY', self.__originTexQuality)
             textureSettings = [ t for t in self.__loweredSettings if t[0] == 'TEXTURE_QUALITY' ][0][2]
             LOG_NOTE('The texture quality setting was restored to the original value <%s>.' % textureSettings[self.__originTexQuality][0])
         if self.__originFloraQuality != -1:
             BigWorld.setGraphicsSetting('FLORA_QUALITY', self.__originFloraQuality)
             floraSettings = [ t for t in self.__loweredSettings if t[0] == 'FLORA_QUALITY' ][0][2]
             LOG_NOTE('The flora quality setting was restored to the original value <%s>.' % floraSettings[self.__originFloraQuality][0])
         if self.__originTerrainQuality != -1:
             BigWorld.setGraphicsSetting('TERRAIN_QUALITY', self.__originTerrainQuality)
             terrainSettings = [ t for t in self.__loweredSettings if t[0] == 'TERRAIN_QUALITY' ][0][2]
             LOG_NOTE('The terrain quality setting was restored to the original value <%s>.' % terrainSettings[self.__originTerrainQuality][0])
         BigWorld.commitPendingGraphicsSettings()
         self.__originTexQuality = -1
         self.__originFloraQuality = -1
         self.__originTerrainQuality = -1
         self.__needReboot = False
         self.__messages = []
Example #15
0
 def restore(self):
     if self.__originTexQuality != -1 or self.__originFloraQuality != -1 or self.__originTerrainQuality != -1:
         if self.__originTexQuality != -1:
             BigWorld.setGraphicsSetting('TEXTURE_QUALITY',
                                         self.__originTexQuality)
             textureSettings = [
                 t for t in self.__loweredSettings
                 if t[0] == 'TEXTURE_QUALITY'
             ][0][2]
             LOG_NOTE(
                 'The texture quality setting was restored to the original value <%s>.'
                 % textureSettings[self.__originTexQuality][0])
         if self.__originFloraQuality != -1:
             BigWorld.setGraphicsSetting('FLORA_QUALITY',
                                         self.__originFloraQuality)
             floraSettings = [
                 t for t in self.__loweredSettings
                 if t[0] == 'FLORA_QUALITY'
             ][0][2]
             LOG_NOTE(
                 'The flora quality setting was restored to the original value <%s>.'
                 % floraSettings[self.__originFloraQuality][0])
         if self.__originTerrainQuality != -1:
             BigWorld.setGraphicsSetting('TERRAIN_QUALITY',
                                         self.__originTerrainQuality)
             terrainSettings = [
                 t for t in self.__loweredSettings
                 if t[0] == 'TERRAIN_QUALITY'
             ][0][2]
             LOG_NOTE(
                 'The terrain quality setting was restored to the original value <%s>.'
                 % terrainSettings[self.__originTerrainQuality][0])
         BigWorld.commitPendingGraphicsSettings()
         self.__originTexQuality = -1
         self.__originFloraQuality = -1
         self.__originTerrainQuality = -1
         self.__needReboot = False
         self.__messages = []
    def apply(self, restartApproved, callbackId, settings):
        restartClient = False
        interfaceScaled = False
        g_settingsCore.isDeviseRecreated = False
        isSoundChanged = settings[
            SOUND.MASTER_TOGGLE] is not g_settingsCore.getSetting(
                SOUND.MASTER_TOGGLE) or settings[
                    SOUND.SOUND_QUALITY] is not g_settingsCore.getSetting(
                        SOUND.SOUND_QUALITY)
        import VOIP
        if (not self.resolutions.isVideoWindowed or settings['fullScreen']
            ) and (settings['monitor'] != self.resolutions.realMonitorIndex
                   or self.resolutions.monitorChanged):
            restartClient = True
        if g_settingsCore.getSetting(
                'interfaceScale') != settings['interfaceScale']:
            interfaceScaled = True
        g_settingsCore.applySetting('ppShowTypes', settings['ppShowTypes'])
        g_settingsCore.applySetting('ppShowLevels', settings['ppShowLevels'])
        g_settingsCore.applySetting('replayEnabled', settings['replayEnabled'])
        g_settingsCore.applySetting('fpsPerfomancer',
                                    settings['fpsPerfomancer'])
        g_settingsCore.applySetting('colorFilterIntensity',
                                    settings['colorFilterIntensity'])
        g_settingsCore.applySetting('fov', settings['fov'])
        g_settingsCore.applySetting('dynamicFov', settings['dynamicFov'])
        g_settingsCore.applySetting('enableOpticalSnpEffect',
                                    settings['enableOpticalSnpEffect'])
        g_settingsCore.applySetting('isColorBlind', settings['isColorBlind'])
        g_settingsCore.applySetting('useServerAim', settings['useServerAim'])
        g_settingsCore.applySetting('showVehiclesCounter',
                                    settings['showVehiclesCounter'])
        g_settingsCore.applySetting('showMarksOnGun',
                                    settings['showMarksOnGun'])
        g_settingsCore.applySetting('simplifiedTTC', settings['simplifiedTTC'])
        g_settingsCore.applySetting('minimapAlpha', settings['minimapAlpha'])
        g_settingsCore.applySetting('showVectorOnMap',
                                    settings['showVectorOnMap'])
        g_settingsCore.applySetting('showSectorOnMap',
                                    settings['showSectorOnMap'])
        g_settingsCore.applySetting('showVehModelsOnMap',
                                    settings['showVehModelsOnMap'])
        g_settingsCore.applySetting('minimapViewRange',
                                    settings['minimapViewRange'])
        g_settingsCore.applySetting('minimapMaxViewRange',
                                    settings['minimapMaxViewRange'])
        g_settingsCore.applySetting('minimapDrawRange',
                                    settings['minimapDrawRange'])
        g_settingsCore.applySetting('battleLoadingInfo',
                                    settings['battleLoadingInfo'])
        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('interfaceScale',
                                    settings['interfaceScale'])
        if 'showBattleEfficiencyRibbons' in settings:
            g_settingsCore.applySetting(
                'showBattleEfficiencyRibbons',
                settings['showBattleEfficiencyRibbons'])
        g_settingsCore.applySetting('dynamicCamera', settings['dynamicCamera'])
        g_settingsCore.applySetting('horStabilizationSnp',
                                    settings['horStabilizationSnp'])
        g_settingsCore.applySetting('increasedZoom', settings['increasedZoom'])
        g_settingsCore.applySetting('sniperModeByShift',
                                    settings['sniperModeByShift'])
        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'])
        g_settingsCore.applySetting(SOUND.CAPTURE_DEVICES,
                                    settings[Settings.KEY_VOIP_DEVICE])
        g_settingsCore.applySetting('enablePostMortemEffect',
                                    settings['enablePostMortemEffect'])
        g_settingsCore.applySetting('enablePostMortemDelay',
                                    settings['enablePostMortemDelay'])
        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']))
        g_settingsCore.applySetting('monitor', settings['monitor'])
        isFullScreen = bool(settings['fullScreen'])
        if isFullScreen:
            g_settingsCore.applySetting('refreshRate', settings['refreshRate'])
            g_settingsCore.applySetting('resolution', settings['resolution'])
            g_settingsCore.applySetting('aspectRatio', settings['aspectRatio'])
            g_settingsCore.applySetting('gamma', settings['gamma'])
        else:
            g_settingsCore.applySetting('windowSize', settings['windowSize'])
        g_settingsCore.applySetting('fullScreen', isFullScreen)
        g_settingsCore.applySetting('multisampling', settings['multisampling'])
        g_settingsCore.applySetting('customAA', settings['customAA'])
        g_settingsCore.applySetting('vertSync', settings['vertSync'])
        g_settingsCore.applySetting('tripleBuffered',
                                    settings['tripleBuffered'])
        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'])
        for s in (SOUND.MASTER_TOGGLE, SOUND.SOUND_QUALITY):
            g_settingsCore.applySetting(s, settings[s])

        SoundGroups.g_instance.setMasterVolume(
            float(settings['masterVolume']) / 100)
        SoundGroups.g_instance.setVolume('music',
                                         float(settings['musicVolume']) / 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)
        g_settingsCore.applySetting('dynamicRange', settings['dynamicRange'])
        g_settingsCore.applySetting('soundDevice', settings['soundDevice'])
        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('receiveFriendshipRequest',
                                    settings['receiveFriendshipRequest'])
        g_settingsCore.applySetting('receiveInvitesInBattle',
                                    settings.get('receiveInvitesInBattle'))
        g_settingsCore.applySetting(
            'receiveClanInvitesNotifications',
            settings.get('receiveClanInvitesNotifications'))
        g_windowsStoredData.stop()
        g_settingsCore.applySetting('invitesFromFriendsOnly',
                                    settings['invitesFromFriendsOnly'])
        g_settingsCore.applySetting('disableBattleChat',
                                    settings['disableBattleChat'])
        g_settingsCore.applySetting('chatContactsListOnly',
                                    settings['chatContactsListOnly'])
        gameplayKeys = filter(
            lambda item: item.startswith(self.GAMEPLAY_PREFIX),
            settings.keys())
        for key in gameplayKeys:
            g_settingsCore.applySetting(key, settings[key])

        qualitySettings = settings['quality']
        applyMethod = g_settingsCore.options.getApplyMethod(qualitySettings)
        for key in GraphicsPresets.GRAPHICS_QUALITY_SETTINGS:
            value = qualitySettings.get(key)
            if value is not None:
                g_settingsCore.applySetting(key, value)

        g_settingsCore.applySetting('dynamicRenderer',
                                    settings['dynamicRenderer'])
        if applyMethod == APPLY_METHOD.RESTART or isSoundChanged:
            BigWorld.commitPendingGraphicsSettings()
            restartClient = True
        elif applyMethod == APPLY_METHOD.DELAYED:
            BigWorld.commitPendingGraphicsSettings()
        confirmators = g_settingsCore.applyStorages(restartClient)
        for confirmation, revert in confirmators:
            if confirmation is not None:
                if confirmation == 'graphicsChangeConfirmation':

                    def callback(isConfirmed):
                        if not isConfirmed:
                            g_settingsCore.isChangesConfirmed = False
                            revert()

                    self.graphicsChangeConfirmationRevert = revert
                    self.call('SettingsDialog.ApplySettings', [confirmation])

        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, self.__restartGame)
            elif g_settingsCore.isDeviseRecreated:
                g_settingsCore.isDeviseRecreated = False
            else:
                BigWorld.callback(
                    0.0,
                    partial(BigWorld.changeVideoMode, -1,
                            BigWorld.isVideoWindowed()))
        if interfaceScaled:
            self.__settingsUI.buildGraphicsData(self.__getVideoSettings())
        return
Example #17
0
    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
Example #18
0
    def apply(self, restartApproved, callbackId, settings):
        restartClient = False
        g_settingsCore.isDeviseRecreated = False
        import VOIP
        if (not self.resolutions.isVideoWindowed or settings['fullScreen']) and (settings['monitor'] != self.resolutions.realMonitorIndex or self.resolutions.monitorChanged):
            restartClient = True
        g_settingsCore.applySetting('ppShowTypes', settings['ppShowTypes'])
        g_settingsCore.applySetting('ppShowLevels', settings['ppShowLevels'])
        g_settingsCore.applySetting('replayEnabled', settings['replayEnabled'])
        g_settingsCore.applySetting('fpsPerfomancer', settings['fpsPerfomancer'])
        g_settingsCore.applySetting('dynamicRenderer', settings['dynamicRenderer'])
        g_settingsCore.applySetting('colorFilterIntensity', settings['colorFilterIntensity'])
        g_settingsCore.applySetting('fov', settings['fov'])
        g_settingsCore.applySetting('dynamicFov', settings['dynamicFov'])
        g_settingsCore.applySetting('enableOpticalSnpEffect', settings['enableOpticalSnpEffect'])
        g_settingsCore.applySetting('nationalVoices', settings['nationalVoices'])
        g_settingsCore.applySetting('isColorBlind', settings['isColorBlind'])
        g_settingsCore.applySetting('useServerAim', settings['useServerAim'])
        g_settingsCore.applySetting('showVehiclesCounter', settings['showVehiclesCounter'])
        g_settingsCore.applySetting('showMarksOnGun', settings['showMarksOnGun'])
        g_settingsCore.applySetting('minimapAlpha', settings['minimapAlpha'])
        g_settingsCore.applySetting('showVectorOnMap', settings['showVectorOnMap'])
        g_settingsCore.applySetting('showSectorOnMap', settings['showSectorOnMap'])
        g_settingsCore.applySetting('showVehModelsOnMap', settings['showVehModelsOnMap'])
        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'])
        g_settingsCore.applySetting(SOUND.CAPTURE_DEVICES, settings[Settings.KEY_VOIP_DEVICE])
        g_settingsCore.applySetting('enablePostMortemEffect', settings['enablePostMortemEffect'])
        g_settingsCore.applySetting('enablePostMortemDelay', settings['enablePostMortemDelay'])
        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']))
        isFullScreen = bool(settings['fullScreen'])
        if isFullScreen:
            g_settingsCore.applySetting('refreshRate', settings['refreshRate'])
            g_settingsCore.applySetting('resolution', settings['resolution'])
            g_settingsCore.applySetting('aspectRatio', settings['aspectRatio'])
            g_settingsCore.applySetting('gamma', settings['gamma'])
        else:
            g_settingsCore.applySetting('windowSize', settings['windowSize'])
        g_settingsCore.applySetting('fullScreen', isFullScreen)
        g_settingsCore.applySetting('multisampling', settings['multisampling'])
        g_settingsCore.applySetting('customAA', settings['customAA'])
        g_settingsCore.applySetting('monitor', settings['monitor'])
        g_settingsCore.applySetting('vertSync', settings['vertSync'])
        g_settingsCore.applySetting('tripleBuffered', settings['tripleBuffered'])
        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)
        from BattleReplay import g_replayCtrl
        if g_replayCtrl is not None and g_replayCtrl.isPlaying:
            if g_replayCtrl.playbackSpeed == 0 or g_replayCtrl.playbackSpeed > 4.0:
                SoundGroups.g_instance.enableReplaySounds(False)
        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'])
        g_settingsCore.applySetting('disableBattleChat', settings['disableBattleChat'])
        gameplayKeys = filter(lambda item: item.startswith(self.GAMEPLAY_PREFIX), settings.keys())
        for key in gameplayKeys:
            g_settingsCore.applySetting(key, settings[key])

        qualitySettings = settings['quality']
        applyMethod = g_settingsCore.options.getApplyMethod(qualitySettings)
        for key in GraphicsPresets.GRAPHICS_QUALITY_SETTINGS:
            value = qualitySettings.get(key)
            if value is not None:
                g_settingsCore.applySetting(key, value)

        if applyMethod == APPLY_METHOD.RESTART:
            BigWorld.commitPendingGraphicsSettings()
            restartClient = True
        elif applyMethod == APPLY_METHOD.DELAYED:
            BigWorld.commitPendingGraphicsSettings()
        confirmators = g_settingsCore.applyStorages(restartClient)
        for confirmation, revert in confirmators:
            if confirmation is not None:
                if confirmation == 'graphicsChangeConfirmation':

                    def callback(isConfirmed):
                        if not isConfirmed:
                            g_settingsCore.isChangesConfirmed = False
                            revert()

                    self.graphicsChangeConfirmationRevert = revert
                    self.call('SettingsDialog.ApplySettings', [confirmation])

        g_postProcessing.refresh()
        if restartClient:
            BigWorld.savePreferences()
            if restartApproved:
                if g_replayCtrl.isPlaying and g_replayCtrl.playbackSpeed == 0:
                    g_replayCtrl.setPlaybackSpeedIdx(5)
                BigWorld.callback(0.3, self.__restartGame)
            elif g_settingsCore.isDeviseRecreated:
                g_settingsCore.isDeviseRecreated = False
            else:
                BigWorld.callback(0.0, partial(BigWorld.changeVideoMode, -1, BigWorld.isVideoWindowed()))
        return
Example #19
0
    def __call__(self):
        if self.__needReboot:
            return
        self.__needReboot = True
        self.__loweredSettings = [
            t for t in BigWorld.graphicsSettings() if t[0] == 'TEXTURE_QUALITY'
            or t[0] == 'FLORA_QUALITY' or t[0] == 'TERRAIN_QUALITY'
        ]
        texQuality = BigWorld.getGraphicsSetting('TEXTURE_QUALITY')
        floraQuality = BigWorld.getGraphicsSetting('FLORA_QUALITY')
        terrainQuality = BigWorld.getGraphicsSetting('TERRAIN_QUALITY')
        pipelineType = BigWorld.getGraphicsSetting('RENDER_PIPELINE')
        textureSettings = [
            t for t in self.__loweredSettings if t[0] == 'TEXTURE_QUALITY'
        ][0][2]
        floraSettings = [
            t for t in self.__loweredSettings if t[0] == 'FLORA_QUALITY'
        ][0][2]
        terrainSettings = [
            t for t in self.__loweredSettings if t[0] == 'TERRAIN_QUALITY'
        ][0][2]
        textureMinQuality = len(textureSettings) - 1
        floraMinQuality = len(floraSettings) - 1
        terrainMinQuality = len(terrainSettings) - 1
        if textureSettings[textureMinQuality][0] == 'OFF':
            textureMinQuality -= 1
        while textureSettings[textureMinQuality][
                1] is False or pipelineType == 1 and textureSettings[
                    textureMinQuality][2] is True:
            textureMinQuality -= 1

        if textureMinQuality < texQuality:
            textureMinQuality = texQuality
        while floraSettings[floraMinQuality][
                1] is False or pipelineType == 1 and floraSettings[
                    floraMinQuality][2] is True:
            floraMinQuality -= 1

        if floraMinQuality < floraQuality:
            floraMinQuality = floraQuality
        while terrainSettings[terrainMinQuality][
                1] is False or pipelineType == 1 and terrainSettings[
                    terrainMinQuality][2] is True:
            terrainMinQuality -= 1

        if terrainMinQuality < terrainQuality:
            terrainMinQuality = terrainQuality
        if texQuality < textureMinQuality or floraQuality < floraMinQuality or terrainQuality < terrainMinQuality:
            if self.__originTexQuality == -1 and texQuality < textureMinQuality:
                self.__originTexQuality = texQuality
            if self.__originFloraQuality == -1 and floraQuality < floraMinQuality:
                self.__originFloraQuality = floraQuality
            if self.__originTerrainQuality == -1 and terrainQuality < terrainMinQuality:
                self.__originTerrainQuality = terrainQuality
        else:
            message = (1, 'insufficient_memory_please_reboot')
            self.__messages.append(message)
            self.__event(message)
            LOG_NOTE(
                "The free memory is too low, We can't do anything. Please, reboot the game."
            )
            return
        message = (0, 'tex_was_lowered_to_min')
        self.__event(message)
        message = (1, 'insufficient_memory_please_reboot')
        self.__messages.append(message)
        if texQuality < textureMinQuality:
            BigWorld.setGraphicsSetting('TEXTURE_QUALITY', textureMinQuality)
            LOG_NOTE(
                'To save the memory the texture quality setting was force lowered to <%s>.'
                % textureSettings[textureMinQuality][0])
        if floraQuality < floraMinQuality:
            BigWorld.setGraphicsSetting('FLORA_QUALITY', floraMinQuality)
            LOG_NOTE(
                'To save the memory the flora quality setting was force lowered to <%s>.'
                % floraSettings[floraMinQuality][0])
        if terrainQuality < terrainMinQuality:
            BigWorld.setGraphicsSetting('TERRAIN_QUALITY', terrainMinQuality)
            LOG_NOTE(
                'To save the memory the terrain quality setting was force lowered to <%s>.'
                % terrainSettings[terrainMinQuality][0])
        BigWorld.commitPendingGraphicsSettings()
    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