(77d1794a) Tester's build January 10th, 2020

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Controller.cs

@@ -0,0 +1,102 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Controller : ItemComponent
+    {
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            if (focusTarget != null && character.ViewTarget == focusTarget)
+            {
+                foreach (ItemComponent ic in focusTarget.Components)
+                {
+                    ic.DrawHUD(spriteBatch, character);
+                }
+            }
+        }
+
+        private bool crewAreaOriginalState;
+        private bool chatBoxOriginalState;
+        private bool isHUDsHidden;
+
+        partial void HideHUDs(bool value)
+        {
+            if (isHUDsHidden == value) { return; }
+            if (value == true)
+            {
+                ToggleCrewArea(false, storeOriginalState: true);
+                ToggleChatBox(false, storeOriginalState: true);
+            }
+            else
+            {
+                ToggleCrewArea(crewAreaOriginalState, storeOriginalState: false);
+                ToggleChatBox(chatBoxOriginalState, storeOriginalState: false);
+            }
+            isHUDsHidden = value;
+        }
+
+        private void ToggleCrewArea(bool value, bool storeOriginalState)
+        {
+            var crewManager = GameMain.GameSession?.CrewManager;
+            if (crewManager == null) { return; }
+
+            if (storeOriginalState)
+            {
+                crewAreaOriginalState = crewManager.ToggleCrewAreaOpen;
+            }
+            crewManager.ToggleCrewAreaOpen = value;
+        }
+
+        private void ToggleChatBox(bool value, bool storeOriginalState)
+        {
+            var crewManager = GameMain.GameSession?.CrewManager;
+            if (crewManager == null) { return; }
+
+            if (crewManager.IsSinglePlayer)
+            {
+                if (crewManager.ChatBox != null)
+                {
+                    if (storeOriginalState)
+                    {
+                        chatBoxOriginalState = crewManager.ChatBox.ToggleOpen;
+                    }
+                    crewManager.ChatBox.ToggleOpen = value;
+                }
+            }
+            else if (GameMain.Client != null)
+            {
+                if (storeOriginalState)
+                {
+                    chatBoxOriginalState = GameMain.Client.ChatBox.ToggleOpen;
+                }
+                GameMain.Client.ChatBox.ToggleOpen = value;
+            }
+        }
+
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            state = msg.ReadBoolean();
+            ushort userID = msg.ReadUInt16();
+            if (userID == 0)
+            {
+                if (user != null)
+                {
+                    IsActive = false;
+                    CancelUsing(user);
+                    user = null;
+                }
+            }
+            else
+            {
+                Character newUser = Entity.FindEntityByID(userID) as Character;
+                if (newUser != user)
+                {
+                    CancelUsing(user);
+                }
+                user = newUser;
+                IsActive = true;
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Deconstructor.cs

@@ -0,0 +1,107 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Deconstructor : Powered, IServerSerializable, IClientSerializable
+    {
+        public GUIButton ActivateButton
+        {
+            get { return activateButton; }
+        }
+        private GUIButton activateButton;
+        private GUIComponent inputInventoryHolder, outputInventoryHolder;
+        private GUICustomComponent inputInventoryOverlay;
+
+        private GUIComponent inSufficientPowerWarning;
+
+        private bool pendingState;
+
+        partial void InitProjSpecific(XElement element)
+        {
+            var paddedFrame = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.9f), GuiFrame.RectTransform, Anchor.Center), childAnchor: Anchor.TopCenter)
+            {
+                Stretch = true,
+                RelativeSpacing = 0.02f
+            };
+
+            inputInventoryHolder = new GUIFrame(new RectTransform(new Vector2(0.2f, 0.7f), paddedFrame.RectTransform), style: null);
+            inputInventoryOverlay = new GUICustomComponent(new RectTransform(Vector2.One, inputInventoryHolder.RectTransform), DrawOverLay, null)
+            {
+                CanBeFocused = false
+            };
+
+            activateButton = new GUIButton(new RectTransform(new Vector2(0.8f, 0.1f), paddedFrame.RectTransform),
+                TextManager.Get("DeconstructorDeconstruct"))
+            {
+                OnClicked = ToggleActive
+            };
+
+
+            inSufficientPowerWarning = new GUITextBlock(new RectTransform(Vector2.One, activateButton.RectTransform), TextManager.Get("DeconstructorNoPower"),
+                textColor: Color.Orange, textAlignment: Alignment.Center, color: Color.Black, style: "OuterGlow")
+            {
+                HoverColor = Color.Black,
+                IgnoreLayoutGroups = true,
+                Visible = false,
+                CanBeFocused = false
+            };
+            outputInventoryHolder = new GUIFrame(new RectTransform(new Vector2(1.0f, 0.3f), paddedFrame.RectTransform), style: null);
+        }
+
+        partial void OnItemLoadedProjSpecific()
+        {
+            inputContainer.AllowUIOverlap = true;
+            inputContainer.Inventory.RectTransform = inputInventoryHolder.RectTransform;
+            outputContainer.AllowUIOverlap = true;
+            outputContainer.Inventory.RectTransform = outputInventoryHolder.RectTransform;
+        }
+
+        private void DrawOverLay(SpriteBatch spriteBatch, GUICustomComponent overlayComponent)
+        {
+            overlayComponent.RectTransform.SetAsLastChild();
+            var lastSlot = inputContainer.Inventory.slots.Last();
+
+            GUI.DrawRectangle(spriteBatch, 
+                new Rectangle(
+                    lastSlot.Rect.X, lastSlot.Rect.Y + (int)(lastSlot.Rect.Height * (1.0f - progressState)), 
+                    lastSlot.Rect.Width, (int)(lastSlot.Rect.Height * progressState)), 
+                Color.Green * 0.5f, isFilled: true);
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            inSufficientPowerWarning.Visible = CurrPowerConsumption > 0 && !hasPower;
+        }
+
+        private bool ToggleActive(GUIButton button, object obj)
+        {
+            if (GameMain.Client != null)
+            {
+                pendingState = !IsActive;
+                item.CreateClientEvent(this);
+            }
+            else
+            {
+                SetActive(!IsActive, Character.Controlled);
+                currPowerConsumption = IsActive ? powerConsumption : 0.0f;
+            }
+
+            return true;
+        }
+
+        public void ClientWrite(IWriteMessage msg, object[] extraData = null)
+        {
+            msg.Write(pendingState);
+        }
+
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            SetActive(msg.ReadBoolean());
+            progressTimer = msg.ReadSingle();
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Engine.cs

@@ -0,0 +1,160 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Engine : Powered, IDrawableComponent
+    {
+        private float spriteIndex;
+
+        private SpriteSheet propellerSprite;
+
+        private GUITickBox powerIndicator;
+        private GUIScrollBar forceSlider;
+        private GUITickBox autoControlIndicator;
+
+        public float AnimSpeed
+        {
+            get;
+            private set;
+        }
+
+        public Vector2 DrawSize
+        {
+            //use the extents of the item as the draw size
+            get { return Vector2.Zero; }
+        }
+
+        partial void InitProjSpecific(XElement element)
+        {
+            var content = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.8f), GuiFrame.RectTransform, Anchor.Center))
+            {
+                Stretch = true,
+                RelativeSpacing = 0.05f
+            };
+
+            float indicatorSize = 0.3f;
+            powerIndicator = new GUITickBox(new RectTransform(new Vector2(indicatorSize), content.RectTransform), 
+                TextManager.Get("EnginePowered"), style: "IndicatorLightGreen")
+            {
+                CanBeFocused = false
+            };
+
+            autoControlIndicator = new GUITickBox(new RectTransform(new Vector2(indicatorSize), content.RectTransform), TextManager.Get("PumpAutoControl", fallBackTag: "ReactorAutoControl"), style: "IndicatorLightRed")
+            {
+                CanBeFocused = false
+            };
+
+            string powerLabel = TextManager.Get("EngineForce");
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.25f), content.RectTransform), "", textAlignment: Alignment.Center)
+            {
+                TextGetter = () => { return TextManager.AddPunctuation(':', powerLabel, (int)(targetForce) + " %"); }
+            };
+
+            forceSlider = new GUIScrollBar(new RectTransform(new Vector2(1.0f, 0.3f), content.RectTransform), barSize: 0.15f, style: "GUISlider")
+            {
+                Step = 0.05f,
+                OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+                {
+                    float newTargetForce = barScroll * 200.0f - 100.0f;
+                    if (Math.Abs(newTargetForce - targetForce) < 0.01) return false;
+
+                    targetForce = newTargetForce;
+
+                    if (GameMain.Client != null)
+                    {
+                        correctionTimer = CorrectionDelay;
+                        item.CreateClientEvent(this);
+                    }
+                    return true;
+                }
+            };
+
+            var textArea = new GUILayoutGroup(new RectTransform(new Vector2(1.0f, 0.2f), content.RectTransform), isHorizontal: true)
+            {
+                Stretch = true
+            };
+
+            new GUITextBlock(new RectTransform(new Vector2(0.5f, 1.0f), textArea.RectTransform), TextManager.Get("EngineBackwards"), 
+                font: GUI.SmallFont, textAlignment: Alignment.CenterLeft);
+            new GUITextBlock(new RectTransform(new Vector2(0.5f, 1.0f), textArea.RectTransform), TextManager.Get("EngineForwards"),
+                font: GUI.SmallFont, textAlignment: Alignment.CenterRight);
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "propellersprite":
+                        propellerSprite = new SpriteSheet(subElement);
+                        AnimSpeed = subElement.GetAttributeFloat("animspeed", 1.0f);
+                        break;
+                }
+            }
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            powerIndicator.Selected = hasPower && IsActive;
+            autoControlIndicator.Selected = controlLockTimer > 0.0f;
+            forceSlider.Enabled = controlLockTimer <= 0.0f;
+
+            if (!PlayerInput.PrimaryMouseButtonHeld())
+            {
+                float newScroll = (targetForce + 100.0f) / 200.0f;
+                if (Math.Abs(newScroll - forceSlider.BarScroll) > 0.01f)
+                {
+                    forceSlider.BarScroll = newScroll;
+                }
+            }
+        }
+
+        partial void UpdateAnimation(float deltaTime)
+        {
+            if (propellerSprite == null) return;
+
+            spriteIndex += (force / 100.0f) * AnimSpeed * deltaTime;
+            if (spriteIndex < 0) spriteIndex = propellerSprite.FrameCount;
+            if (spriteIndex >= propellerSprite.FrameCount) spriteIndex = 0.0f;
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing, float itemDepth = -1)
+        {
+            if (propellerSprite != null)
+            {
+                Vector2 drawPos = item.DrawPosition;
+                drawPos += PropellerPos;
+                drawPos.Y = -drawPos.Y;
+
+                propellerSprite.Draw(spriteBatch, (int)Math.Floor(spriteIndex), drawPos, Color.White, propellerSprite.Origin, 0.0f, Vector2.One);
+            }
+
+            if (editing)
+            {
+                Vector2 drawPos = item.DrawPosition;
+                drawPos += PropellerPos;
+                drawPos.Y = -drawPos.Y;
+                GUI.DrawRectangle(spriteBatch, drawPos - Vector2.One * 10, Vector2.One * 20, Color.Red);
+            }
+        }
+
+        public void ClientWrite(IWriteMessage msg, object[] extraData = null)
+        {
+            //targetForce can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger((int)(targetForce / 10.0f), -10, 10);
+        }
+
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            if (correctionTimer > 0.0f)
+            {
+                StartDelayedCorrection(type, msg.ExtractBits(5), sendingTime);
+                return;
+            }
+
+            targetForce = msg.ReadRangedInteger(-10, 10) * 10.0f;
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Fabricator.cs

@@ -0,0 +1,492 @@
+using Barotrauma.Extensions;
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Fabricator : Powered, IServerSerializable, IClientSerializable
+    {
+        private GUIListBox itemList;
+
+        private GUIFrame selectedItemFrame;
+        
+        public GUIButton ActivateButton
+        {
+            get { return activateButton; }
+        }
+        private GUIButton activateButton;
+
+        private GUITextBox itemFilterBox;
+
+        private GUIComponent inputInventoryHolder, outputInventoryHolder;
+        private GUICustomComponent inputInventoryOverlay, outputInventoryOverlay;
+
+        public FabricationRecipe SelectedItem
+        {
+            get { return selectedItem; }
+        }
+        private FabricationRecipe selectedItem;
+
+        private GUIComponent inSufficientPowerWarning;
+
+        private FabricationRecipe pendingFabricatedItem;
+
+        private Pair<Rectangle, string> tooltip;
+
+        partial void InitProjSpecific()
+        {
+            var paddedFrame = new GUILayoutGroup(new RectTransform(new Vector2(0.95f, 0.95f), GuiFrame.RectTransform, Anchor.Center), childAnchor: Anchor.TopCenter)
+            {
+                Stretch = true,
+                RelativeSpacing = 0.02f
+            };
+            
+            itemList = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.5f), paddedFrame.RectTransform))
+            {
+                OnSelected = (GUIComponent component, object userdata) =>
+                {
+                    selectedItem = userdata as FabricationRecipe;
+                    if (selectedItem != null) { SelectItem(Character.Controlled, selectedItem); }
+                    return true;
+                }
+            };
+
+            var filterArea = new GUILayoutGroup(new RectTransform(new Vector2(1.0f, 0.06f), paddedFrame.RectTransform), isHorizontal: true)
+            {
+                Stretch = true,
+                UserData = "filterarea"
+            };
+            new GUITextBlock(new RectTransform(new Vector2(0.25f, 1.0f), filterArea.RectTransform), TextManager.Get("serverlog.filter"), font: GUI.Font);
+            itemFilterBox = new GUITextBox(new RectTransform(new Vector2(0.8f, 1.0f), filterArea.RectTransform), font: GUI.Font);
+            itemFilterBox.OnTextChanged += (textBox, text) => { FilterEntities(text); return true; };
+            var clearButton = new GUIButton(new RectTransform(new Vector2(0.1f, 1.0f), filterArea.RectTransform), "x")
+            {
+                OnClicked = (btn, userdata) => { ClearFilter(); itemFilterBox.Flash(Color.White); return true; }
+            };
+
+            inputInventoryHolder = new GUIFrame(new RectTransform(new Vector2(0.7f, 0.15f), paddedFrame.RectTransform), style: null);
+            inputInventoryOverlay = new GUICustomComponent(new RectTransform(Vector2.One, inputInventoryHolder.RectTransform), DrawInputOverLay, null)
+            {
+                CanBeFocused = false
+            };
+
+            var outputArea = new GUILayoutGroup(new RectTransform(new Vector2(0.95f, 0.25f), paddedFrame.RectTransform), isHorizontal: true);
+
+            selectedItemFrame = new GUIFrame(new RectTransform(new Vector2(0.75f, 1.0f), outputArea.RectTransform), style: "InnerFrame");
+            outputInventoryHolder = new GUIFrame(new RectTransform(new Vector2(0.25f, 1.0f), outputArea.RectTransform), style: null);
+            outputInventoryOverlay = new GUICustomComponent(new RectTransform(Vector2.One, outputArea.RectTransform), DrawOutputOverLay, null)
+            {
+                CanBeFocused = false
+            };
+
+            CreateRecipes();
+
+            activateButton = new GUIButton(new RectTransform(new Vector2(0.8f, 0.07f), paddedFrame.RectTransform),
+                TextManager.Get("FabricatorCreate"), style: "GUIButtonLarge")
+            {
+                OnClicked = StartButtonClicked,
+                UserData = selectedItem,
+                Enabled = false
+            };
+
+            inSufficientPowerWarning = new GUITextBlock(new RectTransform(Vector2.One, activateButton.RectTransform), TextManager.Get("FabricatorNoPower"),
+                textColor: Color.Orange, textAlignment: Alignment.Center, color: Color.Black, style: "OuterGlow")
+            {
+                HoverColor = Color.Black,
+                IgnoreLayoutGroups = true,
+                Visible = false,
+                CanBeFocused = false
+            };
+        }
+
+        partial void CreateRecipes()
+        {
+            itemList.Content.RectTransform.ClearChildren();
+
+            foreach (FabricationRecipe fi in fabricationRecipes)
+            {
+                GUIFrame frame = new GUIFrame(new RectTransform(new Point(itemList.Rect.Width, (int)(30 * GUI.yScale)), itemList.Content.RectTransform), style: null)
+                {
+                    UserData = fi,
+                    HoverColor = Color.Gold * 0.2f,
+                    SelectedColor = Color.Gold * 0.5f,
+                    ToolTip = fi.TargetItem.Description
+                };
+
+                GUITextBlock textBlock = new GUITextBlock(new RectTransform(Vector2.Zero, frame.RectTransform, Anchor.CenterLeft) { AbsoluteOffset = new Point((int)(50 * GUI.xScale), 0) },
+                    fi.DisplayName)
+                {
+                    ToolTip = fi.TargetItem.Description
+                };
+
+                var itemIcon = fi.TargetItem.InventoryIcon ?? fi.TargetItem.sprite;
+                if (itemIcon != null)
+                {
+                    GUIImage img = new GUIImage(new RectTransform(new Point((int)(30 * GUI.Scale)), frame.RectTransform, Anchor.CenterLeft) { AbsoluteOffset = new Point((int)(3 * GUI.xScale), 0) },
+                        itemIcon, scaleToFit: true)
+                    {
+                        Color = fi.TargetItem.InventoryIconColor,
+                        ToolTip = fi.TargetItem.Description
+                    };
+                }
+            }
+        }
+
+        partial void OnItemLoadedProjSpecific()
+        {
+            inputContainer.AllowUIOverlap = true;
+            inputContainer.Inventory.RectTransform = inputInventoryHolder.RectTransform;
+            outputContainer.AllowUIOverlap = true;
+            outputContainer.Inventory.RectTransform = outputInventoryHolder.RectTransform;
+        }
+
+        partial void SelectProjSpecific(Character character)
+        {
+            var nonItems = itemList.Content.Children.Where(c => !(c.UserData is FabricationRecipe)).ToList();
+            nonItems.ForEach(i => itemList.Content.RemoveChild(i));
+
+            itemList.Content.RectTransform.SortChildren((c1, c2) =>
+            {
+                var item1 = c1.GUIComponent.UserData as FabricationRecipe;
+                var item2 = c2.GUIComponent.UserData as FabricationRecipe;
+
+                bool hasSkills1 = DegreeOfSuccess(character, item1.RequiredSkills) >= 0.5f;
+                bool hasSkills2 = DegreeOfSuccess(character, item2.RequiredSkills) >= 0.5f;
+
+                if (hasSkills1 != hasSkills2)
+                {
+                    return hasSkills1 ? -1 : 1;
+                }
+
+                return string.Compare(item1.DisplayName, item2.DisplayName);
+            });
+
+            var sufficientSkillsText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.15f), itemList.Content.RectTransform),
+                TextManager.Get("fabricatorsufficientskills", returnNull: true) ?? "Sufficient skills to fabricate", textColor: Color.LightGreen)
+            {
+                CanBeFocused = false
+            };
+            sufficientSkillsText.RectTransform.SetAsFirstChild();
+
+            var insufficientSkillsText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.15f), itemList.Content.RectTransform),
+                TextManager.Get("fabricatorinsufficientskills", returnNull: true) ?? "Insufficient skills to fabricate", textColor: Color.Orange)
+            {
+                CanBeFocused = false
+            };
+            var firstinSufficient = itemList.Content.Children.FirstOrDefault(c => c.UserData is FabricationRecipe fabricableItem && DegreeOfSuccess(character, fabricableItem.RequiredSkills) < 0.5f);
+            if (firstinSufficient != null)
+            {
+                insufficientSkillsText.RectTransform.RepositionChildInHierarchy(itemList.Content.RectTransform.GetChildIndex(firstinSufficient.RectTransform));
+            }
+        }
+
+        private void DrawInputOverLay(SpriteBatch spriteBatch, GUICustomComponent overlayComponent)
+        {
+            overlayComponent.RectTransform.SetAsLastChild();
+
+            FabricationRecipe targetItem = fabricatedItem ?? selectedItem;
+            if (targetItem != null)
+            {
+                int slotIndex = 0;
+
+                var missingItems = new List<FabricationRecipe.RequiredItem>();
+                foreach (FabricationRecipe.RequiredItem requiredItem in targetItem.RequiredItems)
+                {
+                    for (int i = 0; i < requiredItem.Amount; i++)
+                    {
+                        missingItems.Add(requiredItem);
+                    }
+                }
+                foreach (Item item in inputContainer.Inventory.Items)
+                {
+                    if (item == null) { continue; }
+                    missingItems.Remove(missingItems.FirstOrDefault(mi => mi.ItemPrefab == item.prefab));
+                }
+
+                var availableIngredients = GetAvailableIngredients();
+
+                foreach (FabricationRecipe.RequiredItem requiredItem in missingItems)
+                {
+                    //highlight suitable ingredients in linked inventories
+                    foreach (Item item in availableIngredients)
+                    {
+                        if (item.ParentInventory != inputContainer.Inventory && IsItemValidIngredient(item, requiredItem))
+                        {
+                            int availableSlotIndex = Array.IndexOf(item.ParentInventory.Items, item);
+                            //slots are null if the inventory has never been displayed 
+                            //(linked item, but the UI is not set to be displayed at the same time)
+                            if (item.ParentInventory.slots != null)
+                            {
+                                if (item.ParentInventory.slots[availableSlotIndex].HighlightTimer <= 0.0f)
+                                {
+                                    item.ParentInventory.slots[availableSlotIndex].ShowBorderHighlight(Color.LightGreen * 0.5f, 0.5f, 0.5f);
+                                }
+                            }
+                        }
+                    }
+
+                    while (slotIndex < inputContainer.Capacity && inputContainer.Inventory.Items[slotIndex] != null)
+                    {
+                        slotIndex++;
+                    }
+                    if (slotIndex >= inputContainer.Capacity) { break; }
+
+                    var itemIcon = requiredItem.ItemPrefab.InventoryIcon ?? requiredItem.ItemPrefab.sprite;
+
+                    Rectangle slotRect = inputContainer.Inventory.slots[slotIndex].Rect;
+
+                    itemIcon.Draw(
+                        spriteBatch,
+                        slotRect.Center.ToVector2(),
+                        color: requiredItem.ItemPrefab.InventoryIconColor * (availableIngredients.Any(i => IsItemValidIngredient(i, requiredItem)) ? 1.0f : 0.3f),
+                        scale: Math.Min(slotRect.Width / itemIcon.size.X, slotRect.Height / itemIcon.size.Y));
+                    
+                    if (slotRect.Contains(PlayerInput.MousePosition))
+                    {
+                        string toolTipText = requiredItem.ItemPrefab.Name;
+                        if (!string.IsNullOrEmpty(requiredItem.ItemPrefab.Description))
+                        {
+                            toolTipText += '\n' + requiredItem.ItemPrefab.Description;
+                        }
+                        tooltip = new Pair<Rectangle, string>(slotRect, toolTipText);
+                    }
+
+                    slotIndex++;
+                }
+            }
+        }
+
+        private void DrawOutputOverLay(SpriteBatch spriteBatch, GUICustomComponent overlayComponent)
+        {
+            overlayComponent.RectTransform.SetAsLastChild();
+            
+            FabricationRecipe targetItem = fabricatedItem ?? selectedItem;
+            if (targetItem != null)
+            {
+                var itemIcon = targetItem.TargetItem.InventoryIcon ?? targetItem.TargetItem.sprite;
+
+                Rectangle slotRect = outputContainer.Inventory.slots[0].Rect;
+
+                if (fabricatedItem != null)
+                {
+                    GUI.DrawRectangle(spriteBatch,
+                        new Rectangle(
+                            slotRect.X, slotRect.Y + (int)(slotRect.Height * (1.0f - progressState)),
+                            slotRect.Width, (int)(slotRect.Height * progressState)),
+                        Color.Green * 0.5f, isFilled: true);
+                }
+
+                itemIcon.Draw(
+                    spriteBatch,
+                    slotRect.Center.ToVector2(),
+                    color: targetItem.TargetItem.InventoryIconColor * 0.4f,
+                    scale: Math.Min(slotRect.Width / itemIcon.size.X, slotRect.Height / itemIcon.size.Y) * 0.9f);
+            }
+            
+            if (tooltip != null)
+            {
+                GUIComponent.DrawToolTip(spriteBatch, tooltip.Second, tooltip.First);
+                tooltip = null;
+            }
+        }
+
+        private bool FilterEntities(string filter)
+        {
+            if (string.IsNullOrWhiteSpace(filter))
+            {
+                itemList.Content.Children.ForEach(c => c.Visible = true);
+                return true;
+            }
+
+            filter = filter.ToLower();
+            foreach (GUIComponent child in itemList.Content.Children)
+            {
+                FabricationRecipe recipe = child.UserData as FabricationRecipe;
+                if (recipe?.DisplayName == null) { continue; }
+                child.Visible = recipe.DisplayName.ToLower().Contains(filter);
+            }
+            itemList.UpdateScrollBarSize();
+            itemList.BarScroll = 0.0f;
+
+            return true;
+        }
+
+        public bool ClearFilter()
+        {
+            FilterEntities("");
+            itemList.UpdateScrollBarSize();
+            itemList.BarScroll = 0.0f;
+            itemFilterBox.Text = "";
+            return true;
+        }
+
+        private bool SelectItem(Character user, FabricationRecipe selectedItem)
+        {
+            selectedItemFrame.ClearChildren();
+            
+            var paddedFrame = new GUILayoutGroup(new RectTransform(new Vector2(0.95f, 0.9f), selectedItemFrame.RectTransform, Anchor.Center)) { RelativeSpacing = 0.03f, Stretch = true };
+
+            /*var itemIcon = selectedItem.TargetItem.InventoryIcon ?? selectedItem.TargetItem.sprite;
+            if (itemIcon != null)
+            {
+                GUIImage img = new GUIImage(new RectTransform(new Point(40, 40), paddedFrame.RectTransform),
+                    itemIcon, scaleToFit: true)
+                {
+                    Color = selectedItem.TargetItem.InventoryIconColor
+                };
+            }*/
+            var nameBlock = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), paddedFrame.RectTransform),
+                selectedItem.TargetItem.Name, textAlignment: Alignment.CenterLeft);
+
+            if (!string.IsNullOrWhiteSpace(selectedItem.TargetItem.Description))
+            {
+                var description = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), paddedFrame.RectTransform),
+                    selectedItem.TargetItem.Description,
+                    font: GUI.SmallFont, wrap: true);
+                if (description.Rect.Height > paddedFrame.Rect.Height * 0.4f)
+                {
+                    description.Wrap = false;
+                    description.Text = description.WrappedText.Split('\n').First()+"...";
+                    nameBlock.ToolTip = description.ToolTip = selectedItem.TargetItem.Description;
+                    description.RectTransform.MaxSize = new Point(int.MaxValue, (int)description.Font.MeasureString(description.Text).Y);
+                }
+            }
+            
+            List<Skill> inadequateSkills = new List<Skill>();
+            if (user != null)
+            {
+                inadequateSkills = selectedItem.RequiredSkills.FindAll(skill => user.GetSkillLevel(skill.Identifier) < skill.Level);
+            }
+            
+            if (selectedItem.RequiredSkills.Any())
+            {
+                string text = TextManager.Get("FabricatorRequiredSkills") + ":\n";
+                foreach (Skill skill in selectedItem.RequiredSkills)
+                {
+                    text += "   - " + TextManager.Get("SkillName." + skill.Identifier) + " " + TextManager.Get("Lvl").ToLower() + " " + skill.Level;
+                    if (skill != selectedItem.RequiredSkills.Last()) { text += "\n"; }
+                }
+                new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), paddedFrame.RectTransform), text,
+                    textColor: inadequateSkills.Any() ? Color.Red : Color.LightGreen, font: GUI.SmallFont);
+            }
+
+            float degreeOfSuccess = user == null ? 0.0f : DegreeOfSuccess(user, selectedItem.RequiredSkills);
+            if (degreeOfSuccess > 0.5f) { degreeOfSuccess = 1.0f; }
+
+            float requiredTime = user == null ? selectedItem.RequiredTime : GetRequiredTime(selectedItem, user);
+            string requiredTimeText = TextManager.AddPunctuation(':', TextManager.Get("FabricatorRequiredTime"), ToolBox.SecondsToReadableTime(requiredTime));
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), paddedFrame.RectTransform),
+                requiredTimeText, textColor: ToolBox.GradientLerp(degreeOfSuccess, Color.Red, Color.Yellow, Color.LightGreen), font: GUI.SmallFont);
+                        
+            return true;
+        }
+
+        public void HighlightRecipe(string identifier, Color color)
+        {
+            foreach (GUIComponent child in itemList.Content.Children)
+            {
+                FabricationRecipe recipe = child.UserData as FabricationRecipe;
+                if (recipe?.DisplayName == null) { continue; }
+                if (recipe.TargetItem.Identifier == identifier)
+                {
+                    if (child.FlashTimer > 0.0f) return;
+                    child.Flash(color, 1.5f, false);
+
+                    for (int i = 0; i < child.CountChildren; i++)
+                    {
+                        var grandChild = child.GetChild(i);
+                        if (grandChild is GUITextBlock) continue;
+                        grandChild.Flash(color, 1.5f, false);
+                    }
+
+                    return;
+                }
+            }
+        }
+        
+        private bool StartButtonClicked(GUIButton button, object obj)
+        {
+            if (selectedItem == null) { return false; }
+            if (!outputContainer.Inventory.IsEmpty())
+            {
+                outputInventoryHolder.Flash(Color.Red);
+                return false;
+            }
+            
+            if (GameMain.Client != null)
+            {
+                pendingFabricatedItem = fabricatedItem != null ? null : selectedItem;
+                item.CreateClientEvent(this);
+            }
+            else
+            {
+                if (fabricatedItem == null)
+                {
+                    StartFabricating(selectedItem, Character.Controlled);
+                }
+                else
+                {
+                    CancelFabricating(Character.Controlled);
+                }
+            }
+
+            return true;
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            activateButton.Enabled = false;
+            inSufficientPowerWarning.Visible = currPowerConsumption > 0 && !hasPower;
+
+            var availableIngredients = GetAvailableIngredients();
+            if (character != null)
+            {
+                foreach (GUIComponent child in itemList.Content.Children)
+                {
+                    var itemPrefab = child.UserData as FabricationRecipe;
+                    if (itemPrefab == null) continue;
+
+                    bool canBeFabricated = CanBeFabricated(itemPrefab, availableIngredients);
+                    if (itemPrefab == selectedItem)
+                    {
+                        activateButton.Enabled = canBeFabricated;
+                    }
+
+                    child.GetChild<GUITextBlock>().TextColor = Color.White * (canBeFabricated ? 1.0f : 0.5f);
+                    child.GetChild<GUIImage>().Color = itemPrefab.TargetItem.InventoryIconColor * (canBeFabricated ? 1.0f : 0.5f);
+                }
+            }
+        }
+
+        public void ClientWrite(IWriteMessage msg, object[] extraData = null)
+        {
+            int itemIndex = pendingFabricatedItem == null ? -1 : fabricationRecipes.IndexOf(pendingFabricatedItem);
+            msg.WriteRangedInteger(itemIndex, -1, fabricationRecipes.Count - 1);
+        }
+
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            int itemIndex = msg.ReadRangedInteger(-1, fabricationRecipes.Count - 1);
+            UInt16 userID = msg.ReadUInt16();
+            Character user = Entity.FindEntityByID(userID) as Character;
+
+            if (itemIndex == -1 || user == null)
+            {
+                CancelFabricating();
+            }
+            else
+            {
+                //if already fabricating the selected item, return
+                if (fabricatedItem != null && fabricationRecipes.IndexOf(fabricatedItem) == itemIndex) { return; }
+                if (itemIndex < 0 || itemIndex >= fabricationRecipes.Count) { return; }
+
+                SelectItem(user, fabricationRecipes[itemIndex]);
+                StartFabricating(fabricationRecipes[itemIndex], user);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/MiniMap.cs

@@ -0,0 +1,327 @@
+using Barotrauma.Extensions;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class MiniMap : Powered
+    {
+        private GUIFrame submarineContainer;
+
+        private GUIFrame hullInfoFrame;
+
+        private GUITextBlock hullNameText, hullBreachText, hullAirQualityText, hullWaterText;
+
+        private string noPowerTip = "";
+
+        private List<Submarine> displayedSubs = new List<Submarine>();
+
+        partial void InitProjSpecific(XElement element)
+        {
+            noPowerTip = TextManager.Get("SteeringNoPowerTip");
+
+            GuiFrame.RectTransform.RelativeOffset = new Vector2(0.05f, 0.0f);
+            new GUICustomComponent(new RectTransform(new Vector2(0.95f, 0.9f), GuiFrame.RectTransform, Anchor.Center),
+                DrawHUDBack, null);
+            submarineContainer = new GUIFrame(new RectTransform(new Vector2(0.95f, 0.9f), GuiFrame.RectTransform, Anchor.Center), style: null);
+
+            new GUICustomComponent(new RectTransform(new Vector2(0.95f, 0.9f), GuiFrame.RectTransform, Anchor.Center),
+                DrawHUDFront, null)
+            {
+                CanBeFocused = false
+            };
+
+            hullInfoFrame = new GUIFrame(new RectTransform(new Vector2(0.13f, 0.13f), GUI.Canvas, minSize: new Point(250, 150)),
+                style: "InnerFrame")
+            {
+                CanBeFocused = false
+            };
+            var hullInfoContainer = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.9f), hullInfoFrame.RectTransform, Anchor.Center))
+            {
+                Stretch = true,
+                RelativeSpacing = 0.05f
+            };
+
+            hullNameText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.4f), hullInfoContainer.RectTransform), "") { Wrap = true };
+            hullBreachText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.3f), hullInfoContainer.RectTransform), "") { Wrap = true };
+            hullAirQualityText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.3f), hullInfoContainer.RectTransform), "") { Wrap = true };
+            hullWaterText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.3f), hullInfoContainer.RectTransform), "") { Wrap = true };
+
+            hullInfoFrame.Children.ForEach(c => { c.CanBeFocused = false; c.Children.ForEach(c2 => c2.CanBeFocused = false); });
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            base.AddToGUIUpdateList();
+            hullInfoFrame.AddToGUIUpdateList();
+        }
+
+        public override void OnMapLoaded()
+        {
+            base.OnMapLoaded();
+            CreateHUD();
+        }
+
+        private void CreateHUD()
+        {
+            submarineContainer.ClearChildren();
+
+            if (item.Submarine == null) return;
+
+            item.Submarine.CreateMiniMap(submarineContainer);
+            displayedSubs.Clear();
+            displayedSubs.Add(item.Submarine);
+            displayedSubs.AddRange(item.Submarine.DockedTo);
+        }
+
+        public override void FlipX(bool relativeToSub)
+        {
+            CreateHUD();
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            //recreate HUD if the subs we should display have changed
+            if ((item.Submarine == null && displayedSubs.Count > 0) ||              //item not inside a sub anymore, but display is still showing subs
+                !displayedSubs.Contains(item.Submarine) ||                          //current sub not displayer
+                item.Submarine.DockedTo.Any(s => !displayedSubs.Contains(s)) ||     //some of the docked subs not diplayed
+                displayedSubs.Any(s => s != item.Submarine && !item.Submarine.DockedTo.Contains(s))) //displaying a sub that shouldn't be displayed
+            {
+                CreateHUD();
+            }
+            
+            float distort = 1.0f - item.Condition / item.MaxCondition;
+            foreach (HullData hullData in hullDatas.Values)
+            {
+                hullData.DistortionTimer -= deltaTime;
+                if (hullData.DistortionTimer <= 0.0f)
+                {
+                    hullData.Distort = Rand.Range(0.0f, 1.0f) < distort * distort;
+                    if (hullData.Distort)
+                    {
+                        hullData.Oxygen = Rand.Range(0.0f, 100.0f);
+                        hullData.Water = Rand.Range(0.0f, 1.0f);
+                    }
+                    hullData.DistortionTimer = Rand.Range(1.0f, 10.0f);
+                }
+            }
+        }
+
+        private void DrawHUDFront(SpriteBatch spriteBatch, GUICustomComponent container)
+        {
+            if (Voltage < MinVoltage)
+        {
+                Vector2 textSize = GUI.Font.MeasureString(noPowerTip);
+                Vector2 textPos = GuiFrame.Rect.Center.ToVector2();
+
+                GUI.DrawString(spriteBatch, textPos - textSize / 2, noPowerTip,
+                    Color.Orange * (float)Math.Abs(Math.Sin(Timing.TotalTime)), Color.Black * 0.8f);
+                return;
+            }
+
+            foreach (GUIComponent child in submarineContainer.Children.First().Children)
+            {
+                if (child.UserData is Hull hull)
+                {
+                    if (hull.Submarine == null || !hull.Submarine.IsOutpost) { continue; }
+                    string text = TextManager.GetWithVariable("MiniMapOutpostDockingInfo", "[outpost]", hull.Submarine.Name);
+                    Vector2 textSize = GUI.Font.MeasureString(text);
+                    Vector2 textPos = child.Center;
+                    if (textPos.X + textSize.X / 2 > submarineContainer.Rect.Right)
+                        textPos.X -= ((textPos.X + textSize.X / 2) - submarineContainer.Rect.Right) + 10 * GUI.xScale;
+                    if (textPos.X - textSize.X / 2 < submarineContainer.Rect.X)
+                        textPos.X += (submarineContainer.Rect.X - (textPos.X - textSize.X / 2)) + 10 * GUI.xScale;
+                    GUI.DrawString(spriteBatch, textPos - textSize / 2, text,
+                       Color.Orange * (float)Math.Abs(Math.Sin(Timing.TotalTime)), Color.Black * 0.8f);
+                    break;
+                }
+            }            
+        }
+
+        private void DrawHUDBack(SpriteBatch spriteBatch, GUICustomComponent container)
+        {
+            Hull mouseOnHull = null;
+            hullInfoFrame.Visible = false;
+
+            foreach (Hull hull in Hull.hullList)
+            {
+                var hullFrame = submarineContainer.Children.First().FindChild(hull);
+                if (hullFrame == null) { continue; }
+
+                if (GUI.MouseOn == hullFrame || hullFrame.IsParentOf(GUI.MouseOn))
+                {
+                    mouseOnHull = hull;
+                }
+                if (item.Submarine == null || !hasPower)
+                {
+                    hullFrame.Color = Color.DarkCyan * 0.3f;
+                    hullFrame.Children.First().Color = Color.DarkCyan * 0.3f;
+                }
+            }
+
+            if (Voltage < MinVoltage)
+            {
+                return;
+            }
+
+            float scale = 1.0f;
+            HashSet<Submarine> subs = new HashSet<Submarine>();
+            foreach (Hull hull in Hull.hullList)
+            {
+                if (hull.Submarine == null) continue;
+                var hullFrame = submarineContainer.Children.First().FindChild(hull);
+                if (hullFrame == null) continue;
+
+                hullDatas.TryGetValue(hull, out HullData hullData);
+                if (hullData == null)
+                {
+                    hullData = new HullData();
+                    GetLinkedHulls(hull, hullData.LinkedHulls);
+                    hullDatas.Add(hull, hullData);
+                }
+                
+                Color neutralColor = Color.DarkCyan;
+                if (hull.RoomName != null)
+                {
+                    if (hull.RoomName.Contains("ballast") || hull.RoomName.Contains("Ballast") ||
+                        hull.RoomName.Contains("airlock") || hull.RoomName.Contains("Airlock"))
+                    {
+                        neutralColor = new Color(9, 80, 159);
+                    }
+                }
+
+                if (hullData.Distort)
+                {
+                    hullFrame.Children.First().Color = Color.Lerp(Color.Black, Color.DarkGray * 0.5f, Rand.Range(0.0f, 1.0f));
+                    hullFrame.Color = neutralColor * 0.5f;
+                    continue;
+                }
+                
+                subs.Add(hull.Submarine);
+                scale = Math.Min(
+                    hullFrame.Parent.Rect.Width / (float)hull.Submarine.Borders.Width, 
+                    hullFrame.Parent.Rect.Height / (float)hull.Submarine.Borders.Height);
+                
+                Color borderColor = neutralColor;
+                
+                float? gapOpenSum = 0.0f;
+                if (ShowHullIntegrity)
+                {
+                    gapOpenSum = hull.ConnectedGaps.Where(g => !g.IsRoomToRoom).Sum(g => g.Open);
+                    borderColor = Color.Lerp(neutralColor, Color.Red, Math.Min((float)gapOpenSum, 1.0f));
+                }
+
+                float? oxygenAmount = null;
+                if (!RequireOxygenDetectors || hullData?.Oxygen != null)
+                {
+                    oxygenAmount = RequireOxygenDetectors ? hullData.Oxygen : hull.OxygenPercentage;
+                    GUI.DrawRectangle(
+                        spriteBatch, hullFrame.Rect, 
+                        Color.Lerp(Color.Red * 0.5f, Color.Green * 0.3f, (float)oxygenAmount / 100.0f), 
+                        true);
+                }
+
+                float? waterAmount = null;
+                if (!RequireWaterDetectors || hullData.Water != null)
+                {
+                    waterAmount = RequireWaterDetectors ? hullData.Water : Math.Min(hull.WaterVolume / hull.Volume, 1.0f);
+                    if (hullFrame.Rect.Height * waterAmount > 3.0f)
+                    {
+                        Rectangle waterRect = new Rectangle(
+                            hullFrame.Rect.X, (int)(hullFrame.Rect.Y + hullFrame.Rect.Height * (1.0f - waterAmount)),
+                            hullFrame.Rect.Width, (int)(hullFrame.Rect.Height * waterAmount));
+
+                        waterRect.Inflate(-3, -3);
+
+                        GUI.DrawRectangle(spriteBatch, waterRect, new Color(85, 136, 147), true);
+                        GUI.DrawLine(spriteBatch, new Vector2(waterRect.X, waterRect.Y), new Vector2(waterRect.Right, waterRect.Y), Color.LightBlue);
+                    }
+                }
+
+                if (mouseOnHull == hull ||
+                    hullData.LinkedHulls.Contains(mouseOnHull))
+                {
+                    borderColor = Color.Lerp(borderColor, Color.White, 0.5f);
+                    hullFrame.Children.First().Color = Color.White;
+                    hullFrame.Color = borderColor;
+                }
+                else
+                {
+                    hullFrame.Children.First().Color = neutralColor * 0.8f;
+                }
+
+                if (mouseOnHull == hull)
+                {                    
+                    hullInfoFrame.RectTransform.ScreenSpaceOffset = hullFrame.Rect.Center;
+                    hullInfoFrame.Visible = true;
+                    hullNameText.Text = hull.DisplayName;
+
+                    foreach (Hull linkedHull in hullData.LinkedHulls)
+                    {
+                        gapOpenSum += linkedHull.ConnectedGaps.Where(g => !g.IsRoomToRoom).Sum(g => g.Open);
+                        oxygenAmount += linkedHull.OxygenPercentage;
+                        waterAmount += Math.Min(linkedHull.WaterVolume / linkedHull.Volume, 1.0f);
+                    }
+                    oxygenAmount /= (hullData.LinkedHulls.Count + 1);
+                    waterAmount /= (hullData.LinkedHulls.Count + 1);
+
+                    hullBreachText.Text = gapOpenSum > 0.1f ? TextManager.Get("MiniMapHullBreach") : "";
+                    hullBreachText.TextColor = Color.Red;
+
+                    hullAirQualityText.Text = oxygenAmount == null ? TextManager.Get("MiniMapAirQualityUnavailable") :
+                        TextManager.AddPunctuation(':', TextManager.Get("MiniMapAirQuality"), + (int)oxygenAmount + " %");
+                    hullAirQualityText.TextColor = oxygenAmount == null ? Color.Red : Color.Lerp(Color.Red, Color.LightGreen, (float)oxygenAmount / 100.0f);
+
+                    hullWaterText.Text = waterAmount == null ? TextManager.Get("MiniMapWaterLevelUnavailable") : 
+                        TextManager.AddPunctuation(':', TextManager.Get("MiniMapWaterLevel"), (int)(waterAmount * 100.0f) + " %");
+                    hullWaterText.TextColor = waterAmount == null ? Color.Red : Color.Lerp(Color.LightGreen, Color.Red, (float)waterAmount);
+                }
+                
+                hullFrame.Color = borderColor;
+            }
+            
+            foreach (Submarine sub in subs)
+            {
+                if (sub.HullVertices == null) { continue; }
+                
+                Rectangle worldBorders = sub.GetDockedBorders();
+                worldBorders.Location += sub.WorldPosition.ToPoint();
+                
+                scale = Math.Min(
+                    submarineContainer.Rect.Width / (float)worldBorders.Width,
+                    submarineContainer.Rect.Height / (float)worldBorders.Height) * 0.9f;
+
+                float displayScale = ConvertUnits.ToDisplayUnits(scale);
+                Vector2 offset = ConvertUnits.ToSimUnits(sub.WorldPosition - new Vector2(worldBorders.Center.X, worldBorders.Y - worldBorders.Height / 2));
+                Vector2 center = container.Rect.Center.ToVector2();
+                
+                for (int i = 0; i < sub.HullVertices.Count; i++)
+                {
+                    Vector2 start = (sub.HullVertices[i] + offset) * displayScale;
+                    start.Y = -start.Y;
+                    Vector2 end = (sub.HullVertices[(i + 1) % sub.HullVertices.Count] + offset) * displayScale;
+                    end.Y = -end.Y;
+                    GUI.DrawLine(spriteBatch, center + start, center + end, Color.DarkCyan * Rand.Range(0.3f, 0.35f), width: (int)(10 * GUI.Scale));
+                }
+            }
+        }
+
+        private void GetLinkedHulls(Hull hull, List<Hull> linkedHulls)
+        {
+            foreach (var linkedEntity in hull.linkedTo)
+            {
+                if (linkedEntity is Hull linkedHull)
+                {
+                    if (linkedHulls.Contains(linkedHull)) { continue; }
+                    linkedHulls.Add(linkedHull);
+                    GetLinkedHulls(linkedHull, linkedHulls);
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Pump.cs

@@ -0,0 +1,199 @@
+using Barotrauma.Networking;
+using Barotrauma.Particles;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Pump : Powered, IServerSerializable, IClientSerializable
+    {
+        public GUIScrollBar IsActiveSlider { get; private set; }
+
+        private GUIScrollBar pumpSpeedSlider;
+        private GUITickBox powerIndicator;
+        private GUITickBox autoControlIndicator;
+
+        private List<Pair<Vector2, ParticleEmitter>> pumpOutEmitters = new List<Pair<Vector2, ParticleEmitter>>(); 
+        private List<Pair<Vector2, ParticleEmitter>> pumpInEmitters = new List<Pair<Vector2, ParticleEmitter>>(); 
+
+        partial void InitProjSpecific(XElement element)
+        {
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "pumpoutemitter":
+                        pumpOutEmitters.Add(new Pair<Vector2, ParticleEmitter>(
+                            subElement.GetAttributeVector2("position", Vector2.Zero), 
+                            new ParticleEmitter(subElement)));
+                        break;
+                    case "pumpinemitter":
+                        pumpInEmitters.Add(new Pair<Vector2, ParticleEmitter>(
+                            subElement.GetAttributeVector2("position", Vector2.Zero),
+                            new ParticleEmitter(subElement)));
+                        break;
+                }
+            }
+
+            if (GuiFrame == null) { return; }
+
+            GUIFrame paddedFrame = new GUIFrame(new RectTransform(new Vector2(0.9f, 0.8f), GuiFrame.RectTransform, Anchor.Center), style: null);
+
+            IsActiveSlider = new GUIScrollBar(new RectTransform(new Point((int)(50 * GUI.Scale), (int)(100 * GUI.Scale)), paddedFrame.RectTransform, Anchor.CenterLeft),
+                barSize: 0.2f, style: "OnOffLever")
+            {
+                IsBooleanSwitch = true,
+                MinValue = 0.25f,
+                MaxValue = 0.75f
+            };
+            var sliderHandle = IsActiveSlider.GetChild<GUIButton>();
+            sliderHandle.RectTransform.NonScaledSize = new Point((int)(84 * GUI.Scale), sliderHandle.Rect.Height);
+            IsActiveSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                bool active = scrollBar.BarScroll < 0.5f;
+                if (active == IsActive) return false;
+
+                targetLevel = null;
+                IsActive = active;
+                if (!IsActive) currPowerConsumption = 0.0f;
+
+                if (GameMain.Client != null)
+                {
+                    correctionTimer = CorrectionDelay;
+                    item.CreateClientEvent(this);
+                }
+
+                return true;
+            };
+
+            var rightArea = new GUILayoutGroup(new RectTransform(new Vector2(0.75f, 0.95f), paddedFrame.RectTransform, Anchor.CenterRight))
+            {
+                RelativeSpacing = 0.1f,
+                Stretch = true
+            };
+
+            powerIndicator = new GUITickBox(new RectTransform(new Point((int)(30 * GUI.Scale)), rightArea.RectTransform), TextManager.Get("PumpPowered"), style: "IndicatorLightGreen")
+            {
+                CanBeFocused = false
+            };
+            autoControlIndicator = new GUITickBox(new RectTransform(new Point((int)(30 * GUI.Scale)), rightArea.RectTransform), TextManager.Get("PumpAutoControl", fallBackTag: "ReactorAutoControl"), style: "IndicatorLightRed")
+            {
+                CanBeFocused = false
+            };
+
+            var pumpSpeedText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.2f), rightArea.RectTransform) { RelativeOffset = new Vector2(0.0f, 0.0f) },
+                "", textAlignment: Alignment.BottomLeft, wrap: true);
+            string pumpSpeedStr = TextManager.Get("PumpSpeed");
+            pumpSpeedText.TextGetter = () => { return TextManager.AddPunctuation(':', pumpSpeedStr, (int)flowPercentage + " %"); };
+
+            var sliderArea = new GUILayoutGroup(new RectTransform(new Vector2(1.0f, 0.3f), rightArea.RectTransform, Anchor.CenterLeft), isHorizontal: true)
+            {
+                Stretch = true,
+                RelativeSpacing = 0.01f
+            };
+
+            var outLabel = new GUITextBlock(new RectTransform(new Vector2(0.25f, 1.0f), sliderArea.RectTransform),
+                TextManager.Get("PumpOut"), textAlignment: Alignment.Center, wrap: false, font: GUI.SmallFont);
+            pumpSpeedSlider = new GUIScrollBar(new RectTransform(new Vector2(0.5f, 1.0f), sliderArea.RectTransform), barSize: 0.25f, style: "GUISlider")
+            {
+                Step = 0.05f,
+                OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+                {
+                    float newValue = barScroll * 200.0f - 100.0f;
+                    if (Math.Abs(newValue - FlowPercentage) < 0.1f) return false;
+
+                    FlowPercentage = newValue;
+
+                    if (GameMain.Client != null)
+                    {
+                        correctionTimer = CorrectionDelay;
+                        item.CreateClientEvent(this);
+                    }
+                    return true;
+                }
+            };
+            var inLabel = new GUITextBlock(new RectTransform(new Vector2(0.25f, 1.0f), sliderArea.RectTransform), 
+                TextManager.Get("PumpIn"), textAlignment: Alignment.Center, wrap: false, font: GUI.SmallFont);
+
+            rightArea.Recalculate();
+            sliderArea.Recalculate();
+            GUITextBlock.AutoScaleAndNormalize(outLabel, inLabel);
+        }
+
+        public override void OnItemLoaded()
+        {
+            base.OnItemLoaded();
+            if (pumpSpeedSlider != null)
+            {
+                pumpSpeedSlider.BarScroll = (flowPercentage + 100.0f) / 200.0f;
+            }
+        }
+        
+        partial void UpdateProjSpecific(float deltaTime)
+        {
+            if (FlowPercentage < 0.0f)
+            {
+                foreach (Pair<Vector2, ParticleEmitter> pumpOutEmitter in pumpOutEmitters)
+                {
+                    //only emit "pump out" particles when underwater
+                    Vector2 particlePos = item.Rect.Location.ToVector2() + pumpOutEmitter.First;
+                    if (item.CurrentHull != null && item.CurrentHull.Surface < particlePos.Y) continue;
+
+                    pumpOutEmitter.Second.Emit(deltaTime, item.WorldRect.Location.ToVector2() + pumpOutEmitter.First * item.Scale, item.CurrentHull,
+                        velocityMultiplier: MathHelper.Lerp(0.5f, 1.0f, -FlowPercentage / 100.0f));
+                }
+            }
+            else if (FlowPercentage > 0.0f)
+            {
+                foreach (Pair<Vector2, ParticleEmitter> pumpInEmitter in pumpInEmitters)
+                {
+                    pumpInEmitter.Second.Emit(deltaTime, item.WorldRect.Location.ToVector2() + pumpInEmitter.First * item.Scale, item.CurrentHull,
+                        velocityMultiplier: MathHelper.Lerp(0.5f, 1.0f, FlowPercentage / 100.0f));
+                }
+            }
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            pumpSpeedLockTimer -= deltaTime;
+            isActiveLockTimer -= deltaTime;
+            powerIndicator.Selected = hasPower && IsActive;
+            autoControlIndicator.Selected = pumpSpeedLockTimer > 0.0f || isActiveLockTimer > 0.0f;
+            IsActiveSlider.Enabled = isActiveLockTimer <= 0.0f;
+            pumpSpeedSlider.Enabled = pumpSpeedLockTimer <= 0.0f && IsActive;
+
+            if (!PlayerInput.PrimaryMouseButtonHeld())
+            {
+                IsActiveSlider.BarScroll += (IsActive ? -10.0f : 10.0f) * deltaTime;
+
+                float pumpSpeedScroll = (FlowPercentage + 100.0f) / 200.0f;
+                if (Math.Abs(pumpSpeedScroll - pumpSpeedSlider.BarScroll) > 0.01f)
+                {
+                    pumpSpeedSlider.BarScroll = pumpSpeedScroll;
+                }
+            }
+        }
+        
+        public void ClientWrite(IWriteMessage msg, object[] extraData = null)
+        {
+            //flowpercentage can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger((int)(flowPercentage / 10.0f), -10, 10);
+            msg.Write(IsActive);
+        }
+
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            if (correctionTimer > 0.0f)
+            {
+                StartDelayedCorrection(type, msg.ExtractBits(5 + 1), sendingTime);
+                return;
+            }
+
+            FlowPercentage = msg.ReadRangedInteger(-10, 10) * 10.0f;
+            IsActive = msg.ReadBoolean();
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Reactor.cs

@@ -0,0 +1,651 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Reactor : Powered, IServerSerializable, IClientSerializable
+    {
+        public GUIScrollBar AutoTempSlider
+        {
+            get { return autoTempSlider; }
+        }
+        private GUIScrollBar autoTempSlider;
+
+        public GUIScrollBar OnOffSwitch
+        {
+            get { return onOffSwitch; }
+        }
+        private GUIScrollBar onOffSwitch;
+
+        private const int GraphSize = 25;
+        private float graphTimer;
+        private int updateGraphInterval = 500;
+        
+        private Sprite fissionRateMeter, turbineOutputMeter;
+        private Sprite meterPointer;
+        private Sprite sectorSprite;
+
+        private Sprite tempMeterFrame, tempMeterBar;
+        private Sprite tempRangeIndicator;
+
+        private Sprite graphLine;
+
+        public GUIScrollBar FissionRateScrollBar
+        {
+            get { return fissionRateScrollBar; }
+        }
+        private GUIScrollBar fissionRateScrollBar;
+
+        public GUIScrollBar TurbineOutputScrollBar
+        {
+            get { return turbineOutputScrollBar; }
+        }
+        private GUIScrollBar turbineOutputScrollBar;
+
+        private float[] outputGraph = new float[GraphSize];
+        private float[] loadGraph = new float[GraphSize];
+        
+        private GUITickBox criticalHeatWarning;
+        private GUITickBox lowTemperatureWarning;
+        private GUITickBox criticalOutputWarning;
+
+        private GUIFrame inventoryContainer;
+
+        private GUIComponent leftHUDColumn;
+        private GUIComponent midHUDColumn;
+        private GUIComponent rightHUDColumn;
+
+        private GUILayoutGroup sliderControlsContainer;
+
+        private Dictionary<string, GUIButton> warningButtons = new Dictionary<string, GUIButton>();
+
+        private static string[] warningTexts = new string[]
+        {
+            "ReactorWarningLowTemp","ReactorWarningOverheating",
+            "ReactorWarningLowOutput", "ReactorWarningHighOutput",
+            "ReactorWarningLowFuel", "ReactorWarningFuelOut",
+            "ReactorWarningMeltdown","ReactorWarningSCRAM"
+        };
+
+        partial void InitProjSpecific(XElement element)
+        {
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "fissionratemeter":
+                        fissionRateMeter = new Sprite(subElement);
+                        break;
+                    case "turbineoutputmeter":
+                        turbineOutputMeter = new Sprite(subElement);
+                        break;
+                    case "meterpointer":
+                        meterPointer = new Sprite(subElement);
+                        break;
+                    case "sectorsprite":
+                        sectorSprite = new Sprite(subElement);
+                        break;
+                    case "tempmeterframe":
+                        tempMeterFrame = new Sprite(subElement);
+                        break;
+                    case "tempmeterbar":
+                        tempMeterBar = new Sprite(subElement);
+                        break;
+                    case "temprangeindicator":
+                        tempRangeIndicator = new Sprite(subElement);
+                        break;
+                    case "graphline":
+                        graphLine = new Sprite(subElement);
+                        break;
+                }
+            }
+
+            var paddedFrame = new GUILayoutGroup(new RectTransform(new Vector2(0.95f, 0.85f), GuiFrame.RectTransform, Anchor.Center), isHorizontal: true)
+            {
+                RelativeSpacing = 0.012f,
+                Stretch = true
+            };
+
+            GUIFrame columnLeft = new GUIFrame(new RectTransform(new Vector2(0.25f, 1.0f), paddedFrame.RectTransform), style: null);
+            GUIFrame columnMid = new GUIFrame(new RectTransform(new Vector2(0.45f, 1.0f), paddedFrame.RectTransform), style: null);
+            GUIFrame columnRight = new GUIFrame(new RectTransform(new Vector2(0.3f, 1.0f), paddedFrame.RectTransform), style: null);
+            leftHUDColumn = columnLeft;
+            midHUDColumn = columnMid;
+            rightHUDColumn = columnRight;
+
+            //----------------------------------------------------------
+            //left column
+            //----------------------------------------------------------
+
+            int buttonsPerRow = 2;
+            int spacing = 5;
+            int buttonWidth = columnLeft.Rect.Width / buttonsPerRow - (spacing * (buttonsPerRow - 1));
+            int buttonHeight = (int)(columnLeft.Rect.Height * 0.5f) / 4;
+            for (int i = 0; i < warningTexts.Length; i++)
+            {
+                var warningBtn = new GUIButton(new RectTransform(new Point(buttonWidth, buttonHeight), columnLeft.RectTransform)
+                { AbsoluteOffset = new Point((i % buttonsPerRow) * (buttonWidth + spacing), (int)Math.Floor(i / (float)buttonsPerRow) * (buttonHeight + spacing)) },
+                    TextManager.Get(warningTexts[i]), style: "IndicatorButton")
+                {
+                    CanBeFocused = false
+                };
+
+                var btnText = warningBtn.GetChild<GUITextBlock>();
+                btnText.Font = GUI.Font;
+                btnText.Wrap = false;
+                btnText.SetTextPos();
+                warningButtons.Add(warningTexts[i], warningBtn);
+            }
+            GUITextBlock.AutoScaleAndNormalize(warningButtons.Values.Select(b => b.TextBlock));
+
+            inventoryContainer = new GUIFrame(new RectTransform(new Vector2(1.0f, 0.45f), columnLeft.RectTransform, Anchor.BottomLeft), style: null);
+
+            //----------------------------------------------------------
+            //mid column
+            //----------------------------------------------------------
+            
+            criticalHeatWarning = new GUITickBox(new RectTransform(new Point(columnMid.Rect.Width / 3, (int)(30 * GUI.Scale)), columnMid.RectTransform),
+                TextManager.Get("ReactorWarningCriticalTemp"), font: GUI.SmallFont, style: "IndicatorLightRed")
+            {
+                CanBeFocused = false
+            };
+            lowTemperatureWarning = new GUITickBox(new RectTransform(new Point(columnMid.Rect.Width / 3, (int)(30 * GUI.Scale)), columnMid.RectTransform) { RelativeOffset = new Vector2(0.27f, 0.0f) },
+                TextManager.Get("ReactorWarningCriticalLowTemp"), font: GUI.SmallFont, style: "IndicatorLightRed")
+            {
+                CanBeFocused = false
+            };
+            criticalOutputWarning = new GUITickBox(new RectTransform(new Point(columnMid.Rect.Width / 3, (int)(30 * GUI.Scale)), columnMid.RectTransform) { RelativeOffset = new Vector2(0.66f, 0.0f) },
+                TextManager.Get("ReactorWarningCriticalOutput"), font: GUI.SmallFont, style: "IndicatorLightRed")
+            {
+                CanBeFocused = false
+            };
+
+            GUITextBlock.AutoScaleAndNormalize(criticalHeatWarning.TextBlock, lowTemperatureWarning.TextBlock, criticalOutputWarning.TextBlock);
+
+            float gaugeOffset = criticalHeatWarning.Rect.Height / (float)columnMid.Rect.Height + 0.05f * GUI.Scale;
+            
+            new GUITextBlock(new RectTransform(new Vector2(0.5f, 0.05f), columnMid.RectTransform) { RelativeOffset = new Vector2(0.0f, gaugeOffset) },
+                TextManager.Get("ReactorFissionRate"));
+            new GUICustomComponent(new RectTransform(new Vector2(0.5f, 0.5f), columnMid.RectTransform) { RelativeOffset = new Vector2(0.0f, gaugeOffset + 0.05f) },
+                DrawFissionRateMeter, null)
+            {
+                ToolTip = TextManager.Get("ReactorTipFissionRate")
+            };
+
+            new GUITextBlock(new RectTransform(new Vector2(0.5f, 0.05f), columnMid.RectTransform, Anchor.TopRight) { RelativeOffset = new Vector2(0.0f, gaugeOffset) },
+                TextManager.Get("ReactorTurbineOutput"));
+            new GUICustomComponent(new RectTransform(new Vector2(0.5f, 0.5f), columnMid.RectTransform, Anchor.TopRight) { RelativeOffset = new Vector2(0.0f, gaugeOffset + 0.05f) },
+                DrawTurbineOutputMeter, null)
+            {
+                ToolTip = TextManager.Get("ReactorTipTurbineOutput")
+            };
+
+            GUILayoutGroup sliderControls = new GUILayoutGroup(new RectTransform(new Point(columnMid.Rect.Width, (int)(114 * GUI.Scale)), columnMid.RectTransform, Anchor.BottomCenter))
+            {
+                Stretch = true,
+                AbsoluteSpacing = (int)(5 * GUI.Scale)
+            };
+            sliderControlsContainer = sliderControls;
+
+            new GUITextBlock(new RectTransform(new Point(0, (int)(20 * GUI.Scale)), sliderControls.RectTransform, Anchor.TopLeft),
+                TextManager.Get("ReactorFissionRate"));
+            fissionRateScrollBar = new GUIScrollBar(new RectTransform(new Point(sliderControls.Rect.Width, (int)(30 * GUI.Scale)), sliderControls.RectTransform, Anchor.TopCenter),
+                style: "GUISlider", barSize: 0.1f)
+            {
+                OnMoved = (GUIScrollBar bar, float scrollAmount) =>
+                {
+                    LastUser = Character.Controlled;
+                    unsentChanges = true;
+                    targetFissionRate = scrollAmount * 100.0f;
+
+                    return false;
+                }
+            };
+
+            new GUITextBlock(new RectTransform(new Point(0, (int)(20 * GUI.Scale)), sliderControls.RectTransform, Anchor.BottomLeft),
+                TextManager.Get("ReactorTurbineOutput"));
+            turbineOutputScrollBar = new GUIScrollBar(new RectTransform(new Point(sliderControls.Rect.Width, (int)(30 * GUI.Scale)), sliderControls.RectTransform, Anchor.BottomCenter),
+                style: "GUISlider", barSize: 0.1f, isHorizontal: true)
+            {
+                OnMoved = (GUIScrollBar bar, float scrollAmount) =>
+                {
+                    LastUser = Character.Controlled;
+                    unsentChanges = true;
+                    targetTurbineOutput = scrollAmount * 100.0f;
+
+                    return false;
+                }
+            };
+
+            //----------------------------------------------------------
+            //right column
+            //----------------------------------------------------------
+
+            new GUITextBlock(new RectTransform(new Vector2(0.7f, 0.1f), columnRight.RectTransform), TextManager.Get("ReactorAutoTemp"))
+            {
+                ToolTip = TextManager.Get("ReactorTipAutoTemp"),
+                AutoScale = true
+            };
+            autoTempSlider = new GUIScrollBar(new RectTransform(new Vector2(0.6f, 0.15f), columnRight.RectTransform) { RelativeOffset = new Vector2(0.0f, 0.1f) },
+                barSize: 0.55f, style: "OnOffSlider", isHorizontal: true)
+            {
+                ToolTip = TextManager.Get("ReactorTipAutoTemp"),
+                IsBooleanSwitch = true,
+                BarScroll = 1.0f,
+                OnMoved = (scrollBar, scrollAmount) =>
+                {
+                    LastUser = Character.Controlled;
+                    unsentChanges = true;
+                    return true;
+                }
+            };
+            var sliderSprite = autoTempSlider.Frame.Style.Sprites[GUIComponent.ComponentState.None].First();
+            autoTempSlider.RectTransform.MaxSize = new Point((int)(sliderSprite.Sprite.SourceRect.Size.X * GUI.Scale), (int)(sliderSprite.Sprite.SourceRect.Size.Y * GUI.Scale));
+
+            onOffSwitch = new GUIScrollBar(new RectTransform(new Vector2(0.4f, 0.3f), columnRight.RectTransform, Anchor.TopRight),
+                barSize: 0.2f, style: "OnOffLever", isHorizontal: false)
+            {
+                IsBooleanSwitch = true,
+                MinValue = 0.25f, 
+                MaxValue = 0.75f,
+                OnMoved = (scrollBar, scrollAmount) =>
+                {
+                    LastUser = Character.Controlled;
+                    unsentChanges = true;
+                    return true;
+                }
+            };
+            var switchSprite = onOffSwitch.Frame.Style.Sprites[GUIComponent.ComponentState.None].First();
+            onOffSwitch.RectTransform.MaxSize = new Point((int)(switchSprite.Sprite.SourceRect.Size.X * GUI.Scale), (int)(switchSprite.Sprite.SourceRect.Size.Y * GUI.Scale));
+
+            var lever = onOffSwitch.GetChild<GUIButton>();
+            lever.RectTransform.NonScaledSize = new Point(lever.Rect.Width + (int)(30 * GUI.Scale), lever.Rect.Height);
+
+            var graphArea = new GUICustomComponent(new RectTransform(new Vector2(1.0f, 0.5f), columnRight.RectTransform, Anchor.BottomCenter) { AbsoluteOffset = new Point(0, 30) },
+                DrawGraph, null);
+
+            Point textSize = new Point((int)(100 * GUI.Scale), (int)(30 * GUI.Scale));
+
+            var loadText = new GUITextBlock(new RectTransform(textSize, graphArea.RectTransform, Anchor.TopLeft, Pivot.BottomLeft),
+                "Load", textColor: Color.LightBlue, textAlignment: Alignment.CenterLeft)
+            {
+                ToolTip = TextManager.Get("ReactorTipLoad")
+            };
+            string loadStr = TextManager.Get("ReactorLoad");
+            loadText.TextGetter += () => { return loadStr.Replace("[kw]", ((int)load).ToString()); };
+
+            var outputText = new GUITextBlock(new RectTransform(textSize, graphArea.RectTransform, Anchor.BottomLeft, Pivot.TopLeft),
+                "Output", textColor: Color.LightGreen, textAlignment: Alignment.CenterLeft)
+            {
+                ToolTip = TextManager.Get("ReactorTipPower")
+            };
+            string outputStr = TextManager.Get("ReactorOutput");
+            outputText.TextGetter += () => { return outputStr.Replace("[kw]", ((int)-currPowerConsumption).ToString()); };
+        }
+
+        public override void OnItemLoaded()
+        {
+            base.OnItemLoaded();
+            turbineOutputScrollBar.BarScroll = targetTurbineOutput / 100.0f;
+            fissionRateScrollBar.BarScroll = targetFissionRate / 100.0f;
+            var itemContainer = item.GetComponent<ItemContainer>();
+            if (itemContainer != null)
+            {
+                itemContainer.AllowUIOverlap = true;
+                itemContainer.Inventory.RectTransform = inventoryContainer.RectTransform;
+            }
+        }
+
+        private void DrawGraph(SpriteBatch spriteBatch, GUICustomComponent container)
+        {
+            if (item.Removed) { return; }
+
+            Rectangle graphArea = new Rectangle(container.Rect.X + 30, container.Rect.Y, container.Rect.Width - 30, container.Rect.Height);
+
+            float maxLoad = loadGraph.Max();
+
+            float xOffset = graphTimer / updateGraphInterval;
+            DrawGraph(outputGraph, spriteBatch,
+                graphArea, Math.Max(10000.0f, maxLoad), xOffset, Color.LightGreen);
+
+            DrawGraph(loadGraph, spriteBatch,
+                graphArea, Math.Max(10000.0f, maxLoad), xOffset, Color.LightBlue);
+
+            tempMeterFrame.Draw(spriteBatch, new Vector2(graphArea.X - 30, graphArea.Y), Color.White, Vector2.Zero, 0.0f, new Vector2(1.0f, graphArea.Height / tempMeterFrame.size.Y));
+            float tempFill = temperature / 100.0f;
+            
+            int barPadding = 5;
+            Vector2 meterBarPos = new Vector2(graphArea.X - 30 + tempMeterFrame.size.X / 2, graphArea.Bottom - tempMeterBar.size.Y);
+            while (meterBarPos.Y > graphArea.Bottom - graphArea.Height * tempFill)
+            {
+                float tempRatio = 1.0f - ((meterBarPos.Y - graphArea.Y) / graphArea.Height);
+                Color color = tempRatio < 0.5f ?
+                    Color.Lerp(Color.Green, Color.Orange, tempRatio * 2.0f) :
+                    Color.Lerp(Color.Orange, Color.Red, (tempRatio - 0.5f) * 2.0f);
+
+                tempMeterBar.Draw(spriteBatch, meterBarPos, color);
+                meterBarPos.Y -= (tempMeterBar.size.Y + barPadding);
+            }
+
+            if (temperature > optimalTemperature.Y)
+            {
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(graphArea.X - 30, graphArea.Y),
+                    new Vector2(tempMeterFrame.SourceRect.Width, (graphArea.Bottom - graphArea.Height * optimalTemperature.Y / 100.0f) - graphArea.Y),
+                    Color.Red * (float)Math.Sin(Timing.TotalTime * 5.0f) * 0.7f, isFilled: true);
+            }
+            if (temperature < optimalTemperature.X)
+            {
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(graphArea.X - 30, graphArea.Bottom - graphArea.Height * optimalTemperature.X / 100.0f),
+                    new Vector2(tempMeterFrame.SourceRect.Width, graphArea.Bottom - (graphArea.Bottom - graphArea.Height * optimalTemperature.X / 100.0f)),
+                    Color.Red * (float)Math.Sin(Timing.TotalTime * 5.0f) * 0.7f, isFilled: true);
+            }
+
+            tempRangeIndicator.Draw(spriteBatch, new Vector2(meterBarPos.X, graphArea.Bottom - graphArea.Height * optimalTemperature.X / 100.0f));
+            tempRangeIndicator.Draw(spriteBatch, new Vector2(meterBarPos.X, graphArea.Bottom - graphArea.Height * optimalTemperature.Y / 100.0f));
+
+        }
+
+
+        private void UpdateGraph(float deltaTime)
+        {
+            graphTimer += deltaTime * 1000.0f;
+
+            if (graphTimer > updateGraphInterval)
+            {
+                UpdateGraph(outputGraph, -currPowerConsumption);
+                UpdateGraph(loadGraph, load);
+
+                graphTimer = 0.0f;
+            }
+
+            if (autoTemp)
+            {
+                fissionRateScrollBar.BarScroll = FissionRate / 100.0f;
+                turbineOutputScrollBar.BarScroll = TurbineOutput / 100.0f;
+            }
+        }
+
+        private void DrawFissionRateMeter(SpriteBatch spriteBatch, GUICustomComponent container)
+        {
+            if (item.Removed) { return; }
+
+            Rectangle prevScissorRect = spriteBatch.GraphicsDevice.ScissorRectangle;
+            spriteBatch.End();
+            spriteBatch.GraphicsDevice.ScissorRectangle = container.Rect;
+            spriteBatch.Begin(SpriteSortMode.Deferred, rasterizerState: GameMain.ScissorTestEnable);
+
+            //make the pointer jitter a bit if it's at the upper limit of the fission rate
+            float jitter = 0.0f;
+            if (FissionRate > allowedFissionRate.Y - 5.0f)
+            {
+                float jitterAmount = Math.Min(targetFissionRate - allowedFissionRate.Y, 10.0f);
+                float t = graphTimer / updateGraphInterval;
+
+                jitter = (PerlinNoise.GetPerlin(t * 0.5f, t * 0.1f) - 0.5f) * jitterAmount;
+            }
+
+            DrawMeter(spriteBatch, container.Rect,
+                fissionRateMeter, FissionRate + jitter, new Vector2(0.0f, 100.0f), optimalFissionRate, allowedFissionRate);
+
+            spriteBatch.End();
+            spriteBatch.GraphicsDevice.ScissorRectangle = prevScissorRect;
+            spriteBatch.Begin(SpriteSortMode.Deferred);
+        }
+
+        private void DrawTurbineOutputMeter(SpriteBatch spriteBatch, GUICustomComponent container)
+        {
+            if (item.Removed) { return; }
+
+            DrawMeter(spriteBatch, container.Rect,
+                turbineOutputMeter, TurbineOutput, new Vector2(0.0f, 100.0f), optimalTurbineOutput, allowedTurbineOutput);
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            IsActive = true;
+            
+            bool lightOn = Timing.TotalTime % 0.5f < 0.25f && onOffSwitch.BarScroll < 0.5f;
+
+            fissionRateScrollBar.Enabled = !autoTemp;
+            turbineOutputScrollBar.Enabled = !autoTemp;
+
+            criticalHeatWarning.Selected = temperature > allowedTemperature.Y && lightOn;
+            lowTemperatureWarning.Selected = temperature < allowedTemperature.X && lightOn;
+            criticalOutputWarning.Selected = -currPowerConsumption > load * 1.5f && lightOn;
+
+            warningButtons["ReactorWarningOverheating"].Selected = temperature > optimalTemperature.Y && lightOn;
+            warningButtons["ReactorWarningHighOutput"].Selected = -currPowerConsumption > load * 1.1f && lightOn;
+            warningButtons["ReactorWarningLowTemp"].Selected = temperature < optimalTemperature.X && lightOn;
+            warningButtons["ReactorWarningLowOutput"].Selected = -currPowerConsumption < load * 0.9f && lightOn;
+            warningButtons["ReactorWarningFuelOut"].Selected = prevAvailableFuel < fissionRate * 0.01f && lightOn;
+            warningButtons["ReactorWarningLowFuel"].Selected = prevAvailableFuel < fissionRate && lightOn;
+            warningButtons["ReactorWarningMeltdown"].Selected = meltDownTimer > MeltdownDelay * 0.5f || item.Condition == 0.0f && lightOn;
+            warningButtons["ReactorWarningSCRAM"].Selected = temperature > 0.1f && onOffSwitch.BarScroll > 0.5f;
+
+            AutoTemp = autoTempSlider.BarScroll < 0.5f;
+            shutDown = onOffSwitch.BarScroll > 0.5f;
+
+            if ((sliderControlsContainer.Rect.Contains(PlayerInput.MousePosition) || sliderControlsContainer.Children.Contains(GUIScrollBar.DraggingBar)) &&
+                !PlayerInput.KeyDown(InputType.Deselect) && !PlayerInput.KeyHit(InputType.Deselect))
+            {
+                Character.DisableControls = true;
+            }
+
+            if (shutDown)
+            {
+                fissionRateScrollBar.BarScroll = FissionRate / 100.0f;
+                turbineOutputScrollBar.BarScroll = TurbineOutput / 100.0f;
+            }
+            else if (!autoTemp && Character.DisableControls && GUI.KeyboardDispatcher.Subscriber == null)
+            {
+                Vector2 input = Vector2.Zero;
+                float rate = 50.0f; //percentage per second
+
+                if (PlayerInput.KeyDown(InputType.Left)) input.X += -1.0f;
+                if (PlayerInput.KeyDown(InputType.Right)) input.X += 1.0f;
+                if (PlayerInput.KeyDown(InputType.Up)) input.Y += 1.0f;
+                if (PlayerInput.KeyDown(InputType.Down)) input.Y += -1.0f;
+                if (PlayerInput.KeyDown(InputType.Run))
+                    rate = 200.0f;
+                else if (PlayerInput.KeyDown(InputType.Crouch))
+                    rate = 20.0f;
+
+                rate *= deltaTime;
+                input.X *= rate;
+                input.Y *= rate;
+
+                if (input.LengthSquared() > 0)
+                {
+                    LastUser = Character.Controlled;
+                    unsentChanges = true;
+                    if (input.X != 0.0f && GUIScrollBar.DraggingBar != fissionRateScrollBar)
+                    {
+                        targetFissionRate = MathHelper.Clamp(targetFissionRate + input.X, 0.0f, 100.0f);
+                        fissionRateScrollBar.BarScroll += input.X / 100.0f;
+                    }
+                    if (input.Y != 0.0f && GUIScrollBar.DraggingBar != turbineOutputScrollBar)
+                    {
+                        targetTurbineOutput = MathHelper.Clamp(targetTurbineOutput + input.Y, 0.0f, 100.0f);
+                        turbineOutputScrollBar.BarScroll += input.Y / 100.0f;
+                    }
+                }
+            }
+        }
+
+        private bool ToggleAutoTemp(GUITickBox tickBox)
+        {
+            unsentChanges = true;
+            autoTemp = tickBox.Selected;
+            LastUser = Character.Controlled;
+
+            return true;
+        }
+
+        private void DrawMeter(SpriteBatch spriteBatch, Rectangle rect, Sprite meterSprite, float value, Vector2 range, Vector2 optimalRange, Vector2 allowedRange)
+        {
+            float scale = Math.Min(rect.Width / meterSprite.size.X, rect.Height / meterSprite.size.Y);
+            Vector2 pos = new Vector2(rect.Center.X, rect.Y + meterSprite.Origin.Y * scale);
+
+            Vector2 optimalRangeNormalized = new Vector2(
+                MathHelper.Clamp((optimalRange.X - range.X) / (range.Y - range.X), 0.0f, 0.95f),
+                MathHelper.Clamp((optimalRange.Y - range.X) / (range.Y - range.X), 0.0f, 1.0f));
+
+            Vector2 allowedRangeNormalized = new Vector2(
+                MathHelper.Clamp((allowedRange.X - range.X) / (range.Y - range.X), 0.0f, 0.95f),
+                MathHelper.Clamp((allowedRange.Y - range.X) / (range.Y - range.X), 0.0f, 1.0f));
+
+            Vector2 sectorRad = new Vector2(-1.57f, 1.57f);
+
+            Vector2 optimalSectorRad = new Vector2(
+                MathHelper.Lerp(sectorRad.X, sectorRad.Y, optimalRangeNormalized.X),
+                MathHelper.Lerp(sectorRad.X, sectorRad.Y, optimalRangeNormalized.Y));
+
+            Vector2 allowedSectorRad = new Vector2(
+                MathHelper.Lerp(sectorRad.X, sectorRad.Y, allowedRangeNormalized.X),
+                MathHelper.Lerp(sectorRad.X, sectorRad.Y, allowedRangeNormalized.Y));
+
+            if (optimalRangeNormalized.X == optimalRangeNormalized.Y)
+            {
+                sectorSprite.Draw(spriteBatch, pos, Color.Red, MathHelper.PiOver2, scale);
+            }
+            else
+            {
+                spriteBatch.End();
+                Rectangle prevScissorRect = spriteBatch.GraphicsDevice.ScissorRectangle;
+                spriteBatch.GraphicsDevice.ScissorRectangle = new Rectangle(0, 0, GameMain.GraphicsWidth, (int)(pos.Y + (meterSprite.size.Y - meterSprite.Origin.Y) * scale) - 3);
+                spriteBatch.Begin(SpriteSortMode.Deferred, rasterizerState: GameMain.ScissorTestEnable);
+
+                sectorSprite.Draw(spriteBatch, pos, Color.LightGreen, MathHelper.PiOver2 + (allowedSectorRad.X + allowedSectorRad.Y) / 2.0f, scale);
+
+                sectorSprite.Draw(spriteBatch, pos, Color.Orange, optimalSectorRad.X, scale);
+                sectorSprite.Draw(spriteBatch, pos, Color.Red, allowedSectorRad.X, scale);
+
+                sectorSprite.Draw(spriteBatch, pos, Color.Orange, MathHelper.Pi + optimalSectorRad.Y, scale);
+                sectorSprite.Draw(spriteBatch, pos, Color.Red, MathHelper.Pi + allowedSectorRad.Y, scale);
+
+                spriteBatch.End();
+                spriteBatch.GraphicsDevice.ScissorRectangle = prevScissorRect;
+                spriteBatch.Begin(SpriteSortMode.Deferred);
+            }
+
+            meterSprite.Draw(spriteBatch, pos, 0, scale);
+
+            float normalizedValue = (value - range.X) / (range.Y - range.X);
+            float valueRad = MathHelper.Lerp(sectorRad.X, sectorRad.Y, normalizedValue);
+            meterPointer.Draw(spriteBatch, pos, valueRad, scale);
+        }
+
+        static void UpdateGraph<T>(IList<T> graph, T newValue)
+        {
+            for (int i = graph.Count - 1; i > 0; i--)
+            {
+                graph[i] = graph[i - 1];
+            }
+            graph[0] = newValue;
+        }
+
+        private void DrawGraph(IList<float> graph, SpriteBatch spriteBatch, Rectangle rect, float maxVal, float xOffset, Color color)
+        {
+            Rectangle prevScissorRect = spriteBatch.GraphicsDevice.ScissorRectangle;
+            spriteBatch.End();
+            spriteBatch.GraphicsDevice.ScissorRectangle = rect;
+            spriteBatch.Begin(SpriteSortMode.Deferred, rasterizerState: GameMain.ScissorTestEnable);
+
+            float lineWidth = (float)rect.Width / (float)(graph.Count - 2);
+            float yScale = (float)rect.Height / maxVal;
+
+            GUI.DrawRectangle(spriteBatch, rect, Color.White);
+
+            Vector2 prevPoint = new Vector2(rect.Right, rect.Bottom - (graph[1] + (graph[0] - graph[1]) * xOffset) * yScale);
+
+            float currX = rect.Right - ((xOffset - 1.0f) * lineWidth);
+
+            for (int i = 1; i < graph.Count - 1; i++)
+            {
+                currX -= lineWidth;
+
+                Vector2 newPoint = new Vector2(currX, rect.Bottom - graph[i] * yScale);
+                
+                if (graphLine?.Texture == null)
+                {
+                    GUI.DrawLine(spriteBatch, prevPoint, newPoint - new Vector2(1.0f, 0), color);
+                }
+                else
+                {
+                    Vector2 dir = Vector2.Normalize(newPoint - prevPoint);
+                    GUI.DrawLine(spriteBatch, graphLine.Texture, prevPoint - dir, newPoint + dir, color, 0, 5);
+                }
+
+                prevPoint = newPoint;
+            }
+
+            Vector2 lastPoint = new Vector2(rect.X,
+                rect.Bottom - (graph[graph.Count - 1] + (graph[graph.Count - 2] - graph[graph.Count - 1]) * xOffset) * yScale);
+
+            if (graphLine?.Texture == null)
+            {
+                GUI.DrawLine(spriteBatch, prevPoint, lastPoint, color);
+            }
+            else
+            {
+                GUI.DrawLine(spriteBatch, graphLine.Texture, prevPoint, lastPoint + (lastPoint - prevPoint), color, 0, 5);
+            }
+
+            spriteBatch.End();
+            spriteBatch.GraphicsDevice.ScissorRectangle = prevScissorRect;
+            spriteBatch.Begin(SpriteSortMode.Deferred);
+        }
+        
+        protected override void RemoveComponentSpecific()
+        {
+            base.RemoveComponentSpecific();
+            graphLine?.Remove();
+            fissionRateMeter?.Remove();
+            turbineOutputMeter?.Remove();
+            meterPointer?.Remove();
+            sectorSprite?.Remove();
+            tempMeterFrame?.Remove();
+            tempMeterBar?.Remove();
+            tempRangeIndicator?.Remove();
+        }
+
+        public void ClientWrite(IWriteMessage msg, object[] extraData = null)
+        {
+            msg.Write(autoTemp);
+            msg.Write(shutDown);
+            msg.WriteRangedSingle(targetFissionRate, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(targetTurbineOutput, 0.0f, 100.0f, 8);
+
+            correctionTimer = CorrectionDelay;
+        }
+
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            if (correctionTimer > 0.0f)
+            {
+                StartDelayedCorrection(type, msg.ExtractBits(1 + 1 + 8 + 8 + 8 + 8), sendingTime);
+                return;
+            }
+
+            AutoTemp = msg.ReadBoolean();
+            shutDown = msg.ReadBoolean();
+            Temperature = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            targetFissionRate = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            targetTurbineOutput = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            degreeOfSuccess = msg.ReadRangedSingle(0.0f, 1.0f, 8);
+
+            fissionRateScrollBar.BarScroll = targetFissionRate / 100.0f;
+            turbineOutputScrollBar.BarScroll = targetTurbineOutput / 100.0f;
+            onOffSwitch.BarScroll = shutDown ? Math.Max(onOffSwitch.BarScroll, 0.55f) : Math.Min(onOffSwitch.BarScroll, 0.45f);
+
+            IsActive = true;
+        }
+    }
+}

Barotrauma/BarotraumaClient/ClientSource/Items/Components/Machines/Steering.cs

@@ -0,0 +1,883 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Steering : Powered, IServerSerializable, IClientSerializable
+    {
+        enum Mode
+        {
+            AutoPilot,
+            Manual
+        };
+        private GUITickBox autopilotTickBox, manualTickBox;
+
+        enum Destination
+        {
+            MaintainPos,
+            LevelEnd,
+            LevelStart
+        };
+        private GUITickBox maintainPosTickBox, levelEndTickBox, levelStartTickBox;
+
+        private GUIComponent statusContainer, dockingContainer, controlContainer;
+
+        private bool dockingNetworkMessagePending;
+
+        private GUIButton dockingButton;
+        private string dockText, undockText;
+
+        private GUIFrame autoPilotControlsDisabler;
+
+        private GUIComponent steerArea;
+
+        private GUITextBlock pressureWarningText;
+
+        private GUITextBlock tipContainer;
+
+        private string noPowerTip, autoPilotMaintainPosTip, autoPilotLevelStartTip, autoPilotLevelEndTip;
+
+        private Sprite maintainPosIndicator, maintainPosOriginIndicator;
+        private Sprite steeringIndicator;
+
+        private List<DockingPort> connectedPorts = new List<DockingPort>();
+        private float checkConnectedPortsTimer;
+        private const float CheckConnectedPortsInterval = 1.0f;
+
+        private Vector2 keyboardInput = Vector2.Zero;
+        private float inputCumulation;
+
+        private bool? swapDestinationOrder;
+
+        private bool levelStartSelected;
+        public bool LevelStartSelected
+        {
+            get { return levelStartTickBox.Selected; }
+            set { levelStartTickBox.Selected = value; }
+        }
+
+        private bool levelEndSelected;
+        public bool LevelEndSelected
+        {
+            get { return levelEndTickBox.Selected; }
+            set { levelEndTickBox.Selected = value; }
+        }
+
+        private bool maintainPos;
+        public bool MaintainPos
+        {
+            get { return maintainPosTickBox.Selected; }
+            set { maintainPosTickBox.Selected = value; }
+        }
+
+        private float steerRadius;
+        public float? SteerRadius
+        {
+            get
+            {
+                return steerRadius;
+            }
+            set
+            {
+                steerRadius = value ?? (steerArea.Rect.Width / 2);
+            }
+        }
+
+        partial void InitProjSpecific(XElement element)
+        {
+            controlContainer = new GUIFrame(new RectTransform(new Vector2(0.3f, 0.35f), GuiFrame.RectTransform, Anchor.CenterLeft)
+                { MinSize = new Point(150, 0) }, "SonarFrame");
+            var paddedControlContainer = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.8f), controlContainer.RectTransform, Anchor.Center))
+            {
+                RelativeSpacing = 0.03f,
+                Stretch = true
+            };
+
+            statusContainer = new GUIFrame(new RectTransform(new Vector2(0.3f, 0.25f), GuiFrame.RectTransform, Anchor.BottomLeft)
+                { MinSize = new Point(150, 0) }, "SonarFrame");
+            var paddedStatusContainer = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.9f), statusContainer.RectTransform, Anchor.Center))
+            {
+                RelativeSpacing = 0.03f,
+                Stretch = true
+            };
+
+            manualTickBox = new GUITickBox(new RectTransform(new Vector2(0.3f, 0.3f), paddedControlContainer.RectTransform),
+                TextManager.Get("SteeringManual"), style: "GUIRadioButton")
+            {
+                Selected = true,
+                OnSelected = (GUITickBox box) =>
+                {
+                    AutoPilot = !box.Selected;
+                    unsentChanges = true;
+                    user = Character.Controlled;
+
+                    return true;
+                }
+            };
+            autopilotTickBox = new GUITickBox(new RectTransform(new Vector2(0.3f, 0.3f), paddedControlContainer.RectTransform),
+                TextManager.Get("SteeringAutoPilot"), style: "GUIRadioButton")
+            {
+                OnSelected = (GUITickBox box) =>
+                {
+                    AutoPilot = box.Selected;
+                    if (AutoPilot && MaintainPos)
+                    {
+                        posToMaintain = controlledSub != null ?
+                            controlledSub.WorldPosition :
+                            item.Submarine == null ? item.WorldPosition : item.Submarine.WorldPosition;
+                    }
+                    unsentChanges = true;
+                    user = Character.Controlled;
+
+                    return true;
+                }
+            };
+
+            GUIRadioButtonGroup modes = new GUIRadioButtonGroup();
+            modes.AddRadioButton((int)Mode.AutoPilot, autopilotTickBox);
+            modes.AddRadioButton((int)Mode.Manual, manualTickBox);
+            modes.Selected = (int)Mode.Manual;
+            
+            var autoPilotControls = new GUIFrame(new RectTransform(new Vector2(1.0f, 0.6f), paddedControlContainer.RectTransform), "InnerFrame");
+            var paddedAutoPilotControls = new GUILayoutGroup(new RectTransform(new Vector2(0.8f), autoPilotControls.RectTransform, Anchor.Center))
+            {
+                Stretch = true,
+                RelativeSpacing = 0.03f
+            };
+
+            maintainPosTickBox = new GUITickBox(new RectTransform(new Vector2(0.2f, 0.2f), paddedAutoPilotControls.RectTransform),
+                TextManager.Get("SteeringMaintainPos"), font: GUI.SmallFont, style: "GUIRadioButton")
+            {
+                Enabled = false,
+                Selected = maintainPos,
+                OnSelected = tickBox =>
+                {
+                    if (maintainPos != tickBox.Selected)
+                    {
+                        unsentChanges = true;
+                        user = Character.Controlled;
+                        maintainPos = tickBox.Selected;
+                        if (maintainPos)
+                        {
+                            if (controlledSub == null)
+                            {
+                                posToMaintain = null;
+                            }
+                            else
+                            {
+                                posToMaintain = controlledSub.WorldPosition;
+                            }
+                        }
+                        else if (!LevelEndSelected && !LevelStartSelected)
+                        {
+                            AutoPilot = false;
+                        }
+                        if (!maintainPos)
+                        {
+                            posToMaintain = null;
+                        }
+                    }
+                    return true;
+                }
+            };
+
+            levelStartTickBox = new GUITickBox(new RectTransform(new Vector2(0.2f, 0.2f), paddedAutoPilotControls.RectTransform),
+                GameMain.GameSession?.StartLocation == null ? "" : ToolBox.LimitString(GameMain.GameSession.StartLocation.Name, 20),
+                font: GUI.SmallFont, style: "GUIRadioButton")
+            {
+                Enabled = false,
+                Selected = levelStartSelected,
+                OnSelected = tickBox =>
+                {
+                    if (levelStartSelected != tickBox.Selected)
+                    {
+                        unsentChanges = true;
+                        user = Character.Controlled;
+                        levelStartSelected = tickBox.Selected;
+                        levelEndSelected = !levelStartSelected;
+                        if (levelStartSelected)
+                        {
+                            UpdatePath();
+                        }
+                        else if (!MaintainPos && !LevelEndSelected)
+                        {
+                            AutoPilot = false;
+                        }
+                    }
+                    return true;
+                }
+            };
+
+            levelEndTickBox = new GUITickBox(new RectTransform(new Vector2(0.2f, 0.2f), paddedAutoPilotControls.RectTransform),
+                GameMain.GameSession?.EndLocation == null ? "" : ToolBox.LimitString(GameMain.GameSession.EndLocation.Name, 20),
+                font: GUI.SmallFont, style: "GUIRadioButton")
+            {
+                Enabled = false,
+                Selected = levelEndSelected,
+                OnSelected = tickBox =>
+                {
+                    if (levelEndSelected != tickBox.Selected)
+                    {
+                        unsentChanges = true;
+                        user = Character.Controlled;
+                        levelEndSelected = tickBox.Selected;
+                        levelStartSelected = !levelEndSelected;
+                        if (levelEndSelected)
+                        {
+                            UpdatePath();
+                        }
+                        else if (!MaintainPos && !LevelStartSelected)
+                        {
+                            AutoPilot = false;
+                        }
+                    }
+                    return true;
+                }
+            };
+
+            autoPilotControlsDisabler = new GUIFrame(new RectTransform(Vector2.One, autoPilotControls.RectTransform), "InnerFrame");
+
+            GUIRadioButtonGroup destinations = new GUIRadioButtonGroup();
+            destinations.AddRadioButton((int)Destination.MaintainPos, maintainPosTickBox);
+            destinations.AddRadioButton((int)Destination.LevelStart, levelStartTickBox);
+            destinations.AddRadioButton((int)Destination.LevelEnd, levelEndTickBox);
+            destinations.Selected = (int)(maintainPos        ? Destination.MaintainPos :
+                                          levelStartSelected ? Destination.LevelStart  : Destination.LevelEnd);
+            
+            string steeringVelX = TextManager.Get("SteeringVelocityX");
+            string steeringVelY = TextManager.Get("SteeringVelocityY");
+            string steeringDepth = TextManager.Get("SteeringDepth");
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.25f), paddedStatusContainer.RectTransform), "")
+            {
+                TextGetter = () =>
+                {
+                    Vector2 vel = controlledSub == null ? Vector2.Zero : controlledSub.Velocity;
+                    var realWorldVel = ConvertUnits.ToDisplayUnits(vel.Y * Physics.DisplayToRealWorldRatio) * 3.6f;
+                    return steeringVelY.Replace("[kph]", ((int)-realWorldVel).ToString());
+                }
+            };
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.25f), paddedStatusContainer.RectTransform), "")
+            {
+                TextGetter = () =>
+                {
+                    Vector2 vel = controlledSub == null ? Vector2.Zero : controlledSub.Velocity;
+                    var realWorldVel = ConvertUnits.ToDisplayUnits(vel.X * Physics.DisplayToRealWorldRatio) * 3.6f;
+                    return steeringVelX.Replace("[kph]", ((int)realWorldVel).ToString());
+                }
+            };
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.25f), paddedStatusContainer.RectTransform), "")
+            {
+                TextGetter = () =>
+                {
+                    Vector2 pos = controlledSub == null ? Vector2.Zero : controlledSub.Position;
+                    float realWorldDepth = Level.Loaded == null ? 0.0f : Math.Abs(pos.Y - Level.Loaded.Size.Y) * Physics.DisplayToRealWorldRatio;
+                    return steeringDepth.Replace("[m]", ((int)realWorldDepth).ToString());
+                }
+            };
+
+            pressureWarningText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.25f), paddedStatusContainer.RectTransform), TextManager.Get("SteeringDepthWarning"), Color.Red)
+            {
+                Visible = false
+            };
+
+            tipContainer = new GUITextBlock(new RectTransform(new Vector2(0.25f, 0.12f), GuiFrame.RectTransform, Anchor.BottomLeft)
+            { MinSize = new Point(150, 0), RelativeOffset = new Vector2(0.0f, -0.05f) }, "", wrap: true, style: "GUIToolTip")
+            {
+                AutoScale = true
+            };
+
+            noPowerTip = TextManager.Get("SteeringNoPowerTip");
+            autoPilotMaintainPosTip = TextManager.Get("SteeringAutoPilotMaintainPosTip");
+            autoPilotLevelStartTip = TextManager.GetWithVariable("SteeringAutoPilotLocationTip", "[locationname]",
+                GameMain.GameSession?.StartLocation == null ? "Start" : GameMain.GameSession.StartLocation.Name);
+            autoPilotLevelEndTip = TextManager.GetWithVariable("SteeringAutoPilotLocationTip", "[locationname]",
+                GameMain.GameSession?.EndLocation == null ? "End" : GameMain.GameSession.EndLocation.Name);
+
+            steerArea = new GUICustomComponent(new RectTransform(Point.Zero, GuiFrame.RectTransform, Anchor.CenterLeft),
+                (spriteBatch, guiCustomComponent) => { DrawHUD(spriteBatch, guiCustomComponent.Rect); }, null);
+
+            //docking interface ----------------------------------------------------
+            dockingContainer = new GUIFrame(new RectTransform(new Vector2(0.3f, 0.25f), GuiFrame.RectTransform, Anchor.BottomLeft)
+            { MinSize = new Point(150, 0) }, style: null);
+            var paddedDockingContainer = new GUIFrame(new RectTransform(new Vector2(0.9f, 0.9f), dockingContainer.RectTransform, Anchor.Center), style: null);
+            
+            dockText = TextManager.Get("label.navterminaldock", fallBackTag: "captain.dock");
+            undockText = TextManager.Get("label.navterminalundock", fallBackTag: "captain.undock");
+            dockingButton = new GUIButton(new RectTransform(new Vector2(0.5f, 0.5f), paddedDockingContainer.RectTransform, Anchor.Center), dockText, style: "GUIButtonLarge")
+            {
+                OnClicked = (btn, userdata) =>
+                {
+                    if (GameMain.Client == null)
+                    {
+                        item.SendSignal(0, "1", "toggle_docking", sender: null);
+                    }
+                    else
+                    {
+                        dockingNetworkMessagePending = true;
+                        item.CreateClientEvent(this);
+                    }
+                    return true;
+                }
+            };
+            dockingButton.Font = GUI.SmallFont;
+
+            var leftButton = new GUIButton(new RectTransform(new Vector2(0.2f, 0.5f), paddedDockingContainer.RectTransform, Anchor.CenterLeft), "")
+            {
+                OnClicked = NudgeButtonClicked,
+                UserData = -Vector2.UnitX
+            };
+            new GUIImage(new RectTransform(new Vector2(0.7f), leftButton.RectTransform, Anchor.Center), "GUIButtonHorizontalArrow").SpriteEffects = SpriteEffects.FlipHorizontally;
+            var rightButton = new GUIButton(new RectTransform(new Vector2(0.2f, 0.5f), paddedDockingContainer.RectTransform, Anchor.CenterRight), "")
+            {
+                OnClicked = NudgeButtonClicked,
+                UserData = Vector2.UnitX
+            };
+            new GUIImage(new RectTransform(new Vector2(0.7f), rightButton.RectTransform, Anchor.Center), "GUIButtonHorizontalArrow");
+            var upButton = new GUIButton(new RectTransform(new Vector2(0.5f, 0.2f), paddedDockingContainer.RectTransform, Anchor.TopCenter), "")
+            {
+                OnClicked = NudgeButtonClicked,
+                UserData = Vector2.UnitY
+            };
+            new GUIImage(new RectTransform(new Vector2(0.7f), upButton.RectTransform, Anchor.Center), "GUIButtonVerticalArrow");
+            var downButton = new GUIButton(new RectTransform(new Vector2(0.5f, 0.2f), paddedDockingContainer.RectTransform, Anchor.BottomCenter), "")
+            {
+                OnClicked = NudgeButtonClicked,
+                UserData = -Vector2.UnitY
+            };
+            new GUIImage(new RectTransform(new Vector2(0.7f), downButton.RectTransform, Anchor.Center), "GUIButtonVerticalArrow").SpriteEffects = SpriteEffects.FlipVertically;
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "steeringindicator":
+                        steeringIndicator = new Sprite(subElement);
+                        break;
+                    case "maintainposindicator":
+                        maintainPosIndicator = new Sprite(subElement);
+                        break;
+                    case "maintainposoriginindicator":
+                        maintainPosOriginIndicator = new Sprite(subElement);
+                        break;
+                }
+            }
+
+            SetUILayout();
+
+            GameMain.Instance.OnResolutionChanged += SetUILayout;
+            GameMain.Config.OnHUDScaleChanged += SetUILayout;
+        }
+
+        private void SetUILayout()
+        {
+            int viewSize = (int)Math.Min(GuiFrame.Rect.Width - 150, GuiFrame.Rect.Height * 0.9f);
+
+            controlContainer.RectTransform.AbsoluteOffset = new Point((int)(viewSize * 0.99f), (int)(viewSize * 0.05f));
+            statusContainer.RectTransform.AbsoluteOffset = new Point((int)(viewSize * 0.9f), 0);
+            steerArea.RectTransform.NonScaledSize = new Point(viewSize);
+            dockingContainer.RectTransform.AbsoluteOffset = new Point((int)(viewSize * 0.9f), 0);
+
+            steerRadius = steerArea.Rect.Width / 2;
+        }
+
+        /// <summary>
+        /// Makes the sonar view CustomComponent render the steering HUD, preventing it from being drawn behing the sonar
+        /// </summary>
+        public void AttachToSonarHUD(GUICustomComponent sonarView)
+        {
+            steerArea.Visible = false;
+            sonarView.OnDraw += (spriteBatch, guiCustomComponent) => { DrawHUD(spriteBatch, guiCustomComponent.Rect); };
+        }
+
+        public void DrawHUD(SpriteBatch spriteBatch, Rectangle rect)
+        {
+            int width = rect.Width, height = rect.Height;
+            int x = rect.X;
+            int y = rect.Y;
+
+            if (Voltage < MinVoltage) { return; }
+
+            Rectangle velRect = new Rectangle(x + 20, y + 20, width - 40, height - 40);
+            Vector2 displaySubPos = (-sonar.DisplayOffset * sonar.Zoom) / sonar.Range * sonar.DisplayRadius * sonar.Zoom;
+            displaySubPos.Y = -displaySubPos.Y;
+            displaySubPos = displaySubPos.ClampLength(velRect.Width / 2);
+            displaySubPos = steerArea.Rect.Center.ToVector2() + displaySubPos;
+            
+            if (!AutoPilot)
+            {
+                Vector2 unitSteeringInput = steeringInput / 100.0f;
+                //map input from rectangle to circle
+                Vector2 steeringInputPos = new Vector2(
+                    steeringInput.X * (float)Math.Sqrt(1.0f - 0.5f * unitSteeringInput.Y * unitSteeringInput.Y),
+                    -steeringInput.Y * (float)Math.Sqrt(1.0f - 0.5f * unitSteeringInput.X * unitSteeringInput.X));
+                steeringInputPos += displaySubPos;
+
+                if (steeringIndicator != null)
+                {
+                    Vector2 dir = steeringInputPos - displaySubPos;
+                    float angle = (float)Math.Atan2(dir.Y, dir.X);
+                    steeringIndicator.Draw(spriteBatch, displaySubPos, Color.White, origin: steeringIndicator.Origin, rotate: angle,
+                        scale: new Vector2(dir.Length() / steeringIndicator.size.X, 1.0f));
+                }
+                else
+                {
+                    GUI.DrawLine(spriteBatch, displaySubPos, steeringInputPos, Color.LightGray);
+                    GUI.DrawRectangle(spriteBatch, new Rectangle((int)steeringInputPos.X - 5, (int)steeringInputPos.Y - 5, 10, 10), Color.White);
+                }
+
+                if (velRect.Contains(PlayerInput.MousePosition))
+                {
+                    GUI.DrawRectangle(spriteBatch, new Rectangle((int)steeringInputPos.X - 4, (int)steeringInputPos.Y - 4, 8, 8), Color.Red, thickness: 2);
+                }
+            }
+            else if (posToMaintain.HasValue && !LevelStartSelected && !LevelEndSelected)
+            {
+                Sonar sonar = item.GetComponent<Sonar>();
+                if (sonar != null && controlledSub != null)
+                {
+                    Vector2 displayPosToMaintain = ((posToMaintain.Value - sonar.DisplayOffset * sonar.Zoom - controlledSub.WorldPosition)) / sonar.Range * sonar.DisplayRadius * sonar.Zoom;
+                    displayPosToMaintain.Y = -displayPosToMaintain.Y;
+                    displayPosToMaintain = displayPosToMaintain.ClampLength(velRect.Width / 2);
+                    displayPosToMaintain = steerArea.Rect.Center.ToVector2() + displayPosToMaintain;
+
+                    Color crosshairColor = Color.Orange * (0.5f + ((float)Math.Sin(Timing.TotalTime * 5.0f) + 1.0f) / 4.0f);
+                    if (maintainPosIndicator != null)
+                    {
+                        maintainPosIndicator.Draw(spriteBatch, displayPosToMaintain, crosshairColor, scale: 0.5f * sonar.Zoom);
+                    }
+                    else
+                    {
+                        float crossHairSize = 8.0f;
+                        GUI.DrawLine(spriteBatch, displayPosToMaintain + Vector2.UnitY * crossHairSize, displayPosToMaintain - Vector2.UnitY * crossHairSize, crosshairColor, width: 3);
+                        GUI.DrawLine(spriteBatch, displayPosToMaintain + Vector2.UnitX * crossHairSize, displayPosToMaintain - Vector2.UnitX * crossHairSize, crosshairColor, width: 3);
+                    }
+
+                    if (maintainPosOriginIndicator != null)
+                    {
+                        maintainPosOriginIndicator.Draw(spriteBatch, displaySubPos, Color.Orange, scale: 0.5f * sonar.Zoom);
+                    }
+                    else
+                    {
+                        GUI.DrawRectangle(spriteBatch, new Rectangle((int)displaySubPos.X - 5, (int)displaySubPos.Y - 5, 10, 10), Color.Orange);
+                    }
+                }
+            }
+            
+            //map velocity from rectangle to circle
+            Vector2 unitTargetVel = targetVelocity / 100.0f;
+            Vector2 steeringPos = new Vector2(
+                targetVelocity.X * 0.9f * (float)Math.Sqrt(1.0f - 0.5f * unitTargetVel.Y * unitTargetVel.Y),
+                -targetVelocity.Y * 0.9f * (float)Math.Sqrt(1.0f - 0.5f * unitTargetVel.X * unitTargetVel.X));
+            steeringPos += displaySubPos;
+
+
+            if (steeringIndicator != null)
+            {
+                Vector2 dir = steeringPos - displaySubPos;
+                float angle = (float)Math.Atan2(dir.Y, dir.X);
+                steeringIndicator.Draw(spriteBatch, displaySubPos, Color.Gray, origin: steeringIndicator.Origin, rotate: angle,
+                    scale: new Vector2(dir.Length() / steeringIndicator.size.X, 0.7f));
+            }
+            else
+            {
+                GUI.DrawLine(spriteBatch,
+                    displaySubPos,
+                    steeringPos,
+                    Color.CadetBlue, 0, 2);
+            }           
+        }
+
+        public void DebugDrawHUD(SpriteBatch spriteBatch, Vector2 transducerCenter, float displayScale, float displayRadius, Vector2 center)
+        {
+            if (SteeringPath == null) return;
+
+            Vector2 prevPos = Vector2.Zero;
+            foreach (WayPoint wp in SteeringPath.Nodes)
+            {
+                Vector2 pos = (wp.Position - transducerCenter) * displayScale;
+                if (pos.Length() > displayRadius) continue;
+
+                pos.Y = -pos.Y;
+                pos += center;
+
+                GUI.DrawRectangle(spriteBatch, new Rectangle((int)pos.X - 3 / 2, (int)pos.Y - 3, 6, 6), (SteeringPath.CurrentNode == wp) ? Color.LightGreen : Color.Green, false);
+
+                if (prevPos != Vector2.Zero)
+                {
+                    GUI.DrawLine(spriteBatch, pos, prevPos, Color.Green);
+                }
+
+                prevPos = pos;
+            }
+
+            foreach (ObstacleDebugInfo obstacle in debugDrawObstacles)
+            {
+                Vector2 pos1 = (obstacle.Point1 - transducerCenter) * displayScale;
+                pos1.Y = -pos1.Y;
+                pos1 += center;
+                Vector2 pos2 = (obstacle.Point2 - transducerCenter) * displayScale;
+                pos2.Y = -pos2.Y;
+                pos2 += center;
+
+                GUI.DrawLine(spriteBatch, 
+                    pos1, 
+                    pos2,
+                    Color.Red * 0.6f, width: 3);
+
+                if (obstacle.Intersection.HasValue)
+                {
+                    Vector2 intersectionPos = (obstacle.Intersection.Value - transducerCenter) *displayScale;
+                    intersectionPos.Y = -intersectionPos.Y;
+                    intersectionPos += center;
+                    GUI.DrawRectangle(spriteBatch, intersectionPos - Vector2.One * 2, Vector2.One * 4, Color.Red);
+                }
+
+                Vector2 obstacleCenter = (pos1 + pos2) / 2;
+                if (obstacle.AvoidStrength.LengthSquared() > 0.01f)
+                {
+                    GUI.DrawLine(spriteBatch,
+                        obstacleCenter,
+                        obstacleCenter + new Vector2(obstacle.AvoidStrength.X, -obstacle.AvoidStrength.Y) * 100,
+                        Color.Lerp(Color.Green, Color.Orange, obstacle.Dot), width: 2);
+                }
+            }
+        }
+
+        public override void UpdateHUD(Character character, float deltaTime, Camera cam)
+        {
+            if (swapDestinationOrder == null)
+            {
+                swapDestinationOrder = item.Submarine != null && item.Submarine.FlippedX;
+                if (swapDestinationOrder.Value)
+                {
+                    levelStartTickBox.RectTransform.SetAsLastChild();
+                }
+            }
+
+            if (steerArea.Rect.Contains(PlayerInput.MousePosition))
+            {
+                if (!PlayerInput.KeyDown(InputType.Deselect) && !PlayerInput.KeyHit(InputType.Deselect))
+                {
+                    Character.DisableControls = true;
+                }
+            }
+
+            dockingContainer.Visible = DockingModeEnabled;
+            statusContainer.Visible = !DockingModeEnabled;
+
+            if (DockingModeEnabled && ActiveDockingSource != null)
+            {
+                if (Math.Abs(ActiveDockingSource.Item.WorldPosition.X - DockingTarget.Item.WorldPosition.X) < ActiveDockingSource.DistanceTolerance.X &&
+                    Math.Abs(ActiveDockingSource.Item.WorldPosition.Y - DockingTarget.Item.WorldPosition.Y) < ActiveDockingSource.DistanceTolerance.Y)
+                {
+                    dockingButton.Text = dockText;
+                    if (dockingButton.FlashTimer <= 0.0f)
+                    {
+                        dockingButton.Flash(Color.LightGreen, 0.5f);
+                        dockingButton.Pulsate(Vector2.One, Vector2.One * 1.2f, dockingButton.FlashTimer);
+                    }
+                }
+            }
+            else if (DockingSources.Any(d => d.Docked))
+            {
+                dockingButton.Text = undockText;
+                dockingContainer.Visible = true;
+                statusContainer.Visible = false;
+                if (dockingButton.FlashTimer <= 0.0f)
+                {
+                    dockingButton.Flash(Color.OrangeRed);
+                    dockingButton.Pulsate(Vector2.One, Vector2.One * 1.2f, dockingButton.FlashTimer);
+                }
+            }
+            else
+            {
+                dockingButton.Text = dockText;
+            }
+
+            autoPilotControlsDisabler.Visible = !AutoPilot;
+
+            if (Voltage < MinVoltage)
+            {
+                tipContainer.Visible = true;
+                tipContainer.Text = noPowerTip;
+                return;
+            }
+
+            tipContainer.Visible = AutoPilot;
+            if (AutoPilot)
+            {
+                if (maintainPos)
+                {
+                    tipContainer.Text = autoPilotMaintainPosTip;
+                }
+                else if (LevelStartSelected)
+                {
+                    tipContainer.Text = autoPilotLevelStartTip;
+                }
+                else if (LevelEndSelected)
+                {
+                    tipContainer.Text = autoPilotLevelEndTip;
+                }
+
+                if (DockingModeEnabled && DockingTarget != null)
+                {
+                    posToMaintain += ConvertUnits.ToDisplayUnits(DockingTarget.Item.Submarine.Velocity) * deltaTime;
+                }
+            }
+
+            pressureWarningText.Visible = item.Submarine != null && item.Submarine.AtDamageDepth && Timing.TotalTime % 1.0f < 0.5f;
+
+            if (Vector2.DistanceSquared(PlayerInput.MousePosition, steerArea.Rect.Center.ToVector2()) < steerRadius * steerRadius)
+            {
+                if (PlayerInput.PrimaryMouseButtonHeld())
+                {
+                    Vector2 displaySubPos = (-sonar.DisplayOffset * sonar.Zoom) / sonar.Range * sonar.DisplayRadius * sonar.Zoom;
+                    displaySubPos.Y = -displaySubPos.Y;
+                    displaySubPos = steerArea.Rect.Center.ToVector2() + displaySubPos;
+
+                    Vector2 inputPos = PlayerInput.MousePosition - displaySubPos;
+                    inputPos.Y = -inputPos.Y;
+                    if (AutoPilot && !LevelStartSelected && !LevelEndSelected)
+                    {
+                        posToMaintain = controlledSub != null ? 
+                            controlledSub.WorldPosition + inputPos / sonar.DisplayRadius * sonar.Range / sonar.Zoom :
+                            item.Submarine == null ? item.WorldPosition : item.Submarine.WorldPosition;
+                    }
+                    else
+                    {
+                        SteeringInput = inputPos;
+                    }
+                    unsentChanges = true;
+                    user = Character.Controlled;
+                }
+            }
+            if (!AutoPilot && Character.DisableControls && GUI.KeyboardDispatcher.Subscriber == null)
+            {
+                steeringAdjustSpeed = character == null ? 0.2f : MathHelper.Lerp(0.2f, 1.0f, character.GetSkillLevel("helm") / 100.0f);
+                Vector2 input = Vector2.Zero;
+                if (PlayerInput.KeyDown(InputType.Left)) { input -= Vector2.UnitX; }
+                if (PlayerInput.KeyDown(InputType.Right)) { input += Vector2.UnitX; }
+                if (PlayerInput.KeyDown(InputType.Up)) { input += Vector2.UnitY; }
+                if (PlayerInput.KeyDown(InputType.Down)) { input -= Vector2.UnitY; }
+                if (PlayerInput.KeyDown(Keys.LeftShift))
+                {
+                    SteeringInput += input * deltaTime * 200;
+                    inputCumulation = 0;
+                    keyboardInput = Vector2.Zero;
+                    unsentChanges = true;
+                }
+                else
+                {
+                    float step = deltaTime * 5;
+                    if (input.Length() > 0)
+                    {
+                        inputCumulation += step;
+                    }
+                    else
+                    {
+                        inputCumulation -= step;
+                    }
+                    float maxCumulation = 1;
+                    inputCumulation = MathHelper.Clamp(inputCumulation, 0, maxCumulation);
+                    float length = MathHelper.Lerp(0, 0.2f, MathUtils.InverseLerp(0, maxCumulation, inputCumulation));
+                    var normalizedInput = Vector2.Normalize(input);
+                    if (MathUtils.IsValid(normalizedInput))
+                    {
+                        keyboardInput += normalizedInput * length;
+                    }
+                    if (keyboardInput.LengthSquared() > 0.01f)
+                    {
+                        SteeringInput += keyboardInput;
+                        unsentChanges = true;
+                        user = Character.Controlled;
+                        keyboardInput *= MathHelper.Clamp(1 - step, 0, 1);
+                    }
+                }
+            }
+            else
+            {
+                inputCumulation = 0;
+                keyboardInput = Vector2.Zero;
+            }
+
+            if (!UseAutoDocking) { return; }
+
+            if (checkConnectedPortsTimer <= 0.0f)
+            {
+                Connection dockingConnection = item.Connections?.FirstOrDefault(c => c.Name == "toggle_docking");
+                if (dockingConnection != null)
+                {
+                    connectedPorts = item.GetConnectedComponentsRecursive<DockingPort>(dockingConnection);
+                }
+                checkConnectedPortsTimer = CheckConnectedPortsInterval;
+            }
+            
+            float closestDist = DockingAssistThreshold * DockingAssistThreshold;
+            DockingModeEnabled = false;
+            
+            foreach (DockingPort sourcePort in connectedPorts)
+            {
+                if (sourcePort.Docked || sourcePort.Item.Submarine == null) { continue; }
+                if (sourcePort.Item.Submarine != controlledSub) { continue; }
+
+                int sourceDir = sourcePort.GetDir();
+
+                foreach (DockingPort targetPort in DockingPort.List)
+                {
+                    if (targetPort.Docked || targetPort.Item.Submarine == null) { continue; }
+                    if (targetPort.Item.Submarine == controlledSub || targetPort.IsHorizontal != sourcePort.IsHorizontal) { continue; }
+                    if (Level.Loaded != null && targetPort.Item.Submarine.WorldPosition.Y > Level.Loaded.Size.Y) { continue; }
+
+                    int targetDir = targetPort.GetDir();
+
+                    if (sourceDir == targetDir) { continue; }
+
+                    float dist = Vector2.DistanceSquared(sourcePort.Item.WorldPosition, targetPort.Item.WorldPosition);
+                    if (dist < closestDist)
+                    {
+                        DockingModeEnabled = true;
+                        ActiveDockingSource = sourcePort;
+                        DockingTarget = targetPort;
+                    }
+                }
+            }
+        }
+
+        private bool NudgeButtonClicked(GUIButton btn, object userdata)
+        {
+            if (!MaintainPos || !AutoPilot)
+            {
+                AutoPilot = true;
+                posToMaintain = item.Submarine.WorldPosition;
+            }
+            MaintainPos = true;
+            if (userdata is Vector2)
+            {
+                Sonar sonar = item.GetComponent<Sonar>();
+                Vector2 nudgeAmount = (Vector2)userdata;
+                if (sonar != null)
+                {
+                    nudgeAmount *= sonar == null ? 500.0f : 500.0f / sonar.Zoom;
+                }
+                PosToMaintain += nudgeAmount;
+            }
+            return true;
+        }
+
+        protected override void RemoveComponentSpecific()
+        {
+            base.RemoveComponentSpecific();
+            maintainPosIndicator?.Remove();
+            maintainPosOriginIndicator?.Remove();
+            steeringIndicator?.Remove();
+        }
+
+        public void ClientWrite(IWriteMessage msg, object[] extraData = null)
+        {
+            msg.Write(autoPilot);
+            msg.Write(dockingNetworkMessagePending);
+            dockingNetworkMessagePending = false;
+
+            if (!autoPilot)
+            {
+                //no need to write steering info if autopilot is controlling
+                msg.Write(steeringInput.X);
+                msg.Write(steeringInput.Y);
+            }
+            else
+            {
+                msg.Write(posToMaintain != null);
+                if (posToMaintain != null)
+                {
+                    msg.Write(((Vector2)posToMaintain).X);
+                    msg.Write(((Vector2)posToMaintain).Y);
+                }
+                else
+                {
+                    msg.Write(LevelStartSelected);
+                }
+            }
+        }
+        
+        public void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            int msgStartPos = msg.BitPosition;
+
+            bool autoPilot                  = msg.ReadBoolean();
+            bool dockingButtonClicked       = msg.ReadBoolean();
+            Vector2 newSteeringInput        = steeringInput;
+            Vector2 newTargetVelocity       = targetVelocity;
+            float newSteeringAdjustSpeed    = steeringAdjustSpeed;
+            bool maintainPos                = false;
+            Vector2? newPosToMaintain       = null;
+            bool headingToStart             = false;
+
+            if (dockingButtonClicked)
+            {
+                item.SendSignal(0, "1", "toggle_docking", sender: null);
+            }
+
+            if (autoPilot)
+            {
+                maintainPos = msg.ReadBoolean();
+                if (maintainPos)
+                {
+                    newPosToMaintain = new Vector2(
+                        msg.ReadSingle(),
+                        msg.ReadSingle());
+                }
+                else
+                {
+                    headingToStart = msg.ReadBoolean();
+                }
+            }
+            else
+            {
+                newSteeringInput = new Vector2(msg.ReadSingle(), msg.ReadSingle());
+                newTargetVelocity = new Vector2(msg.ReadSingle(), msg.ReadSingle());
+                newSteeringAdjustSpeed = msg.ReadSingle();
+            }
+
+            if (correctionTimer > 0.0f)
+            {
+                int msgLength = (int)(msg.BitPosition - msgStartPos);
+                msg.BitPosition = msgStartPos;
+                StartDelayedCorrection(type, msg.ExtractBits(msgLength), sendingTime);
+                return;
+            }
+
+            AutoPilot = autoPilot;
+
+            if (!AutoPilot)
+            {
+                SteeringInput = newSteeringInput;
+                TargetVelocity = newTargetVelocity;
+                steeringAdjustSpeed = newSteeringAdjustSpeed;
+            }
+            else
+            {
+                MaintainPos = newPosToMaintain != null;
+                posToMaintain = newPosToMaintain;
+
+                if (posToMaintain == null)
+                {
+                    LevelStartSelected = headingToStart;
+                    LevelEndSelected = !headingToStart;
+                    UpdatePath();
+                }
+                else
+                {
+                    LevelStartSelected = false;
+                    LevelEndSelected = false;
+                }
+            }
+        }
+    }
+}