Split Machines ItemComponents

There's still a lot of work to do before we can get the server to compile

BarotraumaClient/Source/Characters/AI/CrewCommander.cs

@@ -0,0 +1,313 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class CrewCommander
+    {
+        private CrewManager crewManager;
+
+        private GUIFrame frame;
+        //GUIListBox characterList;
+
+        private bool infoTextShown;
+
+        private int characterFrameBottom;
+
+        public GUIFrame Frame
+        {
+            get { return IsOpen ? frame : null; }
+        }
+
+        public bool IsOpen
+        {
+            get;
+            private set;
+        }
+
+        public CrewCommander(CrewManager crewManager)
+        {
+            this.crewManager = crewManager;
+        }
+
+        public void ToggleGUIFrame()
+        {
+            IsOpen = !IsOpen;
+
+            if (IsOpen) 
+            {
+                if (!infoTextShown)
+                {
+                    GUI.AddMessage("Press " + GameMain.Config.KeyBind(InputType.CrewOrders) + " to open/close the command menu", Color.Cyan, 5.0f);
+                    infoTextShown = true;
+                }
+
+                if (frame == null) CreateGUIFrame();
+                UpdateCharacters();
+            }
+        }
+
+        private void CreateGUIFrame()
+        {
+            frame = new GUIFrame(Rectangle.Empty, Color.Black * 0.6f, null);
+            frame.Padding = new Vector4(200.0f, 100.0f, 200.0f, 100.0f);
+
+            GUIButton closeButton = new GUIButton(new Rectangle(0, 50, 100, 20), "Close", Alignment.BottomCenter, "", frame);
+            closeButton.OnClicked = (GUIButton button, object userData) =>
+            {
+                ToggleGUIFrame();
+                return false;
+            };
+
+            //UpdateCharacters();
+
+            int buttonWidth = 130;
+            int spacing = 20;
+
+            int y = 50;
+
+            for (int n = 0; n<2; n++)
+            {                                      
+                List<Order> orders = (n==0) ? 
+                    Order.PrefabList.FindAll(o => o.ItemComponentType == null && string.IsNullOrEmpty(o.ItemName)) : 
+                    Order.PrefabList.FindAll(o => o.ItemComponentType != null || !string.IsNullOrEmpty(o.ItemName));
+
+                int startX = -(buttonWidth * orders.Count + spacing * (orders.Count - 1)) / 2;
+                
+                int i=0;
+                foreach (Order order in orders)
+                {
+                    int x = startX + (buttonWidth + spacing) * (i % orders.Count);
+
+                    if (order.ItemComponentType!=null || !string.IsNullOrEmpty(order.ItemName))
+                    {
+                        List<Item> matchingItems = !string.IsNullOrEmpty(order.ItemName) ?
+                            Item.ItemList.FindAll(it => it.Name == order.ItemName) :
+                            Item.ItemList.FindAll(it => it.components.Any(ic => ic.GetType() == order.ItemComponentType));
+
+                        int y2 = y;
+                        foreach (Item it in matchingItems)
+                        {
+                            var newOrder = new Order(order, it.components.Find(ic => ic.GetType() == order.ItemComponentType));
+
+                            CreateOrderButton(new Rectangle(x + buttonWidth / 2, y2, buttonWidth, 20), newOrder, y2==y);
+                            y2 += 25;
+                        }
+                    }
+                    else
+                    {
+                        CreateOrderButton(new Rectangle(x + buttonWidth / 2, y, buttonWidth, 20), order);
+                    }
+                    i++;
+                }
+
+                y += 100;
+            }
+        }
+
+        private GUIButton CreateOrderButton(Rectangle rect, Order order, bool createSymbol = true)
+        {
+            var orderButton = new GUIButton(rect, order.Name, null, Alignment.TopCenter, Alignment.Center, "GUITextBox", frame);
+            orderButton.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+            /*orderButton.TextColor = Color.White;
+            orderButton.Color = Color.Black * 0.5f;
+            orderButton.HoverColor = Color.LightGray * 0.5f;
+            orderButton.OutlineColor = Color.LightGray * 0.8f;*/
+            orderButton.UserData = order;
+            orderButton.OnClicked = SetOrder;
+            
+            if (createSymbol)
+            {
+                var symbol = new GUIImage(new Rectangle(0,-60,64,64), order.SymbolSprite, Alignment.TopCenter, orderButton);
+                symbol.Color = order.Color;
+
+                orderButton.children.Insert(0, symbol);
+                orderButton.children.RemoveAt(orderButton.children.Count-1);
+            }
+            
+            return orderButton;
+        }
+
+        public void UpdateCharacters()
+        {
+            CreateGUIFrame();
+
+            List<GUIComponent> prevCharacterFrames = new List<GUIComponent>();
+            foreach (GUIComponent child in frame.children)
+            {
+                if (!(child.UserData is Character)) continue;
+
+                prevCharacterFrames.Add(child);
+            }
+            
+            foreach (GUIComponent child in prevCharacterFrames)
+            {
+                frame.RemoveChild(child);
+            }
+
+            List<Character> aliveCharacters = crewManager.characters.FindAll(c => !c.IsDead && c.AIController is HumanAIController);
+
+            characterFrameBottom = 0;
+
+            int charactersPerRow = 4;
+
+            int spacing = 5;
+
+            int i = 0;
+            foreach (Character character in aliveCharacters)
+            {
+                int rowCharacterCount = Math.Min(charactersPerRow, aliveCharacters.Count);
+                //if (i >= aliveCharacters.Count - charactersPerRow && aliveCharacters.Count % charactersPerRow > 0) rowCharacterCount = aliveCharacters.Count % charactersPerRow;
+
+               // rowCharacterCount = Math.Min(rowCharacterCount, aliveCharacters.Count - i);
+                int startX = -(150 * rowCharacterCount + spacing * (rowCharacterCount - 1)) / 2;
+
+
+                int x = startX + (150 + spacing) * (i % Math.Min(charactersPerRow, aliveCharacters.Count));
+                int y = (105 + spacing)*((int)Math.Floor((double)i / charactersPerRow));
+
+                GUIButton characterButton = new GUIButton(new Rectangle(x+75, y, 150, 40), "", null, Alignment.TopCenter, "GUITextBox", frame);
+                
+                characterButton.UserData = character;
+                characterButton.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+                
+                characterButton.Color = Character.Controlled == character ? Color.Gold : Color.White;
+                /*characterButton.HoverColor = Color.LightGray * 0.5f;
+                characterButton.SelectedColor = Color.Gold * 0.6f;
+                characterButton.OutlineColor = Color.LightGray * 0.8f;*/
+
+                characterFrameBottom = Math.Max(characterFrameBottom, characterButton.Rect.Bottom);
+                
+                string name = character.Info.Name;
+                if (character.Info.Job != null) name += '\n' + "(" + character.Info.Job.Name + ")";
+
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(40, 0, 0, 25),
+                    name,
+                    Color.Transparent, null,
+                    Alignment.Left, Alignment.Left,
+                    "", characterButton, false);
+                textBlock.Font = GUI.SmallFont;
+                textBlock.Padding = new Vector4(5.0f, 0.0f, 5.0f, 0.0f);
+
+                new GUIImage(new Rectangle(-5, -5, 0, 0), character.AnimController.Limbs[0].sprite, Alignment.Left, characterButton);
+
+                var humanAi = character.AIController as HumanAIController;
+                if (humanAi != null && humanAi.CurrentOrder != null)
+                {
+                    CreateCharacterOrderFrame(characterButton, humanAi.CurrentOrder, humanAi.CurrentOrderOption);
+                }
+
+                i++;
+            }
+
+            foreach (GUIComponent child in frame.children)
+            {
+                if (!(child.UserData is Order)) continue;
+
+                Rectangle rect = child.Rect;
+                rect.Y += characterFrameBottom;
+
+                child.Rect = rect;
+            }
+        }
+
+        public void SelectCharacter(Character character)
+        {
+            var characterButton = frame.FindChild(character) as GUIButton;
+
+            if (characterButton == null) return;
+
+            characterButton.Selected = true;
+        }
+
+        private bool SetOrder(GUIButton button, object userData)
+        {
+            Order order = userData as Order;
+
+            foreach (GUIComponent child in frame.children)
+            {
+                var characterButton = child as GUIButton;
+                characterButton.State = GUIComponent.ComponentState.None;
+
+                if (!characterButton.Selected) continue;
+                characterButton.Selected = false;
+
+                CreateCharacterOrderFrame(characterButton, order, "");
+
+                var humanAi = (characterButton.UserData as Character).AIController as HumanAIController;
+
+                humanAi.SetOrder(order, "");
+            }
+
+            //characterList.Deselect();
+
+            return true;
+        }
+
+        private void CreateCharacterOrderFrame(GUIComponent characterFrame, Order order, string selectedOption)
+        {
+            var character = characterFrame.UserData as Character;
+            if (character == null) return;
+
+            var humanAi = character.AIController as HumanAIController;
+            if (humanAi == null) return;
+
+            var existingOrder = characterFrame.children.Find(c => c.UserData is Order);
+            if (existingOrder != null) characterFrame.RemoveChild(existingOrder);
+
+            var orderFrame = new GUIFrame(new Rectangle(-5, characterFrame.Rect.Height, characterFrame.Rect.Width, 30 + order.Options.Length * 15), "InnerFrame", characterFrame);
+            /*orderFrame.OutlineColor = Color.LightGray * 0.5f;*/
+            orderFrame.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+            orderFrame.UserData = order;
+
+            var img = new GUIImage(new Rectangle(0, 0, 20, 20), order.SymbolSprite, Alignment.TopLeft, orderFrame);
+            img.Scale = 20.0f / img.SourceRect.Width;
+            img.Color = order.Color;
+            img.CanBeFocused = false;
+
+            new GUITextBlock(new Rectangle(img.Rect.Width, 0, 0, 20), order.DoingText, "", Alignment.TopLeft, Alignment.CenterLeft, orderFrame);
+            
+            var optionList = new GUIListBox(new Rectangle(0, 20, 0, 80), Color.Transparent, null, orderFrame);
+            optionList.UserData = order;
+
+            for (int i = 0; i < order.Options.Length; i++ )
+            {
+                var optionBox = new GUITextBlock(new Rectangle(0, 0, 0, 15), order.Options[i], "", Alignment.TopLeft, Alignment.CenterLeft, optionList);
+                optionBox.Font = GUI.SmallFont;
+                optionBox.UserData = order.Options[i];
+
+                if (selectedOption == order.Options[i])
+                {
+                    optionList.Select(i);
+                }
+            }
+            optionList.OnSelected = SelectOrderOption;
+
+        }
+
+        private bool SelectOrderOption(GUIComponent component, object userData)
+        {
+            string option = userData.ToString();
+            Order order = component.Parent.UserData as Order;
+            Character character = component.Parent.Parent.Parent.UserData as Character;
+
+            var humanAi = character.AIController as HumanAIController;
+            if (humanAi == null) return false;
+
+            humanAi.SetOrder(order, option);
+
+            return true;
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (!IsOpen) return;
+
+            frame.Draw(spriteBatch);
+        }
+    }
+}

BarotraumaClient/Source/Characters/AICharacter.cs

@@ -0,0 +1,16 @@
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    partial class AICharacter : Character
+    {
+        public override void DrawFront(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch, Camera cam)
+        {
+            base.DrawFront(spriteBatch, cam);
+
+            if (GameMain.DebugDraw && !IsDead) aiController.DebugDraw(spriteBatch);
+        }
+
+    }
+}

BarotraumaClient/Source/Characters/Character.cs

@@ -14,6 +14,9 @@ namespace Barotrauma
 {
     partial class Character : Entity, IDamageable, IPropertyObject, IClientSerializable, IServerSerializable
     {
+        protected float soundTimer;
+        protected float soundInterval;
+
         private List<CharacterSound> sounds;
 
         //the Character that the player is currently controlling

BarotraumaClient/Source/Characters/Limb.cs

@@ -15,6 +15,8 @@ namespace Barotrauma
 {
     partial class Limb
     {
+        public readonly LightSource LightSource;
+
         Sound hitSound;
 
         public Sound HitSound

BarotraumaClient/Source/GUI/GUI.cs

@@ -6,15 +6,6 @@ using System.Collections.Generic;
 
 namespace Barotrauma
 {
-    [Flags]
-    public enum Alignment 
-    { 
-        CenterX = 1, Left = 2, Right = 4, CenterY = 8, Top = 16, Bottom = 32,
-        TopLeft = (Top | Left),         TopCenter = (CenterX | Top),        TopRight = (Top | Right),       
-        CenterLeft = (Left | CenterY),  Center = (CenterX | CenterY),       CenterRight = (Right | CenterY),
-        BottomLeft = (Bottom | Left),   BottomCenter = (CenterX | Bottom),  BottomRight = (Bottom | Right), 
-    }
-
     public enum GUISoundType
     {
         Message,

BarotraumaClient/Source/Items/Components/Door.cs

@@ -0,0 +1,142 @@
+using Barotrauma.Lights;
+using Barotrauma.Networking;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+
+
+namespace Barotrauma.Items.Components
+{
+    partial class Door : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        private ConvexHull convexHull;
+        private ConvexHull convexHull2;
+
+        private Vector2[] GetConvexHullCorners(Rectangle rect)
+        {
+            Vector2[] corners = new Vector2[4];
+            corners[0] = new Vector2(rect.X, rect.Y - rect.Height);
+            corners[1] = new Vector2(rect.X, rect.Y);
+            corners[2] = new Vector2(rect.Right, rect.Y);
+            corners[3] = new Vector2(rect.Right, rect.Y - rect.Height);
+
+            return corners;
+        }
+
+        private void UpdateConvexHulls()
+        {
+            doorRect = new Rectangle(
+                item.Rect.Center.X - (int)(doorSprite.size.X / 2),
+                item.Rect.Y - item.Rect.Height / 2 + (int)(doorSprite.size.Y / 2.0f),
+                (int)doorSprite.size.X,
+                (int)doorSprite.size.Y);
+
+            Rectangle rect = doorRect;
+            if (isHorizontal)
+            {
+                rect.Width = (int)(rect.Width * (1.0f - openState));
+            }
+            else
+            {
+                rect.Height = (int)(rect.Height * (1.0f - openState));
+            }
+
+            if (window.Height > 0 && window.Width > 0)
+            {
+                rect.Height = -window.Y;
+
+                rect.Y += (int)(doorRect.Height * openState);
+                rect.Height = Math.Max(rect.Height - (rect.Y - doorRect.Y), 0);
+                rect.Y = Math.Min(doorRect.Y, rect.Y);
+                
+                if (convexHull2 != null)
+                {
+                    Rectangle rect2 = doorRect;
+                    rect2.Y = rect2.Y + window.Y - window.Height;
+
+                    rect2.Y += (int)(doorRect.Height * openState);
+                    rect2.Y = Math.Min(doorRect.Y, rect2.Y);
+                    rect2.Height = rect2.Y - (doorRect.Y - (int)(doorRect.Height * (1.0f - openState)));
+                    //convexHull2.SetVertices(GetConvexHullCorners(rect2));
+
+                    if (rect2.Height == 0)
+                    {
+                        convexHull2.Enabled = false;
+                    }
+                    else
+                    {
+                        convexHull2.Enabled = true;
+                        convexHull2.SetVertices(GetConvexHullCorners(rect2));
+                    }
+                }
+            }
+            
+            if (convexHull == null) return;
+
+            if (rect.Height == 0 || rect.Width == 0)
+            {
+                convexHull.Enabled = false;
+            }
+            else
+            {
+                convexHull.Enabled = true;
+                convexHull.SetVertices(GetConvexHullCorners(rect));
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing)
+        {
+            Color color = (item.IsSelected) ? Color.Green : Color.White;
+            color = color * (item.Condition / 100.0f);
+            color.A = 255;
+
+            //prefab.sprite.Draw(spriteBatch, new Vector2(rect.X, -rect.Y), new Vector2(rect.Width, rect.Height), color);
+
+            if (stuck > 0.0f && weldedSprite != null)
+            {
+                Vector2 weldSpritePos = new Vector2(item.Rect.Center.X, item.Rect.Y - item.Rect.Height / 2.0f);
+                if (item.Submarine != null) weldSpritePos += item.Submarine.Position;
+                weldSpritePos.Y = -weldSpritePos.Y;
+
+                weldedSprite.Draw(spriteBatch,
+                    weldSpritePos, Color.White * (stuck / 100.0f), 0.0f, 1.0f);
+            }
+
+            if (openState == 1.0f)
+            {
+                body.Enabled = false;
+                return;
+            }
+
+            if (isHorizontal)
+            {
+                Vector2 pos = new Vector2(item.Rect.X, item.Rect.Y - item.Rect.Height / 2);
+                if (item.Submarine != null) pos += item.Submarine.DrawPosition;
+                pos.Y = -pos.Y;
+
+                spriteBatch.Draw(doorSprite.Texture, pos,
+                    new Rectangle((int)(doorSprite.SourceRect.X + doorSprite.size.X * openState), (int)doorSprite.SourceRect.Y,
+                     (int)(doorSprite.size.X * (1.0f - openState)), (int)doorSprite.size.Y),
+                    color, 0.0f, doorSprite.Origin, 1.0f, SpriteEffects.None, doorSprite.Depth);
+            }
+            else
+            {
+                Vector2 pos = new Vector2(item.Rect.Center.X, item.Rect.Y);
+                if (item.Submarine != null) pos += item.Submarine.DrawPosition;
+                pos.Y = -pos.Y;
+
+                spriteBatch.Draw(doorSprite.Texture, pos,
+                    new Rectangle(doorSprite.SourceRect.X, (int)(doorSprite.SourceRect.Y + doorSprite.size.Y * openState),
+                    (int)doorSprite.size.X, (int)(doorSprite.size.Y * (1.0f - openState))),
+                    color, 0.0f, doorSprite.Origin, 1.0f, SpriteEffects.None, doorSprite.Depth);
+            }
+
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/ItemComponent.cs

@@ -0,0 +1,273 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Networking;
+using System.IO;
+
+namespace Barotrauma.Items.Components
+{
+    class ItemSound
+    {
+        public readonly Sound Sound;
+        public readonly ActionType Type;
+
+        public string VolumeProperty;
+
+        public float VolumeMultiplier;
+
+        public readonly float Range;
+
+        public readonly bool Loop;
+
+        public ItemSound(Sound sound, ActionType type, float range, bool loop = false)
+        {
+            this.Sound = sound;
+            this.Type = type;
+            this.Range = range;
+
+            this.Loop = loop;
+        }
+    }
+
+    partial class ItemComponent : IPropertyObject
+    {
+        private Dictionary<ActionType, List<ItemSound>> sounds;
+
+        private GUIFrame guiFrame;
+
+        protected GUIFrame GuiFrame
+        {
+            get
+            {
+                if (guiFrame == null)
+                {
+                    DebugConsole.ThrowError("Error: the component " + name + " in " + item.Name + " doesn't have a GuiFrame component");
+                    guiFrame = new GUIFrame(new Rectangle(0, 0, 100, 100), Color.Black);
+                }
+                return guiFrame;
+            }
+        }
+
+        private ItemSound loopingSound;
+        private int loopingSoundIndex;
+        public void PlaySound(ActionType type, Vector2 position)
+        {
+            if (loopingSound != null)
+            {
+                loopingSoundIndex = loopingSound.Sound.Loop(loopingSoundIndex, GetSoundVolume(loopingSound), position, loopingSound.Range);
+                return;
+            }
+
+            List<ItemSound> matchingSounds;
+            if (!sounds.TryGetValue(type, out matchingSounds)) return;
+
+            ItemSound itemSound = null;
+            if (!Sounds.SoundManager.IsPlaying(loopingSoundIndex))
+            {
+                int index = Rand.Int(matchingSounds.Count);
+                itemSound = matchingSounds[index];
+            }
+
+            if (itemSound == null) return;
+
+            if (itemSound.Loop)
+            {
+                loopingSound = itemSound;
+
+                loopingSoundIndex = loopingSound.Sound.Loop(loopingSoundIndex, GetSoundVolume(loopingSound), position, loopingSound.Range);
+            }
+            else
+            {
+                float volume = GetSoundVolume(itemSound);
+                if (volume == 0.0f) return;
+                itemSound.Sound.Play(volume, itemSound.Range, position);
+            }
+        }
+
+        public void StopSounds(ActionType type)
+        {
+            if (loopingSoundIndex <= 0) return;
+
+            if (loopingSound == null) return;
+
+            if (loopingSound.Type != type) return;
+
+            if (Sounds.SoundManager.IsPlaying(loopingSoundIndex))
+            {
+                Sounds.SoundManager.Stop(loopingSoundIndex);
+                loopingSound = null;
+                loopingSoundIndex = -1;
+            }
+        }
+
+        private float GetSoundVolume(ItemSound sound)
+        {
+            if (sound == null) return 0.0f;
+            if (sound.VolumeProperty == "") return 1.0f;
+
+            ObjectProperty op = null;
+            if (properties.TryGetValue(sound.VolumeProperty.ToLowerInvariant(), out op))
+            {
+                float newVolume = 0.0f;
+                try
+                {
+                    newVolume = (float)op.GetValue();
+                }
+                catch
+                {
+                    return 0.0f;
+                }
+                newVolume *= sound.VolumeMultiplier;
+
+                return MathHelper.Clamp(newVolume, 0.0f, 1.0f);
+            }
+
+            return 0.0f;
+        }
+
+        //public virtual void Draw(SpriteBatch spriteBatch, bool editing = false) 
+        //{
+        //    item.drawableComponents = Array.FindAll(item.drawableComponents, i => i != this);
+        //}
+
+        public virtual void DrawHUD(SpriteBatch spriteBatch, Character character) { }
+
+        public virtual void AddToGUIUpdateList() { }
+
+        public virtual void UpdateHUD(Character character) { }
+
+        private bool LoadElemProjSpecific(XElement subElement)
+        {
+            switch (subElement.Name.ToString().ToLowerInvariant())
+            {
+                case "guiframe":
+                    string rectStr = ToolBox.GetAttributeString(subElement, "rect", "0.0,0.0,0.5,0.5");
+
+                    string[] components = rectStr.Split(',');
+                    if (components.Length < 4) break;
+
+                    Vector4 rect = ToolBox.GetAttributeVector4(subElement, "rect", Vector4.One);
+                    if (components[0].Contains(".")) rect.X *= GameMain.GraphicsWidth;
+                    if (components[1].Contains(".")) rect.Y *= GameMain.GraphicsHeight;
+                    if (components[2].Contains(".")) rect.Z *= GameMain.GraphicsWidth;
+                    if (components[3].Contains(".")) rect.W *= GameMain.GraphicsHeight;
+
+                    string style = ToolBox.GetAttributeString(subElement, "style", "");
+
+                    Vector4 color = ToolBox.GetAttributeVector4(subElement, "color", Vector4.One);
+
+                    Alignment alignment = Alignment.Center;
+                    try
+                    {
+                        alignment = (Alignment)Enum.Parse(typeof(Alignment),
+                            ToolBox.GetAttributeString(subElement, "alignment", "Center"), true);
+                    }
+                    catch
+                    {
+                        DebugConsole.ThrowError("Error in " + subElement.Parent + "! \"" + subElement.Parent.Attribute("type").Value + "\" is not a valid alignment");
+                    }
+
+                    guiFrame = new GUIFrame(
+                        new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Z, (int)rect.W),
+                        new Color(color.X, color.Y, color.Z) * color.W,
+                        alignment, style);
+
+                    break;
+                case "sound":
+                    string filePath = ToolBox.GetAttributeString(subElement, "file", "");
+
+                    if (filePath == "") filePath = ToolBox.GetAttributeString(subElement, "sound", "");
+
+                    if (filePath == "")
+                    {
+                        DebugConsole.ThrowError("Error when instantiating item \"" + item.Name + "\" - sound with no file path set");
+                        break;
+                    }
+
+                    if (!filePath.Contains("/") && !filePath.Contains("\\") && !filePath.Contains(Path.DirectorySeparatorChar))
+                    {
+                        filePath = Path.Combine(Path.GetDirectoryName(item.Prefab.ConfigFile), filePath);
+                    }
+
+                    ActionType type;
+
+                    try
+                    {
+                        type = (ActionType)Enum.Parse(typeof(ActionType), ToolBox.GetAttributeString(subElement, "type", ""), true);
+                    }
+                    catch (Exception e)
+                    {
+                        DebugConsole.ThrowError("Invalid sound type in " + subElement + "!", e);
+                        break;
+                    }
+
+                    Sound sound = Sound.Load(filePath);
+
+                    float range = ToolBox.GetAttributeFloat(subElement, "range", 800.0f);
+                    bool loop = ToolBox.GetAttributeBool(subElement, "loop", false);
+                    ItemSound itemSound = new ItemSound(sound, type, range, loop);
+                    itemSound.VolumeProperty = ToolBox.GetAttributeString(subElement, "volume", "");
+                    itemSound.VolumeMultiplier = ToolBox.GetAttributeFloat(subElement, "volumemultiplier", 1.0f);
+
+                    List<ItemSound> soundList = null;
+                    if (!sounds.TryGetValue(itemSound.Type, out soundList))
+                    {
+                        soundList = new List<ItemSound>();
+                        sounds.Add(itemSound.Type, soundList);
+                    }
+
+                    soundList.Add(itemSound);
+                    break;
+                default:
+                    return false; //unknown element
+            }
+            return true; //element processed
+        }
+
+        //Starts a coroutine that will read the correct state of the component from the NetBuffer when correctionTimer reaches zero.
+        protected void StartDelayedCorrection(ServerNetObject type, NetBuffer buffer, float sendingTime)
+        {
+            if (delayedCorrectionCoroutine != null) CoroutineManager.StopCoroutines(delayedCorrectionCoroutine);
+
+            delayedCorrectionCoroutine = CoroutineManager.StartCoroutine(DoDelayedCorrection(type, buffer, sendingTime));
+        }
+
+        private IEnumerable<object> DoDelayedCorrection(ServerNetObject type, NetBuffer buffer, float sendingTime)
+        {
+            while (correctionTimer > 0.0f)
+            {
+                correctionTimer -= CoroutineManager.DeltaTime;
+                yield return CoroutineStatus.Running;
+            }
+
+            ((IServerSerializable)this).ClientRead(type, buffer, sendingTime);
+
+            correctionTimer = 0.0f;
+            delayedCorrectionCoroutine = null;
+
+            yield return CoroutineStatus.Success;
+        }
+
+        public virtual XElement Save(XElement parentElement)
+        {
+            XElement componentElement = new XElement(name);
+
+            foreach (RelatedItem ri in requiredItems)
+            {
+                XElement newElement = new XElement("requireditem");
+                ri.Save(newElement);
+                componentElement.Add(newElement);
+            }
+
+            ObjectProperty.SaveProperties(this, componentElement);
+
+            parentElement.Add(componentElement);
+            return componentElement;
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/ItemContainer.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma.Items.Components
+{
+    partial class ItemContainer : ItemComponent, IDrawableComponent
+    {
+        //TODO: shouldn't this be overriding the base method?
+        public void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            if (hideItems || (item.body != null && !item.body.Enabled)) return;
+
+            Vector2 transformedItemPos = itemPos;
+            Vector2 transformedItemInterval = itemInterval;
+            float currentRotation = itemRotation;
+
+            if (item.body == null)
+            {
+                transformedItemPos = new Vector2(item.Rect.X, item.Rect.Y);
+                if (item.Submarine != null) transformedItemPos += item.Submarine.DrawPosition;
+                transformedItemPos = transformedItemPos + itemPos;
+            }
+            else
+            {
+                //item.body.Enabled = true;
+
+                Matrix transform = Matrix.CreateRotationZ(item.body.Rotation);
+
+                if (item.body.Dir == -1.0f)
+                {
+                    transformedItemPos.X = -transformedItemPos.X;
+                    transformedItemInterval.X = -transformedItemInterval.X;
+                }
+                transformedItemPos = Vector2.Transform(transformedItemPos, transform);
+                transformedItemInterval = Vector2.Transform(transformedItemInterval, transform);
+
+                transformedItemPos += item.DrawPosition;
+
+                currentRotation += item.body.Rotation;
+            }
+
+            foreach (Item containedItem in Inventory.Items)
+            {
+                if (containedItem == null) continue;
+
+                containedItem.Sprite.Draw(
+                    spriteBatch,
+                    new Vector2(transformedItemPos.X, -transformedItemPos.Y),
+                    -currentRotation,
+                    1.0f,
+                    (item.body != null && item.body.Dir == -1) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
+
+                transformedItemPos += transformedItemInterval;
+            }
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            Inventory.Update((float)Timing.Step);
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            Inventory.Draw(spriteBatch);
+        }
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement componentElement = base.Save(parentElement);
+
+            string[] itemIdStrings = new string[Inventory.Items.Length];
+            for (int i = 0; i < Inventory.Items.Length; i++)
+            {
+                itemIdStrings[i] = (Inventory.Items[i] == null) ? "0" : Inventory.Items[i].ID.ToString();
+            }
+
+            componentElement.Add(new XAttribute("contained", string.Join(",", itemIdStrings)));
+
+            return componentElement;
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/LightComponent.cs

@@ -0,0 +1,27 @@
+using Microsoft.Xna.Framework;
+using Barotrauma.Lights;
+using System;
+using System.Xml.Linq;
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma.Items.Components
+{
+    partial class LightComponent : Powered, IServerSerializable, IDrawableComponent
+    {
+        private LightSource light;
+
+        public void Draw(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch, bool editing = false)
+        {
+            if (light.LightSprite != null && (item.body == null || item.body.Enabled))
+            {
+                light.LightSprite.Draw(spriteBatch, new Vector2(item.DrawPosition.X, -item.DrawPosition.Y), lightColor * lightBrightness, 0.0f, 1.0f, Microsoft.Xna.Framework.Graphics.SpriteEffects.None, item.Sprite.Depth - 0.0001f);
+            }
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            IsOn = msg.ReadBoolean();
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Deconstructor.cs

@@ -0,0 +1,61 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Deconstructor : Powered, IServerSerializable, IClientSerializable
+    {
+        GUIProgressBar progressBar;
+        GUIButton activateButton;
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            GuiFrame.Draw(spriteBatch);
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update((float)Timing.Step);
+        }
+
+        private bool ToggleActive(GUIButton button, object obj)
+        {
+            SetActive(!IsActive, Character.Controlled);
+
+            currPowerConsumption = IsActive ? powerConsumption : 0.0f;
+
+            if (GameMain.Server != null)
+            {
+                item.CreateServerEvent(this);
+            }
+            else if (GameMain.Client != null)
+            {
+                item.CreateClientEvent(this);
+            }
+
+            return true;
+        }
+
+        public void ClientWrite(NetBuffer msg, object[] extraData = null)
+        {
+            msg.Write(IsActive);
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            SetActive(msg.ReadBoolean());
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Engine.cs

@@ -0,0 +1,38 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Engine : Powered
+    {
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            //isActive = true;
+            GuiFrame.Draw(spriteBatch);
+
+            //int width = 300, height = 300;
+            //int x = Game1.GraphicsWidth / 2 - width / 2;
+            //int y = Game1.GraphicsHeight / 2 - height / 2 - 50;
+
+            //GUI.DrawRectangle(spriteBatch, new Rectangle(x, y, width, height), Color.Black, true);
+
+            GUI.Font.DrawString(spriteBatch, "Force: " + (int)(targetForce) + " %", new Vector2(GuiFrame.Rect.X + 30, GuiFrame.Rect.Y + 30), Color.White);
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update(1.0f / 60.0f);
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Fabricator.cs

@@ -0,0 +1,243 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Fabricator : Powered, IServerSerializable, IClientSerializable
+    {
+        private GUIListBox itemList;
+
+        private GUIFrame selectedItemFrame;
+
+        private GUIProgressBar progressBar;
+        private GUIButton activateButton;
+
+        private void InitProjSpecific()
+        {
+            GuiFrame.Padding = new Vector4(20.0f, 20.0f, 20.0f, 20.0f);
+
+            itemList = new GUIListBox(new Rectangle(0, 0, GuiFrame.Rect.Width / 2 - 20, 0), "", GuiFrame);
+            itemList.OnSelected = SelectItem;
+
+            foreach (FabricableItem fi in fabricableItems)
+            {
+                GUIFrame frame = new GUIFrame(new Rectangle(0, 0, 0, 50), Color.Transparent, null, itemList)
+                {
+                    UserData = fi,
+                    Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f),
+                    HoverColor = Color.Gold * 0.2f,
+                    SelectedColor = Color.Gold * 0.5f,
+                    ToolTip = fi.TargetItem.Description
+                };
+
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(40, 0, 0, 25),
+                    fi.TargetItem.Name,
+                    Color.Transparent, Color.White,
+                    Alignment.Left, Alignment.Left,
+                    null, frame);
+                textBlock.ToolTip = fi.TargetItem.Description;
+                textBlock.Padding = new Vector4(5.0f, 0.0f, 5.0f, 0.0f);
+
+                if (fi.TargetItem.sprite != null)
+                {
+                    GUIImage img = new GUIImage(new Rectangle(0, 0, 40, 40), fi.TargetItem.sprite, Alignment.Left, frame);
+                    img.Scale = Math.Min(Math.Min(40.0f / img.SourceRect.Width, 40.0f / img.SourceRect.Height), 1.0f);
+                    img.Color = fi.TargetItem.SpriteColor;
+                    img.ToolTip = fi.TargetItem.Description;
+                }
+            }
+        }
+        
+        private bool SelectItem(GUIComponent component, object obj)
+        {
+            FabricableItem targetItem = obj as FabricableItem;
+            if (targetItem == null) return false;
+
+            if (selectedItemFrame != null) GuiFrame.RemoveChild(selectedItemFrame);
+
+            //int width = 200, height = 150;
+            selectedItemFrame = new GUIFrame(new Rectangle(0, 0, (int)(GuiFrame.Rect.Width * 0.4f), 300), Color.Black * 0.8f, Alignment.CenterY | Alignment.Right, null, GuiFrame);
+
+            selectedItemFrame.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+
+            progressBar = new GUIProgressBar(new Rectangle(0, 0, 0, 20), Color.Green, "", 0.0f, Alignment.BottomCenter, selectedItemFrame);
+            progressBar.IsHorizontal = true;
+
+            if (targetItem.TargetItem.sprite != null)
+            {
+                int y = 0;
+
+                GUIImage img = new GUIImage(new Rectangle(10, 0, 40, 40), targetItem.TargetItem.sprite, Alignment.TopLeft, selectedItemFrame);
+                img.Scale = Math.Min(Math.Min(40.0f / img.SourceRect.Width, 40.0f / img.SourceRect.Height), 1.0f);
+                img.Color = targetItem.TargetItem.SpriteColor;
+
+                new GUITextBlock(
+                    new Rectangle(60, 0, 0, 25),
+                    targetItem.TargetItem.Name,
+                    Color.Transparent, Color.White,
+                    Alignment.TopLeft,
+                    Alignment.TopLeft, null,
+                    selectedItemFrame, true);
+
+                y += 40;
+
+                if (!string.IsNullOrWhiteSpace(targetItem.TargetItem.Description))
+                {
+                    var description = new GUITextBlock(
+                        new Rectangle(0, y, 0, 0),
+                        targetItem.TargetItem.Description,
+                        "", Alignment.TopLeft, Alignment.TopLeft,
+                        selectedItemFrame, true, GUI.SmallFont);
+
+                    y += description.Rect.Height + 10;
+                }
+
+
+                List<Skill> inadequateSkills = new List<Skill>();
+
+                if (Character.Controlled != null)
+                {
+                    inadequateSkills = targetItem.RequiredSkills.FindAll(skill => Character.Controlled.GetSkillLevel(skill.Name) < skill.Level);
+                }
+
+                Color textColor = Color.White;
+                string text;
+                if (!inadequateSkills.Any())
+                {
+                    text = "Required items:\n";
+                    foreach (Tuple<ItemPrefab, int> ip in targetItem.RequiredItems)
+                    {
+                        text += "   - " + ip.Item1.Name + " x" + ip.Item2 + "\n";
+                    }
+                    text += "Required time: " + targetItem.RequiredTime + " s";
+                }
+                else
+                {
+                    text = "Skills required to calibrate:\n";
+                    foreach (Skill skill in inadequateSkills)
+                    {
+                        text += "   - " + skill.Name + " lvl " + skill.Level + "\n";
+                    }
+
+                    textColor = Color.Red;
+                }
+
+                new GUITextBlock(
+                    new Rectangle(0, y, 0, 25),
+                    text,
+                    Color.Transparent, textColor,
+                    Alignment.TopLeft,
+                    Alignment.TopLeft, null,
+                    selectedItemFrame);
+
+                activateButton = new GUIButton(new Rectangle(0, -30, 100, 20), "Create", Color.White, Alignment.CenterX | Alignment.Bottom, "", selectedItemFrame);
+                activateButton.OnClicked = StartButtonClicked;
+                activateButton.UserData = targetItem;
+                activateButton.Enabled = false;
+            }
+
+            return true;
+        }
+
+        private bool StartButtonClicked(GUIButton button, object obj)
+        {
+            if (fabricatedItem == null)
+            {
+                StartFabricating(obj as FabricableItem, Character.Controlled);
+            }
+            else
+            {
+                CancelFabricating(Character.Controlled);
+            }
+
+            if (GameMain.Server != null)
+            {
+                item.CreateServerEvent(this);
+            }
+            else if (GameMain.Client != null)
+            {
+                item.CreateClientEvent(this);
+            }
+
+            return true;
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            GuiFrame.Draw(spriteBatch);
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            FabricableItem targetItem = itemList.SelectedData as FabricableItem;
+            if (targetItem != null)
+            {
+                activateButton.Enabled = CanBeFabricated(targetItem, character);
+            }
+
+            if (character != null)
+            {
+                bool itemsChanged = false;
+                if (prevContainedItems == null)
+                {
+                    itemsChanged = true;
+                }
+                else
+                {
+                    var itemContainer = item.GetComponent<ItemContainer>();
+                    for (int i = 0; i < itemContainer.Inventory.Items.Length; i++)
+                    {
+                        if (prevContainedItems[i] != itemContainer.Inventory.Items[i])
+                        {
+                            itemsChanged = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (itemsChanged) CheckFabricableItems(character);
+            }
+
+
+            GuiFrame.Update((float)Timing.Step);
+        }
+
+        public void ClientWrite(NetBuffer msg, object[] extraData = null)
+        {
+            int itemIndex = fabricatedItem == null ? -1 : fabricableItems.IndexOf(fabricatedItem);
+            msg.WriteRangedInteger(-1, fabricableItems.Count - 1, itemIndex);
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            int itemIndex = msg.ReadRangedInteger(-1, fabricableItems.Count - 1);
+
+            if (itemIndex == -1)
+            {
+                CancelFabricating();
+            }
+            else
+            {
+                //if already fabricating the selected item, return
+                if (fabricatedItem != null && fabricableItems.IndexOf(fabricatedItem) == itemIndex) return;
+                if (itemIndex < 0 || itemIndex >= fabricableItems.Count) return;
+
+                SelectItem(null, fabricableItems[itemIndex]);
+                StartFabricating(fabricableItems[itemIndex]);
+            }
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/MiniMap.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class MiniMap : Powered
+    {
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            if (item.Submarine == null) return;
+
+            int width = GuiFrame.Rect.Width, height = GuiFrame.Rect.Height;
+            int x = GuiFrame.Rect.X;
+            int y = GuiFrame.Rect.Y;
+
+            GuiFrame.Draw(spriteBatch);
+
+            if (!hasPower) return;
+
+            Rectangle miniMap = new Rectangle(x + 20, y + 40, width - 40, height - 60);
+
+            float size = Math.Min((float)miniMap.Width / (float)item.Submarine.Borders.Width, (float)miniMap.Height / (float)item.Submarine.Borders.Height);
+            foreach (Hull hull in Hull.hullList)
+            {
+                Point topLeft = new Point(
+                    miniMap.X + (int)((hull.Rect.X - item.Submarine.HiddenSubPosition.X - item.Submarine.Borders.X) * size),
+                    miniMap.Y - (int)((hull.Rect.Y - item.Submarine.HiddenSubPosition.Y - item.Submarine.Borders.Y) * size));
+
+                Point bottomRight = new Point(
+                    topLeft.X + (int)(hull.Rect.Width * size),
+                    topLeft.Y + (int)(hull.Rect.Height * size));
+
+                topLeft.X = (int)MathUtils.RoundTowardsClosest(topLeft.X, 4);
+                topLeft.Y = (int)MathUtils.RoundTowardsClosest(topLeft.Y, 4);
+                bottomRight.X = (int)MathUtils.RoundTowardsClosest(bottomRight.X, 4);
+                bottomRight.Y = (int)MathUtils.RoundTowardsClosest(bottomRight.Y, 4);
+
+                Rectangle hullRect = new Rectangle(
+                    topLeft, bottomRight - topLeft);
+
+                HullData hullData;
+                hullDatas.TryGetValue(hull, out hullData);
+
+                Color borderColor = Color.Green;
+
+
+                //hull integrity -----------------------------------
+
+                float? gapOpenSum = 0.0f;
+                if (ShowHullIntegrity)
+                {
+                    gapOpenSum = hull.ConnectedGaps.Where(g => !g.IsRoomToRoom).Sum(g => g.Open);
+                    borderColor = Color.Lerp(borderColor, Color.Red, Math.Min((float)gapOpenSum, 1.0f));
+                }
+
+                //oxygen -----------------------------------
+
+                float? oxygenAmount = null;
+                if (RequireOxygenDetectors && (hullData == null || hullData.Oxygen == null))
+                {
+                    borderColor *= 0.5f;
+                }
+                else
+                {
+                    oxygenAmount = hullData != null && hullData.Oxygen != null ? (float)hullData.Oxygen : hull.OxygenPercentage;
+                    GUI.DrawRectangle(spriteBatch, hullRect, Color.Lerp(Color.Red * 0.5f, Color.Green * 0.3f, (float)oxygenAmount / 100.0f), true);
+                }
+
+                //water -----------------------------------
+
+                float? waterAmount = null;
+                if (RequireWaterDetectors && (hullData == null || hullData.Water == null))
+                {
+                    borderColor *= 0.5f;
+                }
+                else
+                {
+                    waterAmount = hullData != null && hullData.Water != null ?
+                        (float)hullData.Water :
+                        Math.Min(hull.Volume / hull.FullVolume, 1.0f);
+
+                    if (hullRect.Height * waterAmount > 3.0f)
+                    {
+                        Rectangle waterRect = new Rectangle(
+                            hullRect.X,
+                            (int)(hullRect.Y + hullRect.Height * (1.0f - waterAmount)),
+                            hullRect.Width,
+                            (int)(hullRect.Height * waterAmount));
+
+                        waterRect.Inflate(-3, -3);
+
+                        GUI.DrawRectangle(spriteBatch, waterRect, Color.DarkBlue, true);
+                        GUI.DrawLine(spriteBatch, new Vector2(waterRect.X, waterRect.Y), new Vector2(waterRect.Right, waterRect.Y), Color.LightBlue);
+                    }
+                }
+
+                if (hullRect.Contains(PlayerInput.MousePosition))
+                {
+                    borderColor = Color.White;
+
+                    if (gapOpenSum > 0.1f)
+                    {
+                        GUI.DrawString(spriteBatch,
+                            new Vector2(x + 10, y + height - 60),
+                            "Hull breach", Color.Red, Color.Black * 0.5f, 2, GUI.SmallFont);
+                    }
+
+                    GUI.DrawString(spriteBatch,
+                        new Vector2(x + 10, y + height - 60),
+                        oxygenAmount == null ? "Air quality data not available" : "Air quality: " + (int)oxygenAmount + " %",
+                        oxygenAmount == null ? Color.Red : Color.Lerp(Color.Red, Color.LightGreen, (float)oxygenAmount / 100.0f),
+                        Color.Black * 0.5f, 2, GUI.SmallFont);
+
+                    GUI.DrawString(spriteBatch,
+                        new Vector2(x + 10, y + height - 40),
+                        waterAmount == null ? "Water level data not available" : "Water level: " + (int)(waterAmount * 100.0f) + " %",
+                        waterAmount == null ? Color.Red : Color.Lerp(Color.LightGreen, Color.Red, (float)waterAmount),
+                        Color.Black * 0.5f, 2, GUI.SmallFont);
+                }
+
+                GUI.DrawRectangle(spriteBatch, hullRect, borderColor, false, 0.0f, 2);
+            }
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Pump.cs

@@ -0,0 +1,117 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Specialized;
+using System.Globalization;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Pump : Powered, IServerSerializable, IClientSerializable
+    {
+        private GUITickBox isActiveTickBox;
+
+        private void InitProjSpecific()
+        {
+            isActiveTickBox = new GUITickBox(new Rectangle(0, 0, 20, 20), "Running", Alignment.TopLeft, GuiFrame);
+            isActiveTickBox.OnSelected = (GUITickBox box) =>
+            {
+                targetLevel = null;
+                IsActive = !IsActive;
+                if (!IsActive) currPowerConsumption = 0.0f;
+
+                if (GameMain.Server != null)
+                {
+                    item.CreateServerEvent(this);
+                    GameServer.Log(Character.Controlled + (IsActive ? " turned on " : " turned off ") + item.Name, ServerLog.MessageType.ItemInteraction);
+                }
+                else if (GameMain.Client != null)
+                {
+                    correctionTimer = CorrectionDelay;
+                    item.CreateClientEvent(this);
+                }
+
+                return true;
+            };
+
+            var button = new GUIButton(new Rectangle(160, 40, 35, 30), "OUT", "", GuiFrame);
+            button.OnClicked = (GUIButton btn, object obj) =>
+            {
+                FlowPercentage -= 10.0f;
+
+                if (GameMain.Server != null)
+                {
+                    item.CreateServerEvent(this);
+                    GameServer.Log(Character.Controlled + " set the pumping speed of " + item.Name + " to " + (int)(flowPercentage) + " %", ServerLog.MessageType.ItemInteraction);
+                }
+                else if (GameMain.Client != null)
+                {
+                    correctionTimer = CorrectionDelay;
+                    item.CreateClientEvent(this);
+                }
+
+                return true;
+            };
+
+            button = new GUIButton(new Rectangle(210, 40, 35, 30), "IN", "", GuiFrame);
+            button.OnClicked = (GUIButton btn, object obj) =>
+            {
+                FlowPercentage += 10.0f;
+
+                if (GameMain.Server != null)
+                {
+                    item.CreateServerEvent(this);
+                    GameServer.Log(Character.Controlled + " set the pumping speed of " + item.Name + " to " + (int)(flowPercentage) + " %", ServerLog.MessageType.ItemInteraction);
+                }
+                else if (GameMain.Client != null)
+                {
+                    correctionTimer = CorrectionDelay;
+                    item.CreateClientEvent(this);
+                }
+
+                return true;
+            };
+        }
+        
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            int x = GuiFrame.Rect.X;
+            int y = GuiFrame.Rect.Y;
+
+            GuiFrame.Draw(spriteBatch);
+
+            GUI.Font.DrawString(spriteBatch, "Pumping speed: " + (int)flowPercentage + " %", new Vector2(x + 40, y + 85), Color.White);
+
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update(1.0f / 60.0f);
+        }
+
+        public void ClientWrite(Lidgren.Network.NetBuffer msg, object[] extraData = null)
+        {
+            //flowpercentage can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger(-10, 10, (int)(flowPercentage / 10.0f));
+            msg.Write(IsActive);
+        }
+
+        public void ClientRead(ServerNetObject type, Lidgren.Network.NetBuffer 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();
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Radar.cs

@@ -0,0 +1,443 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using Voronoi2;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Radar : Powered, IServerSerializable, IClientSerializable
+    {
+        private GUITickBox isActiveTickBox;
+
+        private List<RadarBlip> radarBlips;
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update((float)Timing.Step);
+
+            for (int i = radarBlips.Count - 1; i >= 0; i--)
+            {
+                radarBlips[i].FadeTimer -= (float)Timing.Step * 0.5f;
+                if (radarBlips[i].FadeTimer <= 0.0f) radarBlips.RemoveAt(i);
+            }
+
+            if (IsActive)
+            {
+                float pingRadius = displayRadius * pingState;
+                Ping(item.WorldPosition, pingRadius, prevPingRadius, displayScale, range, 2.0f);
+                prevPingRadius = pingRadius;
+            }
+
+            float passivePingRadius = (float)Math.Sin(Timing.TotalTime * 10);
+            if (passivePingRadius > 0.0f)
+            {
+                foreach (AITarget t in AITarget.List)
+                {
+                    if (t.SoundRange <= 0.0f) continue;
+
+                    if (Vector2.Distance(t.WorldPosition, item.WorldPosition) < t.SoundRange)
+                    {
+                        Ping(t.WorldPosition, t.SoundRange * passivePingRadius * 0.2f, t.SoundRange * prevPassivePingRadius * 0.2f, displayScale, t.SoundRange, 0.5f);
+
+                        radarBlips.Add(new RadarBlip(t.WorldPosition, 1.0f));
+                    }
+                }
+            }
+            prevPassivePingRadius = passivePingRadius;
+
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            GuiFrame.Draw(spriteBatch);
+
+            int radius = GuiFrame.Rect.Height / 2 - 10;
+            DrawRadar(spriteBatch, new Rectangle((int)GuiFrame.Center.X - radius, (int)GuiFrame.Center.Y - radius, radius * 2, radius * 2));
+        }
+
+        private void DrawRadar(SpriteBatch spriteBatch, Rectangle rect)
+        {
+            center = new Vector2(rect.X + rect.Width * 0.5f, rect.Center.Y);
+            displayRadius = (rect.Width / 2.0f) * (1.0f - displayBorderSize);
+            displayScale = displayRadius / range;
+
+            if (IsActive)
+            {
+                pingCircle.Draw(spriteBatch, center, Color.White * (1.0f - pingState), 0.0f, (displayRadius * 2 / pingCircle.size.X) * pingState);
+            }
+
+            if (item.Submarine != null && !DetectSubmarineWalls)
+            {
+                float simScale = displayScale * Physics.DisplayToSimRation;
+
+                foreach (Submarine submarine in Submarine.Loaded)
+                {
+                    if (submarine != item.Submarine && !submarine.DockedTo.Contains(item.Submarine)) continue;
+
+                    Vector2 offset = ConvertUnits.ToSimUnits(submarine.WorldPosition - item.WorldPosition);
+
+                    for (int i = 0; i < submarine.HullVertices.Count; i++)
+                    {
+                        Vector2 start = (submarine.HullVertices[i] + offset) * simScale;
+                        start.Y = -start.Y;
+                        Vector2 end = (submarine.HullVertices[(i + 1) % submarine.HullVertices.Count] + offset) * simScale;
+                        end.Y = -end.Y;
+
+                        GUI.DrawLine(spriteBatch, center + start, center + end, Color.LightBlue);
+                    }
+                }
+            }
+
+            if (radarBlips.Count > 0)
+            {
+                spriteBatch.End();
+                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive);
+
+                foreach (RadarBlip radarBlip in radarBlips)
+                {
+                    DrawBlip(spriteBatch, radarBlip, center, radarBlip.FadeTimer / 2.0f);
+                }
+
+                spriteBatch.End();
+                spriteBatch.Begin(SpriteSortMode.Immediate, null, null, null, GameMain.ScissorTestEnable);
+            }
+
+            if (GameMain.DebugDraw)
+            {
+                GUI.DrawString(spriteBatch, rect.Location.ToVector2(), radarBlips.Count.ToString(), Color.White);
+            }
+
+            if (screenOverlay != null)
+            {
+                screenOverlay.Draw(spriteBatch, center, 0.0f, rect.Width / screenOverlay.size.X);
+            }
+
+            if (GameMain.GameSession == null) return;
+
+            DrawMarker(spriteBatch,
+                GameMain.GameSession.StartLocation.Name,
+                (Level.Loaded.StartPosition - item.WorldPosition), displayScale, center, (rect.Width * 0.5f));
+
+            DrawMarker(spriteBatch,
+                GameMain.GameSession.EndLocation.Name,
+                (Level.Loaded.EndPosition - item.WorldPosition), displayScale, center, (rect.Width * 0.5f));
+
+            if (GameMain.GameSession.Mission != null)
+            {
+                var mission = GameMain.GameSession.Mission;
+
+                if (!string.IsNullOrWhiteSpace(mission.RadarLabel) && mission.RadarPosition != Vector2.Zero)
+                {
+                    DrawMarker(spriteBatch,
+                        mission.RadarLabel,
+                        mission.RadarPosition - item.WorldPosition, displayScale, center, (rect.Width * 0.55f));
+                }
+            }
+
+            foreach (Submarine sub in Submarine.Loaded)
+            {
+                if (!sub.OnRadar) continue;
+                if (item.Submarine == sub || sub.DockedTo.Contains(item.Submarine)) continue;
+                if (sub.WorldPosition.Y > Level.Loaded.Size.Y) continue;
+
+                DrawMarker(spriteBatch, sub.Name, sub.WorldPosition - item.WorldPosition, displayScale, center, (rect.Width * 0.45f));
+            }
+
+            if (!GameMain.DebugDraw) return;
+
+            var steering = item.GetComponent<Steering>();
+            if (steering == null || steering.SteeringPath == null) return;
+
+            Vector2 prevPos = Vector2.Zero;
+
+            foreach (WayPoint wp in steering.SteeringPath.Nodes)
+            {
+                Vector2 pos = (wp.Position - item.WorldPosition) * 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), (steering.SteeringPath.CurrentNode == wp) ? Color.LightGreen : Color.Green, false);
+
+                if (prevPos != Vector2.Zero)
+                {
+                    GUI.DrawLine(spriteBatch, pos, prevPos, Color.Green);
+                }
+
+                prevPos = pos;
+            }
+        }
+
+
+        private void Ping(Vector2 pingSource, float pingRadius, float prevPingRadius, float displayScale, float range, float pingStrength = 1.0f)
+        {
+            foreach (Submarine submarine in Submarine.Loaded)
+            {
+                if (item.Submarine == submarine && !DetectSubmarineWalls) continue;
+                if (item.Submarine != null && item.Submarine.DockedTo.Contains(submarine)) continue;
+                if (submarine.HullVertices == null) continue;
+
+                for (int i = 0; i < submarine.HullVertices.Count; i++)
+                {
+                    Vector2 start = ConvertUnits.ToDisplayUnits(submarine.HullVertices[i]);
+                    Vector2 end = ConvertUnits.ToDisplayUnits(submarine.HullVertices[(i + 1) % submarine.HullVertices.Count]);
+
+                    if (item.Submarine == submarine)
+                    {
+                        start += Rand.Vector(500.0f);
+                        end += Rand.Vector(500.0f);
+                    }
+
+                    CreateBlipsForLine(
+                        start + submarine.WorldPosition,
+                        end + submarine.WorldPosition,
+                        pingRadius, prevPingRadius,
+                        200.0f, 2.0f, range, 1.0f);
+                }
+            }
+
+            if (Level.Loaded != null && (item.CurrentHull == null || !DetectSubmarineWalls))
+            {
+                if (Level.Loaded.Size.Y - pingSource.Y < range)
+                {
+                    CreateBlipsForLine(
+                        new Vector2(pingSource.X - range, Level.Loaded.Size.Y),
+                        new Vector2(pingSource.X + range, Level.Loaded.Size.Y),
+                        pingRadius, prevPingRadius,
+                        250.0f, 150.0f, range, pingStrength);
+                }
+
+                List<VoronoiCell> cells = Level.Loaded.GetCells(pingSource, 7);
+                foreach (VoronoiCell cell in cells)
+                {
+                    foreach (GraphEdge edge in cell.edges)
+                    {
+                        if (!edge.isSolid) continue;
+                        float cellDot = Vector2.Dot(cell.Center - pingSource, (edge.Center + cell.Translation) - cell.Center);
+                        if (cellDot > 0) continue;
+
+                        float facingDot = Vector2.Dot(
+                            Vector2.Normalize(edge.point1 - edge.point2),
+                            Vector2.Normalize(cell.Center - pingSource));
+
+                        CreateBlipsForLine(
+                            edge.point1 + cell.Translation,
+                            edge.point2 + cell.Translation,
+                            pingRadius, prevPingRadius,
+                            350.0f, 3.0f * (Math.Abs(facingDot) + 1.0f), range, pingStrength);
+                    }
+                }
+
+                foreach (RuinGeneration.Ruin ruin in Level.Loaded.Ruins)
+                {
+                    if (!MathUtils.CircleIntersectsRectangle(pingSource, range, ruin.Area)) continue;
+
+                    foreach (var ruinShape in ruin.RuinShapes)
+                    {
+                        foreach (RuinGeneration.Line wall in ruinShape.Walls)
+                        {
+                            float cellDot = Vector2.Dot(
+                                Vector2.Normalize(ruinShape.Center - pingSource),
+                                Vector2.Normalize((wall.A + wall.B) / 2.0f - ruinShape.Center));
+                            if (cellDot > 0) continue;
+
+                            CreateBlipsForLine(
+                                wall.A, wall.B,
+                                pingRadius, prevPingRadius,
+                                100.0f, 1000.0f, range, pingStrength);
+                        }
+                    }
+                }
+            }
+
+            foreach (Character c in Character.CharacterList)
+            {
+                if (c.AnimController.CurrentHull != null || !c.Enabled) continue;
+                if (DetectSubmarineWalls && c.AnimController.CurrentHull == null && item.CurrentHull != null) continue;
+
+                foreach (Limb limb in c.AnimController.Limbs)
+                {
+                    float pointDist = (limb.WorldPosition - pingSource).Length() * displayScale;
+
+                    if (limb.SimPosition == Vector2.Zero || pointDist > displayRadius) continue;
+
+                    if (pointDist > prevPingRadius && pointDist < pingRadius)
+                    {
+                        for (int i = 0; i <= limb.Mass / 100.0f; i++)
+                        {
+                            var blip = new RadarBlip(limb.WorldPosition + Rand.Vector(limb.Mass / 10.0f), MathHelper.Clamp(limb.Mass, 0.1f, pingStrength));
+                            radarBlips.Add(blip);
+                        }
+                    }
+                }
+            }
+        }
+
+        private void CreateBlipsForLine(Vector2 point1, Vector2 point2, float pingRadius, float prevPingRadius,
+            float lineStep, float zStep, float range, float pingStrength)
+        {
+            float length = (point1 - point2).Length();
+
+            Vector2 lineDir = (point2 - point1) / length;
+
+            range *= displayScale;
+
+            for (float x = 0; x < length; x += lineStep * Rand.Range(0.8f, 1.2f))
+            {
+                Vector2 point = point1 + lineDir * x;
+                //point += cell.Translation;
+
+                float pointDist = Vector2.Distance(item.WorldPosition, point) * displayScale;
+
+                if (pointDist > displayRadius) continue;
+                if (pointDist < prevPingRadius || pointDist > pingRadius) continue;
+
+                float alpha = pingStrength * Rand.Range(1.5f, 2.0f);
+                for (float z = 0; z < displayRadius - pointDist * displayScale; z += zStep)
+                {
+                    Vector2 pos = point + Rand.Vector(150.0f) + Vector2.Normalize(point - item.WorldPosition) * z / displayScale;
+                    float fadeTimer = alpha * (1.0f - pointDist / range);
+
+                    int minDist = 200;
+                    radarBlips.RemoveAll(b => b.FadeTimer < fadeTimer && Math.Abs(pos.X - b.Position.X) < minDist && Math.Abs(pos.Y - b.Position.Y) < minDist);
+
+                    var blip = new RadarBlip(pos, fadeTimer);
+
+                    radarBlips.Add(blip);
+                    zStep += 0.5f;
+
+                    if (z == 0)
+                    {
+                        alpha = Math.Min(alpha - 0.5f, 1.5f);
+                    }
+                    else
+                    {
+                        alpha -= 0.1f;
+                    }
+
+                    if (alpha < 0) break;
+                }
+
+            }
+        }
+
+        private void DrawBlip(SpriteBatch spriteBatch, RadarBlip blip, Vector2 center, float strength)
+        {
+            strength = MathHelper.Clamp(strength, 0.0f, 1.0f);
+
+            Color[] colors = new Color[] {
+                Color.TransparentBlack,
+                new Color(0, 50, 160),
+                new Color(0, 133, 166),
+                new Color(2, 159, 30),
+                new Color(255, 255, 255) };
+
+            float scaledT = strength * (colors.Length - 1);
+            Color color = Color.Lerp(colors[(int)scaledT], colors[(int)Math.Min(scaledT + 1, colors.Length - 1)], (scaledT - (int)scaledT));
+
+            Vector2 pos = (blip.Position - item.WorldPosition) * displayScale;
+            pos.Y = -pos.Y;
+
+            if (pos.Length() > displayRadius)
+            {
+                blip.FadeTimer = 0.0f;
+                return;
+            }
+
+            float posDist = pos.Length();
+            Vector2 dir = pos / posDist;
+            float distFactor = (posDist / displayRadius);
+
+            Vector2 normal = new Vector2(dir.Y, -dir.X);
+
+            float scale = (strength + 3.0f) * Math.Max(distFactor * 3.0f, 1.0f);
+
+            if (radarBlip == null)
+            {
+                GUI.DrawRectangle(spriteBatch, center + pos, Vector2.One * 4, Color.Magenta, true);
+                return;
+            }
+
+            radarBlip.Draw(spriteBatch, center + pos, color, radarBlip.Origin, MathUtils.VectorToAngle(pos),
+                new Vector2(scale * 0.3f, scale) * 0.04f, SpriteEffects.None, 0);
+
+            pos += Rand.Range(0.0f, 1.0f) * dir + Rand.Range(-scale, scale) * normal;
+
+            radarBlip.Draw(spriteBatch, center + pos, color * 0.5f, radarBlip.Origin, MathUtils.VectorToAngle(pos),
+                new Vector2(scale * 0.3f, scale) * 0.08f, SpriteEffects.None, 0);
+        }
+
+        private void DrawMarker(SpriteBatch spriteBatch, string label, Vector2 position, float scale, Vector2 center, float radius)
+        {
+            //position += Level.Loaded.Position;
+
+            float dist = position.Length();
+
+            position *= scale;
+            position.Y = -position.Y;
+
+            float textAlpha = MathHelper.Clamp(1.5f - dist / 50000.0f, 0.5f, 1.0f);
+
+            Vector2 dir = Vector2.Normalize(position);
+
+            Vector2 markerPos = (dist * scale > radius) ? dir * radius : position;
+            markerPos += center;
+
+            markerPos.X = (int)markerPos.X;
+            markerPos.Y = (int)markerPos.Y;
+
+            GUI.DrawRectangle(spriteBatch, new Rectangle((int)markerPos.X, (int)markerPos.Y, 5, 5), Color.LightBlue);
+
+            if (dir.X < 0.0f) markerPos.X -= GUI.SmallFont.MeasureString(label).X + 10;
+
+            string wrappedLabel = ToolBox.WrapText(label, 150, GUI.SmallFont);
+
+            wrappedLabel += "\n" + ((int)(dist * Physics.DisplayToRealWorldRatio) + " m");
+
+            GUI.DrawString(spriteBatch,
+                new Vector2(markerPos.X + 10, markerPos.Y),
+                wrappedLabel,
+                Color.LightBlue * textAlpha, Color.Black * textAlpha * 0.5f,
+                2, GUI.SmallFont);
+        }
+        
+        public void ClientWrite(Lidgren.Network.NetBuffer msg, object[] extraData = null)
+        {
+            msg.Write(IsActive);
+        }
+        
+        public void ClientRead(ServerNetObject type, Lidgren.Network.NetBuffer msg, float sendingTime)
+        {
+            if (correctionTimer > 0.0f)
+            {
+                StartDelayedCorrection(type, msg.ExtractBits(1), sendingTime);
+                return;
+            }
+
+            IsActive = msg.ReadBoolean();
+            isActiveTickBox.Selected = IsActive;
+        }
+    }
+
+    class RadarBlip
+    {
+        public float FadeTimer;
+        public Vector2 Position;
+
+        public RadarBlip(Vector2 pos, float fadeTimer)
+        {
+            Position = pos;
+            FadeTimer = Math.Max(fadeTimer, 0.0f);
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Reactor.cs

@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Networking;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Reactor : Powered, IDrawableComponent, IServerSerializable, IClientSerializable
+    {
+        private GUITickBox autoTempTickBox;
+        
+        private void InitProjSpecific()
+        {
+            var button = new GUIButton(new Rectangle(410, 70, 40, 40), "-", "", GuiFrame);
+            button.OnPressed = () =>
+            {
+                lastUser = Character.Controlled;
+                if (nextServerLogWriteTime == null)
+                {
+                    nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+                }
+                unsentChanges = true;
+                ShutDownTemp -= 100.0f;
+
+                return false;
+            };
+
+            button = new GUIButton(new Rectangle(460, 70, 40, 40), "+", "", GuiFrame);
+            button.OnPressed = () =>
+            {
+                lastUser = Character.Controlled;
+                if (nextServerLogWriteTime == null)
+                {
+                    nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+                }
+                unsentChanges = true;
+                ShutDownTemp += 100.0f;
+
+                return false;
+            };
+
+            autoTempTickBox = new GUITickBox(new Rectangle(410, 170, 20, 20), "Automatic temperature control", Alignment.TopLeft, GuiFrame);
+            autoTempTickBox.OnSelected = ToggleAutoTemp;
+
+            button = new GUIButton(new Rectangle(210, 290, 40, 40), "+", "", GuiFrame);
+            button.OnPressed = () =>
+            {
+                lastUser = Character.Controlled;
+                if (nextServerLogWriteTime == null)
+                {
+                    nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+                }
+                unsentChanges = true;
+                FissionRate += 1.0f;
+
+                return false;
+            };
+
+            button = new GUIButton(new Rectangle(210, 340, 40, 40), "-", "", GuiFrame);
+            button.OnPressed = () =>
+            {
+                lastUser = Character.Controlled;
+                if (nextServerLogWriteTime == null)
+                {
+                    nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+                }
+                unsentChanges = true;
+                FissionRate -= 1.0f;
+
+                return false;
+            };
+
+            button = new GUIButton(new Rectangle(500, 290, 40, 40), "+", "", GuiFrame);
+            button.OnPressed = () =>
+            {
+                lastUser = Character.Controlled;
+                if (nextServerLogWriteTime == null)
+                {
+                    nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+                }
+                unsentChanges = true;
+                CoolingRate += 1.0f;
+
+                return false;
+            };
+
+            button = new GUIButton(new Rectangle(500, 340, 40, 40), "-", "", GuiFrame);
+            button.OnPressed = () =>
+            {
+                lastUser = Character.Controlled;
+                if (nextServerLogWriteTime == null)
+                {
+                    nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+                }
+                unsentChanges = true;
+                CoolingRate -= 1.0f;
+
+                return false;
+            };
+        }
+
+        private void UpdateGraph(float deltaTime)
+        {
+            graphTimer += deltaTime * 1000.0f;
+
+            if (graphTimer > updateGraphInterval)
+            {
+                UpdateGraph(fissionRateGraph, fissionRate);
+                UpdateGraph(coolingRateGraph, coolingRate);
+                UpdateGraph(tempGraph, temperature);
+
+                UpdateGraph(loadGraph, load);
+
+                graphTimer = 0.0f;
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            GUI.DrawRectangle(spriteBatch,
+                new Vector2(item.Rect.X + item.Rect.Width / 2 - 6, -item.Rect.Y + 29),
+                new Vector2(12, 42), Color.Black);
+
+            if (temperature > 0)
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(item.Rect.X + item.Rect.Width / 2 - 5, -item.Rect.Y + 30 + (40.0f * (1.0f - temperature / 10000.0f))),
+                    new Vector2(10, 40 * (temperature / 10000.0f)), new Color(temperature / 10000.0f, 1.0f - (temperature / 10000.0f), 0.0f, 1.0f), true);
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            IsActive = true;
+
+            int x = GuiFrame.Rect.X;
+            int y = GuiFrame.Rect.Y;
+
+            GuiFrame.Draw(spriteBatch);
+
+            float xOffset = graphTimer / updateGraphInterval;
+
+            //GUI.DrawRectangle(spriteBatch, new Rectangle(x, y, width, height), Color.Black, true);
+
+            GUI.Font.DrawString(spriteBatch, "Output: " + (int)temperature + " kW",
+                new Vector2(x + 450, y + 30), Color.Red);
+            GUI.Font.DrawString(spriteBatch, "Grid load: " + (int)load + " kW",
+                new Vector2(x + 600, y + 30), Color.Yellow);
+
+            float maxLoad = 0.0f;
+            foreach (float loadVal in loadGraph)
+            {
+                maxLoad = Math.Max(maxLoad, loadVal);
+            }
+
+            DrawGraph(tempGraph, spriteBatch,
+                new Rectangle(x + 30, y + 30, 400, 250), Math.Max(10000.0f, maxLoad), xOffset, Color.Red);
+
+            DrawGraph(loadGraph, spriteBatch,
+                new Rectangle(x + 30, y + 30, 400, 250), Math.Max(10000.0f, maxLoad), xOffset, Color.Yellow);
+
+            GUI.Font.DrawString(spriteBatch, "Shutdown Temperature: " + (int)shutDownTemp, new Vector2(x + 450, y + 80), Color.White);
+
+            //GUI.Font.DrawString(spriteBatch, "Automatic Temperature Control: " + ((autoTemp) ? "ON" : "OFF"), new Vector2(x + 450, y + 180), Color.White);
+
+            y += 300;
+
+            GUI.Font.DrawString(spriteBatch, "Fission rate: " + (int)fissionRate + " %", new Vector2(x + 30, y), Color.White);
+            DrawGraph(fissionRateGraph, spriteBatch,
+                new Rectangle(x + 30, y + 30, 200, 100), 100.0f, xOffset, Color.Orange);
+
+
+            GUI.Font.DrawString(spriteBatch, "Cooling rate: " + (int)coolingRate + " %", new Vector2(x + 320, y), Color.White);
+            DrawGraph(coolingRateGraph, spriteBatch,
+                new Rectangle(x + 320, y + 30, 200, 100), 100.0f, xOffset, Color.LightBlue);
+
+
+            //y = y - 260;
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update(1.0f / 60.0f);
+        }
+
+        private bool ToggleAutoTemp(GUITickBox tickBox)
+        {
+            unsentChanges = true;
+            autoTemp = tickBox.Selected;
+
+            return true;
+        }
+
+        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;
+        }
+
+        static void DrawGraph(IList<float> graph, SpriteBatch spriteBatch, Rectangle rect, float maxVal, float xOffset, Color color)
+        {
+            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);
+
+                GUI.DrawLine(spriteBatch, prevPoint, newPoint - new Vector2(1.0f, 0), color);
+
+                prevPoint = newPoint;
+            }
+
+            Vector2 lastPoint = new Vector2(rect.X,
+                rect.Bottom - (graph[graph.Count - 1] + (graph[graph.Count - 2] - graph[graph.Count - 1]) * xOffset) * yScale);
+
+            GUI.DrawLine(spriteBatch, prevPoint, lastPoint, color);
+        }
+
+        public void ClientWrite(NetBuffer msg, object[] extraData = null)
+        {
+            msg.Write(autoTemp);
+            msg.WriteRangedSingle(shutDownTemp, 0.0f, 10000.0f, 15);
+
+            msg.WriteRangedSingle(coolingRate, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(fissionRate, 0.0f, 100.0f, 8);
+
+            correctionTimer = CorrectionDelay;
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            if (correctionTimer > 0.0f)
+            {
+                StartDelayedCorrection(type, msg.ExtractBits(16 + 1 + 15 + 8 + 8), sendingTime);
+                return;
+            }
+
+            Temperature = msg.ReadRangedSingle(0.0f, 10000.0f, 16);
+
+            AutoTemp = msg.ReadBoolean();
+            ShutDownTemp = msg.ReadRangedSingle(0.0f, 10000.0f, 15);
+
+            CoolingRate = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            FissionRate = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Machines/Steering.cs

@@ -0,0 +1,301 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+using Voronoi2;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Steering : Powered, IServerSerializable, IClientSerializable
+    {
+        private GUITickBox autopilotTickBox, maintainPosTickBox;
+        private GUITickBox levelEndTickBox, levelStartTickBox;
+
+        public bool LevelStartSelected
+        {
+            get { return levelStartTickBox.Selected; }
+            set { levelStartTickBox.Selected = value; }
+        }
+
+        public bool LevelEndSelected
+        {
+            get { return levelEndTickBox.Selected; }
+            set { levelEndTickBox.Selected = value; }
+        }
+
+        public bool MaintainPos
+        {
+            get { return maintainPosTickBox.Selected; }
+            set { maintainPosTickBox.Selected = value; }
+        }
+
+        private void InitProjSpecific()
+        {
+            autopilotTickBox = new GUITickBox(new Rectangle(0, 25, 20, 20), "Autopilot", Alignment.TopLeft, GuiFrame);
+            autopilotTickBox.OnSelected = (GUITickBox box) =>
+            {
+                AutoPilot = box.Selected;
+                unsentChanges = true;
+
+                return true;
+            };
+
+            maintainPosTickBox = new GUITickBox(new Rectangle(5, 50, 15, 15), "Maintain position", Alignment.TopLeft, GUI.SmallFont, GuiFrame);
+            maintainPosTickBox.Enabled = false;
+            maintainPosTickBox.OnSelected = ToggleMaintainPosition;
+
+            levelStartTickBox = new GUITickBox(
+                new Rectangle(5, 70, 15, 15),
+                GameMain.GameSession == null ? "" : ToolBox.LimitString(GameMain.GameSession.StartLocation.Name, 20),
+                Alignment.TopLeft, GUI.SmallFont, GuiFrame);
+            levelStartTickBox.Enabled = false;
+            levelStartTickBox.OnSelected = SelectDestination;
+
+            levelEndTickBox = new GUITickBox(
+                new Rectangle(5, 90, 15, 15),
+                GameMain.GameSession == null ? "" : ToolBox.LimitString(GameMain.GameSession.EndLocation.Name, 20),
+                Alignment.TopLeft, GUI.SmallFont, GuiFrame);
+            levelEndTickBox.Enabled = false;
+            levelEndTickBox.OnSelected = SelectDestination;
+        }
+
+        private bool ToggleMaintainPosition(GUITickBox tickBox)
+        {
+            unsentChanges = true;
+
+            levelStartTickBox.Selected = false;
+            levelEndTickBox.Selected = false;
+
+            if (item.Submarine == null)
+            {
+                posToMaintain = null;
+            }
+            else
+            {
+                posToMaintain = item.Submarine.WorldPosition;
+            }
+
+            tickBox.Selected = true;
+
+            return true;
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            //if (voltage < minVoltage) return;
+
+            int width = GuiFrame.Rect.Width, height = GuiFrame.Rect.Height;
+            int x = GuiFrame.Rect.X;
+            int y = GuiFrame.Rect.Y;
+
+            GuiFrame.Draw(spriteBatch);
+
+            if (voltage < minVoltage && powerConsumption > 0.0f) return;
+
+            Rectangle velRect = new Rectangle(x + 20, y + 20, width - 40, height - 40);
+            //GUI.DrawRectangle(spriteBatch, velRect, Color.White, false);
+
+            if (item.Submarine != null && Level.Loaded != null)
+            {
+                Vector2 realWorldVelocity = ConvertUnits.ToDisplayUnits(item.Submarine.Velocity * Physics.DisplayToRealWorldRatio) * 3.6f;
+                float realWorldDepth = Math.Abs(item.Submarine.Position.Y - Level.Loaded.Size.Y) * Physics.DisplayToRealWorldRatio;
+                GUI.DrawString(spriteBatch, new Vector2(x + 20, y + height - 65),
+                    "Velocity: " + (int)realWorldVelocity.X + " km/h", Color.LightGreen, null, 0, GUI.SmallFont);
+                GUI.DrawString(spriteBatch, new Vector2(x + 20, y + height - 50),
+                    "Descent velocity: " + -(int)realWorldVelocity.Y + " km/h", Color.LightGreen, null, 0, GUI.SmallFont);
+
+                GUI.DrawString(spriteBatch, new Vector2(x + 20, y + height - 30),
+                    "Depth: " + (int)realWorldDepth + " m", Color.LightGreen, null, 0, GUI.SmallFont);
+            }
+
+            GUI.DrawLine(spriteBatch,
+                new Vector2(velRect.Center.X, velRect.Center.Y),
+                new Vector2(velRect.Center.X + currVelocity.X, velRect.Center.Y - currVelocity.Y),
+                Color.Gray);
+
+            Vector2 targetVelPos = new Vector2(velRect.Center.X + targetVelocity.X, velRect.Center.Y - targetVelocity.Y);
+
+            GUI.DrawLine(spriteBatch,
+                new Vector2(velRect.Center.X, velRect.Center.Y),
+                targetVelPos,
+                Color.LightGray);
+
+            GUI.DrawRectangle(spriteBatch, new Rectangle((int)targetVelPos.X - 5, (int)targetVelPos.Y - 5, 10, 10), Color.White);
+
+            if (Vector2.Distance(PlayerInput.MousePosition, new Vector2(velRect.Center.X, velRect.Center.Y)) < 200.0f)
+            {
+                GUI.DrawRectangle(spriteBatch, new Rectangle((int)targetVelPos.X - 10, (int)targetVelPos.Y - 10, 20, 20), Color.Red);
+            }
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update(1.0f / 60.0f);
+
+            if (Vector2.Distance(PlayerInput.MousePosition, new Vector2(GuiFrame.Rect.Center.X, GuiFrame.Rect.Center.Y)) < 200.0f)
+            {
+                if (PlayerInput.LeftButtonHeld())
+                {
+                    TargetVelocity = PlayerInput.MousePosition - new Vector2(GuiFrame.Rect.Center.X, GuiFrame.Rect.Center.Y);
+                    targetVelocity.Y = -targetVelocity.Y;
+
+                    unsentChanges = true;
+                }
+            }
+        }
+
+        public void SetDestinationLevelStart()
+        {
+            AutoPilot = true;
+
+            MaintainPos = false;
+            posToMaintain = null;
+
+            levelEndTickBox.Selected = false;
+
+            if (!levelStartTickBox.Selected)
+            {
+                levelStartTickBox.Selected = true;
+                UpdatePath();
+            }
+        }
+
+        public void SetDestinationLevelEnd()
+        {
+            AutoPilot = false;
+
+            MaintainPos = false;
+            posToMaintain = null;
+
+            levelStartTickBox.Selected = false;
+
+            if (!levelEndTickBox.Selected)
+            {
+                levelEndTickBox.Selected = true;
+                UpdatePath();
+            }
+        }
+
+
+        private bool SelectDestination(GUITickBox tickBox)
+        {
+            unsentChanges = true;
+
+            if (tickBox == levelStartTickBox)
+            {
+                levelEndTickBox.Selected = false;
+            }
+            else
+            {
+                levelStartTickBox.Selected = false;
+            }
+
+            maintainPosTickBox.Selected = false;
+            posToMaintain = null;
+            tickBox.Selected = true;
+
+            UpdatePath();
+
+            return true;
+        }
+
+        public void ClientWrite(Lidgren.Network.NetBuffer msg, object[] extraData = null)
+        {
+            msg.Write(autoPilot);
+
+            if (!autoPilot)
+            {
+                //no need to write steering info if autopilot is controlling
+                msg.Write(targetVelocity.X);
+                msg.Write(targetVelocity.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, Lidgren.Network.NetBuffer msg, float sendingTime)
+        {
+            long msgStartPos = msg.Position;
+
+            bool autoPilot = msg.ReadBoolean();
+            Vector2 newTargetVelocity = targetVelocity;
+            bool maintainPos = false;
+            Vector2? newPosToMaintain = null;
+            bool headingToStart = false;
+
+            if (autoPilot)
+            {
+                maintainPos = msg.ReadBoolean();
+                if (maintainPos)
+                {
+                    newPosToMaintain = new Vector2(
+                        msg.ReadFloat(),
+                        msg.ReadFloat());
+                }
+                else
+                {
+                    headingToStart = msg.ReadBoolean();
+                }
+            }
+            else
+            {
+                newTargetVelocity = new Vector2(msg.ReadFloat(), msg.ReadFloat());
+            }
+
+            if (correctionTimer > 0.0f)
+            {
+                int msgLength = (int)(msg.Position - msgStartPos);
+                msg.Position = msgStartPos;
+                StartDelayedCorrection(type, msg.ExtractBits(msgLength), sendingTime);
+                return;
+            }
+
+            AutoPilot = autoPilot;
+
+            if (!AutoPilot)
+            {
+                targetVelocity = newTargetVelocity;
+            }
+            else
+            {
+
+                MaintainPos = newPosToMaintain != null;
+                posToMaintain = newPosToMaintain;
+
+                if (posToMaintain == null)
+                {
+                    LevelStartSelected = headingToStart;
+                    LevelEndSelected = !headingToStart;
+                    UpdatePath();
+                }
+                else
+                {
+                    LevelStartSelected = false;
+                    LevelEndSelected = false;
+                }
+            }
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Power/PowerContainer.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma.Items.Components
+{
+    partial class PowerContainer : Powered, IDrawableComponent, IServerSerializable, IClientSerializable
+    {
+        private void InitProjSpecific()
+        {
+            if (canBeSelected)
+            {
+                var button = new GUIButton(new Rectangle(160, 50, 30, 30), "-", "", GuiFrame);
+                button.OnClicked = (GUIButton btn, object obj) =>
+                {
+                    RechargeSpeed = rechargeSpeed - maxRechargeSpeed * 0.1f;
+
+                    if (GameMain.Server != null)
+                    {
+                        item.CreateServerEvent(this);
+                        GameServer.Log(Character.Controlled + " set the recharge speed of " + item.Name + " to " + (int)((rechargeSpeed / maxRechargeSpeed) * 100.0f) + " %", ServerLog.MessageType.ItemInteraction);
+                    }
+                    else if (GameMain.Client != null)
+                    {
+                        item.CreateClientEvent(this);
+                        correctionTimer = CorrectionDelay;
+                    }
+
+                    return true;
+                };
+
+                button = new GUIButton(new Rectangle(200, 50, 30, 30), "+", "", GuiFrame);
+                button.OnClicked = (GUIButton btn, object obj) =>
+                {
+                    RechargeSpeed = rechargeSpeed + maxRechargeSpeed * 0.1f;
+
+                    if (GameMain.Server != null)
+                    {
+                        item.CreateServerEvent(this);
+                        GameServer.Log(Character.Controlled + " set the recharge speed of " + item.Name + " to " + (int)((rechargeSpeed / maxRechargeSpeed) * 100.0f) + " %", ServerLog.MessageType.ItemInteraction);
+                    }
+                    else if (GameMain.Client != null)
+                    {
+                        item.CreateClientEvent(this);
+                        correctionTimer = CorrectionDelay;
+                    }
+
+                    return true;
+                };
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            GUI.DrawRectangle(spriteBatch,
+                new Vector2(item.DrawPosition.X - 4, -item.DrawPosition.Y),
+                new Vector2(8, 22), Color.Black);
+
+            if (charge > 0)
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(item.DrawPosition.X - 3, -item.DrawPosition.Y + 1 + (20.0f * (1.0f - charge / capacity))),
+                    new Vector2(6, 20 * (charge / capacity)), Color.Green, true);
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            GuiFrame.Draw(spriteBatch);
+
+            int x = GuiFrame.Rect.X;
+            int y = GuiFrame.Rect.Y;
+            //GUI.DrawRectangle(spriteBatch, new Rectangle(x, y, width, height), Color.Black, true);
+
+            GUI.Font.DrawString(spriteBatch,
+                "Charge: " + (int)charge + "/" + (int)capacity + " kWm (" + (int)((charge / capacity) * 100.0f) + " %)",
+                new Vector2(x + 30, y + 30), Color.White);
+
+            GUI.Font.DrawString(spriteBatch, "Recharge rate: " + (int)((rechargeSpeed / maxRechargeSpeed) * 100.0f) + " %", new Vector2(x + 30, y + 95), Color.White);
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update(1.0f / 60.0f);
+        }
+
+        public void ClientWrite(NetBuffer msg, object[] extraData)
+        {
+            msg.WriteRangedInteger(0, 10, (int)(rechargeSpeed / MaxRechargeSpeed * 10));
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            if (correctionTimer > 0.0f)
+            {
+                StartDelayedCorrection(type, msg.ExtractBits(4 + 8), sendingTime);
+                return;
+            }
+
+            RechargeSpeed = msg.ReadRangedInteger(0, 10) / 10.0f * maxRechargeSpeed;
+            Charge = msg.ReadRangedSingle(0.0f, 1.0f, 8) * capacity;
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Power/PowerTransfer.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Globalization;
+using System.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class PowerTransfer : Powered
+    {
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            if (!canBeSelected) return;
+
+            int x = GuiFrame.Rect.X;
+            int y = GuiFrame.Rect.Y;
+
+            GuiFrame.Draw(spriteBatch);
+
+            GUI.Font.DrawString(spriteBatch, "Power: " + (int)(-currPowerConsumption) + " kW", new Vector2(x + 30, y + 30), Color.White);
+            GUI.Font.DrawString(spriteBatch, "Load: " + (int)powerLoad + " kW", new Vector2(x + 30, y + 100), Color.White);
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            GuiFrame.AddToGUIUpdateList();
+        }
+
+        public override void UpdateHUD(Character character)
+        {
+            GuiFrame.Update(1.0f / 60.0f);
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Power/Powered.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Powered : ItemComponent
+    {
+        protected static Sound[] sparkSounds;
+
+        private bool powerOnSoundPlayed;
+
+        private static Sound powerOnSound;
+    }
+}

BarotraumaClient/Source/Items/Components/Signal/ConnectionPanel.cs

@@ -0,0 +1,51 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using Lidgren.Network;
+
+namespace Barotrauma.Items.Components
+{
+    partial class ConnectionPanel : ItemComponent, IServerSerializable, IClientSerializable
+    {
+        public override void UpdateHUD(Character character)
+        {
+            if (character != Character.Controlled || character != user) return;
+
+            if (Screen.Selected != GameMain.EditMapScreen &&
+                character.IsKeyHit(InputType.Select) &&
+                character.SelectedConstruction == this.item) character.SelectedConstruction = null;
+
+            if (HighlightedWire != null)
+            {
+                HighlightedWire.Item.IsHighlighted = true;
+                if (HighlightedWire.Connections[0] != null && HighlightedWire.Connections[0].Item != null) HighlightedWire.Connections[0].Item.IsHighlighted = true;
+                if (HighlightedWire.Connections[1] != null && HighlightedWire.Connections[1].Item != null) HighlightedWire.Connections[1].Item.IsHighlighted = true;
+            }
+        }
+
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            if (character != Character.Controlled || character != user) return;
+
+            HighlightedWire = null;
+            Connection.DrawConnections(spriteBatch, this, character);
+
+        }
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement componentElement = base.Save(parentElement);
+
+            foreach (Connection c in Connections)
+            {
+                c.Save(componentElement);
+            }
+
+            return componentElement;
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/Signal/Wire.cs

@@ -0,0 +1,256 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Wire : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        partial class WireSection
+        {
+            public void Draw(SpriteBatch spriteBatch, Color color, Vector2 offset, float depth, float width = 0.3f)
+            {
+                spriteBatch.Draw(wireSprite.Texture,
+                    new Vector2(start.X + offset.X, -(start.Y + offset.Y)), null, color,
+                    -angle,
+                    new Vector2(0.0f, wireSprite.size.Y / 2.0f),
+                    new Vector2(length / wireSprite.Texture.Width, width),
+                    SpriteEffects.None,
+                    depth);
+            }
+
+            public static void Draw(SpriteBatch spriteBatch, Vector2 start, Vector2 end, Color color, float depth, float width = 0.3f)
+            {
+                start.Y = -start.Y;
+                end.Y = -end.Y;
+
+                spriteBatch.Draw(wireSprite.Texture,
+                    start, null, color,
+                    MathUtils.VectorToAngle(end - start),
+                    new Vector2(0.0f, wireSprite.size.Y / 2.0f),
+                    new Vector2((Vector2.Distance(start, end)) / wireSprite.Texture.Width, width),
+                    SpriteEffects.None,
+                    depth);
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing)
+        {
+            if (sections.Count == 0 && !IsActive)
+            {
+                Drawable = false;
+                return;
+            }
+
+            Vector2 drawOffset = Vector2.Zero;
+            if (item.Submarine != null)
+            {
+                drawOffset = item.Submarine.DrawPosition + item.Submarine.HiddenSubPosition;
+            }
+
+            float depth = item.IsSelected ? 0.0f : wireSprite.Depth + ((item.ID % 100) * 0.00001f);
+
+            if (item.IsHighlighted)
+            {
+                foreach (WireSection section in sections)
+                {
+                    section.Draw(spriteBatch, Color.Gold, drawOffset, depth + 0.00001f, 0.7f);
+                }
+            }
+            else if (item.IsSelected)
+            {
+                foreach (WireSection section in sections)
+                {
+                    section.Draw(spriteBatch, Color.Red, drawOffset, depth + 0.00001f, 0.7f);
+                }
+            }
+
+            foreach (WireSection section in sections)
+            {
+                section.Draw(spriteBatch, item.Color, drawOffset, depth, 0.3f);
+            }
+
+            if (IsActive && nodes.Count > 0 && Vector2.Distance(newNodePos, nodes[nodes.Count - 1]) > nodeDistance)
+            {
+                WireSection.Draw(
+                    spriteBatch,
+                    new Vector2(nodes[nodes.Count - 1].X, nodes[nodes.Count - 1].Y) + drawOffset,
+                    new Vector2(newNodePos.X, newNodePos.Y) + drawOffset,
+                    item.Color * 0.5f,
+                    depth,
+                    0.3f);
+            }
+
+            if (!editing || !GameMain.EditMapScreen.WiringMode) return;
+
+            for (int i = 0; i < nodes.Count; i++)
+            {
+                Vector2 drawPos = nodes[i];
+                if (item.Submarine != null) drawPos += item.Submarine.Position + item.Submarine.HiddenSubPosition;
+                drawPos.Y = -drawPos.Y;
+
+                if (item.IsSelected)
+                {
+                    GUI.DrawRectangle(spriteBatch, drawPos + new Vector2(-5, -5), new Vector2(10, 10), item.Color, true, 0.0f);
+
+                    if (highlightedNodeIndex == i)
+                    {
+                        GUI.DrawRectangle(spriteBatch, drawPos + new Vector2(-10, -10), new Vector2(20, 20), Color.Red, false, 0.0f);
+                    }
+                }
+                else
+                {
+                    GUI.DrawRectangle(spriteBatch, drawPos + new Vector2(-3, -3), new Vector2(6, 6), item.Color, true, 0.0f);
+                }
+            }
+        }
+
+        public static void UpdateEditing(List<Wire> wires)
+        {
+            //dragging a node of some wire
+            if (draggingWire != null)
+            {
+                //cancel dragging
+                if (!PlayerInput.LeftButtonHeld())
+                {
+                    draggingWire = null;
+                    selectedNodeIndex = null;
+                }
+                //update dragging
+                else
+                {
+                    MapEntity.DisableSelect = true;
+
+                    Submarine sub = null;
+                    if (draggingWire.connections[0] != null && draggingWire.connections[0].Item.Submarine != null) sub = draggingWire.connections[0].Item.Submarine;
+                    if (draggingWire.connections[1] != null && draggingWire.connections[1].Item.Submarine != null) sub = draggingWire.connections[1].Item.Submarine;
+
+                    Vector2 nodeWorldPos = GameMain.EditMapScreen.Cam.ScreenToWorld(PlayerInput.MousePosition) - sub.HiddenSubPosition - sub.Position;// Nodes[(int)selectedNodeIndex];
+
+                    nodeWorldPos.X = MathUtils.Round(nodeWorldPos.X, Submarine.GridSize.X / 2.0f);
+                    nodeWorldPos.Y = MathUtils.Round(nodeWorldPos.Y, Submarine.GridSize.Y / 2.0f);
+
+                    draggingWire.nodes[(int)selectedNodeIndex] = nodeWorldPos;
+                    draggingWire.UpdateSections();
+
+                    MapEntity.SelectEntity(draggingWire.item);
+                }
+
+                return;
+            }
+
+            //a wire has been selected -> check if we should start dragging one of the nodes
+            float nodeSelectDist = 10, sectionSelectDist = 5;
+            highlightedNodeIndex = null;
+            if (MapEntity.SelectedList.Count == 1 && MapEntity.SelectedList[0] is Item)
+            {
+                Wire selectedWire = ((Item)MapEntity.SelectedList[0]).GetComponent<Wire>();
+
+                if (selectedWire != null)
+                {
+                    Vector2 mousePos = GameMain.EditMapScreen.Cam.ScreenToWorld(PlayerInput.MousePosition);
+                    if (selectedWire.item.Submarine != null) mousePos -= (selectedWire.item.Submarine.Position + selectedWire.item.Submarine.HiddenSubPosition);
+
+                    //left click while holding ctrl -> check if the cursor is on a wire section, 
+                    //and add a new node if it is
+                    if (PlayerInput.KeyDown(Keys.RightControl) || PlayerInput.KeyDown(Keys.LeftControl))
+                    {
+                        if (PlayerInput.LeftButtonClicked())
+                        {
+                            float temp = 0.0f;
+                            int closestSectionIndex = selectedWire.GetClosestSectionIndex(mousePos, sectionSelectDist, out temp);
+
+                            if (closestSectionIndex > -1)
+                            {
+                                selectedWire.nodes.Insert(closestSectionIndex + 1, mousePos);
+                                selectedWire.UpdateSections();
+                            }
+                        }
+                    }
+                    else
+                    {
+                        //check if close enough to a node
+                        float temp = 0.0f;
+                        int closestIndex = selectedWire.GetClosestNodeIndex(mousePos, nodeSelectDist, out temp);
+                        if (closestIndex > -1)
+                        {
+                            highlightedNodeIndex = closestIndex;
+                            //start dragging the node
+                            if (PlayerInput.LeftButtonHeld())
+                            {
+                                draggingWire = selectedWire;
+                                selectedNodeIndex = closestIndex;
+                            }
+                            //remove the node
+                            else if (PlayerInput.RightButtonClicked() && closestIndex > 0 && closestIndex < selectedWire.nodes.Count - 1)
+                            {
+                                selectedWire.nodes.RemoveAt(closestIndex);
+                                selectedWire.UpdateSections();
+                            }
+                        }
+                    }
+                }
+            }
+
+            //check which wire is highlighted with the cursor
+            Wire highlighted = null;
+            float closestDist = 0.0f;
+            foreach (Wire w in wires)
+            {
+                Vector2 mousePos = GameMain.EditMapScreen.Cam.ScreenToWorld(PlayerInput.MousePosition);
+                if (w.item.Submarine != null) mousePos -= (w.item.Submarine.Position + w.item.Submarine.HiddenSubPosition);
+
+                float dist = 0.0f;
+                if (w.GetClosestNodeIndex(mousePos, highlighted == null ? nodeSelectDist : closestDist, out dist) > -1)
+                {
+                    highlighted = w;
+                    closestDist = dist;
+                }
+
+                if (w.GetClosestSectionIndex(mousePos, highlighted == null ? sectionSelectDist : closestDist, out dist) > -1)
+                {
+                    highlighted = w;
+                    closestDist = dist;
+                }
+
+            }
+
+
+            if (highlighted != null)
+            {
+                highlighted.item.IsHighlighted = true;
+
+                if (PlayerInput.LeftButtonClicked())
+                {
+                    MapEntity.DisableSelect = true;
+                    MapEntity.SelectEntity(highlighted.item);
+                }
+            }
+        }
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement componentElement = base.Save(parentElement);
+
+            if (nodes == null || nodes.Count == 0) return componentElement;
+
+            string[] nodeCoords = new string[nodes.Count * 2];
+            for (int i = 0; i < nodes.Count; i++)
+            {
+                nodeCoords[i * 2] = nodes[i].X.ToString(CultureInfo.InvariantCulture);
+                nodeCoords[i * 2 + 1] = nodes[i].Y.ToString(CultureInfo.InvariantCulture);
+            }
+
+            componentElement.Add(new XAttribute("nodes", string.Join(";", nodeCoords)));
+
+            return componentElement;
+        }
+    }
+}

BarotraumaClient/Source/Items/Components/StatusHUD.cs

@@ -0,0 +1,64 @@
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Items.Components
+{
+    partial class StatusHUD : ItemComponent
+    {
+        public override void DrawHUD(SpriteBatch spriteBatch, Character character)
+        {
+            if (character == null) return;
+            
+            GUI.DrawRectangle(spriteBatch, new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight),
+                Color.Green * 0.1f, true);
+
+            if (character.ClosestCharacter == null) return;
+
+            var target = character.ClosestCharacter;
+
+            Vector2 hudPos = GameMain.GameScreen.Cam.WorldToScreen(target.WorldPosition);
+            hudPos += Vector2.UnitX * 50.0f;
+
+            List<string> texts = new List<string>();
+
+            texts.Add(target.Name);
+
+            if (target.IsDead)
+            {
+                texts.Add("Deceased");
+            }
+            else
+            {
+                if (target.IsUnconscious) texts.Add("Unconscious");
+                if (target.Stun > 0.01f) texts.Add("Stunned");
+
+                int healthTextIndex = target.Health > 95.0f ? 0 :
+                    MathHelper.Clamp((int)Math.Ceiling((1.0f - (target.Health / 200.0f + 0.5f)) * HealthTexts.Length), 0, HealthTexts.Length - 1);
+
+                texts.Add(HealthTexts[healthTextIndex]);
+
+                int oxygenTextIndex = MathHelper.Clamp((int)Math.Floor((1.0f - (target.Oxygen / 200.0f + 0.5f)) * OxygenTexts.Length), 0, OxygenTexts.Length - 1);
+                texts.Add(OxygenTexts[oxygenTextIndex]);
+
+                if (target.Bleeding > 0.0f)
+                {
+                    int bleedingTextIndex = MathHelper.Clamp((int)Math.Floor(target.Bleeding / 4.0f) * BleedingTexts.Length, 0, BleedingTexts.Length - 1);
+                    texts.Add(BleedingTexts[bleedingTextIndex]);
+                }                
+            }
+
+
+
+            foreach (string text in texts)
+            {
+                GUI.DrawString(spriteBatch, hudPos, text, Color.LightGreen, Color.Black * 0.7f, 2);
+                hudPos.Y += 24.0f;
+            }
+        }
+    }
+}

BarotraumaClient/Source/Items/ItemPrefab.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml.Linq;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace Barotrauma
+{
+    partial class ItemPrefab : MapEntityPrefab
+    {
+        public override void DrawPlacing(SpriteBatch spriteBatch, Camera cam)
+        {
+            Vector2 position = Submarine.MouseToWorldGrid(cam, Submarine.MainSub);
+
+            if (PlayerInput.RightButtonClicked())
+            {
+                selected = null;
+                return;
+            }
+
+            if (!resizeHorizontal && !resizeVertical)
+            {
+                sprite.Draw(spriteBatch, new Vector2(position.X + sprite.size.X / 2.0f, -position.Y + sprite.size.Y / 2.0f), SpriteColor);
+            }
+            else
+            {
+                Vector2 placeSize = size;
+
+                if (placePosition == Vector2.Zero)
+                {
+                    if (PlayerInput.LeftButtonHeld()) placePosition = position;
+                }
+                else
+                {
+                    if (resizeHorizontal)
+                        placeSize.X = Math.Max(position.X - placePosition.X, size.X);
+                    if (resizeVertical)
+                        placeSize.Y = Math.Max(placePosition.Y - position.Y, size.Y);
+
+                    position = placePosition;
+                }
+
+                if (sprite != null) sprite.DrawTiled(spriteBatch, new Vector2(position.X, -position.Y), placeSize, SpriteColor);
+            }
+
+            //if (PlayerInput.GetMouseState.RightButton == ButtonState.Pressed) selected = null;
+
+        }
+    }
+}

BarotraumaClient/Source/Map/Explosion.cs

@@ -0,0 +1,73 @@
+using Microsoft.Xna.Framework;
+using Barotrauma.Lights;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using Barotrauma.Networking;
+using FarseerPhysics;
+
+namespace Barotrauma
+{
+    partial class Explosion
+    {
+        private void ExplodeProjSpecific(Vector2 worldPosition,Hull hull)
+        {
+
+            if (shockwave)
+            {
+                GameMain.ParticleManager.CreateParticle("shockwave", worldPosition,
+                    Vector2.Zero, 0.0f, hull);
+            }
+
+            for (int i = 0; i < attack.Range * 0.1f; i++)
+            {
+                Vector2 bubblePos = Rand.Vector(attack.Range * 0.5f);
+                GameMain.ParticleManager.CreateParticle("bubbles", worldPosition + bubblePos,
+                    bubblePos, 0.0f, hull);
+
+                if (sparks)
+                {
+                    GameMain.ParticleManager.CreateParticle("spark", worldPosition,
+                        Rand.Vector(Rand.Range(500.0f, 800.0f)), 0.0f, hull);
+                }
+                if (flames)
+                {
+                    GameMain.ParticleManager.CreateParticle("explosionfire", ClampParticlePos(worldPosition + Rand.Vector(50f), hull),
+                        Rand.Vector(Rand.Range(50.0f, 100.0f)), 0.0f, hull);
+                }
+                if (smoke)
+                {
+                    GameMain.ParticleManager.CreateParticle("smoke", ClampParticlePos(worldPosition + Rand.Vector(50f), hull),
+                        Rand.Vector(Rand.Range(1.0f, 10.0f)), 0.0f, hull);
+                }
+            }
+
+            float displayRange = attack.Range;
+            if (displayRange < 0.1f) return;
+
+            var light = new LightSource(worldPosition, displayRange, Color.LightYellow, null);
+            CoroutineManager.StartCoroutine(DimLight(light));
+
+        }
+
+        private IEnumerable<object> DimLight(LightSource light)
+        {
+            float currBrightness = 1.0f;
+            float startRange = light.Range;
+
+            while (light.Color.A > 0.0f)
+            {
+                light.Color = new Color(light.Color.R, light.Color.G, light.Color.B, currBrightness);
+                light.Range = startRange * currBrightness;
+
+                currBrightness -= CoroutineManager.DeltaTime * 20.0f;
+
+                yield return CoroutineStatus.Running;
+            }
+
+            light.Remove();
+
+            yield return CoroutineStatus.Success;
+        }
+    }
+}

BarotraumaClient/Source/Map/FireSource.cs

@@ -0,0 +1,86 @@
+using Barotrauma.Lights;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Barotrauma.Networking;
+
+namespace Barotrauma
+{
+    partial class FireSource
+    {
+        static Sound fireSoundBasic, fireSoundLarge;
+
+        private LightSource lightSource;
+
+        private void UpdateProjSpecific(float growModifier)
+        {
+            if (hull.FireSources.Any(fs => fs != this && fs.size.X > size.X))
+            {
+                if (basicSoundIndex > 0)
+                {
+                    Sounds.SoundManager.Stop(basicSoundIndex);
+                    basicSoundIndex = -1;
+                }
+                if (largeSoundIndex > 0)
+                {
+                    Sounds.SoundManager.Stop(largeSoundIndex);
+                    largeSoundIndex = -1;
+                }
+            }
+            else
+            {
+                if (fireSoundBasic != null)
+                {
+                    basicSoundIndex = fireSoundBasic.Loop(basicSoundIndex,
+                        Math.Min(size.X / 100.0f, 1.0f), WorldPosition + size / 2.0f, 1000.0f);
+
+                }
+                if (fireSoundLarge != null)
+                {
+                    largeSoundIndex = fireSoundLarge.Loop(largeSoundIndex,
+                        MathHelper.Clamp((size.X - 200.0f) / 100.0f, 0.0f, 1.0f), WorldPosition + size / 2.0f, 1000.0f);
+                }
+            }
+
+            float count = Rand.Range(0.0f, size.X / 50.0f);
+
+            for (int i = 0; i < count; i++)
+            {
+                Vector2 particlePos = new Vector2(
+                    WorldPosition.X + Rand.Range(0.0f, size.X),
+                    Rand.Range(WorldPosition.Y - size.Y, WorldPosition.Y + 20.0f));
+
+                Vector2 particleVel = new Vector2(
+                    (particlePos.X - (WorldPosition.X + size.X / 2.0f)),
+                    (float)Math.Sqrt(size.X) * Rand.Range(0.0f, 15.0f) * growModifier);
+
+                var particle = GameMain.ParticleManager.CreateParticle("flame",
+                    particlePos, particleVel, 0.0f, hull);
+
+                if (particle == null) continue;
+
+                //make some of the particles create another firesource when they enter another hull
+                if (Rand.Int(20) == 1) particle.OnChangeHull = OnChangeHull;
+
+                particle.Size *= MathHelper.Clamp(size.X / 60.0f * Math.Max(hull.Oxygen / hull.FullVolume, 0.4f), 0.5f, 1.0f);
+
+                if (Rand.Int(5) == 1)
+                {
+                    var smokeParticle = GameMain.ParticleManager.CreateParticle("smoke",
+                    particlePos, new Vector2(particleVel.X, particleVel.Y * 0.1f), 0.0f, hull);
+
+                    if (smokeParticle != null)
+                    {
+                        smokeParticle.Size *= MathHelper.Clamp(size.X / 100.0f * Math.Max(hull.Oxygen / hull.FullVolume, 0.4f), 0.5f, 1.0f);
+                    }
+                }
+            }
+
+            lightSource.Range = Math.Max(size.X, size.Y) * 10.0f / 2.0f;
+            lightSource.Color = new Color(1.0f, 0.45f, 0.3f) * Rand.Range(0.8f, 1.0f);
+            lightSource.Position = position + Vector2.UnitY * 30.0f;
+        }
+    }
+}

BarotraumaClient/Source/Map/Gap.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.ObjectModel;
+using Barotrauma.Items.Components;
+
+namespace Barotrauma
+{
+    partial class Gap : MapEntity
+    {
+        public override void Draw(SpriteBatch sb, bool editing, bool back = true)
+        {
+            if (GameMain.DebugDraw)
+            {
+                Vector2 center = new Vector2(WorldRect.X + rect.Width / 2.0f, -(WorldRect.Y - rect.Height / 2.0f));
+
+                GUI.DrawLine(sb, center, center + new Vector2(flowForce.X, -flowForce.Y) / 10.0f, Color.Red);
+
+                GUI.DrawLine(sb, center + Vector2.One * 5.0f, center + new Vector2(lerpedFlowForce.X, -lerpedFlowForce.Y) / 10.0f + Vector2.One * 5.0f, Color.Orange);
+            }
+
+            if (!editing || !ShowGaps) return;
+
+            Color clr = (open == 0.0f) ? Color.Red : Color.Cyan;
+            if (isHighlighted) clr = Color.Gold;
+
+            float depth = (ID % 255) * 0.000001f;
+
+            GUI.DrawRectangle(
+                sb, new Rectangle(WorldRect.X, -WorldRect.Y, rect.Width, rect.Height),
+                clr * 0.5f, true,
+                depth,
+                (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+
+            for (int i = 0; i < linkedTo.Count; i++)
+            {
+                Vector2 dir = isHorizontal ?
+                    new Vector2(Math.Sign(linkedTo[i].Rect.Center.X - rect.Center.X), 0.0f)
+                    : new Vector2(0.0f, Math.Sign((linkedTo[i].Rect.Y - linkedTo[i].Rect.Height / 2.0f) - (rect.Y - rect.Height / 2.0f)));
+
+                Vector2 arrowPos = new Vector2(WorldRect.Center.X, -(WorldRect.Y - WorldRect.Height / 2));
+                arrowPos += new Vector2(dir.X * (WorldRect.Width / 2 + 10), dir.Y * (WorldRect.Height / 2 + 10));
+
+                GUI.Arrow.Draw(sb,
+                    arrowPos, clr * 0.8f,
+                    GUI.Arrow.Origin, MathUtils.VectorToAngle(dir) + MathHelper.PiOver2,
+                    isHorizontal ? new Vector2(rect.Height / 16.0f, 1.0f) : new Vector2(rect.Width / 16.0f, 1.0f),
+                    SpriteEffects.None, depth);
+            }
+
+            if (IsSelected)
+            {
+                GUI.DrawRectangle(sb,
+                    new Vector2(WorldRect.X - 5, -WorldRect.Y - 5),
+                    new Vector2(rect.Width + 10, rect.Height + 10),
+                    Color.Red,
+                    false,
+                    depth,
+                    (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+            }
+        }
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement element = new XElement("Gap");
+
+            element.Add(
+                new XAttribute("ID", ID),
+                new XAttribute("horizontal", isHorizontal ? "true" : "false"));
+
+            element.Add(new XAttribute("rect",
+                    (int)(rect.X - Submarine.HiddenSubPosition.X) + "," +
+                    (int)(rect.Y - Submarine.HiddenSubPosition.Y) + "," +
+                    rect.Width + "," + rect.Height));
+
+            //if (linkedTo != null)
+            //{
+            //    int i = 0;
+            //    foreach (Entity e in linkedTo)
+            //    {
+            //        if (e == null) continue;
+            //        element.Add(new XAttribute("linkedto" + i, e.ID));
+            //        i += 1;
+            //    }
+            //}
+
+            parentElement.Add(element);
+
+            return element;
+        }
+    }
+}

BarotraumaClient/Source/Map/Hull.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Lidgren.Network;
+using Barotrauma.Networking;
+
+namespace Barotrauma
+{
+    partial class Hull : MapEntity, IPropertyObject, IServerSerializable
+    {
+        public static WaterRenderer renderer;
+
+        private Sound currentFlowSound;
+        private int soundIndex;
+        private float soundVolume;
+
+        public override bool IsMouseOn(Vector2 position)
+        {
+            if (!GameMain.DebugDraw && !ShowHulls) return false;
+
+            return (Submarine.RectContains(WorldRect, position) &&
+                !Submarine.RectContains(MathUtils.ExpandRect(WorldRect, -8), position));
+        }
+
+        public override void Draw(SpriteBatch spriteBatch, bool editing, bool back = true)
+        {
+            //if (back) return;
+            Rectangle drawRect;
+            if (!Visible)
+            {
+                drawRect =
+                    Submarine == null ? rect : new Rectangle((int)(Submarine.DrawPosition.X + rect.X), (int)(Submarine.DrawPosition.Y + rect.Y), rect.Width, rect.Height);
+
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(drawRect.X, -drawRect.Y),
+                    new Vector2(rect.Width, rect.Height),
+                    Color.Black, true,
+                    0, (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+            }
+
+            if (!ShowHulls && !GameMain.DebugDraw) return;
+
+            if (!editing && !GameMain.DebugDraw) return;
+
+            if (aiTarget != null) aiTarget.Draw(spriteBatch);
+
+            drawRect =
+                Submarine == null ? rect : new Rectangle((int)(Submarine.DrawPosition.X + rect.X), (int)(Submarine.DrawPosition.Y + rect.Y), rect.Width, rect.Height);
+
+            GUI.DrawRectangle(spriteBatch,
+                new Vector2(drawRect.X, -drawRect.Y),
+                new Vector2(rect.Width, rect.Height),
+                Color.Blue, false, (ID % 255) * 0.000001f, (int)Math.Max((1.5f / Screen.Selected.Cam.Zoom), 1.0f));
+
+            GUI.DrawRectangle(spriteBatch,
+                new Rectangle(drawRect.X, -drawRect.Y, rect.Width, rect.Height),
+                Color.Red * ((100.0f - OxygenPercentage) / 400.0f), true, 0, (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+
+            if (GameMain.DebugDraw)
+            {
+                GUI.SmallFont.DrawString(spriteBatch, "Pressure: " + ((int)pressure - rect.Y).ToString() +
+                    " - Oxygen: " + ((int)OxygenPercentage), new Vector2(drawRect.X + 5, -drawRect.Y + 5), Color.White);
+                GUI.SmallFont.DrawString(spriteBatch, volume + " / " + FullVolume, new Vector2(drawRect.X + 5, -drawRect.Y + 20), Color.White);
+
+                foreach (FireSource fs in fireSources)
+                {
+                    GUI.DrawRectangle(spriteBatch, new Rectangle((int)fs.WorldPosition.X, (int)-fs.WorldPosition.Y, (int)fs.Size.X, (int)fs.Size.Y), Color.Orange, false);
+                }
+            }
+
+            if ((IsSelected || isHighlighted) && editing)
+            {
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(drawRect.X + 5, -drawRect.Y + 5),
+                    new Vector2(rect.Width - 10, rect.Height - 10),
+                    isHighlighted ? Color.LightBlue * 0.5f : Color.Red * 0.5f, true, 0, (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+            }
+        }
+
+        public void Render(GraphicsDevice graphicsDevice, Camera cam)
+        {
+            if (renderer.PositionInBuffer > renderer.vertices.Length - 6) return;
+
+            Vector2 submarinePos = Submarine == null ? Vector2.Zero : Submarine.DrawPosition;
+
+            //calculate where the surface should be based on the water volume
+            float top = rect.Y + submarinePos.Y;
+            float bottom = top - rect.Height;
+
+            float drawSurface = surface + submarinePos.Y;
+
+            Matrix transform = cam.Transform * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
+
+            if (bottom > cam.WorldView.Y || top < cam.WorldView.Y - cam.WorldView.Height) return;
+
+            if (!update)
+            {
+                // create the four corners of our triangle.
+
+                Vector3[] corners = new Vector3[4];
+
+                corners[0] = new Vector3(rect.X, rect.Y, 0.0f);
+                corners[1] = new Vector3(rect.X + rect.Width, rect.Y, 0.0f);
+
+                corners[2] = new Vector3(corners[1].X, rect.Y - rect.Height, 0.0f);
+                corners[3] = new Vector3(corners[0].X, corners[2].Y, 0.0f);
+
+                Vector2[] uvCoords = new Vector2[4];
+                for (int i = 0; i < 4; i++)
+                {
+                    corners[i] += new Vector3(submarinePos, 0.0f);
+                    uvCoords[i] = Vector2.Transform(new Vector2(corners[i].X, -corners[i].Y), transform);
+                }
+
+                renderer.vertices[renderer.PositionInBuffer] = new VertexPositionTexture(corners[0], uvCoords[0]);
+                renderer.vertices[renderer.PositionInBuffer + 1] = new VertexPositionTexture(corners[1], uvCoords[1]);
+                renderer.vertices[renderer.PositionInBuffer + 2] = new VertexPositionTexture(corners[2], uvCoords[2]);
+
+                renderer.vertices[renderer.PositionInBuffer + 3] = new VertexPositionTexture(corners[0], uvCoords[0]);
+                renderer.vertices[renderer.PositionInBuffer + 4] = new VertexPositionTexture(corners[2], uvCoords[2]);
+                renderer.vertices[renderer.PositionInBuffer + 5] = new VertexPositionTexture(corners[3], uvCoords[3]);
+
+                renderer.PositionInBuffer += 6;
+
+                return;
+            }
+
+            float x = rect.X + Submarine.DrawPosition.X;
+            int start = (int)Math.Floor((cam.WorldView.X - x) / WaveWidth);
+            start = Math.Max(start, 0);
+
+            int end = (waveY.Length - 1)
+                - (int)Math.Floor((float)((x + rect.Width) - (cam.WorldView.X + cam.WorldView.Width)) / WaveWidth);
+            end = Math.Min(end, waveY.Length - 1);
+
+            x += start * WaveWidth;
+
+            for (int i = start; i < end; i++)
+            {
+                if (renderer.PositionInBuffer > renderer.vertices.Length - 6) return;
+
+                Vector3[] corners = new Vector3[4];
+
+                corners[0] = new Vector3(x, top, 0.0f);
+                corners[3] = new Vector3(corners[0].X, drawSurface + waveY[i], 0.0f);
+
+                //skip adjacent "water rects" if the surface of the water is roughly at the same position
+                int width = WaveWidth;
+                while (i < end - 1 && Math.Abs(waveY[i + 1] - waveY[i]) < 1.0f)
+                {
+                    width += WaveWidth;
+                    i++;
+                }
+
+                corners[1] = new Vector3(x + width, top, 0.0f);
+                corners[2] = new Vector3(corners[1].X, drawSurface + waveY[i + 1], 0.0f);
+
+                Vector2[] uvCoords = new Vector2[4];
+                for (int n = 0; n < 4; n++)
+                {
+                    uvCoords[n] = Vector2.Transform(new Vector2(corners[n].X, -corners[n].Y), transform);
+                }
+
+                renderer.vertices[renderer.PositionInBuffer] = new VertexPositionTexture(corners[0], uvCoords[0]);
+                renderer.vertices[renderer.PositionInBuffer + 1] = new VertexPositionTexture(corners[1], uvCoords[1]);
+                renderer.vertices[renderer.PositionInBuffer + 2] = new VertexPositionTexture(corners[2], uvCoords[2]);
+
+                renderer.vertices[renderer.PositionInBuffer + 3] = new VertexPositionTexture(corners[0], uvCoords[0]);
+                renderer.vertices[renderer.PositionInBuffer + 4] = new VertexPositionTexture(corners[2], uvCoords[2]);
+                renderer.vertices[renderer.PositionInBuffer + 5] = new VertexPositionTexture(corners[3], uvCoords[3]);
+
+                renderer.PositionInBuffer += 6;
+
+                x += width;
+            }
+
+        }
+
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement element = new XElement("Hull");
+
+            element.Add
+            (
+                new XAttribute("ID", ID),
+                new XAttribute("rect",
+                    (int)(rect.X - Submarine.HiddenSubPosition.X) + "," +
+                    (int)(rect.Y - Submarine.HiddenSubPosition.Y) + "," +
+                    rect.Width + "," + rect.Height),
+                new XAttribute("water", volume)
+            );
+
+            parentElement.Add(element);
+
+            return element;
+        }
+    }
+}

BarotraumaClient/Source/Map/Levels/Level.cs

@@ -0,0 +1,59 @@
+using FarseerPhysics;
+using FarseerPhysics.Common;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Factories;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Voronoi2;
+using Barotrauma.RuinGeneration;
+
+namespace Barotrauma
+{
+    partial class Level
+    {
+        private LevelRenderer renderer;
+
+        public void DrawFront(SpriteBatch spriteBatch)
+        {
+            if (renderer == null) return;
+            renderer.Draw(spriteBatch);
+
+            if (GameMain.DebugDraw)
+            {
+                foreach (InterestingPosition pos in positionsOfInterest)
+                {
+                    Color color = Color.Yellow;
+                    if (pos.PositionType == PositionType.Cave)
+                    {
+                        color = Color.DarkOrange;
+                    }
+                    else if (pos.PositionType == PositionType.Ruin)
+                    {
+                        color = Color.LightGray;
+                    }
+
+
+                    GUI.DrawRectangle(spriteBatch, new Vector2(pos.Position.X - 15.0f, -pos.Position.Y - 15.0f), new Vector2(30.0f, 30.0f), color, true);
+                }
+            }
+        }
+
+        public void DrawBack(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, BackgroundCreatureManager backgroundSpriteManager = null)
+        {
+            float brightness = MathHelper.Clamp(50.0f + (cam.Position.Y - Size.Y) / 2000.0f, 10.0f, 40.0f);
+
+            float avgValue = (backgroundColor.R + backgroundColor.G + backgroundColor.G) / 3;
+            GameMain.LightManager.AmbientLight = new Color(backgroundColor * (brightness / avgValue), 1.0f);
+
+            graphics.Clear(backgroundColor);
+
+            if (renderer == null) return;
+            renderer.DrawBackground(spriteBatch, cam, backgroundSpriteManager);
+        }
+    }
+}

BarotraumaClient/Source/Map/Levels/LevelRenderer.cs

@@ -0,0 +1,253 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    class LevelRenderer : IDisposable
+    {
+        private static BasicEffect wallEdgeEffect, wallCenterEffect;
+
+        private static Sprite background, backgroundTop;
+        private static Sprite dustParticles;
+        private static Texture2D shaftTexture;
+
+        private static BackgroundSpriteManager backgroundSpriteManager;
+
+        Vector2 dustOffset;
+
+        private Level level;
+
+        private VertexBuffer wallVertices, bodyVertices;
+        
+        //public VertexPositionTexture[] WallVertices;
+        //public VertexPositionColor[] BodyVertices;
+        
+        public LevelRenderer(Level level)
+        {
+            if (shaftTexture == null) shaftTexture = TextureLoader.FromFile("Content/Map/iceWall.png");
+
+            if (background==null)
+            {
+                background = new Sprite("Content/Map/background2.png", Vector2.Zero);
+                backgroundTop = new Sprite("Content/Map/background.png", Vector2.Zero);
+                dustParticles = new Sprite("Content/Map/dustparticles.png", Vector2.Zero);
+            }
+
+            if (wallEdgeEffect == null)
+            {
+                wallEdgeEffect = new BasicEffect(GameMain.Instance.GraphicsDevice)
+                {
+                    DiffuseColor = new Vector3(0.8f, 0.8f, 0.8f),
+                    VertexColorEnabled = false,
+                    TextureEnabled = true,
+                    Texture = shaftTexture
+                };
+                wallEdgeEffect.CurrentTechnique = wallEdgeEffect.Techniques["BasicEffect_Texture"];
+            }
+
+            if (wallCenterEffect == null)
+            {
+                wallCenterEffect = new BasicEffect(GameMain.Instance.GraphicsDevice)
+                {
+                    VertexColorEnabled = false,
+                    TextureEnabled = true,
+                    Texture = backgroundTop.Texture
+                };
+                wallCenterEffect.CurrentTechnique = wallCenterEffect.Techniques["BasicEffect_Texture"];
+            }
+
+            
+            if (backgroundSpriteManager==null)
+            {
+
+                var files = GameMain.SelectedPackage.GetFilesOfType(ContentType.BackgroundSpritePrefabs);
+                if (files.Count > 0)
+                    backgroundSpriteManager = new BackgroundSpriteManager(files);
+                else
+                    backgroundSpriteManager = new BackgroundSpriteManager("Content/BackgroundSprites/BackgroundSpritePrefabs.xml");
+            }
+
+            this.level = level;
+        }
+
+        public void PlaceSprites(int amount)
+        {
+            backgroundSpriteManager.PlaceSprites(level, amount);
+        }
+
+        public void Update(float deltaTime)
+        {
+            dustOffset -= Vector2.UnitY * 10.0f * deltaTime;
+
+            backgroundSpriteManager.Update(deltaTime);
+        }
+
+        public void SetWallVertices(VertexPositionTexture[] vertices)
+        {
+            wallVertices = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionTexture.VertexDeclaration, vertices.Length,BufferUsage.WriteOnly);
+            wallVertices.SetData(vertices);
+        }
+
+        public void SetBodyVertices(VertexPositionTexture[] vertices)
+        {
+            bodyVertices = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionTexture.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
+            bodyVertices.SetData(vertices);
+        }
+
+        public void DrawBackground(SpriteBatch spriteBatch, Camera cam, BackgroundCreatureManager backgroundCreatureManager = null)
+        {
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearWrap);
+
+            Vector2 backgroundPos = cam.WorldViewCenter;
+            
+            backgroundPos.Y = -backgroundPos.Y;
+            backgroundPos /= 20.0f;
+
+            if (backgroundPos.Y < 1024)
+            {
+                if (backgroundPos.Y < 0)
+                {
+                    backgroundTop.SourceRect = new Rectangle((int)backgroundPos.X, (int)backgroundPos.Y, 1024, (int)Math.Min(-backgroundPos.Y, 1024));
+                    backgroundTop.DrawTiled(spriteBatch, Vector2.Zero, new Vector2(GameMain.GraphicsWidth, Math.Min(-backgroundPos.Y, GameMain.GraphicsHeight)),
+                        Vector2.Zero, level.BackgroundColor);
+                }
+                if (backgroundPos.Y > -1024)
+                {
+                    background.SourceRect = new Rectangle((int)backgroundPos.X, (int)Math.Max(backgroundPos.Y, 0), 1024, 1024);
+                    background.DrawTiled(spriteBatch,
+                        (backgroundPos.Y < 0) ? new Vector2(0.0f, (int)-backgroundPos.Y) : Vector2.Zero,
+                        new Vector2(GameMain.GraphicsWidth, (int)Math.Ceiling(1024 - backgroundPos.Y)),
+                        Vector2.Zero, level.BackgroundColor);
+                }
+            }
+
+            spriteBatch.End();
+
+            spriteBatch.Begin(SpriteSortMode.BackToFront,
+                BlendState.AlphaBlend,
+                SamplerState.LinearWrap, DepthStencilState.Default, null, null,
+                cam.Transform);
+
+            backgroundSpriteManager.DrawSprites(spriteBatch, cam);
+
+            if (backgroundCreatureManager!=null) backgroundCreatureManager.Draw(spriteBatch);
+
+
+            for (int i = 0; i < 4; i++)
+            {
+                float scale = 1.0f - i * 0.2f;
+
+                //alpha goes from 1.0 to 0.0 when scale is in the range of 0.2-0.1
+                float alpha = (cam.Zoom * scale) < 0.2f ? (cam.Zoom * scale - 0.1f) * 10.0f : 1.0f;
+                if (alpha <= 0.0f) continue;
+
+                Vector2 offset = (new Vector2(cam.WorldViewCenter.X, cam.WorldViewCenter.Y) + dustOffset) * scale;
+                Vector3 origin = new Vector3(cam.WorldView.Width, cam.WorldView.Height, 0.0f) * 0.5f;
+
+                dustParticles.SourceRect = new Rectangle(
+                    (int)((offset.X - origin.X + (i * 256)) / scale),
+                    (int)((-offset.Y - origin.Y + (i * 256)) / scale),
+                    (int)((cam.WorldView.Width) / scale),
+                    (int)((cam.WorldView.Height) / scale));
+
+                spriteBatch.Draw(dustParticles.Texture,
+                    new Vector2(cam.WorldViewCenter.X, -cam.WorldViewCenter.Y),
+                    dustParticles.SourceRect, Color.White * alpha, 0.0f,
+                    new Vector2(cam.WorldView.Width, cam.WorldView.Height) * 0.5f / scale, scale, SpriteEffects.None, 1.0f - scale);
+            }
+
+            spriteBatch.End();
+
+            RenderWalls(GameMain.Instance.GraphicsDevice, cam);
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (GameMain.DebugDraw)
+            {
+                var cells = level.GetCells(GameMain.GameScreen.Cam.WorldViewCenter, 2);
+                foreach (VoronoiCell cell in cells)
+                {
+                    GUI.DrawRectangle(spriteBatch, new Vector2(cell.Center.X - 10.0f, -cell.Center.Y-10.0f), new Vector2(20.0f, 20.0f), Color.Cyan, true);
+
+                    GUI.DrawLine(spriteBatch, 
+                        new Vector2(cell.edges[0].point1.X, -cell.edges[0].point1.Y),
+                        new Vector2(cell.Center.X, -cell.Center.Y), 
+                        Color.Blue*0.5f);
+                
+                    foreach (GraphEdge edge in cell.edges)
+                    {
+                        GUI.DrawLine(spriteBatch, new Vector2(edge.point1.X, -edge.point1.Y),
+                            new Vector2(edge.point2.X, -edge.point2.Y), cell.body==null ? Color.Cyan*0.5f : Color.White);
+                    }
+
+                    foreach (Vector2 point in cell.bodyVertices)
+                    {
+                        GUI.DrawRectangle(spriteBatch, new Vector2(point.X, -point.Y), new Vector2(10.0f, 10.0f), Color.White, true);
+                    }
+                }
+
+            }
+
+
+            Vector2 pos = new Vector2(0.0f, -level.Size.Y);
+
+            if (GameMain.GameScreen.Cam.WorldView.Y < -pos.Y - 1024) return;
+
+            pos.X = GameMain.GameScreen.Cam.WorldView.X -1024;
+
+            int width = (int)(Math.Ceiling(GameMain.GameScreen.Cam.WorldView.Width / 1024 + 4.0f) * 1024);
+
+            GUI.DrawRectangle(spriteBatch,new Rectangle((int)(MathUtils.Round(pos.X, 1024)), (int)-GameMain.GameScreen.Cam.WorldView.Y, width, (int)(GameMain.GameScreen.Cam.WorldView.Y + pos.Y) - 30),Color.Black, true);
+            spriteBatch.Draw(shaftTexture,
+                new Rectangle((int)(MathUtils.Round(pos.X, 1024)), (int)pos.Y-1000, width, 1024),
+                new Rectangle(0, 0, width, -1024),
+                level.BackgroundColor, 0.0f,
+                Vector2.Zero,
+                SpriteEffects.None, 0.0f);
+
+        }
+
+
+        public void RenderWalls(GraphicsDevice graphicsDevice, Camera cam)
+        {
+            if (wallVertices == null) return;
+            
+            wallEdgeEffect.World = cam.ShaderTransform
+                * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 100) * 0.5f;
+            wallCenterEffect.World = wallEdgeEffect.World;
+
+            //render the solid center of the wall cells
+            graphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
+            graphicsDevice.SetVertexBuffer(bodyVertices);
+            wallCenterEffect.CurrentTechnique.Passes[0].Apply();
+            
+            graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, (int)Math.Floor(bodyVertices.VertexCount / 3.0f));
+            
+            //render the edges of the wall cells
+            graphicsDevice.SetVertexBuffer(wallVertices);
+            wallEdgeEffect.CurrentTechnique.Passes[0].Apply();
+            graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, (int)Math.Floor(wallVertices.VertexCount / 3.0f));
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (wallVertices!=null) wallVertices.Dispose();
+            if (bodyVertices != null) bodyVertices.Dispose();
+        }
+
+    }
+}

BarotraumaClient/Source/Map/Levels/WaterRenderer.cs

@@ -0,0 +1,124 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Content;
+
+namespace Barotrauma
+{
+    class WaterRenderer : IDisposable
+    {
+        const int DefaultBufferSize = 1500;
+
+        private Vector2 wavePos;
+
+        public VertexPositionTexture[] vertices = new VertexPositionTexture[DefaultBufferSize];
+
+        private Effect waterEffect;
+        private BasicEffect basicEffect;
+
+        public int PositionInBuffer = 0;
+
+        private Texture2D waterTexture;
+
+        public Texture2D WaterTexture
+        {
+            get { return waterTexture; }
+        }
+
+        public WaterRenderer(GraphicsDevice graphicsDevice, ContentManager content)
+        {
+#if WINDOWS
+            waterEffect = content.Load<Effect>("watershader");
+#endif
+#if LINUX
+
+            waterEffect = content.Load<Effect>("watershader_opengl");
+#endif
+
+            waterTexture = TextureLoader.FromFile("Content/waterbump.png");
+            waterEffect.Parameters["xWaveWidth"].SetValue(0.05f);
+            waterEffect.Parameters["xWaveHeight"].SetValue(0.05f);
+
+#if WINDOWS
+            //waterEffect.Parameters["xTexture"].SetValue(waterTexture);
+#endif
+#if LINUX
+            waterEffect.Parameters["xWaterBumpMap"].SetValue(waterTexture);
+#endif
+
+            if (basicEffect == null)
+            {
+                basicEffect = new BasicEffect(GameMain.Instance.GraphicsDevice);
+                basicEffect.VertexColorEnabled = false;
+
+                basicEffect.TextureEnabled = true;
+            }
+        }
+
+        public void RenderBack(SpriteBatch spriteBatch, RenderTarget2D texture, float blurAmount = 0.0f)
+        {
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Opaque, SamplerState.LinearWrap, null, null, waterEffect);
+
+            waterEffect.CurrentTechnique = waterEffect.Techniques["WaterShader"];
+            waterEffect.Parameters["xWavePos"].SetValue(wavePos);
+            waterEffect.Parameters["xBlurDistance"].SetValue(blurAmount);
+            //waterEffect.CurrentTechnique.Passes[0].Apply();
+            
+#if WINDOWS
+            waterEffect.Parameters["xTexture"].SetValue(texture);
+            spriteBatch.Draw(waterTexture, new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight), Color.White);
+#elif LINUX
+
+            spriteBatch.Draw(texture, new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight), Color.White);
+#endif
+            spriteBatch.End();
+        }
+
+        public void ScrollWater(float deltaTime)
+        {
+            wavePos.X += 0.006f * deltaTime;
+            wavePos.Y += 0.006f * deltaTime;
+        }
+
+        public void Render(GraphicsDevice graphicsDevice, Camera cam, RenderTarget2D texture, Matrix transform)
+        {
+            if (vertices == null) return;
+            if (vertices.Length < 0) return;
+
+            basicEffect.Texture = texture;
+
+            basicEffect.View = Matrix.Identity;
+            basicEffect.World = transform
+                * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
+
+            basicEffect.CurrentTechnique.Passes[0].Apply();
+
+            graphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
+            graphicsDevice.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleList, vertices, 0, vertices.Length / 3);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposing) return;
+
+            if (waterEffect != null)
+            {
+                waterEffect.Dispose();
+                waterEffect = null;
+            }
+
+            if (basicEffect != null)
+            {
+                basicEffect.Dispose();
+                basicEffect = null;
+            }
+        }
+
+    }
+}

BarotraumaClient/Source/Map/Lights/ConvexHull.cs

@@ -0,0 +1,677 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Barotrauma.Lights
+{
+    /*class CachedShadow : IDisposable
+    {
+        public VertexBuffer ShadowBuffer;
+
+        public Vector2 LightPos;
+
+        public int ShadowVertexCount, PenumbraVertexCount;
+
+        public CachedShadow(VertexPositionColor[] shadowVertices, Vector2 lightPos, int shadowVertexCount, int penumbraVertexCount)
+        {
+            //var ShadowVertices = new VertexPositionColor [shadowVertices.Count()];
+            //shadowVertices.CopyTo(ShadowVertices, 0);
+
+            ShadowBuffer = new VertexBuffer(GameMain.CurrGraphicsDevice, VertexPositionColor.VertexDeclaration, 6*2, BufferUsage.None);
+            ShadowBuffer.SetData(shadowVertices, 0, shadowVertices.Length);
+
+            ShadowVertexCount = shadowVertexCount;
+            PenumbraVertexCount = penumbraVertexCount;
+
+            LightPos = lightPos;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            ShadowBuffer.Dispose();
+        }
+    }*/
+
+    class ConvexHullList
+    {
+        private List<ConvexHull> list;
+
+        public readonly Submarine Submarine;
+        public List<ConvexHull> List
+        {
+            get { return list; }
+            set
+            {
+                Debug.Assert(value != null);
+                Debug.Assert(!list.Contains(null));
+                list = value;
+            }
+        }
+
+        public ConvexHullList(Submarine submarine)
+        {
+            Submarine = submarine;
+            list = new List<ConvexHull>();
+        }
+    }
+
+    class Segment
+    {
+        public SegmentPoint Start;
+        public SegmentPoint End;
+
+        public bool IsHorizontal;
+
+        public Segment(SegmentPoint start, SegmentPoint end)
+        {
+            Start = start;
+            End = end;
+
+            start.Segment = this;
+            end.Segment = this;
+
+            IsHorizontal = Math.Abs(start.Pos.X - end.Pos.X) > Math.Abs(start.Pos.Y - end.Pos.Y);
+        }
+    }
+
+    struct SegmentPoint
+    {
+        public Vector2 Pos;        
+        public Vector2 WorldPos;
+
+        public Segment Segment;
+
+        public SegmentPoint(Vector2 pos)
+        {
+            Pos = pos;
+            WorldPos = pos;
+
+            Segment = null;
+        }
+
+        public override string ToString()
+        {
+            return Pos.ToString();
+        }
+    }
+
+    class ConvexHull
+    {
+        public static List<ConvexHullList> HullLists = new List<ConvexHullList>();
+        static BasicEffect shadowEffect;
+        static BasicEffect penumbraEffect;
+
+        //private Dictionary<LightSource, CachedShadow> cachedShadows;
+
+        public VertexBuffer ShadowBuffer;
+
+        Segment[] segments = new Segment[4];
+        SegmentPoint[] vertices = new SegmentPoint[4];
+        SegmentPoint[] losVertices = new SegmentPoint[4];
+
+        //private Vector2[] vertices;
+        //private Vector2[] losVertices;
+
+        private bool[] backFacing;
+        private bool[] ignoreEdge;
+
+        private VertexPositionColor[] shadowVertices;
+        private VertexPositionTexture[] penumbraVertices;
+        
+        int shadowVertexCount;
+
+        private Entity parentEntity;
+
+        private Rectangle boundingBox;
+
+        public Entity ParentEntity
+        {
+            get { return parentEntity; }
+
+        }
+
+        private bool enabled;
+        public bool Enabled
+        {
+            get
+            {
+                return enabled;
+            }
+            set
+            {
+                if (enabled == value) return;
+                enabled = value;
+                LastVertexChangeTime = (float)Timing.TotalTime;
+            }
+        }
+
+        /// <summary>
+        /// The elapsed gametime when the vertices of this hull last changed
+        /// </summary>
+        public float LastVertexChangeTime
+        {
+            get;
+            private set;
+        }
+
+        public Rectangle BoundingBox
+        {
+            get { return boundingBox; }
+        }
+                
+        public ConvexHull(Vector2[] points, Color color, Entity parent)
+        {
+            if (shadowEffect == null)
+            {
+                shadowEffect = new BasicEffect(GameMain.Instance.GraphicsDevice);
+                shadowEffect.VertexColorEnabled = true;
+            }
+            if (penumbraEffect == null)
+            {
+                penumbraEffect = new BasicEffect(GameMain.Instance.GraphicsDevice);
+                penumbraEffect.TextureEnabled = true;
+                //shadowEffect.VertexColorEnabled = true;
+                penumbraEffect.LightingEnabled = false;
+                penumbraEffect.Texture = TextureLoader.FromFile("Content/Lights/penumbra.png");
+            }
+
+            parentEntity = parent;
+
+            //cachedShadows = new Dictionary<LightSource, CachedShadow>();
+            
+            shadowVertices = new VertexPositionColor[6 * 2];
+            penumbraVertices = new VertexPositionTexture[6];
+            
+            //vertices = points;
+            SetVertices(points);
+            //CalculateDimensions();
+            
+            backFacing = new bool[4];
+            ignoreEdge = new bool[4];
+                        
+            Enabled = true;
+
+            var chList = HullLists.Find(x => x.Submarine == parent.Submarine);
+            if (chList == null)
+            {
+                chList = new ConvexHullList(parent.Submarine);
+                HullLists.Add(chList);
+            }                       
+            
+            foreach (ConvexHull ch in chList.List)
+            {
+                UpdateIgnoredEdges(ch);
+                ch.UpdateIgnoredEdges(this);
+            }
+
+            chList.List.Add(this);
+        }
+
+        private void UpdateIgnoredEdges(ConvexHull ch)
+        {
+            if (ch == this) return;
+            //ignore edges that are inside some other convex hull
+            for (int i = 0; i < vertices.Length; i++)
+            {
+                if (vertices[i].Pos.X >= ch.boundingBox.X && vertices[i].Pos.X <= ch.boundingBox.Right && 
+                    vertices[i].Pos.Y >= ch.boundingBox.Y && vertices[i].Pos.Y <= ch.boundingBox.Bottom)
+                {
+                    Vector2 p = vertices[(i + 1) % vertices.Length].Pos;
+
+                    if (p.X >= ch.boundingBox.X && p.X <= ch.boundingBox.Right && 
+                        p.Y >= ch.boundingBox.Y && p.Y <= ch.boundingBox.Bottom)
+                    {
+                        ignoreEdge[i] = true;
+                    }
+                }                    
+            }            
+        }
+        
+        private void CalculateDimensions()
+        {
+            float minX = vertices[0].Pos.X, minY = vertices[0].Pos.Y, maxX = vertices[0].Pos.X, maxY = vertices[0].Pos.Y;
+
+            for (int i = 1; i < vertices.Length; i++)
+            {
+                if (vertices[i].Pos.X < minX) minX = vertices[i].Pos.X;
+                if (vertices[i].Pos.Y < minY) minY = vertices[i].Pos.Y;
+
+                if (vertices[i].Pos.X > maxX) maxX = vertices[i].Pos.X;
+                if (vertices[i].Pos.Y > minY) maxY = vertices[i].Pos.Y;
+            }
+
+            boundingBox = new Rectangle((int)minX, (int)minY, (int)(maxX - minX), (int)(maxY - minY));
+        }
+                
+        public void Move(Vector2 amount)
+        {
+            for (int i = 0; i < vertices.Length; i++)
+            {
+                vertices[i].Pos         += amount;
+                losVertices[i].Pos      += amount;
+
+                segments[i].Start.Pos   += amount;
+                segments[i].End.Pos     += amount;
+            }
+
+            LastVertexChangeTime = (float)Timing.TotalTime;
+
+            CalculateDimensions();
+        }
+
+        public void SetVertices(Vector2[] points)
+        {
+            Debug.Assert(points.Length == 4, "Only rectangular convex hulls are supported");
+
+            LastVertexChangeTime = (float)Timing.TotalTime;
+
+            for (int i = 0; i < 4; i++)
+            {
+                vertices[i]     = new SegmentPoint(points[i]);
+                losVertices[i]  = new SegmentPoint(points[i]);
+
+            }
+            for (int i = 0; i < 4; i++)
+            {
+                segments[i] = new Segment(vertices[i], vertices[(i + 1) % 4]);
+            }
+            
+            int margin = 0;
+
+            if (Math.Abs(points[0].X - points[2].X) < Math.Abs(points[0].Y - points[1].Y))
+            {
+                losVertices[0].Pos = new Vector2(points[0].X + margin, points[0].Y);
+                losVertices[1].Pos = new Vector2(points[1].X + margin, points[1].Y);
+                losVertices[2].Pos = new Vector2(points[2].X - margin, points[2].Y);
+                losVertices[3].Pos = new Vector2(points[3].X - margin, points[3].Y);
+            }
+            else
+            {
+                losVertices[0].Pos = new Vector2(points[0].X, points[0].Y + margin);
+                losVertices[1].Pos = new Vector2(points[1].X, points[1].Y - margin);
+                losVertices[2].Pos = new Vector2(points[2].X, points[2].Y - margin);
+                losVertices[3].Pos = new Vector2(points[3].X, points[3].Y + margin);
+            }
+
+            CalculateDimensions();
+
+            if (parentEntity == null || ignoreEdge == null) return;
+            for (int i = 0; i<4; i++)
+            {
+                ignoreEdge[i] = false;
+            }
+
+            var chList = HullLists.Find(x => x.Submarine == parentEntity.Submarine);
+            if (chList != null)
+            {
+                foreach (ConvexHull ch in chList.List)
+                {
+                    UpdateIgnoredEdges(ch);
+                }
+            }
+        }
+
+        /*private void RemoveCachedShadow(Lights.LightSource light)
+        {
+            CachedShadow shadow = null;
+            cachedShadows.TryGetValue(light, out shadow);
+
+            if (shadow != null)
+            {
+                shadow.Dispose();
+                cachedShadows.Remove(light);
+            }
+        }
+
+        private void ClearCachedShadows()
+        {
+            foreach (KeyValuePair<LightSource, CachedShadow> cachedShadow in cachedShadows)
+            {
+                cachedShadow.Key.NeedsHullUpdate = true;
+                cachedShadow.Value.Dispose();
+            }
+            cachedShadows.Clear();
+        }*/
+
+        public bool Intersects(Rectangle rect)
+        {
+            if (!Enabled) return false;
+
+            Rectangle transformedBounds = boundingBox;
+            if (parentEntity != null && parentEntity.Submarine != null)
+            {
+                transformedBounds.X += (int)parentEntity.Submarine.Position.X;
+                transformedBounds.Y += (int)parentEntity.Submarine.Position.Y;
+            }
+            return transformedBounds.Intersects(rect);
+        }
+        
+        /// <summary>
+        /// Returns the segments that are facing towards viewPosition
+        /// </summary>
+        public List<Segment> GetVisibleSegments(Vector2 viewPosition)
+        {
+            List<Segment> visibleFaces = new List<Segment>();
+            
+            for (int i = 0; i < 4; i++)
+            {
+                if (ignoreEdge[i]) continue;
+
+                Vector2 pos1 = vertices[i].WorldPos;
+                Vector2 pos2 = vertices[(i + 1) % 4].WorldPos;
+
+                Vector2 middle = (pos1 + pos2) / 2;
+
+                Vector2 L = viewPosition - middle;
+
+                Vector2 N = new Vector2(
+                    -(pos2.Y - pos1.Y),
+                    pos2.X - pos1.X);
+
+                if (Vector2.Dot(N, L) > 0)
+                {
+                    visibleFaces.Add(segments[i]);
+                }
+            }
+
+            return visibleFaces;
+        }
+
+
+        public void RefreshWorldPositions()
+        {
+            if (parentEntity == null || parentEntity.Submarine == null) return;
+            for (int i = 0; i < 4; i++)
+            {
+                vertices[i].WorldPos = vertices[i].Pos + parentEntity.Submarine.DrawPosition;
+                segments[i].Start.WorldPos = segments[i].Start.Pos + parentEntity.Submarine.DrawPosition;
+                segments[i].End.WorldPos = segments[i].End.Pos + parentEntity.Submarine.DrawPosition;
+
+            }
+        }
+
+        private void CalculateShadowVertices(Vector2 lightSourcePos, bool los = true)
+        {
+            shadowVertexCount = 0;
+
+            var vertices = los ? losVertices : this.vertices;
+            
+            //compute facing of each edge, using N*L
+            for (int i = 0; i < 4; i++)
+            {
+                if (ignoreEdge[i])
+                {
+                    backFacing[i] = false;
+                    continue;
+                }
+
+                Vector2 firstVertex = vertices[i].Pos;
+                Vector2 secondVertex = vertices[(i+1) % 4].Pos;
+
+                Vector2 L = lightSourcePos - ((firstVertex + secondVertex) / 2.0f);
+
+                Vector2 N = new Vector2(
+                    -(secondVertex.Y - firstVertex.Y),
+                    secondVertex.X - firstVertex.X);
+
+                backFacing[i] = (Vector2.Dot(N, L) < 0) == los;
+            }
+
+            //find beginning and ending vertices which
+            //belong to the shadow
+            int startingIndex = 0;
+            int endingIndex = 0;
+            for (int i = 0; i < 4; i++)
+            {
+                int currentEdge = i;
+                int nextEdge = (i + 1) % 4;
+
+                if (backFacing[currentEdge] && !backFacing[nextEdge])
+                    endingIndex = nextEdge;
+
+                if (!backFacing[currentEdge] && backFacing[nextEdge])
+                    startingIndex = nextEdge;
+            }
+
+            //nr of vertices that are in the shadow
+            if (endingIndex > startingIndex)
+                shadowVertexCount = endingIndex - startingIndex + 1;
+            else
+                shadowVertexCount = 4 + 1 - startingIndex + endingIndex;
+
+            //shadowVertices = new VertexPositionColor[shadowVertexCount * 2];
+
+            //create a triangle strip that has the shape of the shadow
+            int currentIndex = startingIndex;
+            int svCount = 0;
+            while (svCount != shadowVertexCount * 2)
+            {
+                Vector3 vertexPos = new Vector3(vertices[currentIndex].Pos, 0.0f);
+
+                int i = los ? svCount : svCount + 1;
+                int j = los ? svCount + 1 : svCount;
+
+                //one vertex on the hull
+                shadowVertices[i] = new VertexPositionColor();
+                shadowVertices[i].Color = los ? Color.Black : Color.Transparent;
+                shadowVertices[i].Position = vertexPos;
+
+                //one extruded by the light direction
+                shadowVertices[j] = new VertexPositionColor();
+                shadowVertices[j].Color = shadowVertices[i].Color;
+
+                Vector3 L2P = vertexPos - new Vector3(lightSourcePos, 0);
+                L2P.Normalize();
+                
+                shadowVertices[j].Position = new Vector3(lightSourcePos, 0) + L2P * 9000;
+
+                svCount += 2;
+                currentIndex = (currentIndex + 1) % 4;
+            }
+
+            if (los)
+            {
+                CalculatePenumbraVertices(startingIndex, endingIndex, lightSourcePos, los);
+            }
+        }
+
+        private void CalculatePenumbraVertices(int startingIndex, int endingIndex, Vector2 lightSourcePos, bool los)
+        {
+            for (int n = 0; n < 4; n += 3)
+            {
+                Vector3 penumbraStart = new Vector3((n == 0) ? vertices[startingIndex].Pos : vertices[endingIndex].Pos, 0.0f);
+
+                penumbraVertices[n] = new VertexPositionTexture();
+                penumbraVertices[n].Position = penumbraStart;
+                penumbraVertices[n].TextureCoordinate = new Vector2(0.0f, 1.0f);
+                //penumbraVertices[0].te = fow ? Color.Black : Color.Transparent;
+
+                for (int i = 0; i < 2; i++)
+                {
+                    penumbraVertices[n + i + 1] = new VertexPositionTexture();
+                    Vector3 vertexDir = penumbraStart - new Vector3(lightSourcePos, 0);
+                    vertexDir.Normalize();
+
+                    Vector3 normal = (i == 0) ? new Vector3(-vertexDir.Y, vertexDir.X, 0.0f) : new Vector3(vertexDir.Y, -vertexDir.X, 0.0f) * 0.05f;
+                    if (n > 0) normal = -normal;
+
+                    vertexDir = penumbraStart - (new Vector3(lightSourcePos, 0) - normal * 20.0f);
+                    vertexDir.Normalize();
+                    penumbraVertices[n + i + 1].Position = new Vector3(lightSourcePos, 0) + vertexDir * 9000;
+
+                    if (los)
+                    {
+                        penumbraVertices[n + i + 1].TextureCoordinate = (i == 0) ? new Vector2(0.05f, 0.0f) : new Vector2(1.0f, 0.0f);
+                    }
+                    else
+                    {
+                        penumbraVertices[n + i + 1].TextureCoordinate = (i == 0) ? new Vector2(1.0f, 0.0f) : Vector2.Zero;
+                    }
+                }
+
+                if (n > 0)
+                {
+                    var temp = penumbraVertices[4];
+                    penumbraVertices[4] = penumbraVertices[5];
+                    penumbraVertices[5] = temp;
+                }
+            }
+        }
+
+        public static List<ConvexHull> GetHullsInRange(Vector2 position, float range, Submarine ParentSub)
+        {
+            List<ConvexHull> list = new List<ConvexHull>();
+
+            foreach (ConvexHullList chList in ConvexHull.HullLists)
+            {
+                Vector2 lightPos = position;
+                if (ParentSub == null)
+                {
+                    //light and the convexhull are both outside
+                    if (chList.Submarine == null)
+                    {
+                        list.AddRange(chList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox)));
+
+                    }
+                    //light is outside, convexhull inside a sub
+                    else
+                    {
+                        if (!MathUtils.CircleIntersectsRectangle(lightPos - chList.Submarine.WorldPosition, range, chList.Submarine.Borders)) continue;
+
+                        lightPos -= (chList.Submarine.WorldPosition - chList.Submarine.HiddenSubPosition);
+
+                        list.AddRange(chList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox)));
+                    }
+                }
+                else
+                {
+                    //light is inside, convexhull outside
+                    if (chList.Submarine == null) continue;
+
+                    //light and convexhull are both inside the same sub
+                    if (chList.Submarine == ParentSub)
+                    {
+                        list.AddRange(chList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox)));
+                    }
+                    //light and convexhull are inside different subs
+                    else
+                    {
+                        lightPos -= (chList.Submarine.Position - ParentSub.Position);
+
+                        Rectangle subBorders = chList.Submarine.Borders;
+                        subBorders.Location += chList.Submarine.HiddenSubPosition.ToPoint() - new Point(0, chList.Submarine.Borders.Height);
+
+                        if (!MathUtils.CircleIntersectsRectangle(lightPos, range, subBorders)) continue;
+
+                        list.AddRange(chList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox)));
+                    }
+                }
+            }
+
+            return list;
+        }
+
+        public void DrawShadows(GraphicsDevice graphicsDevice, Camera cam, LightSource light, Matrix transform, bool los = true)
+        {
+            if (!Enabled) return;
+
+            Vector2 lightSourcePos = light.Position;
+
+            if (parentEntity != null && parentEntity.Submarine != null)
+            {
+                if (light.ParentSub == null)
+                {
+                    lightSourcePos -= parentEntity.Submarine.Position;
+                }
+                else if (light.ParentSub != parentEntity.Submarine)
+                {
+                    lightSourcePos += (light.ParentSub.Position-parentEntity.Submarine.Position);
+                }
+                
+            }
+            
+            CalculateShadowVertices(lightSourcePos, los);
+            ShadowBuffer = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionColor.VertexDeclaration, 6 * 2, BufferUsage.None);
+            ShadowBuffer.SetData(shadowVertices, 0, shadowVertices.Length);
+            
+            graphicsDevice.SetVertexBuffer(ShadowBuffer);
+            shadowVertexCount = shadowVertices.Length;
+
+            DrawShadows(graphicsDevice, cam, transform, los);
+        }
+
+        public void DrawShadows(GraphicsDevice graphicsDevice, Camera cam, Vector2 lightSourcePos, Matrix transform, bool los = true)
+        {
+            if (!Enabled) return;
+
+            if (parentEntity != null && parentEntity.Submarine != null) lightSourcePos -= parentEntity.Submarine.Position;
+
+            CalculateShadowVertices(lightSourcePos, los);
+
+            DrawShadows(graphicsDevice, cam, transform, los);
+        }
+
+        private void DrawShadows(GraphicsDevice graphicsDevice, Camera cam, Matrix transform, bool los = true)
+        {
+            Vector3 offset = Vector3.Zero;
+            if (parentEntity != null && parentEntity.Submarine != null)
+            {
+                offset = new Vector3(parentEntity.Submarine.DrawPosition.X, parentEntity.Submarine.DrawPosition.Y, 0.0f);
+            }
+            
+            if (shadowVertexCount>0)
+            {                
+                shadowEffect.World = Matrix.CreateTranslation(offset) * transform;                
+
+                if (los)
+                {
+                    shadowEffect.CurrentTechnique.Passes[0].Apply();
+                    graphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleStrip, shadowVertices, 0, shadowVertexCount * 2 - 2, VertexPositionColor.VertexDeclaration);
+                }
+                else
+                {                    
+                    shadowEffect.CurrentTechnique.Passes[0].Apply();
+                    graphicsDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, shadowVertexCount * 2 - 2);
+                }               
+            
+            }
+
+
+            if (los)
+            {
+                penumbraEffect.World = shadowEffect.World;
+                penumbraEffect.CurrentTechnique.Passes[0].Apply();
+
+#if WINDOWS
+                graphicsDevice.DrawUserPrimitives(PrimitiveType.TriangleList, penumbraVertices, 0, 2, VertexPositionTexture.VertexDeclaration);
+#endif
+            }
+
+        }
+
+        public void Remove()
+        {
+            var chList = HullLists.Find(x => x.Submarine == parentEntity.Submarine);
+
+            if (chList != null)
+            {
+                chList.List.Remove(this);
+                if (chList.List.Count == 0)
+                {
+                    HullLists.Remove(chList);
+                }
+            }
+        }
+    }
+
+}

BarotraumaClient/Source/Map/Lights/LightManager.cs

@@ -0,0 +1,392 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Barotrauma.Lights
+{
+    class LightManager
+    {
+        private const float AmbientLightUpdateInterval = 0.2f;
+        private const float AmbientLightFalloff = 0.8f;
+
+        private static Entity viewTarget;
+
+        public static Entity ViewTarget
+        {
+            get { return viewTarget; }
+            set {
+                if (viewTarget == value) return;
+                viewTarget = value; 
+            }
+        }
+
+        public Color AmbientLight;
+
+        RenderTarget2D lightMap, losTexture;
+
+        BasicEffect lightEffect;
+        
+        private static Texture2D alphaClearTexture;
+
+        private List<LightSource> lights;
+
+        public bool LosEnabled = true;
+
+        public bool LightingEnabled = true;
+
+        public bool ObstructVision;
+
+        private Texture2D visionCircle;
+        
+        private Dictionary<Hull, Color> hullAmbientLights;
+        private Dictionary<Hull, Color> smoothedHullAmbientLights;
+
+        private float ambientLightUpdateTimer;
+
+        public LightManager(GraphicsDevice graphics)
+        {
+            lights = new List<LightSource>();
+
+            AmbientLight = new Color(20, 20, 20, 255);
+
+            visionCircle = Sprite.LoadTexture("Content/Lights/visioncircle.png");
+
+            var pp = graphics.PresentationParameters;
+
+            lightMap = new RenderTarget2D(graphics, 
+                        GameMain.GraphicsWidth, GameMain.GraphicsHeight, false,
+                       pp.BackBufferFormat, pp.DepthStencilFormat, pp.MultiSampleCount,
+                       RenderTargetUsage.DiscardContents);
+
+            losTexture = new RenderTarget2D(graphics, GameMain.GraphicsWidth, GameMain.GraphicsHeight);
+
+            if (lightEffect == null)
+            {
+                lightEffect = new BasicEffect(GameMain.Instance.GraphicsDevice);
+                lightEffect.VertexColorEnabled = false;
+
+                lightEffect.TextureEnabled = true;
+                lightEffect.Texture = LightSource.LightTexture;
+            }
+
+            hullAmbientLights = new Dictionary<Hull, Color>();
+            smoothedHullAmbientLights = new Dictionary<Hull, Color>();
+
+            if (alphaClearTexture == null)
+            {
+                alphaClearTexture = TextureLoader.FromFile("Content/Lights/alphaOne.png");
+            }
+        }
+
+        public void AddLight(LightSource light)
+        {
+            lights.Add(light);
+        }
+
+        public void RemoveLight(LightSource light)
+        {
+            lights.Remove(light);
+        }
+
+        public void OnMapLoaded()
+        {
+            foreach (LightSource light in lights)
+            {
+                light.NeedsHullCheck = true;
+                light.NeedsRecalculation = true;
+            }
+        }
+
+        public void Update(float deltaTime)
+        {
+            if (ambientLightUpdateTimer > 0.0f)
+            {
+                ambientLightUpdateTimer -= deltaTime;
+            }
+            else
+            {
+                CalculateAmbientLights();
+
+                ambientLightUpdateTimer = AmbientLightUpdateInterval;
+            }
+
+            foreach (Hull hull in hullAmbientLights.Keys)
+            {
+                if (!smoothedHullAmbientLights.ContainsKey(hull))
+                {
+                    smoothedHullAmbientLights.Add(hull, Color.TransparentBlack);
+                }
+            }
+
+            foreach (Hull hull in smoothedHullAmbientLights.Keys.ToList())
+            {
+                Color targetColor = Color.TransparentBlack;
+
+                hullAmbientLights.TryGetValue(hull, out targetColor);
+
+                smoothedHullAmbientLights[hull] = Color.Lerp(smoothedHullAmbientLights[hull], targetColor, deltaTime);
+            }
+        }
+
+        public void UpdateLightMap(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, Effect blur)
+        {
+            if (!LightingEnabled) return;
+            
+            graphics.SetRenderTarget(lightMap);
+
+            Rectangle viewRect = cam.WorldView;
+            viewRect.Y -= cam.WorldView.Height;
+            
+            //clear to some small ambient light
+            graphics.Clear(AmbientLight);
+            graphics.BlendState = BlendState.Additive;
+            
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, null, null, null, null, cam.Transform);
+                       
+            Matrix transform = cam.ShaderTransform
+                * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
+
+            Vector3 offset = Vector3.Zero;// new Vector3(Submarine.MainSub.DrawPosition.X, Submarine.MainSub.DrawPosition.Y, 0.0f);
+
+            foreach (LightSource light in lights)
+            {
+                if (light.Color.A < 1 || light.Range < 1.0f || !light.CastShadows) continue;
+                if (!MathUtils.CircleIntersectsRectangle(light.WorldPosition, light.Range, viewRect)) continue;
+
+                light.Draw(spriteBatch, lightEffect, transform);
+            }
+
+            lightEffect.World = Matrix.CreateTranslation(offset) * transform;
+                        
+            GameMain.ParticleManager.Draw(spriteBatch, false, Particles.ParticleBlendState.Additive);
+
+            if (Character.Controlled != null)
+            {
+                if (Character.Controlled.ClosestItem != null)
+                {
+                    Character.Controlled.ClosestItem.IsHighlighted = true;
+                    Character.Controlled.ClosestItem.Draw(spriteBatch, false, true);
+                    Character.Controlled.ClosestItem.IsHighlighted = true;
+                }
+                else if (Character.Controlled.ClosestCharacter != null)
+                {
+                    Character.Controlled.ClosestCharacter.Draw(spriteBatch);
+                }
+            }
+
+            foreach (Hull hull in smoothedHullAmbientLights.Keys)
+            {
+                if (smoothedHullAmbientLights[hull].A < 0.01f) continue;
+
+                var drawRect =
+                    hull.Submarine == null ?
+                    hull.Rect :
+                    new Rectangle((int)(hull.Submarine.DrawPosition.X + hull.Rect.X), (int)(hull.Submarine.DrawPosition.Y + hull.Rect.Y), hull.Rect.Width, hull.Rect.Height);
+
+                GUI.DrawRectangle(spriteBatch,
+                    new Vector2(drawRect.X, -drawRect.Y),
+                    new Vector2(hull.Rect.Width, hull.Rect.Height),
+                    smoothedHullAmbientLights[hull] * 0.5f, true);
+            }
+
+            spriteBatch.End();
+
+            //clear alpha, to avoid messing stuff up later
+            //ClearAlphaToOne(graphics, spriteBatch);
+
+            graphics.SetRenderTarget(null);
+            graphics.BlendState = BlendState.AlphaBlend;
+        }
+
+        public void UpdateObstructVision(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, Vector2 lookAtPosition)
+        {
+            if (!LosEnabled && !ObstructVision) return;
+
+            graphics.SetRenderTarget(losTexture);
+
+                spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, cam.Transform);
+
+            if (ObstructVision)
+            {
+                //graphics.Clear(Color.Black);
+
+                Vector2 diff = lookAtPosition - ViewTarget.WorldPosition;
+                diff.Y = -diff.Y;
+                float rotation = MathUtils.VectorToAngle(diff);
+            
+                Vector2 scale = new Vector2(MathHelper.Clamp(diff.Length()/256.0f, 2.0f, 5.0f), 2.0f);
+
+                spriteBatch.Draw(visionCircle, new Vector2(ViewTarget.WorldPosition.X, -ViewTarget.WorldPosition.Y), null, Color.White, rotation, 
+                    new Vector2(LightSource.LightTexture.Width*0.2f, LightSource.LightTexture.Height/2), scale, SpriteEffects.None, 0.0f);
+            }
+            else
+            {
+                graphics.Clear(Color.White);
+            }
+
+            spriteBatch.End();
+
+            //--------------------------------------
+
+            if (LosEnabled && ViewTarget != null)
+            {
+                Vector2 pos = ViewTarget.WorldPosition;
+
+                Rectangle camView = new Rectangle(cam.WorldView.X, cam.WorldView.Y - cam.WorldView.Height, cam.WorldView.Width, cam.WorldView.Height);
+
+                Matrix shadowTransform = cam.ShaderTransform
+                    * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
+
+                var convexHulls = ConvexHull.GetHullsInRange(viewTarget.Position, cam.WorldView.Width*0.75f, viewTarget.Submarine);
+
+                if (convexHulls != null)
+                {
+                    foreach (ConvexHull convexHull in convexHulls)
+                    {
+                        if (!convexHull.Intersects(camView)) continue;
+                        //if (!camView.Intersects(convexHull.BoundingBox)) continue;
+
+                        convexHull.DrawShadows(graphics, cam, pos, shadowTransform);
+                    }
+                }                
+            }
+            graphics.SetRenderTarget(null);            
+        }
+        
+
+        private void CalculateAmbientLights()
+        {
+            hullAmbientLights.Clear();
+
+            foreach (LightSource light in lights)
+            {
+                if (light.Color.A < 1f || light.Range < 1.0f) continue;
+
+                var newAmbientLights = AmbientLightHulls(light);
+                foreach (Hull hull in newAmbientLights.Keys)
+                {
+                    if (hullAmbientLights.ContainsKey(hull))
+                    {
+                        //hull already lit by some other light source -> add the ambient lights up
+                        hullAmbientLights[hull] = new Color(
+                            hullAmbientLights[hull].R + newAmbientLights[hull].R, 
+                            hullAmbientLights[hull].G + newAmbientLights[hull].G, 
+                            hullAmbientLights[hull].B + newAmbientLights[hull].B,
+                            hullAmbientLights[hull].A + newAmbientLights[hull].A);
+                    }
+                    else
+                    {
+                        hullAmbientLights.Add(hull, newAmbientLights[hull]);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Add ambient light to the hull the lightsource is inside + all adjacent hulls connected by a gap
+        /// </summary>
+        private Dictionary<Hull, Color> AmbientLightHulls(LightSource light)
+        {
+            Dictionary<Hull, Color> hullAmbientLight = new Dictionary<Hull, Color>();
+
+            var hull = Hull.FindHull(light.WorldPosition);
+            if (hull == null) return hullAmbientLight;
+
+            return AmbientLightHulls(hull, hullAmbientLight, light.Color * (light.Range/2000.0f));
+        }
+
+        /// <summary>
+        /// A flood fill algorithm that adds ambient light to all hulls the starting hull is connected to
+        /// </summary>
+        private Dictionary<Hull, Color> AmbientLightHulls(Hull hull, Dictionary<Hull, Color> hullAmbientLight, Color currColor)
+        {
+            if (hullAmbientLight.ContainsKey(hull))
+            {
+                if (hullAmbientLight[hull].A > currColor.A)
+                    return hullAmbientLight;
+                else
+                    hullAmbientLight[hull] = currColor;
+            }
+            else
+            {
+                hullAmbientLight.Add(hull, currColor);
+            }
+
+            Color nextHullLight = currColor * AmbientLightFalloff;
+            //light getting too dark to notice -> no need to spread further
+            if (nextHullLight.A < 20) return hullAmbientLight;
+
+            //use hashset to make sure that each hull is only included once
+            HashSet<Hull> hulls = new HashSet<Hull>();
+            foreach (Gap g in hull.ConnectedGaps)
+            {
+                if (!g.IsRoomToRoom || !g.PassAmbientLight || g.Open < 0.5f) continue;
+                
+                hulls.Add((g.linkedTo[0] == hull ? g.linkedTo[1] : g.linkedTo[0]) as Hull);                
+            }
+
+            foreach (Hull h in hulls)
+            {
+                hullAmbientLight = AmbientLightHulls(h, hullAmbientLight, nextHullLight); 
+            }
+
+            return hullAmbientLight;
+        }
+        
+        public void DrawLightMap(SpriteBatch spriteBatch, Effect effect)
+        {
+            if (!LightingEnabled) return;
+
+            spriteBatch.Begin(SpriteSortMode.Deferred, CustomBlendStates.Multiplicative, null, null, null, effect);
+            spriteBatch.Draw(lightMap, Vector2.Zero, Color.White);            
+            spriteBatch.End();
+        }
+
+        public void DrawLOS(SpriteBatch spriteBatch, Effect effect,bool renderingBackground)
+        {
+            if (!LosEnabled || ViewTarget == null) return;
+            
+            spriteBatch.Begin(SpriteSortMode.Deferred, renderingBackground ? CustomBlendStates.LOS : CustomBlendStates.Multiplicative, null, null, null, effect);
+            spriteBatch.Draw(losTexture, Vector2.Zero, Color.White);
+            spriteBatch.End();
+
+            if (!renderingBackground) ObstructVision = false;
+        }
+
+        public void ClearLights()
+        {
+            lights.Clear();
+        }
+    }
+
+
+    class CustomBlendStates
+    {
+        static CustomBlendStates()
+        {
+            Multiplicative = new BlendState();
+            Multiplicative.ColorSourceBlend = Multiplicative.AlphaSourceBlend = Blend.Zero;
+            Multiplicative.ColorDestinationBlend = Multiplicative.AlphaDestinationBlend = Blend.SourceColor;
+            Multiplicative.ColorBlendFunction = Multiplicative.AlphaBlendFunction = BlendFunction.Add;
+
+            WriteToAlpha = new BlendState();
+            WriteToAlpha.ColorWriteChannels = ColorWriteChannels.Alpha;
+
+            MultiplyWithAlpha = new BlendState();
+            MultiplyWithAlpha.ColorDestinationBlend = MultiplyWithAlpha.AlphaDestinationBlend = Blend.One;
+            MultiplyWithAlpha.ColorSourceBlend = MultiplyWithAlpha.AlphaSourceBlend = Blend.DestinationAlpha;
+
+            LOS = new BlendState();
+            LOS.ColorSourceBlend = LOS.AlphaSourceBlend = Blend.Zero;
+            LOS.ColorDestinationBlend = LOS.AlphaDestinationBlend = Blend.InverseSourceColor;
+            LOS.ColorBlendFunction = LOS.AlphaBlendFunction = BlendFunction.Add;
+        }
+        public static BlendState Multiplicative { get; private set; }
+        public static BlendState WriteToAlpha { get; private set; }
+        public static BlendState MultiplyWithAlpha { get; private set; }
+        public static BlendState LOS { get; private set; }
+    }
+
+}

BarotraumaClient/Source/Map/Lights/LightSource.cs

@@ -0,0 +1,612 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma.Lights
+{
+    class LightSource
+    {
+        private static Texture2D lightTexture;
+
+        private List<ConvexHullList> hullsInRange;
+
+        private Color color;
+        private float range;
+        
+        private Sprite overrideLightTexture;
+        private Texture2D texture;
+        
+        public Sprite LightSprite;
+
+        public Submarine ParentSub;
+
+        public bool CastShadows;
+
+        //what was the range of the light when lightvolumes were last calculated
+        private float prevCalculatedRange;
+        private Vector2 prevCalculatedPosition;
+
+        //do we need to recheck which convex hulls are within range 
+        //(e.g. position or range of the lightsource has changed)
+        public bool NeedsHullCheck = true;
+        //do we need to recalculate the vertices of the light volume
+        public bool NeedsRecalculation = true;
+
+        //when were the vertices of the light volume last calculated
+        private float lastRecalculationTime;
+
+        private Dictionary<Submarine, Vector2> diffToSub;
+
+        private DynamicVertexBuffer lightVolumeBuffer;
+        private DynamicIndexBuffer lightVolumeIndexBuffer;
+        private int vertexCount;
+        private int indexCount;
+
+        private Vector2 position;
+        public Vector2 Position
+        {
+            get { return position; }
+            set
+            {
+                if (position == value) return;
+                position = value;
+
+                if (Vector2.Distance(prevCalculatedPosition, position) < 5.0f) return;
+
+                NeedsHullCheck = true;
+                NeedsRecalculation = true;
+                prevCalculatedPosition = position;
+            }
+        }
+
+        private float rotation;
+        public float Rotation
+        {
+            get { return rotation; }
+            set
+            {
+                if (rotation == value) return;
+                rotation = value;
+
+                NeedsHullCheck = true;
+                NeedsRecalculation = true;
+            }
+        }
+
+        public Vector2 WorldPosition
+        {
+            get { return (ParentSub == null) ? position : position + ParentSub.Position; }
+        }
+
+        public static Texture2D LightTexture
+        {
+            get
+            {
+                if (lightTexture == null)
+                {
+                    lightTexture = TextureLoader.FromFile("Content/Lights/light.png");
+                }
+
+                return lightTexture;
+            }
+        }
+
+        public Color Color
+        {
+            get { return color; }
+            set { color = value; }
+        }
+
+        public float Range
+        {
+            get { return range; }
+            set
+            {
+
+                range = MathHelper.Clamp(value, 0.0f, 2048.0f);
+                if (Math.Abs(prevCalculatedRange - range) < 10.0f) return;
+
+                NeedsHullCheck = true;
+                NeedsRecalculation = true;
+                prevCalculatedRange = range;
+            }
+        }
+
+        public LightSource (XElement element)
+            : this(Vector2.Zero, 100.0f, Color.White, null)
+        {
+            range = ToolBox.GetAttributeFloat(element, "range", 100.0f);
+            color = new Color(ToolBox.GetAttributeVector4(element, "color", Vector4.One));
+
+            CastShadows = ToolBox.GetAttributeBool(element, "castshadows", true);
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        LightSprite = new Sprite(subElement);
+                        break;
+                    case "lighttexture":
+                        overrideLightTexture = new Sprite(subElement);
+                        break;
+                }
+            }
+        }
+
+        public LightSource(Vector2 position, float range, Color color, Submarine submarine)
+        {
+            hullsInRange = new List<ConvexHullList>();
+
+            this.ParentSub = submarine;
+
+            this.position = position;
+            this.range = range;
+            this.color = color;
+
+            CastShadows = true;
+            
+            texture = LightTexture;
+
+            diffToSub = new Dictionary<Submarine, Vector2>();
+
+            GameMain.LightManager.AddLight(this);
+        }
+
+        /*public void DrawShadows(GraphicsDevice graphics, Camera cam, Matrix shadowTransform)
+        {
+            if (!CastShadows) return;
+            if (range < 1.0f || color.A < 0.01f) return;
+
+            foreach (Submarine sub in Submarine.Loaded)
+            {
+                var hulls = GetHullsInRange(sub);
+
+                if (hulls == null) continue;
+
+                foreach ( ConvexHull ch in hulls)
+                {
+                    ch.DrawShadows(graphics, cam, this, shadowTransform, false);
+                }                
+            }
+
+            var outsideHulls = GetHullsInRange(null);
+
+            NeedsHullUpdate = false;
+
+            if (outsideHulls == null) return;
+            foreach (ConvexHull ch in outsideHulls)
+            {
+                ch.DrawShadows(graphics, cam, this, shadowTransform, false);
+            }
+        }*/
+        
+        /// <summary>
+        /// Update the contents of ConvexHullList and check if we need to recalculate vertices
+        /// </summary>
+        private void RefreshConvexHullList(ConvexHullList chList, Vector2 lightPos, Submarine sub)
+        {
+            var fullChList = ConvexHull.HullLists.Find(x => x.Submarine == sub);
+            if (fullChList == null) return;
+
+            chList.List = fullChList.List.FindAll(ch => ch.Enabled && MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox));
+
+            NeedsHullCheck = true;
+        }
+
+        /// <summary>
+        /// Recheck which convex hulls are in range (if needed), 
+        /// and check if we need to recalculate vertices due to changes in the convex hulls
+        /// </summary>
+        private void CheckHullsInRange()
+        {
+            List<Submarine> subs = new List<Submarine>(Submarine.Loaded);
+            subs.Add(null);
+
+            foreach (Submarine sub in subs)
+            {
+                //find the list of convexhulls that belong to the sub
+                var chList = hullsInRange.Find(x => x.Submarine == sub);
+
+                //not found -> create one
+                if (chList == null)
+                {
+                    chList = new ConvexHullList(sub);
+                    hullsInRange.Add(chList);
+                    NeedsRecalculation = true;
+                }
+
+                if (chList.List.Any(ch => ch.LastVertexChangeTime > lastRecalculationTime))
+                {
+                    NeedsRecalculation = true;
+                }
+
+                Vector2 lightPos = position;
+                if (ParentSub == null)
+                {
+                    //light and the convexhulls are both outside
+                    if (sub == null)
+                    {
+                        if (NeedsHullCheck)
+                        {
+                            RefreshConvexHullList(chList, lightPos, null);
+                        }
+                    }
+                    //light is outside, convexhulls inside a sub
+                    else
+                    {
+                        lightPos -= sub.Position;
+
+                        Rectangle subBorders = sub.Borders;
+                        subBorders.Location += sub.HiddenSubPosition.ToPoint() - new Point(0, sub.Borders.Height);
+
+                        //only draw if the light overlaps with the sub
+                        if (!MathUtils.CircleIntersectsRectangle(lightPos, range, subBorders))
+                        {
+                            if (chList.List.Count > 0) NeedsRecalculation = true;
+                            chList.List.Clear();
+                            continue;
+                        }
+                        
+                        RefreshConvexHullList(chList, lightPos, sub);
+                    }
+                }
+                else 
+                {
+                    //light is inside, convexhull outside
+                    if (sub == null) continue;
+                
+                    //light and convexhull are both inside the same sub
+                    if (sub == ParentSub)
+                    {
+                        if (NeedsHullCheck)
+                        {                            
+                            RefreshConvexHullList(chList, lightPos, sub);
+                        }
+                    }
+                    //light and convexhull are inside different subs
+                    else
+                    {
+                        if (sub.DockedTo.Contains(ParentSub) && !NeedsHullCheck) continue;
+                        
+                        lightPos -= (sub.Position - ParentSub.Position);
+
+                        Rectangle subBorders = sub.Borders;
+                        subBorders.Location += sub.HiddenSubPosition.ToPoint() - new Point(0, sub.Borders.Height);
+
+                        //don't draw any shadows if the light doesn't overlap with the borders of the sub
+                        if (!MathUtils.CircleIntersectsRectangle(lightPos, range, subBorders))
+                        {
+                            if (chList.List.Count > 0) NeedsRecalculation = true;
+                            chList.List.Clear();
+                            continue;
+                        }
+
+                        //recalculate vertices if the subs have moved > 5 px relative to each other
+                        Vector2 diff = ParentSub.WorldPosition - sub.WorldPosition;
+                        Vector2 prevDiff;
+                        if (!diffToSub.TryGetValue(sub, out prevDiff))
+                        {
+                            diffToSub.Add(sub, diff);
+                            NeedsRecalculation = true;
+                        }
+                        else if (Vector2.DistanceSquared(diff, prevDiff) > 5.0f*5.0f)
+                        {
+                            diffToSub[sub] = diff;
+                            NeedsRecalculation = true;
+                        }
+
+                        RefreshConvexHullList(chList, lightPos, sub);
+                    }
+                }
+            }
+        }
+
+        private List<Vector2> FindRaycastHits()
+        {
+            if (!CastShadows) return null;
+            if (range < 1.0f || color.A < 0.01f) return null;
+
+            Vector2 drawPos = position;
+            if (ParentSub != null) drawPos += ParentSub.DrawPosition;
+
+            var hulls = new List<ConvexHull>();// ConvexHull.GetHullsInRange(position, range, ParentSub);
+            foreach (ConvexHullList chList in hullsInRange)
+            {
+                hulls.AddRange(chList.List);
+            }
+
+            //find convexhull segments that are close enough and facing towards the light source
+            List<Segment> visibleSegments = new List<Segment>();
+            List<SegmentPoint> points = new List<SegmentPoint>();
+            foreach (ConvexHull hull in hulls)
+            {
+                hull.RefreshWorldPositions();
+                
+                var visibleHullSegments = hull.GetVisibleSegments(drawPos);
+                visibleSegments.AddRange(visibleHullSegments);
+
+                foreach (Segment s in visibleHullSegments)
+                {
+                    points.Add(s.Start);
+                    points.Add(s.End);
+                }
+            }
+
+            //add a square-shaped boundary to make sure we've got something to construct the triangles from
+            //even if there aren't enough hull segments around the light source
+
+            //(might be more effective to calculate if we actually need these extra points)
+            var boundaryCorners = new List<SegmentPoint> {
+                new SegmentPoint(new Vector2(drawPos.X + range*2, drawPos.Y + range*2)),
+                new SegmentPoint(new Vector2(drawPos.X + range*2, drawPos.Y - range*2)),
+                new SegmentPoint(new Vector2(drawPos.X - range*2, drawPos.Y - range*2)),
+                new SegmentPoint(new Vector2(drawPos.X - range*2, drawPos.Y + range*2))
+            };
+
+            points.AddRange(boundaryCorners);
+
+            var compareCCW = new CompareSegmentPointCW(drawPos);
+            try
+            {
+                points.Sort(compareCCW);
+            }
+            catch (Exception e)
+            {
+                StringBuilder sb = new StringBuilder("Constructing light volumes failed! Light pos: "+drawPos+", Hull verts:\n");
+                foreach (SegmentPoint sp in points)
+                {
+                    sb.AppendLine(sp.Pos.ToString());
+                }
+                DebugConsole.ThrowError(sb.ToString(), e);
+            }
+            
+            List<Vector2> output = new List<Vector2>();
+
+            //remove points that are very close to each other
+            for (int i = 0; i < points.Count - 1; i++)
+            {
+                if (Math.Abs(points[i].WorldPos.X - points[i + 1].WorldPos.X) < 3 &&
+                    Math.Abs(points[i].WorldPos.Y - points[i + 1].WorldPos.Y) < 3)
+                {
+                    points.RemoveAt(i + 1);
+                }
+            }
+
+            foreach (SegmentPoint p in points)
+            {
+                Vector2 dir = Vector2.Normalize(p.WorldPos - drawPos);
+                Vector2 dirNormal = new Vector2(-dir.Y, dir.X)*3;
+                
+                //do two slightly offset raycasts to hit the segment itself and whatever's behind it
+                Vector2 intersection1 = RayCast(drawPos, drawPos + dir * range * 2 - dirNormal, visibleSegments);
+                Vector2 intersection2 = RayCast(drawPos, drawPos + dir * range * 2 + dirNormal, visibleSegments);
+
+                //hit almost the same position -> only add one vertex to output
+                if ((Math.Abs(intersection1.X - intersection2.X) < 5 &&
+                    Math.Abs(intersection1.Y - intersection2.Y) < 5))
+                {
+                    output.Add(intersection1);
+                }
+                else
+                {
+                    output.Add(intersection1);
+                    output.Add(intersection2);
+                }
+            }
+            
+            return output;
+        }
+
+        private Vector2 RayCast(Vector2 rayStart, Vector2 rayEnd, List<Segment> segments)
+        {
+            float closestDist = 0.0f;
+            Vector2? closestIntersection = null;
+            
+            foreach (Segment s in segments)
+            {
+                Vector2? intersection = MathUtils.GetAxisAlignedLineIntersection(rayStart, rayEnd, s.Start.WorldPos, s.End.WorldPos, s.IsHorizontal);
+
+                if (intersection != null)
+                {
+                    float dist = Vector2.Distance((Vector2)intersection, rayStart);
+                    if (closestIntersection == null || dist < closestDist)
+                    {
+                        closestDist = dist;
+                        closestIntersection = intersection;
+                    }
+                }
+            }            
+
+            return closestIntersection == null ? rayEnd : (Vector2)closestIntersection;
+        }
+
+        private void CalculateLightVertices(List<Vector2> rayCastHits)
+        {
+            List<VertexPositionTexture> vertices = new List<VertexPositionTexture>();
+
+            Vector2 drawPos = position;
+            if (ParentSub != null) drawPos += ParentSub.DrawPosition;
+
+            float cosAngle = (float)Math.Cos(Rotation);
+            float sinAngle = -(float)Math.Sin(Rotation);
+            
+            Vector2 uvOffset = Vector2.Zero;
+            Vector2 overrideTextureDims = Vector2.One;
+            if (overrideLightTexture != null)
+            {
+                overrideTextureDims = new Vector2(overrideLightTexture.SourceRect.Width, overrideLightTexture.SourceRect.Height);
+                uvOffset = (overrideLightTexture.Origin / overrideTextureDims) - new Vector2(0.5f, 0.5f);
+            }
+
+            // Add a vertex for the center of the mesh
+            vertices.Add(new VertexPositionTexture(new Vector3(position.X, position.Y, 0),
+                new Vector2(0.5f, 0.5f) + uvOffset));
+
+            // Add all the other encounter points as vertices
+            // storing their world position as UV coordinates
+            foreach (Vector2 vertex in rayCastHits)
+            {
+                Vector2 rawDiff = vertex - drawPos;
+                Vector2 diff = rawDiff;
+                diff /= range*2.0f;
+                if (overrideLightTexture != null)
+                {
+                    Vector2 originDiff = diff;
+
+                    diff.X = originDiff.X * cosAngle - originDiff.Y * sinAngle;
+                    diff.Y = originDiff.X * sinAngle + originDiff.Y * cosAngle;
+                    diff *= (overrideTextureDims / overrideLightTexture.size) * 2.0f;
+
+                    diff += uvOffset;
+                }
+
+                vertices.Add(new VertexPositionTexture(new Vector3(position.X + rawDiff.X, position.Y + rawDiff.Y, 0),
+                   new Vector2(0.5f, 0.5f) + diff));
+            }
+
+            // Compute the indices to form triangles
+            List<short> indices = new List<short>();
+            for (int i = 0; i < rayCastHits.Count - 1; i++)
+            {
+                indices.Add(0);
+                indices.Add((short)((i + 2) % vertices.Count));
+                indices.Add((short)((i + 1) % vertices.Count));
+            }
+
+            indices.Add(0);
+            indices.Add((short)(1));
+            indices.Add((short)(vertices.Count - 1));
+
+            vertexCount = vertices.Count;
+            indexCount = indices.Count;
+
+            //TODO: a better way to determine the size of the vertex buffer and handle changes in size?
+            //now we just create a buffer for 64 verts and make it larger if needed
+            if (lightVolumeBuffer == null)
+            {
+                lightVolumeBuffer = new DynamicVertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionTexture.VertexDeclaration, Math.Max(64, (int)(vertexCount*1.5)), BufferUsage.None);
+                lightVolumeIndexBuffer = new DynamicIndexBuffer(GameMain.Instance.GraphicsDevice, typeof(short), Math.Max(64*3, (int)(indexCount * 1.5)), BufferUsage.None);
+            }
+            else if (vertexCount > lightVolumeBuffer.VertexCount)
+            {
+                lightVolumeBuffer.Dispose();
+                lightVolumeIndexBuffer.Dispose();
+
+                lightVolumeBuffer = new DynamicVertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionTexture.VertexDeclaration, (int)(vertexCount*1.5), BufferUsage.None);
+                lightVolumeIndexBuffer = new DynamicIndexBuffer(GameMain.Instance.GraphicsDevice, typeof(short), (int)(indexCount * 1.5), BufferUsage.None);
+            }
+                        
+            lightVolumeBuffer.SetData<VertexPositionTexture>(vertices.ToArray());
+            lightVolumeIndexBuffer.SetData<short>(indices.ToArray());
+        }     
+
+        public void Draw(SpriteBatch spriteBatch, BasicEffect lightEffect, Matrix transform)
+        {
+            CheckHullsInRange();
+
+            Vector3 offset = ParentSub == null ? Vector3.Zero :
+            new Vector3(ParentSub.DrawPosition.X, ParentSub.DrawPosition.Y, 0.0f);
+
+            lightEffect.World = Matrix.CreateTranslation(offset) * transform;
+
+            Vector2 drawPos = position;
+            if (ParentSub != null) drawPos += ParentSub.DrawPosition;
+
+            drawPos.Y = -drawPos.Y;
+            
+            /*if (range > 1.0f)
+            {
+                if (overrideLightTexture == null)
+                {
+                    Vector2 center = new Vector2(LightTexture.Width / 2, LightTexture.Height / 2);
+                    float scale = range / (lightTexture.Width / 2.0f);
+
+                    spriteBatch.Draw(lightTexture, drawPos, null, color * (color.A / 255.0f), 0, center, scale, SpriteEffects.None, 1);
+                }
+                else
+                {
+                    overrideLightTexture.Draw(spriteBatch,
+                        drawPos, color * (color.A / 255.0f),
+                        overrideLightTexture.Origin, -Rotation,
+                        new Vector2(overrideLightTexture.size.X / overrideLightTexture.SourceRect.Width, overrideLightTexture.size.Y / overrideLightTexture.SourceRect.Height));
+                }
+            }
+
+            if (LightSprite != null)
+            {
+                LightSprite.Draw(spriteBatch, drawPos, Color, LightSprite.Origin, -Rotation, 1);
+            }*/
+
+            if (NeedsRecalculation)
+            {
+                var verts = FindRaycastHits();
+                CalculateLightVertices(verts);
+
+                lastRecalculationTime = (float)Timing.TotalTime;
+                NeedsRecalculation = false;
+            }
+            
+            if (vertexCount == 0) return;
+
+            lightEffect.DiffuseColor = (new Vector3(color.R, color.G, color.B) * (color.A / 255.0f)) / 255.0f;// color.ToVector3();
+            if (overrideLightTexture != null)
+            {
+                lightEffect.Texture = overrideLightTexture.Texture;
+            }
+            else
+            {
+                lightEffect.Texture = LightTexture;
+            }
+            lightEffect.CurrentTechnique.Passes[0].Apply();
+
+            GameMain.Instance.GraphicsDevice.SetVertexBuffer(lightVolumeBuffer);
+            GameMain.Instance.GraphicsDevice.Indices = lightVolumeIndexBuffer;
+
+            GameMain.Instance.GraphicsDevice.DrawIndexedPrimitives
+            (
+                PrimitiveType.TriangleList, 0, 0, indexCount / 3
+            );
+        }
+
+        /*public void FlipX()
+        {
+            if (LightSprite != null)
+            {
+                Vector2 lightOrigin = LightSprite.Origin;
+                lightOrigin.X = LightSprite.SourceRect.Width - lightOrigin.X;
+                LightSprite.Origin = lightOrigin;
+            }
+
+            if (overrideLightTexture != null)
+            {
+                Vector2 lightOrigin = overrideLightTexture.Origin;
+                lightOrigin.X = overrideLightTexture.SourceRect.Width - lightOrigin.X;
+                overrideLightTexture.Origin = lightOrigin;
+            }
+        }*/
+
+        public void Remove()
+        {
+            if (LightSprite != null) LightSprite.Remove();
+
+            if (lightVolumeBuffer != null)
+            {
+                lightVolumeBuffer.Dispose();
+                lightVolumeBuffer = null;
+            }
+
+            if (lightVolumeIndexBuffer != null)
+            {
+                lightVolumeIndexBuffer.Dispose();
+                lightVolumeIndexBuffer = null;
+            }
+
+            GameMain.LightManager.RemoveLight(this);
+        }
+    }
+}

BarotraumaClient/Source/Map/LinkedSubmarine.cs

@@ -0,0 +1,234 @@
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class LinkedSubmarine : MapEntity
+    {
+        public override void Draw(SpriteBatch spriteBatch, bool editing, bool back = true)
+        {
+            if (!editing || wallVertices == null) return;
+
+            Color color = (isHighlighted) ? Color.Orange : Color.Green;
+            if (IsSelected) color = Color.Red;
+
+            Vector2 pos = Position;
+
+            for (int i = 0; i < wallVertices.Count; i++)
+            {
+                Vector2 startPos = wallVertices[i] + pos;
+                startPos.Y = -startPos.Y;
+
+                Vector2 endPos = wallVertices[(i + 1) % wallVertices.Count] + pos;
+                endPos.Y = -endPos.Y;
+
+                GUI.DrawLine(spriteBatch,
+                    startPos,
+                    endPos,
+                    color, 0.0f, 5);
+            }
+
+            pos.Y = -pos.Y;
+            GUI.DrawLine(spriteBatch, pos + Vector2.UnitY * 50.0f, pos - Vector2.UnitY * 50.0f, color, 0.0f, 5);
+            GUI.DrawLine(spriteBatch, pos + Vector2.UnitX * 50.0f, pos - Vector2.UnitX * 50.0f, color, 0.0f, 5);
+
+            Rectangle drawRect = rect;
+            drawRect.Y = -rect.Y;
+            GUI.DrawRectangle(spriteBatch, drawRect, Color.Red, true);
+
+            foreach (MapEntity e in linkedTo)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2(WorldPosition.X, -WorldPosition.Y),
+                     new Vector2(e.WorldPosition.X, -e.WorldPosition.Y),
+                    Color.Red * 0.3f);
+            }
+        }
+
+        public override void UpdateEditing(Camera cam)
+        {
+            if (editingHUD == null || editingHUD.UserData as LinkedSubmarine != this)
+            {
+                editingHUD = CreateEditingHUD();
+            }
+
+            editingHUD.Update((float)Timing.Step);
+
+            if (!PlayerInput.LeftButtonClicked() || !PlayerInput.KeyDown(Keys.Space)) return;
+
+            Vector2 position = cam.ScreenToWorld(PlayerInput.MousePosition);
+
+            foreach (MapEntity entity in mapEntityList)
+            {
+                if (entity == this || !entity.IsHighlighted || !(entity is Item) || !entity.IsMouseOn(position)) continue;
+                if (((Item)entity).GetComponent<DockingPort>() == null) continue;
+                if (linkedTo.Contains(entity))
+                {
+                    linkedTo.Remove(entity);
+                }
+                else
+                {
+                    linkedTo.Add(entity);
+                }
+            }
+        }
+
+        public override void DrawEditing(SpriteBatch spriteBatch, Camera cam)
+        {
+            if (editingHUD == null) return;
+
+            editingHUD.Draw(spriteBatch);
+        }
+
+
+        private GUIComponent CreateEditingHUD(bool inGame = false)
+        {
+            int width = 450;
+            int x = GameMain.GraphicsWidth / 2 - width / 2, y = 10;
+
+            editingHUD = new GUIFrame(new Rectangle(x, y, width, 100), "");
+            editingHUD.Padding = new Vector4(10, 10, 0, 0);
+            editingHUD.UserData = this;
+
+            new GUITextBlock(new Rectangle(0, 0, 100, 20), "Linked submarine", "",
+                Alignment.TopLeft, Alignment.TopLeft, editingHUD, false, GUI.LargeFont);
+
+            var pathBox = new GUITextBox(new Rectangle(10, 30, 300, 20), "", editingHUD);
+            pathBox.Font = GUI.SmallFont;
+            pathBox.Text = filePath;
+
+            var reloadButton = new GUIButton(new Rectangle(320, 30, 80, 20), "Refresh", "", editingHUD);
+            reloadButton.OnClicked = Reload;
+            reloadButton.UserData = pathBox;
+
+            reloadButton.ToolTip = "Reload the linked submarine from the specified file";
+
+            y += 20;
+
+            if (!inGame)
+            {
+                new GUITextBlock(new Rectangle(0, 0, 0, 20), "Hold space to link to a docking port",
+                    "", Alignment.TopRight, Alignment.TopRight, editingHUD, false, GUI.SmallFont);
+                y += 25;
+
+            }
+            return editingHUD;
+        }
+
+        private bool Reload(GUIButton button, object obj)
+        {
+            var pathBox = obj as GUITextBox;
+
+            if (!File.Exists(pathBox.Text))
+            {
+                new GUIMessageBox("Error", "Submarine file \"" + pathBox.Text + "\" not found!");
+                pathBox.Flash(Color.Red);
+                pathBox.Text = filePath;
+                return false;
+            }
+
+            XDocument doc = Submarine.OpenFile(pathBox.Text);
+            if (doc == null || doc.Root == null) return false;
+
+            pathBox.Flash(Color.Green);
+
+            GenerateWallVertices(doc.Root);
+            saveElement = doc.Root;
+            saveElement.Name = "LinkedSubmarine";
+
+            filePath = pathBox.Text;
+
+            return true;
+        }
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement saveElement = null;
+
+            if (sub == null)
+            {
+                if (this.saveElement == null)
+                {
+                    var doc = Submarine.OpenFile(filePath);
+                    saveElement = doc.Root;
+
+                    saveElement.Name = "LinkedSubmarine";
+
+                    saveElement.Add(new XAttribute("filepath", filePath));
+                }
+                else
+                {
+                    saveElement = this.saveElement;
+                }
+
+                if (saveElement.Attribute("pos") != null) saveElement.Attribute("pos").Remove();
+                saveElement.Add(new XAttribute("pos", ToolBox.Vector2ToString(Position - Submarine.HiddenSubPosition)));
+
+
+
+                var linkedPort = linkedTo.FirstOrDefault(lt => (lt is Item) && ((Item)lt).GetComponent<DockingPort>() != null);
+                if (linkedPort != null)
+                {
+                    if (saveElement.Attribute("linkedto") != null) saveElement.Attribute("linkedto").Remove();
+
+                    saveElement.Add(new XAttribute("linkedto", linkedPort.ID));
+                }
+            }
+            else
+            {
+
+                saveElement = new XElement("LinkedSubmarine");
+
+
+                sub.SaveToXElement(saveElement);
+            }
+
+            if (sub != null)
+            {
+                bool leaveBehind = false;
+                if (!sub.DockedTo.Contains(Submarine.MainSub))
+                {
+                    System.Diagnostics.Debug.Assert(Submarine.MainSub.AtEndPosition || Submarine.MainSub.AtStartPosition);
+                    if (Submarine.MainSub.AtEndPosition)
+                    {
+                        leaveBehind = sub.AtEndPosition != Submarine.MainSub.AtEndPosition;
+                    }
+                    else
+                    {
+                        leaveBehind = sub.AtStartPosition != Submarine.MainSub.AtStartPosition;
+                    }
+                }
+
+
+                if (leaveBehind)
+                {
+                    saveElement.SetAttributeValue("location", Level.Loaded.Seed);
+                    saveElement.SetAttributeValue("worldpos", ToolBox.Vector2ToString(sub.SubBody.Position));
+
+                }
+                else
+                {
+                    if (saveElement.Attribute("location") != null) saveElement.Attribute("location").Remove();
+                    if (saveElement.Attribute("worldpos") != null) saveElement.Attribute("worldpos").Remove();
+                }
+
+                saveElement.SetAttributeValue("pos", ToolBox.Vector2ToString(Position - Submarine.HiddenSubPosition));
+            }
+
+
+
+            parentElement.Add(saveElement);
+
+            return saveElement;
+        }
+    }
+}

BarotraumaClient/Source/Map/MapEntity.cs

@@ -12,7 +12,7 @@ using Barotrauma.Items.Components;
 
 namespace Barotrauma
 {
-    abstract partial class MapEntity
+    abstract partial class MapEntity : Entity
     {
         protected static Vector2 selectionPos = Vector2.Zero;
         protected static Vector2 selectionSize = Vector2.Zero;

BarotraumaClient/Source/Map/Structure.cs

@@ -14,8 +14,62 @@ using Barotrauma.Lights;
 
 namespace Barotrauma
 {
+    partial class WallSection
+    {
+        public ConvexHull hull;
+    }
+
     partial class Structure : MapEntity, IDamageable, IServerSerializable
     {
+        List<ConvexHull> convexHulls;
+
+        private void GenerateConvexHull()
+        {
+            // If not null and not empty , remove the hulls from the system
+            if (convexHulls != null && convexHulls.Any())
+                convexHulls.ForEach(x => x.Remove());
+
+            // list all of hulls for this structure
+            convexHulls = new List<ConvexHull>();
+
+            var mergedSections = new List<WallSection>();
+            foreach (var section in sections)
+            {
+                if (mergedSections.Count > 5)
+                {
+                    mergedSections.Add(section);
+                    GenerateMergedHull(mergedSections);
+                    continue;
+                }
+
+                // if there is a gap and we have sections to merge, do it.
+                if (section.gap != null)
+                {
+                    GenerateMergedHull(mergedSections);
+                }
+                else
+                {
+                    mergedSections.Add(section);
+                }
+            }
+
+            // take care of any leftover pieces
+            if (mergedSections.Count > 0)
+            {
+                GenerateMergedHull(mergedSections);
+            }
+        }
+
+        private void GenerateMergedHull(List<WallSection> mergedSections)
+        {
+            if (!mergedSections.Any()) return;
+            Rectangle mergedRect = GenerateMergedRect(mergedSections);
+
+            var h = new ConvexHull(CalculateExtremes(mergedRect), Color.Black, this);
+            mergedSections.ForEach(x => x.hull = h);
+            convexHulls.Add(h);
+            mergedSections.Clear();
+        }
 
         public override void Draw(SpriteBatch spriteBatch, bool editing, bool back = true)
         {

BarotraumaClient/Source/Networking/BanList.cs

@@ -0,0 +1,86 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma.Networking
+{
+    partial class BanList
+    {
+        private GUIComponent banFrame;
+
+        public GUIComponent BanFrame
+        {
+            get { return banFrame; }
+        }
+
+        public GUIComponent CreateBanFrame(GUIComponent parent)
+        {
+            banFrame = new GUIListBox(new Rectangle(0, 0, 0, 0), "", parent);
+
+            foreach (BannedPlayer bannedPlayer in bannedPlayers)
+            {
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(0, 0, 0, 25),
+                    bannedPlayer.IP + " (" + bannedPlayer.Name + ")",
+                    "",
+                    Alignment.Left, Alignment.Left, banFrame);
+                textBlock.Padding = new Vector4(10.0f, 10.0f, 0.0f, 0.0f);
+                textBlock.UserData = banFrame;
+
+                var removeButton = new GUIButton(new Rectangle(0, 0, 100, 20), "Remove", Alignment.Right | Alignment.CenterY, "", textBlock);
+                removeButton.UserData = bannedPlayer;
+                removeButton.OnClicked = RemoveBan;
+                if (bannedPlayer.IP.IndexOf(".x") <= -1)
+                {
+                    var rangeBanButton = new GUIButton(new Rectangle(-100, 0, 100, 20), "Ban range", Alignment.Right | Alignment.CenterY, "", textBlock);
+                    rangeBanButton.UserData = bannedPlayer;
+                    rangeBanButton.OnClicked = RangeBan;
+                }
+            }
+
+            return banFrame;
+        }
+
+        private bool RemoveBan(GUIButton button, object obj)
+        {
+            BannedPlayer banned = obj as BannedPlayer;
+            if (banned == null) return false;
+
+            RemoveBan(banned);
+
+            if (banFrame != null)
+            {
+                banFrame.Parent.RemoveChild(banFrame);
+                CreateBanFrame(banFrame.Parent);
+            }
+
+            return true;
+        }
+
+        private bool RangeBan(GUIButton button, object obj)
+        {
+            BannedPlayer banned = obj as BannedPlayer;
+            if (banned == null) return false;
+
+            RangeBan(banned);
+
+            if (banFrame != null)
+            {
+                banFrame.Parent.RemoveChild(banFrame);
+                CreateBanFrame(banFrame.Parent);
+            }
+
+            return true;
+        }
+
+        private bool CloseFrame(GUIButton button, object obj)
+        {
+            banFrame = null;
+
+            return true;
+        }
+    }
+}

BarotraumaClient/Source/Networking/GameServer.cs

@@ -12,6 +12,8 @@ namespace Barotrauma.Networking
 {
     partial class GameServer : NetworkMember
     {
+        private NetStats netStats;
+
         private GUIButton showLogButton;
 
         private GUIScrollBar clientListScrollBar;
@@ -54,6 +56,13 @@ namespace Barotrauma.Networking
             //----------------------------------------
         }
 
+        public override void AddToGUIUpdateList()
+        {
+            if (started) base.AddToGUIUpdateList();
+
+            if (settingsFrame != null) settingsFrame.AddToGUIUpdateList();
+            if (log.LogFrame != null) log.LogFrame.AddToGUIUpdateList();
+        }
 
         public override void Draw(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch)
         {

BarotraumaClient/Source/Networking/GameServerSettings.cs

@@ -0,0 +1,534 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace Barotrauma.Networking
+{
+    partial class GameServer : NetworkMember, IPropertyObject
+    {
+        private GUIFrame settingsFrame;
+        private GUIFrame[] settingsTabs;
+        private int settingsTabIndex;
+
+
+        private void CreateSettingsFrame()
+        {
+            settingsFrame = new GUIFrame(new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight), Color.Black * 0.5f, null);
+
+            GUIFrame innerFrame = new GUIFrame(new Rectangle(0, 0, 400, 430), null, Alignment.Center, "", settingsFrame);
+            innerFrame.Padding = new Vector4(20.0f, 20.0f, 20.0f, 20.0f);
+
+            new GUITextBlock(new Rectangle(0, -5, 0, 20), "Settings", "", innerFrame, GUI.LargeFont);
+
+            string[] tabNames = { "Rounds", "Server", "Banlist", "Whitelist" };
+            settingsTabs = new GUIFrame[tabNames.Length];
+            for (int i = 0; i < tabNames.Length; i++)
+            {
+                settingsTabs[i] = new GUIFrame(new Rectangle(0, 15, 0, innerFrame.Rect.Height - 120), null, Alignment.Center, "InnerFrame", innerFrame);
+                settingsTabs[i].Padding = new Vector4(40.0f, 20.0f, 40.0f, 40.0f);
+
+                var tabButton = new GUIButton(new Rectangle(85 * i, 35, 80, 20), tabNames[i], "", innerFrame);
+                tabButton.UserData = i;
+                tabButton.OnClicked = SelectSettingsTab;
+            }
+
+            settingsTabs[2].Padding = Vector4.Zero;
+
+            SelectSettingsTab(null, 0);
+
+            var closeButton = new GUIButton(new Rectangle(10, 0, 100, 20), "Close", Alignment.BottomRight, "", innerFrame);
+            closeButton.OnClicked = ToggleSettingsFrame;
+
+            //--------------------------------------------------------------------------------
+            //                              game settings 
+            //--------------------------------------------------------------------------------
+
+            int y = 0;
+
+            settingsTabs[0].Padding = new Vector4(40.0f, 5.0f, 40.0f, 40.0f);
+
+            new GUITextBlock(new Rectangle(0, y, 100, 20), "Submarine selection:", "", settingsTabs[0]);
+            var selectionFrame = new GUIFrame(new Rectangle(0, y + 20, 300, 20), null, settingsTabs[0]);
+            for (int i = 0; i < 3; i++)
+            {
+                var selectionTick = new GUITickBox(new Rectangle(i * 100, 0, 20, 20), ((SelectionMode)i).ToString(), Alignment.Left, selectionFrame);
+                selectionTick.Selected = i == (int)subSelectionMode;
+                selectionTick.OnSelected = SwitchSubSelection;
+                selectionTick.UserData = (SelectionMode)i;
+            }
+
+            y += 45;
+
+            new GUITextBlock(new Rectangle(0, y, 100, 20), "Mode selection:", "", settingsTabs[0]);
+            selectionFrame = new GUIFrame(new Rectangle(0, y + 20, 300, 20), null, settingsTabs[0]);
+            for (int i = 0; i < 3; i++)
+            {
+                var selectionTick = new GUITickBox(new Rectangle(i * 100, 0, 20, 20), ((SelectionMode)i).ToString(), Alignment.Left, selectionFrame);
+                selectionTick.Selected = i == (int)modeSelectionMode;
+                selectionTick.OnSelected = SwitchModeSelection;
+                selectionTick.UserData = (SelectionMode)i;
+            }
+
+            y += 60;
+
+            var endBox = new GUITickBox(new Rectangle(0, y, 20, 20), "End round when destination reached", Alignment.Left, settingsTabs[0]);
+            endBox.Selected = EndRoundAtLevelEnd;
+            endBox.OnSelected = (GUITickBox) => { EndRoundAtLevelEnd = GUITickBox.Selected; return true; };
+
+            y += 25;
+
+            var endVoteBox = new GUITickBox(new Rectangle(0, y, 20, 20), "End round by voting", Alignment.Left, settingsTabs[0]);
+            endVoteBox.Selected = Voting.AllowEndVoting;
+            endVoteBox.OnSelected = (GUITickBox) =>
+            {
+                Voting.AllowEndVoting = !Voting.AllowEndVoting;
+                GameMain.Server.UpdateVoteStatus();
+                return true;
+            };
+
+
+            var votesRequiredText = new GUITextBlock(new Rectangle(20, y + 15, 20, 20), "Votes required: 50 %", "", settingsTabs[0], GUI.SmallFont);
+
+            var votesRequiredSlider = new GUIScrollBar(new Rectangle(150, y + 22, 100, 15), "", 0.1f, settingsTabs[0]);
+            votesRequiredSlider.UserData = votesRequiredText;
+            votesRequiredSlider.Step = 0.2f;
+            votesRequiredSlider.BarScroll = (EndVoteRequiredRatio - 0.5f) * 2.0f;
+            votesRequiredSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                GUITextBlock voteText = scrollBar.UserData as GUITextBlock;
+
+                EndVoteRequiredRatio = barScroll / 2.0f + 0.5f;
+                voteText.Text = "Votes required: " + (int)MathUtils.Round(EndVoteRequiredRatio * 100.0f, 10.0f) + " %";
+                return true;
+            };
+            votesRequiredSlider.OnMoved(votesRequiredSlider, votesRequiredSlider.BarScroll);
+
+            y += 35;
+
+            var respawnBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Allow respawning", Alignment.Left, settingsTabs[0]);
+            respawnBox.Selected = AllowRespawn;
+            respawnBox.OnSelected = (GUITickBox) =>
+            {
+                AllowRespawn = !AllowRespawn;
+                return true;
+            };
+
+
+            var respawnIntervalText = new GUITextBlock(new Rectangle(20, y + 13, 20, 20), "Respawn interval", "", settingsTabs[0], GUI.SmallFont);
+
+            var respawnIntervalSlider = new GUIScrollBar(new Rectangle(150, y + 20, 100, 15), "", 0.1f, settingsTabs[0]);
+            respawnIntervalSlider.UserData = respawnIntervalText;
+            respawnIntervalSlider.Step = 0.05f;
+            respawnIntervalSlider.BarScroll = RespawnInterval / 600.0f;
+            respawnIntervalSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                GUITextBlock text = scrollBar.UserData as GUITextBlock;
+
+                RespawnInterval = Math.Max(barScroll * 600.0f, 10.0f);
+                text.Text = "Interval: " + ToolBox.SecondsToReadableTime(RespawnInterval);
+                return true;
+            };
+            respawnIntervalSlider.OnMoved(respawnIntervalSlider, respawnIntervalSlider.BarScroll);
+
+            y += 35;
+
+            var minRespawnText = new GUITextBlock(new Rectangle(0, y, 200, 20), "Minimum players to respawn", "", settingsTabs[0]);
+            minRespawnText.ToolTip = "What percentage of players has to be dead/spectating until a respawn shuttle is dispatched";
+
+            var minRespawnSlider = new GUIScrollBar(new Rectangle(150, y + 20, 100, 15), "", 0.1f, settingsTabs[0]);
+            minRespawnSlider.ToolTip = minRespawnText.ToolTip;
+            minRespawnSlider.UserData = minRespawnText;
+            minRespawnSlider.Step = 0.1f;
+            minRespawnSlider.BarScroll = MinRespawnRatio;
+            minRespawnSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                GUITextBlock txt = scrollBar.UserData as GUITextBlock;
+
+                MinRespawnRatio = barScroll;
+                txt.Text = "Minimum players to respawn: " + (int)MathUtils.Round(MinRespawnRatio * 100.0f, 10.0f) + " %";
+                return true;
+            };
+            minRespawnSlider.OnMoved(minRespawnSlider, MinRespawnRatio);
+
+            y += 30;
+
+            var respawnDurationText = new GUITextBlock(new Rectangle(0, y, 200, 20), "Duration of respawn transport", "", settingsTabs[0]);
+            respawnDurationText.ToolTip = "The amount of time respawned players have to navigate the respawn shuttle to the main submarine. " +
+                "After the duration expires, the shuttle will automatically head back out of the level.";
+
+            var respawnDurationSlider = new GUIScrollBar(new Rectangle(150, y + 20, 100, 15), "", 0.1f, settingsTabs[0]);
+            respawnDurationSlider.ToolTip = minRespawnText.ToolTip;
+            respawnDurationSlider.UserData = respawnDurationText;
+            respawnDurationSlider.Step = 0.1f;
+            respawnDurationSlider.BarScroll = MaxTransportTime <= 0.0f ? 1.0f : (MaxTransportTime - 60.0f) / 600.0f;
+            respawnDurationSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                GUITextBlock txt = scrollBar.UserData as GUITextBlock;
+
+                if (barScroll == 1.0f)
+                {
+                    MaxTransportTime = 0;
+                    txt.Text = "Duration of respawn transport: unlimited";
+                }
+                else
+                {
+                    MaxTransportTime = barScroll * 600.0f + 60.0f;
+                    txt.Text = "Duration of respawn transport: " + ToolBox.SecondsToReadableTime(MaxTransportTime);
+                }
+
+                return true;
+            };
+            respawnDurationSlider.OnMoved(respawnDurationSlider, respawnDurationSlider.BarScroll);
+
+            y += 35;
+
+            var monsterButton = new GUIButton(new Rectangle(0, y, 130, 20), "Monster Spawns", "", settingsTabs[0]);
+            monsterButton.Enabled = !GameStarted;
+            var monsterFrame = new GUIListBox(new Rectangle(-290, 60, 280, 250), "", settingsTabs[0]);
+            monsterFrame.Visible = false;
+            monsterButton.UserData = monsterFrame;
+            monsterButton.OnClicked = (button, obj) =>
+            {
+                if (gameStarted)
+                {
+                    ((GUIComponent)obj).Visible = false;
+                    button.Enabled = false;
+                    return true;
+                }
+                ((GUIComponent)obj).Visible = !((GUIComponent)obj).Visible;
+                return true;
+            };
+            List<string> monsterNames = monsterEnabled.Keys.ToList();
+            foreach (string s in monsterNames)
+            {
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(0, 0, 260, 25),
+                    s,
+                    "",
+                    Alignment.Left, Alignment.Left, monsterFrame);
+                textBlock.Padding = new Vector4(35.0f, 3.0f, 0.0f, 0.0f);
+                textBlock.UserData = monsterFrame;
+                textBlock.CanBeFocused = false;
+
+                var monsterEnabledBox = new GUITickBox(new Rectangle(-25, 0, 20, 20), "", Alignment.Left, textBlock);
+                monsterEnabledBox.Selected = monsterEnabled[s];
+                monsterEnabledBox.OnSelected = (GUITickBox) =>
+                {
+                    if (gameStarted)
+                    {
+                        monsterFrame.Visible = false;
+                        monsterButton.Enabled = false;
+                        return true;
+                    }
+                    monsterEnabled[s] = !monsterEnabled[s];
+                    return true;
+                };
+            }
+
+            var cargoButton = new GUIButton(new Rectangle(160, y, 130, 20), "Additional Cargo", "", settingsTabs[0]);
+            cargoButton.Enabled = !GameStarted;
+
+            var cargoFrame = new GUIListBox(new Rectangle(300, 60, 280, 250), "", settingsTabs[0]);
+            cargoFrame.Visible = false;
+            cargoButton.UserData = cargoFrame;
+            cargoButton.OnClicked = (button, obj) =>
+            {
+                if (gameStarted)
+                {
+                    ((GUIComponent)obj).Visible = false;
+                    button.Enabled = false;
+                    return true;
+                }
+                ((GUIComponent)obj).Visible = !((GUIComponent)obj).Visible;
+                return true;
+            };
+
+
+            foreach (MapEntityPrefab pf in MapEntityPrefab.list)
+            {
+                if (!(pf is ItemPrefab) || (pf.Price <= 0.0f && !pf.tags.Contains("smallitem"))) continue;
+
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(0, 0, 260, 25),
+                    pf.Name, "",
+                    Alignment.Left, Alignment.CenterLeft, cargoFrame, false, GUI.SmallFont);
+                textBlock.Padding = new Vector4(40.0f, 3.0f, 0.0f, 0.0f);
+                textBlock.UserData = cargoFrame;
+                textBlock.CanBeFocused = false;
+
+                if (pf.sprite != null)
+                {
+                    float scale = Math.Min(Math.Min(30.0f / pf.sprite.SourceRect.Width, 30.0f / pf.sprite.SourceRect.Height), 1.0f);
+                    GUIImage img = new GUIImage(new Rectangle(-20 - (int)(pf.sprite.SourceRect.Width * scale * 0.5f), 12 - (int)(pf.sprite.SourceRect.Height * scale * 0.5f), 40, 40), pf.sprite, Alignment.Left, textBlock);
+                    img.Color = pf.SpriteColor;
+                    img.Scale = scale;
+                }
+
+                int cargoVal = 0;
+                extraCargo.TryGetValue(pf.Name, out cargoVal);
+                var countText = new GUITextBlock(
+                    new Rectangle(160, 0, 55, 25),
+                    cargoVal.ToString(),
+                    "",
+                    Alignment.Left, Alignment.Center, textBlock);
+
+                var incButton = new GUIButton(new Rectangle(200, 5, 15, 15), ">", "", textBlock);
+                incButton.UserData = countText;
+                incButton.OnClicked = (button, obj) =>
+                {
+                    int val;
+                    if (extraCargo.TryGetValue(pf.Name, out val))
+                    {
+                        extraCargo[pf.Name]++; val = extraCargo[pf.Name];
+                    }
+                    else
+                    {
+                        extraCargo.Add(pf.Name, 1); val = 1;
+                    }
+                    ((GUITextBlock)obj).Text = val.ToString();
+                    ((GUITextBlock)obj).SetTextPos();
+                    return true;
+                };
+
+                var decButton = new GUIButton(new Rectangle(160, 5, 15, 15), "<", "", textBlock);
+                decButton.UserData = countText;
+                decButton.OnClicked = (button, obj) =>
+                {
+                    int val;
+                    if (extraCargo.TryGetValue(pf.Name, out val))
+                    {
+                        extraCargo[pf.Name]--;
+                        val = extraCargo[pf.Name];
+                        if (val <= 0)
+                        {
+                            extraCargo.Remove(pf.Name);
+                            val = 0;
+                        }
+                        ((GUITextBlock)obj).Text = val.ToString();
+                        ((GUITextBlock)obj).SetTextPos();
+                    }
+
+                    return true;
+                };
+            }
+
+
+            //--------------------------------------------------------------------------------
+            //                              server settings 
+            //--------------------------------------------------------------------------------
+
+            y = 0;
+
+
+            var startIntervalText = new GUITextBlock(new Rectangle(-10, y, 100, 20), "Autorestart delay", "", settingsTabs[1]);
+            var startIntervalSlider = new GUIScrollBar(new Rectangle(10, y + 22, 100, 15), "", 0.1f, settingsTabs[1]);
+            startIntervalSlider.UserData = startIntervalText;
+            startIntervalSlider.Step = 0.05f;
+            startIntervalSlider.BarScroll = AutoRestartInterval / 300.0f;
+            startIntervalSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                GUITextBlock text = scrollBar.UserData as GUITextBlock;
+
+                AutoRestartInterval = Math.Max(barScroll * 300.0f, 10.0f);
+
+                text.Text = "Autorestart delay: " + ToolBox.SecondsToReadableTime(AutoRestartInterval);
+                return true;
+            };
+            startIntervalSlider.OnMoved(startIntervalSlider, startIntervalSlider.BarScroll);
+
+            y += 45;
+
+            var allowSpecBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Allow spectating", Alignment.Left, settingsTabs[1]);
+            allowSpecBox.Selected = AllowSpectating;
+            allowSpecBox.OnSelected = (GUITickBox) =>
+            {
+                AllowSpectating = GUITickBox.Selected;
+                return true;
+            };
+
+            y += 40;
+
+            var voteKickBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Allow vote kicking", Alignment.Left, settingsTabs[1]);
+            voteKickBox.Selected = Voting.AllowVoteKick;
+            voteKickBox.OnSelected = (GUITickBox) =>
+            {
+                Voting.AllowVoteKick = !Voting.AllowVoteKick;
+                GameMain.Server.UpdateVoteStatus();
+                return true;
+            };
+
+            var kickVotesRequiredText = new GUITextBlock(new Rectangle(20, y + 20, 20, 20), "Votes required: 50 %", "", settingsTabs[1], GUI.SmallFont);
+
+            var kickVoteSlider = new GUIScrollBar(new Rectangle(150, y + 22, 100, 15), "", 0.1f, settingsTabs[1]);
+            kickVoteSlider.UserData = kickVotesRequiredText;
+            kickVoteSlider.Step = 0.2f;
+            kickVoteSlider.BarScroll = (KickVoteRequiredRatio - 0.5f) * 2.0f;
+            kickVoteSlider.OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
+            {
+                GUITextBlock voteText = scrollBar.UserData as GUITextBlock;
+
+                KickVoteRequiredRatio = barScroll / 2.0f + 0.5f;
+                voteText.Text = "Votes required: " + (int)MathUtils.Round(KickVoteRequiredRatio * 100.0f, 10.0f) + " %";
+                return true;
+            };
+            kickVoteSlider.OnMoved(kickVoteSlider, kickVoteSlider.BarScroll);
+
+            y += 45;
+
+            var shareSubsBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Share submarine files with players", Alignment.Left, settingsTabs[1]);
+            shareSubsBox.Selected = AllowFileTransfers;
+            shareSubsBox.OnSelected = (GUITickBox) =>
+            {
+                AllowFileTransfers = GUITickBox.Selected;
+                return true;
+            };
+
+            y += 40;
+
+            var randomizeLevelBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Randomize level seed between rounds", Alignment.Left, settingsTabs[1]);
+            randomizeLevelBox.Selected = RandomizeSeed;
+            randomizeLevelBox.OnSelected = (GUITickBox) =>
+            {
+                RandomizeSeed = GUITickBox.Selected;
+                return true;
+            };
+
+            y += 40;
+
+            var saveLogsBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Save server logs", Alignment.Left, settingsTabs[1]);
+            saveLogsBox.Selected = SaveServerLogs;
+            saveLogsBox.OnSelected = (GUITickBox) =>
+            {
+                SaveServerLogs = GUITickBox.Selected;
+                showLogButton.Visible = SaveServerLogs;
+                return true;
+            };
+
+
+            //--------------------------------------------------------------------------------
+            //                              banlist
+            //--------------------------------------------------------------------------------
+
+
+            banList.CreateBanFrame(settingsTabs[2]);
+
+            //--------------------------------------------------------------------------------
+            //                              whitelist
+            //--------------------------------------------------------------------------------
+
+            whitelist.CreateWhiteListFrame(settingsTabs[3]);
+
+        }
+
+
+        private bool SwitchSubSelection(GUITickBox tickBox)
+        {
+            subSelectionMode = (SelectionMode)tickBox.UserData;
+
+            foreach (GUIComponent otherTickBox in tickBox.Parent.children)
+            {
+                if (otherTickBox == tickBox) continue;
+                ((GUITickBox)otherTickBox).Selected = false;
+            }
+
+            Voting.AllowSubVoting = subSelectionMode == SelectionMode.Vote;
+
+            if (subSelectionMode == SelectionMode.Random)
+            {
+                GameMain.NetLobbyScreen.SubList.Select(Rand.Range(0, GameMain.NetLobbyScreen.SubList.CountChildren));
+            }
+
+            return true;
+        }
+
+        private bool SelectSettingsTab(GUIButton button, object obj)
+        {
+            settingsTabIndex = (int)obj;
+
+            for (int i = 0; i < settingsTabs.Length; i++)
+            {
+                settingsTabs[i].Visible = i == settingsTabIndex;
+            }
+
+            return true;
+        }
+
+        private bool SwitchModeSelection(GUITickBox tickBox)
+        {
+            modeSelectionMode = (SelectionMode)tickBox.UserData;
+
+            foreach (GUIComponent otherTickBox in tickBox.Parent.children)
+            {
+                if (otherTickBox == tickBox) continue;
+                ((GUITickBox)otherTickBox).Selected = false;
+            }
+
+            Voting.AllowModeVoting = modeSelectionMode == SelectionMode.Vote;
+
+            if (modeSelectionMode == SelectionMode.Random)
+            {
+                GameMain.NetLobbyScreen.ModeList.Select(Rand.Range(0, GameMain.NetLobbyScreen.ModeList.CountChildren));
+            }
+
+            return true;
+        }
+
+
+        public bool ToggleSettingsFrame(GUIButton button, object obj)
+        {
+            if (settingsFrame == null)
+            {
+                CreateSettingsFrame();
+            }
+            else
+            {
+                settingsFrame = null;
+                SaveSettings();
+            }
+
+            return false;
+        }
+
+        public void ManagePlayersFrame(GUIFrame infoFrame)
+        {
+            GUIListBox cList = new GUIListBox(new Rectangle(0, 0, 0, 300), Color.White * 0.7f, "", infoFrame);
+            cList.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+            //crewList.OnSelected = SelectCrewCharacter;
+
+            foreach (Client c in ConnectedClients)
+            {
+                GUIFrame frame = new GUIFrame(new Rectangle(0, 0, 0, 40), Color.Transparent, null, cList);
+                frame.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+                frame.Color = (c.inGame && c.Character != null && !c.Character.IsDead) ? Color.Gold * 0.2f : Color.Transparent;
+                frame.HoverColor = Color.LightGray * 0.5f;
+                frame.SelectedColor = Color.Gold * 0.5f;
+
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(40, 0, 0, 25),
+                    c.name + " (" + c.Connection.RemoteEndPoint.Address.ToString() + ")",
+                    Color.Transparent, Color.White,
+                    Alignment.Left, Alignment.Left,
+                    null, frame);
+
+                var banButton = new GUIButton(new Rectangle(-110, 0, 100, 20), "Ban", Alignment.Right | Alignment.CenterY, "", frame);
+                banButton.UserData = c.name;
+                banButton.OnClicked = GameMain.NetLobbyScreen.BanPlayer;
+
+                var rangebanButton = new GUIButton(new Rectangle(-220, 0, 100, 20), "Ban range", Alignment.Right | Alignment.CenterY, "", frame);
+                rangebanButton.UserData = c.name;
+                rangebanButton.OnClicked = GameMain.NetLobbyScreen.BanPlayerRange;
+
+                var kickButton = new GUIButton(new Rectangle(0, 0, 100, 20), "Kick", Alignment.Right | Alignment.CenterY, "", frame);
+                kickButton.UserData = c.name;
+                kickButton.OnClicked = GameMain.NetLobbyScreen.KickPlayer;
+
+                textBlock.Padding = new Vector4(5.0f, 0.0f, 5.0f, 0.0f);
+            }
+        }
+    }
+}

BarotraumaClient/Source/Networking/NetStats.cs

@@ -0,0 +1,177 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma.Networking
+{
+    class NetStats
+    {
+        public enum NetStatType
+        {
+            SentBytes = 0,
+            ReceivedBytes = 1,
+            ResentMessages = 2
+        }
+
+        private Graph[] graphs;
+
+        private float[] totalValue;
+        private float[] lastValue;
+
+        const float UpdateInterval = 0.1f;
+        float updateTimer;
+
+        public NetStats()
+        {
+            graphs = new Graph[3];
+
+            totalValue = new float[3];
+            lastValue = new float[3];
+            for (int i = 0; i < 3; i++ )
+            {                
+                graphs[i] = new Graph();
+            }            
+        }
+
+        public void AddValue(NetStatType statType, float value)
+        {
+            float valueChange = value - lastValue[(int)statType];
+
+            totalValue[(int)statType] += valueChange;
+
+            lastValue[(int)statType] = value;
+        }
+
+        public void Update(float deltaTime)
+        {
+            updateTimer -= deltaTime;
+
+            if (updateTimer > 0.0f) return;
+
+            for (int i = 0; i<3; i++)
+            {
+
+                graphs[i].Update(totalValue[i] / UpdateInterval);
+                totalValue[i] = 0.0f;
+            }
+
+            updateTimer = UpdateInterval;
+        }
+
+        public void Draw(SpriteBatch spriteBatch, Rectangle rect, GameServer server)
+        {
+            GUI.DrawRectangle(spriteBatch, rect, Color.Black*0.4f, true);
+
+            graphs[(int)NetStatType.ReceivedBytes].Draw(spriteBatch, rect, null, 0.0f, Color.Cyan);
+
+            graphs[(int)NetStatType.SentBytes].Draw(spriteBatch, rect, null, 0.0f, Color.Orange);
+
+            graphs[(int)NetStatType.ResentMessages].Draw(spriteBatch, rect, null, 0.0f, Color.Red);
+
+            GUI.SmallFont.DrawString(spriteBatch,
+                "Peak received: " + MathUtils.GetBytesReadable((int)graphs[(int)NetStatType.ReceivedBytes].LargestValue()) + "/s      " +
+                "Avg received: " + MathUtils.GetBytesReadable((int)graphs[(int)NetStatType.ReceivedBytes].Average()) + "/s",
+                new Vector2(rect.X + 10, rect.Y + 10), Color.Cyan);
+
+
+            GUI.SmallFont.DrawString(spriteBatch, "Peak sent: " + MathUtils.GetBytesReadable((int)graphs[(int)NetStatType.SentBytes].LargestValue()) + "/s      " +
+                "Avg sent: " + MathUtils.GetBytesReadable((int)graphs[(int)NetStatType.SentBytes].Average()) + "/s",
+                new Vector2(rect.X + 10, rect.Y + 30), Color.Orange);
+
+            GUI.SmallFont.DrawString(spriteBatch, "Peak resent: " + graphs[(int)NetStatType.ResentMessages].LargestValue() + " messages/s",
+                new Vector2(rect.X + 10, rect.Y + 50), Color.Red);
+#if DEBUG
+            int y = 10;
+
+            foreach (KeyValuePair<string, long> msgBytesSent in server.messageCount.OrderBy(key => -key.Value))
+            {
+                GUI.SmallFont.DrawString(spriteBatch, msgBytesSent.Key + ": " + MathUtils.GetBytesReadable(msgBytesSent.Value),
+                    new Vector2(rect.Right - 200, rect.Y + y), Color.Red);
+
+                y += 15;
+            }
+#endif
+        }
+    }
+
+    class Graph
+    {
+        public const int ArraySize = 100;
+
+        private float[] values;
+
+        public Graph()
+        {
+            values = new float[ArraySize];
+        }
+
+        public float LargestValue()
+        {
+            float maxValue = 0.0f;
+            for (int i = 0; i < values.Length; i++)
+            {
+                if (values[i] > maxValue) maxValue = values[i];
+            }
+            return maxValue;
+        }
+
+        public float Average()
+        {
+            return values.Length == 0 ? 0.0f : values.Average();
+        }
+
+        public void Update(float newValue)
+        {
+            for (int i = values.Length-1; i > 0; i--)
+            {
+                values[i] = values[i - 1];
+            }
+            values[0] = newValue;
+        }
+
+        public void Draw(SpriteBatch spriteBatch, Rectangle rect, float? maxVal, float xOffset, Color color)
+        {
+            float graphMaxVal = 1.0f;
+            if (maxVal == null)
+            {
+                graphMaxVal = LargestValue();
+            }
+            else if (maxVal > 0.0f)
+            {
+                graphMaxVal = (float)maxVal;
+            }
+
+            GUI.DrawRectangle(spriteBatch, rect, Color.White);
+
+            if (values.Length == 0) return;
+
+            float lineWidth = (float)rect.Width / (float)(values.Length - 2);
+            float yScale = (float)rect.Height / graphMaxVal;
+
+            Vector2 prevPoint = new Vector2(rect.Right, rect.Bottom - (values[1] + (values[0] - values[1]) * xOffset) * yScale);
+
+            float currX = rect.Right - ((xOffset - 1.0f) * lineWidth);
+
+            for (int i = 1; i < values.Length - 1; i++)
+            {
+                currX -= lineWidth;
+
+                Vector2 newPoint = new Vector2(currX, rect.Bottom - values[i] * yScale);
+
+                GUI.DrawLine(spriteBatch, prevPoint, newPoint - new Vector2(1.0f, 0), color);
+
+                prevPoint = newPoint;
+            }
+
+            Vector2 lastPoint = new Vector2(rect.X,
+                rect.Bottom - (values[values.Length - 1] + (values[values.Length - 2] - values[values.Length - 1]) * xOffset) * yScale);
+
+            GUI.DrawLine(spriteBatch, prevPoint, lastPoint, color);
+        }
+    }
+
+
+}

BarotraumaClient/Source/Networking/NetworkMember.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using System.Collections.Generic;
+using Lidgren.Network;
+using Barotrauma.Items.Components;
+
+namespace Barotrauma.Networking
+{
+    abstract partial class NetworkMember
+    {
+        protected GUIFrame inGameHUD;
+        protected GUIListBox chatBox;
+        protected GUITextBox chatMsgBox;
+
+        public GUIFrame InGameHUD
+        {
+            get { return inGameHUD; }
+        }
+        
+        private void InitProjSpecific()
+        {
+            inGameHUD = new GUIFrame(new Rectangle(0, 0, 0, 0), null, null);
+            inGameHUD.CanBeFocused = false;
+
+            int width = (int)MathHelper.Clamp(GameMain.GraphicsWidth * 0.35f, 350, 500);
+            int height = (int)MathHelper.Clamp(GameMain.GraphicsHeight * 0.15f, 100, 200);
+            chatBox = new GUIListBox(new Rectangle(
+                GameMain.GraphicsWidth - 20 - width,
+                GameMain.GraphicsHeight - 40 - 25 - height,
+                width, height),
+                Color.White * 0.5f, "", inGameHUD);
+            chatBox.Padding = Vector4.Zero;
+
+            chatMsgBox = new GUITextBox(
+                new Rectangle(chatBox.Rect.X, chatBox.Rect.Y + chatBox.Rect.Height + 20, chatBox.Rect.Width, 25),
+                Color.White * 0.5f, Color.Black, Alignment.TopLeft, Alignment.Left, "", inGameHUD);
+            chatMsgBox.Font = GUI.SmallFont;
+            chatMsgBox.MaxTextLength = ChatMessage.MaxLength;
+            chatMsgBox.Padding = Vector4.Zero;
+            chatMsgBox.OnEnterPressed = EnterChatMessage;
+            chatMsgBox.OnTextChanged = TypingChatMessage;
+        }
+
+        public bool TypingChatMessage(GUITextBox textBox, string text)
+        {
+            string tempStr;
+            string command = ChatMessage.GetChatMessageCommand(text, out tempStr);
+            switch (command)
+            {
+                case "r":
+                case "radio":
+                    textBox.TextColor = ChatMessage.MessageColor[(int)ChatMessageType.Radio];
+                    break;
+                case "d":
+                case "dead":
+                    textBox.TextColor = ChatMessage.MessageColor[(int)ChatMessageType.Dead];
+                    break;
+                default:
+                    textBox.TextColor = ChatMessage.MessageColor[(int)ChatMessageType.Default];
+                    break;
+            }
+
+            return true;
+        }
+
+        public bool EnterChatMessage(GUITextBox textBox, string message)
+        {
+            textBox.TextColor = ChatMessage.MessageColor[(int)ChatMessageType.Default];
+
+            if (string.IsNullOrWhiteSpace(message)) return false;
+
+            if (this == GameMain.Server)
+            {
+                GameMain.Server.SendChatMessage(message, null, null);
+            }
+            else if (this == GameMain.Client)
+            {
+                GameMain.Client.SendChatMessage(message);
+            }
+
+            if (textBox == chatMsgBox) textBox.Deselect();
+
+            return true;
+        }
+
+        public virtual void AddToGUIUpdateList()
+        {
+            if (gameStarted && Screen.Selected == GameMain.GameScreen)
+            {
+                inGameHUD.AddToGUIUpdateList();
+            }
+        }
+
+        public virtual void Draw(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch)
+        {
+            if (!gameStarted || Screen.Selected != GameMain.GameScreen) return;
+
+            GameMain.GameSession.CrewManager.Draw(spriteBatch);
+
+            inGameHUD.Draw(spriteBatch);
+
+            if (EndVoteCount > 0)
+            {
+                if (GameMain.NetworkMember.myCharacter == null)
+                {
+                    GUI.DrawString(spriteBatch, new Vector2(GameMain.GraphicsWidth - 180.0f, 40),
+                        "Votes to end the round (y/n): " + EndVoteCount + "/" + (EndVoteMax - EndVoteCount), Color.White, null, 0, GUI.SmallFont);
+                }
+                else
+                {
+                    GUI.DrawString(spriteBatch, new Vector2(GameMain.GraphicsWidth - 140.0f, 40),
+                        "Votes (y/n): " + EndVoteCount + "/" + (EndVoteMax - EndVoteCount), Color.White, null, 0, GUI.SmallFont);
+                }
+            }
+
+            if (respawnManager != null)
+            {
+                string respawnInfo = "";
+
+                if (respawnManager.CurrentState == RespawnManager.State.Waiting &&
+                    respawnManager.CountdownStarted)
+                {
+                    respawnInfo = respawnManager.RespawnTimer <= 0.0f ? "" : "Respawn Shuttle dispatching in " + ToolBox.SecondsToReadableTime(respawnManager.RespawnTimer);
+
+                }
+                else if (respawnManager.CurrentState == RespawnManager.State.Transporting)
+                {
+                    respawnInfo = respawnManager.TransportTimer <= 0.0f ? "" : "Shuttle leaving in " + ToolBox.SecondsToReadableTime(respawnManager.TransportTimer);
+                }
+
+                if (!string.IsNullOrEmpty(respawnInfo))
+                {
+                    GUI.DrawString(spriteBatch,
+                        new Vector2(120.0f, 10),
+                        respawnInfo, Color.White, null, 0, GUI.SmallFont);
+                }
+
+            }
+        }
+
+        public virtual bool SelectCrewCharacter(Character character, GUIComponent crewFrame)
+        {
+            return false;
+        }
+    }
+}

BarotraumaClient/Source/Networking/ServerLog.cs

@@ -0,0 +1,128 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Barotrauma.Networking
+{
+    partial class ServerLog
+    {
+        public GUIFrame LogFrame;
+
+        private GUIListBox listBox;
+
+        public void CreateLogFrame()
+        {
+            LogFrame = new GUIFrame(new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight), Color.Black * 0.5f);
+
+            GUIFrame innerFrame = new GUIFrame(new Rectangle(0, 0, 600, 420), null, Alignment.Center, "", LogFrame);
+            innerFrame.Padding = new Vector4(10.0f, 20.0f, 10.0f, 20.0f);
+
+            new GUITextBlock(new Rectangle(-200, 0, 100, 15), "Filter", "", Alignment.TopRight, Alignment.CenterRight, innerFrame, false, GUI.SmallFont);
+
+            GUITextBox searchBox = new GUITextBox(new Rectangle(-20, 0, 180, 15), Alignment.TopRight, "", innerFrame);
+            searchBox.Font = GUI.SmallFont;
+            searchBox.OnTextChanged = (textBox, text) =>
+            {
+                msgFilter = text;
+                FilterMessages();
+                return true;
+            };
+            GUIComponent.KeyboardDispatcher.Subscriber = searchBox;
+
+            var clearButton = new GUIButton(new Rectangle(0, 0, 15, 15), "x", Alignment.TopRight, "", innerFrame);
+            clearButton.OnClicked = ClearFilter;
+            clearButton.UserData = searchBox;
+
+            listBox = new GUIListBox(new Rectangle(0, 30, 450, 340), "", Alignment.TopRight, innerFrame);
+
+            int y = 30;
+            foreach (MessageType msgType in Enum.GetValues(typeof(MessageType)))
+            {
+                var tickBox = new GUITickBox(new Rectangle(0, y, 20, 20), messageTypeName[(int)msgType], Alignment.TopLeft, GUI.SmallFont, innerFrame);
+                tickBox.Selected = true;
+                tickBox.TextColor = messageColor[(int)msgType];
+
+                tickBox.OnSelected += (GUITickBox tb) =>
+                {
+                    msgTypeHidden[(int)msgType] = !tb.Selected;
+                    FilterMessages();
+                    return true;
+                };
+
+                y += 20;
+            }
+
+            var currLines = lines.ToList();
+
+            foreach (LogMessage line in currLines)
+            {
+                AddLine(line);
+            }
+
+            listBox.UpdateScrollBarSize();
+
+            if (listBox.BarScroll == 0.0f || listBox.BarScroll == 1.0f) listBox.BarScroll = 1.0f;
+
+            GUIButton closeButton = new GUIButton(new Rectangle(-100, 10, 100, 15), "Close", Alignment.BottomRight, "", innerFrame);
+            closeButton.OnClicked = (button, userData) =>
+            {
+                LogFrame = null;
+                return true;
+            };
+
+            msgFilter = "";
+        }
+
+        private void AddLine(LogMessage line)
+        {
+            float prevSize = listBox.BarSize;
+
+            var textBlock = new GUITextBlock(new Rectangle(0, 0, 0, 0), line.Text, "", Alignment.TopLeft, Alignment.TopLeft, listBox, true, GUI.SmallFont);
+            textBlock.Rect = new Rectangle(textBlock.Rect.X, textBlock.Rect.Y, textBlock.Rect.Width, Math.Max(13, textBlock.Rect.Height));
+            textBlock.TextColor = messageColor[(int)line.Type];
+            textBlock.CanBeFocused = false;
+            textBlock.UserData = line;
+
+            if ((prevSize == 1.0f && listBox.BarScroll == 0.0f) || (prevSize < 1.0f && listBox.BarScroll == 1.0f)) listBox.BarScroll = 1.0f;
+        }
+
+        private bool FilterMessages()
+        {
+            string filter = msgFilter == null ? "" : msgFilter.ToLower();
+
+            foreach (GUIComponent child in listBox.children)
+            {
+                var textBlock = child as GUITextBlock;
+                if (textBlock == null) continue;
+
+                child.Visible = true;
+
+                if (msgTypeHidden[(int)((LogMessage)child.UserData).Type])
+                {
+                    child.Visible = false;
+                    continue;
+                }
+
+                textBlock.Visible = string.IsNullOrEmpty(filter) || textBlock.Text.ToLower().Contains(filter);
+            }
+
+            listBox.BarScroll = 0.0f;
+
+            return true;
+        }
+
+        public bool ClearFilter(GUIComponent button, object obj)
+        {
+            var searchBox = button.UserData as GUITextBox;
+            if (searchBox != null) searchBox.Text = "";
+
+            msgFilter = "";
+            FilterMessages();
+
+            return true;
+        }
+
+    }
+}

BarotraumaClient/Source/Networking/WhiteList.cs

@@ -0,0 +1,112 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma.Networking
+{
+    partial class WhiteList
+    {
+        private GUIComponent whitelistFrame;
+
+        private GUITextBox nameBox;
+        private GUITextBox ipBox;
+
+        public GUIComponent CreateWhiteListFrame(GUIComponent parent)
+        {
+            if (whitelistFrame != null)
+            {
+                whitelistFrame.Parent.ClearChildren();
+                whitelistFrame = null;
+            }
+
+            parent.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+
+            var enabledTick = new GUITickBox(new Rectangle(0, 0, 20, 20), "Enabled", Alignment.TopLeft, parent);
+            enabledTick.Selected = Enabled;
+            enabledTick.OnSelected = (GUITickBox box) =>
+            {
+                Enabled = !Enabled;
+
+                if (Enabled)
+                {
+                    foreach (Client c in GameMain.Server.ConnectedClients)
+                    {
+                        if (!IsWhiteListed(c.name, c.Connection.RemoteEndPoint.Address.ToString()))
+                        {
+                            whitelistedPlayers.Add(new WhiteListedPlayer(c.name, c.Connection.RemoteEndPoint.Address.ToString()));
+                            if (whitelistFrame != null) CreateWhiteListFrame(whitelistFrame.Parent);
+                        }
+                    }
+                }
+
+                Save();
+                return true;
+            };
+
+            new GUITextBlock(new Rectangle(0, -35, 90, 20), "Name:", "", Alignment.BottomLeft, Alignment.CenterLeft, parent, false, GUI.Font);
+            nameBox = new GUITextBox(new Rectangle(100, -35, 170, 20), Alignment.BottomLeft, "", parent);
+            nameBox.Font = GUI.Font;
+
+            new GUITextBlock(new Rectangle(0, 0, 90, 20), "IP Address:", "", Alignment.BottomLeft, Alignment.CenterLeft, parent, false, GUI.Font);
+            ipBox = new GUITextBox(new Rectangle(100, 0, 170, 20), Alignment.BottomLeft, "", parent);
+            ipBox.Font = GUI.Font;
+
+            var addnewButton = new GUIButton(new Rectangle(0, 35, 150, 20), "Add to whitelist", Alignment.BottomLeft, "", parent);
+            addnewButton.OnClicked = AddToWhiteList;
+
+            whitelistFrame = new GUIListBox(new Rectangle(0, 30, 0, parent.Rect.Height - 110), "", parent);
+
+            foreach (WhiteListedPlayer wlp in whitelistedPlayers)
+            {
+                string blockText = wlp.Name;
+                if (!string.IsNullOrWhiteSpace(wlp.IP)) blockText += " (" + wlp.IP + ")";
+                GUITextBlock textBlock = new GUITextBlock(
+                    new Rectangle(0, 0, 0, 25),
+                    blockText,
+                    "",
+                    Alignment.Left, Alignment.Left, whitelistFrame);
+                textBlock.Padding = new Vector4(10.0f, 10.0f, 0.0f, 0.0f);
+                textBlock.UserData = wlp;
+
+                var removeButton = new GUIButton(new Rectangle(0, 0, 100, 20), "Remove", Alignment.Right | Alignment.CenterY, "", textBlock);
+                removeButton.UserData = wlp;
+                removeButton.OnClicked = RemoveFromWhiteList;
+            }
+
+            return parent;
+        }
+
+        private bool RemoveFromWhiteList(GUIButton button, object obj)
+        {
+            WhiteListedPlayer wlp = obj as WhiteListedPlayer;
+            if (wlp == null) return false;
+
+            RemoveFromWhiteList(wlp);
+
+            if (whitelistFrame != null)
+            {
+                whitelistFrame.Parent.ClearChildren();
+                CreateWhiteListFrame(whitelistFrame.Parent);
+            }
+
+            return true;
+        }
+
+        private bool AddToWhiteList(GUIButton button, object obj)
+        {
+            if (string.IsNullOrWhiteSpace(nameBox.Text)) return false;
+            if (whitelistedPlayers.Any(x => x.Name.ToLower() == nameBox.Text.ToLower() && x.IP == ipBox.Text)) return false;
+
+            AddToWhiteList(nameBox.Text, ipBox.Text);
+
+            if (whitelistFrame != null)
+            {
+                CreateWhiteListFrame(whitelistFrame.Parent);
+            }
+            return true;
+        }
+    }
+}

BarotraumaClient/Source/Utils/MathUtils.cs

@@ -0,0 +1,22 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class CompareSegmentPointCW : IComparer<Lights.SegmentPoint>
+    {
+        private Vector2 center;
+
+        public CompareSegmentPointCW(Vector2 center)
+        {
+            this.center = center;
+        }
+        public int Compare(Lights.SegmentPoint a, Lights.SegmentPoint b)
+        {
+            return -CompareCCW.Compare(a.WorldPos, b.WorldPos, center);
+        }
+    }
+}

BarotraumaClient/Source/Utils/ToolBox.cs

@@ -0,0 +1,103 @@
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    public static partial class ToolBox
+    {
+        public static string LimitString(string str, ScalableFont font, int maxWidth)
+        {
+            if (maxWidth <= 0 || string.IsNullOrWhiteSpace(str)) return "";
+
+            float currWidth = font.MeasureString("...").X;
+            for (int i = 0; i < str.Length; i++)
+            {
+                currWidth += font.MeasureString(str[i].ToString()).X;
+
+                if (currWidth > maxWidth)
+                {
+                    return str.Substring(0, Math.Max(i - 2, 1)) + "...";
+                }
+            }
+
+            return str;
+        }
+
+        public static string WrapText(string text, float lineLength, ScalableFont font, float textScale = 1.0f) //TODO: could integrate this into the ScalableFont class directly
+        {
+            if (font.MeasureString(text).X < lineLength) return text;
+
+            text = text.Replace("\n", " \n ");
+
+            string[] words = text.Split(' ');
+
+            StringBuilder wrappedText = new StringBuilder();
+            float linePos = 0f;
+            float spaceWidth = font.MeasureString(" ").X * textScale;
+            for (int i = 0; i < words.Length; ++i)
+            {
+                if (string.IsNullOrWhiteSpace(words[i]) && words[i] != "\n") continue;
+
+                Vector2 size = font.MeasureString(words[i]) * textScale;
+                if (size.X > lineLength)
+                {
+                    if (linePos == 0.0f)
+                    {
+                        wrappedText.AppendLine(words[i]);
+                    }
+                    else
+                    {
+                        do
+                        {
+                            if (words[i].Length == 0) break;
+
+                            wrappedText.Append(words[i][0]);
+                            words[i] = words[i].Remove(0, 1);
+
+                            linePos += size.X;
+                        } while (words[i].Length > 0 && (size = font.MeasureString((words[i][0]).ToString()) * textScale).X + linePos < lineLength);
+
+                        wrappedText.Append("\n");
+                        linePos = 0.0f;
+                        i--;
+                    }
+
+                    continue;
+                }
+
+                if (linePos + size.X < lineLength)
+                {
+                    wrappedText.Append(words[i]);
+                    if (words[i] == "\n")
+                    {
+                        linePos = 0.0f;
+                    }
+                    else
+                    {
+
+                        linePos += size.X + spaceWidth;
+                    }
+                }
+                else
+                {
+                    wrappedText.Append("\n");
+                    wrappedText.Append(words[i]);
+
+                    linePos = size.X + spaceWidth;
+                }
+
+                if (i < words.Length - 1) wrappedText.Append(" ");
+            }
+
+            return wrappedText.ToString();
+        }
+    }
+}