2f107db...5202af9

2019-03-18 21:42:26 +02:00
parent 58c92888b7
commit 044fd3344b
395 changed files with 27417 additions and 19754 deletions
@@ -26,7 +26,9 @@ namespace Barotrauma

    public partial class GameSettings
    {
-        const string FilePath = "config.xml";
+        const string savePath = "config.xml";
+        const string playerSavePath = "config_player.xml";
+        const string vanillaContentPackagePath = "Data/ContentPackages/Vanilla";

        public int GraphicsWidth { get; set; }
        public int GraphicsHeight { get; set; }
@@ -37,10 +39,26 @@ namespace Barotrauma
        
        public int ParticleLimit { get; set; }

+        public int ParticleLimit { get; set; }
+
        public float LightMapScale { get; set; }
        public bool SpecularityEnabled { get; set; }
        public bool ChromaticAberrationEnabled { get; set; }

+        public bool MuteOnFocusLost { get; set; }
+
+        public enum VoiceMode
+        {
+            Disabled,
+            PushToTalk,
+            Activity
+        };
+
+        public VoiceMode VoiceSetting { get; set; }
+        public string VoiceCaptureDevice { get; set; }
+
+        public float NoiseGateThreshold { get; set; } = -45;
+
        private KeyOrMouse[] keyMapping;

        private WindowMode windowMode;
@@ -90,10 +108,23 @@ namespace Barotrauma
        }
 #endif

+        public bool AutoUpdateWorkshopItems;
+
        public WindowMode WindowMode
        {
            get { return windowMode; }
-            set { windowMode = value; }
+            set
+            {
+#if (OSX)
+                // Fullscreen doesn't work on macOS, so just force any usage of it to borderless windowed.
+                if (value == WindowMode.Fullscreen)
+                {
+                    windowMode = WindowMode.BorderlessWindowed;
+                    return;
+                }
+#endif
+                windowMode = value;
+            }
        }

        public List<string> JobPreferences
@@ -102,7 +133,7 @@ namespace Barotrauma
            set { jobPreferences = value; }
        }

-        public int CharacterHeadIndex { get; set; }
+        public int CharacterHeadIndex { get; set; } = 1;
        public int CharacterHairIndex { get; set; }
        public int CharacterBeardIndex { get; set; }
        public int CharacterMoustacheIndex { get; set; }
@@ -133,13 +164,13 @@ namespace Barotrauma
                {
                    //applyButton.Selected = unsavedSettings;
                    applyButton.Enabled = unsavedSettings;
-                    applyButton.Text = unsavedSettings ? "Apply*" : "Apply";
+                    applyButton.Text = TextManager.Get(unsavedSettings ? "ApplySettingsButtonUnsavedChanges" : "ApplySettingsButton");
                }
 #endif
            }
        }

-        private float soundVolume, musicVolume;
+        private float soundVolume = 0.5f, musicVolume = 0.3f, voiceChatVolume = 0.5f;

        public float SoundVolume
        {
@@ -170,6 +201,18 @@ namespace Barotrauma
            }
        }

+        public float VoiceChatVolume
+        {
+            get { return voiceChatVolume; }
+            set
+            {
+                voiceChatVolume = MathHelper.Clamp(value, 0.0f, 1.0f);
+#if CLIENT
+                GameMain.SoundManager?.SetCategoryGainMultiplier("voip", voiceChatVolume);
+#endif
+            }
+        }
+
        public string Language
        {
            get { return TextManager.Language; }
@@ -178,6 +221,8 @@ namespace Barotrauma

        public HashSet<ContentPackage> SelectedContentPackages { get; set; }

+        private HashSet<string> selectedContentPackagePaths = new HashSet<string>();
+
        public string   MasterServerUrl { get; set; }
        public bool     AutoCheckUpdates { get; set; }
        public bool     WasGameUpdated { get; set; }
@@ -221,24 +266,34 @@ namespace Barotrauma
            set
            {
                sendUserStatistics = value;
-                GameMain.Config.Save();
+                GameMain.Config.SaveNewPlayerConfig();
            }
        }
        public static bool ShowUserStatisticsPrompt { get; set; }

-        public GameSettings(string filePath)
+        public GameSettings()
        {
            SelectedContentPackages = new HashSet<ContentPackage>();
-
            ContentPackage.LoadAll(ContentPackage.Folder);
            CompletedTutorialNames = new List<string>();
-            Load(filePath);
+
+            LoadDefaultConfig();
+
+            if (WasGameUpdated)
+            {
+                UpdaterUtil.CleanOldFiles();
+                WasGameUpdated = false;
+                SaveNewDefaultConfig();
+            }
+
+            LoadPlayerConfig();
        }

-        public void Load(string filePath)
+        #region Load DefaultConfig
+        public void LoadDefaultConfig()
        {
-            XDocument doc = XMLExtensions.TryLoadXml(filePath);
-            
+            XDocument doc = XMLExtensions.TryLoadXml(savePath);
+
            Language = doc.Root.GetAttributeString("language", "English");

            MasterServerUrl = doc.Root.GetAttributeString("masterserverurl", "");
@@ -248,14 +303,11 @@ namespace Barotrauma

            VerboseLogging = doc.Root.GetAttributeBool("verboselogging", false);
            SaveDebugConsoleLogs = doc.Root.GetAttributeBool("savedebugconsolelogs", false);
-            if (doc.Root.Attribute("senduserstatistics") == null)
-            {
-                ShowUserStatisticsPrompt = true;
-            }
-            else
-            {
-                sendUserStatistics = doc.Root.GetAttributeBool("senduserstatistics", true);
-            }
+
+#if DEBUG
+            UseSteam = doc.Root.GetAttributeBool("usesteam", true);
+#endif
+            QuickStartSubmarineName = doc.Root.GetAttributeString("quickstartsub", "");

 #if DEBUG
            UseSteam = doc.Root.GetAttributeBool("usesteam", true);
@@ -280,8 +332,8 @@ namespace Barotrauma
            }

            XElement graphicsMode = doc.Root.Element("graphicsmode");
-            GraphicsWidth   = graphicsMode.GetAttributeInt("width", 0);
-            GraphicsHeight  = graphicsMode.GetAttributeInt("height", 0);
+            GraphicsWidth   = 0;
+            GraphicsHeight  = 0;
            VSyncEnabled    = graphicsMode.GetAttributeBool("vsync", true);

            XElement graphicsSettings = doc.Root.Element("graphicssettings");
@@ -305,21 +357,24 @@ namespace Barotrauma
            }
 #endif

-            //FullScreenEnabled = ToolBox.GetAttributeBool(graphicsMode, "fullscreen", true);
-
            var windowModeStr = graphicsMode.GetAttributeString("displaymode", "Fullscreen");
-            if (!Enum.TryParse<WindowMode>(windowModeStr, out windowMode))
+            if (!Enum.TryParse(windowModeStr, out WindowMode wm))
            {
-                windowMode = WindowMode.Fullscreen;
+                wm = WindowMode.Fullscreen;
            }
-
-            SoundVolume = doc.Root.GetAttributeFloat("soundvolume", 1.0f);
-            MusicVolume = doc.Root.GetAttributeFloat("musicvolume", 0.3f);
-
+            WindowMode = wm;
+            
            useSteamMatchmaking = doc.Root.GetAttributeBool("usesteammatchmaking", true);
            requireSteamAuthentication = doc.Root.GetAttributeBool("requiresteamauthentication", true);
+            AutoUpdateWorkshopItems = doc.Root.GetAttributeBool("autoupdateworkshopitems", true);

+#if DEBUG
+            EnableSplashScreen = false;
+#else
            EnableSplashScreen = doc.Root.GetAttributeBool("enablesplashscreen", true);
+#endif
+
+            AimAssistAmount = doc.Root.GetAttributeFloat("aimassistamount", 0.5f);

            AimAssistAmount = doc.Root.GetAttributeFloat("aimassistamount", 0.5f);
            
@@ -330,8 +385,9 @@ namespace Barotrauma
            keyMapping[(int)InputType.Right] = new KeyOrMouse(Keys.D);
            keyMapping[(int)InputType.Run] = new KeyOrMouse(Keys.LeftShift);

-            keyMapping[(int)InputType.Chat] = new KeyOrMouse(Keys.Tab);
-            keyMapping[(int)InputType.RadioChat] = new KeyOrMouse(Keys.OemPipe);
+            keyMapping[(int)InputType.InfoTab] = new KeyOrMouse(Keys.Tab);
+            keyMapping[(int)InputType.Chat] = new KeyOrMouse(Keys.T);
+            keyMapping[(int)InputType.RadioChat] = new KeyOrMouse(Keys.Y);
            keyMapping[(int)InputType.CrewOrders] = new KeyOrMouse(Keys.C);

            keyMapping[(int)InputType.Select] = new KeyOrMouse(Keys.E);
@@ -339,6 +395,8 @@ namespace Barotrauma
            keyMapping[(int)InputType.SelectNextCharacter] = new KeyOrMouse(Keys.Tab);
            keyMapping[(int)InputType.SelectPreviousCharacter] = new KeyOrMouse(Keys.Q);

+            keyMapping[(int)InputType.Voice] = new KeyOrMouse(Keys.V);
+
            keyMapping[(int)InputType.Use] = new KeyOrMouse(0);
            keyMapping[(int)InputType.Aim] = new KeyOrMouse(1);

@@ -376,9 +434,11 @@ namespace Barotrauma
                        break;
                    case "player":
                        defaultPlayerName = subElement.GetAttributeString("name", "");
-                        CharacterHeadIndex = subElement.GetAttributeInt("headindex", Rand.Int(10));
-                        CharacterGender = subElement.GetAttributeString("gender", Rand.Range(0.0f, 1.0f) < 0.5f ? "male" : "female")
-                            .ToLowerInvariant() == "male" ? Gender.Male : Gender.Female;
+                        CharacterHeadIndex = subElement.GetAttributeInt("headindex", CharacterHeadIndex);
+                        if (Enum.TryParse(subElement.GetAttributeString("gender", "none"), true, out Gender g))
+                        {
+                            CharacterGender = g;
+                        }
                        if (Enum.TryParse(subElement.GetAttributeString("race", "white"), true, out Race r))
                        {
                            CharacterRace = r;
@@ -392,12 +452,6 @@ namespace Barotrauma
                        CharacterMoustacheIndex = subElement.GetAttributeInt("moustacheindex", -1);
                        CharacterFaceAttachmentIndex = subElement.GetAttributeInt("faceattachmentindex", -1);
                        break;
-                    case "tutorials":
-                        foreach (XElement tutorialElement in subElement.Elements())
-                        {
-                            CompletedTutorialNames.Add(tutorialElement.GetAttributeString("name", ""));
-                        }
-                        break;
                }
            }

@@ -409,9 +463,7 @@ namespace Barotrauma
                    keyMapping[(int)inputType] = new KeyOrMouse(Keys.D1);
                }
            }
-            
-            UnsavedSettings = false;
-            
+
            List<string> missingPackagePaths = new List<string>();
            List<ContentPackage> incompatiblePackages = new List<ContentPackage>();
            foreach (XElement subElement in doc.Root.Elements())
@@ -439,6 +491,34 @@ namespace Barotrauma
            
            TextManager.LoadTextPacks(SelectedContentPackages);

+            //display error messages after all content packages have been loaded
+            //to make sure the package that contains text files has been loaded before we attempt to use TextManager
+            foreach (string missingPackagePath in missingPackagePaths)
+            {
+                DebugConsole.ThrowError(TextManager.Get("ContentPackageNotFound").Replace("[packagepath]", missingPackagePath));
+            }
+            foreach (ContentPackage incompatiblePackage in incompatiblePackages)
+            {
+                DebugConsole.ThrowError(TextManager.Get(incompatiblePackage.GameVersion <= new Version(0, 0, 0, 0) ? "IncompatibleContentPackageUnknownVersion" : "IncompatibleContentPackage")
+                                .Replace("[packagename]", incompatiblePackage.Name)
+                                .Replace("[packageversion]", incompatiblePackage.GameVersion.ToString())
+                                .Replace("[gameversion]", GameMain.Version.ToString()));
+            }
+            foreach (ContentPackage contentPackage in SelectedContentPackages)
+            {
+                foreach (ContentFile file in contentPackage.Files)
+                {
+                    if (!System.IO.File.Exists(file.Path))
+                    {
+                        DebugConsole.ThrowError("Error in content package \"" + contentPackage.Name + "\" - file \"" + file.Path + "\" not found.");
+                        continue;
+                    }
+                    ToolBox.IsProperFilenameCase(file.Path);
+                }
+            }
+
+            TextManager.LoadTextPacks(SelectedContentPackages);
+
            //display error messages after all content packages have been loaded
            //to make sure the package that contains text files has been loaded before we attempt to use TextManager
            foreach (string missingPackagePath in missingPackagePaths)
@@ -474,19 +554,382 @@ namespace Barotrauma
            }

            //save to get rid of the invalid selected packages in the config file
-            if (missingPackagePaths.Count > 0 || incompatiblePackages.Count > 0) { Save(); }
+            if (missingPackagePaths.Count > 0 || incompatiblePackages.Count > 0) { SaveNewPlayerConfig(); }
        }
+        #endregion

-        public KeyOrMouse KeyBind(InputType inputType)
+        #region Save DefaultConfig
+        private void SaveNewDefaultConfig()
        {
-            return keyMapping[(int)inputType];
+            XDocument doc = new XDocument();
+
+            if (doc.Root == null)
+            {
+                doc.Add(new XElement("config"));
+            }
+
+            doc.Root.Add(
+                new XAttribute("language", TextManager.Language),
+                new XAttribute("masterserverurl", MasterServerUrl),
+                new XAttribute("autocheckupdates", AutoCheckUpdates),
+                new XAttribute("musicvolume", musicVolume),
+                new XAttribute("soundvolume", soundVolume),
+                new XAttribute("voicechatvolume", voiceChatVolume),
+                new XAttribute("verboselogging", VerboseLogging),
+                new XAttribute("savedebugconsolelogs", SaveDebugConsoleLogs),
+                new XAttribute("enablesplashscreen", EnableSplashScreen),
+                new XAttribute("usesteammatchmaking", useSteamMatchmaking),
+                new XAttribute("quickstartsub", QuickStartSubmarineName),
+                new XAttribute("requiresteamauthentication", requireSteamAuthentication),
+                new XAttribute("aimassistamount", aimAssistAmount));
+
+            if (!ShowUserStatisticsPrompt)
+            {
+                doc.Root.Add(new XAttribute("senduserstatistics", sendUserStatistics));
+            }
+
+            if (WasGameUpdated)
+            {
+                doc.Root.Add(new XAttribute("wasgameupdated", true));
+            }
+            
+            XElement gMode = doc.Root.Element("graphicsmode");
+            if (gMode == null)
+            {
+                gMode = new XElement("graphicsmode");
+                doc.Root.Add(gMode);
+            }
+            if (GraphicsWidth == 0 || GraphicsHeight == 0)
+            {
+                gMode.ReplaceAttributes(new XAttribute("displaymode", windowMode));
+            }
+            else
+            {
+                gMode.ReplaceAttributes(
+                    new XAttribute("width", GraphicsWidth),
+                    new XAttribute("height", GraphicsHeight),
+                    new XAttribute("vsync", VSyncEnabled),
+                    new XAttribute("displaymode", windowMode));
+            }
+
+            XElement gSettings = doc.Root.Element("graphicssettings");
+            if (gSettings == null)
+            {
+                gSettings = new XElement("graphicssettings");
+                doc.Root.Add(gSettings);
+            }
+
+            gSettings.ReplaceAttributes(
+                new XAttribute("particlelimit", ParticleLimit),
+                new XAttribute("lightmapscale", LightMapScale),
+                new XAttribute("specularity", SpecularityEnabled),
+                new XAttribute("chromaticaberration", ChromaticAberrationEnabled),
+                new XAttribute("losmode", LosMode),
+                new XAttribute("hudscale", HUDScale),
+                new XAttribute("inventoryscale", InventoryScale));
+
+            foreach (ContentPackage contentPackage in SelectedContentPackages)
+            {
+                if (contentPackage.Path.Contains(vanillaContentPackagePath))
+                {
+                    doc.Root.Add(new XElement("contentpackage", new XAttribute("path", contentPackage.Path)));
+                    break;
+                }
+            }
+
+            var keyMappingElement = new XElement("keymapping");
+            doc.Root.Add(keyMappingElement);
+            for (int i = 0; i < keyMapping.Length; i++)
+            {
+                if (keyMapping[i].MouseButton == null)
+                {
+                    keyMappingElement.Add(new XAttribute(((InputType)i).ToString(), keyMapping[i].Key));
+                }
+                else
+                {
+                    keyMappingElement.Add(new XAttribute(((InputType)i).ToString(), keyMapping[i].MouseButton));
+                }
+            }
+
+            var gameplay = new XElement("gameplay");
+            var jobPreferences = new XElement("jobpreferences");
+            foreach (string jobName in JobPreferences)
+            {
+                jobPreferences.Add(new XElement("job", new XAttribute("identifier", jobName)));
+            }
+            gameplay.Add(jobPreferences);
+            doc.Root.Add(gameplay);
+
+            var playerElement = new XElement("player",
+                new XAttribute("name", defaultPlayerName ?? ""),
+                new XAttribute("headindex", CharacterHeadIndex),
+                new XAttribute("gender", CharacterGender),
+                new XAttribute("race", CharacterRace),
+                new XAttribute("hairindex", CharacterHairIndex),
+                new XAttribute("beardindex", CharacterBeardIndex),
+                new XAttribute("moustacheindex", CharacterMoustacheIndex),
+                new XAttribute("faceattachmentindex", CharacterFaceAttachmentIndex));
+            doc.Root.Add(playerElement);
+
+            XmlWriterSettings settings = new XmlWriterSettings
+            {
+                Indent = true,
+                OmitXmlDeclaration = true,
+                NewLineOnAttributes = true
+            };
+
+            try
+            {
+                using (var writer = XmlWriter.Create(savePath, settings))
+                {
+                    doc.WriteTo(writer);
+                    writer.Flush();
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Saving game settings failed.", e);
+                GameAnalyticsManager.AddErrorEventOnce("GameSettings.Save:SaveFailed", GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
+                    "Saving game settings failed.\n" + e.Message + "\n" + e.StackTrace);
+            }
        }
+        #endregion

-        public void Save()
+        #region Load PlayerConfig
+        // TODO: DRY
+        public void LoadPlayerConfig()
        {
+            XDocument doc = XMLExtensions.LoadXml(playerSavePath);
+
+            if (doc == null || doc.Root == null)
+            {
+                ShowUserStatisticsPrompt = true;
+                SaveNewPlayerConfig();
+                return;
+            }
+
+            Language = doc.Root.GetAttributeString("language", Language);
+            AutoCheckUpdates = doc.Root.GetAttributeBool("autocheckupdates", AutoCheckUpdates);
+            sendUserStatistics = doc.Root.GetAttributeBool("senduserstatistics", true);
+
+            XElement graphicsMode = doc.Root.Element("graphicsmode");
+            GraphicsWidth = graphicsMode.GetAttributeInt("width", GraphicsWidth);
+            GraphicsHeight = graphicsMode.GetAttributeInt("height", GraphicsHeight);
+            VSyncEnabled = graphicsMode.GetAttributeBool("vsync", VSyncEnabled);
+
+            XElement graphicsSettings = doc.Root.Element("graphicssettings");
+            ParticleLimit = graphicsSettings.GetAttributeInt("particlelimit", ParticleLimit);
+            LightMapScale = MathHelper.Clamp(graphicsSettings.GetAttributeFloat("lightmapscale", LightMapScale), 0.1f, 1.0f);
+            SpecularityEnabled = graphicsSettings.GetAttributeBool("specularity", SpecularityEnabled);
+            ChromaticAberrationEnabled = graphicsSettings.GetAttributeBool("chromaticaberration", ChromaticAberrationEnabled);
+            HUDScale = graphicsSettings.GetAttributeFloat("hudscale", HUDScale);
+            InventoryScale = graphicsSettings.GetAttributeFloat("inventoryscale", InventoryScale);
+            var losModeStr = graphicsSettings.GetAttributeString("losmode", "Transparent");
+            if (!Enum.TryParse(losModeStr, out losMode))
+            {
+                losMode = LosMode.Transparent;
+            }
+
+#if CLIENT
+            if (GraphicsWidth == 0 || GraphicsHeight == 0)
+            {
+                GraphicsWidth = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
+                GraphicsHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
+            }
+#endif
+
+            var windowModeStr = graphicsMode.GetAttributeString("displaymode", "Fullscreen");
+            if (!Enum.TryParse(windowModeStr, out windowMode))
+            {
+                windowMode = WindowMode.Fullscreen;
+            }
+
+            XElement audioSettings = doc.Root.Element("audio");
+            if (audioSettings != null)
+            {
+                SoundVolume = audioSettings.GetAttributeFloat("soundvolume", SoundVolume);
+                MusicVolume = audioSettings.GetAttributeFloat("musicvolume", MusicVolume);
+                VoiceChatVolume = audioSettings.GetAttributeFloat("voicechatvolume", VoiceChatVolume);
+                string voiceSettingStr = audioSettings.GetAttributeString("voicesetting", "Disabled");
+                VoiceCaptureDevice = audioSettings.GetAttributeString("voicecapturedevice", "");
+                NoiseGateThreshold = audioSettings.GetAttributeFloat("noisegatethreshold", -45);
+                var voiceSetting = VoiceMode.Disabled;
+                if (Enum.TryParse(voiceSettingStr, out voiceSetting))
+                {
+                    VoiceSetting = voiceSetting;
+                }
+            }
+            
+            useSteamMatchmaking = doc.Root.GetAttributeBool("usesteammatchmaking", useSteamMatchmaking);
+            requireSteamAuthentication = doc.Root.GetAttributeBool("requiresteamauthentication", requireSteamAuthentication);
+
+            EnableSplashScreen = doc.Root.GetAttributeBool("enablesplashscreen", EnableSplashScreen);
+
+            AimAssistAmount = doc.Root.GetAttributeFloat("aimassistamount", AimAssistAmount);
+
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "keymapping":
+                        foreach (XAttribute attribute in subElement.Attributes())
+                        {
+                            if (Enum.TryParse(attribute.Name.ToString(), true, out InputType inputType))
+                            {
+                                if (int.TryParse(attribute.Value.ToString(), out int mouseButton))
+                                {
+                                    keyMapping[(int)inputType] = new KeyOrMouse(mouseButton);
+                                }
+                                else
+                                {
+                                    if (Enum.TryParse(attribute.Value.ToString(), true, out Keys key))
+                                    {
+                                        keyMapping[(int)inputType] = new KeyOrMouse(key);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case "gameplay":
+                        jobPreferences = new List<string>();
+                        foreach (XElement ele in subElement.Element("jobpreferences").Elements("job"))
+                        {
+                            string jobIdentifier = ele.GetAttributeString("identifier", "");
+                            if (string.IsNullOrEmpty(jobIdentifier)) continue;
+                            jobPreferences.Add(jobIdentifier);
+                        }
+                        break;
+                    case "player":
+                        defaultPlayerName = subElement.GetAttributeString("name", defaultPlayerName);
+                        CharacterHeadIndex = subElement.GetAttributeInt("headindex", CharacterHeadIndex);
+                        if (Enum.TryParse(subElement.GetAttributeString("gender", "none"), true, out Gender g))
+                        {
+                            CharacterGender = g;
+                        }
+                        if (Enum.TryParse(subElement.GetAttributeString("race", "white"), true, out Race r))
+                        {
+                            CharacterRace = r;
+                        }
+                        else
+                        {
+                            CharacterRace = Race.White;
+                        }
+                        CharacterHairIndex = subElement.GetAttributeInt("hairindex", CharacterHairIndex);
+                        CharacterBeardIndex = subElement.GetAttributeInt("beardindex", CharacterBeardIndex);
+                        CharacterMoustacheIndex = subElement.GetAttributeInt("moustacheindex", CharacterMoustacheIndex);
+                        CharacterFaceAttachmentIndex = subElement.GetAttributeInt("faceattachmentindex", CharacterFaceAttachmentIndex);
+                        break;
+                    case "tutorials":
+                        foreach (XElement tutorialElement in subElement.Elements())
+                        {
+                            CompletedTutorialNames.Add(tutorialElement.GetAttributeString("name", ""));
+                        }
+                        break;
+                }
+            }
+
+            foreach (InputType inputType in Enum.GetValues(typeof(InputType)))
+            {
+                if (keyMapping[(int)inputType] == null)
+                {
+                    DebugConsole.ThrowError("Key binding for the input type \"" + inputType + " not set!");
+                    keyMapping[(int)inputType] = new KeyOrMouse(Keys.D1);
+                }
+            }
+
            UnsavedSettings = false;

+            selectedContentPackagePaths = new HashSet<string>();
+
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "contentpackage":
+                        string path = System.IO.Path.GetFullPath(subElement.GetAttributeString("path", ""));
+                        selectedContentPackagePaths.Add(path);
+                        break;
+                }
+            }
+
+            LoadContentPackages(selectedContentPackagePaths);
+        }
+
+        public void ReloadContentPackages()
+        {
+            LoadContentPackages(selectedContentPackagePaths);
+        }
+
+        private void LoadContentPackages(IEnumerable<string> contentPackagePaths)
+        {
+            var missingPackagePaths = new List<string>();
+            var incompatiblePackages = new List<ContentPackage>();
+            SelectedContentPackages.Clear();
+            foreach (string path in contentPackagePaths)
+            {
+                var matchingContentPackage = ContentPackage.List.Find(cp => System.IO.Path.GetFullPath(cp.Path) == path);
+
+                if (matchingContentPackage == null)
+                {
+                    missingPackagePaths.Add(path);
+                }
+                else if (!matchingContentPackage.IsCompatible())
+                {
+                    incompatiblePackages.Add(matchingContentPackage);
+                }
+                else
+                {
+                    SelectedContentPackages.Add(matchingContentPackage);
+                }
+            }
+
+            TextManager.LoadTextPacks(SelectedContentPackages);
+
+            foreach (ContentPackage contentPackage in SelectedContentPackages)
+            {
+                foreach (ContentFile file in contentPackage.Files)
+                {
+                    if (!System.IO.File.Exists(file.Path))
+                    {
+                        DebugConsole.ThrowError("Error in content package \"" + contentPackage.Name + "\" - file \"" + file.Path + "\" not found.");
+                        continue;
+                    }
+                    ToolBox.IsProperFilenameCase(file.Path);
+                }
+            }
+            if (!SelectedContentPackages.Any())
+            {
+                var availablePackage = ContentPackage.List.FirstOrDefault(cp => cp.IsCompatible() && cp.CorePackage);
+                if (availablePackage != null)
+                {
+                    SelectedContentPackages.Add(availablePackage);
+                }
+            }
+
+            //save to get rid of the invalid selected packages in the config file
+            if (missingPackagePaths.Count > 0 || incompatiblePackages.Count > 0) { SaveNewPlayerConfig(); }
+
+            //display error messages after all content packages have been loaded
+            //to make sure the package that contains text files has been loaded before we attempt to use TextManager
+            foreach (string missingPackagePath in missingPackagePaths)
+            {
+                DebugConsole.ThrowError(TextManager.Get("ContentPackageNotFound").Replace("[packagepath]", missingPackagePath));
+            }
+            foreach (ContentPackage incompatiblePackage in incompatiblePackages)
+            {
+                DebugConsole.ThrowError(TextManager.Get(incompatiblePackage.GameVersion <= new Version(0, 0, 0, 0) ? "IncompatibleContentPackageUnknownVersion" : "IncompatibleContentPackage")
+                                .Replace("[packagename]", incompatiblePackage.Name)
+                                .Replace("[packageversion]", incompatiblePackage.GameVersion.ToString())
+                                .Replace("[gameversion]", GameMain.Version.ToString()));
+            }
+        }
+        #endregion
+
+        #region Save PlayerConfig
+        public void SaveNewPlayerConfig()
+        {
            XDocument doc = new XDocument();
+            UnsavedSettings = false;

            if (doc.Root == null)
            {
@@ -505,6 +948,7 @@ namespace Barotrauma
                new XAttribute("usesteammatchmaking", useSteamMatchmaking),
                new XAttribute("quickstartsub", QuickStartSubmarineName),
                new XAttribute("requiresteamauthentication", requireSteamAuthentication),
+                new XAttribute("autoupdateworkshopitems", AutoUpdateWorkshopItems),
                new XAttribute("aimassistamount", aimAssistAmount));

            if (!ShowUserStatisticsPrompt)
@@ -512,11 +956,6 @@ namespace Barotrauma
                doc.Root.Add(new XAttribute("senduserstatistics", sendUserStatistics));
            }

-            if (WasGameUpdated)
-            {
-                doc.Root.Add(new XAttribute("wasgameupdated", true));
-            }
-
            XElement gMode = doc.Root.Element("graphicsmode");
            if (gMode == null)
            {
@@ -536,6 +975,19 @@ namespace Barotrauma
                    new XAttribute("vsync", VSyncEnabled),
                    new XAttribute("displaymode", windowMode));
            }
+            
+            XElement audio = doc.Root.Element("audio");
+            if (audio == null)
+            {
+                audio = new XElement("audio");
+                doc.Root.Add(audio);
+            }
+            audio.ReplaceAttributes(
+                new XAttribute("musicvolume", musicVolume),
+                new XAttribute("soundvolume", soundVolume),
+                new XAttribute("voicesetting", VoiceSetting),
+                new XAttribute("voicecapturedevice", VoiceCaptureDevice ?? ""),
+                new XAttribute("noisegatethreshold", NoiseGateThreshold));

            XElement gSettings = doc.Root.Element("graphicssettings");
            if (gSettings == null)
@@ -619,9 +1071,35 @@ namespace Barotrauma
                NewLineOnAttributes = true
            };

+#if CLIENT
+            if (Tutorial.Tutorials != null)
+            {
+                foreach (Tutorial tutorial in Tutorial.Tutorials)
+                {
+                    if (tutorial.Completed && !CompletedTutorialNames.Contains(tutorial.Name))
+                    {
+                        CompletedTutorialNames.Add(tutorial.Name);
+                    }
+                }
+            }
+#endif
+            var tutorialElement = new XElement("tutorials");
+            foreach (string tutorialName in CompletedTutorialNames)
+            {
+                tutorialElement.Add(new XElement("Tutorial", new XAttribute("name", tutorialName)));
+            }
+            doc.Root.Add(tutorialElement);
+
+            XmlWriterSettings settings = new XmlWriterSettings
+            {
+                Indent = true,
+                OmitXmlDeclaration = true,
+                NewLineOnAttributes = true
+            };
+
            try
            {
-                using (var writer = XmlWriter.Create(FilePath, settings))
+                using (var writer = XmlWriter.Create(playerSavePath, settings))
                {
                    doc.WriteTo(writer);
                    writer.Flush();
@@ -634,5 +1112,17 @@ namespace Barotrauma
                    "Saving game settings failed.\n" + e.Message + "\n" + e.StackTrace);
            }
        }
+        #endregion
+
+        public void ResetToDefault()
+        {
+            LoadDefaultConfig();
+            SaveNewPlayerConfig();
+        }
+
+        public KeyOrMouse KeyBind(InputType inputType)
+        {
+            return keyMapping[(int)inputType];
+        }
    }
 }