(875de4a5a) Merge branch 'dev' of https://github.com/Regalis11/Barotrauma-development into dev

Barotrauma/BarotraumaClient/ClientCode.projitems

@@ -79,8 +79,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\ParamsEditor.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\RectTransform.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\ShapeExtensions.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\SpriteSheetPlayer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\UISprite.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\VideoPlayer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Source\GUI\Widget.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Source\Items\CharacterInventory.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Source\Items\Components\Door.cs" />

Barotrauma/BarotraumaClient/Source/Characters/Health/CharacterHealth.cs

@@ -68,6 +68,14 @@ namespace Barotrauma
 
         private float dropItemAnimDuration = 0.5f;
         private float dropItemAnimTimer;
+
+        public Item DroppedItem
+        {
+            get
+            {
+                return droppedItem;
+            }
+        }
         private Item droppedItem;
 
         private GUIComponent draggingMed;

Barotrauma/BarotraumaClient/Source/DebugConsole.cs

@@ -3828,6 +3828,189 @@ namespace Barotrauma
                 NPCConversation.WriteToCSV();
             }));
 
+            commands.Add(new Command("csvtoxml", "csvtoxml [language] -> Converts .csv localization files in Content/NPCConversations & Content/Texts to .xml for use in-game.", (string[] args) =>
+            {
+                if (args.Length == 0) return;
+                LocalizationCSVtoXML.Convert(args[0]);
+            }));
+#endif
+
+            commands.Add(new Command("cleanbuild", "", (string[] args) =>
+            {
+                float defaultZoom = Screen.Selected.Cam.DefaultZoom;
+                if (args.Length > 0) float.TryParse(args[0], NumberStyles.Number, CultureInfo.InvariantCulture, out defaultZoom);
+
+                float zoomSmoothness = Screen.Selected.Cam.ZoomSmoothness;
+                if (args.Length > 1) float.TryParse(args[1], NumberStyles.Number, CultureInfo.InvariantCulture, out zoomSmoothness);
+                float moveSmoothness = Screen.Selected.Cam.MoveSmoothness;
+                if (args.Length > 2) float.TryParse(args[2], NumberStyles.Number, CultureInfo.InvariantCulture, out moveSmoothness);
+
+                float minZoom = Screen.Selected.Cam.MinZoom;
+                if (args.Length > 3) float.TryParse(args[3], NumberStyles.Number, CultureInfo.InvariantCulture, out minZoom);
+                float maxZoom = Screen.Selected.Cam.MaxZoom;
+                if (args.Length > 4) float.TryParse(args[4], NumberStyles.Number, CultureInfo.InvariantCulture, out maxZoom);
+
+                Screen.Selected.Cam.DefaultZoom = defaultZoom;
+                Screen.Selected.Cam.ZoomSmoothness = zoomSmoothness;
+                Screen.Selected.Cam.MoveSmoothness = moveSmoothness;
+                Screen.Selected.Cam.MinZoom = minZoom;
+                Screen.Selected.Cam.MaxZoom = maxZoom;
+            }));
+
+            commands.Add(new Command("waterparams", "waterparams [distortionscalex] [distortionscaley] [distortionstrengthx] [distortionstrengthy] [bluramount]: default 0.5 0.5 0.5 0.5 1", (string[] args) =>
+            {
+                float distortScaleX = 0.5f, distortScaleY = 0.5f;
+                float distortStrengthX = 0.5f, distortStrengthY = 0.5f;
+                float blurAmount = 0.0f;
+                if (args.Length > 0) float.TryParse(args[0], NumberStyles.Number, CultureInfo.InvariantCulture, out distortScaleX);
+                if (args.Length > 1) float.TryParse(args[1], NumberStyles.Number, CultureInfo.InvariantCulture, out distortScaleY);
+                if (args.Length > 2) float.TryParse(args[2], NumberStyles.Number, CultureInfo.InvariantCulture, out distortStrengthX);
+                if (args.Length > 3) float.TryParse(args[3], NumberStyles.Number, CultureInfo.InvariantCulture, out distortStrengthY);
+                if (args.Length > 4) float.TryParse(args[4], NumberStyles.Number, CultureInfo.InvariantCulture, out blurAmount);
+                WaterRenderer.DistortionScale = new Vector2(distortScaleX, distortScaleY);
+                WaterRenderer.DistortionStrength = new Vector2(distortStrengthX, distortStrengthY);
+                WaterRenderer.BlurAmount = blurAmount;
+            }));
+
+
+            commands.Add(new Command("refreshrect", "Updates the dimensions of the selected items to match the ones defined in the prefab. Applied only in the subeditor.", (string[] args) =>
+            {
+                //TODO: maybe do this automatically during loading when possible?
+                if (Screen.Selected == GameMain.SubEditorScreen)
+                {
+                    if (!MapEntity.SelectedAny)
+                    {
+                        ThrowError("You have to select item(s) first!");
+                    }
+                    else
+                    {
+                        foreach (var mapEntity in MapEntity.SelectedList)
+                        {
+                            if (mapEntity is Item item)
+                            {
+                                item.Rect = new Rectangle(item.Rect.X, item.Rect.Y,
+                                    (int)(item.Prefab.sprite.size.X * item.Prefab.Scale),
+                                    (int)(item.Prefab.sprite.size.Y * item.Prefab.Scale));
+                            }
+                            else if (mapEntity is Structure structure)
+                            {
+                                if (!structure.ResizeHorizontal)
+                                {
+                                    structure.Rect = new Rectangle(structure.Rect.X, structure.Rect.Y,
+                                        (int)structure.Prefab.ScaledSize.X,
+                                        structure.Rect.Height);
+                                }
+                                if (!structure.ResizeVertical)
+                                {
+                                    structure.Rect = new Rectangle(structure.Rect.X, structure.Rect.Y,
+                                        structure.Rect.Width,
+                                        (int)structure.Prefab.ScaledSize.Y);
+                                }
+                            }
+                        }
+                    }
+                }
+            }, isCheat: false));
+#endif
+
+                GameMain.Config.SaveNewPlayerConfig();
+
+            commands.Add(new Command("loadtexts", "loadtexts [sourcefile] [destinationfile]: Loads all lines of text from a given .txt file and inserts them sequientially into the elements of an xml file. If the file paths are omitted, EnglishVanilla.txt and EnglishVanilla.xml are used.", (string[] args) =>
+            {
+                string sourcePath = args.Length > 0 ? args[0] : "Content/Texts/EnglishVanilla.txt";
+                string destinationPath = args.Length > 1 ? args[1] : "Content/Texts/EnglishVanilla.xml";
+
+                string[] lines;
+                try
+                {
+                    lines = File.ReadAllLines(sourcePath);
+                }
+                catch (Exception e)
+                {
+                    ThrowError("Reading the file \"" + sourcePath + "\" failed.", e);
+                    return;
+                }
+                var doc = XMLExtensions.TryLoadXml(destinationPath);
+                int i = 0;
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    if (i >= lines.Length)
+                    {
+                        ThrowError("Error while loading texts to the xml file. The xml has more elements than the number of lines in the text file.");
+                        return;
+                    }
+                    element.Value = lines[i];
+                    i++;
+                }
+                doc.Save(destinationPath);
+            },
+            () =>
+            {
+                var files = TextManager.GetTextFiles().Select(f => f.Replace("\\", "/"));
+                return new string[][]
+                {
+                    files.Where(f => Path.GetExtension(f)==".txt").ToArray(),
+                    files.Where(f => Path.GetExtension(f)==".xml").ToArray()
+                };
+            }));
+
+            commands.Add(new Command("updatetextfile", "updatetextfile [sourcefile] [destinationfile]: Inserts all the xml elements that are only present in the source file into the destination file. Can be used to update outdated translation files more easily.", (string[] args) =>
+            {
+                if (args.Length < 2) return;
+                string sourcePath = args[0];
+                string destinationPath = args[1];
+
+                var sourceDoc = XMLExtensions.TryLoadXml(sourcePath);
+                var destinationDoc = XMLExtensions.TryLoadXml(destinationPath);
+
+                XElement destinationElement = destinationDoc.Root.Elements().First();
+                foreach (XElement element in sourceDoc.Root.Elements())
+                {
+                    if (destinationDoc.Root.Element(element.Name) == null)
+                    {
+                        element.Value = "!!!!!!!!!!!!!" + element.Value;
+                        destinationElement.AddAfterSelf(element);
+                    }
+                    XNode nextNode = destinationElement.NextNode;
+                    while ((!(nextNode is XElement) || nextNode == element) && nextNode != null) nextNode = nextNode.NextNode;
+                    destinationElement = nextNode as XElement;
+                }
+                destinationDoc.Save(destinationPath);
+            },
+            () =>
+            {
+                var files = TextManager.GetTextFiles().Where(f => Path.GetExtension(f) == ".xml").Select(f => f.Replace("\\", "/")).ToArray();
+                return new string[][]
+                {
+                    files,
+                    files
+                };
+            }));
+
+            commands.Add(new Command("dumpentitytexts", "dumpentitytexts [filepath]: gets the names and descriptions of all entity prefabs and writes them into a file along with xml tags that can be used in translation files. If the filepath is omitted, the file is written to Content/Texts/EntityTexts.txt", (string[] args) =>
+            {
+                string filePath = args.Length > 0 ? args[0] : "Content/Texts/EntityTexts.txt";
+                List<string> lines = new List<string>();
+                foreach (MapEntityPrefab me in MapEntityPrefab.List)
+                {
+                    lines.Add("<EntityName." + me.Identifier + ">" + me.Name + "</" + me.Identifier + ".Name>");
+                    lines.Add("<EntityDescription." + me.Identifier + ">" + me.Description + "</" + me.Identifier + ".Description>");
+                }
+                File.WriteAllLines(filePath, lines);
+            }));
+#if DEBUG
+            commands.Add(new Command("checkduplicates", "Checks the given language for duplicate translation keys and writes to file.", (string[] args) =>
+            {
+                if (args.Length != 1) return;
+                TextManager.CheckForDuplicates(args[0]);
+            }));
+
+            commands.Add(new Command("writetocsv", "Writes the default language (English) to a .csv file.", (string[] args) =>
+            {
+                TextManager.WriteToCSV();
+                NPCConversation.WriteToCSV();
+            }));
+
             commands.Add(new Command("csvtoxml", "csvtoxml [language] -> Converts .csv localization files in Content/NPCConversations & Content/Texts to .xml for use in-game.", (string[] args) =>
             {
                 if (args.Length == 0) return;

Barotrauma/BarotraumaClient/Source/GUI/GUI.cs

@@ -69,6 +69,9 @@ namespace Barotrauma
         public static ScalableFont Font => Style?.Font;
         public static ScalableFont SmallFont => Style?.SmallFont;
         public static ScalableFont LargeFont => Style?.LargeFont;
+        public static ScalableFont VideoTitleFont => Style?.VideoTitleFont;
+        public static ScalableFont ObjectiveTitleFont => Style?.ObjectiveTitleFont;
+        public static ScalableFont ObjectiveNameFont => Style?.ObjectiveNameFont;
 
         public static UISprite UIGlow => Style.UIGlow;
 
@@ -530,14 +533,19 @@ namespace Barotrauma
             if (list.Count == 0) { return; }
             foreach (var item in list)
             {
-                int i = updateList.Count - 1;
-                while (updateList[i].UpdateOrder > item.UpdateOrder)
+                int index = 0;
+                if (updateList.Count > 0)
                 {
-                    i--;
+                    index = updateList.Count - 1;
+                    while (updateList[index].UpdateOrder > item.UpdateOrder)
+                    {
+                        index--;
+                        if (index == 0) { break; }
+                    }
                 }
                 if (!updateListSet.Contains(item))
                 {
-                    updateList.Insert(Math.Max(i, 0), item);
+                    updateList.Insert(index, item);
                     updateListSet.Add(item);
                 }
             }
@@ -648,6 +656,7 @@ namespace Barotrauma
                 msg.Timer -= deltaTime;                
                 msg.Pos += msg.Velocity * deltaTime;                
             }
+        }
 
             messages.RemoveAll(m => m.Timer <= 0.0f);
         }
@@ -721,6 +730,10 @@ namespace Barotrauma
                 Vector2 textSize = font.MeasureString(text);
                 DrawRectangle(sb, pos - Vector2.One * backgroundPadding, textSize + Vector2.One * 2.0f * backgroundPadding, (Color)backgroundColor, true);
             }
+            else
+            {
+                sb.Draw(t, new Rectangle(rect.X + thickness, rect.Y, rect.Width - thickness * 2, thickness), null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
+                sb.Draw(t, new Rectangle(rect.X + thickness, rect.Y + rect.Height - thickness, rect.Width - thickness * 2, thickness), null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
 
             font.DrawString(sb, text, pos, color);
         }

Barotrauma/BarotraumaClient/Source/GUI/GUIStyle.cs

@@ -12,6 +12,9 @@ namespace Barotrauma
         public ScalableFont Font { get; private set; }
         public ScalableFont SmallFont { get; private set; }
         public ScalableFont LargeFont { get; private set; }
+        public ScalableFont VideoTitleFont { get; private set; }
+        public ScalableFont ObjectiveTitleFont { get; private set; }
+        public ScalableFont ObjectiveNameFont { get; private set; }
 
         public Sprite CursorSprite { get; private set; }
 
@@ -48,6 +51,15 @@ namespace Barotrauma
                     case "largefont":
                         LargeFont = new ScalableFont(subElement, graphicsDevice);
                         break;
+                    case "objectivetitle":
+                        ObjectiveTitleFont = new ScalableFont(subElement, graphicsDevice);
+                        break;
+                    case "objectivename":
+                        ObjectiveNameFont = new ScalableFont(subElement, graphicsDevice);
+                        break;
+                    case "videotitle":
+                        VideoTitleFont = new ScalableFont(subElement, graphicsDevice);
+                        break;
                     case "cursor":
                         CursorSprite = new Sprite(subElement);
                         break;

Barotrauma/BarotraumaClient/Source/GUI/HUDLayoutSettings.cs

@@ -50,6 +50,11 @@ namespace Barotrauma
             get; private set;
         }
 
+        public static Rectangle ObjectiveAnchor
+        {
+            get; private set;
+        }
+
         public static Rectangle InventoryAreaLower
         {
             get; private set;
@@ -156,6 +161,10 @@ namespace Barotrauma
                 new Rectangle(Padding, CrewArea.Y, chatBoxWidth, chatBoxHeight) :
                 new Rectangle(GameMain.GraphicsWidth - Padding - chatBoxWidth, CrewArea.Y, chatBoxWidth, chatBoxHeight);
 
+            int objectiveAnchorWidth = (int)(250 * GUI.Scale);
+            int objectiveAnchorOffsetY = (int)(100 * GUI.Scale);
+            ObjectiveAnchor = new Rectangle(GameMain.GraphicsWidth - Padding - objectiveAnchorWidth, CrewArea.Y + crewAreaHeight + objectiveAnchorOffsetY, objectiveAnchorWidth, 0);
+
             int lowerAreaHeight = (int)Math.Min(GameMain.GraphicsHeight * 0.25f, 280);
             InventoryAreaLower = new Rectangle(Padding, GameMain.GraphicsHeight - lowerAreaHeight, GameMain.GraphicsWidth - Padding * 2, lowerAreaHeight);
 

Barotrauma/BarotraumaClient/Source/GameSession/GameModes/SinglePlayerCampaign.cs

@@ -44,7 +44,7 @@ namespace Barotrauma
 
             ContextualTutorial = Tutorial.Tutorials.Find(t => t is ContextualTutorial) as ContextualTutorial;
 
-            if (ContextualTutorial.Selected && !ContextualTutorial.Initialized) // Selected when starting a new game -> initialize
+            if (ContextualTutorial.Selected) // Selected when starting a new game -> initialize
             {
                 ContextualTutorial.Initialize();
             }

Barotrauma/BarotraumaClient/Source/GameSession/GameModes/Tutorials/ContextualTutorial.cs

@@ -1,9 +1,10 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Xml.Linq;
 using System;
 using Microsoft.Xna.Framework;
 using Barotrauma.Items.Components;
 using System.Linq;
+using Microsoft.Xna.Framework.Input;
 
 namespace Barotrauma.Tutorials
 {
@@ -13,38 +14,60 @@ namespace Barotrauma.Tutorials
         public static bool ContentRunning = false;
         public static bool Initialized = false;
 
-        private enum ContentTypes { None = 0, Video = 1, Text = 2 };
+        private enum ContentTypes { None = 0, Video = 1, TextOnly = 2 };
 
         private TutorialSegment activeSegment;
         private List<TutorialSegment> segments;
+        
+        private VideoPlayer videoPlayer;
 
-        private SpriteSheetPlayer spriteSheetPlayer;
         private Steering navConsole;
         private Reactor reactor;
         private Sonar sonar;
         private Vector2 subStartingPosition;
         private List<Character> crew;
+        private Character mechanic;
+        private Character engineer;
+        private Character injuredMember = null;
+
         private List<Pair<Character, float>> characterTimeOnSonar;
         private float requiredTimeOnSonar = 5f;
 
         private bool started = false;
         private string playableContentPath;
-        
+
         private float tutorialTimer;
-        private float degrading2ActivationCountdown;
 
         private bool disableTutorialOnDeficiencyFound = true;
 
+        private GUIFrame holderFrame, objectiveFrame;
+        //private GUIButton toggleButton;
+        //private bool objectivesOpen = false;
+        //private float openState = 0f;
+        private List<TutorialSegment> activeObjectives = new List<TutorialSegment>();
+        private string objectiveTranslated;
+        //private Point objectiveBaseOffset = Point.Zero;
+
+        private float floodTutorialTimer = 0.0f;
+        private const float floodTutorialDelay = 2.0f;
+        private float medicalTutorialTimer = 0.0f;
+        private const float medicalTutorialDelay = 2.0f;
+
         private class TutorialSegment
         {
-            public string Name;
+            public string Id;
+            public string Objective;
             public ContentTypes ContentType;
-            public XElement Content;
+            public XElement TextContent;
+            public XElement VideoContent;
             public bool IsTriggered;
+            public GUIButton ReplayButton;
+            public GUITextBlock LinkedTitle, LinkedText;
 
             public TutorialSegment(XElement config)
             {
-                Name = config.GetAttributeString("name", "Missing Name");
+                Id = config.GetAttributeString("id", "Missing ID");
+                Objective = TextManager.Get(config.GetAttributeString("objective", string.Empty), true);
                 Enum.TryParse(config.GetAttributeString("contenttype", "None"), true, out ContentType);
                 IsTriggered = config.GetAttributeBool("istriggered", false);
 
@@ -53,10 +76,11 @@ namespace Barotrauma.Tutorials
                     case ContentTypes.None:
                         break;
                     case ContentTypes.Video:
-                        Content = config.Element("Video");
+                        VideoContent = config.Element("Video");
+                        TextContent = config.Element("Text");
                         break;
-                    case ContentTypes.Text:
-                        Content = config.Element("Text");
+                    case ContentTypes.TextOnly:
+                        TextContent = config.Element("Text");
                         break;
                 }
             }
@@ -77,17 +101,18 @@ namespace Barotrauma.Tutorials
 
         public override void Initialize()
         {
-            if (Initialized) return;
-            Initialized = true;
-
-            base.Initialize();
-            spriteSheetPlayer = new SpriteSheetPlayer();
-            characterTimeOnSonar = new List<Pair<Character, float>>();
-
             for (int i = 0; i < segments.Count; i++)
             {
                 segments[i].IsTriggered = false;
             }
+
+            if (Initialized) return;
+            Initialized = true;
+
+            base.Initialize();
+            videoPlayer = new VideoPlayer();
+            characterTimeOnSonar = new List<Pair<Character, float>>();
+            //objectivesOpen = true;
         }
 
         public void LoadPartiallyComplete(XElement element)
@@ -111,13 +136,13 @@ namespace Barotrauma.Tutorials
             }
         }
 
-        private void PreloadVideoContent()
+        private void PreloadVideoContent() // Have to see if needed with videos
         {
-            for (int i = 0; i < segments.Count; i++)
+            /*for (int i = 0; i < segments.Count; i++)
             {
                 if (segments[i].ContentType != ContentTypes.Video || segments[i].IsTriggered) continue;
-                spriteSheetPlayer.PreloadContent(playableContentPath, "tutorial", segments[i].Name, segments[i].Content);
-            }
+                spriteSheetPlayer.PreloadContent(playableContentPath, "tutorial", segments[i].Id, segments[i].VideoContent);
+            }*/
         }
 
         public void SavePartiallyComplete(XElement element)
@@ -155,9 +180,12 @@ namespace Barotrauma.Tutorials
 
             base.Start();
 
+            injuredMember = null;
+            activeObjectives.Clear();
+            objectiveTranslated = TextManager.Get("Objective");
+            CreateObjectiveFrame();
             activeSegment = null;
-            tutorialTimer = 0.0f;
-            degrading2ActivationCountdown = -1;
+            tutorialTimer = floodTutorialTimer = medicalTutorialTimer = 0.0f;
             subStartingPosition = Vector2.Zero;
             characterTimeOnSonar.Clear();
 
@@ -193,6 +221,9 @@ namespace Barotrauma.Tutorials
             }
 
             crew = GameMain.GameSession.CrewManager.GetCharacters().ToList();
+            mechanic = CrewMemberWithJob("mechanic");
+            engineer = CrewMemberWithJob("engineer");
+
             Completed = true; // Trigger completed at start to prevent the contextual tutorial from automatically activating on starting new campaigns after this one
             started = true;
         }
@@ -208,71 +239,196 @@ namespace Barotrauma.Tutorials
         public void Stop()
         {
             started = ContentRunning = Initialized = false;
-            spriteSheetPlayer.Remove();
-            spriteSheetPlayer = null;
+            videoPlayer.Remove();
+            videoPlayer = null;
             characterTimeOnSonar = null;
         }
 
+        private void CreateObjectiveFrame()
+        {
+            holderFrame = new GUIFrame(new RectTransform(new Point(GameMain.GraphicsWidth, GameMain.GraphicsHeight), GUI.Canvas, Anchor.Center));
+            objectiveFrame = new GUIFrame(HUDLayoutSettings.ToRectTransform(HUDLayoutSettings.ObjectiveAnchor, holderFrame.RectTransform), style: null);
+
+            /*int toggleButtonWidth = (int)(30 * GUI.Scale);
+            int toggleButtonHeight = (int)(40 * GUI.Scale);
+            toggleButton = new GUIButton(new RectTransform(new Point(toggleButtonWidth, toggleButtonHeight), objectiveFrame.RectTransform, Anchor.CenterRight) { AbsoluteOffset = new Point(0, 20) }, style: "UIToggleButton");
+            toggleButton.OnClicked += (GUIButton btn, object userdata) =>
+            {
+                objectivesOpen = !objectivesOpen;
+                foreach (GUIComponent child in btn.Children)
+                {
+                    child.SpriteEffects = objectivesOpen ? SpriteEffects.FlipHorizontally : SpriteEffects.None;
+                }
+                return true;
+            };
+
+            objectiveBaseOffset = new Point((int)(-2.5f * toggleButton.Rect.Width), 0);*/
+        }
+
         public override void AddToGUIUpdateList()
         {
-            base.AddToGUIUpdateList();
-            if (spriteSheetPlayer != null)
+            if (objectiveFrame != null && activeObjectives.Count > 0)
             {
-                spriteSheetPlayer.AddToGUIUpdateList();
+                objectiveFrame.AddToGUIUpdateList(order: -1);
+            }
+            base.AddToGUIUpdateList();
+            if (videoPlayer != null)
+            {
+                videoPlayer.AddToGUIUpdateList(order: 100);
             }
         }
 
         public override void Update(float deltaTime)
         {
+            if (videoPlayer != null)
+            {
+                videoPlayer.Update();
+            }
+
+            if (infoBox != null)
+            {
+                if (PlayerInput.KeyHit(Keys.Enter) || PlayerInput.KeyHit(Keys.Escape))
+                {
+                    CloseInfoFrame(null, null);
+                }
+            }
+
             if (!started || ContentRunning) return;
 
             deltaTime *= 0.5f;
-
+                       
             for (int i = 0; i < segments.Count; i++)
             {
-                if (segments[i].IsTriggered) continue;
+                if (segments[i].IsTriggered || activeObjectives.Contains(segments[i])) continue;
                 if (CheckContextualTutorials(i, deltaTime)) // Found a relevant tutorial, halt finding new ones
                 {
                     break;
                 }
             }
+
+            for (int i = 0; i < activeObjectives.Count; i++)
+            {
+                CheckActiveObjectives(activeObjectives[i], deltaTime);
+            }
+
+            /*if (activeObjectives.Count > 0)
+            {
+                if (objectivesOpen)
+                {
+                    openState -= deltaTime * 5.0f;
+                }
+                else
+                {
+                    openState += deltaTime * 5.0f;
+                }
+
+                openState = MathHelper.Clamp(openState, 0.0f, 1.0f);
+
+                float widestObjective = 0f;
+                for (int i = 0; i < activeObjectives.Count; i++)
+                {
+                    if (activeObjectives[i].ReplayButton.Rect.Width > widestObjective)
+                    {
+                        widestObjective = activeObjectives[i].ReplayButton.Rect.Width;
+                    }
+                }
+
+                float objectivesHiddenOffset = widestObjective + toggleButton.Rect.Width + 100f;
+
+                for (int i = 0; i < activeObjectives.Count; i++)
+                {
+                    activeObjectives[i].ReplayButton.RectTransform.AbsoluteOffset = objectiveBaseOffset + new Point((int)MathHelper.SmoothStep(0, objectivesHiddenOffset, openState), 0);
+                }
+            }*/
+        }
+
+        private void ClosePreTextAndTriggerVideoCallback()
+        {
+            if (!string.IsNullOrEmpty(activeSegment.Objective))
+            {
+                videoPlayer.LoadContentWithObjective(playableContentPath, new VideoPlayer.VideoSettings(activeSegment.VideoContent), new VideoPlayer.TextSettings(activeSegment.VideoContent), activeSegment.Id, true, activeSegment.Objective, CurrentSegmentStopCallback);
+            }
+            else
+            {
+                videoPlayer.LoadContent(playableContentPath, new VideoPlayer.VideoSettings(activeSegment.VideoContent), new VideoPlayer.TextSettings(activeSegment.VideoContent), activeSegment.Id, true, CurrentSegmentStopCallback);
+            }
         }
 
         private void CurrentSegmentStopCallback()
         {
+            if (!string.IsNullOrEmpty(activeSegment.Objective))
+            {
+                AddNewObjective(activeSegment);
+            }
+
             activeSegment = null;
             ContentRunning = false;
         }
 
+        private void AddNewObjective(TutorialSegment segment)
+        {
+            activeObjectives.Add(segment);
+
+            Point replayButtonSize = new Point((int)GUI.ObjectiveNameFont.MeasureString(segment.Objective).X, (int)(GUI.ObjectiveNameFont.MeasureString(segment.Objective).Y * 1.45f));
+
+            segment.ReplayButton = new GUIButton(new RectTransform(replayButtonSize, objectiveFrame.RectTransform, Anchor.TopRight, Pivot.TopRight) { AbsoluteOffset = new Point(/*(int)(-2.5f * toggleButton.Rect.Width)*/0, (replayButtonSize.Y + 20) * (activeObjectives.Count - 1)) }, style: null);
+            segment.ReplayButton.OnClicked += (GUIButton btn, object userdata) =>
+            {
+                ReplaySegmentVideo(segment);
+                return true;
+            };
+
+            int yOffset = (int)(GUI.ObjectiveNameFont.MeasureString(objectiveTranslated).Y / 2f) + 5;
+            segment.LinkedTitle = new GUITextBlock(new RectTransform(new Point(replayButtonSize.X, yOffset), segment.ReplayButton.RectTransform, Anchor.Center, Pivot.BottomCenter) { AbsoluteOffset = new Point(10, 0) }, objectiveTranslated, textColor: Color.White, font: GUI.ObjectiveTitleFont, textAlignment: Alignment.CenterRight);
+            segment.LinkedText = new GUITextBlock(new RectTransform(new Point(replayButtonSize.X, yOffset), segment.ReplayButton.RectTransform, Anchor.Center, Pivot.TopCenter) { AbsoluteOffset = new Point(10, 0) }, segment.Objective, textColor: new Color(4, 180, 108), font: GUI.ObjectiveNameFont, textAlignment: Alignment.CenterRight);
+
+            segment.LinkedTitle.Color = segment.LinkedTitle.HoverColor = segment.LinkedTitle.PressedColor = segment.LinkedTitle.SelectedColor = Color.Transparent;
+            segment.LinkedText.Color = segment.LinkedText.HoverColor = segment.LinkedText.PressedColor = segment.LinkedText.SelectedColor = Color.Transparent;
+            segment.ReplayButton.Color = segment.ReplayButton.HoverColor = segment.ReplayButton.PressedColor = segment.ReplayButton.SelectedColor = Color.Transparent;
+        }
+
+        private void RemoveCompletedObjective(TutorialSegment objective)
+        {
+            objectiveFrame.RemoveChild(objective.ReplayButton);
+            activeObjectives.Remove(objective);
+            objective.IsTriggered = true;
+
+            for (int i = 0; i < activeObjectives.Count; i++)
+            {
+                activeObjectives[i].ReplayButton.RectTransform.AbsoluteOffset = new Point(0, (activeObjectives[i].ReplayButton.Rect.Height + 20) * i);
+            }
+        }
+
         private bool CheckContextualTutorials(int index, float deltaTime)
         {
             switch (index)
             {
                 case 0: // Welcome: Game Start [Text]
-                    if (tutorialTimer < 0.5f)
+                    if (tutorialTimer < 1.0f)
                     {
                         tutorialTimer += deltaTime;
                         return false;
                     }
                     break;
-                case 1: // Command Reactor: 10 seconds after 'Welcome' dismissed and only if no command given to start reactor [Video]
-                    if (tutorialTimer < 10.5f)
+                case 1: // Command Reactor: 2 seconds after 'Welcome' dismissed and only if no command given to start reactor [Video]
+                    if (!segments[0].IsTriggered) return false;
+                    if (tutorialTimer < 3.0f)
                     {
                         tutorialTimer += deltaTime;
 
                         if (HasOrder("operatereactor"))
                         {
                             segments[index].IsTriggered = true;
-                            tutorialTimer = 10.5f;
+                            tutorialTimer = 2.5f;
                         }
                         return false;
                     }
                     break;
-                case 2: // Nav Console: 20 seconds after 'Command Reactor' dismissed or if nav console is activated [Video]
+                case 2: // Nav Console: 2 seconds after 'Command Reactor' dismissed or if nav console is activated [Video]
+                    if (!IsReactorPoweredUp()) return false; // Do not advance tutorial based on this segment if reactor has not been powered up
                     if (Character.Controlled?.SelectedConstruction != navConsole.Item)
-                    {
-                        if (!segments[1].IsTriggered) return false; // Do not advance tutorial timer based on this segment if reactor has not been powered up
-                        if (tutorialTimer < 30.5f)
+                    {                       
+                        if (tutorialTimer < 4.5f)
                         {
                             tutorialTimer += deltaTime;
                             return false;
@@ -280,20 +436,13 @@ namespace Barotrauma.Tutorials
                     }
                     else
                     {
-                        if (!segments[1].IsTriggered || !HasOrder("operatereactor")) // If reactor has not been powered up or ordered to be, default to that one first
-                        {
-                            if (tutorialTimer < 10.5f)
-                            {
-                                tutorialTimer = 10.5f;
-                            }
-                            return false;
-                        }
-
-                        tutorialTimer = 30.5f;
+                        tutorialTimer = 4.5f;
                     }
-                    break;
+
+                    TriggerTutorialSegment(index, GameMain.GameSession.EndLocation.Name);
+                    return true;
                 case 3: // Objective: Travel ~150 meters and while sub is not flooding [Text]
-                    if (Vector2.Distance(subStartingPosition, Submarine.MainSub.WorldPosition) < 12000f || IsFlooding())
+                    if (Vector2.Distance(subStartingPosition, Submarine.MainSub.WorldPosition) < 8000f || IsFlooding())
                     {
                         return false;
                     }
@@ -307,6 +456,11 @@ namespace Barotrauma.Tutorials
                     {
                         return false;
                     }
+                    else if (floodTutorialTimer < floodTutorialDelay)
+                    {
+                        floodTutorialTimer += deltaTime;
+                        return false;
+                    }
                     break;
                 case 5: // Reactor: Player uses reactor for the first time [Video]
                     if (Character.Controlled?.SelectedConstruction != reactor.Item)
@@ -321,19 +475,23 @@ namespace Barotrauma.Tutorials
                     }
                     break;
                 case 7: // Degrading1: Any equipment degrades to 50% health or less and player has not assigned any crew to perform maintenance [Text]
+                    if ((mechanic == null || mechanic.IsDead) && (engineer == null || engineer.IsDead)) // Both engineer and mechanic are dead or do not exist -> do not display
+                    {
+                        return false;
+                    }
+
                     bool degradedEquipmentFound = false;
 
                     foreach (Item item in Item.ItemList)
                     {
-                        if (!item.Repairables.Any() || item.ConditionPercentage > 50) continue;
+                        if (!item.Repairables.Any() || item.Condition > 50.0f) continue;
                         degradedEquipmentFound = true;
                         break;
                     }
 
                     if (degradedEquipmentFound)
                     {
-                        degrading2ActivationCountdown = 5f;
-                        if (HasOrder("repairsystems"))
+                        if (HasOrder("repairsystems", "jobspecific"))
                         {
                             segments[index].IsTriggered = true;
                             return false;
@@ -344,43 +502,44 @@ namespace Barotrauma.Tutorials
                         return false;
                     }
                     break;
-                case 8: // Degrading2: 5 seconds after 'Degrading1' dismissed, and only if player has not assigned any crew to perform maintenance [Video]
-                    if (degrading2ActivationCountdown == -1f)
+                case 8: // Medical: Crewmember is injured but not killed [Video]
+
+                    if (injuredMember == null)
                     {
-                        return false;
-                    }
-                    else if (degrading2ActivationCountdown > 0.0f)
-                    {
-                        degrading2ActivationCountdown -= deltaTime;
-                        if (HasOrder("repairsystems"))
+                        for (int i = 0; i < crew.Count; i++)
                         {
-                            segments[index].IsTriggered = true;
+                            Character member = crew[i];
+                            if (member.Vitality < member.MaxVitality && !member.IsDead)
+                            {
+                                injuredMember = member;
+                                break;
+                            }
                         }
 
                         return false;
                     }
-                    break;
-                case 9: // Medical: Crewmember is injured but not killed [Video]
-                    bool injuredFound = false;
-                    for (int i = 0; i < crew.Count; i++)
+                    else if (medicalTutorialTimer < medicalTutorialDelay)
                     {
-                        Character member = crew[i];
-                        if (member.Vitality < member.MaxVitality && !member.IsDead)
-                        {
-                            injuredFound = true;
-                            break;
-                        }
+                        medicalTutorialTimer += deltaTime;
+                        return false;
                     }
-
-                    if (!injuredFound) return false;
-                    break;
-                case 10: // Approach1: Destination is within ~100m [Video]
+                    else
+                    {
+                        TriggerTutorialSegment(index, new string[] { injuredMember.Info.DisplayName,
+                                (injuredMember.Info.Gender == Gender.Male) ? TextManager.Get("PronounPossessiveMale").ToLower() : TextManager.Get("PronounPossessiveFemale").ToLower() });
+                        return true;
+                    }
+                case 9: // Approach1: Destination is within ~100m [Video]
                     if (Vector2.Distance(Submarine.MainSub.WorldPosition, Level.Loaded.EndPosition) > 8000f)
                     {
                         return false;
                     }
-                    break;
-                case 11: // Approach2: Sub is docked [Text]
+                    else
+                    {
+                        TriggerTutorialSegment(index, GameMain.GameSession.EndLocation.Name);
+                        return true;
+                    }
+                case 10: // Approach2: Sub is docked [Text]
                     if (!Submarine.MainSub.AtEndPosition || Submarine.MainSub.DockedTo.Count == 0)
                     {
                         return false;
@@ -392,11 +551,128 @@ namespace Barotrauma.Tutorials
             return true;
         }
 
-        private bool HasOrder(string aiTag)
+        private bool HasObjective(string objectiveName)
+        {
+            for (int i = 0; i < activeObjectives.Count; i++)
+            {
+                if (activeObjectives[i].Id == objectiveName) return true;
+            }
+
+            return false;
+        }
+
+        private void CheckActiveObjectives(TutorialSegment objective, float deltaTime)
+        {
+            switch(objective.Id)
+            {
+                case "ReactorCommand": // Reactor commanded
+                    if (!IsReactorPoweredUp())
+                    {
+                        if (!HasOrder("operatereactor")) return;
+                    }
+                    break;
+                case "NavConsole": // traveled 50 meters
+                    if (Vector2.Distance(subStartingPosition, Submarine.MainSub.WorldPosition) < 4000f)
+                    {
+                        return;
+                    }
+                    break;
+                case "Flood": // Hull breaches repaired
+                    if (IsFlooding()) return;
+                    break;
+                case "Medical":
+                    if (injuredMember != null && !injuredMember.IsDead)
+                    {
+                        if (injuredMember.CharacterHealth.DroppedItem == null) return;
+                    }
+                    break;
+                case "EnemyOnSonar": // Enemy dispatched
+                    if (HasEnemyOnSonarForDuration(deltaTime))
+                    {
+                        return;
+                    }
+                    break;
+                case "Degrading": // Fixed
+                    if (mechanic != null && !mechanic.IsDead)
+                    {
+                        HumanAIController humanAI = mechanic.AIController as HumanAIController;
+                        if (mechanic.CurrentOrder?.AITag != "repairsystems" || humanAI.CurrentOrderOption != "jobspecific")
+                        {
+                            return;
+                        }
+                    }
+
+                    if (engineer != null && !engineer.IsDead)
+                    {
+                        HumanAIController humanAI = engineer.AIController as HumanAIController;
+                        if (engineer.CurrentOrder?.AITag != "repairsystems" || humanAI.CurrentOrderOption != "jobspecific")
+                        {
+                            return;
+                        }
+                    }
+
+                    break;
+                case "Approach1": // Wait until docked
+                    if (!Submarine.MainSub.AtEndPosition || Submarine.MainSub.DockedTo.Count == 0)
+                    {
+                        return;
+                    }
+                    break;
+            }
+
+            RemoveCompletedObjective(objective);
+        }
+
+        private bool IsReactorPoweredUp()
+        {
+            float load = 0.0f;
+            List<Connection> connections = reactor.Item.Connections;
+            if (connections != null && connections.Count > 0)
+            {
+                foreach (Connection connection in connections)
+                {
+                    if (!connection.IsPower) continue;
+                    foreach (Connection recipient in connection.Recipients)
+                    {
+                        if (!(recipient.Item is Item it)) continue;
+
+                        PowerTransfer pt = it.GetComponent<PowerTransfer>();
+                        if (pt == null) continue;
+
+                        load = Math.Max(load, pt.PowerLoad);
+                    }
+                }
+            }
+
+            return Math.Abs(load + reactor.CurrPowerConsumption) < 10;
+        }
+
+        private Character CrewMemberWithJob(string job)
         {
             for (int i = 0; i < crew.Count; i++)
             {
-                if (crew[i].CurrentOrder?.AITag == aiTag) return true;
+                if (crew[i].Info.Job.Name == job) return crew[i];
+            }
+
+            return null;
+        }
+
+        private bool HasOrder(string aiTag, string option = null)
+        {
+            for (int i = 0; i < crew.Count; i++)
+            {
+                if (crew[i].CurrentOrder?.AITag == aiTag)
+                {
+                    if (option == null)
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        HumanAIController humanAI = crew[i].AIController as HumanAIController;
+                        return humanAI.CurrentOrderOption == option;
+                    }
+                }
             }
 
             return false;
@@ -447,27 +723,51 @@ namespace Barotrauma.Tutorials
                 }
             }
 
-            return characterTimeOnSonar.Find(ct => ct.Second >= requiredTimeOnSonar) != null;
+            return characterTimeOnSonar.Find(ct => ct.Second >= requiredTimeOnSonar && !ct.First.IsDead) != null;
         }
 
         private void TriggerTutorialSegment(int index, params object[] args)
         {
+            Inventory.draggingItem = null;
             ContentRunning = true;
             activeSegment = segments[index];
-            activeSegment.IsTriggered = true;
+
+            string tutorialText = TextManager.GetFormatted(activeSegment.TextContent.GetAttributeString("tag", ""), true, args);
+            string objectiveText = string.Empty;
+
+            if (!string.IsNullOrEmpty(activeSegment.Objective))
+            {
+                if (args.Length == 0)
+                {
+                    objectiveText = activeSegment.Objective;
+                }
+                else
+                {
+                    objectiveText = string.Format(activeSegment.Objective, args);
+                }
+
+                activeSegment.Objective = objectiveText;
+            }
+            else
+            {
+                activeSegment.IsTriggered = true; // Complete at this stage only if no related objective
+            }
 
             switch (activeSegment.ContentType)
             {
                 case ContentTypes.None:
                     break;
                 case ContentTypes.Video:
-                    spriteSheetPlayer.LoadContent(playableContentPath, activeSegment.Content, activeSegment.Name, true, true, CurrentSegmentStopCallback);
+                    infoBox = CreateInfoFrame(TextManager.Get(activeSegment.Id), tutorialText,
+                          activeSegment.TextContent.GetAttributeInt("width", 300),
+                          activeSegment.TextContent.GetAttributeInt("height", 80),
+                          activeSegment.TextContent.GetAttributeString("anchor", "Center"), true, ClosePreTextAndTriggerVideoCallback);                    
                     break;
-                case ContentTypes.Text:
-                    infoBox = CreateInfoFrame(TextManager.Get(activeSegment.Name), TextManager.GetFormatted(activeSegment.Content.GetAttributeString("tag", ""), false, args),
-                                              activeSegment.Content.GetAttributeInt("width", 300),
-                                              activeSegment.Content.GetAttributeInt("height", 80),
-                                              activeSegment.Content.GetAttributeString("anchor", "Center"), true, CurrentSegmentStopCallback);
+                case ContentTypes.TextOnly:
+                    infoBox = CreateInfoFrame(TextManager.Get(activeSegment.Id), tutorialText,
+                                              activeSegment.TextContent.GetAttributeInt("width", 300),
+                                              activeSegment.TextContent.GetAttributeInt("height", 80),
+                                              activeSegment.TextContent.GetAttributeString("anchor", "Center"), true, CurrentSegmentStopCallback);
                     break;
             }
 
@@ -479,6 +779,13 @@ namespace Barotrauma.Tutorials
             CoroutineManager.StartCoroutine(WaitToStop()); // Completed
         }
 
+        private void ReplaySegmentVideo(TutorialSegment segment)
+        {
+            if (ContentRunning) return;
+            ContentRunning = true;
+            videoPlayer.LoadContent(playableContentPath, new VideoPlayer.VideoSettings(segment.VideoContent), new VideoPlayer.TextSettings(segment.VideoContent), segment.Id, true, () => ContentRunning = false);
+        }
+
         private IEnumerable<object> WaitToStop()
         {
             while (ContentRunning) yield return null;

Barotrauma/BarotraumaClient/Source/GameSession/GameModes/Tutorials/Tutorial.cs

@@ -121,7 +121,7 @@ namespace Barotrauma.Tutorials
 
         public virtual void AddToGUIUpdateList()
         {
-            if (infoBox != null) infoBox.AddToGUIUpdateList();
+            if (infoBox != null) infoBox.AddToGUIUpdateList(order: 100);
         }
 
         public virtual void Update(float deltaTime)
@@ -194,7 +194,7 @@ namespace Barotrauma.Tutorials
             if (title.Length > 0)
             {
                 var titleBlock = new GUITextBlock(new RectTransform(new Vector2(1f, .35f), infoBlock.RectTransform, Anchor.TopCenter,
-                Pivot.TopCenter), title, font: GUI.LargeFont, textAlignment: Alignment.Center);
+                Pivot.TopCenter), title, font: GUI.VideoTitleFont, textAlignment: Alignment.Center, textColor: new Color(253, 174, 0));
             }
 
             var textBlock = new GUITextBlock(new RectTransform(new Vector2(0.9f, 1f), infoBlock.RectTransform, Anchor.BottomCenter),

Barotrauma/BarotraumaClient/Source/Screens/CampaignSetupUI.cs

@@ -57,18 +57,6 @@ namespace Barotrauma
                 RelativeSpacing = 0.02f
             };
 
-            var columnContainer = new GUILayoutGroup(new RectTransform(Vector2.One, newGameContainer.RectTransform), isHorizontal: true)
-            {
-                Stretch = true,
-                RelativeSpacing = 0.05f
-            };
-
-            var leftColumn = new GUILayoutGroup(new RectTransform(Vector2.One, columnContainer.RectTransform))
-            {
-                Stretch = true,
-                RelativeSpacing = 0.02f
-            };
-
             var rightColumn = new GUILayoutGroup(new RectTransform(Vector2.One, columnContainer.RectTransform))
             {
                 RelativeSpacing = 0.02f
@@ -76,11 +64,14 @@ namespace Barotrauma
 
             // New game left side
             new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.1f), leftColumn.RectTransform), TextManager.Get("SelectedSub") + ":", textAlignment: Alignment.BottomLeft);
-            subList = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.65f), leftColumn.RectTransform));
+            subList = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.65f), leftColumn.RectTransform))
+            {
+                OnSelected = CheckForPax
+            };
 
             UpdateSubList(submarines);
 
-            // New game right side
+            // New game right sideon
             new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.1f), rightColumn.RectTransform), TextManager.Get("SaveName") + ":", textAlignment: Alignment.BottomLeft);
             saveNameBox = new GUITextBox(new RectTransform(new Vector2(1.0f, 0.1f), rightColumn.RectTransform), string.Empty);
 
@@ -377,7 +368,25 @@ namespace Barotrauma
         {
             if (isMultiplayer) return;
             Tutorial contextualTutorial = Tutorial.Tutorials.Find(t => t is ContextualTutorial);
-            contextualTutorialBox.Selected = (contextualTutorial != null) ? !GameMain.Config.CompletedTutorialNames.Contains(contextualTutorial.Name) : true;
+
+            Submarine selectedSub = subList.SelectedData as Submarine;
+
+            if (selectedSub == null || selectedSub.Name != "PAX")
+            {
+                contextualTutorialBox.Selected = (contextualTutorial != null) ? !GameMain.Config.CompletedTutorialNames.Contains(contextualTutorial.Name) : true;
+            }
+            else
+            {
+                contextualTutorialBox.Selected = true;
+            }
+        }
+
+        private bool CheckForPax(GUIComponent component, object obj)
+        {
+            if (!(obj is Submarine) || contextualTutorialBox == null) return false;
+            Submarine sub = obj as Submarine;
+            contextualTutorialBox.Selected = sub.Name == "PAX";
+            return true;
         }
 
         private bool SelectSaveFile(GUIComponent component, object obj)

Barotrauma/BarotraumaShared/SharedContent.projitems

@@ -357,6 +357,33 @@
     <Content Include="$(MSBuildThisFileDirectory)Content\Effects\waterbump.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\1_CommandReactor\BaroTutorial_CommandReactor.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\2_NavConsole\BaroTutorial_NavConsole.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\3_Flood\BaroTutorial_Flood.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\4_Reactor\BaroTutorial_Reactor.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\5_EnemyOnSonar\BaroTutorial_EnemyOnSonar.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\6_Degrading2\BaroTutorial_Degrading.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\7_Medical\BaroTutorial_Medical.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)Content\Tutorials\ContextualTutorial\8_Approach1\BaroTutorial_Approach.mp4">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <None Include="$(MSBuildThisFileDirectory)Content\Fonts\BebasNeue-Regular.otf">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <Content Include="$(MSBuildThisFileDirectory)Content\Fonts\NotoSans\LICENSE_OFL.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>

Barotrauma/BarotraumaShared/Source/Items/Components/Holdable/RepairTool.cs

@@ -147,7 +147,7 @@ namespace Barotrauma.Items.Components
             var collisionCategories = Physics.CollisionWall | Physics.CollisionCharacter | Physics.CollisionItem | Physics.CollisionLevel | Physics.CollisionRepair;
             if (RepairThroughWalls)
             {
-                var bodies = Submarine.PickBodies(rayStart, rayEnd, ignoredBodies, collisionCategories, ignoreSensors: false);
+                var bodies = Submarine.PickBodies(rayStart, rayEnd, ignoredBodies, collisionCategories, ignoreSensors: false, allowInsideFixture: true);
                 foreach (Body body in bodies)
                 {
                     FixBody(user, deltaTime, degreeOfSuccess, body);
@@ -155,7 +155,7 @@ namespace Barotrauma.Items.Components
             }
             else
             {
-                FixBody(user, deltaTime, degreeOfSuccess, Submarine.PickBody(rayStart, rayEnd, ignoredBodies, collisionCategories, ignoreSensors: false));
+                FixBody(user, deltaTime, degreeOfSuccess, Submarine.PickBody(rayStart, rayEnd, ignoredBodies, collisionCategories, ignoreSensors: false, allowInsideFixture: true));
             }
             
             if (ExtinguishAmount > 0.0f && item.CurrentHull != null)

Barotrauma/BarotraumaShared/Source/Map/Submarine.cs

@@ -666,7 +666,7 @@ namespace Barotrauma
             }
         }
 
-        public static Body PickBody(Vector2 rayStart, Vector2 rayEnd, IEnumerable<Body> ignoredBodies = null, Category? collisionCategory = null, bool ignoreSensors = true, Predicate<Fixture> customPredicate = null)
+        public static Body PickBody(Vector2 rayStart, Vector2 rayEnd, IEnumerable<Body> ignoredBodies = null, Category? collisionCategory = null, bool ignoreSensors = true, Predicate<Fixture> customPredicate = null, bool allowInsideFixture = false)
         {
             if (Vector2.DistanceSquared(rayStart, rayEnd) < 0.00001f)
             {
@@ -678,20 +678,16 @@ namespace Barotrauma
             Body closestBody = null;
             if (allowInsideFixture)
             {
-                if (fixture == null ||
-                    (ignoreSensors && fixture.IsSensor) ||
-                    fixture.CollisionCategories == Category.None ||
-                    fixture.CollisionCategories == Physics.CollisionItem) return -1;
-                
-                if (customPredicate != null && !customPredicate(fixture)) return -1;
-                
-                if (collisionCategory != null && 
-                    !fixture.CollisionCategories.HasFlag((Category)collisionCategory) &&
-                    !((Category)collisionCategory).HasFlag(fixture.CollisionCategories)) return -1;
-
-                if (ignoredBodies != null && ignoredBodies.Contains(fixture.Body)) return -1;
-
-                if (fixture.Body.UserData is Structure structure)
+                var aabb = new FarseerPhysics.Collision.AABB(rayStart - Vector2.UnitY * 0.001f, rayStart + Vector2.UnitY * 0.001f);
+                GameMain.World.QueryAABB((fixture) =>
+                {
+                    if (!CheckFixtureCollision(fixture, ignoredBodies, collisionCategory, ignoreSensors, customPredicate)) { return false; }
+                    closestFraction = 0.0f;
+                    closestNormal = Vector2.Normalize(rayEnd - rayStart);
+                    if (fixture.Body != null) closestBody = fixture.Body;                    
+                    return true;
+                }, ref aabb);
+                if (closestFraction <= 0.0f)
                 {
                     return closestBody;
                 }
@@ -718,7 +714,7 @@ namespace Barotrauma
             return closestBody;
         }
 
-        public static List<Body> PickBodies(Vector2 rayStart, Vector2 rayEnd, List<Body> ignoredBodies = null, Category? collisionCategory = null, bool ignoreSensors = true, Predicate<Fixture> customPredicate = null)
+        public static List<Body> PickBodies(Vector2 rayStart, Vector2 rayEnd, IEnumerable<Body> ignoredBodies = null, Category? collisionCategory = null, bool ignoreSensors = true, Predicate<Fixture> customPredicate = null, bool allowInsideFixture = false)
         {
             if (Vector2.DistanceSquared(rayStart, rayEnd) < 0.00001f)
             {
@@ -729,25 +725,9 @@ namespace Barotrauma
             List<Body> bodies = new List<Body>();
             GameMain.World.RayCast((fixture, point, normal, fraction) =>
             {
-                if (fixture == null ||
-                    (ignoreSensors && fixture.IsSensor) ||
-                    fixture.CollisionCategories == Category.None ||
-                    fixture.CollisionCategories == Physics.CollisionItem) return -1;
+                if (!CheckFixtureCollision(fixture, ignoredBodies, collisionCategory, ignoreSensors, customPredicate)) { return -1; }
 
-                if (customPredicate != null && !customPredicate(fixture)) return -1;
-
-                if (collisionCategory != null &&
-                    !fixture.CollisionCategories.HasFlag((Category)collisionCategory) &&
-                    !((Category)collisionCategory).HasFlag(fixture.CollisionCategories)) return -1;
-
-                if (ignoredBodies != null && ignoredBodies.Contains(fixture.Body)) return -1;
-
-                if (fixture.Body.UserData is Structure structure)
-                {
-                    if (structure.IsPlatform && collisionCategory != null && !((Category)collisionCategory).HasFlag(Physics.CollisionPlatform)) return -1;
-                }
-
-                bodies.Add(fixture.Body);
+                if (fixture.Body != null) { bodies.Add(fixture.Body); }
                 if (fraction < closestFraction)
                 {
                     lastPickedPosition = rayStart + (rayEnd - rayStart) * fraction;
@@ -757,10 +737,61 @@ namespace Barotrauma
 
                 return fraction;
             }, rayStart, rayEnd);
-            
+
+            if (allowInsideFixture)
+            {
+                var aabb = new FarseerPhysics.Collision.AABB(rayStart - Vector2.UnitY * 0.001f, rayStart + Vector2.UnitY * 0.001f);
+                GameMain.World.QueryAABB((fixture) =>
+                {
+                    if (bodies.Contains(fixture.Body) || fixture.Body == null) { return false; }
+                    if (!CheckFixtureCollision(fixture, ignoredBodies, collisionCategory, ignoreSensors, customPredicate)) { return false; }
+                    closestFraction = 0.0f;
+                    bodies.Add(fixture.Body);
+                    return true;
+                }, ref aabb);
+            }
+
             return bodies;
         }
 
+        private static bool CheckFixtureCollision(Fixture fixture, IEnumerable<Body> ignoredBodies = null, Category? collisionCategory = null, bool ignoreSensors = true, Predicate<Fixture> customPredicate = null)
+        {
+            if (fixture == null ||
+                (ignoreSensors && fixture.IsSensor) ||
+                fixture.CollisionCategories == Category.None ||
+                fixture.CollisionCategories == Physics.CollisionItem)
+            {
+                return false;
+            }
+
+            if (customPredicate != null && !customPredicate(fixture))
+            {
+                return false;
+            }
+
+            if (collisionCategory != null &&
+                !fixture.CollisionCategories.HasFlag((Category)collisionCategory) &&
+                !((Category)collisionCategory).HasFlag(fixture.CollisionCategories))
+            {
+                return false;
+            }
+
+            if (ignoredBodies != null && ignoredBodies.Contains(fixture.Body))
+            {
+                return false;
+            }
+
+            if (fixture.Body.UserData is Structure structure)
+            {
+                if (structure.IsPlatform && collisionCategory != null && !((Category)collisionCategory).HasFlag(Physics.CollisionPlatform))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// check visibility between two points (in sim units)
         /// </summary>