Merge branch 'dedicated-server' (TODO: make sure I didn't break anything)

Conflicts:
	Barotrauma/Barotrauma.csproj
	Barotrauma/BarotraumaShared/Source/Characters/AI/AIController.cs
	Barotrauma/BarotraumaShared/Source/Characters/AI/EnemyAIController.cs
	Barotrauma/BarotraumaShared/Source/Characters/AICharacter.cs
	Barotrauma/BarotraumaShared/Source/Characters/Animation/Ragdoll.cs
	Barotrauma/BarotraumaShared/Source/Characters/Attack.cs
	Barotrauma/BarotraumaShared/Source/Characters/Character.cs
	Barotrauma/BarotraumaShared/Source/Characters/CharacterNetworking.cs
	Barotrauma/BarotraumaShared/Source/Characters/Limb.cs
	Barotrauma/BarotraumaShared/Source/Events/MonsterEvent.cs
	Barotrauma/BarotraumaShared/Source/Map/Explosion.cs

Barotrauma/BarotraumaClient/Source/Camera.cs

@@ -0,0 +1,265 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+using System.Linq;
+
+namespace Barotrauma
+{
+    public class Camera
+    {
+        public static bool FollowSub = true;
+
+        const float DefaultZoom = 1.0f;
+        const float ZoomSmoothness = 8.0f;
+        const float MoveSmoothness = 8.0f;
+
+        private float zoom;
+
+        private float offsetAmount;
+
+        private Matrix transform, shaderTransform, viewMatrix;
+        private Vector2 position;
+        private float rotation;
+
+        private Vector2 prevPosition;
+        private float prevZoom;
+
+        public float Shake;
+        private Vector2 shakePosition;
+        private Vector2 shakeTargetPosition;
+        
+        //the area of the world inside the camera view
+        private Rectangle worldView;
+
+        private Point resolution;
+
+        private Vector2 targetPos;
+
+        public float Zoom
+        {
+            get { return zoom; }
+            set 
+            {
+                zoom = Math.Max(value, GameMain.DebugDraw ? 0.01f : 0.1f);
+                
+                Vector2 center = WorldViewCenter;
+                float newWidth = resolution.X / zoom;
+                float newHeight = resolution.Y / zoom;
+
+                worldView = new Rectangle(
+                    (int)(center.X - newWidth / 2.0f),
+                    (int)(center.Y + newHeight / 2.0f),
+                    (int)newWidth,
+                    (int)newHeight);
+
+                //UpdateTransform();
+            }
+        }
+
+        public float Rotation
+        {
+            get { return rotation; }
+            set { rotation = value; }
+        }
+
+        public float OffsetAmount
+        {
+            get { return offsetAmount; }
+            set { offsetAmount = value; }
+        }
+
+        public Point Resolution
+        {
+            get { return resolution; }
+        }
+
+        public Rectangle WorldView
+        {
+            get { return worldView; }
+        }
+
+        public Vector2 WorldViewCenter
+        {
+            get
+            {
+                return new Vector2(
+                    worldView.X + worldView.Width / 2.0f,
+                    worldView.Y - worldView.Height / 2.0f);
+            }
+        }
+
+        public Matrix Transform
+        {
+            get { return transform; }
+        }
+
+        public Matrix ShaderTransform
+        {
+            get { return shaderTransform; }
+        }
+
+        public Camera()
+        {
+            zoom = 1.0f;
+            rotation = 0.0f;
+            position = Vector2.Zero;
+
+            worldView = new Rectangle(0,0, 
+                GameMain.GraphicsWidth,
+                GameMain.GraphicsHeight);
+
+            resolution = new Point(GameMain.GraphicsWidth, GameMain.GraphicsHeight);
+
+            viewMatrix = 
+                Matrix.CreateTranslation(new Vector3(GameMain.GraphicsWidth / 2.0f, GameMain.GraphicsHeight / 2.0f, 0));
+
+            UpdateTransform();
+        }
+
+        public Vector2 TargetPos
+        {
+            get { return targetPos; }
+            set { targetPos = value; }
+        }
+                
+        // Auxiliary function to move the camera
+        public void Translate(Vector2 amount)
+        {
+            position += amount;
+
+        }
+
+        public void UpdateTransform(bool interpolate = true, bool clampPos = false)
+        {
+            Vector2 interpolatedPosition = interpolate ? Timing.Interpolate(prevPosition, position) : position;
+
+            float interpolatedZoom = interpolate ? Timing.Interpolate(prevZoom, zoom) : zoom;
+
+            worldView.X = (int)(interpolatedPosition.X - worldView.Width / 2.0);
+            worldView.Y = (int)(interpolatedPosition.Y + worldView.Height / 2.0);
+
+            if (Level.Loaded != null && clampPos)
+            {
+                position.Y -= Math.Max(worldView.Y - Level.Loaded.Size.Y, 0.0f);
+                interpolatedPosition.Y -= Math.Max(worldView.Y - Level.Loaded.Size.Y, 0.0f);
+
+                worldView.Y = Math.Min((int)Level.Loaded.Size.Y, worldView.Y); 
+            }
+
+            transform = Matrix.CreateTranslation(
+                new Vector3(-interpolatedPosition.X, interpolatedPosition.Y, 0)) *
+                Matrix.CreateScale(new Vector3(interpolatedZoom, interpolatedZoom, 1)) *
+                viewMatrix;
+
+            shaderTransform = Matrix.CreateTranslation(
+                new Vector3(
+                    -interpolatedPosition.X - resolution.X / interpolatedZoom / 2.0f,
+                    -interpolatedPosition.Y - resolution.Y / interpolatedZoom / 2.0f, 0)) *
+                Matrix.CreateScale(new Vector3(interpolatedZoom, interpolatedZoom, 1)) *
+                viewMatrix;
+            
+            Sound.CameraPos = new Vector3(WorldViewCenter.X, WorldViewCenter.Y, 0.0f);
+
+            if (!interpolate)
+            {
+                prevPosition = position;
+                prevZoom = zoom;
+            }
+        }
+
+        public void MoveCamera(float deltaTime, bool allowMove = true, bool allowZoom = true)
+        {            
+            prevPosition = position;
+            prevZoom = zoom;
+
+            float moveSpeed = 20.0f/zoom;
+
+            Vector2 moveCam = Vector2.Zero;
+            if (targetPos == Vector2.Zero)
+            {
+                if (allowMove && GUIComponent.KeyboardDispatcher.Subscriber == null)
+                {
+                    if (PlayerInput.KeyDown(Keys.LeftShift)) moveSpeed *= 2.0f;
+                    if (PlayerInput.KeyDown(Keys.LeftControl)) moveSpeed *= 0.5f;
+
+                    if (GameMain.Config.KeyBind(InputType.Left).IsDown())   moveCam.X -= moveSpeed;
+                    if (GameMain.Config.KeyBind(InputType.Right).IsDown())  moveCam.X += moveSpeed;
+                    if (GameMain.Config.KeyBind(InputType.Down).IsDown())   moveCam.Y -= moveSpeed;
+                    if (GameMain.Config.KeyBind(InputType.Up).IsDown())     moveCam.Y += moveSpeed;
+                }
+
+                if (Screen.Selected == GameMain.GameScreen && FollowSub)
+                {
+                    var closestSub = Submarine.FindClosest(WorldViewCenter);
+                    if (closestSub != null)
+                    {
+                        moveCam += FarseerPhysics.ConvertUnits.ToDisplayUnits(closestSub.Velocity * deltaTime);
+                    }
+                }
+                 
+                moveCam = moveCam * deltaTime * 60.0f;
+
+                if (allowZoom)
+                {
+                    Vector2 mouseInWorld = ScreenToWorld(PlayerInput.MousePosition);
+                    Vector2 diffViewCenter;
+                    diffViewCenter = ((mouseInWorld - Position) * Zoom);
+                    Zoom = MathHelper.Clamp(zoom + (PlayerInput.ScrollWheelSpeed / 1000.0f) * zoom, GameMain.DebugDraw ? 0.01f : 0.1f, 2.0f);
+                    if (!PlayerInput.KeyDown(Keys.F)) Position = mouseInWorld - (diffViewCenter / Zoom);
+                }
+            }
+            else
+            {
+                Vector2 mousePos = PlayerInput.MousePosition;
+
+                Vector2 offset = mousePos - new Vector2(resolution.X / 2.0f, resolution.Y / 2.0f);
+
+                offset.X = offset.X / (resolution.X * 0.4f);
+                offset.Y = -offset.Y / (resolution.Y * 0.3f);
+
+                if (offset.Length() > 1.0f) offset.Normalize();
+
+                offset = offset * offsetAmount;
+
+                float newZoom = Math.Min(DefaultZoom - Math.Min(offset.Length() / resolution.Y, 1.0f),1.0f);
+                Zoom += (newZoom - zoom) / ZoomSmoothness;
+
+                Vector2 diff = (targetPos + offset) - position;
+
+                moveCam = diff / MoveSmoothness;
+            }
+
+            shakeTargetPosition = Rand.Vector(Shake);
+            shakePosition = Vector2.Lerp(shakePosition, shakeTargetPosition, 0.5f);
+            Shake = MathHelper.Lerp(Shake, 0.0f, deltaTime * 2.0f);
+
+            Translate(moveCam + shakePosition);
+        }
+        
+        public Vector2 Position
+        {
+            get { return position; }
+            set 
+            { 
+                if (!MathUtils.IsValid(value))
+                {
+                    return;
+                }
+                position = value; 
+            }
+        }
+        
+        public Vector2 ScreenToWorld(Vector2 coords)
+        {
+            Vector2 worldCoords = Vector2.Transform(coords, Matrix.Invert(transform));
+            return new Vector2(worldCoords.X, -worldCoords.Y);
+        }
+
+        public Vector2 WorldToScreen(Vector2 coords)
+        {
+            coords.Y = -coords.Y;
+            //Vector2 screenCoords = Vector2.Transform(coords, transform);
+            return Vector2.Transform(coords, transform);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/AI/AIController.cs

@@ -0,0 +1,11 @@
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    partial class AIController : ISteerable
+    {
+        public virtual void DebugDraw(SpriteBatch spriteBatch) { }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/AI/AITarget.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    partial class AITarget
+    {
+        public static bool ShowAITargets;
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (!ShowAITargets) return;
+
+            var rangeSprite = GUI.SubmarineIcon;
+
+            if (soundRange > 0.0f)
+                rangeSprite.Draw(spriteBatch,
+                    new Vector2(WorldPosition.X, -WorldPosition.Y),
+                    Color.Cyan * 0.1f, rangeSprite.Origin,
+                    0.0f, soundRange / rangeSprite.size.X);
+
+            if (sightRange > 0.0f)
+                rangeSprite.Draw(spriteBatch,
+                    new Vector2(WorldPosition.X, -WorldPosition.Y),
+                    Color.Orange * 0.1f, rangeSprite.Origin,
+                    0.0f, sightRange / rangeSprite.size.X);
+        }
+    }
+}

Barotrauma/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);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/AI/EnemyAIController.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Xml.Linq;
+using FarseerPhysics;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    partial class EnemyAIController : AIController
+    {
+        public override void DebugDraw(SpriteBatch spriteBatch)
+        {
+            if (Character.IsDead) return;
+
+            Vector2 pos = Character.WorldPosition;
+            pos.Y = -pos.Y;
+
+            if (selectedAiTarget != null)
+            {
+                GUI.DrawLine(spriteBatch, pos, new Vector2(selectedAiTarget.WorldPosition.X, -selectedAiTarget.WorldPosition.Y), Color.Red);
+
+                if (wallAttackPos != Vector2.Zero)
+                {
+                    GUI.DrawRectangle(spriteBatch, ConvertUnits.ToDisplayUnits(new Vector2(wallAttackPos.X, -wallAttackPos.Y)) - new Vector2(10.0f, 10.0f), new Vector2(20.0f, 20.0f), Color.Red, false);
+                }
+
+                GUI.Font.DrawString(spriteBatch, targetValue.ToString(), pos - Vector2.UnitY * 20.0f, Color.Red);
+            }
+
+            if (selectedAiTarget != null)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2(Character.DrawPosition.X, -Character.DrawPosition.Y),
+                    new Vector2(selectedAiTarget.WorldPosition.X, -selectedAiTarget.WorldPosition.Y), Color.Red);
+            }
+
+            GUI.Font.DrawString(spriteBatch, targetValue.ToString(), pos - Vector2.UnitY * 80.0f, Color.Red);
+
+            GUI.Font.DrawString(spriteBatch, "updatetargets: " + updateTargetsTimer, pos - Vector2.UnitY * 100.0f, Color.Red);
+            GUI.Font.DrawString(spriteBatch, "cooldown: " + coolDownTimer, pos - Vector2.UnitY * 120.0f, Color.Red);
+
+
+            IndoorsSteeringManager pathSteering = steeringManager as IndoorsSteeringManager;
+            if (pathSteering == null || pathSteering.CurrentPath == null || pathSteering.CurrentPath.CurrentNode == null) return;
+
+            GUI.DrawLine(spriteBatch,
+                new Vector2(Character.DrawPosition.X, -Character.DrawPosition.Y),
+                new Vector2(pathSteering.CurrentPath.CurrentNode.DrawPosition.X, -pathSteering.CurrentPath.CurrentNode.DrawPosition.Y),
+                Color.LightGreen);
+
+
+            for (int i = 1; i < pathSteering.CurrentPath.Nodes.Count; i++)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2(pathSteering.CurrentPath.Nodes[i].DrawPosition.X, -pathSteering.CurrentPath.Nodes[i].DrawPosition.Y),
+                    new Vector2(pathSteering.CurrentPath.Nodes[i - 1].DrawPosition.X, -pathSteering.CurrentPath.Nodes[i - 1].DrawPosition.Y),
+                    Color.LightGreen);
+
+                GUI.SmallFont.DrawString(spriteBatch,
+                    pathSteering.CurrentPath.Nodes[i].ID.ToString(),
+                    new Vector2(pathSteering.CurrentPath.Nodes[i].DrawPosition.X, -pathSteering.CurrentPath.Nodes[i].DrawPosition.Y - 10),
+                    Color.LightGreen);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/AI/HumanAIController.cs

@@ -0,0 +1,55 @@
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    partial class HumanAIController : AIController
+    {
+        partial void InitProjSpecific()
+        {
+            if (GameMain.GameSession != null && GameMain.GameSession.CrewManager != null)
+            {
+                CurrentOrder = Order.PrefabList.Find(o => o.Name.ToLowerInvariant() == "dismissed");
+                objectiveManager.SetOrder(CurrentOrder, "");
+                GameMain.GameSession.CrewManager.SetCharacterOrder(Character, CurrentOrder);
+            }
+        }
+
+        partial void SetOrderProjSpecific(Order order)
+        {
+            GameMain.GameSession.CrewManager.SetCharacterOrder(Character, order);
+        }
+
+        public override void DebugDraw(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch)
+        {
+            if (selectedAiTarget != null)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2(Character.DrawPosition.X, -Character.DrawPosition.Y),
+                    new Vector2(selectedAiTarget.WorldPosition.X, -selectedAiTarget.WorldPosition.Y), Color.Red);
+            }
+
+            IndoorsSteeringManager pathSteering = steeringManager as IndoorsSteeringManager;
+            if (pathSteering == null || pathSteering.CurrentPath == null || pathSteering.CurrentPath.CurrentNode == null) return;
+
+            GUI.DrawLine(spriteBatch,
+                new Vector2(Character.DrawPosition.X, -Character.DrawPosition.Y),
+                new Vector2(pathSteering.CurrentPath.CurrentNode.DrawPosition.X, -pathSteering.CurrentPath.CurrentNode.DrawPosition.Y),
+                Color.LightGreen);
+
+
+            for (int i = 1; i < pathSteering.CurrentPath.Nodes.Count; i++)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2(pathSteering.CurrentPath.Nodes[i].DrawPosition.X, -pathSteering.CurrentPath.Nodes[i].DrawPosition.Y),
+                    new Vector2(pathSteering.CurrentPath.Nodes[i - 1].DrawPosition.X, -pathSteering.CurrentPath.Nodes[i - 1].DrawPosition.Y),
+                    Color.LightGreen);
+
+                GUI.SmallFont.DrawString(spriteBatch,
+                    pathSteering.CurrentPath.Nodes[i].ID.ToString(),
+                    new Vector2(pathSteering.CurrentPath.Nodes[i].DrawPosition.X, -pathSteering.CurrentPath.Nodes[i].DrawPosition.Y - 10),
+                    Color.LightGreen);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/AICharacter.cs

@@ -0,0 +1,42 @@
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    partial class AICharacter : Character
+    {
+        partial void InitProjSpecific()
+        {
+            soundTimer = Rand.Range(0.0f, soundInterval);
+        }
+
+        partial void SoundUpdate(float deltaTime)
+        {
+            if (soundTimer > 0)
+            {
+                soundTimer -= deltaTime;
+            }
+            else
+            {
+                switch (aiController.State)
+                {
+                    case AIController.AIState.Attack:
+                        PlaySound(CharacterSound.SoundType.Attack);
+                        break;
+                    default:
+                        PlaySound(CharacterSound.SoundType.Idle);
+                        break;
+                }
+                soundTimer = soundInterval;
+            }
+        }
+
+        public override void DrawFront(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch, Camera cam)
+        {
+            base.DrawFront(spriteBatch, cam);
+
+            if (GameMain.DebugDraw && !IsDead) aiController.DebugDraw(spriteBatch);
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/Animation/Ragdoll.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Contacts;
+using FarseerPhysics.Dynamics.Joints;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    partial class Ragdoll
+    {
+        partial void ImpactProjSpecific(float impact, Body body)
+        {
+            float volume = Math.Min(impact - 3.0f, 1.0f);
+
+            if (body.UserData is Limb)
+            {
+                Limb limb = (Limb)body.UserData;
+
+                if (impact > 3.0f && limb.HitSound != null && limb.SoundTimer <= 0.0f)
+                {
+                    limb.SoundTimer = Limb.SoundInterval;
+                    limb.HitSound.Play(volume, impact * 100.0f, limb.WorldPosition);
+                }
+            }
+            else if (body == Collider.FarseerBody)
+            {
+                if (!character.IsRemotePlayer || GameMain.Server != null)
+                {
+                    if (impact > ImpactTolerance)
+                    {
+                        SoundPlayer.PlayDamageSound(DamageSoundType.LimbBlunt, strongestImpact, Collider);
+                    }
+                }
+
+                if (Character.Controlled == character) GameMain.GameScreen.Cam.Shake = strongestImpact;
+            }
+        }
+
+        partial void Splash(Limb limb, Hull limbHull)
+        {
+            //create a splash particle
+            GameMain.ParticleManager.CreateParticle("watersplash",
+                new Vector2(limb.Position.X, limbHull.Surface) + limbHull.Submarine.Position,
+                new Vector2(0.0f, Math.Abs(-limb.LinearVelocity.Y * 20.0f)),
+                0.0f, limbHull);
+
+            GameMain.ParticleManager.CreateParticle("bubbles",
+                new Vector2(limb.Position.X, limbHull.Surface) + limbHull.Submarine.Position,
+                limb.LinearVelocity * 0.001f,
+                0.0f, limbHull);
+
+            //if the Character dropped into water, create a wave
+            if (limb.LinearVelocity.Y < 0.0f)
+            {
+                if (splashSoundTimer <= 0.0f)
+                {
+                    SoundPlayer.PlaySplashSound(limb.WorldPosition, Math.Abs(limb.LinearVelocity.Y) + Rand.Range(-5.0f, 0.0f));
+                    splashSoundTimer = 0.5f;
+                }
+            }
+        }
+
+        public virtual void Draw(SpriteBatch spriteBatch)
+        {
+            if (simplePhysicsEnabled) return;
+
+            Collider.UpdateDrawPosition();
+
+            foreach (Limb limb in Limbs)
+            {
+                limb.Draw(spriteBatch);
+            }
+        }
+
+        public void DebugDraw(SpriteBatch spriteBatch)
+        {
+            if (!GameMain.DebugDraw || !character.Enabled) return;
+            if (simplePhysicsEnabled) return;
+
+            foreach (Limb limb in Limbs)
+            {
+
+                if (limb.pullJoint != null)
+                {
+                    Vector2 pos = ConvertUnits.ToDisplayUnits(limb.pullJoint.WorldAnchorA);
+                    if (currentHull != null) pos += currentHull.Submarine.DrawPosition;
+                    pos.Y = -pos.Y;
+                    GUI.DrawRectangle(spriteBatch, new Rectangle((int)pos.X, (int)pos.Y, 5, 5), Color.Red, true, 0.01f);
+                }
+
+                limb.body.DebugDraw(spriteBatch, inWater ? Color.Cyan : Color.White);
+            }
+
+            Collider.DebugDraw(spriteBatch, frozen ? Color.Red : (inWater ? Color.SkyBlue : Color.Gray));
+            GUI.Font.DrawString(spriteBatch, Collider.LinearVelocity.X.ToString(), new Vector2(Collider.DrawPosition.X, -Collider.DrawPosition.Y), Color.Orange);
+
+            foreach (RevoluteJoint joint in LimbJoints)
+            {
+                Vector2 pos = ConvertUnits.ToDisplayUnits(joint.WorldAnchorA);
+                GUI.DrawRectangle(spriteBatch, new Rectangle((int)pos.X, (int)-pos.Y, 5, 5), Color.White, true);
+
+                pos = ConvertUnits.ToDisplayUnits(joint.WorldAnchorB);
+                GUI.DrawRectangle(spriteBatch, new Rectangle((int)pos.X, (int)-pos.Y, 5, 5), Color.White, true);
+            }
+
+            foreach (Limb limb in Limbs)
+            {
+                if (limb.body.TargetPosition != null)
+                {
+                    Vector2 pos = ConvertUnits.ToDisplayUnits((Vector2)limb.body.TargetPosition);
+                    if (currentHull != null) pos += currentHull.Submarine.DrawPosition;
+                    pos.Y = -pos.Y;
+
+                    GUI.DrawRectangle(spriteBatch, new Rectangle((int)pos.X - 10, (int)pos.Y - 10, 20, 20), Color.Cyan, false, 0.01f);
+                    GUI.DrawLine(spriteBatch, pos, new Vector2(limb.WorldPosition.X, -limb.WorldPosition.Y), Color.Cyan);
+                }
+            }
+
+            if (character.MemState.Count > 1)
+            {
+                Vector2 prevPos = ConvertUnits.ToDisplayUnits(character.MemState[0].Position);
+                if (currentHull != null) prevPos += currentHull.Submarine.DrawPosition;
+                prevPos.Y = -prevPos.Y;
+
+                for (int i = 1; i < character.MemState.Count; i++)
+                {
+                    Vector2 currPos = ConvertUnits.ToDisplayUnits(character.MemState[i].Position);
+                    if (currentHull != null) currPos += currentHull.Submarine.DrawPosition;
+                    currPos.Y = -currPos.Y;
+
+                    GUI.DrawRectangle(spriteBatch, new Rectangle((int)currPos.X - 3, (int)currPos.Y - 3, 6, 6), Color.Cyan * 0.6f, true, 0.01f);
+                    GUI.DrawLine(spriteBatch, prevPos, currPos, Color.Cyan * 0.6f, 0, 3);
+
+                    prevPos = currPos;
+                }
+            }
+
+            if (ignorePlatforms)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2(Collider.DrawPosition.X, -Collider.DrawPosition.Y),
+                    new Vector2(Collider.DrawPosition.X, -Collider.DrawPosition.Y + 50),
+                    Color.Orange, 0, 5);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/Attack.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Barotrauma.Particles;
+
+namespace Barotrauma
+{
+    partial class Attack
+    {
+        private Sound sound;
+
+        private ParticleEmitterPrefab particleEmitterPrefab;
+
+        partial void InitProjSpecific(XElement element)
+        {
+            string soundPath = ToolBox.GetAttributeString(element, "sound", "");
+            if (!string.IsNullOrWhiteSpace(soundPath))
+            {
+                sound = Sound.Load(soundPath);
+            }
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "particleemitter":
+                        particleEmitterPrefab = new ParticleEmitterPrefab(subElement);
+                        break;
+                }
+
+            }
+        }
+
+        partial void DamageParticles(Vector2 worldPosition)
+        {
+            if (particleEmitterPrefab != null)
+            {
+                particleEmitterPrefab.Emit(worldPosition);
+            }
+
+            if (sound != null)
+            {
+                sound.Play(1.0f, 500.0f, worldPosition);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/BackgroundSprite/BackgroundCreature.cs

@@ -0,0 +1,238 @@
+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
+{
+
+    class BackgroundCreature : ISteerable
+    {
+        const float MaxDepth = 100.0f;
+
+        const float CheckWallsInterval = 5.0f;
+
+        public bool Enabled;
+
+        private BackgroundCreaturePrefab prefab;
+
+        private Vector2 position;
+
+        private Vector3 velocity;
+
+        private float depth;
+        
+        private SteeringManager steeringManager;
+
+        private float checkWallsTimer;
+
+        public Swarm Swarm;
+
+        Vector2 drawPosition;
+        public Vector2 TransformedPosition
+        {
+            get { return drawPosition; }
+        }
+
+        public Vector2 SimPosition
+        {
+            get { return FarseerPhysics.ConvertUnits.ToSimUnits(position); }
+        }
+
+        public Vector2 WorldPosition
+        {
+            get { return position; }
+        }
+
+        public Vector2 Velocity
+        {
+            get { return new Vector2(velocity.X, velocity.Y); }
+        }
+
+        public Vector2 Steering
+        {
+            get;
+            set;
+        }
+        
+        public BackgroundCreature(BackgroundCreaturePrefab prefab, Vector2 position)
+        {
+            this.prefab = prefab;
+
+            this.position = position;
+
+            drawPosition = position;
+
+            steeringManager = new SteeringManager(this);
+
+            velocity = new Vector3(
+                Rand.Range(-prefab.Speed, prefab.Speed),
+                Rand.Range(-prefab.Speed, prefab.Speed),
+                Rand.Range(0.0f, prefab.WanderZAmount));
+
+            checkWallsTimer = Rand.Range(0.0f, CheckWallsInterval);
+            
+        }
+
+        float ang;
+        Vector2 obstacleDiff;
+
+        public void Update(float deltaTime)
+        {
+            position += new Vector2(velocity.X, velocity.Y) * deltaTime;
+            depth = MathHelper.Clamp(depth + velocity.Z * deltaTime, 0.0f, MaxDepth);
+
+            checkWallsTimer -= deltaTime;
+            if (checkWallsTimer <= 0.0f && Level.Loaded != null)
+            {
+                checkWallsTimer = CheckWallsInterval;
+
+                obstacleDiff = Vector2.Zero;
+                if (position.Y > Level.Loaded.Size.Y)
+                {
+                    obstacleDiff = Vector2.UnitY;
+                }
+                else if (position.Y < 0.0f)
+                {
+                    obstacleDiff = -Vector2.UnitY;
+                }
+                else if (position.X < 0.0f)
+                {
+                    obstacleDiff = Vector2.UnitX;
+                }
+                else if (position.X > Level.Loaded.Size.X)
+                {
+                    obstacleDiff = -Vector2.UnitX;
+                }
+                else
+                {
+                    var cells = Level.Loaded.GetCells(position, 1);
+                    if (cells.Count > 0)
+                    {
+
+                        foreach (Voronoi2.VoronoiCell cell in cells)
+                        {
+                            obstacleDiff += cell.Center - position;
+                        }
+                        obstacleDiff /= cells.Count;
+
+                        obstacleDiff = Vector2.Normalize(obstacleDiff) * prefab.Speed;
+                    }
+                }
+            }
+
+
+
+
+            if (Swarm!=null)
+            {
+                Vector2 midPoint = Swarm.MidPoint();
+                float midPointDist = Vector2.Distance(SimPosition, midPoint);
+
+                if (midPointDist > Swarm.MaxDistance)
+                {
+                    steeringManager.SteeringSeek(midPoint, (midPointDist / Swarm.MaxDistance) * prefab.Speed);
+                }
+            }
+
+            if (prefab.WanderAmount > 0.0f)
+            {
+                steeringManager.SteeringWander(prefab.Speed);
+            }
+
+            //Level.Loaded.Size
+
+
+            if (obstacleDiff != Vector2.Zero)
+            {
+                steeringManager.SteeringSeek(SimPosition-obstacleDiff, prefab.Speed*2.0f);
+            }
+
+            steeringManager.Update(prefab.Speed);
+
+            if (prefab.WanderZAmount>0.0f)
+            {
+                ang += Rand.Range(-prefab.WanderZAmount, prefab.WanderZAmount);
+                velocity.Z = (float)Math.Sin(ang)*prefab.Speed;
+            }
+            
+            velocity = Vector3.Lerp(velocity, new Vector3(Steering.X, Steering.Y, velocity.Z), deltaTime);
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            float rotation = 0.0f;
+            if (!prefab.DisableRotation)
+            {
+                rotation = MathUtils.VectorToAngle(new Vector2(velocity.X, -velocity.Y));
+                if (velocity.X < 0.0f) rotation -= MathHelper.Pi;
+            }
+
+            drawPosition = position;// +Level.Loaded.Position;
+
+            if (depth > 0.0f)
+            {
+                Vector2 camOffset = drawPosition - GameMain.GameScreen.Cam.WorldViewCenter;
+
+                drawPosition -= camOffset * (depth / MaxDepth) * 0.05f;
+            }
+            
+            prefab.Sprite.Draw(spriteBatch, new Vector2(drawPosition.X, -drawPosition.Y), Color.Lerp(Color.White, Color.DarkBlue, (depth/MaxDepth)*0.3f),
+                rotation, 1.0f - (depth / MaxDepth) * 0.2f, velocity.X > 0.0f ? SpriteEffects.None : SpriteEffects.FlipHorizontally, (depth / MaxDepth));
+        }
+    }
+
+    class Swarm
+    {
+        public List<BackgroundCreature> Members;
+
+        public readonly float MaxDistance;
+
+        public Vector2 MidPoint()
+        {
+            if (Members.Count == 0) return Vector2.Zero;
+
+            Vector2 midPoint = Vector2.Zero;
+
+            foreach (BackgroundCreature member in Members)
+            {
+                midPoint += member.SimPosition;
+            }
+
+            midPoint /= Members.Count;
+
+            return midPoint;
+        }
+
+        public Vector2 AvgVelocity()
+        {
+            if (Members.Count == 0) return Vector2.Zero;
+
+            Vector2 avgVel = Vector2.Zero;
+
+            foreach (BackgroundCreature member in Members)
+            {
+                avgVel += member.Velocity;
+            }
+
+           avgVel /= Members.Count;
+
+            return avgVel;
+        }
+
+        public Swarm(List<BackgroundCreature> members, float maxDistance)
+        {
+            this.Members = members;
+
+            this.MaxDistance = maxDistance;
+
+            foreach (BackgroundCreature bgSprite in members)
+            {
+                bgSprite.Swarm = this;
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/BackgroundSprite/BackgroundCreatureManager.cs

@@ -0,0 +1,139 @@
+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
+{
+    class BackgroundCreatureManager
+    {
+        const int MaxSprites = 100;
+
+        const float checkActiveInterval = 1.0f;
+
+        float checkActiveTimer;
+
+        private List<BackgroundCreaturePrefab> prefabs = new List<BackgroundCreaturePrefab>();
+        private List<BackgroundCreature> activeSprites = new List<BackgroundCreature>();
+
+        public BackgroundCreatureManager(string configPath)
+        {
+            LoadConfig(configPath);
+        }
+        public BackgroundCreatureManager(List<string> files)
+        {
+            foreach(var file in files)
+            {
+                LoadConfig(file);
+            }
+        }
+        private void LoadConfig(string configPath)
+        {
+            try
+            {
+                XDocument doc = ToolBox.TryLoadXml(configPath);
+                if (doc == null || doc.Root == null) return;
+
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    prefabs.Add(new BackgroundCreaturePrefab(element));
+                };
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError(String.Format("Failed to load BackgroundCreatures from {0}", configPath), e);
+            }
+        }
+        public void SpawnSprites(int count, Vector2? position = null)
+        {
+            activeSprites.Clear();
+
+            if (prefabs.Count == 0) return;
+
+            count = Math.Min(count, MaxSprites);
+
+            for (int i = 0; i < count; i++ )
+            {
+                Vector2 pos = Vector2.Zero;
+
+                if (position == null)
+                {
+                    var wayPoints = WayPoint.WayPointList.FindAll(wp => wp.Submarine==null);
+                    if (wayPoints.Any())
+                    {
+                        WayPoint wp = wayPoints[Rand.Int(wayPoints.Count, Rand.RandSync.ClientOnly)];
+
+                        pos = new Vector2(wp.Rect.X, wp.Rect.Y);
+                        pos += Rand.Vector(200.0f, Rand.RandSync.ClientOnly);
+                    }
+                    else
+                    {
+                        pos = Rand.Vector(2000.0f, Rand.RandSync.ClientOnly);
+                    } 
+                }
+                else
+                {
+                    pos = (Vector2)position;
+                }
+
+
+                var prefab = prefabs[Rand.Int(prefabs.Count, Rand.RandSync.ClientOnly)];
+
+                int amount = Rand.Range(prefab.SwarmMin, prefab.SwarmMax, Rand.RandSync.ClientOnly);
+                List<BackgroundCreature> swarmMembers = new List<BackgroundCreature>();
+
+                for (int n = 0; n < amount; n++)
+                {
+                    var newSprite = new BackgroundCreature(prefab, pos);
+                    activeSprites.Add(newSprite);
+                    swarmMembers.Add(newSprite);
+                }
+                if (amount > 0)
+                {
+                    new Swarm(swarmMembers, prefab.SwarmRadius);
+                }
+            }
+        }
+
+        public void ClearSprites()
+        {
+            activeSprites.Clear();
+        }
+
+        public void Update(float deltaTime, Camera cam)
+        {
+            if (checkActiveTimer<0.0f)
+            {
+                foreach (BackgroundCreature sprite in activeSprites)
+                {
+                    sprite.Enabled = (Math.Abs(sprite.TransformedPosition.X - cam.WorldViewCenter.X) < 4000.0f &&
+                    Math.Abs(sprite.TransformedPosition.Y - cam.WorldViewCenter.Y) < 4000.0f);                    
+                }
+
+                checkActiveTimer = checkActiveInterval;
+            }
+            else
+            {
+                checkActiveTimer -= deltaTime;
+            }
+
+            foreach (BackgroundCreature sprite in activeSprites)
+            {
+                if (!sprite.Enabled) continue;
+                sprite.Update(deltaTime);
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            foreach (BackgroundCreature sprite in activeSprites)
+            {
+                if (!sprite.Enabled) continue;
+                sprite.Draw(spriteBatch);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/BackgroundSprite/BackgroundCreaturePrefab.cs

@@ -0,0 +1,47 @@
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class BackgroundCreaturePrefab
+    {
+
+        public readonly Sprite Sprite;
+
+        public readonly float Speed;
+
+        public readonly float WanderAmount;
+
+        public readonly float WanderZAmount;
+
+        public readonly int SwarmMin, SwarmMax;
+
+        public readonly float SwarmRadius;
+
+        public readonly bool DisableRotation;
+        
+        public BackgroundCreaturePrefab(XElement element)
+        {
+            Speed = ToolBox.GetAttributeFloat(element, "speed", 1.0f);
+
+            WanderAmount = ToolBox.GetAttributeFloat(element, "wanderamount", 0.0f);
+
+            WanderZAmount = ToolBox.GetAttributeFloat(element, "wanderzamount", 0.0f);
+            
+            SwarmMin = ToolBox.GetAttributeInt(element, "swarmmin", 1);
+            SwarmMax = ToolBox.GetAttributeInt(element, "swarmmax", 1);
+
+            SwarmRadius = ToolBox.GetAttributeFloat(element, "swarmradius", 200.0f);
+
+            DisableRotation = ToolBox.GetAttributeBool(element, "disablerotation", false);
+
+            foreach (XElement subElement in element.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "sprite") continue;
+
+                Sprite = new Sprite(subElement);
+                break;
+            }
+        }
+    }
+
+}

Barotrauma/BarotraumaClient/Source/Characters/BackgroundSprite/BackgroundSpriteManager.cs

@@ -0,0 +1,349 @@
+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 System.Xml.Linq;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    class BackgroundSprite
+    {
+        public readonly BackgroundSpritePrefab Prefab;
+        public Vector3 Position;
+
+        public float Scale;
+
+        public float Rotation;
+        
+        //public Vector2[] spriteCorners;
+
+        public BackgroundSprite(BackgroundSpritePrefab prefab, Vector3 position, float scale, float rotation = 0.0f)
+        {
+            this.Prefab = prefab;
+            this.Position = position;
+
+            this.Scale = scale;
+
+            this.Rotation = rotation;
+        }
+    }
+
+    class BackgroundSpriteManager
+    {
+        const int GridSize = 1000;
+
+        private List<BackgroundSpritePrefab> prefabs = new List<BackgroundSpritePrefab>();
+        
+        private List<BackgroundSprite>[,] sprites;
+
+        private float swingTimer;
+
+        public BackgroundSpriteManager(string configPath)
+        {
+            LoadConfig(configPath);
+        }
+        public BackgroundSpriteManager(List<string> files)
+        {
+            foreach (var file in files)
+            {
+                LoadConfig(file);
+            }
+        }
+        private void LoadConfig(string configPath)
+        {
+            try
+            {
+                XDocument doc = ToolBox.TryLoadXml(configPath);
+                if (doc == null || doc.Root == null) return;
+
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    prefabs.Add(new BackgroundSpritePrefab(element));
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError(String.Format("Failed to load BackgroundSprites from {0}", configPath), e);
+            }
+        }
+
+
+        public void PlaceSprites(Level level, int amount)
+        {
+            sprites = new List<BackgroundSprite>[
+                (int)Math.Ceiling(level.Size.X / GridSize),
+                (int)Math.Ceiling(level.Size.Y / GridSize)];
+
+            for (int x = 0; x < sprites.GetLength(0); x++)
+            {
+                for (int y = 0; y < sprites.GetLength(1); y++)
+                {
+                    sprites[x, y] = new List<BackgroundSprite>();
+                }
+            }
+
+            for (int i = 0 ; i < amount; i++)
+            {
+                BackgroundSpritePrefab prefab = GetRandomPrefab(level.GenerationParams.Name);
+                GraphEdge selectedEdge = null;
+                Vector2 edgeNormal = Vector2.One;
+                Vector2? pos = FindSpritePosition(level, prefab, out selectedEdge, out edgeNormal);
+
+                if (pos == null) continue;
+
+                float rotation = 0.0f;
+                if (prefab.AlignWithSurface)
+                {
+                    rotation = MathUtils.VectorToAngle(new Vector2(edgeNormal.Y, edgeNormal.X));
+                }
+
+                rotation += Rand.Range(prefab.RandomRotation.X, prefab.RandomRotation.Y, Rand.RandSync.ClientOnly);
+
+                var newSprite = new BackgroundSprite(prefab,
+                    new Vector3((Vector2)pos, Rand.Range(prefab.DepthRange.X, prefab.DepthRange.Y, Rand.RandSync.ClientOnly)), Rand.Range(prefab.Scale.X, prefab.Scale.Y, Rand.RandSync.ClientOnly), rotation);
+                
+                //calculate the positions of the corners of the rotated sprite
+                Vector2 halfSize = newSprite.Prefab.Sprite.size * newSprite.Scale / 2;
+                var spriteCorners = new Vector2[]
+                {
+                    -halfSize, new Vector2(-halfSize.X, halfSize.Y),
+                    halfSize, new Vector2(halfSize.X, -halfSize.Y)
+                };
+
+                Vector2 pivotOffset = newSprite.Prefab.Sprite.Origin * newSprite.Scale - halfSize;
+                pivotOffset.X = -pivotOffset.X;
+                pivotOffset = new Vector2(
+                    (float)(pivotOffset.X * Math.Cos(-rotation) - pivotOffset.Y * Math.Sin(-rotation)),
+                    (float)(pivotOffset.X * Math.Sin(-rotation) + pivotOffset.Y * Math.Cos(-rotation)));                
+
+                for (int j = 0; j < 4; j++)
+                {
+                    spriteCorners[j] = new Vector2(
+                        (float)(spriteCorners[j].X * Math.Cos(-rotation) - spriteCorners[j].Y * Math.Sin(-rotation)),
+                        (float)(spriteCorners[j].X * Math.Sin(-rotation) + spriteCorners[j].Y * Math.Cos(-rotation)));
+
+                    spriteCorners[j] += (Vector2)pos + pivotOffset;
+                }
+
+                //newSprite.spriteCorners = spriteCorners;
+                
+                int minX = (int)Math.Floor((spriteCorners.Min(c => c.X) - newSprite.Position.Z) / GridSize);
+                int maxX = (int)Math.Floor((spriteCorners.Max(c => c.X) + newSprite.Position.Z) / GridSize);
+                if (minX < 0 || maxX >= sprites.GetLength(0)) continue;
+
+                int minY = (int)Math.Floor((spriteCorners.Min(c => c.Y) - newSprite.Position.Z) / GridSize);
+                int maxY = (int)Math.Floor((spriteCorners.Max(c => c.Y) + newSprite.Position.Z) / GridSize);
+                if (minY < 0 || maxY >= sprites.GetLength(1)) continue;
+
+                for (int x = minX; x <= maxX; x++)
+                {
+                    for (int y = minY; y <= maxY; y++)
+                    {
+                        sprites[x, y].Add(newSprite);
+                    }
+                }
+            }
+        }
+
+        private Vector2? FindSpritePosition(Level level, BackgroundSpritePrefab prefab, out GraphEdge closestEdge, out Vector2 edgeNormal)
+        {
+            closestEdge = null;
+            edgeNormal = Vector2.One;
+
+            Vector2 randomPos = new Vector2(
+                Rand.Range(0.0f, level.Size.X, Rand.RandSync.ClientOnly), 
+                Rand.Range(0.0f, level.Size.Y, Rand.RandSync.ClientOnly));
+
+            if (!prefab.SpawnOnWalls) return randomPos;
+
+            List<GraphEdge> edges = new List<GraphEdge>();
+            List<Vector2> normals = new List<Vector2>();
+
+            var cells = level.GetCells(randomPos);
+
+            if (cells.Any())
+            {
+                VoronoiCell cell = cells[Rand.Int(cells.Count, Rand.RandSync.ClientOnly)];
+
+                foreach (GraphEdge edge in cell.edges)
+                {
+                    if (!edge.isSolid || edge.OutsideLevel) continue;
+
+                    Vector2 normal = edge.GetNormal(cell);
+                
+                    if (prefab.Alignment.HasFlag(Alignment.Bottom) && normal.Y < -0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else if (prefab.Alignment.HasFlag(Alignment.Top) && normal.Y > 0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else if (prefab.Alignment.HasFlag(Alignment.Left) && normal.X < -0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else if (prefab.Alignment.HasFlag(Alignment.Right) && normal.X > 0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    normals.Add(normal);
+                }
+            }
+
+            foreach (RuinGeneration.Ruin ruin in Level.Loaded.Ruins)
+            {
+                Rectangle expandedArea = ruin.Area;
+                expandedArea.Inflate(ruin.Area.Width, ruin.Area.Height);
+                if (!expandedArea.Contains(randomPos)) continue;
+
+                foreach (var ruinShape in ruin.RuinShapes)
+                {
+                    foreach (var wall in ruinShape.Walls)
+                    {
+                        if (!prefab.Alignment.HasFlag(ruinShape.GetLineAlignment(wall))) continue;
+
+                        edges.Add(new GraphEdge(wall.A, wall.B));
+                        normals.Add((wall.A + wall.B) / 2.0f - ruinShape.Center);
+                    }
+                }
+            }
+
+            if (!edges.Any()) return null;
+
+            int index = Rand.Int(edges.Count, Rand.RandSync.ClientOnly);
+            closestEdge = edges[index];
+            edgeNormal = normals[index];
+
+            float length = Vector2.Distance(closestEdge.point1, closestEdge.point2);
+            Vector2 dir = (closestEdge.point1 - closestEdge.point2) / length;
+            Vector2 pos = closestEdge.point2 + dir * Rand.Range(prefab.Sprite.size.X / 2.0f, length - prefab.Sprite.size.X / 2.0f, Rand.RandSync.ClientOnly);
+
+            return pos;
+        }
+
+        public void Update(float deltaTime)
+        {
+            swingTimer += deltaTime;
+        }
+
+        public void DrawSprites(SpriteBatch spriteBatch, Camera cam)
+        {
+            Rectangle indices = Rectangle.Empty;
+            indices.X = (int)Math.Floor(cam.WorldView.X / (float)GridSize);            
+            if (indices.X >= sprites.GetLength(0)) return;
+            indices.Y = (int)Math.Floor((cam.WorldView.Y - cam.WorldView.Height) / (float)GridSize);
+            if (indices.Y >= sprites.GetLength(1)) return;
+
+            indices.Width = (int)Math.Floor(cam.WorldView.Right / (float)GridSize)+1;
+            if (indices.Width < 0) return;
+            indices.Height = (int)Math.Floor(cam.WorldView.Y / (float)GridSize)+1;
+            if (indices.Height < 0) return;
+
+            indices.X = Math.Max(indices.X, 0);
+            indices.Y = Math.Max(indices.Y, 0);
+            indices.Width = Math.Min(indices.Width, sprites.GetLength(0)-1);
+            indices.Height = Math.Min(indices.Height, sprites.GetLength(1)-1);
+
+            float swingState = (float)Math.Sin(swingTimer * 0.1f);
+
+            List<BackgroundSprite> visibleSprites = new List<BackgroundSprite>();
+
+            float z = 0.0f;
+            for (int x = indices.X; x <= indices.Width; x++)
+            {
+                for (int y = indices.Y; y <= indices.Height; y++)
+                {
+                    foreach (BackgroundSprite sprite in sprites[x, y])
+                    {
+                        int drawOrderIndex = 0;
+                        for (int i = 0; i < visibleSprites.Count; i++)
+                        {
+                            if (visibleSprites[i] == sprite)
+                            {
+                                drawOrderIndex = -1;
+                                break;
+                            }
+
+                            if (visibleSprites[i].Position.Z > sprite.Position.Z)
+                            {
+                                break;
+                            }
+                            else
+                            {
+                                drawOrderIndex = i + 1;
+                            }
+                        }
+
+                        if (drawOrderIndex >= 0)
+                        {
+                            visibleSprites.Insert(drawOrderIndex, sprite);
+                        }
+                    }
+                }
+            }
+
+            foreach (BackgroundSprite sprite in visibleSprites)
+            {              
+                Vector2 camDiff = new Vector2(sprite.Position.X, sprite.Position.Y) - cam.WorldViewCenter;
+                camDiff.Y = -camDiff.Y;
+
+                sprite.Prefab.Sprite.Draw(
+                    spriteBatch,
+                    new Vector2(sprite.Position.X, -sprite.Position.Y) - camDiff * sprite.Position.Z / 10000.0f,
+                    Color.Lerp(Color.White, Level.Loaded.BackgroundColor, sprite.Position.Z / 5000.0f),
+                    sprite.Rotation + swingState * sprite.Prefab.SwingAmount,
+                    sprite.Scale,
+                    SpriteEffects.None,
+                    z);
+
+                /*for (int i = 0; i < 4; i++)
+                {
+                    GUI.DrawLine(spriteBatch,
+                        new Vector2(sprite.spriteCorners[i].X, -sprite.spriteCorners[i].Y),
+                        new Vector2(sprite.spriteCorners[(i + 1) % 4].X, -sprite.spriteCorners[(i + 1) % 4].Y),
+                        Color.White, 0, 5);
+                }*/
+
+                if (GameMain.DebugDraw)
+                {
+                    GUI.DrawRectangle(spriteBatch, new Vector2(sprite.Position.X, -sprite.Position.Y), new Vector2(10.0f, 10.0f), Color.Red, true);
+                }
+
+                z += 0.0001f;
+            }
+        }
+
+        private BackgroundSpritePrefab GetRandomPrefab(string levelType)
+        {
+            int totalCommonness = 0;
+            foreach (BackgroundSpritePrefab prefab in prefabs)
+            {
+                totalCommonness += prefab.GetCommonness(levelType);
+            }
+
+            float randomNumber = Rand.Int(totalCommonness+1, Rand.RandSync.ClientOnly);
+
+            foreach (BackgroundSpritePrefab prefab in prefabs)
+            {
+                if (randomNumber <= prefab.GetCommonness(levelType))
+                {
+                    return prefab;
+                }
+
+                randomNumber -= prefab.GetCommonness(levelType);
+            }
+
+            return null;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/BackgroundSprite/BackgroundSpritePrefab.cs

@@ -0,0 +1,89 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class BackgroundSpritePrefab
+    {
+        public readonly Sprite Sprite;
+
+        public readonly Alignment Alignment;
+
+        public readonly Vector2 Scale;
+
+        public bool SpawnOnWalls;
+
+        public readonly bool AlignWithSurface;
+
+        public readonly Vector2 RandomRotation;
+
+        public readonly Vector2 DepthRange;
+
+        public readonly float SwingAmount;
+
+        public readonly int Commonness;
+
+        public Dictionary<string, int> OverrideCommonness;
+
+        public BackgroundSpritePrefab(XElement element)
+        {
+            string alignmentStr = ToolBox.GetAttributeString(element, "alignment", "");
+
+            if (string.IsNullOrEmpty(alignmentStr) || !Enum.TryParse(alignmentStr, out Alignment))
+            {
+                Alignment = Alignment.Top | Alignment.Bottom | Alignment.Left | Alignment.Right;
+            }
+
+            Commonness = ToolBox.GetAttributeInt(element, "commonness", 1);
+
+            SpawnOnWalls = ToolBox.GetAttributeBool(element, "spawnonwalls", true);
+
+            Scale.X = ToolBox.GetAttributeFloat(element, "minsize", 1.0f);
+            Scale.Y = ToolBox.GetAttributeFloat(element, "maxsize", 1.0f);
+
+            DepthRange = ToolBox.GetAttributeVector2(element, "depthrange", new Vector2(0.0f, 1.0f));
+
+            AlignWithSurface = ToolBox.GetAttributeBool(element, "alignwithsurface", false);
+
+            RandomRotation = ToolBox.GetAttributeVector2(element, "randomrotation", Vector2.Zero);
+            RandomRotation.X = MathHelper.ToRadians(RandomRotation.X);
+            RandomRotation.Y = MathHelper.ToRadians(RandomRotation.Y);
+
+            SwingAmount = MathHelper.ToRadians(ToolBox.GetAttributeFloat(element, "swingamount", 0.0f));
+
+            OverrideCommonness = new Dictionary<string, int>();
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch(subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        Sprite = new Sprite(subElement);
+                        break;
+                    case "overridecommonness":
+                        string levelType = ToolBox.GetAttributeString(subElement, "leveltype", "");
+                        if (!OverrideCommonness.ContainsKey(levelType))
+                        {
+                            OverrideCommonness.Add(levelType, ToolBox.GetAttributeInt(subElement, "commonness", 1));
+                        }
+                        break;
+
+                }
+            }
+        }
+
+        public int GetCommonness(string levelType)
+        {
+            int commonness = 0;
+            if (!OverrideCommonness.TryGetValue(levelType, out commonness))
+            {
+                return Commonness;
+            }
+
+            return commonness;
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/Character.cs

@@ -0,0 +1,442 @@
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Joints;
+using Barotrauma.Networking;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Particles;
+
+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
+        private static Character controlled;
+
+        public static Character Controlled
+        {
+            get { return controlled; }
+            set
+            {
+                if (controlled == value) return;
+                controlled = value;
+                CharacterHUD.Reset();
+
+                if (controlled != null)
+                {
+                    controlled.Enabled = true;
+                }
+            }
+        }
+        
+        private Dictionary<object, HUDProgressBar> hudProgressBars;
+
+        public Dictionary<object, HUDProgressBar> HUDProgressBars
+        {
+            get { return hudProgressBars; }
+        }
+
+        partial void InitProjSpecific(XDocument doc)
+        {
+            soundInterval = ToolBox.GetAttributeFloat(doc.Root, "soundinterval", 10.0f);
+
+            keys = new Key[Enum.GetNames(typeof(InputType)).Length];
+
+            for (int i = 0; i < Enum.GetNames(typeof(InputType)).Length; i++)
+            {
+                keys[i] = new Key(GameMain.Config.KeyBind((InputType)i));
+            }
+
+            var soundElements = doc.Root.Elements("sound").ToList();
+
+            sounds = new List<CharacterSound>();
+            foreach (XElement soundElement in soundElements)
+            {
+                sounds.Add(new CharacterSound(soundElement));
+            }
+
+            hudProgressBars = new Dictionary<object, HUDProgressBar>();
+        }
+
+
+        /// <summary>
+        /// Control the Character according to player input
+        /// </summary>
+        public void ControlLocalPlayer(float deltaTime, Camera cam, bool moveCam = true)
+        {
+            if (!DisableControls)
+            {
+                for (int i = 0; i < keys.Length; i++)
+                {
+                    keys[i].SetState();
+                }
+            }
+            else
+            {
+                foreach (Key key in keys)
+                {
+                    if (key == null) continue;
+                    key.Reset();
+                }
+            }
+
+            if (moveCam)
+            {
+                if (needsAir &&
+                    pressureProtection < 80.0f &&
+                    (AnimController.CurrentHull == null || AnimController.CurrentHull.LethalPressure > 50.0f))
+                {
+                    float pressure = AnimController.CurrentHull == null ? 100.0f : AnimController.CurrentHull.LethalPressure;
+
+                    cam.Zoom = MathHelper.Lerp(cam.Zoom,
+                        (pressure / 50.0f) * Rand.Range(1.0f, 1.05f),
+                        (pressure - 50.0f) / 50.0f);
+                }
+
+                if (IsHumanoid)
+                {
+                    cam.OffsetAmount = MathHelper.Lerp(cam.OffsetAmount, 250.0f, deltaTime);
+                }
+                else
+                {
+                    //increased visibility range when controlling large a non-humanoid
+                    cam.OffsetAmount = MathHelper.Lerp(cam.OffsetAmount, MathHelper.Clamp(Mass, 250.0f, 800.0f), deltaTime);
+                }
+            }
+
+            cursorPosition = cam.ScreenToWorld(PlayerInput.MousePosition);
+            if (AnimController.CurrentHull != null && AnimController.CurrentHull.Submarine != null)
+            {
+                cursorPosition -= AnimController.CurrentHull.Submarine.Position;
+            }
+
+            Vector2 mouseSimPos = ConvertUnits.ToSimUnits(cursorPosition);
+
+            if (Lights.LightManager.ViewTarget == this && Vector2.DistanceSquared(AnimController.Limbs[0].SimPosition, mouseSimPos) > 1.0f)
+            {
+                Body body = Submarine.PickBody(AnimController.Limbs[0].SimPosition, mouseSimPos);
+                Structure structure = null;
+                if (body != null) structure = body.UserData as Structure;
+                if (structure != null)
+                {
+                    if (!structure.CastShadow && moveCam)
+                    {
+                        cam.OffsetAmount = MathHelper.Lerp(cam.OffsetAmount, 500.0f, 0.05f);
+                    }
+                }
+            }
+
+            if (!LockHands)
+            {
+                //find the closest item if selectkey has been hit, or if the Character is being
+                //controlled by the player (in order to highlight it)
+
+                if (findClosestTimer <= 0.0f || Screen.Selected == GameMain.EditMapScreen)
+                {
+                    closestCharacter = FindClosestCharacter(mouseSimPos);
+                    if (closestCharacter != null && closestCharacter.info == null)
+                    {
+                        closestCharacter = null;
+                    }
+
+                    float closestItemDist = 0.0f;
+                    closestItem = FindClosestItem(mouseSimPos, out closestItemDist);
+
+                    if (closestCharacter != null && closestItem != null)
+                    {
+                        if (Vector2.DistanceSquared(closestCharacter.SimPosition, mouseSimPos) < ConvertUnits.ToSimUnits(closestItemDist) * ConvertUnits.ToSimUnits(closestItemDist))
+                        {
+                            if (selectedConstruction != closestItem) closestItem = null;
+                        }
+                        else
+                        {
+                            closestCharacter = null;
+                        }
+                    }
+
+                    findClosestTimer = 0.1f;
+                }
+                else
+                {
+                    findClosestTimer -= deltaTime;
+                }
+
+                if (selectedCharacter == null && closestItem != null)
+                {
+                    closestItem.IsHighlighted = true;
+                    if (!LockHands && closestItem.Pick(this))
+                    {
+
+                    }
+                }
+
+                if (IsKeyHit(InputType.Select))
+                {
+                    if (selectedCharacter != null)
+                    {
+                        DeselectCharacter();
+                    }
+                    else if (closestCharacter != null && closestCharacter.IsHumanoid && closestCharacter.CanBeSelected)
+                    {
+                        SelectCharacter(closestCharacter);
+                    }
+                }
+            }
+            else
+            {
+                if (selectedCharacter != null) DeselectCharacter();
+                selectedConstruction = null;
+                closestItem = null;
+                closestCharacter = null;
+            }
+
+            DisableControls = false;
+        }
+
+        partial void UpdateControlled(float deltaTime,Camera cam)
+        {
+            if (controlled != this) return;
+            
+            ControlLocalPlayer(deltaTime, cam);            
+
+            Lights.LightManager.ViewTarget = this;
+            CharacterHUD.Update(deltaTime, this);
+
+            foreach (HUDProgressBar progressBar in hudProgressBars.Values)
+            {
+                progressBar.Update(deltaTime);
+            }
+
+            foreach (var pb in hudProgressBars.Where(pb => pb.Value.FadeTimer <= 0.0f).ToList())
+            {
+                hudProgressBars.Remove(pb.Key);
+            }
+        }
+
+        partial void DamageHUD(float amount)
+        {
+            if (controlled == this) CharacterHUD.TakeDamage(amount);
+        }
+
+        partial void UpdateOxygenProjSpecific(float prevOxygen)
+        {
+            if (prevOxygen > 0.0f && Oxygen <= 0.0f && controlled == this)
+            {
+                SoundPlayer.PlaySound("drown");
+            }
+        }
+
+        partial void KillProjSpecific()
+        {
+            if (GameMain.NetworkMember != null && Character.controlled == this)
+            {
+                string chatMessage = InfoTextManager.GetInfoText("Self_CauseOfDeath." + causeOfDeath.ToString());
+                if (GameMain.Client != null) chatMessage += " Your chat messages will only be visible to other dead players.";
+
+                GameMain.NetworkMember.AddChatMessage(chatMessage, ChatMessageType.Dead);
+                GameMain.LightManager.LosEnabled = false;
+                controlled = null;
+            }
+
+            PlaySound(CharacterSound.SoundType.Die);
+        }
+
+        partial void DisposeProjSpecific()
+        {
+            if (controlled == this) controlled = null;
+
+            if (GameMain.GameSession?.CrewManager != null &&
+                GameMain.GameSession.CrewManager.characters.Contains(this))
+            {
+                GameMain.GameSession.CrewManager.characters.Remove(this);
+            }
+
+            if (GameMain.Client != null && GameMain.Client.Character == this) GameMain.Client.Character = null;
+
+            if (Lights.LightManager.ViewTarget == this) Lights.LightManager.ViewTarget = null;
+        }
+
+        public static void AddAllToGUIUpdateList()
+        {
+            for (int i = 0; i < CharacterList.Count; i++)
+            {
+                CharacterList[i].AddToGUIUpdateList();
+            }
+        }
+
+        public virtual void AddToGUIUpdateList()
+        {
+            if (controlled == this)
+            {
+                CharacterHUD.AddToGUIUpdateList(this);
+            }
+        }
+        
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Enabled) return;
+
+            AnimController.Draw(spriteBatch);
+        }
+
+        public void DrawHUD(SpriteBatch spriteBatch, Camera cam)
+        {
+            CharacterHUD.Draw(spriteBatch, this, cam);
+        }
+
+        public virtual void DrawFront(SpriteBatch spriteBatch, Camera cam)
+        {
+            if (!Enabled) return;
+
+            if (GameMain.DebugDraw)
+            {
+                AnimController.DebugDraw(spriteBatch);
+
+                if (aiTarget != null) aiTarget.Draw(spriteBatch);
+            }
+
+            /*if (memPos != null && memPos.Count > 0 && controlled == this)
+            {
+                PosInfo serverPos = memPos.Last();
+                Vector2 remoteVec = ConvertUnits.ToDisplayUnits(serverPos.Position);
+                if (Submarine != null)
+                {
+                    remoteVec += Submarine.DrawPosition;
+                }
+                remoteVec.Y = -remoteVec.Y;
+
+                PosInfo localPos = memLocalPos.Find(m => m.ID == serverPos.ID);
+                int mpind = memLocalPos.FindIndex(lp => lp.ID == localPos.ID);
+                PosInfo localPos1 = mpind > 0 ? memLocalPos[mpind - 1] : null;
+                PosInfo localPos2 = mpind < memLocalPos.Count-1 ? memLocalPos[mpind + 1] : null;
+
+                Vector2 localVec = ConvertUnits.ToDisplayUnits(localPos.Position);
+                Vector2 localVec1 = localPos1 != null ? ConvertUnits.ToDisplayUnits(((PosInfo)localPos1).Position) : Vector2.Zero;
+                Vector2 localVec2 = localPos2 != null ? ConvertUnits.ToDisplayUnits(((PosInfo)localPos2).Position) : Vector2.Zero;
+                if (Submarine != null)
+                {
+                    localVec += Submarine.DrawPosition;
+                    localVec1 += Submarine.DrawPosition;
+                    localVec2 += Submarine.DrawPosition;
+                }
+                localVec.Y = -localVec.Y;
+                localVec1.Y = -localVec1.Y;
+                localVec2.Y = -localVec2.Y;
+
+                //GUI.DrawLine(spriteBatch, remoteVec, localVec, Color.Yellow, 0, 10);
+                if (localPos1 != null) GUI.DrawLine(spriteBatch, remoteVec, localVec1, Color.Lime, 0, 2);
+                if (localPos2 != null) GUI.DrawLine(spriteBatch, remoteVec + Vector2.One, localVec2 + Vector2.One, Color.Red, 0, 2);
+            }
+
+            Vector2 mouseDrawPos = CursorWorldPosition;
+            mouseDrawPos.Y = -mouseDrawPos.Y;
+            GUI.DrawLine(spriteBatch, mouseDrawPos - new Vector2(0, 5), mouseDrawPos + new Vector2(0, 5), Color.Red, 0, 10);
+
+            Vector2 closestItemPos = closestItem != null ? closestItem.DrawPosition : Vector2.Zero;
+            closestItemPos.Y = -closestItemPos.Y;
+            GUI.DrawLine(spriteBatch, closestItemPos - new Vector2(0, 5), closestItemPos + new Vector2(0, 5), Color.Lime, 0, 10);*/
+
+            if (this == controlled || GUI.DisableHUD) return;
+
+            Vector2 pos = DrawPosition;
+            pos.Y = -pos.Y;
+
+            if (speechBubbleTimer > 0.0f)
+            {
+                GUI.SpeechBubbleIcon.Draw(spriteBatch, pos - Vector2.UnitY * 100.0f,
+                    speechBubbleColor * Math.Min(speechBubbleTimer, 1.0f), 0.0f,
+                    Math.Min((float)speechBubbleTimer, 1.0f));
+            }
+
+            if (this == controlled) return;
+
+            if (info != null)
+            {
+                Vector2 namePos = new Vector2(pos.X, pos.Y - 110.0f - (5.0f / cam.Zoom)) - GUI.Font.MeasureString(Info.Name) * 0.5f / cam.Zoom;
+                Color nameColor = Color.White;
+
+                if (Character.Controlled != null && TeamID != Character.Controlled.TeamID)
+                {
+                    nameColor = Color.Red;
+                }
+                GUI.Font.DrawString(spriteBatch, Info.Name, namePos + new Vector2(1.0f / cam.Zoom, 1.0f / cam.Zoom), Color.Black, 0.0f, Vector2.Zero, 1.0f / cam.Zoom, SpriteEffects.None, 0.001f);
+                GUI.Font.DrawString(spriteBatch, Info.Name, namePos, nameColor, 0.0f, Vector2.Zero, 1.0f / cam.Zoom, SpriteEffects.None, 0.0f);
+
+                if (GameMain.DebugDraw)
+                {
+                    GUI.Font.DrawString(spriteBatch, ID.ToString(), namePos - new Vector2(0.0f, 20.0f), Color.White);
+                }
+            }
+
+            if (isDead) return;
+
+            if (health < maxHealth * 0.98f)
+            {
+                Vector2 healthBarPos = new Vector2(pos.X - 50, DrawPosition.Y + 100.0f);
+
+                GUI.DrawProgressBar(spriteBatch, healthBarPos, new Vector2(100.0f, 15.0f), health / maxHealth, Color.Lerp(Color.Red, Color.Green, health / maxHealth) * 0.8f);
+            }
+        }
+
+        /// <summary>
+        /// Creates a progress bar that's "linked" to the specified object (or updates an existing one if there's one already linked to the object)
+        /// The progress bar will automatically fade out after 1 sec if the method hasn't been called during that time
+        /// </summary>
+        public HUDProgressBar UpdateHUDProgressBar(object linkedObject, Vector2 worldPosition, float progress, Color emptyColor, Color fullColor)
+        {
+            if (controlled != this) return null;
+
+            HUDProgressBar progressBar = null;
+            if (!hudProgressBars.TryGetValue(linkedObject, out progressBar))
+            {
+                progressBar = new HUDProgressBar(worldPosition, Submarine, emptyColor, fullColor);
+                hudProgressBars.Add(linkedObject, progressBar);
+            }
+
+            progressBar.WorldPosition = worldPosition;
+            progressBar.FadeTimer = Math.Max(progressBar.FadeTimer, 1.0f);
+            progressBar.Progress = progress;
+
+            return progressBar;
+        }
+
+        public void PlaySound(CharacterSound.SoundType soundType)
+        {
+            if (sounds == null || sounds.Count == 0) return;
+
+            var matchingSounds = sounds.FindAll(s => s.Type == soundType);
+            if (matchingSounds.Count == 0) return;
+
+            var selectedSound = matchingSounds[Rand.Int(matchingSounds.Count)];
+            selectedSound.Sound.Play(1.0f, selectedSound.Range, AnimController.WorldPosition);
+        }
+
+        partial void ImplodeFX()
+        {
+            Vector2 centerOfMass = AnimController.GetCenterOfMass();
+
+            SoundPlayer.PlaySound("implode", 1.0f, 150.0f, WorldPosition);
+
+            for (int i = 0; i < 10; i++)
+            {
+                Particle p = GameMain.ParticleManager.CreateParticle("waterblood",
+                    ConvertUnits.ToDisplayUnits(centerOfMass) + Rand.Vector(5.0f),
+                    Rand.Vector(10.0f));
+                if (p != null) p.Size *= 2.0f;
+
+                GameMain.ParticleManager.CreateParticle("bubbles",
+                    ConvertUnits.ToDisplayUnits(centerOfMass) + Rand.Vector(5.0f),
+                    new Vector2(Rand.Range(-50f, 50f), Rand.Range(-100f, 50f)));
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/CharacterHUD.cs

@@ -0,0 +1,339 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using Barotrauma.Items.Components;
+
+namespace Barotrauma
+{
+    class CharacterHUD
+    {
+        private static Sprite statusIcons;
+
+        private static Sprite noiseOverlay, damageOverlay;
+
+        private static GUIButton cprButton;
+
+        private static GUIButton suicideButton;
+
+        private static GUIProgressBar drowningBar, healthBar;
+
+        public static float damageOverlayTimer { get; private set; }
+
+        public static void Reset()
+        {
+            damageOverlayTimer = 0.0f;
+        }
+
+        public static void TakeDamage(float amount)
+        {
+            healthBar.Flash();
+
+            damageOverlayTimer = MathHelper.Clamp(amount * 0.1f, 0.2f, 5.0f);
+        }
+
+        public static void AddToGUIUpdateList(Character character)
+        {
+            if (GUI.DisableHUD) return;
+
+            if (cprButton != null && cprButton.Visible) cprButton.AddToGUIUpdateList();
+
+            if (suicideButton != null && suicideButton.Visible) suicideButton.AddToGUIUpdateList();
+            
+            if (!character.IsUnconscious && character.Stun <= 0.0f)
+            {
+
+                if (character.Inventory != null)
+                {
+                    for (int i = 0; i < character.Inventory.Items.Length - 1; i++)
+                    {
+                        var item = character.Inventory.Items[i];
+                        if (item == null || CharacterInventory.limbSlots[i] == InvSlotType.Any) continue;
+
+                        foreach (ItemComponent ic in item.components)
+                        {
+                            if (ic.DrawHudWhenEquipped) ic.AddToGUIUpdateList();
+                        }
+                    }
+                }
+            }
+        }
+
+        public static void Update(float deltaTime, Character character)
+        {
+            if (drowningBar != null)
+            {
+                drowningBar.Update(deltaTime);
+                if (character.Oxygen < 10.0f) drowningBar.Flash();
+            }
+            if (healthBar != null) healthBar.Update(deltaTime);
+
+            if (cprButton != null && cprButton.Visible) cprButton.Update(deltaTime);
+
+            if (suicideButton != null && suicideButton.Visible) suicideButton.Update(deltaTime);
+
+            if (damageOverlayTimer > 0.0f) damageOverlayTimer -= deltaTime;
+
+            if (!character.IsUnconscious && character.Stun <= 0.0f)
+            {
+
+                if (character.Inventory != null)
+                {
+                    if (!character.LockHands && character.Stun >= -0.1f)
+                    {
+                        character.Inventory.Update(deltaTime);
+                    }
+
+                    for (int i = 0; i < character.Inventory.Items.Length - 1; i++)
+                    {
+                        var item = character.Inventory.Items[i];
+                        if (item == null || CharacterInventory.limbSlots[i] == InvSlotType.Any) continue;
+
+                        foreach (ItemComponent ic in item.components)
+                        {
+                            if (ic.DrawHudWhenEquipped) ic.UpdateHUD(character);
+                        }
+                    }
+                }
+
+                if (character.SelectedCharacter != null && character.SelectedCharacter.Inventory != null)
+                {
+                    character.SelectedCharacter.Inventory.Update(deltaTime);
+                }
+            }
+        }
+
+        public static void Draw(SpriteBatch spriteBatch, Character character, Camera cam)
+        {
+            if (statusIcons == null)
+            {
+                statusIcons = new Sprite("Content/UI/statusIcons.png", Vector2.Zero);
+            }
+
+            if (noiseOverlay == null)
+            {
+                noiseOverlay = new Sprite("Content/UI/noise.png", Vector2.Zero);
+            }
+
+            if (damageOverlay == null)
+            {
+                damageOverlay = new Sprite("Content/UI/damageOverlay.png", Vector2.Zero);
+            }
+
+            if (GUI.DisableHUD) return;
+
+            if (character.Inventory != null)
+            {
+                for (int i = 0; i < character.Inventory.Items.Length - 1; i++)
+                {
+                    var item = character.Inventory.Items[i];
+                    if (item == null || CharacterInventory.limbSlots[i] == InvSlotType.Any) continue;
+
+                    foreach (ItemComponent ic in item.components)
+                    {
+                        if (ic.DrawHudWhenEquipped) ic.DrawHUD(spriteBatch, character);
+                    }
+                }
+            }
+
+            DrawStatusIcons(spriteBatch, character);
+
+            if (!character.IsUnconscious && character.Stun <= 0.0f)
+            {
+                if (character.Inventory != null && !character.LockHands && character.Stun >= -0.1f)
+                {
+                    character.Inventory.DrawOffset = Vector2.Zero;
+                    character.Inventory.DrawOwn(spriteBatch);
+                }
+
+                if (character.SelectedCharacter != null && character.SelectedCharacter.Inventory != null)
+                {
+                    character.SelectedCharacter.Inventory.DrawOffset = new Vector2(320.0f, 0.0f);
+                    character.SelectedCharacter.Inventory.DrawOwn(spriteBatch);
+
+                    if (cprButton == null)
+                    {
+                        cprButton = new GUIButton(
+                            new Rectangle(character.SelectedCharacter.Inventory.SlotPositions[0].ToPoint() + new Point(320, -30), new Point(130, 20)), "Perform CPR", "");
+
+                        cprButton.OnClicked = (button, userData) =>
+                        {
+                            if (Character.Controlled == null || Character.Controlled.SelectedCharacter == null) return false;
+
+                            Character.Controlled.AnimController.Anim = (Character.Controlled.AnimController.Anim == AnimController.Animation.CPR) ?
+                                AnimController.Animation.None : AnimController.Animation.CPR;
+
+                            foreach (Limb limb in Character.Controlled.SelectedCharacter.AnimController.Limbs)
+                            {
+                                limb.pullJoint.Enabled = false;
+                            }
+                            
+                            if (GameMain.Client != null)
+                            {
+                                GameMain.Client.CreateEntityEvent(Character.Controlled, new object[] { NetEntityEvent.Type.Repair });
+                            }
+                            
+                            return true;
+                        };
+                    }
+
+                    //cprButton.Visible = character.GetSkillLevel("Medical") > 20.0f;
+
+                    if (cprButton.Visible) cprButton.Draw(spriteBatch);
+                }
+
+                if (character.ClosestCharacter != null && character.ClosestCharacter.CanBeSelected)
+                {
+                    Vector2 startPos = character.DrawPosition + (character.ClosestCharacter.DrawPosition - character.DrawPosition) * 0.7f;
+                    startPos = cam.WorldToScreen(startPos);
+
+                    Vector2 textPos = startPos;
+                    textPos -= new Vector2(GUI.Font.MeasureString(character.ClosestCharacter.Info.Name).X / 2, 20);
+
+                    GUI.DrawString(spriteBatch, textPos, character.ClosestCharacter.Info.Name, Color.White, Color.Black, 2);
+                }
+                else if (character.SelectedCharacter == null && character.ClosestItem != null && character.SelectedConstruction == null)
+                {
+                    var hudTexts = character.ClosestItem.GetHUDTexts(character);
+
+                    Vector2 startPos = new Vector2((int)(GameMain.GraphicsWidth / 2.0f), GameMain.GraphicsHeight);
+                    startPos.Y -= 50 + hudTexts.Count * 25;
+
+                    Vector2 textPos = startPos;
+                    textPos -= new Vector2((int)GUI.Font.MeasureString(character.ClosestItem.Name).X / 2, 20);
+
+                    GUI.DrawString(spriteBatch, textPos, character.ClosestItem.Name, Color.White, Color.Black * 0.7f, 2);
+
+                    textPos.Y += 30.0f;
+                    foreach (ColoredText coloredText in hudTexts)
+                    {
+                        textPos.X = (int)(startPos.X - GUI.SmallFont.MeasureString(coloredText.Text).X / 2);
+
+                        GUI.DrawString(spriteBatch, textPos, coloredText.Text, coloredText.Color, Color.Black * 0.7f, 2, GUI.SmallFont);
+
+                        textPos.Y += 25;
+                    }
+                }
+                
+                foreach (HUDProgressBar progressBar in character.HUDProgressBars.Values)
+                {
+                    progressBar.Draw(spriteBatch, cam);
+                }
+            }
+
+            if (Screen.Selected == GameMain.EditMapScreen) return;
+
+            if (character.IsUnconscious || (character.Oxygen < 80.0f && !character.IsDead))
+            {
+                Vector2 offset = Rand.Vector(noiseOverlay.size.X);
+                offset.X = Math.Abs(offset.X);
+                offset.Y = Math.Abs(offset.Y);
+
+                float alpha = character.IsUnconscious ? 1.0f : Math.Min((80.0f - character.Oxygen)/50.0f, 0.8f);
+
+                noiseOverlay.DrawTiled(spriteBatch, Vector2.Zero - offset, new Vector2(GameMain.GraphicsWidth, GameMain.GraphicsHeight) + offset,
+                    Vector2.Zero,
+                    Color.White * alpha);
+
+            }
+            else
+            {
+                if (suicideButton != null) suicideButton.Visible = false;
+            }
+
+            if (damageOverlayTimer>0.0f)
+            {
+                damageOverlay.Draw(spriteBatch, Vector2.Zero, Color.White * damageOverlayTimer, Vector2.Zero, 0.0f,
+                    new Vector2(GameMain.GraphicsWidth / damageOverlay.size.X, GameMain.GraphicsHeight / damageOverlay.size.Y));
+            }
+
+            if (character.IsUnconscious && !character.IsDead)
+            {
+                if (suicideButton == null)
+                {
+                    suicideButton = new GUIButton(
+                        new Rectangle(new Point(GameMain.GraphicsWidth / 2 - 60, 20), new Point(120, 20)), "Give in", "");
+
+                    
+                    suicideButton.ToolTip = GameMain.NetworkMember == null ?
+                        "The character can no longer be revived if you give in." :
+                        "Let go of your character and enter spectator mode (other players will no longer be able to revive you)";
+
+                    suicideButton.OnClicked = (button, userData) =>
+                    {
+                        GUIComponent.ForceMouseOn(null);
+                        if (Character.Controlled != null)
+                        {
+                            if (GameMain.Client != null)
+                            {
+                                GameMain.Client.CreateEntityEvent(Character.Controlled, new object[] { NetEntityEvent.Type.Status });
+                            }
+                            else
+                            {
+                                Character.Controlled.Kill(Character.Controlled.CauseOfDeath);
+                                Character.Controlled = null;
+                            }
+                        }
+                        return true;
+                    };
+                }
+
+                suicideButton.Visible = true;
+                suicideButton.Draw(spriteBatch);                
+            }
+        }
+
+        private static void DrawStatusIcons(SpriteBatch spriteBatch, Character character)
+        {
+            if (GameMain.DebugDraw)
+            {
+                GUI.DrawString(spriteBatch, new Vector2(30, GameMain.GraphicsHeight - 260), "Stun: "+character.Stun, Color.White);
+            }
+
+            if (drowningBar == null)
+            {
+                int width = 100, height = 20;
+
+                drowningBar = new GUIProgressBar(new Rectangle(30, GameMain.GraphicsHeight - 200, width, height), Color.Blue, "", 1.0f, Alignment.TopLeft);
+                new GUIImage(new Rectangle(-27, -7, 20, 20), new Rectangle(17, 0, 20, 24), statusIcons, Alignment.TopLeft, drowningBar);
+
+                healthBar = new GUIProgressBar(new Rectangle(30, GameMain.GraphicsHeight - 230, width, height), Color.Red, "", 1.0f, Alignment.TopLeft);
+                new GUIImage(new Rectangle(-26, -7, 20, 20), new Rectangle(0, 0, 13, 24), statusIcons, Alignment.TopLeft, healthBar);
+            }
+
+            drowningBar.BarSize = character.Oxygen / 100.0f;
+            if (drowningBar.BarSize < 0.99f)
+            {
+                drowningBar.Draw(spriteBatch);
+            }
+
+            healthBar.BarSize = character.Health / character.MaxHealth;
+            if (healthBar.BarSize < 1.0f)
+            {
+                healthBar.Draw(spriteBatch);
+            }
+
+            float bloodDropCount = character.Bleeding;
+            bloodDropCount = MathHelper.Clamp(bloodDropCount, 0.0f, 5.0f);
+            for (int i = 0; i < Math.Ceiling(bloodDropCount); i++)
+            {
+                float alpha = MathHelper.Clamp(bloodDropCount-i, 0.2f, 1.0f);
+                spriteBatch.Draw(statusIcons.Texture, new Vector2(25.0f + 20 * i, healthBar.Rect.Y - 20.0f), new Rectangle(39, 3, 15, 19), Color.White * alpha);
+            }
+
+            float pressureFactor = (character.AnimController.CurrentHull == null) ?
+                100.0f : Math.Min(character.AnimController.CurrentHull.LethalPressure,100.0f);
+            if (character.PressureProtection > 0.0f) pressureFactor = 0.0f;
+
+            if (pressureFactor>0.0f)
+            {
+                float indicatorAlpha = ((float)Math.Sin(character.PressureTimer * 0.1f) + 1.0f) * 0.5f;
+
+                indicatorAlpha = MathHelper.Clamp(indicatorAlpha, 0.1f, pressureFactor/100.0f);
+
+                spriteBatch.Draw(statusIcons.Texture, new Vector2(10.0f, healthBar.Rect.Y - 60.0f), new Rectangle(0, 24, 24, 25), Color.White * indicatorAlpha);
+            
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/CharacterInfo.cs

@@ -0,0 +1,75 @@
+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
+{
+    partial class CharacterInfo
+    {
+
+        public GUIFrame CreateInfoFrame(Rectangle rect)
+        {
+            GUIFrame frame = new GUIFrame(rect, Color.Transparent);
+            frame.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+
+            return CreateInfoFrame(frame);
+        }
+
+        public GUIFrame CreateInfoFrame(GUIFrame frame)
+        {
+            new GUIImage(new Rectangle(0, 0, 30, 30), HeadSprite, Alignment.TopLeft, frame);
+
+            ScalableFont font = frame.Rect.Width < 280 ? GUI.SmallFont : GUI.Font;
+
+            int x = 0, y = 0;
+            new GUITextBlock(new Rectangle(x + 60, y, 200, 20), Name, "", frame, font);
+            y += 20;
+
+            if (Job != null)
+            {
+                new GUITextBlock(new Rectangle(x + 60, y, 200, 20), Job.Name, "", frame, font);
+                y += 30;
+
+                var skills = Job.Skills;
+                skills.Sort((s1, s2) => -s1.Level.CompareTo(s2.Level));
+
+                new GUITextBlock(new Rectangle(x, y, 200, 20), "Skills:", "", frame, font);
+                y += 20;
+                foreach (Skill skill in skills)
+                {
+                    Color textColor = Color.White * (0.5f + skill.Level / 200.0f);
+                    new GUITextBlock(new Rectangle(x, y, 200, 20), skill.Name, Color.Transparent, textColor, Alignment.Left, "", frame).Font = font;
+                    new GUITextBlock(new Rectangle(x, y, 200, 20), skill.Level.ToString(), Color.Transparent, textColor, Alignment.Right, "", frame).Font = font;
+                    y += 20;
+                }
+            }
+
+
+            return frame;
+        }
+
+        public GUIFrame CreateCharacterFrame(GUIComponent parent, string text, object userData)
+        {
+            GUIFrame frame = new GUIFrame(new Rectangle(0, 0, 0, 40), Color.Transparent, "ListBoxElement", parent);
+            frame.UserData = userData;
+
+            GUITextBlock textBlock = new GUITextBlock(
+                new Rectangle(40, 0, 0, 25),
+                text,
+                null, null,
+                Alignment.Left, Alignment.Left,
+                "", frame, 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), HeadSprite, Alignment.Left, frame);
+
+            return frame;
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/CharacterNetworking.cs

@@ -0,0 +1,296 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    partial class Character
+    {
+               public virtual void ClientWrite(NetBuffer msg, object[] extraData = null)
+        {
+            if (GameMain.Server != null) return;
+
+            if (extraData != null)
+            {
+                switch ((NetEntityEvent.Type)extraData[0])
+                {
+                    case NetEntityEvent.Type.InventoryState:
+                        msg.WriteRangedInteger(0, 2, 0);
+                        inventory.ClientWrite(msg, extraData);
+                        break;
+                    case NetEntityEvent.Type.Repair:
+                        msg.WriteRangedInteger(0, 2, 1);
+                        msg.Write(AnimController.Anim == AnimController.Animation.CPR);
+                        break;
+                    case NetEntityEvent.Type.Status:
+                        msg.WriteRangedInteger(0, 2, 2);
+                        break;
+                }
+            }
+            else
+            {
+                msg.Write((byte)ClientNetObject.CHARACTER_INPUT);
+
+                if (memInput.Count > 60)
+                {
+                    memInput.RemoveRange(60, memInput.Count - 60);
+                }
+
+                msg.Write(LastNetworkUpdateID);
+                byte inputCount = Math.Min((byte)memInput.Count, (byte)60);
+                msg.Write(inputCount);
+                for (int i = 0; i < inputCount; i++)
+                {
+                    msg.WriteRangedInteger(0, (int)InputNetFlags.MaxVal, (int)memInput[i].states);
+                    if (memInput[i].states.HasFlag(InputNetFlags.Aim))
+                    {
+                        msg.Write(memInput[i].intAim);
+                    }
+                    if (memInput[i].states.HasFlag(InputNetFlags.Select) || memInput[i].states.HasFlag(InputNetFlags.Use))
+                    {
+                        msg.Write(memInput[i].interact);
+                    }
+                }
+            }
+            msg.WritePadBits();
+        }
+
+        public virtual void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            if (GameMain.Server != null) return;
+
+            switch (type)
+            {
+                case ServerNetObject.ENTITY_POSITION:
+                    bool facingRight = AnimController.Dir > 0.0f;
+
+                    lastRecvPositionUpdateTime = (float)NetTime.Now;
+
+                    AnimController.Frozen = false;
+                    Enabled = true;
+
+                    UInt16 networkUpdateID = 0;
+                    if (msg.ReadBoolean())
+                    {
+                        networkUpdateID = msg.ReadUInt16();
+                    }
+                    else
+                    {
+                        bool aimInput = msg.ReadBoolean();
+                        keys[(int)InputType.Aim].Held = aimInput;
+                        keys[(int)InputType.Aim].SetState(false, aimInput);
+
+                        bool useInput = msg.ReadBoolean();
+                        keys[(int)InputType.Use].Held = useInput;
+                        keys[(int)InputType.Use].SetState(false, useInput);
+
+                        bool hasAttackLimb = msg.ReadBoolean();
+                        if (hasAttackLimb)
+                        {
+                            bool attackInput = msg.ReadBoolean();
+                            keys[(int)InputType.Attack].Held = attackInput;
+                            keys[(int)InputType.Attack].SetState(false, attackInput);
+                        }
+
+                        if (aimInput)
+                        {
+                            double aimAngle = ((double)msg.ReadUInt16() / 65535.0) * 2.0 * Math.PI;
+                            cursorPosition = (ViewTarget == null ? AnimController.Collider.Position : ViewTarget.Position)
+                                + new Vector2((float)Math.Cos(aimAngle), (float)Math.Sin(aimAngle)) * 60.0f;
+
+                            TransformCursorPos();
+                        }
+                        facingRight = msg.ReadBoolean();
+                    }
+
+                    bool entitySelected = msg.ReadBoolean();
+                    Entity selectedEntity = null;
+
+                    AnimController.Animation animation = AnimController.Animation.None;
+                    if (entitySelected)
+                    {
+                        ushort entityID = msg.ReadUInt16();
+                        selectedEntity = FindEntityByID(entityID);
+                        if (selectedEntity is Character)
+                        {
+                            bool doingCpr = msg.ReadBoolean();
+                            if (doingCpr && selectedCharacter != null)
+                            {
+                                animation = AnimController.Animation.CPR;
+                            }
+                        }
+                    }
+
+                    Vector2 pos = new Vector2(
+                        msg.ReadFloat(),
+                        msg.ReadFloat());
+
+
+                    int index = 0;
+                    if (GameMain.NetworkMember.Character == this && AllowInput)
+                    {
+                        var posInfo = new CharacterStateInfo(pos, networkUpdateID, facingRight ? Direction.Right : Direction.Left, selectedEntity, animation);
+                        while (index < memState.Count && NetIdUtils.IdMoreRecent(posInfo.ID, memState[index].ID))
+                            index++;
+
+                        memState.Insert(index, posInfo);
+                    }
+                    else
+                    {
+                        var posInfo = new CharacterStateInfo(pos, sendingTime, facingRight ? Direction.Right : Direction.Left, selectedEntity, animation);
+                        while (index < memState.Count && posInfo.Timestamp > memState[index].Timestamp)
+                            index++;
+
+                        memState.Insert(index, posInfo);
+                    }
+
+                    break;
+                case ServerNetObject.ENTITY_EVENT:
+
+                    int eventType = msg.ReadRangedInteger(0, 2);
+                    switch (eventType)
+                    {
+                        case 0:
+                            inventory.ClientRead(type, msg, sendingTime);
+                            break;
+                        case 1:
+                            byte ownerID = msg.ReadByte();
+                            ResetNetState();
+                            if (ownerID == GameMain.Client.ID)
+                            {
+                                if (controlled != null)
+                                {
+                                    LastNetworkUpdateID = controlled.LastNetworkUpdateID;
+                                }
+
+                                controlled = this;
+                                IsRemotePlayer = false;
+                                GameMain.Client.Character = this;
+                            }
+                            else if (controlled == this)
+                            {
+                                controlled = null;
+                                IsRemotePlayer = ownerID > 0;
+                            }
+                            break;
+                        case 2:
+                            ReadStatus(msg);
+                            break;
+                    }
+
+                    break;
+            }
+        }
+        public static Character ReadSpawnData(NetBuffer inc, bool spawn = true)
+        {
+            DebugConsole.NewMessage("READING CHARACTER SPAWN DATA", Color.Cyan);
+
+            if (GameMain.Server != null) return null;
+
+            bool noInfo = inc.ReadBoolean();
+            ushort id = inc.ReadUInt16();
+            string configPath = inc.ReadString();
+
+            Vector2 position = new Vector2(inc.ReadFloat(), inc.ReadFloat());
+
+            bool enabled = inc.ReadBoolean();
+
+            DebugConsole.Log("Received spawn data for " + configPath);
+
+            Character character = null;
+            if (noInfo)
+            {
+                if (!spawn) return null;
+
+                character = Character.Create(configPath, position, null, true);
+                character.ID = id;
+            }
+            else
+            {
+                bool hasOwner = inc.ReadBoolean();
+                int ownerId = hasOwner ? inc.ReadByte() : -1;
+
+
+                string newName = inc.ReadString();
+                byte teamID = inc.ReadByte();
+
+                bool hasAi = inc.ReadBoolean();
+                bool isFemale = inc.ReadBoolean();
+                int headSpriteID = inc.ReadByte();
+                string jobName = inc.ReadString();
+
+                JobPrefab jobPrefab = null;
+                Dictionary<string, int> skillLevels = new Dictionary<string, int>();
+                if (!string.IsNullOrEmpty(jobName))
+                {
+                    jobPrefab = JobPrefab.List.Find(jp => jp.Name == jobName);
+                    int skillCount = inc.ReadByte();
+                    for (int i = 0; i < skillCount; i++)
+                    {
+                        string skillName = inc.ReadString();
+                        int skillLevel = inc.ReadRangedInteger(0, 100);
+
+                        skillLevels.Add(skillName, skillLevel);
+                    }
+                }
+
+                if (!spawn) return null;
+
+
+                CharacterInfo ch = new CharacterInfo(configPath, newName, isFemale ? Gender.Female : Gender.Male, jobPrefab);
+                ch.HeadSpriteId = headSpriteID;
+
+                System.Diagnostics.Debug.Assert(skillLevels.Count == ch.Job.Skills.Count);
+                if (ch.Job != null)
+                {
+                    foreach (KeyValuePair<string, int> skill in skillLevels)
+                    {
+                        Skill matchingSkill = ch.Job.Skills.Find(s => s.Name == skill.Key);
+                        if (matchingSkill == null)
+                        {
+                            DebugConsole.ThrowError("Skill \"" + skill.Key + "\" not found in character \"" + newName + "\"");
+                            continue;
+                        }
+                        matchingSkill.Level = skill.Value;
+                    }
+                }
+
+                character = Create(configPath, position, ch, GameMain.Client.ID != ownerId, hasAi);
+                character.ID = id;
+                character.TeamID = teamID;
+
+                if (GameMain.Client.ID == ownerId)
+                {
+                    GameMain.Client.Character = character;
+                    Controlled = character;
+
+                    GameMain.LightManager.LosEnabled = true;
+
+                    character.memInput.Clear();
+                    character.memState.Clear();
+                    character.memLocalState.Clear();
+                }
+                else
+                {
+                    var ownerClient = GameMain.Client.ConnectedClients.Find(c => c.ID == ownerId);
+                    if (ownerClient != null)
+                    {
+                        ownerClient.Character = character;
+                    }
+                }
+
+                if (configPath == Character.HumanConfigFile)
+                {
+                    GameMain.GameSession.CrewManager.characters.Add(character);
+                }
+            }
+
+            character.Enabled = Controlled == character || enabled;
+
+            return character;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/CharacterSound.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class CharacterSound
+    {
+        public enum SoundType
+        {
+            Idle, Attack, Die
+        }
+
+        public readonly Sound Sound;
+
+        public readonly SoundType Type;
+
+        public readonly float Range;
+
+        public CharacterSound(XElement element)
+        {
+            Sound = Sound.Load(element.Attribute("file").Value);
+            Range = ToolBox.GetAttributeFloat(element, "range", 1000.0f);
+
+            Enum.TryParse<SoundType>(ToolBox.GetAttributeString(element, "state", "Idle"), true, out Type);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/HUDProgressBar.cs

@@ -0,0 +1,87 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+
+namespace Barotrauma
+{
+    class HUDProgressBar
+    {
+        private float progress;
+
+        public float Progress
+        {
+            get { return progress; }
+            set { progress = MathHelper.Clamp(value, 0.0f, 1.0f); }
+        }
+
+        public float FadeTimer;
+
+        private Color fullColor, emptyColor;
+
+        private Vector2 worldPosition;
+
+        public Vector2 WorldPosition
+        {
+            get
+            {
+                return worldPosition;
+            }
+            set
+            {
+                worldPosition = value;
+                if (parentSub != null)
+                {                 
+                    worldPosition -= parentSub.DrawPosition;
+                }
+            }
+        }
+
+        public Vector2 Size;
+
+        private Submarine parentSub;
+
+        public HUDProgressBar(Vector2 worldPosition, Submarine parentSubmarine = null)
+            : this(worldPosition, parentSubmarine, Color.Red, Color.Green)
+        {
+        }
+
+        public HUDProgressBar(Vector2 worldPosition, Submarine parentSubmarine, Color emptyColor, Color fullColor)
+        {
+            this.emptyColor = emptyColor;
+            this.fullColor = fullColor;
+            
+            parentSub = parentSubmarine;
+
+            WorldPosition = worldPosition;
+
+            Size = new Vector2(100.0f, 20.0f);
+
+            FadeTimer = 1.0f;
+        }
+
+        public void Update(float deltatime)
+        {
+            FadeTimer -= deltatime;
+        }
+
+        public void Draw(SpriteBatch spriteBatch, Camera cam)
+        {
+            float a = Math.Min(FadeTimer, 1.0f);
+
+            Vector2 pos = new Vector2(WorldPosition.X - Size.X / 2, WorldPosition.Y + Size.Y / 2);
+
+            if (parentSub != null)
+            {
+                pos += parentSub.DrawPosition;
+            }
+
+            pos = cam.WorldToScreen(pos);
+            
+            GUI.DrawProgressBar(spriteBatch,
+                new Vector2(pos.X, -pos.Y),
+                Size, progress, 
+                Color.Lerp(emptyColor, fullColor, progress) * a,
+                Color.White * a * 0.8f);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/HuskInfection.cs

@@ -0,0 +1,36 @@
+using Microsoft.Xna.Framework;
+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 HuskInfection
+    {
+        partial void UpdateProjSpecific(float prevTimer, Character character)
+        {
+            if (IncubationTimer < 0.5f)
+            {
+                if (prevTimer % 0.1f > 0.05f && IncubationTimer % 0.1f < 0.05f)
+                {
+                    GUI.AddMessage(InfoTextManager.GetInfoText("HuskDormant"), Color.Red, 4.0f);
+                }
+            }
+            else if (IncubationTimer < 1.0f)
+            {
+                if (state == InfectionState.Dormant && Character.Controlled == character)
+                {
+                    new GUIMessageBox("", InfoTextManager.GetInfoText("HuskCantSpeak"));
+                }
+            }
+            else
+            {
+                if (Character.Controlled == character) new GUIMessageBox("", InfoTextManager.GetInfoText("HuskActivate"));
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/Jobs/JobPrefab.cs

@@ -0,0 +1,57 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Xml.Linq;
+using System.Linq;
+
+namespace Barotrauma
+{
+    partial class JobPrefab
+    {
+        public GUIFrame CreateInfoFrame()
+        {
+            int width = 500, height = 400;
+
+            GUIFrame backFrame = new GUIFrame(Rectangle.Empty, Color.Black * 0.5f);
+            backFrame.Padding = Vector4.Zero;
+
+            GUIFrame frame = new GUIFrame(new Rectangle(GameMain.GraphicsWidth / 2 - width / 2, GameMain.GraphicsHeight / 2 - height / 2, width, height), "", backFrame);
+            frame.Padding = new Vector4(30.0f, 30.0f, 30.0f, 30.0f);
+
+            new GUITextBlock(new Rectangle(0, 0, 100, 20), Name, "", Alignment.TopLeft, Alignment.TopLeft, frame, false, GUI.LargeFont);
+
+            var descriptionBlock = new GUITextBlock(new Rectangle(0, 40, 0, 0), Description, "", Alignment.TopLeft, Alignment.TopLeft, frame, true, GUI.SmallFont);
+
+            new GUITextBlock(new Rectangle(0, 40 + descriptionBlock.Rect.Height + 20, 100, 20), "Skills: ", "", Alignment.TopLeft, Alignment.TopLeft, frame, false, GUI.LargeFont);
+
+            int y = 40 + descriptionBlock.Rect.Height + 50;
+            foreach (SkillPrefab skill in Skills)
+            {
+                string skillDescription = Skill.GetLevelName((int)skill.LevelRange.X);
+                string skillDescription2 = Skill.GetLevelName((int)skill.LevelRange.Y);
+
+                if (skillDescription2 != skillDescription)
+                {
+                    skillDescription += "/" + skillDescription2;
+                }
+                new GUITextBlock(new Rectangle(0, y, 100, 20),
+                    "   - " + skill.Name + ": " + skillDescription, "", Alignment.TopLeft, Alignment.TopLeft, frame, false, GUI.SmallFont);
+
+                y += 20;
+            }
+
+            new GUITextBlock(new Rectangle(250, 40 + descriptionBlock.Rect.Height + 20, 0, 20), "Items: ", "", Alignment.TopLeft, Alignment.TopLeft, frame, false, GUI.LargeFont);
+
+            y = 40 + descriptionBlock.Rect.Height + 50;
+            foreach (string itemName in ItemNames)
+            {
+                new GUITextBlock(new Rectangle(250, y, 100, 20),
+                "   - " + itemName, "", Alignment.TopLeft, Alignment.TopLeft, frame, false, GUI.SmallFont);
+
+                y += 20;
+            }
+
+            return backFrame;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Characters/Limb.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Joints;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Items.Components;
+using System.Collections.Generic;
+using Barotrauma.Lights;
+using System.Linq;
+using System.IO;
+
+namespace Barotrauma
+{
+    partial class Limb
+    {
+        public LightSource LightSource
+        {
+            get;
+            private set;
+        }
+
+        Sound hitSound;
+
+        public Sound HitSound
+        {
+            get { return hitSound; }
+        }
+
+        partial void InitProjSpecific(XElement element)
+        {
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "lightsource":
+                        LightSource = new LightSource(subElement);
+                        break;
+                    case "sound":
+                        hitSound = Sound.Load(ToolBox.GetAttributeString(subElement, "file", ""));
+                        break;
+                }
+            }
+        }
+
+        partial void UpdateProjSpecific()
+        {
+            if (LightSource != null)
+            {
+                LightSource.ParentSub = body.Submarine;
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            float brightness = 1.0f - (burnt / 100.0f) * 0.5f;
+            Color color = new Color(brightness, brightness, brightness);
+
+            if (isSevered)
+            {
+                if (severedFadeOutTimer > SeveredFadeOutTime)
+                {
+                    return;
+                }
+                else if (severedFadeOutTimer > SeveredFadeOutTime - 1.0f)
+                {
+                    color *= SeveredFadeOutTime - severedFadeOutTimer;
+                }
+            }
+
+            body.Dir = Dir;
+
+            bool hideLimb = wearingItems.Any(w => w != null && w.HideLimb);
+            if (!hideLimb)
+            {
+                body.Draw(spriteBatch, sprite, color, null, scale);
+            }
+            else
+            {
+                body.UpdateDrawPosition();
+            }
+
+            if (LightSource != null)
+            {
+                LightSource.Position = body.DrawPosition;
+            }
+
+            foreach (WearableSprite wearable in wearingItems)
+            {
+                SpriteEffects spriteEffect = (dir == Direction.Right) ? SpriteEffects.None : SpriteEffects.FlipHorizontally;
+
+                Vector2 origin = wearable.Sprite.Origin;
+                if (body.Dir == -1.0f) origin.X = wearable.Sprite.SourceRect.Width - origin.X;
+
+                float depth = sprite.Depth - 0.000001f;
+
+                if (wearable.DepthLimb != LimbType.None)
+                {
+                    Limb depthLimb = character.AnimController.GetLimb(wearable.DepthLimb);
+                    if (depthLimb != null)
+                    {
+                        depth = depthLimb.sprite.Depth - 0.000001f;
+                    }
+                }
+
+                wearable.Sprite.Draw(spriteBatch,
+                    new Vector2(body.DrawPosition.X, -body.DrawPosition.Y),
+                    color, origin,
+                    -body.DrawRotation,
+                    scale, spriteEffect, depth);
+            }
+
+            if (damage > 0.0f && damagedSprite != null && !hideLimb)
+            {
+                SpriteEffects spriteEffect = (dir == Direction.Right) ? SpriteEffects.None : SpriteEffects.FlipHorizontally;
+
+                float depth = sprite.Depth - 0.0000015f;
+
+                damagedSprite.Draw(spriteBatch,
+                    new Vector2(body.DrawPosition.X, -body.DrawPosition.Y),
+                    color * Math.Min(damage / 50.0f, 1.0f), sprite.Origin,
+                    -body.DrawRotation,
+                    1.0f, spriteEffect, depth);
+            }
+
+            if (!GameMain.DebugDraw) return;
+
+            if (pullJoint != null)
+            {
+                Vector2 pos = ConvertUnits.ToDisplayUnits(pullJoint.WorldAnchorB);
+                GUI.DrawRectangle(spriteBatch, new Rectangle((int)pos.X, (int)-pos.Y, 5, 5), Color.Red, true);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/DebugConsole.cs

@@ -0,0 +1,491 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Barotrauma.Networking;
+using Barotrauma.Items.Components;
+using System.Text;
+using FarseerPhysics;
+
+namespace Barotrauma
+{
+    static partial class DebugConsole
+    {
+        static bool isOpen;
+
+        //used for keeping track of the message entered when pressing up/down
+        static int selectedIndex;
+
+        public static bool IsOpen
+        {
+            get
+            {
+                return isOpen;
+            }
+        }
+
+        static GUIFrame frame;
+        static GUIListBox listBox;
+        static GUITextBox textBox;
+        
+        public static void Init(GameWindow window)
+        {
+            int x = 20, y = 20;
+            int width = 800, height = 500;
+
+            frame = new GUIFrame(new Rectangle(x, y, width, height), new Color(0.4f, 0.4f, 0.4f, 0.8f));
+            frame.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+
+            listBox = new GUIListBox(new Rectangle(0, 0, 0, frame.Rect.Height - 40), Color.Black, "", frame);
+            //listBox.Color = Color.Black * 0.7f;
+
+            textBox = new GUITextBox(new Rectangle(0, 0, 0, 20), Color.Black, Color.White, Alignment.BottomLeft, Alignment.Left, "", frame);
+            //textBox.Color = Color.Black * 0.7f;
+
+            //messages already added before initialization -> add them to the listbox
+            List<ColoredText> unInitializedMessages = new List<ColoredText>(Messages);
+            Messages.Clear();
+
+            foreach (ColoredText msg in unInitializedMessages)
+            {
+                NewMessage(msg.Text, msg.Color);
+            }
+
+            NewMessage("Press F3 to open/close the debug console", Color.Cyan);
+            NewMessage("Enter \"help\" for a list of available console commands", Color.Cyan);
+
+        }
+
+        public static void AddToGUIUpdateList()
+        {
+            if (isOpen)
+            {
+                frame.AddToGUIUpdateList();
+            }
+        }
+
+        public static void Update(GameMain game, float deltaTime)
+        {
+            if (PlayerInput.KeyHit(Keys.F3))
+            {
+                isOpen = !isOpen;
+                if (isOpen)
+                {
+                    textBox.Select();
+                    AddToGUIUpdateList();
+                }
+                else
+                {
+                    GUIComponent.ForceMouseOn(null);
+                    textBox.Deselect();
+                }
+
+                //keyboardDispatcher.Subscriber = (isOpen) ? textBox : null;
+            }
+
+            if (isOpen)
+            {
+                frame.Update(deltaTime);
+
+                Character.DisableControls = true;
+
+                if (PlayerInput.KeyHit(Keys.Up))
+                {
+                    SelectMessage(-1);
+                }
+                else if (PlayerInput.KeyHit(Keys.Down))
+                {
+                    SelectMessage(1);
+                }
+
+                //textBox.Update(deltaTime);
+
+                if (PlayerInput.KeyDown(Keys.Enter) && textBox.Text != "")
+                {
+                    ExecuteCommand(textBox.Text, game);
+                    textBox.Text = "";
+
+                    //selectedIndex = messages.Count;
+                }
+            }
+        }
+
+        private static void SelectMessage(int direction)
+        {
+            int messageCount = listBox.children.Count;
+            if (messageCount == 0) return;
+
+            direction = Math.Min(Math.Max(-1, direction), 1);
+
+            selectedIndex += direction;
+            if (selectedIndex < 0) selectedIndex = messageCount - 1;
+            selectedIndex = selectedIndex % messageCount;
+
+            textBox.Text = (listBox.children[selectedIndex] as GUITextBlock).Text;
+        }
+
+        public static void Draw(SpriteBatch spriteBatch)
+        {
+            if (!isOpen) return;
+
+            frame.Draw(spriteBatch);
+        }
+
+        private static bool IsCommandPermitted(string command, GameClient client)
+        {
+            switch (command)
+            {
+                case "kick":
+                    return client.HasPermission(ClientPermissions.Kick);
+                case "ban":
+                case "banip":
+                    return client.HasPermission(ClientPermissions.Ban);
+                case "netstats":
+                case "help":
+                case "dumpids":
+                case "admin":
+                case "entitylist":
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        private static bool ExecProjSpecific(string[] commands)
+        {
+            switch (commands[0].ToLowerInvariant())
+            {
+                case "startclient":
+                    if (commands.Length == 1) return true;
+                    if (GameMain.Client == null)
+                    {
+                        GameMain.NetworkMember = new GameClient("Name");
+                        GameMain.Client.ConnectToServer(commands[1]);
+                    }
+                    break;
+                case "mainmenuscreen":
+                case "mainmenu":
+                case "menu":
+                    GameMain.GameSession = null;
+
+                    List<Character> characters = new List<Character>(Character.CharacterList);
+                    foreach (Character c in characters)
+                    {
+                        c.Remove();
+                    }
+
+                    GameMain.MainMenuScreen.Select();
+                    break;
+                case "gamescreen":
+                case "game":
+                    GameMain.GameScreen.Select();
+                    break;
+                case "editmapscreen":
+                case "editmap":
+                case "edit":
+                    if (commands.Length > 1)
+                    {
+                        Submarine.Load(string.Join(" ", commands.Skip(1)), true);
+                    }
+                    GameMain.EditMapScreen.Select();
+                    break;
+                case "editcharacter":
+                case "editchar":
+                    GameMain.EditCharacterScreen.Select();
+                    break;
+                case "controlcharacter":
+                case "control":
+                    {
+                        if (commands.Length < 2) break;
+
+                        var character = FindMatchingCharacter(commands, true);
+
+                        if (character != null)
+                        {
+                            Character.Controlled = character;
+                        }
+                    }
+                    break;
+                case "setclientcharacter":
+                    {
+                        if (GameMain.Server == null) break;
+
+                        int separatorIndex = Array.IndexOf(commands, ";");
+
+                        if (separatorIndex == -1 || commands.Length < 4)
+                        {
+                            ThrowError("Invalid parameters. The command should be formatted as \"setclientcharacter [client] ; [character]\"");
+                            break;
+                        }
+
+                        string[] commandsLeft = commands.Take(separatorIndex).ToArray();
+                        string[] commandsRight = commands.Skip(separatorIndex).ToArray();
+
+                        string clientName = String.Join(" ", commandsLeft.Skip(1));
+
+                        var client = GameMain.Server.ConnectedClients.Find(c => c.name == clientName);
+                        if (client == null)
+                        {
+                            ThrowError("Client \"" + clientName + "\" not found.");
+                        }
+
+                        var character = FindMatchingCharacter(commandsRight, false);
+                        GameMain.Server.SetClientCharacter(client, character);
+                    }
+                    break;
+                case "test":
+                    Submarine.Load("aegir mark ii", true);
+                    GameMain.DebugDraw = true;
+                    GameMain.LightManager.LosEnabled = false;
+                    GameMain.EditMapScreen.Select();
+                    break;
+                case "shake":
+                    GameMain.GameScreen.Cam.Shake = 10.0f;
+                    break;
+                case "losenabled":
+                case "los":
+                case "drawlos":
+                    GameMain.LightManager.LosEnabled = !GameMain.LightManager.LosEnabled;
+                    break;
+                case "lighting":
+                case "lightingenabled":
+                case "light":
+                case "lights":
+                    GameMain.LightManager.LightingEnabled = !GameMain.LightManager.LightingEnabled;
+                    break;
+                case "tutorial":
+                    TutorialMode.StartTutorial(Tutorials.TutorialType.TutorialTypes[0]);
+                    break;
+                case "editortutorial":
+                    GameMain.EditMapScreen.Select();
+                    GameMain.EditMapScreen.StartTutorial();
+                    break;
+                case "lobbyscreen":
+                case "lobby":
+                    GameMain.LobbyScreen.Select();
+                    break;
+                case "savemap":
+                case "savesub":
+                case "save":
+                    if (commands.Length < 2) break;
+
+                    if (GameMain.EditMapScreen.CharacterMode)
+                    {
+                        GameMain.EditMapScreen.ToggleCharacterMode();
+                    }
+
+                    string fileName = string.Join(" ", commands.Skip(1));
+                    if (fileName.Contains("../"))
+                    {
+                        DebugConsole.ThrowError("Illegal symbols in filename (../)");
+                        return true;
+                    }
+
+                    if (Submarine.SaveCurrent(System.IO.Path.Combine(Submarine.SavePath, fileName + ".sub")))
+                    {
+                        NewMessage("Sub saved", Color.Green);
+                        //Submarine.Loaded.First().CheckForErrors();
+                    }
+
+                    break;
+                case "loadmap":
+                case "loadsub":
+                case "load":
+                    if (commands.Length < 2) break;
+
+                    Submarine.Load(string.Join(" ", commands.Skip(1)), true);
+                    break;
+                case "cleansub":
+                    for (int i = MapEntity.mapEntityList.Count - 1; i >= 0; i--)
+                    {
+                        MapEntity me = MapEntity.mapEntityList[i];
+
+                        if (me.SimPosition.Length() > 2000.0f)
+                        {
+                            DebugConsole.NewMessage("Removed " + me.Name + " (simposition " + me.SimPosition + ")", Color.Orange);
+                            MapEntity.mapEntityList.RemoveAt(i);
+                        }
+                        else if (me.MoveWithLevel)
+                        {
+                            DebugConsole.NewMessage("Removed " + me.Name + " (MoveWithLevel==true)", Color.Orange);
+                            MapEntity.mapEntityList.RemoveAt(i);
+                        }
+                        else if (me is Item)
+                        {
+                            Item item = me as Item;
+                            var wire = item.GetComponent<Wire>();
+                            if (wire == null) continue;
+
+                            if (wire.GetNodes().Count > 0 && !wire.Connections.Any(c => c != null))
+                            {
+                                wire.Item.Drop(null);
+                                DebugConsole.NewMessage("Dropped wire (ID: " + wire.Item.ID + ") - attached on wall but no connections found", Color.Orange);
+                            }
+                        }
+
+                    }
+                    break;
+                case "messagebox":
+                    if (commands.Length < 3) break;
+                    new GUIMessageBox(commands[1], commands[2]);
+                    break;
+                case "debugdraw":
+                    GameMain.DebugDraw = !GameMain.DebugDraw;
+                    break;
+                case "disablehud":
+                case "hud":
+                    GUI.DisableHUD = !GUI.DisableHUD;
+                    GameMain.Instance.IsMouseVisible = !GameMain.Instance.IsMouseVisible;
+                    break;
+                case "followsub":
+                    Camera.FollowSub = !Camera.FollowSub;
+                    break;
+                case "drawaitargets":
+                case "showaitargets":
+                    AITarget.ShowAITargets = !AITarget.ShowAITargets;
+                    break;
+#if DEBUG
+                case "spamevents":
+                    foreach (Item item in Item.ItemList)
+                    {
+                        for (int i = 0; i<item.components.Count; i++)
+                        {
+                            if (item.components[i] is IServerSerializable)
+                            {
+                                GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.ComponentState, i });
+                            }
+                            var itemContainer = item.GetComponent<ItemContainer>();
+                            if (itemContainer != null)
+                            {
+                                GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.InventoryState });
+                            }
+
+                            GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.Status });
+
+                            item.NeedsPositionUpdate = true;
+                        }
+                    }
+
+                    foreach (Character c in Character.CharacterList)
+                    {
+                        GameMain.Server.CreateEntityEvent(c, new object[] { NetEntityEvent.Type.Status });
+                    }
+
+                    foreach (Structure wall in Structure.WallList)
+                    {
+                        GameMain.Server.CreateEntityEvent(wall);
+                    }
+                    break;
+                case "spamchatmessages":
+                    int msgCount = 1000;
+                    if (commands.Length > 1) int.TryParse(commands[1], out msgCount);
+                    int msgLength = 50;
+                    if (commands.Length > 2) int.TryParse(commands[2], out msgLength);
+
+                    for (int i = 0; i < msgCount; i++)
+                    {
+                        if (GameMain.Server != null)
+                        {
+                            GameMain.Server.SendChatMessage(ToolBox.RandomSeed(msgLength), ChatMessageType.Default);
+                        }
+                        else
+                        {
+                            GameMain.Client.SendChatMessage(ToolBox.RandomSeed(msgLength));
+                        }
+                    }
+                    break;
+#endif
+                case "cleanbuild":
+                    GameMain.Config.MusicVolume = 0.5f;
+                    GameMain.Config.SoundVolume = 0.5f;
+                    DebugConsole.NewMessage("Music and sound volume set to 0.5", Color.Green);
+
+                    GameMain.Config.GraphicsWidth = 0;
+                    GameMain.Config.GraphicsHeight = 0;
+                    GameMain.Config.WindowMode = WindowMode.Fullscreen;
+                    DebugConsole.NewMessage("Resolution set to 0 x 0 (screen resolution will be used)", Color.Green);
+                    DebugConsole.NewMessage("Fullscreen enabled", Color.Green);
+
+                    GameSettings.VerboseLogging = false;
+
+                    if (GameMain.Config.MasterServerUrl != "http://www.undertowgames.com/baromaster")
+                    {
+                        DebugConsole.ThrowError("MasterServerUrl \"" + GameMain.Config.MasterServerUrl + "\"!");
+                    }
+
+                    GameMain.Config.Save("config.xml");
+
+                    var saveFiles = System.IO.Directory.GetFiles(SaveUtil.SaveFolder);
+
+                    foreach (string saveFile in saveFiles)
+                    {
+                        System.IO.File.Delete(saveFile);
+                        DebugConsole.NewMessage("Deleted " + saveFile, Color.Green);
+                    }
+
+                    if (System.IO.Directory.Exists(System.IO.Path.Combine(SaveUtil.SaveFolder, "temp")))
+                    {
+                        System.IO.Directory.Delete(System.IO.Path.Combine(SaveUtil.SaveFolder, "temp"), true);
+                        DebugConsole.NewMessage("Deleted temp save folder", Color.Green);
+                    }
+
+                    if (System.IO.Directory.Exists(ServerLog.SavePath))
+                    {
+                        var logFiles = System.IO.Directory.GetFiles(ServerLog.SavePath);
+
+                        foreach (string logFile in logFiles)
+                        {
+                            System.IO.File.Delete(logFile);
+                            DebugConsole.NewMessage("Deleted " + logFile, Color.Green);
+                        }
+                    }
+
+                    if (System.IO.File.Exists("filelist.xml"))
+                    {
+                        System.IO.File.Delete("filelist.xml");
+                        DebugConsole.NewMessage("Deleted filelist", Color.Green);
+                    }
+
+
+                    if (System.IO.File.Exists("Submarines/TutorialSub.sub"))
+                    {
+                        System.IO.File.Delete("Submarines/TutorialSub.sub");
+
+                        DebugConsole.NewMessage("Deleted TutorialSub from the submarine folder", Color.Green);
+                    }
+
+                    if (System.IO.File.Exists(GameServer.SettingsFile))
+                    {
+                        System.IO.File.Delete(GameServer.SettingsFile);
+                        DebugConsole.NewMessage("Deleted server settings", Color.Green);
+                    }
+
+                    if (System.IO.File.Exists(GameServer.ClientPermissionsFile))
+                    {
+                        System.IO.File.Delete(GameServer.ClientPermissionsFile);
+                        DebugConsole.NewMessage("Deleted client permission file", Color.Green);
+
+                    }
+
+                    if (System.IO.File.Exists("crashreport.txt"))
+                    {
+                        System.IO.File.Delete("crashreport.txt");
+                        DebugConsole.NewMessage("Deleted crashreport.txt", Color.Green);
+                    }
+
+                    if (!System.IO.File.Exists("Content/Map/TutorialSub.sub"))
+                    {
+                        DebugConsole.ThrowError("TutorialSub.sub not found!");
+                    }
+
+                    break;
+                default:
+                    return false; //command not found
+                    break;
+            }
+            return true; //command found
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/EventInput/EventInput.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+
+namespace EventInput
+{
+#if WINDOWS
+    public class KeyboardLayout
+    {
+        const uint KLF_ACTIVATE = 1; //activate the layout
+        const int KL_NAMELENGTH = 9; // length of the keyboard buffer
+        const string LANG_EN_US = "00000409";
+        const string LANG_HE_IL = "0001101A";
+
+        [DllImport("user32.dll")]
+        private static extern long LoadKeyboardLayout(
+        string pwszKLID,  // input locale identifier
+        uint Flags       // input locale identifier options
+        );
+
+        [DllImport("user32.dll")]
+        private static extern long GetKeyboardLayoutName(
+        StringBuilder pwszKLID  //[out] string that receives the name of the locale identifier
+        );
+
+        public static string getName()
+        {
+            StringBuilder name = new StringBuilder(KL_NAMELENGTH);
+            GetKeyboardLayoutName(name);
+            return name.ToString();
+        }
+    }
+#endif
+
+    public class CharacterEventArgs : EventArgs
+    {
+        private readonly char character;
+        private readonly int lParam;
+
+        public CharacterEventArgs(char character, int lParam)
+        {
+            this.character = character;
+            this.lParam = lParam;
+        }
+
+        public char Character
+        {
+            get { return character; }
+        }
+
+        public int Param
+        {
+            get { return lParam; }
+        }
+
+        public int RepeatCount
+        {
+            get { return lParam & 0xffff; }
+        }
+
+        public bool ExtendedKey
+        {
+            get { return (lParam & (1 << 24)) > 0; }
+        }
+
+        public bool AltPressed
+        {
+            get { return (lParam & (1 << 29)) > 0; }
+        }
+
+        public bool PreviousState
+        {
+            get { return (lParam & (1 << 30)) > 0; }
+        }
+
+        public bool TransitionState
+        {
+            get { return (lParam & (1 << 31)) > 0; }
+        }
+    }
+
+    public class KeyEventArgs : EventArgs
+    {
+        private Keys keyCode;
+
+        public KeyEventArgs(Keys keyCode)
+        {
+            this.keyCode = keyCode;
+        }
+
+        public Keys KeyCode
+        {
+            get { return keyCode; }
+        }
+    }
+
+    public delegate void CharEnteredHandler(object sender, CharacterEventArgs e);
+    public delegate void KeyEventHandler(object sender, KeyEventArgs e);
+
+    public static class EventInput
+    {
+        /// <summary>
+        /// Event raised when a Character has been entered.
+        /// </summary>
+        public static event CharEnteredHandler CharEntered;
+
+        /// <summary>
+        /// Event raised when a key has been pressed down. May fire multiple times due to keyboard repeat.
+        /// </summary>
+        public static event KeyEventHandler KeyDown;
+
+        /// <summary>
+        /// Event raised when a key has been released.
+        /// </summary>
+        public static event KeyEventHandler KeyUp;
+
+        static bool initialized;
+
+#if WINDOWS
+        delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
+
+
+        static IntPtr prevWndProc;
+        static WndProc hookProcDelegate;
+        static IntPtr hIMC;
+
+        //various Win32 constants that we need
+        const int GWL_WNDPROC = -4;
+        const int WM_KEYDOWN = 0x100;
+        const int WM_KEYUP = 0x101;
+        const int WM_CHAR = 0x102;
+        const int WM_IME_SETCONTEXT = 0x0281;
+        const int WM_INPUTLANGCHANGE = 0x51;
+        const int WM_GETDLGCODE = 0x87;
+        const int WM_IME_COMPOSITION = 0x10f;
+        const int DLGC_WANTALLKEYS = 4;
+
+        //Win32 functions that we're using
+        [DllImport("Imm32.dll", CharSet = CharSet.Unicode)]
+        static extern IntPtr ImmGetContext(IntPtr hWnd);
+
+        [DllImport("Imm32.dll", CharSet = CharSet.Unicode)]
+        static extern IntPtr ImmAssociateContext(IntPtr hWnd, IntPtr hIMC);
+
+        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+        static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+        static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
+#endif
+
+        /// <summary>
+        /// Initialize the TextInput with the given GameWindow.
+        /// </summary>
+        /// <param name="window">The XNA window to which text input should be linked.</param>
+        public static void Initialize(GameWindow window)
+        {
+            if (initialized)
+            {
+                return;
+            }
+
+#if WINDOWS
+            hookProcDelegate = HookProc;
+
+            prevWndProc = (IntPtr)SetWindowLong(window.Handle, GWL_WNDPROC,
+            (int)Marshal.GetFunctionPointerForDelegate(hookProcDelegate));
+
+            hIMC = ImmGetContext(window.Handle);
+#else
+            window.TextInput += ReceiveInput;
+#endif
+
+            initialized = true;
+        }
+
+        private static void ReceiveInput(object sender, TextInputEventArgs e)
+        {
+            OnCharEntered(e.Character);
+        }
+
+        public static void OnCharEntered(char character)
+        {
+            if (CharEntered != null) CharEntered(null, new CharacterEventArgs(character, 0));
+        }
+#if WINDOWS
+        static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
+        {
+        IntPtr returnCode = CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
+
+        switch (msg)
+        {
+        case WM_GETDLGCODE:
+        returnCode = (IntPtr)(returnCode.ToInt32() | DLGC_WANTALLKEYS);
+        break;
+
+        case WM_KEYDOWN:
+        if (KeyDown != null)
+        KeyDown(null, new KeyEventArgs((Keys)wParam));
+
+        break;
+
+        case WM_KEYUP:
+        if (KeyUp != null)
+        KeyUp(null, new KeyEventArgs((Keys)wParam));
+        break;
+
+        case WM_CHAR:
+        if (CharEntered != null)
+        CharEntered(null, new CharacterEventArgs((char)wParam, lParam.ToInt32()));
+        break;
+
+        case WM_IME_SETCONTEXT:
+        if (wParam.ToInt32() == 1)
+        ImmAssociateContext(hWnd, hIMC);
+        break;
+
+        case WM_INPUTLANGCHANGE:
+        ImmAssociateContext(hWnd, hIMC);
+        returnCode = (IntPtr)1;
+        break;
+        }
+
+        return returnCode;
+        }
+
+#endif
+    }
+
+}

Barotrauma/BarotraumaClient/Source/EventInput/KeyboardDispatcher.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Threading;
+#if WINDOWS
+using System.Windows;
+#endif
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+
+namespace EventInput
+{
+    public interface IKeyboardSubscriber
+    {
+        void ReceiveTextInput(char inputChar);
+        void ReceiveTextInput(string text);
+        void ReceiveCommandInput(char command);
+        void ReceiveSpecialInput(Keys key);
+
+        bool Selected { get; set; } //or Focused
+    }
+
+    public class KeyboardDispatcher
+    {
+        public KeyboardDispatcher(GameWindow window)
+        {
+            EventInput.Initialize(window);
+            EventInput.CharEntered += EventInput_CharEntered;
+            EventInput.KeyDown += EventInput_KeyDown;
+        }
+
+        void EventInput_KeyDown(object sender, KeyEventArgs e)
+        {
+            if (_subscriber == null)
+                return;
+
+            _subscriber.ReceiveSpecialInput(e.KeyCode);
+        }
+
+        void EventInput_CharEntered(object sender, CharacterEventArgs e)
+        {
+            if (_subscriber == null)
+                return;
+            if (char.IsControl(e.Character))
+            {
+                //ctrl-v
+                if (e.Character == 0x16)
+                {
+#if WINDOWS
+                    //XNA runs in Multiple Thread Apartment state, which cannot recieve clipboard
+                    Thread thread = new Thread(PasteThread);
+                    thread.SetApartmentState(ApartmentState.STA);
+                    thread.Start();
+                    thread.Join();
+                    _subscriber.ReceiveTextInput(_pasteResult);
+#endif
+                }
+                else
+                {
+                    _subscriber.ReceiveCommandInput(e.Character);
+                }
+            }
+            else
+            {
+                _subscriber.ReceiveTextInput(e.Character);
+            }
+        }
+
+        IKeyboardSubscriber _subscriber;
+        public IKeyboardSubscriber Subscriber
+        {
+            get { return _subscriber; }
+            set
+            {
+                if (_subscriber != null)
+                    _subscriber.Selected = false;
+                _subscriber = value;
+                if (value != null)
+                    value.Selected = true;
+            }
+        }
+
+#if WINDOWS
+        //Thread has to be in Single Thread Apartment state in order to receive clipboard
+        string _pasteResult = "";
+        [STAThread]
+        void PasteThread()
+        {
+            _pasteResult = Clipboard.ContainsText() ? Clipboard.GetText() : "";
+        }
+#endif
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Events/Missions/Mission.cs

@@ -0,0 +1,25 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class Mission
+    {
+        public void ShowMessage(int index)
+        {
+            if (index >= headers.Count && index >= messages.Count) return;
+
+            string header = index < headers.Count ? headers[index] : "";
+            string message = index < messages.Count ? messages[index] : "";
+
+            GameServer.Log("Mission info: " + header + " - " + message, ServerLog.MessageType.ServerMessage);
+
+            new GUIMessageBox(header, message);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Events/Missions/MissionMode.cs

@@ -0,0 +1,18 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    partial class MissionMode : GameMode
+    {
+        public override void MsgBox()
+        {
+            if (mission == null) return;
+
+            var missionMsg = new GUIMessageBox(mission.Name, mission.Description, 400, 400);
+            missionMsg.UserData = "missionstartmessage";
+
+            Networking.GameServer.Log("Mission: " + mission.Name, Networking.ServerLog.MessageType.ServerMessage);
+            Networking.GameServer.Log(mission.Description, Networking.ServerLog.MessageType.ServerMessage);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Fonts/ScalableFont.cs

@@ -0,0 +1,287 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpFont;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    public class ScalableFont
+    {
+        private static List<ScalableFont> FontList = new List<ScalableFont>();
+        private static Library Lib = null;
+
+        private string filename;
+        private Face face;
+        private uint size;
+        private int baseHeight;
+        //private int lineHeight;
+        private Dictionary<uint, GlyphData> texCoords;
+        private List<Texture2D> textures;
+        private GraphicsDevice graphicsDevice;
+
+        public uint Size
+        {
+            get
+            {
+                return size;
+            }
+            set
+            {
+                size = value;
+                if (graphicsDevice!=null) RenderAtlas(graphicsDevice, charRanges, texDims, baseChar);
+            }
+        }
+
+        private uint[] charRanges;
+        private int texDims;
+        private uint baseChar;
+
+        private struct GlyphData
+        {
+            public int texIndex;
+            public Vector2 drawOffset;
+            public float advance;
+            public Rectangle texCoords;
+        }
+
+        public ScalableFont(string filename, uint size, GraphicsDevice gd=null)
+        {
+            if (Lib == null) Lib = new Library();
+            this.filename = filename;
+            this.face = null;
+            foreach (ScalableFont font in FontList)
+            {
+                if (font.filename == filename)
+                {
+                    this.face = font.face;
+                    break;
+                }
+            }
+            if (this.face == null)
+            {
+                this.face = new Face(Lib, filename);
+            }
+            this.size = size;
+
+            this.textures = new List<Texture2D>();
+
+            this.texCoords = new Dictionary<uint, GlyphData>();
+
+            if (gd != null) RenderAtlas(gd);
+
+            FontList.Add(this);
+        }
+
+        /// <summary>
+        /// Renders the font into at least one texture atlas, which is simply a collection of all glyphs in the ranges defined by charRanges.
+        /// Don't call this too often or with very large sizes.
+        /// </summary>
+        /// <param name="gd">Graphics device, required to create textures.</param>
+        /// <param name="charRanges">Character ranges between each even element with their corresponding odd element. Default is 0x20 to 0xFFFF.</param>
+        /// <param name="texDims">Texture dimensions. Default is 512x512.</param>
+        /// <param name="baseChar">Base character used to shift all other characters downwards when rendering. Defaults to T.</param>
+        public void RenderAtlas(GraphicsDevice gd, uint[] charRanges = null, int texDims = 512, uint baseChar = 0x54)
+        {
+            if (charRanges == null)
+            {
+                charRanges = new uint[] { 0x20, 0xFFFF };
+            }
+            this.charRanges = charRanges;
+            this.texDims = texDims;
+            this.baseChar = baseChar;
+
+            face.SetPixelSizes(0, size);
+            textures.ForEach(t => t.Dispose());
+            textures.Clear();
+            texCoords.Clear();
+
+            uint[] pixelBuffer = new uint[texDims * texDims];
+            for (int i = 0; i < texDims * texDims; i++)
+            {
+                pixelBuffer[i] = 0;
+            }
+
+            textures.Add(new Texture2D(gd, texDims, texDims, false, SurfaceFormat.Color));
+            int texIndex = 0;
+
+            Vector2 currentCoords = Vector2.Zero;
+            int nextY = 0;
+
+            face.LoadGlyph(face.GetCharIndex(baseChar), LoadFlags.Default, LoadTarget.Normal);
+            baseHeight = face.Glyph.Metrics.Height.ToInt32();
+            //lineHeight = baseHeight;
+            for (int i = 0; i < charRanges.Length; i += 2)
+            {
+                uint start = charRanges[i];
+                uint end = charRanges[i + 1];
+                for (uint j = start; j <= end; j++)
+                {
+                    uint glyphIndex = face.GetCharIndex(j);
+                    if (glyphIndex == 0) continue;
+                    face.LoadGlyph(glyphIndex, LoadFlags.Default, LoadTarget.Normal);
+                    if (face.Glyph.Metrics.Width == 0 || face.Glyph.Metrics.Height == 0)
+                    {
+                        if (face.Glyph.Metrics.HorizontalAdvance > 0)
+                        {
+                            //glyph is empty, but char still applies advance
+                            GlyphData blankData = new GlyphData();
+                            blankData.advance = (float)face.Glyph.Metrics.HorizontalAdvance;
+                            blankData.texIndex = -1; //indicates no texture because the glyph is empty
+                            texCoords.Add(j, blankData);
+                        }
+                        continue;
+                    }
+                    //stacktrace doesn't really work that well when RenderGlyph throws an exception
+                    face.Glyph.RenderGlyph(RenderMode.Normal);
+                    byte[] bitmap = face.Glyph.Bitmap.BufferData;
+                    int glyphWidth = face.Glyph.Bitmap.Width;
+                    int glyphHeight = bitmap.Length / glyphWidth;
+
+                    //if (glyphHeight>lineHeight) lineHeight=glyphHeight;
+
+                    if (glyphWidth > texDims - 1 || glyphHeight > texDims - 1)
+                    {
+                        throw new Exception(filename + ", " + size.ToString() + ", "+ (char)j + "; Glyph dimensions exceed texture atlas dimensions");
+                    }
+
+                    nextY = Math.Max(nextY, glyphHeight + 2);
+
+                    if (currentCoords.X + glyphWidth + 2 > texDims - 1)
+                    {
+                        currentCoords.X = 0;
+                        currentCoords.Y += nextY;
+                        nextY = 0;
+                    }
+                    if (currentCoords.Y + glyphHeight + 2 > texDims - 1)
+                    {
+                        currentCoords.X = 0;
+                        currentCoords.Y = 0;
+                        textures[texIndex].SetData<uint>(pixelBuffer);
+                        textures.Add(new Texture2D(gd, texDims, texDims, false, SurfaceFormat.Color));
+                        texIndex++;
+                        for (int k = 0; k < texDims * texDims; k++)
+                        {
+                            pixelBuffer[k] = 0;
+                        }
+                    }
+
+                    GlyphData newData = new GlyphData();
+                    newData.advance = (float)face.Glyph.Metrics.HorizontalAdvance;
+                    newData.texIndex = texIndex;
+                    newData.texCoords = new Rectangle((int)currentCoords.X, (int)currentCoords.Y, glyphWidth, glyphHeight);
+                    newData.drawOffset = new Vector2(face.Glyph.BitmapLeft, baseHeight*14/10 - face.Glyph.BitmapTop);
+                    texCoords.Add(j, newData);
+
+                    for (int y = 0; y < glyphHeight; y++)
+                    {
+                        for (int x = 0; x < glyphWidth; x++)
+                        {
+                            byte byteColor = bitmap[x + y * glyphWidth];
+                            pixelBuffer[((int)currentCoords.X + x) + ((int)currentCoords.Y + y) * texDims] = (uint)(byteColor << 24 | byteColor << 16 | byteColor << 8 | byteColor);
+                        }
+                    }
+
+                    currentCoords.X += glyphWidth + 2;
+                }
+                textures[texIndex].SetData<uint>(pixelBuffer);
+            }
+
+            graphicsDevice = gd;
+        }
+        
+        public void DrawString(SpriteBatch sb, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects se, float layerDepth)
+        {
+            if (textures.Count == 0) return;
+            
+            int lineNum = 0;
+            Vector2 currentPos = position;
+            Vector2 advanceUnit = new Vector2((float)Math.Cos(rotation), (float)Math.Sin(rotation));
+            for (int i = 0; i < text.Length; i++)
+            {
+                if (text[i]=='\n')
+                {
+                    lineNum++;
+                    currentPos = position;
+                    currentPos.X -= baseHeight * 1.8f * lineNum * advanceUnit.Y * scale.Y;
+                    currentPos.Y += baseHeight * 1.8f * lineNum * advanceUnit.X * scale.Y;
+                    continue;
+                }
+                uint charIndex = text[i];
+                GlyphData gd;
+                if (texCoords.TryGetValue(charIndex, out gd))
+                {
+                    if (gd.texIndex >= 0)
+                    {
+                        Texture2D tex = textures[gd.texIndex];
+                        Vector2 drawOffset;
+                        drawOffset.X = gd.drawOffset.X * advanceUnit.X * scale.X - gd.drawOffset.Y * advanceUnit.Y * scale.Y;
+                        drawOffset.Y = gd.drawOffset.X * advanceUnit.Y * scale.Y + gd.drawOffset.Y * advanceUnit.X * scale.X;
+
+                        sb.Draw(tex, currentPos + drawOffset, null, gd.texCoords, origin, rotation, scale, color, se, layerDepth);
+                    }
+                    currentPos += gd.advance * advanceUnit * scale.X;
+                }
+            }
+        }
+
+        public void DrawString(SpriteBatch sb, string text, Vector2 position, Color color, float rotation, Vector2 origin, float scale, SpriteEffects se, float layerDepth)
+        {
+            DrawString(sb, text, position, color, rotation, origin, new Vector2(scale), se, layerDepth);
+        }
+
+        public void DrawString(SpriteBatch sb, string text, Vector2 position, Color color)
+        {
+            if (textures.Count == 0) return;
+
+            Vector2 currentPos = position;
+            for (int i = 0; i < text.Length; i++)
+            {
+                if (text[i] == '\n')
+                {
+                    currentPos.X = position.X;
+                    currentPos.Y += baseHeight * 1.8f;
+                    continue;
+                }
+                uint charIndex = text[i];
+                GlyphData gd;
+                if (texCoords.TryGetValue(charIndex, out gd))
+                {
+                    if (gd.texIndex >= 0)
+                    {
+                        Texture2D tex = textures[gd.texIndex];
+                        sb.Draw(tex, currentPos + gd.drawOffset, gd.texCoords, color);
+                    }
+                    currentPos.X += gd.advance;
+                }
+            }
+        }
+    
+        public Vector2 MeasureString(string text)
+        {
+            float currentLineX = 0.0f;
+            Vector2 retVal = Vector2.Zero;
+            retVal.Y = baseHeight*1.8f;
+            for (int i = 0; i < text.Length; i++)
+            {
+                if (text[i] == '\n')
+                {
+                    currentLineX = 0.0f;
+                    retVal.Y += baseHeight*18/10;
+                    continue;
+                }
+                uint charIndex = text[i];
+                GlyphData gd;
+                if (texCoords.TryGetValue(charIndex, out gd))
+                {
+                    currentLineX += gd.advance;
+                }
+                retVal.X = Math.Max(retVal.X,currentLineX);
+            }
+            return retVal;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/ComponentStyle.cs

@@ -0,0 +1,147 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    public class UISprite
+    {
+        public Sprite Sprite
+        {
+            get;
+            private set;
+        }
+
+        public bool Tile
+        {
+            get;
+            private set;
+        }
+
+        public bool Slice
+        {
+            get;
+            set;
+        }
+
+        public Rectangle[] Slices
+        {
+            get;
+            set;
+        }
+
+        public bool MaintainAspectRatio
+        {
+            get;
+            private set;
+        }
+
+        public UISprite(Sprite sprite, bool tile, bool maintainAspectRatio)
+        {
+            Sprite = sprite;
+            Tile = tile;
+            MaintainAspectRatio = maintainAspectRatio;
+        }
+    }
+
+    public class GUIComponentStyle
+    {
+        public readonly Vector4 Padding;
+
+        public readonly Color Color;
+
+        public readonly Color textColor;
+
+        public readonly Color HoverColor;
+        public readonly Color SelectedColor;
+
+        public readonly Color OutlineColor;
+
+        public readonly Dictionary<GUIComponent.ComponentState, List<UISprite>> Sprites;
+        
+        public Dictionary<string, GUIComponentStyle> ChildStyles;
+
+        public GUIComponentStyle(XElement element)
+        {
+            Sprites = new Dictionary<GUIComponent.ComponentState, List<UISprite>>();
+            foreach (GUIComponent.ComponentState state in Enum.GetValues(typeof(GUIComponent.ComponentState)))
+            {
+                Sprites[state] = new List<UISprite>();
+            }
+
+            ChildStyles = new Dictionary<string, GUIComponentStyle>();
+
+            Padding = ToolBox.GetAttributeVector4(element, "padding", Vector4.Zero);
+
+            Vector4 colorVector = ToolBox.GetAttributeVector4(element, "color", new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+            Color = new Color(colorVector.X, colorVector.Y, colorVector.Z, colorVector.W);
+
+            colorVector = ToolBox.GetAttributeVector4(element, "textcolor", new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+            textColor = new Color(colorVector.X, colorVector.Y, colorVector.Z, colorVector.W);
+
+            colorVector = ToolBox.GetAttributeVector4(element, "hovercolor", new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+            HoverColor = new Color(colorVector.X, colorVector.Y, colorVector.Z, colorVector.W);
+
+            colorVector = ToolBox.GetAttributeVector4(element, "selectedcolor", new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+            SelectedColor = new Color(colorVector.X, colorVector.Y, colorVector.Z, colorVector.W);
+
+            colorVector = ToolBox.GetAttributeVector4(element, "outlinecolor", new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+            OutlineColor = new Color(colorVector.X, colorVector.Y, colorVector.Z, colorVector.W);
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        Sprite sprite = new Sprite(subElement);
+                        bool maintainAspect = ToolBox.GetAttributeBool(subElement, "maintainaspectratio",false);
+                        bool tile = ToolBox.GetAttributeBool(subElement, "tile", true);
+
+                        string stateStr = ToolBox.GetAttributeString(subElement, "state", "None");
+                        GUIComponent.ComponentState spriteState = GUIComponent.ComponentState.None;
+                        Enum.TryParse(stateStr, out spriteState);
+
+                        UISprite newSprite = new UISprite(sprite, tile, maintainAspect);
+
+                        Vector4 sliceVec = ToolBox.GetAttributeVector4(subElement, "slice", Vector4.Zero);
+                        if (sliceVec != Vector4.Zero)
+                        {
+                            Rectangle slice = new Rectangle((int)sliceVec.X, (int)sliceVec.Y, (int)(sliceVec.Z - sliceVec.X), (int)(sliceVec.W - sliceVec.Y));
+
+                            newSprite.Slice = true;
+
+                            newSprite.Slices = new Rectangle[9];
+
+                            //top-left
+                            newSprite.Slices[0] = new Rectangle(newSprite.Sprite.SourceRect.Location, slice.Location - newSprite.Sprite.SourceRect.Location);
+                            //top-mid
+                            newSprite.Slices[1] = new Rectangle(slice.Location.X, newSprite.Slices[0].Y, slice.Width, newSprite.Slices[0].Height);
+                            //top-right
+                            newSprite.Slices[2] = new Rectangle(slice.Right, newSprite.Slices[0].Y, newSprite.Sprite.SourceRect.Right - slice.Right, newSprite.Slices[0].Height);
+
+                            //mid-left
+                            newSprite.Slices[3] = new Rectangle(newSprite.Slices[0].X, slice.Y, newSprite.Slices[0].Width, slice.Height);
+                            //center
+                            newSprite.Slices[4] = slice;
+                            //mid-right
+                            newSprite.Slices[5] = new Rectangle(newSprite.Slices[2].X, slice.Y, newSprite.Slices[2].Width, slice.Height);
+
+                            //bottom-left
+                            newSprite.Slices[6] = new Rectangle(newSprite.Slices[0].X, slice.Bottom, newSprite.Slices[0].Width, newSprite.Sprite.SourceRect.Bottom - slice.Bottom);
+                            //bottom-mid
+                            newSprite.Slices[7] = new Rectangle(newSprite.Slices[1].X, slice.Bottom, newSprite.Slices[1].Width, newSprite.Sprite.SourceRect.Bottom - slice.Bottom);
+                            //bottom-right
+                            newSprite.Slices[8] = new Rectangle(newSprite.Slices[2].X, slice.Bottom, newSprite.Slices[2].Width, newSprite.Sprite.SourceRect.Bottom - slice.Bottom);
+                        }
+
+                        Sprites[spriteState].Add(newSprite);
+                        break;
+                    default:
+                        ChildStyles.Add(subElement.Name.ToString().ToLowerInvariant(), new GUIComponentStyle(subElement));
+                        break;
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUI.cs

@@ -0,0 +1,606 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    public enum GUISoundType
+    {
+        Message,
+        RadioMessage,
+        DeadMessage,
+        Click,
+        Inventory,
+    }
+    
+    public class GUI
+    {
+
+        public static GUIStyle Style;
+
+        private static Texture2D t;
+        public static ScalableFont Font, SmallFont, LargeFont;
+
+        private static Sprite cursor;
+
+        private static GraphicsDevice graphicsDevice;
+        public static GraphicsDevice GraphicsDevice
+        {
+            get
+            {
+                return graphicsDevice;
+            }
+            set
+            {
+                graphicsDevice = value;
+            }
+        }
+
+        private static List<GUIMessage> messages = new List<GUIMessage>();
+
+        private static Sound[] sounds;
+
+        private static bool pauseMenuOpen, settingsMenuOpen;
+        private static GUIFrame pauseMenu;
+
+        public static Color ScreenOverlayColor;
+
+        private static Sprite submarineIcon, arrow;
+
+        public static Sprite SubmarineIcon
+        {
+            get { return submarineIcon; }
+        }
+
+        public static Sprite SpeechBubbleIcon
+        {
+            get;
+            private set;
+        }
+
+        public static Sprite Arrow
+        {
+            get { return arrow; }
+        }
+
+        public static bool DisableHUD;
+
+        public static void Init(ContentManager content)
+        {
+            Font = new ScalableFont("Content/Exo2-Medium.otf", 14, graphicsDevice);
+            SmallFont = new ScalableFont("Content/Exo2-Light.otf", 12, graphicsDevice);
+            LargeFont = new ScalableFont("Content/Code Pro Bold.otf", 22, graphicsDevice);
+
+            cursor = new Sprite("Content/UI/cursor.png", Vector2.Zero);
+
+            Style = new GUIStyle("Content/UI/style.xml");
+        }
+
+        public static bool PauseMenuOpen
+        {
+            get { return pauseMenuOpen; }
+        }
+
+        public static bool SettingsMenuOpen
+        {
+            get { return settingsMenuOpen; }
+        }
+
+        public static void LoadContent(bool loadSounds = true)
+        {
+            if (loadSounds)
+            {
+                sounds = new Sound[Enum.GetValues(typeof(GUISoundType)).Length];
+                sounds[(int)GUISoundType.Message] = Sound.Load("Content/Sounds/UI/UImsg.ogg", false);
+                sounds[(int)GUISoundType.RadioMessage] = Sound.Load("Content/Sounds/UI/radiomsg.ogg", false);
+                sounds[(int)GUISoundType.DeadMessage] = Sound.Load("Content/Sounds/UI/deadmsg.ogg", false);
+                sounds[(int)GUISoundType.Click] = Sound.Load("Content/Sounds/UI/beep-shinymetal.ogg", false);
+
+                sounds[(int)GUISoundType.Inventory] = Sound.Load("Content/Sounds/pickItem.ogg", false);
+
+            }
+
+            // create 1x1 texture for line drawing
+            t = new Texture2D(graphicsDevice, 1, 1);
+            t.SetData(new Color[] { Color.White });// fill the texture with white
+
+            submarineIcon = new Sprite("Content/UI/uiIcons.png", new Rectangle(0, 192, 64, 64), null);
+            submarineIcon.Origin = submarineIcon.size / 2;
+
+            arrow = new Sprite("Content/UI/uiIcons.png", new Rectangle(80, 240, 16, 16), null);
+            arrow.Origin = arrow.size / 2;
+
+            SpeechBubbleIcon = new Sprite("Content/UI/uiIcons.png", new Rectangle(0, 129, 65, 61), null);
+            SpeechBubbleIcon.Origin = SpeechBubbleIcon.size / 2;
+        }
+
+        public static void TogglePauseMenu()
+        {
+            if (Screen.Selected == GameMain.MainMenuScreen) return;
+
+            settingsMenuOpen = false;
+
+            TogglePauseMenu(null, null);
+
+            if (pauseMenuOpen)
+            {
+                pauseMenu = new GUIFrame(new Rectangle(0, 0, 200, 300), null, Alignment.Center, "");
+
+                int y = 0;
+                var button = new GUIButton(new Rectangle(0, y, 0, 30), "Resume", Alignment.CenterX, "", pauseMenu);
+                button.OnClicked = TogglePauseMenu;
+
+                y += 60;
+
+                button = new GUIButton(new Rectangle(0, y, 0, 30), "Settings", Alignment.CenterX, "", pauseMenu);
+                button.OnClicked = (btn, userData) => 
+                {
+                    TogglePauseMenu();
+                    settingsMenuOpen = !settingsMenuOpen;
+                    
+                    return true; 
+                };
+
+
+                y += 60;
+
+                if (Screen.Selected == GameMain.GameScreen && GameMain.GameSession != null)
+                {
+                    SinglePlayerMode spMode = GameMain.GameSession.gameMode as SinglePlayerMode;
+                    if (spMode != null)
+                    {
+                        button = new GUIButton(new Rectangle(0, y, 0, 30), "Load previous", Alignment.CenterX, "", pauseMenu);
+                        button.OnClicked += TogglePauseMenu;
+                        button.OnClicked += GameMain.GameSession.LoadPrevious;
+
+                        y += 60;
+                    }
+                }
+
+                if (Screen.Selected == GameMain.LobbyScreen)
+                {
+                    SinglePlayerMode spMode = GameMain.GameSession.gameMode as SinglePlayerMode;
+                    if (spMode != null)
+                    {
+                        button = new GUIButton(new Rectangle(0, y, 0, 30), "Save & quit", Alignment.CenterX, "", pauseMenu);
+                        button.OnClicked += QuitClicked;
+                        button.OnClicked += TogglePauseMenu;
+                        button.UserData = "save";
+
+                        y += 60;
+                    }
+                }
+
+
+                button = new GUIButton(new Rectangle(0, y, 0, 30), "Quit", Alignment.CenterX, "", pauseMenu);
+                button.OnClicked += QuitClicked;
+                button.OnClicked += TogglePauseMenu;
+            }
+
+        }
+
+        private static bool TogglePauseMenu(GUIButton button, object obj)
+        {
+            pauseMenuOpen = !pauseMenuOpen;
+
+            return true;
+        }
+
+        private static bool QuitClicked(GUIButton button, object obj)
+        {
+            if (button.UserData as string == "save")
+            {
+                SaveUtil.SaveGame(GameMain.GameSession.SaveFile);
+            }
+
+            if (GameMain.NetworkMember != null)
+            {
+                GameMain.NetworkMember.Disconnect();
+                GameMain.NetworkMember = null;
+            }
+
+            CoroutineManager.StopCoroutines("EndCinematic");
+
+            GameMain.GameSession = null;
+
+            GameMain.MainMenuScreen.Select();
+            //Game1.MainMenuScreen.SelectTab(null, (int)MainMenuScreen.Tabs.Main);
+
+            return true;
+        }
+
+        public static void DrawLine(SpriteBatch sb, Vector2 start, Vector2 end, Color clr, float depth = 0.0f, int width = 1)
+        {
+            Vector2 edge = end - start;
+            // calculate angle to rotate line
+            float angle = (float)Math.Atan2(edge.Y, edge.X);
+
+            sb.Draw(t,
+                new Rectangle(// rectangle defines shape of line and position of start of line
+                    (int)start.X,
+                    (int)start.Y,
+                    (int)edge.Length(), //sb will strech the texture to fill this rectangle
+                    width), //width of line, change this to make thicker line
+                null,
+                clr, //colour of line
+                angle,     //angle of line (calulated above)
+                new Vector2(0, 0), // point in line about which to rotate
+                SpriteEffects.None,
+                depth);
+        }
+        
+        public static void DrawString(SpriteBatch sb, Vector2 pos, string text, Color color, Color? backgroundColor=null, int backgroundPadding=0, ScalableFont font = null)
+        {
+
+            if (font == null) font = Font;
+            if (backgroundColor != null)
+            {
+                Vector2 textSize = font.MeasureString(text);
+                DrawRectangle(sb, pos - Vector2.One * backgroundPadding, textSize + Vector2.One * 2.0f * backgroundPadding, (Color)backgroundColor, true);
+            }
+
+            font.DrawString(sb, text, pos, color);
+        }
+
+        public static void DrawRectangle(SpriteBatch sb, Vector2 start, Vector2 size, Color clr, bool isFilled = false, float depth = 0.0f, int thickness = 1)
+        {
+            if (size.X < 0)
+            {
+                start.X += size.X;
+                size.X = -size.X;
+            }
+            if (size.Y < 0)
+            {
+                start.Y += size.Y;
+                size.Y = -size.Y;
+            }
+            DrawRectangle(sb, new Rectangle((int)start.X, (int)start.Y, (int)size.X, (int)size.Y), clr, isFilled, depth, thickness);
+        }
+
+        public static void DrawRectangle(SpriteBatch sb, Rectangle rect, Color clr, bool isFilled = false, float depth = 0.0f, int thickness = 1)
+        {
+            if (isFilled)
+            {
+                sb.Draw(t, rect, null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
+            }
+            else
+            {
+                sb.Draw(t, new Rectangle(rect.X + thickness, rect.Y, rect.Width - thickness * 2, thickness), null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
+                sb.Draw(t, new Rectangle(rect.X + thickness, rect.Y + rect.Height - thickness, rect.Width - thickness * 2, thickness), null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
+
+                sb.Draw(t, new Rectangle(rect.X, rect.Y, thickness, rect.Height), null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
+                sb.Draw(t, new Rectangle(rect.X + rect.Width - thickness, rect.Y, thickness, rect.Height), null, clr, 0.0f, Vector2.Zero, SpriteEffects.None, depth);
+            }
+        }
+
+        public static void DrawProgressBar(SpriteBatch sb, Vector2 start, Vector2 size, float progress, Color clr, float depth = 0.0f)
+        {
+            DrawProgressBar(sb, start, size, progress, clr, new Color(0.5f, 0.57f, 0.6f, 1.0f), depth);
+        }
+
+        public static void DrawProgressBar(SpriteBatch sb, Vector2 start, Vector2 size, float progress, Color clr, Color outlineColor, float depth = 0.0f)
+        {
+            DrawRectangle(sb, new Vector2(start.X, -start.Y), size, outlineColor, false, depth);
+
+            int padding = 2;
+            DrawRectangle(sb, new Rectangle((int)start.X + padding, -(int)(start.Y - padding), (int)((size.X - padding * 2) * progress), (int)size.Y - padding * 2),
+                clr, true, depth);
+        }
+
+
+        public static Texture2D CreateCircle(int radius)
+        {
+            int outerRadius = radius * 2 + 2; // So circle doesn't go out of bounds
+            Texture2D texture = new Texture2D(graphicsDevice, outerRadius, outerRadius);
+
+            Color[] data = new Color[outerRadius * outerRadius];
+
+            // Colour the entire texture transparent first.
+            for (int i = 0; i < data.Length; i++)
+                data[i] = Color.Transparent;
+
+            // Work out the minimum step necessary using trigonometry + sine approximation.
+            double angleStep = 1f / radius;
+
+            for (double angle = 0; angle < Math.PI * 2; angle += angleStep)
+            {
+                // Use the parametric definition of a circle: http://en.wikipedia.org/wiki/Circle#Cartesian_coordinates
+                int x = (int)Math.Round(radius + radius * Math.Cos(angle));
+                int y = (int)Math.Round(radius + radius * Math.Sin(angle));
+
+                data[y * outerRadius + x + 1] = Color.White;
+            }
+
+            texture.SetData(data);
+            return texture;
+        }
+
+        public static Texture2D CreateCapsule(int radius, int height)
+        {
+            int textureWidth = radius * 2, textureHeight = height + radius * 2;
+
+            Texture2D texture = new Texture2D(graphicsDevice, textureWidth, textureHeight);
+            Color[] data = new Color[textureWidth * textureHeight];
+
+            // Colour the entire texture transparent first.
+            for (int i = 0; i < data.Length; i++)
+                data[i] = Color.Transparent;
+
+            // Work out the minimum step necessary using trigonometry + sine approximation.
+            double angleStep = 1f / radius;
+
+            for (int i = 0; i < 2; i++ )
+            {
+                for (double angle = 0; angle < Math.PI * 2; angle += angleStep)
+                {
+                    // Use the parametric definition of a circle: http://en.wikipedia.org/wiki/Circle#Cartesian_coordinates
+                    int x = (int)Math.Round(radius + radius * Math.Cos(angle));
+                    int y = (height-1)*i + (int)Math.Round(radius + radius * Math.Sin(angle));
+
+                    data[y * textureWidth + x] = Color.White;
+                }
+            }
+
+            for (int y = radius; y<textureHeight-radius; y++)
+            {
+                data[y * textureWidth] = Color.White;
+                data[y * textureWidth + (textureWidth-1)] = Color.White;
+            }
+
+            texture.SetData(data);
+            return texture;
+        }
+
+        public static Texture2D CreateRectangle(int width, int height)
+        {
+            Texture2D texture = new Texture2D(graphicsDevice, width, height);
+            Color[] data = new Color[width * height];
+
+            for (int i = 0; i < data.Length; i++)
+                data[i] = Color.Transparent;
+
+            for (int y = 0; y < height; y++)
+            {
+                data[y * width] = Color.White;
+                data[y * width + (width-1)] = Color.White;
+            }
+
+            for (int x = 0; x < width; x++)
+            {
+                data[x] = Color.White;
+                data[(height - 1) * width + x] = Color.White;
+            }
+
+            texture.SetData(data);
+            return texture;
+        }
+
+        public static bool DrawButton(SpriteBatch sb, Rectangle rect, string text, Color color, bool isHoldable = false)
+        {
+            bool clicked = false;
+
+            if (rect.Contains(PlayerInput.MousePosition))
+            {
+                clicked = PlayerInput.LeftButtonHeld();
+
+                color = clicked ? 
+                    new Color((int)(color.R * 0.8f), (int)(color.G * 0.8f), (int)(color.B * 0.8f), color.A) : 
+                    new Color((int)(color.R * 1.2f), (int)(color.G * 1.2f), (int)(color.B * 1.2f), color.A);
+
+                if (!isHoldable) clicked = PlayerInput.LeftButtonClicked();
+            }
+
+            DrawRectangle(sb, rect, color, true);
+            
+            Vector2 origin;
+            try
+            {
+                origin = Font.MeasureString(text)/2;
+            }
+            catch
+            {
+                origin = Vector2.Zero;
+            }
+
+            Font.DrawString(sb, text, new Vector2(rect.Center.X, rect.Center.Y) , Color.White, 0.0f, origin, 1.0f, SpriteEffects.None, 0.0f);
+
+            return clicked;
+        }
+
+        public static void Draw(float deltaTime, SpriteBatch spriteBatch, Camera cam)
+        {
+            if (ScreenOverlayColor.A>0.0f)
+            {
+                DrawRectangle(
+                    spriteBatch,
+                    new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight),
+                    ScreenOverlayColor, true);
+            }
+
+            if (GameMain.DebugDraw)
+            {
+                DrawString(spriteBatch, new Vector2(10, 10), 
+                    "FPS: " + (int)GameMain.FrameCounter.AverageFramesPerSecond,
+                    Color.White, Color.Black * 0.5f, 0, SmallFont);
+
+                DrawString(spriteBatch, new Vector2(10, 25),
+                    "Physics: " + GameMain.World.UpdateTime,
+                    Color.White, Color.Black * 0.5f, 0, SmallFont);
+
+                DrawString(spriteBatch, new Vector2(10, 40),
+                    "Bodies: " + GameMain.World.BodyList.Count + " (" + GameMain.World.BodyList.FindAll(b => b.Awake && b.Enabled).Count + " awake)",
+                    Color.White, Color.Black * 0.5f, 0, SmallFont);
+
+                if (Screen.Selected.Cam != null)
+                {
+                    DrawString(spriteBatch, new Vector2(10, 55),
+                        "Camera pos: " + Screen.Selected.Cam.Position.ToPoint(),
+                        Color.White, Color.Black * 0.5f, 0, SmallFont);
+                }
+
+                if (Submarine.MainSub != null)
+                {
+                    DrawString(spriteBatch, new Vector2(10, 70),
+                        "Sub pos: " + Submarine.MainSub.Position.ToPoint(),
+                        Color.White, Color.Black * 0.5f, 0, SmallFont);
+                }
+
+                for (int i = 1; i < Sounds.SoundManager.DefaultSourceCount; i++)
+                {
+                    Color clr = Color.White;
+
+                    string soundStr = i+": ";
+
+                    var playingSound = Sounds.SoundManager.GetPlayingSound(i);
+
+                    if (playingSound == null)
+                    {
+                        soundStr+= "none";
+                        clr *= 0.5f;
+                    }
+                    else
+                    {
+                        soundStr += System.IO.Path.GetFileNameWithoutExtension(playingSound.FilePath);
+
+                        if (Sounds.SoundManager.IsLooping(i))
+                        {
+                            soundStr += " (looping)";
+                            clr = Color.Yellow;
+                        }
+                    }
+
+                    GUI.DrawString(spriteBatch, new Vector2(200, i * 15), soundStr, clr, Color.Black * 0.5f, 0, GUI.SmallFont);
+                }
+            }
+            
+            if (GameMain.NetworkMember != null) GameMain.NetworkMember.Draw(spriteBatch);
+
+            DrawMessages(spriteBatch, (float)deltaTime);
+
+            if (GUIMessageBox.VisibleBox != null)
+            {
+                GUIMessageBox.VisibleBox.Draw(spriteBatch);
+            }            
+
+            if (pauseMenuOpen)
+            {
+                pauseMenu.Draw(spriteBatch);
+            }
+
+            if (settingsMenuOpen)
+            {
+                GameMain.Config.SettingsFrame.Draw(spriteBatch);
+            }
+            
+            DebugConsole.Draw(spriteBatch);
+            
+            if (GUIComponent.MouseOn != null && !string.IsNullOrWhiteSpace(GUIComponent.MouseOn.ToolTip)) GUIComponent.MouseOn.DrawToolTip(spriteBatch);
+            
+            if (!GUI.DisableHUD)
+                cursor.Draw(spriteBatch, PlayerInput.LatestMousePosition);            
+        }
+
+        public static void AddToGUIUpdateList()
+        {
+            if (pauseMenuOpen)
+            {
+                pauseMenu.AddToGUIUpdateList();
+            }
+
+            if (settingsMenuOpen)
+            {
+                GameMain.Config.SettingsFrame.AddToGUIUpdateList();
+            }
+
+            if (GUIMessageBox.VisibleBox != null)
+            {
+                GUIMessageBox.VisibleBox.AddToGUIUpdateList();
+            }            
+        }
+
+        public static void Update(float deltaTime)
+        {
+            if (pauseMenuOpen)
+            {
+                pauseMenu.Update(deltaTime);
+            }
+
+            if (settingsMenuOpen)
+            {
+                GameMain.Config.SettingsFrame.Update(deltaTime);
+            }
+
+            if (GUIMessageBox.VisibleBox != null)
+            {
+                GUIMessageBox.VisibleBox.Update(deltaTime);
+            }            
+        }
+
+        public static void AddMessage(string message, Color color, float lifeTime = 3.0f, bool playSound = true)
+        {
+            if (messages.Count>0 && messages[messages.Count-1].Text == message)
+            {
+                messages[messages.Count - 1].LifeTime = lifeTime;
+                return;
+            }
+
+            Vector2 currPos = new Vector2(GameMain.GraphicsWidth / 2.0f, GameMain.GraphicsHeight * 0.7f);
+            currPos.Y += messages.Count * 30;
+
+            messages.Add(new GUIMessage(message, color, currPos, lifeTime));
+            if (playSound) PlayUISound(GUISoundType.Message);
+        }
+
+        public static void PlayUISound(GUISoundType soundType)
+        {
+            if (sounds == null) return;
+
+            int soundIndex = (int)soundType;
+            if (soundIndex < 0 || soundIndex >= sounds.Length) return;
+
+            sounds[soundIndex].Play();
+        }
+
+        private static void DrawMessages(SpriteBatch spriteBatch, float deltaTime)
+        {
+            if (messages.Count == 0) return;
+
+            Vector2 currPos = new Vector2(GameMain.GraphicsWidth / 2.0f, GameMain.GraphicsHeight * 0.7f);
+
+            int i = 1;
+            foreach (GUIMessage msg in messages)
+            {
+                float alpha = 1.0f;
+
+                if (msg.LifeTime < 1.0f)
+                {
+                    alpha -= 1.0f - msg.LifeTime;
+                }
+
+                msg.Pos = MathUtils.SmoothStep(msg.Pos, currPos, deltaTime*20.0f);
+
+                Font.DrawString(spriteBatch, msg.Text,
+                    new Vector2((int)msg.Pos.X - 1, (int)msg.Pos.Y - 1),
+                    Color.Black * alpha*0.5f, 0.0f,
+                    new Vector2((int)(0.5f * msg.Size.X), (int)(0.5f * msg.Size.Y)), 1.0f, SpriteEffects.None, 0.0f);
+
+                Font.DrawString(spriteBatch, msg.Text,
+                    new Vector2((int)msg.Pos.X, (int)msg.Pos.Y), 
+                    msg.Color * alpha, 0.0f,
+                    new Vector2((int)(0.5f * msg.Size.X), (int)(0.5f * msg.Size.Y)), 1.0f, SpriteEffects.None, 0.0f);
+
+
+
+                currPos.Y += 30.0f;
+
+                messages[0].LifeTime -= deltaTime/i;
+
+                i++;
+            }
+            
+            if (messages[0].LifeTime <= 0.0f) messages.Remove(messages[0]);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIButton.cs

@@ -0,0 +1,227 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace Barotrauma
+{
+    public class GUIButton : GUIComponent
+    {
+        protected GUITextBlock textBlock;
+        protected GUIFrame frame;
+
+        public delegate bool OnClickedHandler(GUIButton button, object obj);
+        public OnClickedHandler OnClicked;
+
+        public delegate bool OnPressedHandler();
+        public OnPressedHandler OnPressed;
+
+        public bool CanBeSelected = true;
+
+        private bool enabled;
+
+        public bool Enabled 
+        { 
+            get
+            {
+                return enabled;
+            }
+
+            set
+            {
+                if (value == enabled) return;
+
+                enabled = value;
+                frame.Color = enabled ? color : Color.Gray * 0.7f;
+            }
+        }
+
+        public override Color Color
+        {
+            get { return base.Color; }
+            set
+            {
+                base.Color = value;
+                frame.Color = value;
+            }
+        }
+
+        public override Color HoverColor
+        {
+            get { return base.HoverColor; }
+            set
+            {
+                base.HoverColor = value;
+                frame.HoverColor = value;
+            }
+        }
+
+        public override Color SelectedColor
+        {
+            get
+            {
+                return base.SelectedColor;
+            }
+            set
+            {
+                base.SelectedColor = value;
+                frame.SelectedColor = value;
+            }
+        }
+
+        public override Color OutlineColor
+        {
+            get { return base.OutlineColor; }
+            set
+            {
+                base.OutlineColor = value;
+                if (frame != null) frame.OutlineColor = value;
+            }
+        }
+
+        public Color TextColor
+        {
+            get { return textBlock.TextColor; }
+            set { textBlock.TextColor = value; }
+        }
+
+        public override ScalableFont Font
+        {
+            get
+            {
+                return (textBlock==null) ? GUI.Font : textBlock.Font;
+            }
+            set
+            {
+                base.Font = value;
+                if (textBlock != null) textBlock.Font = value;                
+            }
+        }
+        
+        public string Text
+        {
+            get { return textBlock.Text; }
+            set { textBlock.Text = value; }
+        }
+
+        public override string ToolTip
+        {
+            get
+            {
+                return base.ToolTip;
+            }
+            set
+            {
+                textBlock.ToolTip = value;
+                base.ToolTip = value;
+            }
+        }
+
+        public override Rectangle Rect
+        {
+            get
+            {
+                return rect;
+            }
+            set
+            {
+                base.Rect = value;
+
+                frame.Rect = new Rectangle(value.X, value.Y, frame.Rect.Width, frame.Rect.Height);
+                textBlock.Rect = value;
+            }
+        }
+
+        public bool Selected { get; set; }
+
+        public GUIButton(Rectangle rect, string text, string style, GUIComponent parent = null)
+            : this(rect, text, null, Alignment.Left, style, parent)
+        {
+        }
+
+        public GUIButton(Rectangle rect, string text, Alignment alignment, string style, GUIComponent parent = null)
+            : this(rect, text, null, alignment, style, parent)
+        {
+        }
+
+        public GUIButton(Rectangle rect, string text, Color? color, string style, GUIComponent parent = null)
+            : this(rect, text, color, (Alignment.Left | Alignment.Top), style, parent)
+        {
+        }
+
+        public GUIButton(Rectangle rect, string text, Color? color, Alignment alignment, string style = "", GUIComponent parent = null)
+            : this(rect, text, color, alignment, Alignment.Center, style, parent)
+        {
+
+        }
+
+        public GUIButton(Rectangle rect, string text, Color? color, Alignment alignment, Alignment textAlignment, string style = "", GUIComponent parent = null)
+            : base(style)
+        {
+            this.rect = rect;
+            if (color != null) this.color = (Color)color;
+            this.alignment = alignment;
+
+            if (parent != null) parent.AddChild(this);
+
+            frame = new GUIFrame(Rectangle.Empty, style, this);
+            GUI.Style.Apply(frame, style == "" ? "GUIButton" : style);
+
+            textBlock = new GUITextBlock(Rectangle.Empty, text,
+                Color.Transparent, (this.style == null) ? Color.Black : this.style.textColor,
+                textAlignment, null, this);
+            GUI.Style.Apply(textBlock, style, this);
+
+            Enabled = true;
+        }
+
+        public override void ApplyStyle(GUIComponentStyle style)
+        {
+            base.ApplyStyle(style);
+
+            if (frame != null) frame.ApplyStyle(style);
+            if (textBlock != null) textBlock.ApplyStyle(style);
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+            
+            DrawChildren(spriteBatch);
+        }
+        
+        public override void Update(float deltaTime)
+        {
+            if (!Visible) return;
+            base.Update(deltaTime);
+            if (rect.Contains(PlayerInput.MousePosition) && CanBeSelected && Enabled && (MouseOn == null || MouseOn == this || IsParentOf(MouseOn)))
+            {
+                state = ComponentState.Hover;
+                if (PlayerInput.LeftButtonHeld())
+                {
+                    if (OnPressed != null)
+                    {
+                        if (OnPressed()) state = ComponentState.Pressed;
+                    }
+                }
+                else if (PlayerInput.LeftButtonClicked())
+                {
+                    GUI.PlayUISound(GUISoundType.Click);
+                    if (OnClicked != null)
+                    {
+                        if (OnClicked(this, UserData) && CanBeSelected) state = ComponentState.Selected;
+                    }
+                    else
+                    {
+                        Selected = !Selected;
+                        // state = state == ComponentState.Selected ? ComponentState.None : ComponentState.Selected;
+                    }
+                }
+            }
+            else
+            {
+                state = Selected ? ComponentState.Selected : ComponentState.None;
+            }
+            frame.State = state;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIComponent.cs

@@ -0,0 +1,543 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using EventInput;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    public abstract class GUIComponent
+    {
+        const float FlashDuration = 1.5f;
+        
+        public static GUIComponent MouseOn
+        {
+            get;
+            private set;
+        }
+        public static void ForceMouseOn(GUIComponent c)
+        {
+            MouseOn = c;
+        }
+
+        protected static List<GUIComponent> ComponentsToUpdate = new List<GUIComponent>();
+
+        public virtual void AddToGUIUpdateList()
+        {
+            if (!Visible) return;
+            if (ComponentsToUpdate.Contains(this)) return;
+            ComponentsToUpdate.Add(this);
+
+            try
+            {
+                List<GUIComponent> fixedChildren = new List<GUIComponent>(children);
+                foreach (GUIComponent c in fixedChildren)
+                {
+                    c.AddToGUIUpdateList();
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.NewMessage("Error in AddToGUIUPdateList! GUIComponent runtime type: "+this.GetType().ToString()+"; children count: "+children.Count.ToString(),Color.Red);
+                throw;
+            }
+        }
+
+        public static void ClearUpdateList()
+        {
+            if (keyboardDispatcher != null &&
+                KeyboardDispatcher.Subscriber is GUIComponent && 
+                !ComponentsToUpdate.Contains((GUIComponent)KeyboardDispatcher.Subscriber))
+            {
+                KeyboardDispatcher.Subscriber = null;
+            }
+
+            ComponentsToUpdate.Clear();
+        }
+
+        public static GUIComponent UpdateMouseOn()
+        {
+            MouseOn = null;
+            for (int i=ComponentsToUpdate.Count-1;i>=0;i--)
+            {
+                GUIComponent c = ComponentsToUpdate[i];
+                if (c.MouseRect.Contains(PlayerInput.MousePosition))
+                {
+                    MouseOn = c;
+                    break;
+                }
+            }
+            return MouseOn;
+        }
+
+        protected static KeyboardDispatcher keyboardDispatcher;
+
+        public enum ComponentState { None, Hover, Pressed, Selected };
+
+        protected Alignment alignment;
+
+        protected GUIComponentStyle style;
+        
+        protected object userData;
+
+        protected Rectangle rect;
+
+        public bool CanBeFocused;
+
+        protected Vector4 padding;
+
+        protected Color color;
+        protected Color hoverColor;
+        protected Color selectedColor;
+
+        protected GUIComponent parent;
+        public List<GUIComponent> children;
+
+        protected ComponentState state;
+
+        protected Color flashColor;
+        protected float flashTimer;
+
+        public virtual ScalableFont Font
+        {
+            get;
+            set;
+        }
+
+        public virtual string ToolTip
+        {
+            get;
+            set;
+        }
+
+        public GUIComponentStyle Style
+        {
+            get { return style; }
+        }
+
+        public bool Visible
+        {
+            get;
+            set;
+        }
+
+        public bool TileSprites;
+
+        private static GUITextBlock toolTipBlock;
+
+        //protected float alpha;
+                
+        public GUIComponent Parent
+        {
+            get { return parent; }
+        }
+
+        public Vector2 Center
+        {
+            get { return new Vector2(rect.Center.X, rect.Center.Y); }
+        }
+                
+        public virtual Rectangle Rect
+        {
+            get { return rect; }
+            set 
+            {
+                int prevX = rect.X, prevY = rect.Y;
+                int prevWidth = rect.Width, prevHeight = rect.Height;
+
+                rect = value;
+
+                if (prevX == rect.X && prevY == rect.Y && rect.Width == prevWidth && rect.Height == prevHeight) return;
+                
+                foreach (GUIComponent child in children)
+                {
+                    child.Rect = new Rectangle(
+                        child.rect.X + (rect.X - prevX), 
+                        child.rect.Y + (rect.Y - prevY),
+                        Math.Max(child.rect.Width + (rect.Width - prevWidth),0),
+                        Math.Max(child.rect.Height + (rect.Height - prevHeight),0));
+                }                
+            }
+        }
+        
+        public virtual Rectangle MouseRect
+        {
+            get { return CanBeFocused ? rect : Rectangle.Empty; }
+        }
+
+        public Dictionary<GUIComponent.ComponentState, List<UISprite>> sprites;
+        //public Alignment SpriteAlignment { get; set; }
+        //public bool RepeatSpriteX, RepeatSpriteY;
+
+        public virtual Color OutlineColor { get; set; }
+
+        public ComponentState State
+        {
+            get { return state; }
+            set { state = value; }
+        }
+
+        public object UserData
+        {
+            get { return userData; }
+            set { userData = value; }
+        }
+
+        public virtual Vector4 Padding
+        {
+            get { return padding; }
+            set { padding = value; }
+        }
+
+        public int CountChildren
+        {
+            get { return children.Count; }
+        }
+
+        public virtual Color Color
+        {
+            get { return color; }
+            set { color = value; }
+        }
+
+        public virtual Color HoverColor
+        {
+            get { return hoverColor; }
+            set { hoverColor = value; }
+        }
+
+        public virtual Color SelectedColor
+        {
+            get { return selectedColor; }
+            set { selectedColor = value; }
+        }
+
+        public static KeyboardDispatcher KeyboardDispatcher
+        {
+            get { return keyboardDispatcher; }
+        }
+
+        protected GUIComponent(string style)
+        {
+            Visible = true;
+
+            TileSprites = true;
+
+            OutlineColor = Color.Transparent;
+
+            Font = GUI.Font;
+            
+            children = new List<GUIComponent>();
+
+            CanBeFocused = true;
+
+            if (style != null)
+                GUI.Style.Apply(this, style);
+        }
+
+        public static void Init(GameWindow window)
+        {
+            keyboardDispatcher = new KeyboardDispatcher(window);
+        }
+
+        public T GetChild<T>() where T : GUIComponent
+        {
+            foreach (GUIComponent child in children)
+            {
+                if (child is T) return (T)(object)child;
+            }
+
+            return default(T);
+        }
+        
+        public GUIComponent GetChild(object obj)
+        {
+            foreach (GUIComponent child in children)
+            {
+                if (child.UserData == obj) return child;
+            }
+            return null;
+        }
+
+        public bool IsParentOf(GUIComponent component)
+        {
+            for(int i = children.Count - 1; i >= 0; i--)
+            {
+                if (children[i] == component) return true;
+                if (children[i].IsParentOf(component)) return true;
+            }
+
+            return false;
+        }
+
+        public virtual void Flash(Color? color = null)
+        {
+            flashTimer = FlashDuration;
+            flashColor = (color == null) ? Color.Red * 0.8f : (Color)color;
+
+            //foreach (GUIComponent child in children)
+            //{
+            //    child.Flash();
+            //}
+        }
+
+        public virtual void Draw(SpriteBatch spriteBatch) 
+        {
+            if (!Visible) return;
+
+            Color currColor = color;
+            if (state == ComponentState.Selected) currColor = selectedColor;
+            if (state == ComponentState.Hover) currColor = hoverColor;
+
+            if (flashTimer > 0.0f)
+            {
+                GUI.DrawRectangle(spriteBatch,
+                    new Rectangle(rect.X - 5, rect.Y - 5, rect.Width + 10, rect.Height + 10),
+                    flashColor * (flashTimer / FlashDuration), true);
+            }
+
+            if (currColor.A > 0.0f && (sprites == null || !sprites.Any())) GUI.DrawRectangle(spriteBatch, rect, currColor * (currColor.A / 255.0f), true);
+
+            if (sprites != null && sprites[state] != null && currColor.A > 0.0f)
+            {
+                foreach (UISprite uiSprite in sprites[state])
+                {
+                    if (uiSprite.Slice)
+                    {
+                        Vector2 pos = new Vector2(rect.X, rect.Y);
+
+                        int centerWidth = Math.Max(rect.Width - uiSprite.Slices[0].Width - uiSprite.Slices[2].Width, 0);
+                        int centerHeight = Math.Max(rect.Height - uiSprite.Slices[0].Height - uiSprite.Slices[8].Height, 0);
+
+                        Vector2 scale = new Vector2(
+                            MathHelper.Clamp((float)rect.Width / (uiSprite.Slices[0].Width + uiSprite.Slices[2].Width),0, 1),
+                            MathHelper.Clamp((float)rect.Height / (uiSprite.Slices[0].Height + uiSprite.Slices[6].Height), 0, 1));
+
+                        for (int x = 0; x < 3; x++)
+                        {
+                            float width = (x == 1 ? centerWidth : uiSprite.Slices[x].Width) * scale.X;
+                            for (int y = 0; y < 3; y++)
+                            {
+                                float height = (y == 1 ? centerHeight : uiSprite.Slices[x + y * 3].Height) * scale.Y;
+
+                                spriteBatch.Draw(uiSprite.Sprite.Texture,
+                                    new Rectangle((int)pos.X, (int)pos.Y, (int)width, (int)height),
+                                    uiSprite.Slices[x + y * 3],
+                                    currColor * (currColor.A / 255.0f));
+                                
+                                pos.Y += height;
+                            }
+                            pos.X += width;
+                            pos.Y = rect.Y;
+                        }
+                    }
+                    else if (uiSprite.Tile)
+                    {
+                        Vector2 startPos = new Vector2(rect.X, rect.Y);
+                        Vector2 size = new Vector2(Math.Min(uiSprite.Sprite.SourceRect.Width, rect.Width), Math.Min(uiSprite.Sprite.SourceRect.Height, rect.Height));
+
+                        if (uiSprite.Sprite.size.X == 0.0f) size.X = rect.Width;
+                        if (uiSprite.Sprite.size.Y == 0.0f) size.Y = rect.Height;
+
+                        uiSprite.Sprite.DrawTiled(spriteBatch, startPos, size, currColor * (currColor.A / 255.0f));
+                    }
+                    else
+                    {
+                        if (uiSprite.MaintainAspectRatio)
+                        {
+                            float scale = (float)(rect.Width) / uiSprite.Sprite.SourceRect.Width;
+
+                            spriteBatch.Draw(uiSprite.Sprite.Texture, rect,
+                                new Rectangle(uiSprite.Sprite.SourceRect.X, uiSprite.Sprite.SourceRect.Y, (int)(uiSprite.Sprite.SourceRect.Width), (int)(rect.Height / scale)), 
+                                currColor * (currColor.A / 255.0f), 0.0f, Vector2.Zero, SpriteEffects.None, 0.0f);
+                        }
+                        else
+                        {
+                            spriteBatch.Draw(uiSprite.Sprite.Texture, rect, uiSprite.Sprite.SourceRect, currColor * (currColor.A / 255.0f));
+                        }
+
+
+                    }
+                }
+            }
+
+            //Color newColor = color;
+            //if (state == ComponentState.Selected)   newColor = selectedColor;
+            //if (state == ComponentState.Hover)      newColor = hoverColor;
+
+            //GUI.DrawRectangle(spriteBatch, rect, newColor*alpha, true);
+            //DrawChildren(spriteBatch);
+        }
+
+        public  void DrawToolTip(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            int width = 400;
+            if (toolTipBlock == null || (string)toolTipBlock.userData != ToolTip)
+            {
+                toolTipBlock = new GUITextBlock(new Rectangle(0, 0, width, 18), ToolTip, "GUIToolTip", Alignment.TopLeft, Alignment.TopLeft, null, true, GUI.SmallFont);
+                toolTipBlock.padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+                toolTipBlock.rect.Width = (int)(GUI.SmallFont.MeasureString(toolTipBlock.WrappedText).X + 20);
+                toolTipBlock.rect.Height = toolTipBlock.WrappedText.Split('\n').Length * 18 + 7;
+                toolTipBlock.userData = ToolTip;
+
+            }
+
+            toolTipBlock.rect = new Rectangle(MouseOn.Rect.Center.X, MouseOn.rect.Bottom, toolTipBlock.rect.Width, toolTipBlock.rect.Height);
+            if (toolTipBlock.rect.Right > GameMain.GraphicsWidth - 10)
+            {
+                toolTipBlock.rect.Location -= new Point(toolTipBlock.rect.Right - (GameMain.GraphicsWidth - 10), 0);
+            }
+
+            toolTipBlock.Draw(spriteBatch);
+        }
+
+        public virtual void Update(float deltaTime)
+        {
+            if (!Visible) return;
+
+            if (flashTimer>0.0f) flashTimer -= deltaTime;
+
+            /*if (CanBeFocused)
+            {
+                if (rect.Contains(PlayerInput.MousePosition))
+                {
+                    MouseOn = this;
+                }
+                else
+                {
+                    if (MouseOn == this) MouseOn = null;
+                }
+
+            }*/
+
+            try
+            {
+                //use a fixed list since children can change their order in the main children list
+                //TODO: maybe find a more efficient way of handling changes in list order
+                List<GUIComponent> fixedChildren = new List<GUIComponent>(children);
+                foreach (GUIComponent c in fixedChildren)
+                {
+                    if (!c.Visible) continue;
+                    c.Update(deltaTime);
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.NewMessage("Error in Update! GUIComponent runtime type: " + this.GetType().ToString() + "; children count: " + children.Count.ToString(), Color.Red);
+                throw;
+            }
+        }
+
+        protected virtual void UpdateDimensions(GUIComponent parent = null)
+        {
+            Rectangle parentRect = (parent==null) ? new Rectangle(0,0,GameMain.GraphicsWidth, GameMain.GraphicsHeight) : parent.rect;
+
+            Vector4 padding = (parent == null) ? Vector4.Zero : parent.padding;
+
+            if (rect.Width == 0) rect.Width = parentRect.Width - rect.X 
+                - (int)padding.X - (int)padding.Z;
+
+            if (rect.Height == 0) rect.Height = parentRect.Height - rect.Y
+                - (int)padding.Y - (int)padding.W;
+
+            if (alignment.HasFlag(Alignment.CenterX))
+            {
+                rect.X += parentRect.X + (int)parentRect.Width/2 - (int)rect.Width/2;
+            }
+            else if (alignment.HasFlag(Alignment.Right))
+            {
+                rect.X += parentRect.X + (int)parentRect.Width - (int)padding.Z - (int)rect.Width;
+            }
+            else
+            {
+                rect.X += parentRect.X + (int)padding.X;
+            }
+
+            if (alignment.HasFlag(Alignment.CenterY))
+            {
+                rect.Y += parentRect.Y + (int)parentRect.Height / 2 - (int)rect.Height / 2;
+            }
+            else if (alignment.HasFlag(Alignment.Bottom))
+            {
+                rect.Y += parentRect.Y + (int)parentRect.Height - (int)padding.W - (int)rect.Height;
+            }
+            else
+            {
+                rect.Y += parentRect.Y + (int)padding.Y;
+            }            
+        }
+
+        public virtual void ApplyStyle(GUIComponentStyle style)
+        {
+            if (style == null) return;
+
+            color = style.Color;
+            hoverColor = style.HoverColor;
+            selectedColor = style.SelectedColor;
+            
+            padding = style.Padding;
+            sprites = style.Sprites;
+
+            OutlineColor = style.OutlineColor;
+
+            this.style = style;
+        }
+
+        public virtual void DrawChildren(SpriteBatch spriteBatch)
+        {
+            for (int i = 0; i < children.Count; i++ )
+            {
+                children[i].Draw(spriteBatch);
+            }
+        }
+
+        public virtual void AddChild(GUIComponent child)
+        {
+            if (child == null) return;
+            if (child.IsParentOf(this))
+            {
+                DebugConsole.ThrowError("Tried to add the parent of a GUIComponent as a child.\n" + Environment.StackTrace);
+                return;
+            }
+            if (child == this)
+            {
+                DebugConsole.ThrowError("Tried to add a GUIComponent as its own child\n" + Environment.StackTrace);
+                return;
+            }
+            if (children.Contains(child))
+            {
+                DebugConsole.ThrowError("Tried to add a the same child twice to a GUIComponent" + Environment.StackTrace);
+                return;
+            }
+
+            child.parent = this;
+            child.UpdateDimensions(this);
+
+            children.Add(child);
+        }
+
+        public virtual void RemoveChild(GUIComponent child)
+        {
+            if (child == null) return;
+            if (children.Contains(child)) children.Remove(child);            
+        }
+
+        public GUIComponent FindChild(object userData)
+        {
+            return children.FirstOrDefault(c => c.userData == userData);
+        }
+
+        public List<GUIComponent> FindChildren(object userData)
+        {
+            return children.FindAll(c => c.userData == userData);
+        }
+
+        public virtual void ClearChildren()
+        {
+            children.Clear();
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIDropDown.cs

@@ -0,0 +1,205 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    public class GUIDropDown : GUIComponent
+    {
+
+        public delegate bool OnSelectedHandler(GUIComponent selected, object obj = null);
+        public OnSelectedHandler OnSelected;
+
+        private GUIButton button;
+        private GUIListBox listBox;
+
+        public bool Dropped { get; set; }
+
+        public object SelectedItemData
+        {
+            get
+            {
+                if (listBox.Selected == null) return null;
+                return listBox.Selected.UserData;
+            }
+        }
+
+        public bool Enabled
+        {
+            get { return listBox.Enabled; }
+            set { listBox.Enabled = value; }
+        }
+
+        public GUIComponent Selected
+        {
+            get { return listBox.Selected; }
+        }
+
+        public GUIListBox ListBox
+        {
+            get { return listBox; }
+        }
+
+        public object SelectedData
+        {
+            get
+            {
+                return (listBox.Selected == null) ? null : listBox.Selected.UserData;
+            }
+        }
+
+        public int SelectedIndex
+        {
+            get
+            {
+                if (listBox.Selected == null) return -1;
+                return listBox.children.FindIndex(x => x == listBox.Selected);
+            }
+        }
+
+        public override string ToolTip
+        {
+            get
+            {
+                return base.ToolTip;
+            }
+            set
+            {
+                base.ToolTip    = value;
+                button.ToolTip  = value;
+                listBox.ToolTip = value;
+            }
+        }
+        
+        public GUIDropDown(Rectangle rect, string text, string style, GUIComponent parent = null)
+            : base(style)
+        {
+            this.rect = rect;
+
+            if (parent != null) parent.AddChild(this);
+
+            button = new GUIButton(this.rect, text, Color.White, Alignment.TopLeft, Alignment.CenterLeft, "GUIDropDown", null);
+            GUI.Style.Apply(button, style, this);
+            
+            button.OnClicked = OnClicked;
+
+            listBox = new GUIListBox(new Rectangle(this.rect.X, this.rect.Bottom, this.rect.Width, 200), style, null);
+            listBox.OnSelected = SelectItem;
+        }
+
+        public override void AddChild(GUIComponent child)
+        {
+            listBox.AddChild(child);
+        }
+
+        public void AddItem(string text, object userData = null)
+        {
+            GUITextBlock textBlock = new GUITextBlock(new Rectangle(0,0,0,20), text, "ListBoxElement", Alignment.TopLeft, Alignment.CenterLeft, listBox);
+            textBlock.UserData = userData;
+        }
+
+        public override void ClearChildren()
+        {
+            listBox.ClearChildren();
+        }
+
+        public List<GUIComponent> GetChildren()
+        {
+            return listBox.children;
+        }
+
+        private bool SelectItem(GUIComponent component, object obj)
+        {
+            GUITextBlock textBlock = component as GUITextBlock;
+            if (textBlock==null) return false;
+            button.Text = textBlock.Text;
+
+            Dropped = false;
+
+            if (OnSelected != null) OnSelected(component, component.UserData);
+
+            return true;
+        }
+
+        public void SelectItem(object userData)
+        {
+            //GUIComponent child = listBox.children.FirstOrDefault(c => c.UserData == userData);
+
+            //if (child == null) return;
+
+            listBox.Select(userData);
+
+            //SelectItem(child, userData);
+        }
+
+        public void Select(int index)
+        {
+            listBox.Select(index);
+        }
+       
+
+        private bool wasOpened;
+
+        private bool OnClicked(GUIComponent component, object obj)
+        {
+            if (wasOpened) return false;
+            
+            wasOpened = true;
+            Dropped = !Dropped;
+
+            if (Dropped && parent.children[parent.children.Count-1]!=this)
+            {
+                parent.children.Remove(this);
+                parent.children.Add(this);
+            }
+
+            return true;
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            base.AddToGUIUpdateList();
+            button.AddToGUIUpdateList();
+            if (Dropped) listBox.AddToGUIUpdateList();
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (!Visible) return;
+
+            wasOpened = false;
+
+            base.Update(deltaTime);
+
+            if (Dropped && PlayerInput.LeftButtonClicked())
+            {
+                Rectangle listBoxRect = listBox.Rect;
+                listBoxRect.Width += 20;
+                if (!listBoxRect.Contains(PlayerInput.MousePosition) && !button.Rect.Contains(PlayerInput.MousePosition))
+                {
+                    Dropped = false;
+                }
+            }
+            
+            button.Update(deltaTime);
+
+            if (Dropped) listBox.Update(deltaTime);
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            base.Draw(spriteBatch);
+
+            button.Draw(spriteBatch);
+
+            if (!Dropped) return;
+
+            listBox.Draw(spriteBatch);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIFrame.cs

@@ -0,0 +1,61 @@
+using Microsoft.Xna.Framework;
+using System.Linq;
+
+namespace Barotrauma
+{
+    public class GUIFrame : GUIComponent
+    {        
+        public GUIFrame(Rectangle rect, string style = "", GUIComponent parent = null)
+            : this(rect, null, (Alignment.Left | Alignment.Top), style, parent)
+        {
+        }
+
+
+        public GUIFrame(Rectangle rect, Color color, string style = "", GUIComponent parent = null)
+            : this(rect, color, (Alignment.Left | Alignment.Top), style, parent)
+        {
+        }
+
+        public GUIFrame(Rectangle rect, Color? color, Alignment alignment, string style = "", GUIComponent parent = null)
+            : base(style)
+        {
+            this.rect = rect;
+
+            this.alignment = alignment;
+
+            if (color != null) this.color = (Color)color;
+
+            if (parent != null)
+            {
+                parent.AddChild(this);
+            }
+            else
+            {
+                UpdateDimensions();
+            }
+
+            //if (style != null) ApplyStyle(style);
+        }
+
+        public override void Draw(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+                           
+            Color currColor = color;
+            if (state == ComponentState.Selected) currColor = selectedColor;
+            if (state == ComponentState.Hover) currColor = hoverColor;
+
+            if (sprites == null || !sprites.Any()) GUI.DrawRectangle(spriteBatch, rect, currColor * (currColor.A/255.0f), true);
+            base.Draw(spriteBatch);
+
+            if (OutlineColor != Color.Transparent)
+            {
+                GUI.DrawRectangle(spriteBatch, rect, OutlineColor * (OutlineColor.A/255.0f), false);
+            }
+
+
+            DrawChildren(spriteBatch);
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIImage.cs

@@ -0,0 +1,97 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    public class GUIImage : GUIComponent
+    {
+        public float Rotation;
+
+        private Sprite sprite;
+
+        private Rectangle sourceRect;
+
+        bool crop;
+        
+        public bool Crop
+        {
+            get
+            { 
+                return crop;
+            }
+            set
+            {
+                crop = value;
+                if (crop)
+                {                                
+                    sourceRect.Width = Math.Min(sprite.SourceRect.Width, Rect.Width);
+                    sourceRect.Height = Math.Min(sprite.SourceRect.Height, Rect.Height);
+                }
+            }
+        }
+
+        public float Scale
+        {
+            get;
+            set;
+        }
+
+        public Rectangle SourceRect
+        {
+            get { return sourceRect; }
+            set { sourceRect = value; }
+        }
+
+        public GUIImage(Rectangle rect, string spritePath, Alignment alignment, GUIComponent parent = null)
+            : this(rect, new Sprite(spritePath, Vector2.Zero), alignment, parent)
+        {
+        }
+
+        public GUIImage(Rectangle rect, Sprite sprite, Alignment alignment, GUIComponent parent = null)
+            : this(rect, sprite==null ? Rectangle.Empty : sprite.SourceRect, sprite, alignment, parent)
+        {
+        }
+
+        public GUIImage(Rectangle rect, Rectangle sourceRect, Sprite sprite, Alignment alignment, GUIComponent parent = null)
+            : base(null)
+        {
+            this.rect = rect;
+
+            this.alignment = alignment;
+
+            color = Color.White;
+
+            //alpha = 1.0f;
+
+            Scale = 1.0f;
+
+            this.sprite = sprite;
+
+            if (rect.Width == 0) this.rect.Width = (int)sprite.size.X;
+            if (rect.Height == 0) this.rect.Height = (int)Math.Min(sprite.size.Y, sprite.size.Y * (this.rect.Width / sprite.size.X));
+
+            this.sourceRect = sourceRect;
+
+            if (parent != null) parent.AddChild(this);
+            this.parent = parent;
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            Color currColor = color;
+            if (state == ComponentState.Hover) currColor = hoverColor;
+            if (state == ComponentState.Selected) currColor = selectedColor;
+
+            if (sprite != null && sprite.Texture != null)
+            {
+                spriteBatch.Draw(sprite.Texture, new Vector2(rect.X, rect.Y), sourceRect, currColor * (currColor.A / 255.0f), Rotation, Vector2.Zero,
+                    Scale, SpriteEffects.None, 0.0f);
+            }          
+            
+            DrawChildren(spriteBatch);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIListBox.cs

@@ -0,0 +1,426 @@
+using System;
+using System.Linq;
+using System.Diagnostics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    public class GUIListBox : GUIComponent
+    {
+        protected List<GUIComponent> selected;
+
+        public delegate bool OnSelectedHandler(GUIComponent component, object obj);
+        public OnSelectedHandler OnSelected;
+
+        public delegate object CheckSelectedHandler();
+        public CheckSelectedHandler CheckSelected;
+
+        private GUIScrollBar scrollBar;
+        private GUIFrame frame;
+
+        private int totalSize;
+
+        private int spacing;
+
+        private bool scrollBarEnabled;
+        private bool scrollBarHidden;
+
+        private bool enabled;
+
+        public bool SelectMultiple;
+
+        public GUIComponent Selected
+        {
+            get
+            {
+                return selected.Any() ? selected[0] : null;
+            }
+        }
+
+        public List<GUIComponent> AllSelected
+        {
+            get { return selected; }
+        }
+
+        public object SelectedData
+        {
+            get
+            {
+                return (Selected == null) ? null : Selected.UserData;
+            }
+        }
+
+        public int SelectedIndex
+        {
+            get
+            {
+                if (Selected == null) return -1;
+                return children.FindIndex(x => x == Selected);
+            }
+        }
+
+        public float BarScroll
+        {
+            get { return scrollBar.BarScroll; }
+            set { scrollBar.BarScroll = value; }
+        }
+
+        public float BarSize
+        {
+            get { return scrollBar.BarSize; }
+        }
+
+        public int Spacing
+        {
+            get { return spacing; }
+            set { spacing = value; }
+        }
+
+        public bool Enabled
+        {
+            get { return enabled; }
+            set { enabled = value; }
+        }
+
+        public override Color Color
+        {
+            get
+            {
+                return base.Color;
+            }
+            set
+            {
+                base.Color = value;
+
+                frame.Color = value;
+            }
+        }
+
+        public bool ScrollBarEnabled
+        {
+            get { return scrollBarEnabled; }
+            set
+            {
+                scrollBarEnabled = value;
+            }
+        }
+
+        public GUIListBox(Rectangle rect, string style, GUIComponent parent = null)
+            : this(rect, style, Alignment.TopLeft, parent)
+        {
+        }
+
+        public GUIListBox(Rectangle rect, string style, Alignment alignment, GUIComponent parent = null)
+            : this(rect, null, alignment, style, parent, false)
+        {
+        }
+
+        public GUIListBox(Rectangle rect, Color? color, string style = null, GUIComponent parent = null)
+            : this(rect, color, (Alignment.Left | Alignment.Top), style, parent)
+        {
+        }
+
+        public GUIListBox(Rectangle rect, Color? color, Alignment alignment, string style = null, GUIComponent parent = null, bool isHorizontal = false)
+            : base(style)
+        {
+            this.rect = rect;
+            this.alignment = alignment;
+
+            selected = new List<GUIComponent>();
+
+            if (color != null) this.color = (Color)color;
+
+            if (parent != null)
+                parent.AddChild(this);
+
+            scrollBarHidden = true;
+
+            if (isHorizontal)
+            {
+                scrollBar = new GUIScrollBar(
+                    new Rectangle(this.rect.X, this.rect.Bottom - 20, this.rect.Width, 20), null, 1.0f, "");
+            }
+            else
+            {
+                scrollBar = new GUIScrollBar(
+                    new Rectangle(this.rect.Right - 20, this.rect.Y, 20, this.rect.Height), null, 1.0f, "");
+            }
+
+            scrollBar.IsHorizontal = isHorizontal;            
+
+            frame = new GUIFrame(new Rectangle(0, 0, this.rect.Width, this.rect.Height), style, this);
+            if (style != null) GUI.Style.Apply(frame, style, this);
+
+            UpdateScrollBarSize();
+
+            children.Clear();
+
+            enabled = true;
+
+            scrollBarEnabled = true;
+
+            scrollBar.BarScroll = 0.0f;
+        }
+        
+        public void Select(object userData, bool force = false)
+        {
+            for (int i = 0; i < children.Count; i++)
+            {
+                if (!children[i].UserData.Equals(userData)) continue;
+
+                Select(i, force);
+
+                //if (OnSelected != null) OnSelected(Selected, Selected.UserData);
+                if (!SelectMultiple) return;
+            }
+        }
+
+        private void UpdateChildrenRect(float deltaTime)
+        {
+            int x = rect.X, y = rect.Y;
+
+            if (!scrollBarHidden)
+            {
+                if (scrollBar.IsHorizontal)
+                {
+                    x -= (int)((totalSize - rect.Width) * scrollBar.BarScroll);
+                }
+                else
+                {
+                    y -= (int)((totalSize - rect.Height) * scrollBar.BarScroll);
+                }
+            }
+
+            for (int i = 0; i < children.Count; i++)
+            {
+                GUIComponent child = children[i];
+                if (child == frame || !child.Visible) continue;
+
+                child.Rect = new Rectangle(x, y, child.Rect.Width, child.Rect.Height);
+                if (scrollBar.IsHorizontal)
+                {
+                    x += child.Rect.Width + spacing;
+                }
+                else
+                {
+                    y += child.Rect.Height + spacing;
+                }
+                
+                if (deltaTime>0.0f) child.Update(deltaTime);
+                if (enabled && child.CanBeFocused &&
+                    (MouseOn == this || (MouseOn != null && this.IsParentOf(MouseOn))) && child.Rect.Contains(PlayerInput.MousePosition))
+                {
+                    child.State = ComponentState.Hover;
+                    if (PlayerInput.LeftButtonClicked())
+                    {
+                        Select(i);
+                    }
+                }
+                else if (selected.Contains(child))
+                {
+                    child.State = ComponentState.Selected;
+
+                    if (CheckSelected != null)
+                    {
+                        if (CheckSelected() != child.UserData) selected.Remove(child);
+                    }
+                }
+                else
+                {
+                    child.State = ComponentState.None;
+                }
+            }
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            if (!Visible) return;
+            if (ComponentsToUpdate.Contains(this)) return;
+            ComponentsToUpdate.Add(this);
+
+            try
+            {
+                List<GUIComponent> fixedChildren = new List<GUIComponent>(children);
+                int lastVisible = 0;
+                for (int i = 0; i < fixedChildren.Count; i++)
+                {
+                    if (fixedChildren[i] == frame) continue;
+
+                    if (!IsChildVisible(fixedChildren[i]))
+                    {
+                        if (lastVisible > 0) break;
+                        continue;
+                    }
+
+                    lastVisible = i;
+                    fixedChildren[i].AddToGUIUpdateList();
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.NewMessage("Error in AddToGUIUpdateList! GUIComponent runtime type: " + this.GetType().ToString() + "; children count: " + children.Count.ToString(), Color.Red);
+                throw;
+            }
+
+            if (scrollBarEnabled && !scrollBarHidden) scrollBar.AddToGUIUpdateList();
+        }
+
+        public override Rectangle MouseRect
+        {
+            get
+            {
+                return rect;
+            }
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (!Visible) return;
+
+            UpdateChildrenRect(deltaTime);
+            
+            //base.Update(deltaTime);
+
+            if (scrollBarEnabled && !scrollBarHidden) scrollBar.Update(deltaTime);
+
+            if ((MouseOn == this || MouseOn == scrollBar || IsParentOf(MouseOn)) && PlayerInput.ScrollWheelSpeed != 0)
+            {
+                scrollBar.BarScroll -= (PlayerInput.ScrollWheelSpeed / 500.0f) * BarSize;
+            }
+        }
+
+        public void Select(int childIndex, bool force = false)
+        {
+            if (childIndex >= children.Count || childIndex < 0) return;
+
+            bool wasSelected = true;
+            if (OnSelected != null) wasSelected = OnSelected(children[childIndex], children[childIndex].UserData) || force;
+            
+            if (!wasSelected) return;
+
+            if (SelectMultiple)
+            {
+                if (selected.Contains(children[childIndex]))
+                {
+                    selected.Remove(children[childIndex]);
+                }
+                else
+                {
+                    selected.Add(children[childIndex]);
+                }
+            }
+            else
+            {
+                selected.Clear();
+                selected.Add(children[childIndex]);
+            }
+
+        }
+
+        public void Deselect()
+        {
+            selected.Clear();
+        }
+
+        public void UpdateScrollBarSize()
+        {
+            totalSize = 0;
+            foreach (GUIComponent child in children)
+            {
+                if (child == frame) continue;
+                totalSize += (scrollBar.IsHorizontal) ? child.Rect.Width : child.Rect.Height;
+                totalSize += spacing;
+            }
+
+            scrollBar.BarSize = scrollBar.IsHorizontal ?
+                Math.Max(Math.Min((float)rect.Width / (float)totalSize, 1.0f), 5.0f / rect.Width) :
+                Math.Max(Math.Min((float)rect.Height / (float)totalSize, 1.0f), 5.0f / rect.Height);
+
+            scrollBarHidden = scrollBar.BarSize >= 1.0f;
+        }
+
+        public override void AddChild(GUIComponent child)
+        {
+            //temporarily reduce the size of the rect to prevent the child from expanding over the scrollbar
+            if (scrollBar.IsHorizontal)            
+                rect.Height -= scrollBar.Rect.Height;
+            else
+                rect.Width -= scrollBar.Rect.Width;
+
+            base.AddChild(child);
+
+            if (scrollBar.IsHorizontal)
+                rect.Height += scrollBar.Rect.Height;
+            else
+                rect.Width += scrollBar.Rect.Width;
+            
+            UpdateScrollBarSize();
+            UpdateChildrenRect(0.0f);
+        }
+
+        public override void ClearChildren()
+        {
+            base.ClearChildren();
+            selected.Clear();
+        }
+
+        public override void RemoveChild(GUIComponent child)
+        {
+            base.RemoveChild(child);
+
+            if (selected.Contains(child)) selected.Remove(child);
+
+            UpdateScrollBarSize();
+        }
+        
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+            
+            frame.Draw(spriteBatch);
+
+            if (!scrollBarHidden) scrollBar.Draw(spriteBatch);
+
+            Rectangle prevScissorRect = spriteBatch.GraphicsDevice.ScissorRectangle;
+            spriteBatch.GraphicsDevice.ScissorRectangle = frame.Rect;
+
+            int lastVisible = 0;
+            for (int i = 0; i < children.Count; i++)
+            {
+                GUIComponent child = children[i];
+                if (child == frame || !child.Visible) continue;
+
+                if (!IsChildVisible(child))
+                {
+                    if (lastVisible > 0) break;
+                    continue;
+                }
+
+                lastVisible = i;         
+                child.Draw(spriteBatch);
+            }
+
+            spriteBatch.GraphicsDevice.ScissorRectangle = prevScissorRect;
+        }
+
+        private bool IsChildVisible(GUIComponent child)
+        {
+            if (child == null) return false;
+
+            if (scrollBar.IsHorizontal)
+            {
+                if (child.Rect.Right < rect.X) return false;
+                if (child.Rect.X > rect.Right) return false;
+            }
+            else
+            {
+                if (child.Rect.Bottom < rect.Y) return false;
+                if (child.Rect.Y > rect.Bottom) return false;
+            }
+
+            return true;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIMessage.cs

@@ -0,0 +1,51 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    class GUIMessage
+    {
+        private ColoredText coloredText;
+        private Vector2 pos;
+
+        private float lifeTime;
+
+        private Vector2 size;
+
+        public string Text
+        {
+            get { return coloredText.Text; }
+        }
+
+        public Color Color
+        {
+            get { return coloredText.Color; }
+        }
+
+        public Vector2 Pos
+        {
+            get { return pos; }
+            set { pos = value; }
+        }
+
+        public Vector2 Size
+        {
+            get { return size; }
+        }
+
+
+        public float LifeTime
+        {
+            get { return lifeTime; }
+            set { lifeTime = value; }
+        }
+
+        public GUIMessage(string text, Color color, Vector2 position, float lifeTime)
+        {
+            coloredText = new ColoredText(text, color);
+            pos = position;
+            this.lifeTime = lifeTime;
+
+            size = GUI.Font.MeasureString(text);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIMessageBox.cs

@@ -0,0 +1,96 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    public class GUIMessageBox : GUIFrame
+    {
+        public static List<GUIComponent> MessageBoxes = new List<GUIComponent>();
+
+        const int DefaultWidth=400, DefaultHeight=250;
+
+        //public delegate bool OnClickedHandler(GUIButton button, object obj);
+        //public OnClickedHandler OnClicked;
+
+        //GUIFrame frame;
+        public GUIButton[] Buttons;
+
+        public static GUIComponent VisibleBox
+        {
+            get { return MessageBoxes.Count == 0 ? null : MessageBoxes[0]; }
+        }
+
+        public string Text
+        {
+            get { return (children[0].children[1] as GUITextBlock).Text; }
+            set { (children[0].children[1] as GUITextBlock).Text = value; }
+        }
+
+        public GUIMessageBox(string headerText, string text)
+            : this(headerText, text, new string[] {"OK"})
+        {
+            this.Buttons[0].OnClicked = Close;
+        }
+
+        public GUIMessageBox(string headerText, string text, int width, int height)
+            : this(headerText, text, new string[] { "OK" }, width, height)
+        {
+            this.Buttons[0].OnClicked = Close;
+        }
+
+        public GUIMessageBox(string headerText, string text, string[] buttons, int width = DefaultWidth, int height = DefaultHeight, Alignment textAlignment = Alignment.TopLeft, GUIComponent parent = null)
+            : base(new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight),
+                Color.Black * 0.5f, Alignment.TopLeft, null, parent)
+        {
+            if (height == 0)
+            {
+                string wrappedText = ToolBox.WrapText(text, width, GUI.Font);
+                string[] lines = wrappedText.Split('\n');
+                foreach (string line in lines)
+                {
+                    height += (int)GUI.Font.MeasureString(line).Y;
+                }
+                height += 220;
+            }
+
+            var frame = new GUIFrame(new Rectangle(0, 0, width, height), null, Alignment.Center, "", this);
+            GUI.Style.Apply(frame, "", this);
+
+            var header = new GUITextBlock(new Rectangle(0, 0, 0, 30), headerText, null, null, textAlignment, "", frame, true);
+            GUI.Style.Apply(header, "", this);
+
+            if (!string.IsNullOrWhiteSpace(text))
+            {
+                var textBlock = new GUITextBlock(new Rectangle(0, 30, 0, height - 70), text,
+                    null, null, textAlignment, "", frame, true);
+                GUI.Style.Apply(textBlock, "", this);
+            }
+
+            int x = 0;
+            this.Buttons = new GUIButton[buttons.Length];
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                this.Buttons[i] = new GUIButton(new Rectangle(x, 0, 150, 30), buttons[i], Alignment.Left | Alignment.Bottom, "", frame);
+
+                x += this.Buttons[i].Rect.Width + 20;
+            }
+
+            MessageBoxes.Add(this);
+        }
+
+
+
+        public bool Close(GUIButton button, object obj)
+        {
+            if (parent != null) parent.RemoveChild(this);
+            if (MessageBoxes.Contains(this)) MessageBoxes.Remove(this);
+
+            return true;
+        }
+
+        public static void CloseAll()
+        {
+            MessageBoxes.Clear();
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIProgressBar.cs

@@ -0,0 +1,125 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    public class GUIProgressBar : GUIComponent
+    {
+        private bool isHorizontal;
+
+        private GUIFrame frame, slider;
+        private float barSize;
+                
+        public delegate float ProgressGetterHandler();
+        public ProgressGetterHandler ProgressGetter;
+
+        public bool IsHorizontal
+        {
+            get { return isHorizontal; }
+            set { isHorizontal = value; }
+        }
+
+        public float BarSize
+        {
+            get { return barSize; }
+            set
+            {
+                float oldBarSize = barSize;
+                barSize = MathHelper.Clamp(value, 0.0f, 1.0f);
+                if (barSize != oldBarSize) UpdateRect();
+            }
+        }
+
+        public GUIProgressBar(Rectangle rect, Color color, float barSize, GUIComponent parent = null)
+            : this(rect, color, barSize, (Alignment.Left | Alignment.Top), parent)
+        {
+        }
+
+        public GUIProgressBar(Rectangle rect, Color color, float barSize, Alignment alignment, GUIComponent parent = null)
+            : this(rect, color, null, barSize, alignment, parent)
+        {
+
+        }
+
+        public GUIProgressBar(Rectangle rect, Color color, string style, float barSize, Alignment alignment, GUIComponent parent = null)
+            : base(style)
+        {
+            this.rect = rect;
+            this.color = color;
+            isHorizontal = (rect.Width > rect.Height);
+
+            this.alignment = alignment;
+            
+            if (parent != null)
+                parent.AddChild(this);
+
+            frame = new GUIFrame(new Rectangle(0, 0, 0, 0), null, this);
+            GUI.Style.Apply(frame, "", this);
+
+            slider = new GUIFrame(new Rectangle(0, 0, 0, 0), null);
+            GUI.Style.Apply(slider, "Slider", this);
+
+            this.barSize = barSize;
+            UpdateRect();
+        }
+
+        /*public override void ApplyStyle(GUIComponentStyle style)
+        {
+            if (frame == null) return;
+
+            frame.Color = style.Color;
+            frame.HoverColor = style.HoverColor;
+            frame.SelectedColor = style.SelectedColor;
+
+            Padding = style.Padding;
+
+            frame.OutlineColor = style.OutlineColor;
+
+            this.style = style;
+        }*/
+
+        private void UpdateRect()
+        {
+            slider.Rect = new Rectangle(
+                (int)(frame.Rect.X + padding.X),
+                (int)(frame.Rect.Y + padding.Y),
+                isHorizontal ? (int)((frame.Rect.Width - padding.X - padding.Z) * barSize) : frame.Rect.Width,
+                isHorizontal ? (int)(frame.Rect.Height - padding.Y - padding.W) : (int)(frame.Rect.Height * barSize));
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            if (ProgressGetter != null) BarSize = ProgressGetter();
+
+            DrawChildren(spriteBatch);
+
+            Color currColor = color;
+            if (state == ComponentState.Selected) currColor = selectedColor;
+            if (state == ComponentState.Hover) currColor = hoverColor;
+
+            if (slider.sprites != null && slider.sprites[state].Count > 0)
+            {
+                foreach (UISprite uiSprite in slider.sprites[state])
+                {
+                    if (uiSprite.Tile)
+                    {
+                        uiSprite.Sprite.DrawTiled(spriteBatch, slider.Rect.Location.ToVector2(), slider.Rect.Size.ToVector2(), currColor);
+                    }
+                    else
+                    {
+                        spriteBatch.Draw(uiSprite.Sprite.Texture,
+                            slider.Rect, new Rectangle(
+                                uiSprite.Sprite.SourceRect.X, 
+                                uiSprite.Sprite.SourceRect.Y, 
+                                (int)(uiSprite.Sprite.SourceRect.Width * (isHorizontal ? barSize : 1.0f)),
+                                (int)(uiSprite.Sprite.SourceRect.Height * (isHorizontal ? 1.0f : barSize))), 
+                            currColor);
+                    }
+                }
+            }
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIScrollBar.cs

@@ -0,0 +1,218 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    public class GUIScrollBar : GUIComponent
+    {
+        public static GUIScrollBar draggingBar;
+
+        private bool isHorizontal;
+
+        private GUIFrame frame;
+        private GUIButton bar;
+        private float barSize;
+        private float barScroll;
+
+        private float step;
+
+        private bool enabled;
+
+        public delegate bool OnMovedHandler(GUIScrollBar scrollBar, float barScroll);
+        public OnMovedHandler OnMoved;
+
+        public bool IsHorizontal
+        {
+            get { return isHorizontal; }
+            set 
+            { 
+                if (isHorizontal == value) return;
+                isHorizontal = value;
+                UpdateRect();
+            }
+        }
+
+        public bool Enabled
+        {
+            get { return enabled; }
+            set { enabled = value; }
+        }
+
+        public float BarScroll
+        {
+            get { return step == 0.0f ? barScroll : MathUtils.RoundTowardsClosest(barScroll, step); }
+            set
+            {
+                barScroll = MathHelper.Clamp(value, 0.0f, 1.0f);
+                int newX = bar.Rect.X - frame.Rect.X;
+                int newY = bar.Rect.Y - frame.Rect.Y;
+
+                float newScroll = step == 0.0f ? barScroll : MathUtils.RoundTowardsClosest(barScroll, step);
+
+                if (isHorizontal)
+                {
+                    newX = (int)(frame.Padding.X + newScroll * (frame.Rect.Width - bar.Rect.Width - frame.Padding.X - frame.Padding.Z));
+                    newX = MathHelper.Clamp(newX, (int)frame.Padding.X, frame.Rect.Width - bar.Rect.Width - (int)frame.Padding.Z);
+
+                }
+                else
+                {
+                    newY = (int)(frame.Padding.Y + newScroll * (frame.Rect.Height - bar.Rect.Height - frame.Padding.Y - frame.Padding.W));
+                    newY = MathHelper.Clamp(newY, (int)frame.Padding.Y, frame.Rect.Height - bar.Rect.Height - (int)frame.Padding.W);
+
+                }
+                bar.Rect = new Rectangle(newX + frame.Rect.X, newY + frame.Rect.Y, bar.Rect.Width, bar.Rect.Height);
+            }
+        }
+
+        public float Step
+        {
+            get
+            {
+                return step;
+            }
+            set
+            {
+                step = MathHelper.Clamp(value, 0.0f, 1.0f);
+            }
+        }
+
+        public float BarSize
+        {
+            get { return barSize; }
+            set 
+            {
+                float oldBarSize = barSize;
+                barSize = Math.Min(Math.Max(value, 0.0f), 1.0f);
+                if (barSize != oldBarSize) UpdateRect();
+            }
+        }
+
+        public GUIScrollBar(Rectangle rect, string style, float barSize, GUIComponent parent = null)
+            : this(rect, null, barSize, style, parent)
+        {
+        }
+
+        public GUIScrollBar(Rectangle rect, Color? color, float barSize, string style = "", GUIComponent parent = null)
+            : this(rect, color, barSize, Alignment.TopLeft, style, parent)
+        {
+        }
+
+
+        public GUIScrollBar(Rectangle rect, Color? color, float barSize, Alignment alignment, string style = "", GUIComponent parent = null)
+            : base(style)
+        {
+            this.rect = rect;
+            //GetDimensions(parent);
+
+            this.alignment = alignment;
+
+            if (parent != null)
+                parent.AddChild(this);
+
+            isHorizontal = (rect.Width > rect.Height);
+            frame = new GUIFrame(new Rectangle(0,0,0,0), style, this);
+            GUI.Style.Apply(frame, isHorizontal ? "GUIFrameHorizontal" : "GUIFrameVertical", this);
+
+            this.barSize = barSize;
+
+            bar = new GUIButton(new Rectangle(0, 0, 0, 0), "", color, "", this);
+            GUI.Style.Apply(bar, isHorizontal ? "GUIButtonHorizontal" : "GUIButtoneVertical", this);
+            
+            bar.OnPressed = SelectBar;
+
+            enabled = true;
+
+            UpdateRect();
+        }
+
+        private void UpdateRect()
+        {
+            float width = frame.Rect.Width - frame.Padding.X - frame.Padding.Z;
+            float height = frame.Rect.Height - frame.Padding.Y - frame.Padding.W;
+
+            bar.Rect = new Rectangle(
+                bar.Rect.X,
+                bar.Rect.Y,
+                isHorizontal ? (int)(width * barSize) : (int)width,
+                isHorizontal ? (int)height : (int)(height * barSize));
+
+            ClampRect();
+
+            foreach (GUIComponent child in bar.children)
+            {
+                child.Rect = bar.Rect;
+            }
+        }
+
+        private void ClampRect()
+        {
+            bar.Rect = new Rectangle(
+                (int)MathHelper.Clamp(bar.Rect.X, frame.Rect.X + frame.Padding.X, frame.Rect.Right - bar.Rect.Width - frame.Padding.X - frame.Padding.Z),
+                (int)MathHelper.Clamp(bar.Rect.Y, frame.Rect.Y + frame.Padding.Y, frame.Rect.Bottom - bar.Rect.Height - frame.Padding.Y - frame.Padding.W), 
+                bar.Rect.Width, 
+                bar.Rect.Height);
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (!Visible) return;
+
+            base.Update(deltaTime);
+
+            if (MouseOn == frame)
+            {
+                if (PlayerInput.LeftButtonClicked())
+                {
+                    MoveButton(new Vector2(
+                        Math.Sign(PlayerInput.MousePosition.X - bar.Rect.Center.X) * bar.Rect.Width,
+                        Math.Sign(PlayerInput.MousePosition.Y - bar.Rect.Center.Y) * bar.Rect.Height));
+                }
+            }
+
+            if (draggingBar == this)
+            {
+                if (!PlayerInput.LeftButtonHeld()) draggingBar = null;
+                MoveButton(PlayerInput.MouseSpeed);
+            }       
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            DrawChildren(spriteBatch);
+        }
+
+        private bool SelectBar()
+        {
+            if (!enabled) return false;
+            if (barSize == 1.0f) return false;
+
+            draggingBar = this;
+
+            return true;
+
+        }
+
+        private void MoveButton(Vector2 moveAmount)
+        {
+            if (isHorizontal)
+            {
+                moveAmount.Y = 0.0f;
+                barScroll += moveAmount.X / (frame.Rect.Width - bar.Rect.Width - frame.Padding.X - frame.Padding.Z);
+            }
+            else
+            {
+                moveAmount.X = 0.0f;
+                barScroll += moveAmount.Y / (frame.Rect.Height - bar.Rect.Height - frame.Padding.Y - frame.Padding.W);
+            }
+
+            BarScroll = barScroll;
+
+            if (moveAmount != Vector2.Zero && OnMoved != null) OnMoved(this, BarScroll);
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUIStyle.cs

@@ -0,0 +1,73 @@
+using System.Xml.Linq;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    public class GUIStyle
+    {
+        private Dictionary<string, GUIComponentStyle> componentStyles;
+                
+        public GUIStyle(string file)
+        {
+            componentStyles = new Dictionary<string, GUIComponentStyle>();
+
+            XDocument doc;
+            try
+            {
+                ToolBox.IsProperFilenameCase(file);
+                doc = XDocument.Load(file);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Loading style \"" + file + "\" failed", e);
+                return;
+            }
+
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                GUIComponentStyle componentStyle = new GUIComponentStyle(subElement);
+                componentStyles.Add(subElement.Name.ToString().ToLowerInvariant(), componentStyle);
+            }
+        }
+
+        public void Apply(GUIComponent targetComponent, string styleName = "", GUIComponent parent = null)
+        {
+            GUIComponentStyle componentStyle = null;  
+            if (parent != null)
+            {
+
+                GUIComponentStyle parentStyle = parent.Style;
+
+                if (parent.Style == null)
+                {
+                    string parentStyleName = parent.GetType().Name.ToLowerInvariant();
+
+                    if (!componentStyles.TryGetValue(parentStyleName, out parentStyle))
+                    {
+                        DebugConsole.ThrowError("Couldn't find a GUI style \""+ parentStyleName + "\"");
+                        return;
+                    }
+                }
+
+
+                string childStyleName = string.IsNullOrEmpty(styleName) ? targetComponent.GetType().Name : styleName;
+                parentStyle.ChildStyles.TryGetValue(childStyleName.ToLowerInvariant(), out componentStyle);
+            }
+            else
+            {
+                if (string.IsNullOrEmpty(styleName))
+                {
+                    styleName = targetComponent.GetType().Name;
+                }
+                if (!componentStyles.TryGetValue(styleName.ToLowerInvariant(), out componentStyle))
+                {
+                    DebugConsole.ThrowError("Couldn't find a GUI style \""+ styleName+"\"");
+                    return;
+                }
+            }
+            
+            targetComponent.ApplyStyle(componentStyle);            
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUITextBlock.cs

@@ -0,0 +1,308 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+
+namespace Barotrauma
+{
+    public class GUITextBlock : GUIComponent
+    {
+        protected string text;
+
+        protected Alignment textAlignment;
+
+        private float textScale;
+
+        protected Vector2 textPos;
+        protected Vector2 origin;
+
+        protected Vector2 caretPos;
+
+        protected Color textColor;
+
+        private string wrappedText;
+
+        public delegate string TextGetterHandler();
+        public TextGetterHandler TextGetter;
+
+        public bool Wrap;
+
+        private bool overflowClipActive;
+        public bool OverflowClip;
+
+        private float textDepth;
+
+        public override Vector4 Padding
+        {
+            get { return padding; }
+            set 
+            { 
+                padding = value;
+                SetTextPos();
+            }
+        }
+
+        public string Text
+        {
+            get { return text; }
+            set
+            {
+                if (Text == value) return;
+
+                text = value;
+                wrappedText = value;
+                SetTextPos();
+            }
+        }
+
+        public string WrappedText
+        {
+            get { return wrappedText; }
+        }
+
+        public override Rectangle Rect
+        {
+            get
+            {
+                return base.Rect;
+            }
+            set
+            {
+                if (base.Rect == value) return;
+                foreach (GUIComponent child in children)
+                {
+                    child.Rect = new Rectangle(child.Rect.X + value.X - rect.X, child.Rect.Y + value.Y - rect.Y, child.Rect.Width, child.Rect.Height);
+                }
+
+                if (value.Width != rect.Width || value.Height != rect.Height)
+                {
+                    SetTextPos();
+                }
+
+                rect = value;
+            }
+        }
+
+        public float TextDepth
+        {
+            get { return textDepth; }
+            set { textDepth = MathHelper.Clamp(value, 0.0f, 1.0f); }
+        }
+        
+        public Vector2 TextPos
+        {
+            get { return textPos; }
+        }
+
+        public float TextScale
+        {
+            get { return textScale; }
+            set
+            {
+                if (value != textScale)
+                {
+                    textScale = value;
+                    SetTextPos();
+                }
+            }
+        }
+
+        public Vector2 Origin
+        {
+            get { return origin; }
+        }
+
+        public Color TextColor
+        {
+            get { return textColor; }
+            set { textColor = value; }
+        }
+
+        public Vector2 CaretPos
+        {
+            get { return caretPos; }
+        }
+        
+        public GUITextBlock(Rectangle rect, string text, string style, GUIComponent parent, ScalableFont font)
+            : this(rect, text, style, Alignment.TopLeft, Alignment.TopLeft, parent, false, font)
+        {
+        }
+
+
+        public GUITextBlock(Rectangle rect, string text, string style, GUIComponent parent = null, bool wrap = false)
+            : this(rect, text, style, Alignment.TopLeft, Alignment.TopLeft, parent, wrap)
+        {
+        }
+
+        public GUITextBlock(Rectangle rect, string text, Color? color, Color? textColor, Alignment textAlignment = Alignment.Left, string style = null, GUIComponent parent = null, bool wrap = false)
+            : this(rect, text,color, textColor, Alignment.TopLeft, textAlignment, style, parent, wrap)
+        {
+        }
+
+        protected override void UpdateDimensions(GUIComponent parent = null)
+        {
+            base.UpdateDimensions(parent);
+
+            SetTextPos();
+        }
+
+        public override void ApplyStyle(GUIComponentStyle style)
+        {
+            if (style == null) return;
+            base.ApplyStyle(style);
+
+            textColor = style.textColor;
+        }
+
+
+        public GUITextBlock(Rectangle rect, string text, Color? color, Color? textColor, Alignment alignment, Alignment textAlignment = Alignment.Left, string style = null, GUIComponent parent = null, bool wrap = false, ScalableFont font = null)
+            : this (rect, text, style, alignment, textAlignment, parent, wrap, font)
+        {
+            if (color != null) this.color = (Color)color;
+            if (textColor != null) this.textColor = (Color)textColor;
+        }
+
+        public GUITextBlock(Rectangle rect, string text, string style, Alignment alignment = Alignment.TopLeft, Alignment textAlignment = Alignment.TopLeft, GUIComponent parent = null, bool wrap = false, ScalableFont font = null)
+            : base(style)        
+        {
+            this.Font = font == null ? GUI.Font : font;
+
+            this.rect = rect;
+
+            this.text = text;
+
+            this.alignment = alignment;
+
+            this.padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+
+            this.textAlignment = textAlignment;
+            
+            if (parent != null)
+                parent.AddChild(this);
+
+            this.Wrap = wrap;
+
+            SetTextPos();
+
+            TextScale = 1.0f;
+
+            if (rect.Height == 0 && !string.IsNullOrEmpty(Text))
+            {
+                this.rect.Height = (int)Font.MeasureString(wrappedText).Y;
+            }
+        }
+
+        public void SetTextPos()
+        {
+            if (text == null) return;
+
+            overflowClipActive = false;
+
+            wrappedText = text;
+
+            Vector2 size = MeasureText(text);           
+
+            if (Wrap && rect.Width > 0)
+            {
+                wrappedText = ToolBox.WrapText(text, rect.Width - padding.X - padding.Z, Font, textScale);
+                size = MeasureText(wrappedText);
+            }
+            else if (OverflowClip)
+            {
+                overflowClipActive = size.X > rect.Width;
+            }
+                     
+            textPos = new Vector2(rect.Width / 2.0f, rect.Height / 2.0f);
+            origin = size * 0.5f;
+
+            if (textAlignment.HasFlag(Alignment.Left) && !overflowClipActive)
+                origin.X += (rect.Width / 2.0f - padding.X) - size.X / 2;
+            
+            if (textAlignment.HasFlag(Alignment.Right) || overflowClipActive)
+                origin.X -= (rect.Width / 2.0f - padding.Z) - size.X / 2;
+
+            if (textAlignment.HasFlag(Alignment.Top))
+                origin.Y += (rect.Height / 2.0f - padding.Y) - size.Y / 2;
+
+            if (textAlignment.HasFlag(Alignment.Bottom))
+                origin.Y -= (rect.Height / 2.0f - padding.W) - size.Y / 2;
+            
+            origin.X = (int)origin.X;
+            origin.Y = (int)origin.Y;
+
+            textPos.X = (int)textPos.X;
+            textPos.Y = (int)textPos.Y;
+
+            if (wrappedText.Contains("\n"))
+            {
+                string[] lines = wrappedText.Split('\n');
+                Vector2 lastLineSize = MeasureText(lines[lines.Length-1]);
+                caretPos = new Vector2(rect.X + lastLineSize.X, rect.Y + size.Y - lastLineSize.Y) + textPos - origin;
+            }
+            else
+            {
+                caretPos = new Vector2(rect.X + size.X, rect.Y) + textPos - origin;
+            }
+
+        }
+
+        private Vector2 MeasureText(string text) 
+        {
+            if (Font == null) return Vector2.Zero;
+
+            Vector2 size = Vector2.Zero;
+            while (size == Vector2.Zero)
+            {
+                try { size = Font.MeasureString((text == "") ? " " : text); }
+                catch { text = text.Substring(0, text.Length - 1); }
+            }
+
+            return size;
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            Draw(spriteBatch, Vector2.Zero);
+        }
+
+        public void Draw(SpriteBatch spriteBatch, Vector2 offset)
+        {
+            if (!Visible) return;
+
+            Color currColor = color;
+            if (state == ComponentState.Hover) currColor = hoverColor;
+            if (state == ComponentState.Selected) currColor = selectedColor;
+
+            Rectangle drawRect = rect;
+            if (offset != Vector2.Zero) drawRect.Location += offset.ToPoint();
+            
+            base.Draw(spriteBatch);
+            
+            if (TextGetter != null) Text = TextGetter();
+            
+            Rectangle prevScissorRect = spriteBatch.GraphicsDevice.ScissorRectangle;
+            if (overflowClipActive)
+            {
+                spriteBatch.GraphicsDevice.ScissorRectangle = rect;
+            }
+
+            if (!string.IsNullOrEmpty(text))
+            {
+                Font.DrawString(spriteBatch,
+                    Wrap ? wrappedText : text,
+                    new Vector2(rect.X, rect.Y) + textPos + offset,
+                    textColor * (textColor.A / 255.0f),
+                    0.0f, origin, TextScale,
+                    SpriteEffects.None, textDepth);
+            }
+
+            if (overflowClipActive)
+            {
+                spriteBatch.GraphicsDevice.ScissorRectangle = prevScissorRect;
+            }
+
+            DrawChildren(spriteBatch);
+
+            if (OutlineColor.A * currColor.A > 0.0f) GUI.DrawRectangle(spriteBatch, rect, OutlineColor * (currColor.A / 255.0f), false);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUITextBox.cs

@@ -0,0 +1,335 @@
+using System;
+using EventInput;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace Barotrauma
+{
+
+    delegate void TextBoxEvent(GUITextBox sender, Keys key);
+
+    class GUITextBox : GUIComponent, IKeyboardSubscriber
+    {        
+        public event TextBoxEvent OnSelected;
+
+        bool caretVisible;
+        float caretTimer;
+        
+        GUITextBlock textBlock;
+
+        public delegate bool OnEnterHandler(GUITextBox textBox, string text);
+        public OnEnterHandler OnEnterPressed;
+        
+        public event TextBoxEvent OnKeyHit;
+
+        public delegate bool OnTextChangedHandler(GUITextBox textBox, string text);
+        public OnTextChangedHandler OnTextChanged;
+
+        public bool CaretEnabled;
+
+        private int? maxTextLength;
+        
+        public GUITextBlock.TextGetterHandler TextGetter
+        {
+            get { return textBlock.TextGetter; }
+            set { textBlock.TextGetter = value; }
+        }
+
+        public bool Wrap
+        {
+            get { return textBlock.Wrap; }
+            set { textBlock.Wrap = value; }
+        }
+
+        public int? MaxTextLength
+        {
+            get { return maxTextLength; }
+            set
+            {
+                textBlock.OverflowClip = true;                
+                maxTextLength = value;
+            }
+        }
+        
+        public bool Enabled
+        {
+            get;
+            set;
+        }
+
+        public override string ToolTip
+        {
+            get
+            {
+                return base.ToolTip;
+            }
+            set
+            {
+                base.ToolTip = value;
+                textBlock.ToolTip = value;
+            }
+        }
+
+        public override ScalableFont Font
+        {
+            set
+            {
+                base.Font = value;
+                if (textBlock == null) return;
+                textBlock.Font = value;
+            }
+        }
+
+        public override Color Color
+        {
+            get { return color; }
+            set
+            {
+                color = value;
+                textBlock.Color = color;
+            }
+        }
+
+        public Color TextColor
+        {
+            get { return textBlock.TextColor; }
+            set { textBlock.TextColor = value; }
+        }
+
+        public override Color HoverColor
+        {
+            get
+            {
+                return base.HoverColor;
+            }
+            set
+            {
+                base.HoverColor = value;
+                textBlock.HoverColor = value;
+            }
+        }
+
+        public override Rectangle Rect
+        {
+            get
+            {
+                return base.Rect;
+            }
+            set
+            {
+                base.Rect = value;
+
+                textBlock.Rect = value;
+            }
+        }
+        
+        public string Text
+        {
+            get
+            {
+                return textBlock.Text;
+            }
+            set
+            {
+                if (textBlock.Text == value) return;
+
+                textBlock.Text = value;
+                if (textBlock.Text == null) textBlock.Text = "";
+
+                if (textBlock.Text != "")
+                {
+                    if (!Wrap)
+                    {
+                        if (maxTextLength != null)
+                        {
+                            if (Text.Length > maxTextLength)
+                            {
+                                Text = textBlock.Text.Substring(0, (int)maxTextLength);
+                            }
+                        }
+                        else if (Font.MeasureString(textBlock.Text).X > (int)(textBlock.Rect.Width - textBlock.Padding.X - textBlock.Padding.Z))
+                        {
+                            Text = textBlock.Text.Substring(0, textBlock.Text.Length - 1);
+                        }
+                    }
+                }
+            }
+        }
+
+        public GUITextBox(Rectangle rect, string style = null, GUIComponent parent = null)
+            : this(rect, null, null, Alignment.Left, Alignment.Left, style, parent)
+        {
+
+        }
+
+        public GUITextBox(Rectangle rect, Alignment alignment = Alignment.Left, string style = null, GUIComponent parent = null)
+            : this(rect, null, null, alignment, Alignment.Left, style, parent)
+        {
+
+        }
+
+        public GUITextBox(Rectangle rect, Color? color, Color? textColor, Alignment alignment, Alignment textAlignment = Alignment.CenterLeft, string style = null, GUIComponent parent = null)
+            : base(style)
+        {
+            Enabled = true;
+
+            this.rect = rect;
+
+            if (color != null) this.color = (Color)color;
+                        
+            this.alignment = alignment;
+            
+            if (parent != null)
+                parent.AddChild(this);
+
+
+            textBlock = new GUITextBlock(new Rectangle(0,0,0,0), "", color, textColor, textAlignment, style, this);
+            
+            Font = GUI.Font;
+
+            GUI.Style.Apply(textBlock, style == "" ? "GUITextBox" : style);
+            textBlock.Padding = new Vector4(3.0f, 0.0f, 3.0f, 0.0f);
+            
+            CaretEnabled = true;
+        }
+
+        public void Select()
+        {
+            Selected = true;
+            keyboardDispatcher.Subscriber = this;
+            //if (Clicked != null) Clicked(this);
+        }
+
+        public void Deselect()
+        {
+            Selected = false;
+            if (keyboardDispatcher.Subscriber == this) keyboardDispatcher.Subscriber = null;
+        }
+
+        public override void Flash(Color? color = null)
+        {
+            textBlock.Flash(color);
+        }
+
+        //MouseState previousMouse;
+        public override void Update(float deltaTime)
+        {
+            if (!Visible) return;
+
+            if (flashTimer > 0.0f) flashTimer -= deltaTime;
+            if (!Enabled) return;
+            
+            if (rect.Contains(PlayerInput.MousePosition) && Enabled &&
+                (MouseOn == null || MouseOn == this || IsParentOf(MouseOn) || MouseOn.IsParentOf(this)))
+            {
+
+                state = ComponentState.Hover;
+                if (PlayerInput.LeftButtonClicked())
+                {
+                    Select();
+                    if (OnSelected != null) OnSelected(this, Keys.None);
+                }
+            }
+            else
+            {
+                state = ComponentState.None;
+            }
+
+            
+            if (CaretEnabled)
+            {
+                caretTimer += deltaTime;
+                caretVisible = ((caretTimer * 1000.0f) % 1000) < 500;
+            }
+            
+            if (keyboardDispatcher.Subscriber == this)
+            {
+                state = ComponentState.Selected;
+                Character.DisableControls = true;
+                if (OnEnterPressed != null &&  PlayerInput.KeyHit(Keys.Enter))
+                {
+                    string input = Text;
+                    Text = "";
+                    OnEnterPressed(this, input);                    
+                }
+#if LINUX
+                else if (PlayerInput.KeyHit(Keys.Back) && Text.Length>0)
+                {
+                    Text = Text.Substring(0, Text.Length-1);
+                }
+#endif
+
+            }
+
+            textBlock.State = state;
+            textBlock.Update(deltaTime);
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            DrawChildren(spriteBatch);
+
+            if (!CaretEnabled) return;
+            
+            Vector2 caretPos = textBlock.CaretPos;
+
+            if (caretVisible && Selected)
+            {
+                GUI.DrawLine(spriteBatch,
+                    new Vector2((int)caretPos.X + 2, caretPos.Y + 3),
+                    new Vector2((int)caretPos.X + 2, caretPos.Y + Font.MeasureString("I").Y - 3),
+                    textBlock.TextColor * (textBlock.TextColor.A / 255.0f));
+            }
+        }
+
+        public void ReceiveTextInput(char inputChar)
+        {
+            Text = Text + inputChar;
+
+            if (OnTextChanged!=null) OnTextChanged(this, Text);
+        }
+        public void ReceiveTextInput(string text)
+        {
+            Text = Text + text;
+
+            if (OnTextChanged != null) OnTextChanged(this, Text);
+        }
+        public void ReceiveCommandInput(char command)
+        {
+            if (Text == null) Text = "";
+
+            switch (command)
+            {
+                case '\b': //backspace
+                    if (Text.Length > 0)  Text = Text.Substring(0, Text.Length - 1);
+                    break;
+                //case '\r': //return
+                //    if (OnEnterPressed != null)
+                //        OnEnterPressed(this);
+                //    break;
+                //case '\t': //tab
+                //    if (OnTabPressed != null)
+                //        OnTabPressed(this);
+                //    break;
+            }
+
+           if (OnTextChanged != null) OnTextChanged(this, Text);
+        }
+
+        public void ReceiveSpecialInput(Keys key)
+        {
+            if (OnKeyHit != null) OnKeyHit(this, key);
+        }
+
+        //public event TextBoxEvent OnTabPressed;
+
+        public bool Selected
+        {
+            get;
+            set;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/GUITickBox.cs

@@ -0,0 +1,146 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    public class GUITickBox : GUIComponent
+    {
+        private GUIFrame box;
+        private GUITextBlock text;
+
+        public delegate bool OnSelectedHandler(GUITickBox obj);
+        public OnSelectedHandler OnSelected;
+
+        private bool selected;
+
+        public bool Selected
+        {
+            get { return selected; }
+            set 
+            { 
+                if (value == selected) return;
+                selected = value;
+                state = (selected) ? ComponentState.Selected : ComponentState.None;
+
+                box.State = state;
+            }
+        }
+
+        private bool enabled;
+
+        public bool Enabled
+        {
+            get
+            {
+                return enabled;
+            }
+            set
+            {
+                enabled = value;
+            }
+        }
+
+        public override Rectangle Rect
+        {
+            get
+            {
+                return rect;
+            }
+            set
+            {
+                base.Rect = value;
+
+                box.Rect = new Rectangle(value.X,value.Y,box.Rect.Width,box.Rect.Height);
+                text.Rect = new Rectangle(box.Rect.Right + 10, box.Rect.Y + 2, 20, box.Rect.Height);
+            }
+        }
+
+        public Color TextColor
+        {
+            get { return text.TextColor; }
+            set { text.TextColor = value; }
+        }
+
+        public override Rectangle MouseRect
+        {
+            get { return box.Rect; }
+        }
+
+        public override ScalableFont Font
+        {
+            get
+            {
+                return base.Font;
+            }
+
+            set
+            {
+                base.Font = value;
+                if (text != null) text.Font = value;
+            }
+        }
+
+        public GUITickBox(Rectangle rect, string label, Alignment alignment, GUIComponent parent)
+            : this(rect, label, alignment, GUI.Font, parent)
+        {
+        }
+
+        public GUITickBox(Rectangle rect, string label, Alignment alignment, ScalableFont font, GUIComponent parent)
+            : base(null)
+        {
+            if (parent != null)
+                parent.AddChild(this);
+
+            box = new GUIFrame(rect, Color.DarkGray, "", this);
+            box.HoverColor = Color.Gray;
+            box.SelectedColor = Color.DarkGray;
+            box.CanBeFocused = false;
+
+            GUI.Style.Apply(box, "GUITickBox");
+            
+            text = new GUITextBlock(new Rectangle(rect.Right, rect.Y, 20, rect.Height), label, "", Alignment.TopLeft, Alignment.Left | Alignment.CenterY, this, false, font);
+            GUI.Style.Apply(text, "GUIButtonHorizontal", this);
+            
+            this.rect = new Rectangle(box.Rect.X, box.Rect.Y, 240, rect.Height);
+
+            Enabled = true;
+        }
+        
+        public override void Update(float deltaTime)
+        {
+            if (!Visible) return;
+
+            if (MouseOn == this && Enabled)
+            {
+                box.State = ComponentState.Hover;
+
+                if (PlayerInput.LeftButtonHeld())
+                {
+                    box.State = ComponentState.Selected;                    
+                }
+
+                if (PlayerInput.LeftButtonClicked())
+                {
+                    Selected = !Selected;
+                    if (OnSelected != null) OnSelected(this);
+                }
+            }
+            else
+            {
+                box.State = ComponentState.None;
+            }
+
+            if (selected)
+            {
+                box.State = ComponentState.Selected;
+            }
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Visible) return;
+
+            DrawChildren(spriteBatch);            
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GUI/LoadingScreen.cs

@@ -0,0 +1,245 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Media;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class LoadingScreen
+    {
+        private Texture2D backgroundTexture,monsterTexture,titleTexture;
+
+        readonly RenderTarget2D renderTarget;
+
+        float state;
+
+        public Vector2 CenterPosition;
+
+        public Vector2 TitlePosition;
+
+        private float? loadState;
+#if !LINUX
+        Video splashScreenVideo;
+        VideoPlayer videoPlayer;
+#endif
+        public Vector2 TitleSize
+        {
+            get { return new Vector2(titleTexture.Width, titleTexture.Height); }
+        }
+
+        public float Scale
+        {
+            get;
+            private set;
+        }
+
+        public float? LoadState
+        {
+            get { return loadState; }        
+            set 
+            {
+                loadState = value;
+                DebugConsole.NewMessage("Loading: " + value.ToString() + "%",Color.Yellow);
+                DrawLoadingText = true;
+            }
+        }
+
+        public bool DrawLoadingText
+        {
+            get;
+            set;
+        }
+
+        public LoadingScreen(GraphicsDevice graphics)
+        {
+#if !LINUX
+
+            if (GameMain.Config.EnableSplashScreen)
+            {
+                try
+                {
+                    splashScreenVideo = GameMain.Instance.Content.Load<Video>("utg_4");
+                } 
+
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError("Failed to load splashscreen", e);
+                    GameMain.Config.EnableSplashScreen = false;
+                }
+            }
+#endif
+
+
+            backgroundTexture = TextureLoader.FromFile("Content/UI/titleBackground.png");
+            monsterTexture = TextureLoader.FromFile("Content/UI/titleMonster.png");
+            titleTexture = TextureLoader.FromFile("Content/UI/titleText.png");
+
+            renderTarget = new RenderTarget2D(graphics, GameMain.GraphicsWidth, GameMain.GraphicsHeight);
+
+            DrawLoadingText = true;
+        }
+
+        
+        public void Draw(SpriteBatch spriteBatch, GraphicsDevice graphics, float deltaTime)
+        {
+#if !LINUX
+            if (GameMain.Config.EnableSplashScreen && splashScreenVideo != null)
+            {
+                try
+                {
+                    DrawSplashScreen(spriteBatch);
+                    if (videoPlayer != null && videoPlayer.State == MediaState.Playing)
+                        return;
+                }
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError("Playing splash screen video failed", e);
+                    GameMain.Config.EnableSplashScreen = false;
+                }
+            }
+#endif
+                        
+            drawn = true;
+
+            graphics.SetRenderTarget(renderTarget);
+
+            Scale = GameMain.GraphicsHeight/1500.0f;
+
+            state += deltaTime;
+
+            if (DrawLoadingText)
+            {
+                CenterPosition = new Vector2(GameMain.GraphicsWidth*0.3f, GameMain.GraphicsHeight/2.0f); 
+                TitlePosition = CenterPosition + new Vector2(-0.0f + (float)Math.Sqrt(state) * 220.0f, 0.0f) * Scale;
+                TitlePosition.X = Math.Min(TitlePosition.X, (float)GameMain.GraphicsWidth / 2.0f);
+            }
+
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
+            graphics.Clear(Color.Black);
+
+            spriteBatch.Draw(backgroundTexture, CenterPosition, null, Color.White * Math.Min(state / 5.0f, 1.0f), 0.0f,
+                new Vector2(backgroundTexture.Width / 2.0f, backgroundTexture.Height / 2.0f),
+                Scale*1.5f, SpriteEffects.None, 0.2f);
+
+            spriteBatch.Draw(monsterTexture,
+                CenterPosition + new Vector2((state % 40) * 100.0f - 1800.0f, (state % 40) * 30.0f - 200.0f) * Scale, null,
+                Color.White, 0.0f, Vector2.Zero, Scale, SpriteEffects.None, 0.1f);
+
+            spriteBatch.Draw(titleTexture,
+                TitlePosition, null,
+                Color.White * Math.Min((state - 1.0f) / 5.0f, 1.0f), 0.0f, new Vector2(titleTexture.Width / 2.0f, titleTexture.Height / 2.0f), Scale, SpriteEffects.None, 0.0f);
+            
+            spriteBatch.End();
+
+            graphics.SetRenderTarget(null);
+
+            if (Hull.renderer != null)
+            {
+                Hull.renderer.ScrollWater(deltaTime);
+                Hull.renderer.RenderBack(spriteBatch, renderTarget, 0.0f);
+            }
+            
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
+            
+            spriteBatch.Draw(titleTexture,
+                TitlePosition, null,
+                Color.White * Math.Min((state - 3.0f) / 5.0f, 1.0f), 0.0f, new Vector2(titleTexture.Width / 2.0f, titleTexture.Height / 2.0f), Scale, SpriteEffects.None, 0.0f);
+
+            if (DrawLoadingText)
+            {
+                string loadText = "";
+                if (loadState == 100.0f)
+                {
+                    loadText = "Press any key to continue";
+                }
+                else
+                {
+                    loadText = "Loading... ";
+                    if (loadState!=null)
+                    {
+                        loadText += (int)loadState + " %";
+                    }
+                }
+
+                if (GUI.LargeFont!=null)
+                {
+                    GUI.LargeFont.DrawString(spriteBatch, loadText, 
+                        new Vector2(GameMain.GraphicsWidth/2.0f - GUI.LargeFont.MeasureString(loadText).X/2.0f, GameMain.GraphicsHeight*0.8f), 
+                        Color.White); 
+                }
+           
+            }
+            spriteBatch.End();
+
+        }
+
+#if !LINUX
+        private void DrawSplashScreen(SpriteBatch spriteBatch)
+        {
+            if (videoPlayer == null)
+            {
+                videoPlayer = new VideoPlayer();
+                videoPlayer.Play(splashScreenVideo);
+                videoPlayer.Volume = GameMain.Config.SoundVolume;
+            }
+            else
+            {
+                Texture2D videoTexture = null;
+
+                if (videoPlayer.State == MediaState.Stopped)
+                {
+                    videoPlayer.Dispose();
+                    videoPlayer = null;
+
+                    splashScreenVideo.Dispose();
+                    splashScreenVideo = null;
+                }
+                else
+                {
+                    videoTexture = videoPlayer.GetTexture();
+
+                    spriteBatch.Begin();
+                    spriteBatch.Draw(videoTexture, new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight), Color.White);
+                    spriteBatch.End();
+
+                    if (PlayerInput.KeyHit(Keys.Space) || PlayerInput.KeyHit(Keys.Enter) || PlayerInput.LeftButtonDown())
+                    {
+                        videoPlayer.Stop();
+                    }
+                }
+
+            }
+        }
+#endif
+ 
+        bool drawn;
+        public IEnumerable<object> DoLoading(IEnumerable<object> loader)
+        {
+            drawn = false;
+            LoadState = null;
+
+            while (!drawn)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            CoroutineManager.StartCoroutine(loader);
+            
+            yield return CoroutineStatus.Running;
+
+            while (CoroutineManager.IsCoroutineRunning(loader.ToString()))
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            loadState = 100.0f;
+
+            yield return CoroutineStatus.Success;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameMain.cs

@@ -0,0 +1,430 @@
+using System;
+using System.Diagnostics;
+using System.Reflection;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Barotrauma.Networking;
+using Barotrauma.Particles;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace Barotrauma
+{
+    class GameMain : Game
+    {
+        public static bool DebugDraw;
+        
+        public static FrameCounter FrameCounter;
+
+        public static readonly Version Version = Assembly.GetEntryAssembly().GetName().Version;
+
+        public static GameScreen            GameScreen;
+        public static MainMenuScreen        MainMenuScreen;
+        public static LobbyScreen           LobbyScreen;
+
+        public static NetLobbyScreen        NetLobbyScreen;
+        public static ServerListScreen      ServerListScreen;
+
+        public static EditMapScreen         EditMapScreen;
+        public static EditCharacterScreen   EditCharacterScreen;
+
+        public static Lights.LightManager LightManager;
+        
+        public static ContentPackage SelectedPackage
+        {
+            get { return Config.SelectedContentPackage; }
+        }
+        
+        public static GameSession GameSession;
+
+        public static NetworkMember NetworkMember;
+
+        public static ParticleManager ParticleManager;
+        
+        public static World World;
+
+        public static LoadingScreen TitleScreen;
+        private bool loadingScreenOpen;
+
+        public static GameSettings Config;
+
+        private CoroutineHandle loadingCoroutine;
+        private bool hasLoaded;
+
+        private GameTime fixedTime;
+
+        private static SpriteBatch spriteBatch;
+
+        public static GameMain Instance
+        {
+            get;
+            private set;
+        }
+
+        public static GraphicsDeviceManager GraphicsDeviceManager
+        {
+            get;
+            private set;
+        }
+        
+        public static int GraphicsWidth
+        {
+            get;
+            private set;
+        }
+
+        public static int GraphicsHeight
+        {
+            get;
+            private set;
+        }
+
+        public static bool WindowActive
+        {
+            get { return Instance == null || Instance.IsActive; }
+        }
+
+        public static GameServer Server
+        {
+            get { return NetworkMember as GameServer; }
+        }
+
+        public static GameClient Client
+        {
+            get { return NetworkMember as GameClient; }
+        }
+        
+        public static RasterizerState ScissorTestEnable
+        {
+            get;
+            private set;
+        }
+                                
+        public GameMain()
+        {
+            GraphicsDeviceManager = new GraphicsDeviceManager(this);
+            Window.Title = "Barotrauma";
+            
+            Instance = this;
+
+            Config = new GameSettings("config.xml");
+            if (Config.WasGameUpdated)
+            {
+                UpdaterUtil.CleanOldFiles();
+                Config.WasGameUpdated = false;
+                Config.Save("config.xml");
+            }
+
+            ApplyGraphicsSettings();
+
+            Content.RootDirectory = "Content";
+
+            FrameCounter = new FrameCounter();
+            
+            IsFixedTimeStep = false;
+
+            Timing.Accumulator = 0.0f;
+            fixedTime = new GameTime();
+
+            World = new World(new Vector2(0, -9.82f));
+            FarseerPhysics.Settings.AllowSleep = true;
+            FarseerPhysics.Settings.ContinuousPhysics = false;
+            FarseerPhysics.Settings.VelocityIterations = 1;
+            FarseerPhysics.Settings.PositionIterations = 1;
+        }
+
+        public void ApplyGraphicsSettings()
+        {
+            GraphicsWidth = Config.GraphicsWidth;
+            GraphicsHeight = Config.GraphicsHeight;
+            GraphicsDeviceManager.SynchronizeWithVerticalRetrace = Config.VSyncEnabled;
+
+            //for whatever reason, window isn't centered automatically
+            //since MonoGame 3.6 (nuget package might be broken), so
+            //let's do it manually
+            Window.Position = new Point((GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width - GraphicsWidth) / 2,
+                                        (GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height - GraphicsHeight) / 2);
+
+            GraphicsDeviceManager.HardwareModeSwitch = Config.WindowMode != WindowMode.BorderlessWindowed;
+
+            GraphicsDeviceManager.IsFullScreen = Config.WindowMode == WindowMode.Fullscreen || Config.WindowMode == WindowMode.BorderlessWindowed;
+            GraphicsDeviceManager.PreferredBackBufferWidth = GraphicsWidth;
+            GraphicsDeviceManager.PreferredBackBufferHeight = GraphicsHeight;
+
+            GraphicsDeviceManager.ApplyChanges();
+        }
+
+        /// <summary>
+        /// Allows the game to perform any initialization it needs to before starting to run.
+        /// This is where it can query for any required services and load any non-graphic
+        /// related content.  Calling base.Initialize will enumerate through any components
+        /// and initialize them as well.
+        /// </summary>
+        protected override void Initialize()
+        {
+            base.Initialize();
+            
+            ScissorTestEnable = new RasterizerState() { ScissorTestEnable = true };
+
+            Hyper.ComponentModel.HyperTypeDescriptionProvider.Add(typeof(Character));
+            Hyper.ComponentModel.HyperTypeDescriptionProvider.Add(typeof(Item));
+            Hyper.ComponentModel.HyperTypeDescriptionProvider.Add(typeof(Items.Components.ItemComponent));
+            Hyper.ComponentModel.HyperTypeDescriptionProvider.Add(typeof(Hull));
+        }
+
+        /// <summary>
+        /// LoadContent will be called once per game and is the place to load
+        /// all of your content.
+        /// </summary>
+        protected override void LoadContent()
+        {
+            GraphicsWidth = GraphicsDevice.Viewport.Width;
+            GraphicsHeight = GraphicsDevice.Viewport.Height;
+
+            Sound.Init();
+
+            ConvertUnits.SetDisplayUnitToSimUnitRatio(Physics.DisplayToSimRation);
+
+            spriteBatch = new SpriteBatch(GraphicsDevice);
+            TextureLoader.Init(GraphicsDevice);
+
+            loadingScreenOpen = true;
+            TitleScreen = new LoadingScreen(GraphicsDevice);
+
+            loadingCoroutine = CoroutineManager.StartCoroutine(Load());
+        }
+
+        private IEnumerable<object> Load()
+        {
+            DebugConsole.NewMessage("LOADING COROUTINE", Color.Lime);
+            GUI.GraphicsDevice = base.GraphicsDevice;
+            GUI.Init(Content);
+
+            GUIComponent.Init(Window);
+            DebugConsole.Init(Window);
+            DebugConsole.Log(SelectedPackage == null ? "No content package selected" : "Content package \"" + SelectedPackage.Name + "\" selected");
+        yield return CoroutineStatus.Running;
+
+            LightManager = new Lights.LightManager(base.GraphicsDevice);
+
+            Hull.renderer = new WaterRenderer(base.GraphicsDevice, Content);
+            TitleScreen.LoadState = 1.0f;
+        yield return CoroutineStatus.Running;
+
+            GUI.LoadContent();
+            TitleScreen.LoadState = 2.0f;
+        yield return CoroutineStatus.Running;
+
+            Mission.Init();
+            MapEntityPrefab.Init();
+            LevelGenerationParams.LoadPresets();
+            TitleScreen.LoadState = 10.0f;
+        yield return CoroutineStatus.Running;
+
+            JobPrefab.LoadAll(SelectedPackage.GetFilesOfType(ContentType.Jobs));
+            // Add any missing jobs from the prefab into Config.JobNamePreferences.
+            foreach (JobPrefab job in JobPrefab.List)
+            {
+                if (!Config.JobNamePreferences.Contains(job.Name)) { Config.JobNamePreferences.Add(job.Name); }
+            }
+            StructurePrefab.LoadAll(SelectedPackage.GetFilesOfType(ContentType.Structure));
+            TitleScreen.LoadState = 20.0f;
+        yield return CoroutineStatus.Running;
+
+            ItemPrefab.LoadAll(SelectedPackage.GetFilesOfType(ContentType.Item));
+            TitleScreen.LoadState = 30.0f;
+        yield return CoroutineStatus.Running;
+
+            Debug.WriteLine("sounds");
+            CoroutineManager.StartCoroutine(SoundPlayer.Init());
+
+            int i = 0;
+            while (!SoundPlayer.Initialized)
+            {
+                i++;
+                TitleScreen.LoadState = SoundPlayer.SoundCount == 0 ? 
+                    30.0f :
+                    Math.Min(30.0f + 40.0f * i / Math.Max(SoundPlayer.SoundCount, 1), 70.0f);
+                yield return CoroutineStatus.Running;
+            }
+
+            TitleScreen.LoadState = 70.0f;
+        yield return CoroutineStatus.Running;
+
+            GameModePreset.Init();
+
+            Submarine.RefreshSavedSubs();
+            TitleScreen.LoadState = 80.0f;
+        yield return CoroutineStatus.Running;
+
+            GameScreen          =   new GameScreen(GraphicsDeviceManager.GraphicsDevice, Content);
+            TitleScreen.LoadState = 90.0f;
+        yield return CoroutineStatus.Running;
+
+            MainMenuScreen      =   new MainMenuScreen(this); 
+            LobbyScreen         =   new LobbyScreen();
+            
+            ServerListScreen    =   new ServerListScreen();
+
+            EditMapScreen       =   new EditMapScreen();
+            EditCharacterScreen =   new EditCharacterScreen();
+
+        yield return CoroutineStatus.Running;
+
+            ParticleManager = new ParticleManager("Content/Particles/ParticlePrefabs.xml", GameScreen.Cam);
+        yield return CoroutineStatus.Running;
+
+            LocationType.Init();
+            MainMenuScreen.Select();
+
+            TitleScreen.LoadState = 100.0f;
+            hasLoaded = true;
+            DebugConsole.NewMessage("LOADING COROUTINE FINISHED", Color.Lime);
+        yield return CoroutineStatus.Success;
+
+        }
+
+        /// <summary>
+        /// UnloadContent will be called once per game and is the place to unload
+        /// all content.
+        /// </summary>
+        protected override void UnloadContent()
+        {
+            Sound.Dispose();
+        }
+        
+        /// <summary>
+        /// Allows the game to run logic such as updating the world,
+        /// checking for collisions, gathering input, and playing audio.
+        /// </summary>
+        /// <param name="gameTime">Provides a snapshot of timing values.</param>
+        protected override void Update(GameTime gameTime)
+        {
+            Timing.TotalTime = gameTime.TotalGameTime.TotalSeconds;
+            Timing.Accumulator += gameTime.ElapsedGameTime.TotalSeconds;
+            PlayerInput.UpdateVariable();
+
+            bool paused = true;
+
+            while (Timing.Accumulator >= Timing.Step)
+            {
+                fixedTime.IsRunningSlowly = gameTime.IsRunningSlowly;
+                TimeSpan addTime = new TimeSpan(0, 0, 0, 0, 16);
+                fixedTime.ElapsedGameTime = addTime;
+                fixedTime.TotalGameTime.Add(addTime);
+                base.Update(fixedTime);
+
+                PlayerInput.Update(Timing.Step);
+
+                if (loadingScreenOpen)
+                {
+                    //reset accumulator if loading
+                    // -> less choppy loading screens because the screen is rendered after each update
+                    // -> no pause caused by leftover time in the accumulator when starting a new shift
+                    Timing.Accumulator = 0.0f;
+
+                    if (TitleScreen.LoadState >= 100.0f && 
+                        (!waitForKeyHit || PlayerInput.GetKeyboardState.GetPressedKeys().Length>0 || PlayerInput.LeftButtonClicked()))
+                    {
+                        loadingScreenOpen = false;
+                    }
+
+                    if (!hasLoaded && !CoroutineManager.IsCoroutineRunning(loadingCoroutine))
+                    {
+                        throw new Exception("Loading was interrupted due to an error");
+                    }
+                }
+                else if (hasLoaded)
+                {
+                    SoundPlayer.Update();
+
+                    if (PlayerInput.KeyHit(Keys.Escape)) GUI.TogglePauseMenu();
+
+                    GUIComponent.ClearUpdateList();
+                    paused = (DebugConsole.IsOpen || GUI.PauseMenuOpen || GUI.SettingsMenuOpen) &&
+                             (NetworkMember == null || !NetworkMember.GameStarted);
+
+                    if (!paused)
+                    {
+                        Screen.Selected.AddToGUIUpdateList();
+                    }
+
+                    if (NetworkMember != null)
+                    {
+                        NetworkMember.AddToGUIUpdateList();
+                    }
+
+                    GUI.AddToGUIUpdateList();
+                    DebugConsole.AddToGUIUpdateList();
+                    GUIComponent.UpdateMouseOn();
+
+                    DebugConsole.Update(this, (float)Timing.Step);
+                    
+                    if (!paused)
+                    {
+                        Screen.Selected.Update(Timing.Step);
+                    }
+
+                    if (NetworkMember != null)
+                    {
+                        NetworkMember.Update((float)Timing.Step);
+                    }
+
+                    GUI.Update((float)Timing.Step);
+                }
+
+                CoroutineManager.Update((float)Timing.Step, paused ? 0.0f : (float)Timing.Step);
+
+                Timing.Accumulator -= Timing.Step;
+            }
+
+            if (!paused) Timing.Alpha = Timing.Accumulator / Timing.Step;
+        }
+
+
+        /// <summary>
+        /// This is called when the game should draw itself.
+        /// </summary>
+        protected override void Draw(GameTime gameTime)
+        {
+            double deltaTime = gameTime.ElapsedGameTime.TotalSeconds;
+
+            FrameCounter.Update(deltaTime);
+
+            if (loadingScreenOpen)
+            {
+                TitleScreen.Draw(spriteBatch, base.GraphicsDevice, (float)deltaTime);
+            }
+            else if (hasLoaded)
+            {
+                Screen.Selected.Draw(deltaTime, base.GraphicsDevice, spriteBatch);
+            }
+
+            if (!DebugDraw) return;
+            if (GUIComponent.MouseOn!=null)
+            {
+                spriteBatch.Begin();
+                GUI.DrawRectangle(spriteBatch, GUIComponent.MouseOn.MouseRect, Color.Lime);
+                spriteBatch.End();
+            }
+        }
+
+        static bool waitForKeyHit = true;
+        public CoroutineHandle ShowLoading(IEnumerable<object> loader, bool waitKeyHit = true)
+        {
+            waitForKeyHit = waitKeyHit;
+            loadingScreenOpen = true;
+            TitleScreen.LoadState = null;
+            return CoroutineManager.StartCoroutine(TitleScreen.DoLoading(loader));
+        }
+
+        protected override void OnExiting(object sender, EventArgs args)
+        {
+            if (NetworkMember != null) NetworkMember.Disconnect();
+           
+            base.OnExiting(sender, args);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameSession/CrewManager.cs

@@ -0,0 +1,359 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class CrewManager
+    {
+        public List<Character> characters;
+        public List<CharacterInfo> characterInfos;
+
+        public int WinningTeam = 1;
+        
+        private int money;
+        
+        private GUIFrame guiFrame;
+        private GUIListBox listBox, orderListBox;
+        
+        private CrewCommander commander;
+
+        public CrewCommander CrewCommander
+        {
+            get { return commander; }
+        }
+        
+        public int Money
+        {
+            get { return money; }
+            set { money = (int)Math.Max(value, 0.0f); }
+        }
+
+        public CrewManager()
+        {
+            characters = new List<Character>();
+            characterInfos = new List<CharacterInfo>();
+            
+            guiFrame = new GUIFrame(new Rectangle(0, 50, 150, 450), Color.Transparent);
+            guiFrame.Padding = Vector4.One * 5.0f;
+
+            listBox = new GUIListBox(new Rectangle(45, 30, 150, 0), Color.Transparent, null, guiFrame);
+            listBox.ScrollBarEnabled = false;
+            listBox.OnSelected = SelectCharacter;
+
+            orderListBox = new GUIListBox(new Rectangle(5, 30, 30, 0), Color.Transparent, null, guiFrame);
+            orderListBox.ScrollBarEnabled = false;
+            orderListBox.OnSelected = SelectCharacterOrder;
+
+            commander = new CrewCommander(this);
+
+            money = 10000;
+        }
+
+        public CrewManager(XElement element)
+            : this()
+        {
+            money = ToolBox.GetAttributeInt(element, "money", 0);
+
+            foreach (XElement subElement in element.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "character") continue;
+
+                characterInfos.Add(new CharacterInfo(subElement));
+            }
+        }
+
+        public bool SelectCharacter(GUIComponent component, object selection)
+        {
+            //listBox.Select(selection);
+            Character character = selection as Character;
+
+            if (character == null || character.IsDead || character.IsUnconscious) return false;
+
+            if (characters.Contains(character))
+            {
+                Character.Controlled = character;
+                return true;
+            }
+
+            return false;
+        }
+
+        public void SetCharacterOrder(Character character, Order order)
+        {
+            if (order == null) return;
+
+            var characterFrame = listBox.FindChild(character);
+
+            if (characterFrame == null) return;
+
+            int characterIndex = listBox.children.IndexOf(characterFrame);
+
+            orderListBox.children[characterIndex].ClearChildren();
+            
+            var img = new GUIImage(new Rectangle(0, 0, 30, 30), order.SymbolSprite, Alignment.Center, orderListBox.children[characterIndex]);
+            img.Scale = 30.0f / img.SourceRect.Width;
+            img.Color = order.Color;
+            img.CanBeFocused = false;
+
+            orderListBox.children[characterIndex].ToolTip = "Order: " + order.Name;
+        }
+
+        public bool SelectCharacterOrder(GUIComponent component, object selection)
+        {
+            commander.ToggleGUIFrame();
+
+            int orderIndex = orderListBox.children.IndexOf(component);
+            if (orderIndex < 0 || orderIndex >= listBox.children.Count) return false;
+
+            var characterFrame = listBox.children[orderIndex];
+            if (characterFrame == null) return false;
+
+            commander.SelectCharacter(characterFrame.UserData as Character);
+
+            return false;
+        }
+
+        public void AddCharacter(Character character)
+        {
+            characters.Add(character);
+            if (!characterInfos.Contains(character.Info))
+            {
+                characterInfos.Add(character.Info);
+            }
+
+            if (character is AICharacter)
+            {
+                commander.UpdateCharacters();
+            }
+
+            character.Info.CreateCharacterFrame(listBox, character.Info.Name.Replace(' ', '\n'), character);
+
+            GUIFrame orderFrame = new GUIFrame(new Rectangle(0, 0, 40, 40), Color.Transparent, "ListBoxElement", orderListBox);
+            orderFrame.UserData = character;
+
+            var ai = character.AIController as HumanAIController;
+            if (ai == null)
+            {
+                DebugConsole.ThrowError("Error in crewmanager - attempted to give orders to a character with no HumanAIController");
+                return;
+            }
+            SetCharacterOrder(character, ai.CurrentOrder);
+        }
+
+        public void AddToGUIUpdateList()
+        {
+            guiFrame.AddToGUIUpdateList();
+            if (commander.Frame != null) commander.Frame.AddToGUIUpdateList();
+        }
+
+        public void Update(float deltaTime)
+        {
+            guiFrame.Update(deltaTime);
+            
+            //TODO: implement AI commands in multiplayer?
+            if (GameMain.NetworkMember == null &&
+                GameMain.Config.KeyBind(InputType.CrewOrders).IsHit())
+            {
+                //deselect construction unless it's the ladders the character is climbing
+                if (!commander.IsOpen && Character.Controlled != null && 
+                    Character.Controlled.SelectedConstruction != null && 
+                    Character.Controlled.SelectedConstruction.GetComponent<Items.Components.Ladder>() == null)
+                {
+                    Character.Controlled.SelectedConstruction = null;
+                }
+
+                //only allow opening the command UI if there are AICharacters in the crew
+                if (commander.IsOpen || characters.Any(c => c is AICharacter)) commander.ToggleGUIFrame();                
+            }
+
+            if (commander.Frame != null) commander.Frame.Update(deltaTime);
+        }
+
+        public void ReviveCharacter(Character revivedCharacter)
+        {
+            GUIComponent characterBlock = listBox.GetChild(revivedCharacter) as GUIComponent;
+            if (characterBlock != null) characterBlock.Color = Color.Transparent;
+
+            if (revivedCharacter is AICharacter)
+            {
+                commander.UpdateCharacters();
+            }
+        }
+
+        public void KillCharacter(Character killedCharacter)
+        {
+            GUIComponent characterBlock = listBox.GetChild(killedCharacter) as GUIComponent;
+            if (characterBlock != null) characterBlock.Color = Color.DarkRed * 0.5f;
+
+            if (killedCharacter is AICharacter)
+            {
+                commander.UpdateCharacters();
+            }
+            //if (characters.Find(c => !c.IsDead)==null)
+            //{
+            //    Game1.GameSession.EndShift(null, null);
+            //}            
+        }
+
+        public void CreateCrewFrame(List<Character> crew, GUIFrame crewFrame)
+        {
+            List<byte> teamIDs = crew.Select(c => c.TeamID).Distinct().ToList();
+
+            if (!teamIDs.Any()) teamIDs.Add(0);            
+
+            int listBoxHeight = 300 / teamIDs.Count;
+
+            int y = 20;
+            for (int i = 0; i < teamIDs.Count; i++)
+            {
+                if (teamIDs.Count > 1)
+                {
+                    new GUITextBlock(new Rectangle(0, y - 20, 100, 20), CombatMission.GetTeamName(teamIDs[i]), "", crewFrame);
+                }
+
+                GUIListBox crewList = new GUIListBox(new Rectangle(0, y, 280, listBoxHeight), Color.White * 0.7f, "", crewFrame);
+                crewList.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+                crewList.OnSelected = (component, obj) =>
+                {
+                    SelectCrewCharacter(component.UserData as Character, crewList);
+                    return true;
+                };
+            
+                foreach (Character character in crew.FindAll(c => c.TeamID == teamIDs[i]))
+                {
+                    GUIFrame frame = new GUIFrame(new Rectangle(0, 0, 0, 40), Color.Transparent, "ListBoxElement", crewList);
+                    frame.UserData = character;
+                    frame.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+                    frame.Color = (GameMain.NetworkMember != null && GameMain.NetworkMember.Character == character) ? Color.Gold * 0.2f : Color.Transparent;
+
+                    GUITextBlock textBlock = new GUITextBlock(
+                        new Rectangle(40, 0, 0, 25),
+                        ToolBox.LimitString(character.Info.Name + " (" + character.Info.Job.Name + ")", GUI.Font, frame.Rect.Width-20),
+                        null,null,
+                        Alignment.Left, Alignment.Left,
+                        "", frame);
+                    textBlock.Padding = new Vector4(5.0f, 0.0f, 5.0f, 0.0f);
+
+                    new GUIImage(new Rectangle(-10, 0, 0, 0), character.AnimController.Limbs[0].sprite, Alignment.Left, frame);
+                }
+
+                y += crewList.Rect.Height + 30;
+            }
+
+
+        }
+
+        protected virtual bool SelectCrewCharacter(Character character, GUIComponent crewList)
+        {
+            if (character == null) return false;
+
+            GUIComponent existingFrame = crewList.Parent.FindChild("selectedcharacter");
+            if (existingFrame != null) crewList.Parent.RemoveChild(existingFrame);
+
+            var previewPlayer = new GUIFrame(
+                new Rectangle(0, 0, 230, 300),
+                new Color(0.0f, 0.0f, 0.0f, 0.8f), Alignment.TopRight, "", crewList.Parent);
+            previewPlayer.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+            previewPlayer.UserData = "selectedcharacter";
+
+            character.Info.CreateInfoFrame(previewPlayer);
+
+            if (GameMain.NetworkMember != null) GameMain.NetworkMember.SelectCrewCharacter(character, crewList);
+
+            return true;
+        }
+
+        //private bool ToggleCrewFrame(GUIButton button, object obj)
+        //{
+        //    if (crewFrame == null) CreateCrewFrame(characters);
+
+        //    crewFrameOpen = !crewFrameOpen;
+        //    return true;
+        //}
+
+        public void StartShift()
+        {
+            listBox.ClearChildren();
+            characters.Clear();
+
+            WayPoint[] waypoints = WayPoint.SelectCrewSpawnPoints(characterInfos, Submarine.MainSub, false);
+
+            for (int i = 0; i < waypoints.Length; i++)
+            {
+                Character character;
+
+                if (characterInfos[i].HullID != null)
+                {
+                    var hull = Entity.FindEntityByID((ushort)characterInfos[i].HullID) as Hull;
+                    if (hull == null) continue;
+                    character = Character.Create(characterInfos[i], hull.WorldPosition);
+                }
+                else
+                {
+                    character = Character.Create(characterInfos[i], waypoints[i].WorldPosition);
+                    Character.Controlled = character;
+
+                    if (character.Info != null && !character.Info.StartItemsGiven)
+                    {
+                        character.GiveJobItems(waypoints[i]);
+                        character.Info.StartItemsGiven = true;
+                    }
+                }
+
+                AddCharacter(character);
+            }
+
+            if (characters.Any()) listBox.Select(0);// SelectCharacter(null, characters[0]);
+        }
+
+        public void EndShift()
+        {
+            foreach (Character c in characters)
+            {
+                if (!c.IsDead)
+                {
+                    c.Info.UpdateCharacterItems();
+                    continue;
+                }
+
+                CharacterInfo deadInfo = characterInfos.Find(x => c.Info == x);
+                if (deadInfo != null) characterInfos.Remove(deadInfo);
+            }
+
+            characters.Clear();
+            listBox.ClearChildren();
+            orderListBox.ClearChildren();
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (commander.IsOpen)
+            {
+                commander.Draw(spriteBatch);
+            }
+            else
+            {
+                guiFrame.Draw(spriteBatch);
+            }
+        }
+
+        public void Save(XElement parentElement)
+        {
+            XElement element = new XElement("crew");
+                
+            element.Add(new XAttribute("money", money));
+            
+            foreach (CharacterInfo ci in characterInfos)
+            {
+                ci.Save(element);
+            }
+
+            parentElement.Add(element);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameSession/GameMode.cs

@@ -0,0 +1,10 @@
+using Microsoft.Xna.Framework.Graphics;
+namespace Barotrauma
+{
+    partial class GameMode
+    {
+        public virtual void Draw(SpriteBatch spriteBatch)
+        {
+        }
+    }
+}

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

@@ -0,0 +1,411 @@
+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
+{
+    class SinglePlayerMode : GameMode
+    {
+        //private const int StartCharacterAmount = 3;
+
+        //public readonly CrewManager CrewManager;
+        //public readonly HireManager hireManager;
+
+        private GUIButton endShiftButton;
+
+        public readonly CargoManager CargoManager;
+        
+        public Map Map;
+
+        private bool crewDead;
+        private float endTimer;
+
+        private bool savedOnStart;
+
+        private List<Submarine> subsToLeaveBehind;
+
+        private Submarine leavingSub;
+        private bool atEndPosition;
+
+        public override Mission Mission
+        {
+            get
+            {
+                return Map.SelectedConnection.Mission;
+            }
+        }
+
+        public int Money
+        {
+            get { return GameMain.GameSession.CrewManager.Money; }
+            set { GameMain.GameSession.CrewManager.Money = value; }
+        }
+
+        private CrewManager CrewManager
+        {
+            get { return GameMain.GameSession.CrewManager; }
+        }
+
+        public SinglePlayerMode(GameModePreset preset, object param)
+            : base(preset, param)
+        {
+
+            CargoManager = new CargoManager();
+
+            endShiftButton = new GUIButton(new Rectangle(GameMain.GraphicsWidth - 220, 20, 200, 25), "End shift", null, Alignment.TopLeft, Alignment.Center, "");
+            endShiftButton.Font = GUI.SmallFont;
+            endShiftButton.OnClicked = TryEndShift;
+
+            for (int i = 0; i < 3; i++)
+            {
+                JobPrefab jobPrefab = null;
+                switch (i)
+                {
+                    case 0:
+                        jobPrefab = JobPrefab.List.Find(jp => jp.Name == "Captain");
+                        break;
+                    case 1:
+                        jobPrefab = JobPrefab.List.Find(jp => jp.Name == "Engineer");
+                        break;
+                    case 2:
+                        jobPrefab = JobPrefab.List.Find(jp => jp.Name == "Mechanic");
+                        break;
+                }
+
+                CharacterInfo characterInfo =
+                    new CharacterInfo(Character.HumanConfigFile, "", Gender.None, jobPrefab);
+                CrewManager.characterInfos.Add(characterInfo);
+            }
+  
+        }
+
+        public SinglePlayerMode(XElement element)
+            : this(GameModePreset.list.Find(gm => gm.Name == "Single Player"), null)
+        {            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "crew":
+                        GameMain.GameSession.CrewManager = new CrewManager(subElement); 
+                        break;
+                    case "map":
+                        Map = Map.Load(subElement);
+                        break;
+                }               
+            }
+
+            //backwards compatibility with older save files
+            if (Map==null)
+            {
+                string mapSeed = ToolBox.GetAttributeString(element, "mapseed", "a");
+
+                GenerateMap(mapSeed);
+
+                Map.SetLocation(ToolBox.GetAttributeInt(element, "currentlocation", 0));
+            }
+
+            savedOnStart = true;
+        }
+
+        public void GenerateMap(string seed)
+        {
+            Map = new Map(seed, 500);
+        }
+
+        public override void Start()
+        {
+            CargoManager.CreateItems();
+
+            if (!savedOnStart)
+            {
+                SaveUtil.SaveGame(GameMain.GameSession.SaveFile);
+                savedOnStart = true;
+            }
+
+            endTimer = 5.0f;
+
+            isRunning = true;
+
+            CrewManager.StartShift();
+        }
+
+        public bool TryHireCharacter(HireManager hireManager, CharacterInfo characterInfo)
+        {
+            if (CrewManager.Money < characterInfo.Salary) return false;
+
+            hireManager.availableCharacters.Remove(characterInfo);
+            CrewManager.characterInfos.Add(characterInfo);
+
+            CrewManager.Money -= characterInfo.Salary;
+
+            return true;
+        }
+
+        public string GetMoney()
+        {
+            return "Money: " + CrewManager.Money;
+        }
+
+
+        private Submarine GetLeavingSub()
+        {
+            if (Character.Controlled != null && Character.Controlled.Submarine != null)
+            {
+                if (Character.Controlled.Submarine.AtEndPosition || Character.Controlled.Submarine.AtStartPosition)
+                {
+                    return Character.Controlled.Submarine;
+                }
+                return null;
+            }
+
+            Submarine closestSub = Submarine.FindClosest(GameMain.GameScreen.Cam.WorldViewCenter);
+            if (closestSub != null && (closestSub.AtEndPosition || closestSub.AtStartPosition))
+            {
+                return closestSub.DockedTo.Contains(Submarine.MainSub) ? Submarine.MainSub : closestSub;
+            }
+
+            return null;
+        }
+
+        private List<Submarine> GetSubsToLeaveBehind(Submarine leavingSub)
+        {
+            //leave subs behind if they're not docked to the leaving sub and not at the same exit
+            return Submarine.Loaded.FindAll(s =>
+                s != leavingSub &&
+                !leavingSub.DockedTo.Contains(s) &&
+                (s.AtEndPosition != leavingSub.AtEndPosition || s.AtStartPosition != leavingSub.AtStartPosition));
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (!isRunning|| GUI.DisableHUD) return;
+
+            CrewManager.Draw(spriteBatch);
+
+            if (Submarine.MainSub == null) return;
+
+            Submarine leavingSub = GetLeavingSub();
+
+            if (leavingSub == null)
+            {
+                endShiftButton.Visible = false;
+            }
+            else if (leavingSub.AtEndPosition)
+            {
+                endShiftButton.Text = ToolBox.LimitString("Enter " + Map.SelectedLocation.Name, endShiftButton.Font, endShiftButton.Rect.Width - 5);
+                endShiftButton.UserData = leavingSub;
+                endShiftButton.Visible = true;
+            }
+            else if (leavingSub.AtStartPosition)
+            {
+                endShiftButton.Text = ToolBox.LimitString("Enter " + Map.CurrentLocation.Name, endShiftButton.Font, endShiftButton.Rect.Width - 5);
+                endShiftButton.UserData = leavingSub;
+                endShiftButton.Visible = true;
+            }
+            else
+            {
+                endShiftButton.Visible = false;
+            }
+
+            endShiftButton.Draw(spriteBatch);
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            if (!isRunning) return;
+
+            base.AddToGUIUpdateList();
+
+            CrewManager.AddToGUIUpdateList();
+
+            endShiftButton.AddToGUIUpdateList();
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (!isRunning || GUI.DisableHUD) return;
+
+            base.Update(deltaTime);
+
+            CrewManager.Update(deltaTime);
+
+            endShiftButton.Update(deltaTime);
+
+            if (!crewDead)
+            {
+                if (!CrewManager.characters.Any(c => !c.IsDead)) crewDead = true;                
+            }
+            else
+            {
+                endTimer -= deltaTime;
+
+                if (endTimer <= 0.0f) EndShift(null, null);
+            }  
+        }
+
+        public override void End(string endMessage = "")
+        {
+            isRunning = false;
+
+            bool success = CrewManager.characters.Any(c => !c.IsDead);
+
+            if (success)
+            {
+                if (subsToLeaveBehind == null || leavingSub == null)
+                {
+                    DebugConsole.ThrowError("Leaving submarine not selected -> selecting the closest one");
+
+                    leavingSub = GetLeavingSub();
+
+                    subsToLeaveBehind = GetSubsToLeaveBehind(leavingSub);
+                }
+            }
+            
+            GameMain.GameSession.EndShift("");
+
+            if (success)
+            {
+                if (leavingSub != Submarine.MainSub && !leavingSub.DockedTo.Contains(Submarine.MainSub))
+                {
+                    Submarine.MainSub = leavingSub;
+
+                    GameMain.GameSession.Submarine = leavingSub;
+                    
+                    foreach (Submarine sub in subsToLeaveBehind)
+                    {
+                        MapEntity.mapEntityList.RemoveAll(e => e.Submarine == sub && e is LinkedSubmarine);
+                        LinkedSubmarine.CreateDummy(leavingSub, sub);
+                    }
+                }
+
+                if (atEndPosition)
+                {
+                    Map.MoveToNextLocation();
+                }
+
+                SaveUtil.SaveGame(GameMain.GameSession.SaveFile);
+            }
+
+
+            if (!success)
+            {
+                var summaryScreen = GUIMessageBox.VisibleBox;
+
+                if (summaryScreen != null)
+                {
+                    summaryScreen = summaryScreen.children[0];
+                    summaryScreen.RemoveChild(summaryScreen.children.Find(c => c is GUIButton));
+
+                    var okButton = new GUIButton(new Rectangle(-120, 0, 100, 30), "Load game", Alignment.BottomRight, "", summaryScreen);
+                    okButton.OnClicked += GameMain.GameSession.LoadPrevious;
+                    okButton.OnClicked += (GUIButton button, object obj) => { GUIMessageBox.MessageBoxes.Remove(GUIMessageBox.VisibleBox); return true; };
+
+                    var quitButton = new GUIButton(new Rectangle(0, 0, 100, 30), "Quit", Alignment.BottomRight, "", summaryScreen);
+                    quitButton.OnClicked += GameMain.LobbyScreen.QuitToMainMenu;
+                    quitButton.OnClicked += (GUIButton button, object obj) => { GUIMessageBox.MessageBoxes.Remove(GUIMessageBox.VisibleBox); return true; };
+                }
+            }
+
+            CrewManager.EndShift();
+            for (int i = Character.CharacterList.Count - 1; i >= 0; i--)
+            {
+                Character.CharacterList[i].Remove();
+            }
+
+            Submarine.Unload();
+        }
+
+        private bool TryEndShift(GUIButton button, object obj)
+        {
+            leavingSub = obj as Submarine;
+            if (leavingSub != null)
+            {
+                subsToLeaveBehind = GetSubsToLeaveBehind(leavingSub);
+            }
+
+            atEndPosition = leavingSub.AtEndPosition;
+
+            if (subsToLeaveBehind.Any())
+            {
+                string msg = "";
+                if (subsToLeaveBehind.Count == 1)
+                {
+                    msg = "One of your vessels isn't at the exit yet. Do you want to leave it behind?";
+                }
+                else
+                {
+                    msg = "Some of your vessels aren't at the exit yet. Do you want to leave them behind?";
+                }
+
+                var msgBox = new GUIMessageBox("Warning", msg, new string[] {"Yes", "No"});
+                msgBox.Buttons[0].OnClicked += EndShift;
+                msgBox.Buttons[0].OnClicked += msgBox.Close;
+                msgBox.Buttons[0].UserData = Submarine.Loaded.FindAll(s => !subsToLeaveBehind.Contains(s));
+
+                msgBox.Buttons[1].OnClicked += msgBox.Close;
+            }
+            else
+            {
+                EndShift(button, obj);
+            }
+
+            return true;
+        }
+
+        private bool EndShift(GUIButton button, object obj)
+        {
+            isRunning = false;
+
+            List<Submarine> leavingSubs = obj as List<Submarine>;
+            if (leavingSubs == null) leavingSubs = new List<Submarine>() { GetLeavingSub() };
+            
+            var cinematic = new TransitionCinematic(leavingSubs, GameMain.GameScreen.Cam, 5.0f);
+
+            SoundPlayer.OverrideMusicType = CrewManager.characters.Any(c => !c.IsDead) ? "endshift" : "crewdead";
+
+            CoroutineManager.StartCoroutine(EndCinematic(cinematic),"EndCinematic");
+
+            return true;
+        }
+
+        private IEnumerable<object> EndCinematic(TransitionCinematic cinematic)
+        {
+            while (cinematic.Running)
+            {
+                if (Submarine.MainSub == null) yield return CoroutineStatus.Success;
+
+                yield return CoroutineStatus.Running;
+            }
+
+            if (Submarine.MainSub == null) yield return CoroutineStatus.Success;
+
+            End("");
+
+            yield return new WaitForSeconds(18.0f);
+            
+            SoundPlayer.OverrideMusicType = null;
+
+            yield return CoroutineStatus.Success;
+        }
+
+        public void Save(XElement element)
+        {
+            //element.Add(new XAttribute("day", day));
+            XElement modeElement = new XElement("gamemode");
+
+            //modeElement.Add(new XAttribute("currentlocation", Map.CurrentLocationIndex));
+            //modeElement.Add(new XAttribute("mapseed", Map.Seed));
+            
+            
+            CrewManager.Save(modeElement);
+            Map.Save(modeElement);
+
+            element.Add(modeElement);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+using Barotrauma.Networking;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    partial class TraitorManager
+    {
+        public static void CreateStartPopUp(string targetName)
+        {
+            new GUIMessageBox("You are the Traitor!",
+                "Your secret task is to assassinate " + targetName + "! Discretion is an utmost concern; sinking the submarine and killing the entire crew "
+                + "will arouse suspicion amongst the Fleet. If possible, make the death look like an accident.", 400, 350);
+        }
+    }
+}

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

@@ -0,0 +1,674 @@
+using Barotrauma.Items.Components;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma.Tutorials
+{
+    class BasicTutorial : TutorialType
+    {
+        public BasicTutorial(string name)
+            :base (name)
+        {
+
+        }
+
+        public override IEnumerable<object> UpdateState()
+        {
+            //spawn some fish next to the player
+            GameMain.GameScreen.BackgroundCreatureManager.SpawnSprites(2,
+                Submarine.MainSub.Position + Character.Controlled.Position);
+
+            foreach (Item item in Item.ItemList)
+            {
+                var wire = item.GetComponent<Wire>();
+                if (wire != null && wire.Connections.Any(c => c != null))
+                {
+                    wire.Locked = true;
+                }
+            }
+
+            yield return new WaitForSeconds(4.0f);
+
+            infoBox = CreateInfoFrame("Use WASD to move and the mouse to look around");
+
+            yield return new WaitForSeconds(5.0f);
+
+            //-----------------------------------
+
+            infoBox = CreateInfoFrame("Open the door at your right side by highlighting the button next to it with your cursor and pressing E");
+
+            Door tutorialDoor = Item.ItemList.Find(i => i.HasTag("tutorialdoor")).GetComponent<Door>();
+
+            while (!tutorialDoor.IsOpen && Character.Controlled.WorldPosition.X < tutorialDoor.Item.WorldPosition.X)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            yield return new WaitForSeconds(2.0f);
+
+            //-----------------------------------
+
+            infoBox = CreateInfoFrame("Hold W or S to walk up or down stairs. Use shift to run.", true);
+
+            while (infoBox != null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            //-----------------------------------
+
+            infoBox = CreateInfoFrame("At the moment the submarine has no power, which means that crucial systems such as the oxygen generator or the engine aren't running. Let's fix this: go to the upper left corner of the submarine, where you'll find a nuclear reactor.");
+
+            Reactor reactor = Item.ItemList.Find(i => i.HasTag("tutorialreactor")).GetComponent<Reactor>();
+            reactor.MeltDownTemp = 20000.0f;
+
+            while (Vector2.Distance(Character.Controlled.Position, reactor.Item.Position) > 200.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("The reactor requires fuel rods to generate power. You can grab one from the steel cabinet by walking next to it and pressing E.");
+
+            while (Character.Controlled.SelectedConstruction == null || Character.Controlled.SelectedConstruction.Name != "Steel Cabinet")
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Pick up one of the fuel rods either by double-clicking or dragging and dropping it into your inventory.");
+
+            while (!HasItem("Fuel Rod"))
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Select the reactor by walking next to it and pressing E.");
+
+            while (Character.Controlled.SelectedConstruction != reactor.Item)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("Load the fuel rod into the reactor by dropping it into any of the 5 slots.");
+
+            while (reactor.AvailableFuel <= 0.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("The reactor is now fueled up. Try turning it on by increasing the fission rate.");
+
+            while (reactor.FissionRate <= 0.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("The reactor core has started generating heat, which in turn generates power for the submarine. The power generation is very low at the moment,"
+            + " because the reactor is set to shut itself down when the temperature rises above 500 degrees Celsius. You can adjust the temperature limit by changing the \"Shutdown Temperature\" in the control panel.", true);
+
+            while (infoBox != null)
+            {
+                reactor.ShutDownTemp = Math.Min(reactor.ShutDownTemp, 5000.0f);
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("The amount of power generated by the reactor should be kept close to the amount of power consumed by the devices in the submarine. "
+                + "If there isn't enough power, devices won't function properly (or at all), and if there's too much power, some devices may be damaged."
+                + " Try to raise the temperature of the reactor close to 3000 degrees by adjusting the fission and cooling rates.", true);
+
+            while (Math.Abs(reactor.Temperature - 3000.0f) > 100.0f)
+            {
+                reactor.AutoTemp = false;
+                reactor.ShutDownTemp = Math.Min(reactor.ShutDownTemp, 5000.0f);
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("Looks like we're up and running! Now you should turn on the \"Automatic temperature control\", which will make the reactor "
+                + "automatically adjust the temperature to a suitable level. Even though it's an easy way to keep the reactor up and running most of the time, "
+                + "you should keep in mind that it changes the temperature very slowly and carefully, which may cause issues if there are sudden changes in grid load.");
+
+            while (!reactor.AutoTemp)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("That's the basics of operating the reactor! Now that there's power available for the engines, it's time to get the submarine moving. "
+                + "Deselect the reactor by pressing E and head to the command room at the right edge of the vessel.");
+
+            Steering steering = Item.ItemList.Find(i => i.HasTag("tutorialsteering")).GetComponent<Steering>();
+            Radar radar = steering.Item.GetComponent<Radar>();
+
+            while (Vector2.Distance(Character.Controlled.Position, steering.Item.Position) > 150.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            CoroutineManager.StartCoroutine(KeepReactorRunning(reactor));
+
+            infoBox = CreateInfoFrame("Select the navigation terminal by walking next to it and pressing E.");
+
+            while (Character.Controlled.SelectedConstruction != steering.Item)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("There seems to be something wrong with the navigation terminal." +
+                " There's nothing on the monitor, so it's probably out of power. The reactor must still be"
+                + " running or the lights would've gone out, so it's most likely a problem with the wiring."
+                + " Deselect the terminal by pressing E to start checking the wiring.");
+
+            while (Character.Controlled.SelectedConstruction == steering.Item)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(1.0f);
+
+            infoBox = CreateInfoFrame("You need a screwdriver to check the wiring of the terminal."
+            + " Equip a screwdriver by pulling it to either of the slots with a hand symbol, and then use it on the terminal by left clicking.");
+
+            while (Character.Controlled.SelectedConstruction != steering.Item ||
+                Character.Controlled.SelectedItems.FirstOrDefault(i => i != null && i.Name == "Screwdriver") == null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+
+            infoBox = CreateInfoFrame("Here you can see all the wires connected to the terminal. Apparently there's no wire"
+                + " going into the to the power connection - that's why the monitor isn't working."
+                + " You should find a piece of wire to connect it. Try searching some of the cabinets scattered around the sub.");
+
+            while (!HasItem("Wire"))
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Head back to the navigation terminal to fix the wiring.");
+
+            PowerTransfer junctionBox = Item.ItemList.Find(i => i != null && i.HasTag("tutorialjunctionbox")).GetComponent<PowerTransfer>();
+
+            while ((Character.Controlled.SelectedConstruction != junctionBox.Item &&
+                Character.Controlled.SelectedConstruction != steering.Item) ||
+            Character.Controlled.SelectedItems.FirstOrDefault(i => i != null && i.Name == "Screwdriver") == null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            if (Character.Controlled.SelectedItems.FirstOrDefault(i => i != null && i.GetComponent<Wire>() != null) == null)
+            {
+                infoBox = CreateInfoFrame("Equip the wire by dragging it to one of the slots with a hand symbol.");
+
+                while (Character.Controlled.SelectedItems.FirstOrDefault(i => i != null && i.GetComponent<Wire>() != null) == null)
+                {
+                    yield return CoroutineStatus.Running;
+                }
+            }
+
+            infoBox = CreateInfoFrame("You can see the equipped wire at the middle of the connection panel. Drag it to the power connector.");
+
+            var steeringConnection = steering.Item.Connections.Find(c => c.Name.Contains("power"));
+
+            while (steeringConnection.Wires.FirstOrDefault(w => w != null) == null)
+            {
+                yield return CoroutineStatus.Running;
+
+            }
+
+            infoBox = CreateInfoFrame("Now you have to connect the other end of the wire to a power source. "
+                + "The junction box in the room just below the command room should do.");
+
+            while (Character.Controlled.SelectedConstruction != null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            yield return new WaitForSeconds(2.0f);
+
+            infoBox = CreateInfoFrame("You can now move the other end of the wire around, and attach it on the wall by left clicking or "
+                + "remove the previous attachment by right clicking. Or if you don't care for neatly laid out wiring, you can just "
+                + "run it straight to the junction box.");
+
+            while (Character.Controlled.SelectedConstruction == null || Character.Controlled.SelectedConstruction.GetComponent<PowerTransfer>() == null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Connect the wire to the junction box by pulling it to the power connection, the same way you did with the navigation terminal.");
+
+            while (radar.Voltage < 0.1f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Great! Now we should be able to get moving.");
+
+
+            while (Character.Controlled.SelectedConstruction != steering.Item)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("You can take a look at the area around the sub by selecting the \"Sonar\" checkbox.");
+
+            while (!radar.IsActive)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(0.5f);
+
+            infoBox = CreateInfoFrame("The green rectangle in the middle is the submarine, and the flickering shapes outside it are the walls of an underwater cavern. "
+                + "Try moving the submarine by clicking somewhere on the monitor and dragging the pointer to the direction you want to go to.");
+
+            while (steering.TargetVelocity == Vector2.Zero && steering.TargetVelocity.Length() < 50.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(4.0f);
+
+            infoBox = CreateInfoFrame("The submarine moves up and down by pumping water in and out of the two ballast tanks at the bottom of the submarine. "
+                + "The engine at the back of the sub moves it forwards and backwards.", true);
+
+            while (infoBox != null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Steer the submarine downwards, heading further into the cavern.");
+
+            while (Submarine.MainSub.WorldPosition.Y > 40000.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            yield return new WaitForSeconds(1.0f);
+
+            var moloch = Character.Create(
+                "Content/Characters/Moloch/moloch.xml", 
+                steering.Item.WorldPosition + new Vector2(3000.0f, -500.0f));
+
+            moloch.PlaySound(CharacterSound.SoundType.Attack);
+
+            yield return new WaitForSeconds(1.0f);
+
+            infoBox = CreateInfoFrame("Uh-oh... Something enormous just appeared on the radar.");
+
+            List<Structure> windows = new List<Structure>();
+            foreach (Structure s in Structure.WallList)
+            {
+                if (s.CastShadow || !s.HasBody) continue;
+                
+                if (s.Rect.Right > steering.Item.CurrentHull.Rect.Right) windows.Add(s);
+            }
+
+            float slowdownTimer = 1.0f;
+            bool broken = false;
+            do
+            {
+                steering.TargetVelocity = Vector2.Zero;
+
+                slowdownTimer = Math.Max(0.0f, slowdownTimer - CoroutineManager.DeltaTime*0.3f);
+                Submarine.MainSub.Velocity *= slowdownTimer;
+
+                moloch.AIController.SelectTarget(steering.Item.CurrentHull.AiTarget);
+                Vector2 steeringDir = windows[0].WorldPosition - moloch.WorldPosition;
+                if (steeringDir != Vector2.Zero) steeringDir = Vector2.Normalize(steeringDir);
+
+                moloch.AIController.SteeringManager.SteeringManual(CoroutineManager.DeltaTime, steeringDir*100.0f);
+
+                foreach (Structure window in windows)
+                {
+                    for (int i = 0; i < window.SectionCount; i++)
+                    {
+                        if (!window.SectionIsLeaking(i)) continue;
+                        broken = true;
+                        break;
+                    }
+                    if (broken) break;
+                }
+                if (broken) break;
+
+                yield return CoroutineStatus.Running;
+            } while (!broken);
+
+            //fix everything except the command windows
+            foreach (Structure w in Structure.WallList)
+            {
+                bool isWindow = windows.Contains(w);
+
+                for (int i = 0; i < w.SectionCount; i++)
+                {
+                    if (!w.SectionIsLeaking(i)) continue;
+
+                    if (isWindow)
+                    {
+                        //decrease window damage to slow down the leaking
+                        w.AddDamage(i, -w.SectionDamage(i) * 0.48f);
+                    }
+                    else
+                    {
+                        w.AddDamage(i, -100000.0f);
+                    }
+                }
+            }
+
+            Submarine.MainSub.GodMode = true;
+
+            var capacitor1 = Item.ItemList.Find(i => i.HasTag("capacitor1")).GetComponent<PowerContainer>();
+            var capacitor2 = Item.ItemList.Find(i => i.HasTag("capacitor1")).GetComponent<PowerContainer>();
+            CoroutineManager.StartCoroutine(KeepEnemyAway(moloch, new PowerContainer[] { capacitor1, capacitor2 }));
+
+            infoBox = CreateInfoFrame("The hull has been breached! Close all the doors to the command room to stop the water from flooding the entire sub!");
+
+            Door commandDoor1 = Item.ItemList.Find(i => i.HasTag("commanddoor1")).GetComponent<Door>();
+            Door commandDoor2 = Item.ItemList.Find(i => i.HasTag("commanddoor2")).GetComponent<Door>();
+            Door commandDoor3 = Item.ItemList.Find(i => i.HasTag("commanddoor3")).GetComponent<Door>();
+
+            //wait until the player is out of the room and the doors are closed
+            while (Character.Controlled.WorldPosition.X > commandDoor1.Item.WorldPosition.X ||
+                (commandDoor1.IsOpen || (commandDoor2.IsOpen || commandDoor3.IsOpen)))
+            {
+                //prevent the hull from filling up completely and crushing the player
+                steering.Item.CurrentHull.Volume = Math.Min(steering.Item.CurrentHull.Volume, steering.Item.CurrentHull.FullVolume * 0.9f);
+                yield return CoroutineStatus.Running;
+            }
+
+
+            infoBox = CreateInfoFrame("You should quickly find yourself a diving mask or a diving suit. " +
+                "There are some in the room next to the airlock.");
+
+            bool divingMaskSelected = false;
+
+            while (!HasItem("Diving Mask") && !HasItem("Diving Suit"))
+            {
+                if (!divingMaskSelected &&
+                    Character.Controlled.ClosestItem != null && Character.Controlled.ClosestItem.Name == "Diving Suit")
+                {
+                    infoBox = CreateInfoFrame("There can only be one item in each inventory slot, so you need to take off "
+                        + "the jumpsuit if you wish to wear a diving suit.");
+
+                    divingMaskSelected = true;
+                }
+
+                yield return CoroutineStatus.Running;
+            }
+
+            if (HasItem("Diving Mask"))
+            {
+                infoBox = CreateInfoFrame("The diving mask will let you breathe underwater, but it won't protect from the water pressure outside the sub. " +
+                    "It should be fine for the situation at hand, but you still need to find an oxygen tank and drag it into the same slot as the mask." +
+                    "You should grab one or two from one of the cabinets.");
+            }
+            else if (HasItem("Diving Suit"))
+            {
+                infoBox = CreateInfoFrame("In addition to letting you breathe underwater, the suit will protect you from the water pressure outside the sub " +
+                    "(unlike the diving mask). However, you still need to drag an oxygen tank into the same slot as the suit to supply oxygen. " +
+                    "You should grab one or two from one of the cabinets.");
+            }
+
+            while (!HasItem("Oxygen Tank"))
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            yield return new WaitForSeconds(5.0f);
+
+            infoBox = CreateInfoFrame("Now you should stop the creature attacking the submarine before it does any more damage. Head to the railgun room at the upper right corner of the sub.");
+
+            var railGun = Item.ItemList.Find(i => i.GetComponent<Turret>() != null);
+
+            while (Vector2.Distance(Character.Controlled.Position, railGun.Position) > 500)
+            {
+                yield return new WaitForSeconds(1.0f);
+            }
+
+            infoBox = CreateInfoFrame("The railgun requires a large power surge to fire. The reactor can't provide a surge large enough, so we need to use the "
+                + " supercapacitors in the railgun room. The capacitors need to be charged first; select them and crank up the recharge rate.");
+
+            while (capacitor1.RechargeSpeed < 0.5f && capacitor2.RechargeSpeed < 0.5f)
+            {
+                yield return new WaitForSeconds(1.0f);
+            }
+
+            infoBox = CreateInfoFrame("The capacitors take some time to recharge, so now is a good " +
+                "time to head to the room below and load some shells for the railgun.");
+
+
+            var loader = Item.ItemList.Find(i => i.Name == "Railgun Loader").GetComponent<ItemContainer>();
+
+            while (Math.Abs(Character.Controlled.Position.Y - loader.Item.Position.Y) > 80)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Grab one of the shells. You can load it by selecting the railgun loader and dragging the shell to. "
+                + "one of the free slots. You need two hands to carry a shell, so make sure you don't have anything else in either hand.");
+
+            while (loader.Item.ContainedItems.FirstOrDefault(i => i != null && i.Name == "Railgun Shell") == null)
+            {
+                moloch.Health = 50.0f;
+
+                capacitor1.Charge += 5.0f;
+                capacitor2.Charge += 5.0f;
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Now we're ready to shoot! Select the railgun controller.");
+
+            while (Character.Controlled.SelectedConstruction == null || Character.Controlled.SelectedConstruction.Name != "Railgun Controller")
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            moloch.AnimController.SetPosition(ConvertUnits.ToSimUnits(Character.Controlled.WorldPosition + Vector2.UnitY * 600.0f));
+
+            infoBox = CreateInfoFrame("Use the right mouse button to aim and wait for the creature to come closer. When you're ready to shoot, "
+                + "press the left mouse button.");
+
+            while (!moloch.IsDead)
+            {
+                if (moloch.WorldPosition.Y > Character.Controlled.WorldPosition.Y + 600.0f)
+                {
+                    moloch.AIController.SteeringManager.SteeringManual(CoroutineManager.DeltaTime, Character.Controlled.WorldPosition - moloch.WorldPosition);
+                }
+
+                moloch.AIController.SelectTarget(Character.Controlled.AiTarget);
+                yield return CoroutineStatus.Running;
+            }
+
+            Submarine.MainSub.GodMode = false;
+
+            infoBox = CreateInfoFrame("The creature has died. Now you should fix the damages in the control room: " +
+                "Grab a welding tool from the closet in the railgun room.");
+
+            while (!HasItem("Welding Tool"))
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("The welding tool requires fuel to work. Grab a welding fuel tank and attach it to the tool " +
+                "by dragging it into the same slot.");
+
+            do
+            {
+                var weldingTool = Character.Controlled.Inventory.Items.FirstOrDefault(i => i != null && i.Name == "Welding Tool");
+                if (weldingTool != null &&
+                    weldingTool.ContainedItems.FirstOrDefault(contained => contained != null && contained.Name == "Welding Fuel Tank") != null) break;
+
+                yield return CoroutineStatus.Running;
+            } while (true);
+
+
+            infoBox = CreateInfoFrame("You can aim with the tool using the right mouse button and weld using the left button. " +
+                "Head to the command room to fix the leaks there.");
+
+            do
+            {
+                broken = false;
+                foreach (Structure window in windows)
+                {
+                    for (int i = 0; i < window.SectionCount; i++)
+                    {
+                        if (!window.SectionIsLeaking(i)) continue;
+                        broken = true;
+                        break;
+                    }
+                    if (broken) break;
+                }
+
+                yield return new WaitForSeconds(1.0f);
+            } while (broken);
+
+            infoBox = CreateInfoFrame("The hull is fixed now, but there's still quite a bit of water inside the sub. It should be pumped out "
+                + "using the bilge pump in the room at the bottom of the submarine.");
+
+            Pump pump = Item.ItemList.Find(i => i.HasTag("tutorialpump")).GetComponent<Pump>();
+
+            while (Vector2.Distance(Character.Controlled.Position, pump.Item.Position) > 100.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("The two pumps inside the ballast tanks "
+                + "are connected straight to the navigation terminal and can't be manually controlled unless you mess with their wiring, " +
+                "so you should only use the pump in the middle room to pump out the water. Select it, turn it on and adjust the pumping speed " +
+                "to start pumping water out.", true);
+
+            while (infoBox != null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+
+            bool brokenMsgShown = false;
+
+            Item brokenBox = null;
+
+            while (pump.FlowPercentage > 0.0f || pump.CurrFlow <= 0.0f || !pump.IsActive)
+            {
+                if (!brokenMsgShown && pump.Voltage < pump.MinVoltage && Character.Controlled.SelectedConstruction == pump.Item)
+                {
+                    brokenMsgShown = true;
+
+                    infoBox = CreateInfoFrame("Looks like the pump isn't getting any power. The water must have short-circuited some of the junction "
+                        +"boxes. You can check which boxes are broken by selecting them.");
+
+                    while (true)
+                    {
+                        if (Character.Controlled.SelectedConstruction!=null && 
+                            Character.Controlled.SelectedConstruction.GetComponent<PowerTransfer>() != null && 
+                            Character.Controlled.SelectedConstruction.Condition == 0.0f)
+                        {
+                            brokenBox = Character.Controlled.SelectedConstruction;
+
+                            infoBox = CreateInfoFrame("Here's our problem: this junction box is broken. Luckily engineers are adept at fixing electrical devices - "
+                                +"you just need to find a spare wire and click the \"Fix\"-button to repair the box.");
+                            break;
+                        }
+
+                        if (pump.Voltage > pump.MinVoltage) break;
+
+                        yield return CoroutineStatus.Running;
+                    }
+                }
+
+                if (brokenBox != null && brokenBox.Condition > 50.0f && pump.Voltage < pump.MinVoltage)
+                {
+                    yield return new WaitForSeconds(1.0f);
+
+                    if (pump.Voltage < pump.MinVoltage)
+                    {
+                        infoBox = CreateInfoFrame("The pump is still not running. Check if there are more broken junction boxes between the pump and the reactor.");
+                    }
+                    brokenBox = null;
+                }
+
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("The pump is up and running. Wait for the water to be drained out.");
+
+            while (pump.Item.CurrentHull.Volume > 1000.0f)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("That was all there is to this tutorial! Now you should be able to handle " +
+            "most of the basic tasks on board the submarine.");
+
+            yield return new WaitForSeconds(4.0f);
+
+            Character.Controlled = null;
+            GameMain.GameScreen.Cam.TargetPos = Vector2.Zero;
+            GameMain.LightManager.LosEnabled = false;
+
+            var cinematic = new TransitionCinematic(Submarine.MainSub, GameMain.GameScreen.Cam, 5.0f);
+
+            while (cinematic.Running)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            Submarine.Unload();
+            GameMain.MainMenuScreen.Select();
+
+            yield return CoroutineStatus.Success;
+        }
+
+        private bool HasItem(string itemName)
+        {
+            if (Character.Controlled == null) return false;
+
+            return Character.Controlled.Inventory.FindItem(itemName) != null;
+        }
+
+
+
+        protected IEnumerable<object> KeepReactorRunning(Reactor reactor)
+        {
+            do
+            {
+                reactor.AutoTemp = true;
+                reactor.ShutDownTemp = 5000.0f;
+
+                yield return CoroutineStatus.Running;
+            } while (Item.ItemList.Contains(reactor.Item));
+
+            yield return CoroutineStatus.Success;
+        }
+
+
+        /// <summary>
+        /// keeps the enemy away from the sub until the capacitors are loaded
+        /// </summary>
+        private IEnumerable<object> KeepEnemyAway(Character enemy, PowerContainer[] capacitors)
+        {
+            do
+            {
+                if (enemy == null || Character.Controlled == null) break;
+
+                enemy.Health = 50.0f;
+
+                enemy.AIController.State = AIController.AIState.None;
+
+                Vector2 targetPos = Character.Controlled.WorldPosition + new Vector2(0.0f, 3000.0f);
+
+                Vector2 steering = targetPos - enemy.WorldPosition;
+                if (steering != Vector2.Zero) steering = Vector2.Normalize(steering);
+
+                enemy.AIController.Steering = steering * 2.0f;
+
+                yield return CoroutineStatus.Running;
+            } while (capacitors.FirstOrDefault(c => c.Charge > 0.4f) == null);
+
+            yield return CoroutineStatus.Success;
+        }
+
+    }
+}

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

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+
+namespace Barotrauma.Tutorials
+{
+    class EditorTutorial : TutorialType
+    {
+        public EditorTutorial(string name)
+            : base (name)
+        {
+        }
+
+        public override IEnumerable<object> UpdateState()
+        {
+            infoBox = CreateInfoFrame("Use the mouse wheel to zoom in and out, and WASD to move the camera around.", true);
+
+            while (infoBox!=null)
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("Press \"Structure\" at the left side of the screen to start placing some walls.");
+
+            while (GameMain.EditMapScreen.SelectedTab != (int)MapEntityCategory.Structure)
+            {
+                yield return CoroutineStatus.Running;
+            }
+            
+            infoBox = CreateInfoFrame("Select \"topwall\" from the list.", true);
+
+            while (MapEntityPrefab.Selected == null || MapEntityPrefab.Selected.Name != "topwall")
+            {
+                yield return CoroutineStatus.Running;
+            }
+
+            infoBox = CreateInfoFrame("You can now create a horizontal wall by clicking and dragging. When you're done, right click to stop creating walls.");
+
+
+
+
+            yield return CoroutineStatus.Success;
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Tutorials;
+
+namespace Barotrauma
+{
+    class TutorialMode : GameMode
+    {
+        public TutorialType tutorialType;
+        
+        public static void StartTutorial(TutorialType tutorialType)
+        {
+            Submarine.MainSub = Submarine.Load("Content/Map/TutorialSub.sub", "", true);
+            
+            tutorialType.Initialize();
+        }
+
+        public TutorialMode(GameModePreset preset, object param)
+            : base(preset, param)
+        {
+        }
+
+        public override void Start()
+        {
+            base.Start();
+
+            tutorialType.Start();
+
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            tutorialType.AddToGUIUpdateList();
+        }
+
+        public override void Update(float deltaTime)
+        {
+            base.Update(deltaTime);
+
+            tutorialType.Update(deltaTime);
+
+        }
+
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            base.Draw(spriteBatch);
+
+            //CrewManager.Draw(spriteBatch);
+            tutorialType.Draw(spriteBatch);
+        }
+
+    }
+}

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

@@ -0,0 +1,181 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+
+namespace Barotrauma.Tutorials
+{
+    class TutorialType
+    {
+
+        public static List<TutorialType> TutorialTypes;
+
+        protected GUIComponent infoBox;
+
+        Character character;
+
+
+        public string Name
+        {
+            get;
+            private set;
+        }
+
+        static TutorialType()
+        {
+            TutorialTypes = new List<TutorialType>();
+
+            TutorialTypes.Add(new BasicTutorial("Basic tutorial"));
+
+        }
+
+        public TutorialType(string name)
+        {
+            this.Name = name;
+        }
+
+        public virtual void Initialize()
+        {
+
+            GameMain.GameSession = new GameSession(Submarine.MainSub, "", GameModePreset.list.Find(gm => gm.Name.ToLowerInvariant() == "tutorial"));
+            (GameMain.GameSession.gameMode as TutorialMode).tutorialType = this;
+
+            GameMain.GameSession.StartShift("tuto");
+
+            GameMain.GameSession.TaskManager.Tasks.Clear();
+
+            GameMain.GameScreen.Select();
+        }
+
+        public virtual void Start()
+        {
+
+            WayPoint wayPoint = WayPoint.GetRandom(SpawnType.Cargo, null);
+            if (wayPoint == null)
+            {
+                DebugConsole.ThrowError("A waypoint with the spawntype \"cargo\" is required for the tutorial event");
+                return;
+            }
+
+            CharacterInfo charInfo = new CharacterInfo(Character.HumanConfigFile, "", Gender.None, JobPrefab.List.Find(jp => jp.Name == "Engineer"));
+
+            character = Character.Create(charInfo, wayPoint.WorldPosition, false, false);
+            Character.Controlled = character;
+            character.GiveJobItems(null);
+
+            var idCard = character.Inventory.FindItem("ID Card");
+            if (idCard == null)
+            {
+                DebugConsole.ThrowError("Item prefab \"ID Card\" not found!");
+                return;
+            }
+            idCard.AddTag("com");
+            idCard.AddTag("eng");
+
+            //CoroutineManager.StartCoroutine(QuitChecker());
+            CoroutineManager.StartCoroutine(UpdateState());
+        }
+
+        public virtual void AddToGUIUpdateList()
+        {
+            if (infoBox != null) infoBox.AddToGUIUpdateList();
+        }
+
+        public virtual void Update(float deltaTime)
+        {
+            if (character!=null)
+            {
+                if (Character.Controlled==null)
+                {
+                    CoroutineManager.StopCoroutines("TutorialMode.UpdateState");
+                    infoBox = null;
+                }
+                else if (Character.Controlled.IsDead)
+                {
+                    Character.Controlled = null;
+
+                    CoroutineManager.StopCoroutines("TutorialMode.UpdateState");
+                    infoBox = null;
+                    CoroutineManager.StartCoroutine(Dead());
+                }
+            }
+
+
+            //CrewManager.Update(deltaTime);
+
+            if (infoBox != null) infoBox.Update(deltaTime);
+        }
+
+        public virtual IEnumerable<object> UpdateState()
+        {
+            yield return CoroutineStatus.Success;
+        }
+
+        public virtual void Draw(SpriteBatch spriteBatch)
+        {
+
+            if (infoBox != null) infoBox.Draw(spriteBatch);
+        }
+
+
+
+        private IEnumerable<object> Dead()
+        {
+            yield return new WaitForSeconds(3.0f);
+
+            var messageBox = new GUIMessageBox("You have died", "Do you want to try again?", new string[] { "Yes", "No" });
+
+            messageBox.Buttons[0].OnClicked += Restart;
+            messageBox.Buttons[0].OnClicked += messageBox.Close;
+
+
+            messageBox.Buttons[1].OnClicked = GameMain.MainMenuScreen.SelectTab;
+            messageBox.Buttons[1].OnClicked += messageBox.Close;
+
+            yield return CoroutineStatus.Success;
+        }
+
+
+        protected bool CloseInfoFrame(GUIButton button, object userData)
+        {
+            infoBox = null;
+
+            return true;
+        }
+
+        protected GUIComponent CreateInfoFrame(string text, bool hasButton = false)
+        {
+            int width = 300;
+            int height = hasButton ? 110 : 80;
+
+            string wrappedText = ToolBox.WrapText(text, width, GUI.Font);
+
+            height += wrappedText.Split('\n').Length * 25;
+
+            var infoBlock = new GUIFrame(new Rectangle(-20, 20, width, height), null, Alignment.TopRight, "");
+            //infoBlock.Color = infoBlock.Color * 0.8f;
+            infoBlock.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+            infoBlock.Flash(Color.Green);
+
+            var textBlock = new GUITextBlock(new Rectangle(10, 10, width - 40, height), text, "", infoBlock, true);
+
+            if (hasButton)
+            {
+                var okButton = new GUIButton(new Rectangle(0, -40, 80, 25), "OK", Alignment.BottomCenter, "", textBlock);
+                okButton.OnClicked = CloseInfoFrame;
+            }
+
+
+            GUI.PlayUISound(GUISoundType.Message);
+
+            return infoBlock;
+        }
+
+
+        private bool Restart(GUIButton button, object obj)
+        {
+            TutorialMode.StartTutorial(this);
+
+            return true;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameSession/GameSession.cs

@@ -0,0 +1,197 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class GameSession
+    {
+        private InfoFrameTab selectedTab;
+        private GUIButton infoButton;
+        private GUIFrame infoFrame;
+
+        public Map Map
+        {
+            get
+            {
+                SinglePlayerMode mode = (gameMode as SinglePlayerMode);
+                return (mode == null) ? null : mode.Map;
+            }
+        }
+        
+        private ShiftSummary shiftSummary;
+
+        public ShiftSummary ShiftSummary
+        {
+            get { return shiftSummary; }
+        }
+
+        public bool LoadPrevious(GUIButton button, object obj)
+        {
+            Submarine.Unload();
+
+            SaveUtil.LoadGame(saveFile);
+
+            GameMain.LobbyScreen.Select();
+
+            return true;
+        }
+
+        private bool ToggleInfoFrame(GUIButton button, object obj)
+        {
+            if (infoFrame == null)
+            {
+                if (CrewManager != null && CrewManager.CrewCommander != null && CrewManager.CrewCommander.IsOpen)
+                {
+                    CrewManager.CrewCommander.ToggleGUIFrame();
+                }
+
+                CreateInfoFrame();
+                SelectInfoFrameTab(null, selectedTab);
+            }
+            else
+            {
+                infoFrame = null;
+            }
+
+            return true;
+        }
+
+        public void CreateInfoFrame()
+        {
+            int width = 600, height = 400;
+
+
+            infoFrame = new GUIFrame(
+                Rectangle.Empty, Color.Black * 0.8f, null);
+
+            var innerFrame = new GUIFrame(
+                new Rectangle(GameMain.GraphicsWidth / 2 - width / 2, GameMain.GraphicsHeight / 2 - height / 2, width, height), "", infoFrame);
+
+            innerFrame.Padding = new Vector4(10.0f, 10.0f, 10.0f, 10.0f);
+
+            var crewButton = new GUIButton(new Rectangle(0, -30, 100, 20), "Crew", "", innerFrame);
+            crewButton.UserData = InfoFrameTab.Crew;
+            crewButton.OnClicked = SelectInfoFrameTab;
+
+            var missionButton = new GUIButton(new Rectangle(100, -30, 100, 20), "Mission", "", innerFrame);
+            missionButton.UserData = InfoFrameTab.Mission;
+            missionButton.OnClicked = SelectInfoFrameTab;
+
+            if (GameMain.Server != null)
+            {
+                var manageButton = new GUIButton(new Rectangle(200, -30, 130, 20), "Manage players", "", innerFrame);
+                manageButton.UserData = InfoFrameTab.ManagePlayers;
+                manageButton.OnClicked = SelectInfoFrameTab;
+            }
+
+            var closeButton = new GUIButton(new Rectangle(0, 0, 80, 20), "Close", Alignment.BottomCenter, "", innerFrame);
+            closeButton.OnClicked = ToggleInfoFrame;
+
+        }
+
+        private bool SelectInfoFrameTab(GUIButton button, object userData)
+        {
+            selectedTab = (InfoFrameTab)userData;
+
+            CreateInfoFrame();
+
+            switch (selectedTab)
+            {
+                case InfoFrameTab.Crew:
+                    CrewManager.CreateCrewFrame(CrewManager.characters, infoFrame.children[0] as GUIFrame);
+                    break;
+                case InfoFrameTab.Mission:
+                    CreateMissionInfo(infoFrame.children[0] as GUIFrame);
+                    break;
+                case InfoFrameTab.ManagePlayers:
+                    GameMain.Server.ManagePlayersFrame(infoFrame.children[0] as GUIFrame);
+                    break;
+            }
+
+            return true;
+        }
+
+        private void CreateMissionInfo(GUIFrame infoFrame)
+        {
+            if (Mission == null)
+            {
+                new GUITextBlock(new Rectangle(0, 0, 0, 50), "No mission", "", infoFrame, true);
+                return;
+            }
+
+            new GUITextBlock(new Rectangle(0, 0, 0, 40), Mission.Name, "", infoFrame, GUI.LargeFont);
+
+            new GUITextBlock(new Rectangle(0, 50, 0, 20), "Reward: " + Mission.Reward, "", infoFrame, true);
+            new GUITextBlock(new Rectangle(0, 70, 0, 50), Mission.Description, "", infoFrame, true);
+
+
+        }
+
+        public void AddToGUIUpdateList()
+        {
+            infoButton.AddToGUIUpdateList();
+
+            if (gameMode != null) gameMode.AddToGUIUpdateList();
+
+            if (infoFrame != null) infoFrame.AddToGUIUpdateList();
+        }
+
+        public void Update(float deltaTime)
+        {
+            TaskManager.Update(deltaTime);
+
+            if (GUI.DisableHUD) return;
+
+            //guiRoot.Update(deltaTime);
+            infoButton.Update(deltaTime);
+
+            if (gameMode != null) gameMode.Update(deltaTime);
+            if (Mission != null) Mission.Update(deltaTime);
+            if (infoFrame != null)
+            {
+                infoFrame.Update(deltaTime);
+
+                if (CrewManager != null && CrewManager.CrewCommander != null && CrewManager.CrewCommander.IsOpen)
+                {
+                    infoFrame = null;
+                }
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (GUI.DisableHUD) return;
+
+            infoButton.Draw(spriteBatch);
+
+            if (gameMode != null) gameMode.Draw(spriteBatch);
+            if (infoFrame != null) infoFrame.Draw(spriteBatch);
+        }
+
+        public void Save(string filePath)
+        {
+            XDocument doc = new XDocument(
+                new XElement("Gamesession"));
+
+            var now = DateTime.Now;
+            doc.Root.Add(new XAttribute("savetime", now.ToShortTimeString() + ", " + now.ToShortDateString()));
+
+            doc.Root.Add(new XAttribute("submarine", submarine == null ? "" : submarine.Name));
+
+            doc.Root.Add(new XAttribute("mapseed", Map.Seed));
+
+            ((SinglePlayerMode)gameMode).Save(doc.Root);
+
+            try
+            {
+                doc.Save(filePath);
+            }
+            catch
+            {
+                DebugConsole.ThrowError("Saving gamesession to \"" + filePath + "\" failed!");
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameSession/HireManager.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class HireManager
+    {
+        public List<CharacterInfo> availableCharacters;
+
+        public const int MaxAvailableCharacters = 10;
+
+        public HireManager()
+        {
+            availableCharacters = new List<CharacterInfo>();
+        }
+        
+        public void GenerateCharacters(Location location, int amount)
+        {            
+            for (int i = 0 ; i<amount ; i++)
+            {
+                JobPrefab job = location.Type.GetRandomHireable();
+                if (job == null) return;
+
+                availableCharacters.Add(new CharacterInfo(Character.HumanConfigFile, "", Gender.None, job));
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameSession/ShiftSummary.cs

@@ -0,0 +1,128 @@
+using Microsoft.Xna.Framework;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class ShiftSummary
+    {
+        private Location startLocation, endLocation;
+
+        private GameSession gameSession;
+
+        private Mission selectedMission;
+               
+        public ShiftSummary(GameSession gameSession)
+        {
+            this.gameSession = gameSession;
+
+            startLocation   = gameSession.StartLocation;
+            endLocation     = gameSession.EndLocation;
+            
+            selectedMission = gameSession.Mission;
+        }
+        
+
+        public GUIFrame CreateSummaryFrame(string endMessage)
+        {
+            bool singleplayer = GameMain.NetworkMember == null;
+
+            bool gameOver = gameSession.CrewManager.characters.All(c => c.IsDead);
+            bool progress = Submarine.MainSub.AtEndPosition;
+            
+            GUIFrame frame = new GUIFrame(new Rectangle(0, 0, GameMain.GraphicsWidth, GameMain.GraphicsHeight), Color.Black * 0.8f);
+            
+            int width = 760, height = 400;
+            GUIFrame innerFrame = new GUIFrame(new Rectangle(0, 0, width, height), null, Alignment.Center, "", frame);
+            
+            int y = 0;
+            
+            if (singleplayer)
+            {
+                string summaryText = InfoTextManager.GetInfoText(gameOver ? "gameover" :
+                    (progress ? "progress" : "return"));
+
+                var infoText = new GUITextBlock(new Rectangle(0, y, 0, 50), summaryText, "", innerFrame, true);
+                y += infoText.Rect.Height;
+            }
+
+
+            if (!string.IsNullOrWhiteSpace(endMessage))
+            {
+                var endText = new GUITextBlock(new Rectangle(0, y, 0, 30), endMessage, "", innerFrame, true);
+
+                y += 30 + endText.Text.Split('\n').Length * 20;
+            }
+
+            new GUITextBlock(new Rectangle(0, y, 0, 20), "Crew status:", "", innerFrame, GUI.LargeFont);
+            y += 30;
+
+            GUIListBox listBox = new GUIListBox(new Rectangle(0,y,0,90), null, Alignment.TopLeft, "", innerFrame, true);
+
+            int x = 0;
+            foreach (Character character in gameSession.CrewManager.characters)
+            {
+                if (GameMain.GameSession.Mission is CombatMission && 
+                    character.TeamID != GameMain.GameSession.CrewManager.WinningTeam)
+                {
+                    continue;
+                }
+
+                var characterFrame = new GUIFrame(new Rectangle(x, y, 170, 70), Color.Transparent, "", listBox);
+                characterFrame.OutlineColor = Color.Transparent;
+                characterFrame.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+                characterFrame.CanBeFocused = false;
+
+                character.Info.CreateCharacterFrame(characterFrame,
+                    character.Info.Job != null ? (character.Info.Name + '\n' + "(" + character.Info.Job.Name + ")") : character.Info.Name, null);
+                
+                string statusText = "OK";
+                Color statusColor = Color.DarkGreen;
+
+                if (character.IsDead)
+                {
+                    statusText = InfoTextManager.GetInfoText("CauseOfDeath." + character.CauseOfDeath.ToString());
+                    statusColor = Color.DarkRed;
+                }
+                else
+                {
+                    if (character.IsUnconscious)
+                    {
+                        statusText = "Unconscious";
+                        statusColor = Color.DarkOrange;
+                    }
+                    else if (character.Health / character.MaxHealth < 0.8f)
+                    {
+                        statusText = "Injured";
+                        statusColor = Color.DarkOrange;
+                    }
+                }
+
+                new GUITextBlock(
+                    new Rectangle(0, 0, 0, 20), statusText, statusColor * 0.8f, Color.White,
+                    Alignment.BottomLeft, Alignment.Center,
+                    null, characterFrame, true, GUI.SmallFont);
+
+                x += characterFrame.Rect.Width + 10;                
+            }
+
+            y += 120;
+
+            if (GameMain.GameSession.Mission != null)
+            {
+                new GUITextBlock(new Rectangle(0, y, 0, 20), "Mission: " + GameMain.GameSession.Mission.Name, "", innerFrame, GUI.LargeFont);
+                y += 30;
+
+                new GUITextBlock(new Rectangle(0, y, innerFrame.Rect.Width - 170, 0),
+                    (GameMain.GameSession.Mission.Completed) ? GameMain.GameSession.Mission.SuccessMessage : GameMain.GameSession.Mission.FailureMessage,
+                    "", innerFrame, true);
+
+                if (GameMain.GameSession.Mission.Completed && singleplayer)
+                {
+                    new GUITextBlock(new Rectangle(0, 0, 0, 30), "Reward: " + GameMain.GameSession.Mission.Reward, "", Alignment.BottomLeft, Alignment.BottomLeft, innerFrame);
+                }  
+            }
+
+            return frame;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/GameSettings.cs

@@ -0,0 +1,529 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    public enum WindowMode
+    {
+        Windowed, Fullscreen, BorderlessWindowed
+    }
+
+    public partial class GameSettings
+    {
+        private GUIFrame settingsFrame;
+        private GUIButton applyButton;
+        
+        private float soundVolume, musicVolume;
+
+        private WindowMode windowMode;
+
+        public List<string> jobNamePreferences;
+
+        private KeyOrMouse[] keyMapping;
+
+        private bool unsavedSettings;
+        
+        public GUIFrame SettingsFrame
+        {
+            get
+            {
+                if (settingsFrame == null) CreateSettingsFrame();
+                return settingsFrame;
+            }
+        }
+
+        public KeyOrMouse KeyBind(InputType inputType)
+        {
+            return keyMapping[(int)inputType];
+        }
+
+        public int GraphicsWidth { get; set; }
+        public int GraphicsHeight { get; set; }
+
+        public bool VSyncEnabled { get; set; }
+
+        public bool EnableSplashScreen { get; set; }
+
+        //public bool FullScreenEnabled { get; set; }
+
+        public WindowMode WindowMode
+        {
+            get { return windowMode; }
+            set { windowMode = value; }
+        }
+        
+        public List<string> JobNamePreferences
+        {
+            get { return jobNamePreferences; }
+            set
+            {
+                // Begin saving coroutine. Remove any existing save coroutines if one is running.
+                if (CoroutineManager.IsCoroutineRunning("saveCoroutine")) { CoroutineManager.StopCoroutines("saveCoroutine"); }
+                CoroutineManager.StartCoroutine(ApplyUnsavedChanges(), "saveCoroutine");
+
+                jobNamePreferences = value;
+            }
+        }
+        
+        public bool UnsavedSettings
+        {
+            get
+            {
+                return unsavedSettings;
+            }
+            private set
+            {
+                unsavedSettings = value;
+
+                if (applyButton != null)
+                {
+                    //applyButton.Selected = unsavedSettings;
+                    applyButton.Enabled = unsavedSettings;
+                    applyButton.Text = unsavedSettings ? "Apply*" : "Apply";
+                }
+            }
+        }
+
+        public float SoundVolume
+        {
+            get { return soundVolume; }
+            set
+            {
+                soundVolume = MathHelper.Clamp(value, 0.0f, 1.0f);
+                Sounds.SoundManager.MasterVolume = soundVolume;
+            }
+        }
+
+        public float MusicVolume
+        {
+            get { return musicVolume; }
+            set
+            {
+                musicVolume = MathHelper.Clamp(value, 0.0f, 1.0f);
+                SoundPlayer.MusicVolume = musicVolume;
+            }
+        }
+
+        partial void InitProjSpecific(XDocument doc)
+        {
+            if (doc == null)
+            {
+                GraphicsWidth = 1024;
+                GraphicsHeight = 678;
+                
+                MasterServerUrl = "";
+                
+                SelectedContentPackage = ContentPackage.list.Any() ? ContentPackage.list[0] : new ContentPackage("");
+
+                JobNamePreferences = new List<string>();
+                foreach (JobPrefab job in JobPrefab.List)
+                {
+                    JobNamePreferences.Add(job.Name);
+                }
+                return;
+            }
+
+            XElement graphicsMode = doc.Root.Element("graphicsmode");
+            GraphicsWidth = ToolBox.GetAttributeInt(graphicsMode, "width", 0);
+            GraphicsHeight = ToolBox.GetAttributeInt(graphicsMode, "height", 0);
+            VSyncEnabled = ToolBox.GetAttributeBool(graphicsMode, "vsync", true);
+
+            if (GraphicsWidth == 0 || GraphicsHeight == 0)
+            {
+                GraphicsWidth = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
+                GraphicsHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
+            }
+
+            //FullScreenEnabled = ToolBox.GetAttributeBool(graphicsMode, "fullscreen", true);
+
+            var windowModeStr = ToolBox.GetAttributeString(graphicsMode, "displaymode", "Fullscreen");
+            if (!Enum.TryParse<WindowMode>(windowModeStr, out windowMode))
+            {
+                windowMode = WindowMode.Fullscreen;
+            }
+
+            SoundVolume = ToolBox.GetAttributeFloat(doc.Root, "soundvolume", 1.0f);
+            MusicVolume = ToolBox.GetAttributeFloat(doc.Root, "musicvolume", 0.3f);
+
+            EnableSplashScreen = ToolBox.GetAttributeBool(doc.Root, "enablesplashscreen", true);
+
+            keyMapping = new KeyOrMouse[Enum.GetNames(typeof(InputType)).Length];
+            keyMapping[(int)InputType.Up] = new KeyOrMouse(Keys.W);
+            keyMapping[(int)InputType.Down] = new KeyOrMouse(Keys.S);
+            keyMapping[(int)InputType.Left] = new KeyOrMouse(Keys.A);
+            keyMapping[(int)InputType.Right] = new KeyOrMouse(Keys.D);
+            keyMapping[(int)InputType.Run] = new KeyOrMouse(Keys.LeftShift);
+
+
+            keyMapping[(int)InputType.Chat] = new KeyOrMouse(Keys.Tab);
+            keyMapping[(int)InputType.CrewOrders] = new KeyOrMouse(Keys.C);
+
+            keyMapping[(int)InputType.Select] = new KeyOrMouse(Keys.E);
+
+            keyMapping[(int)InputType.Use] = new KeyOrMouse(0);
+            keyMapping[(int)InputType.Aim] = new KeyOrMouse(1);
+
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "keymapping":
+                        foreach (XAttribute attribute in subElement.Attributes())
+                        {
+                            InputType inputType;
+                            if (Enum.TryParse(attribute.Name.ToString(), true, out inputType))
+                            {
+                                int mouseButton;
+                                if (int.TryParse(attribute.Value.ToString(), out mouseButton))
+                                {
+                                    keyMapping[(int)inputType] = new KeyOrMouse(mouseButton);
+                                }
+                                else
+                                {
+                                    Keys key;
+                                    if (Enum.TryParse(attribute.Value.ToString(), true, out key))
+                                    {
+                                        keyMapping[(int)inputType] = new KeyOrMouse(key);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case "gameplay":
+                        JobNamePreferences = new List<string>();
+                        foreach (XElement ele in subElement.Element("jobpreferences").Elements("job"))
+                        {
+                            JobNamePreferences.Add(ToolBox.GetAttributeString(ele, "name", ""));
+                        }
+                        break;
+                }
+            }
+
+            foreach (InputType inputType in Enum.GetValues(typeof(InputType)))
+            {
+                if (keyMapping[(int)inputType] == null)
+                {
+                    DebugConsole.ThrowError("Key binding for the input type \"" + inputType + " not set!");
+                    keyMapping[(int)inputType] = new KeyOrMouse(Keys.D1);
+                }
+            }
+
+
+            UnsavedSettings = false;
+        }
+
+        public void Save(string filePath)
+        {
+            UnsavedSettings = false;
+
+            XDocument doc = new XDocument();
+
+            if (doc.Root == null)
+            {
+                doc.Add(new XElement("config"));
+            }
+
+            doc.Root.Add(
+                new XAttribute("masterserverurl", MasterServerUrl),
+                new XAttribute("autocheckupdates", AutoCheckUpdates),
+                new XAttribute("musicvolume", musicVolume),
+                new XAttribute("soundvolume", soundVolume),
+                new XAttribute("verboselogging", VerboseLogging),
+                new XAttribute("enablesplashscreen", EnableSplashScreen));
+
+            if (WasGameUpdated)
+            {
+                doc.Root.Add(new XAttribute("wasgameupdated", true));
+            }
+
+            XElement gMode = doc.Root.Element("graphicsmode");
+            if (gMode == null)
+            {
+                gMode = new XElement("graphicsmode");
+                doc.Root.Add(gMode);
+            }
+
+            if (GraphicsWidth == 0 || GraphicsHeight == 0)
+            {
+                gMode.ReplaceAttributes(new XAttribute("displaymode", windowMode));
+            }
+            else
+            {
+                gMode.ReplaceAttributes(
+                    new XAttribute("width", GraphicsWidth),
+                    new XAttribute("height", GraphicsHeight),
+                    new XAttribute("vsync", VSyncEnabled),
+                    new XAttribute("displaymode", windowMode));
+            }
+
+
+            if (SelectedContentPackage != null)
+            {
+                doc.Root.Add(new XElement("contentpackage",
+                    new XAttribute("path", SelectedContentPackage.Path)));
+            }
+
+            var keyMappingElement = new XElement("keymapping");
+            doc.Root.Add(keyMappingElement);
+            for (int i = 0; i < keyMapping.Length; i++)
+            {
+                if (keyMapping[i].MouseButton == null)
+                {
+                    keyMappingElement.Add(new XAttribute(((InputType)i).ToString(), keyMapping[i].Key));
+                }
+                else
+                {
+                    keyMappingElement.Add(new XAttribute(((InputType)i).ToString(), keyMapping[i].MouseButton));
+                }
+
+
+            }
+
+            var gameplay = new XElement("gameplay");
+
+            var jobPreferences = new XElement("jobpreferences");
+            foreach (string jobName in JobNamePreferences)
+            {
+                jobPreferences.Add(new XElement("job", new XAttribute("name", jobName)));
+            }
+
+            gameplay.Add(jobPreferences);
+            doc.Root.Add(gameplay);
+
+            doc.Save(filePath);
+        }
+
+        private bool ChangeSoundVolume(GUIScrollBar scrollBar, float barScroll)
+        {
+            UnsavedSettings = true;
+            SoundVolume = barScroll;
+
+            return true;
+        }
+
+        private bool ChangeMusicVolume(GUIScrollBar scrollBar, float barScroll)
+        {
+            UnsavedSettings = true;
+            MusicVolume = barScroll;
+
+            return true;
+        }
+
+        public void ResetSettingsFrame()
+        {
+            settingsFrame = null;
+        }
+
+        private void CreateSettingsFrame()
+        {
+            settingsFrame = new GUIFrame(new Rectangle(0, 0, 500, 500), null, Alignment.Center, "");
+
+            new GUITextBlock(new Rectangle(0, -30, 0, 30), "Settings", "", Alignment.TopCenter, Alignment.TopCenter, settingsFrame, false, GUI.LargeFont);
+
+            int x = 0, y = 10;
+
+            new GUITextBlock(new Rectangle(0, y, 20, 20), "Resolution", "", Alignment.TopLeft, Alignment.TopLeft, settingsFrame);
+            var resolutionDD = new GUIDropDown(new Rectangle(0, y + 20, 180, 20), "", "", settingsFrame);
+            resolutionDD.OnSelected = SelectResolution;
+
+            var supportedModes = new List<DisplayMode>();
+            foreach (DisplayMode mode in GraphicsAdapter.DefaultAdapter.SupportedDisplayModes)
+            {
+                if (supportedModes.FirstOrDefault(m => m.Width == mode.Width && m.Height == mode.Height) != null) continue;
+
+                resolutionDD.AddItem(mode.Width + "x" + mode.Height, mode);
+                supportedModes.Add(mode);
+
+                if (GraphicsWidth == mode.Width && GraphicsHeight == mode.Height) resolutionDD.SelectItem(mode);
+            }
+
+            if (resolutionDD.SelectedItemData == null)
+            {
+                resolutionDD.SelectItem(GraphicsAdapter.DefaultAdapter.SupportedDisplayModes.Last());
+            }
+
+            y += 50;
+
+            //var fullScreenTick = new GUITickBox(new Rectangle(x, y, 20, 20), "Fullscreen", Alignment.TopLeft, settingsFrame);
+            //fullScreenTick.OnSelected = ToggleFullScreen;
+            //fullScreenTick.Selected = FullScreenEnabled;
+
+            new GUITextBlock(new Rectangle(x, y, 20, 20), "Display mode", "", Alignment.TopLeft, Alignment.TopLeft, settingsFrame);
+            var displayModeDD = new GUIDropDown(new Rectangle(x, y + 20, 180, 20), "", "", settingsFrame);
+            displayModeDD.AddItem("Fullscreen", WindowMode.Fullscreen);
+            displayModeDD.AddItem("Windowed", WindowMode.Windowed);
+            displayModeDD.AddItem("Borderless windowed", WindowMode.BorderlessWindowed);
+
+            displayModeDD.SelectItem(GameMain.Config.WindowMode);
+
+            displayModeDD.OnSelected = (guiComponent, obj) => { GameMain.Config.WindowMode = (WindowMode)guiComponent.UserData; return true; };
+
+            y += 70;
+
+            GUITickBox vsyncTickBox = new GUITickBox(new Rectangle(0, y, 20, 20), "Enable vertical sync", Alignment.CenterY | Alignment.Left, settingsFrame);
+            vsyncTickBox.OnSelected = (GUITickBox box) =>
+            {
+                VSyncEnabled = !VSyncEnabled;
+                GameMain.GraphicsDeviceManager.SynchronizeWithVerticalRetrace = VSyncEnabled;
+                GameMain.GraphicsDeviceManager.ApplyChanges();
+                UnsavedSettings = true;
+
+                return true;
+            };
+            vsyncTickBox.Selected = VSyncEnabled;
+
+            y += 70;
+
+            new GUITextBlock(new Rectangle(0, y, 100, 20), "Sound volume:", "", settingsFrame);
+            GUIScrollBar soundScrollBar = new GUIScrollBar(new Rectangle(0, y + 20, 150, 20), "", 0.1f, settingsFrame);
+            soundScrollBar.BarScroll = SoundVolume;
+            soundScrollBar.OnMoved = ChangeSoundVolume;
+            soundScrollBar.Step = 0.05f;
+
+            new GUITextBlock(new Rectangle(0, y + 40, 100, 20), "Music volume:", "", settingsFrame);
+            GUIScrollBar musicScrollBar = new GUIScrollBar(new Rectangle(0, y + 60, 150, 20), "", 0.1f, settingsFrame);
+            musicScrollBar.BarScroll = MusicVolume;
+            musicScrollBar.OnMoved = ChangeMusicVolume;
+            musicScrollBar.Step = 0.05f;
+
+            x = 200;
+            y = 10;
+
+            new GUITextBlock(new Rectangle(x, y, 20, 20), "Content package", "", Alignment.TopLeft, Alignment.TopLeft, settingsFrame);
+            var contentPackageDD = new GUIDropDown(new Rectangle(x, y + 20, 200, 20), "", "", settingsFrame);
+
+            foreach (ContentPackage contentPackage in ContentPackage.list)
+            {
+                contentPackageDD.AddItem(contentPackage.Name, contentPackage);
+
+                if (SelectedContentPackage == contentPackage) contentPackageDD.SelectItem(contentPackage);
+            }
+
+            y += 50;
+            new GUITextBlock(new Rectangle(x, y, 100, 20), "Controls:", "", settingsFrame);
+            y += 30;
+            var inputNames = Enum.GetNames(typeof(InputType));
+            for (int i = 0; i < inputNames.Length; i++)
+            {
+                new GUITextBlock(new Rectangle(x, y, 100, 18), inputNames[i] + ": ", "", Alignment.TopLeft, Alignment.CenterLeft, settingsFrame);
+                var keyBox = new GUITextBox(new Rectangle(x + 100, y, 120, 18), null, null, Alignment.TopLeft, Alignment.CenterLeft, "", settingsFrame);
+
+                keyBox.Text = keyMapping[i].ToString();
+                keyBox.UserData = i;
+                keyBox.OnSelected += KeyBoxSelected;
+                keyBox.SelectedColor = Color.Gold * 0.3f;
+
+                y += 20;
+            }
+
+            applyButton = new GUIButton(new Rectangle(0, 0, 100, 20), "Apply", Alignment.BottomRight, "", settingsFrame);
+            applyButton.OnClicked = ApplyClicked;
+        }
+
+        private void KeyBoxSelected(GUITextBox textBox, Keys key)
+        {
+            textBox.Text = "";
+            CoroutineManager.StartCoroutine(WaitForKeyPress(textBox));
+        }
+
+        private bool MarkUnappliedChanges(GUIButton button, object obj)
+        {
+            UnsavedSettings = true;
+
+            return true;
+        }
+
+        private bool SelectResolution(GUIComponent selected, object userData)
+        {
+            DisplayMode mode = selected.UserData as DisplayMode;
+            if (mode == null) return false;
+
+            if (GraphicsWidth == mode.Width && GraphicsHeight == mode.Height) return false;
+
+            GraphicsWidth = mode.Width;
+            GraphicsHeight = mode.Height;
+
+
+            //GameMain.Graphics.PreferredBackBufferWidth = GraphicsWidth;
+            //GameMain.Graphics.PreferredBackBufferHeight = GraphicsHeight;
+            //GameMain.Graphics.ApplyChanges();
+
+            //CoroutineManager.StartCoroutine(GameMain.Instance.Load());
+
+            UnsavedSettings = true;
+
+            return true;
+        }
+
+
+
+        private IEnumerable<object> WaitForKeyPress(GUITextBox keyBox)
+        {
+            yield return CoroutineStatus.Running;
+
+            while (keyBox.Selected && PlayerInput.GetKeyboardState.GetPressedKeys().Length == 0
+                && !PlayerInput.LeftButtonClicked() && !PlayerInput.RightButtonClicked())
+            {
+                if (Screen.Selected != GameMain.MainMenuScreen && !GUI.SettingsMenuOpen) yield return CoroutineStatus.Success;
+
+                yield return CoroutineStatus.Running;
+            }
+
+            UnsavedSettings = true;
+
+            int keyIndex = (int)keyBox.UserData;
+
+            if (PlayerInput.LeftButtonClicked())
+            {
+                keyMapping[keyIndex] = new KeyOrMouse(0);
+                keyBox.Text = "Mouse1";
+            }
+            else if (PlayerInput.LeftButtonClicked())
+            {
+                keyMapping[keyIndex] = new KeyOrMouse(1);
+                keyBox.Text = "Mouse2";
+            }
+            else if (PlayerInput.GetKeyboardState.GetPressedKeys().Length > 0)
+            {
+                Keys key = PlayerInput.GetKeyboardState.GetPressedKeys()[0];
+                keyMapping[keyIndex] = new KeyOrMouse(key);
+                keyBox.Text = key.ToString("G");
+            }
+            else
+            {
+                yield return CoroutineStatus.Success;
+            }
+
+            keyBox.Deselect();
+
+            yield return CoroutineStatus.Success;
+        }
+
+        private IEnumerable<object> ApplyUnsavedChanges()
+        {
+            yield return new WaitForSeconds(10.0f);
+
+            Save("config.xml");
+        }
+
+        private bool ApplyClicked(GUIButton button, object userData)
+        {
+            Save("config.xml");
+
+            settingsFrame.Flash(Color.Green);
+
+            if (GameMain.GraphicsWidth != GameMain.Config.GraphicsWidth || GameMain.GraphicsHeight != GameMain.Config.GraphicsHeight)
+            {
+                new GUIMessageBox("Restart required", "You need to restart the game for the resolution changes to take effect.");
+            }
+
+            return true;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/CharacterInventory.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System.Collections.Generic;
+using Barotrauma.Items.Components;
+
+namespace Barotrauma
+{
+    partial class CharacterInventory : Inventory
+    {
+        private static Texture2D icons;
+
+        public Vector2[] SlotPositions;
+
+        private GUIButton[] useOnSelfButton;
+
+        partial void InitProjSpecific()
+        {
+            useOnSelfButton = new GUIButton[2];
+
+            if (icons == null) icons = TextureLoader.FromFile("Content/UI/inventoryIcons.png");
+
+            SlotPositions = new Vector2[limbSlots.Length];
+
+            int rectWidth = 40, rectHeight = 40;
+            int spacing = 10;
+            for (int i = 0; i < SlotPositions.Length; i++)
+            {
+                switch (i)
+                {
+                    //head, torso, legs
+                    case 0:
+                    case 1:
+                    case 2:
+                        SlotPositions[i] = new Vector2(
+                            spacing,
+                            GameMain.GraphicsHeight - (spacing + rectHeight) * (3 - i));
+                        break;
+                    //lefthand, righthand
+                    case 3:
+                    case 4:
+                        SlotPositions[i] = new Vector2(
+                            spacing * 2 + rectWidth + (spacing + rectWidth) * (i - 2),
+                            GameMain.GraphicsHeight - (spacing + rectHeight) * 3);
+
+                        useOnSelfButton[i - 3] = new GUIButton(
+                            new Rectangle((int)SlotPositions[i].X, (int)(SlotPositions[i].Y - spacing - rectHeight),
+                                rectWidth, rectHeight), "Use", "")
+                        {
+                            UserData = i,
+                            OnClicked = UseItemOnSelf
+                        };
+
+
+                        break;
+                    case 5:
+                        SlotPositions[i] = new Vector2(
+                            spacing * 2 + rectWidth + (spacing + rectWidth) * (i - 5),
+                            GameMain.GraphicsHeight - (spacing + rectHeight) * 3);
+
+                        break;
+                    default:
+                        SlotPositions[i] = new Vector2(
+                            spacing * 2 + rectWidth + (spacing + rectWidth) * ((i - 6) % 5),
+                            GameMain.GraphicsHeight - (spacing + rectHeight) * ((i > 10) ? 2 : 1));
+                        break;
+                }
+            }
+        }
+
+        private bool UseItemOnSelf(GUIButton button, object obj)
+        {
+            if (!(obj is int)) return false;
+
+            int slotIndex = (int)obj;
+
+            return UseItemOnSelf(slotIndex);
+        }
+
+        protected override void CreateSlots()
+        {
+            if (slots == null) slots = new InventorySlot[capacity];
+
+            int rectWidth = 40, rectHeight = 40;
+
+            Rectangle slotRect = new Rectangle(0, 0, rectWidth, rectHeight);
+            for (int i = 0; i < capacity; i++)
+            {
+                if (slots[i] == null) slots[i] = new InventorySlot(slotRect);
+
+                slots[i].Disabled = false;
+
+                slotRect.X = (int)(SlotPositions[i].X + DrawOffset.X);
+                slotRect.Y = (int)(SlotPositions[i].Y + DrawOffset.Y);
+
+                slots[i].Rect = slotRect;
+
+                slots[i].Color = limbSlots[i] == InvSlotType.Any ? Color.White * 0.2f : Color.White * 0.4f;
+            }
+
+            MergeSlots();
+        }
+
+        public void DrawOwn(SpriteBatch spriteBatch)
+        {
+            if (slots == null) CreateSlots();
+
+            Rectangle slotRect = new Rectangle(0, 0, 40, 40);
+
+            for (int i = 0; i < capacity; i++)
+            {
+                slotRect.X = (int)(SlotPositions[i].X + DrawOffset.X);
+                slotRect.Y = (int)(SlotPositions[i].Y + DrawOffset.Y);
+
+                if (i == 1) //head
+                {
+                    spriteBatch.Draw(icons, new Vector2(slotRect.Center.X, slotRect.Center.Y),
+                        new Rectangle(0, 0, 56, 128), Color.White * 0.7f, 0.0f,
+                        new Vector2(28.0f, 64.0f), Vector2.One,
+                        SpriteEffects.None, 0.1f);
+                }
+                else if (i == 3 || i == 4)
+                {
+                    spriteBatch.Draw(icons, new Vector2(slotRect.Center.X, slotRect.Center.Y),
+                        new Rectangle(92, 41 * (4 - i), 36, 40), Color.White * 0.7f, 0.0f,
+                        new Vector2(18.0f, 20.0f), Vector2.One,
+                        SpriteEffects.None, 0.1f);
+                }
+                else if (i == 5)
+                {
+                    spriteBatch.Draw(icons, new Vector2(slotRect.Center.X, slotRect.Center.Y),
+                        new Rectangle(57, 0, 31, 32), Color.White * 0.7f, 0.0f,
+                        new Vector2(15.0f, 16.0f), Vector2.One,
+                        SpriteEffects.None, 0.1f);
+                }
+            }
+
+            base.Draw(spriteBatch);
+
+            if (character == Character.Controlled)
+            {
+                for (int i = 0; i < capacity; i++)
+                {
+                    if (selectedSlot != i &&
+                        Items[i] != null && Items[i].CanUseOnSelf && character.HasSelectedItem(Items[i]))
+                    {
+                        useOnSelfButton[i - 3].Draw(spriteBatch);
+                    }
+                }
+            }
+
+            if (selectedSlot > -1)
+            {
+                DrawSubInventory(spriteBatch, selectedSlot);
+
+                if (selectedSlot > -1 &&
+                    !slots[selectedSlot].IsHighlighted &&
+                    (draggingItem == null || draggingItem.Container != Items[selectedSlot]))
+                {
+                    selectedSlot = -1;
+                }
+            }
+        }
+    }
+}

Barotrauma/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);
+            }
+
+        }
+    }
+}

Barotrauma/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;
+        }
+    }
+}

Barotrauma/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;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/Components/ItemLabel.cs

@@ -0,0 +1,89 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class ItemLabel : ItemComponent, IDrawableComponent
+    {
+        private GUITextBlock textBlock;
+
+        private Color textColor;
+
+        [HasDefaultValue("", true), Editable(100)]
+        public string Text
+        {
+            get { return textBlock.Text.Replace("\n", ""); }
+            set
+            {
+                if (value == TextBlock.Text || item.Rect.Width < 5) return;
+
+                if (textBlock.Rect.Width != item.Rect.Width || textBlock.Rect.Height != item.Rect.Height)
+                {
+                    textBlock = null;
+                }
+
+                TextBlock.Text = value;
+            }
+        }
+
+        [Editable, HasDefaultValue("0.0,0.0,0.0,1.0", true)]
+        public string TextColor
+        {
+            get { return ToolBox.Vector4ToString(textColor.ToVector4()); }
+            set
+            {
+                textColor = new Color(ToolBox.ParseToVector4(value));
+                if (textBlock != null) textBlock.TextColor = textColor;
+            }
+        }
+
+        [Editable, HasDefaultValue(1.0f, true)]
+        public float TextScale
+        {
+            get { return textBlock == null ? 1.0f : textBlock.TextScale; }
+            set
+            {
+                if (textBlock != null) textBlock.TextScale = MathHelper.Clamp(value, 0.1f, 10.0f);
+            }
+        }
+
+        private GUITextBlock TextBlock
+        {
+            get
+            {
+                if (textBlock == null)
+                {
+                    textBlock = new GUITextBlock(new Rectangle(item.Rect.X, -item.Rect.Y, item.Rect.Width, item.Rect.Height), "",
+                        Color.Transparent, textColor,
+                        Alignment.TopLeft, Alignment.Center,
+                        null, null, true);
+                    textBlock.Font = GUI.SmallFont;
+                    textBlock.Padding = new Vector4(5.0f, 5.0f, 5.0f, 5.0f);
+                    textBlock.TextDepth = item.Sprite.Depth - 0.0001f;
+                    textBlock.TextScale = TextScale;
+                }
+                return textBlock;
+            }
+        }
+
+        public override void Move(Vector2 amount)
+        {
+            textBlock.Rect = new Rectangle(item.Rect.X, -item.Rect.Y, item.Rect.Width, item.Rect.Height);
+        }
+
+        public ItemLabel(Item item, XElement element)
+            : base(item, element)
+        {
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            var drawPos = new Vector2(
+                item.DrawPosition.X - item.Rect.Width / 2.0f,
+                -(item.DrawPosition.Y + item.Rect.Height / 2.0f));
+
+            textBlock.Draw(spriteBatch, drawPos - textBlock.Rect.Location.ToVector2());
+        }
+    }
+}

Barotrauma/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();
+        }
+    }
+}

Barotrauma/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());
+        }
+    }
+}

Barotrauma/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);
+        }
+    }
+}

Barotrauma/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;
+
+        partial 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]);
+            }
+        }
+    }
+}

Barotrauma/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);
+            }
+        }
+    }
+}

Barotrauma/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;
+
+        partial 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();
+        }
+    }
+}

Barotrauma/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);
+        }
+    }
+}

Barotrauma/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;
+        
+        partial 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);
+        }
+    }
+}

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

@@ -0,0 +1,268 @@
+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; }
+        }
+
+        partial 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;
+                }
+            }
+        }
+
+        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;
+                }
+            }
+        }
+    }
+}

Barotrauma/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
+    {
+        partial 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;
+        }
+    }
+}

Barotrauma/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);
+        }
+    }
+}

Barotrauma/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;
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/Components/Signal/Connection.cs

@@ -0,0 +1,284 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Connection
+    {
+        private static Texture2D panelTexture;
+        private static Sprite connector;
+        private static Sprite wireVertical;
+
+        public static void DrawConnections(SpriteBatch spriteBatch, ConnectionPanel panel, Character character)
+        {
+
+            int width = 400, height = 200;
+            int x = GameMain.GraphicsWidth / 2 - width / 2, y = GameMain.GraphicsHeight - height;
+
+            Rectangle panelRect = new Rectangle(x, y, width, height);
+
+            spriteBatch.Draw(panelTexture, panelRect, new Rectangle(0, 512 - height, width, height), Color.White);
+
+            //GUI.DrawRectangle(spriteBatch, panelRect, Color.Black, true);
+
+            bool mouseInRect = panelRect.Contains(PlayerInput.MousePosition);
+
+            int totalWireCount = 0;
+            foreach (Connection c in panel.Connections)
+            {
+                totalWireCount += c.Wires.Count(w => w != null);
+            }
+
+            Wire equippedWire = null;
+
+            //if the Character using the panel has a wire item equipped
+            //and the wire hasn't been connected yet, draw it on the panel
+            for (int i = 0; i < character.SelectedItems.Length; i++)
+            {
+                Item selectedItem = character.SelectedItems[i];
+
+                if (selectedItem == null) continue;
+
+                Wire wireComponent = selectedItem.GetComponent<Wire>();
+                if (wireComponent != null) equippedWire = wireComponent;
+            }
+
+            Vector2 rightPos = new Vector2(x + width - 130, y + 50);
+            Vector2 leftPos = new Vector2(x + 130, y + 50);
+
+            Vector2 rightWirePos = new Vector2(x + width - 5, y + 30);
+
+            Vector2 leftWirePos = new Vector2(x + 5, y + 30);
+
+            int wireInterval = (height - 20) / Math.Max(totalWireCount, 1);
+
+            foreach (Connection c in panel.Connections)
+            {
+                //if dragging a wire, let the Inventory know so that the wire can be
+                //dropped or dragged from the panel to the players inventory
+                if (draggingConnected != null)
+                {
+                    int linkIndex = c.FindWireIndex(draggingConnected.Item);
+                    if (linkIndex > -1)
+                    {
+                        Inventory.draggingItem = c.Wires[linkIndex].Item;
+                    }
+                }
+
+                //outputs are drawn at the right side of the panel, inputs at the left
+                if (c.IsOutput)
+                {
+                    c.Draw(spriteBatch, panel.Item, rightPos,
+                        new Vector2(rightPos.X - GUI.SmallFont.MeasureString(c.Name).X - 20, rightPos.Y + 3),
+                        rightWirePos,
+                        mouseInRect, equippedWire,
+                        wireInterval);
+
+                    rightPos.Y += 30;
+                    rightWirePos.Y += c.Wires.Count(w => w != null) * wireInterval;
+                }
+                else
+                {
+                    c.Draw(spriteBatch, panel.Item, leftPos,
+                        new Vector2(leftPos.X + 20, leftPos.Y - 12),
+                        leftWirePos,
+                        mouseInRect, equippedWire,
+                        wireInterval);
+
+                    leftPos.Y += 30;
+                    leftWirePos.Y += c.Wires.Count(w => w != null) * wireInterval;
+                    //leftWireX -= wireInterval;
+                }
+            }
+
+            if (draggingConnected != null)
+            {
+                DrawWire(spriteBatch, draggingConnected, draggingConnected.Item, PlayerInput.MousePosition, new Vector2(x + width / 2, y + height), mouseInRect, null);
+
+                if (!PlayerInput.LeftButtonHeld())
+                {
+                    if (GameMain.Client != null)
+                    {
+                        panel.Item.CreateClientEvent<ConnectionPanel>(panel);
+                    }
+                    else if (GameMain.Server != null)
+                    {
+                        panel.Item.CreateServerEvent<ConnectionPanel>(panel);
+                    }
+
+                    draggingConnected = null;
+                }
+            }
+
+            //if the Character using the panel has a wire item equipped
+            //and the wire hasn't been connected yet, draw it on the panel
+            if (equippedWire != null)
+            {
+                if (panel.Connections.Find(c => c.Wires.Contains(equippedWire)) == null)
+                {
+                    DrawWire(spriteBatch, equippedWire, equippedWire.Item,
+                        new Vector2(x + width / 2, y + height - 100),
+                        new Vector2(x + width / 2, y + height), mouseInRect, null);
+
+                    if (draggingConnected == equippedWire) Inventory.draggingItem = equippedWire.Item;
+                }
+            }
+
+            //stop dragging a wire item if cursor is outside the panel
+            if (mouseInRect) Inventory.draggingItem = null;
+
+
+            spriteBatch.Draw(panelTexture, panelRect, new Rectangle(0, 0, width, height), Color.White);
+
+        }
+
+        private void Draw(SpriteBatch spriteBatch, Item item, Vector2 position, Vector2 labelPos, Vector2 wirePosition, bool mouseIn, Wire equippedWire, float wireInterval)
+        {
+            //spriteBatch.DrawString(GUI.SmallFont, Name, new Vector2(labelPos.X, labelPos.Y-10), Color.White);
+            GUI.DrawString(spriteBatch, labelPos, Name, IsPower ? Color.Red : Color.White, Color.Black, 0, GUI.SmallFont);
+
+            GUI.DrawRectangle(spriteBatch, new Rectangle((int)position.X - 10, (int)position.Y - 10, 20, 20), Color.White);
+            spriteBatch.Draw(panelTexture, position - new Vector2(16.0f, 16.0f), new Rectangle(64, 256, 32, 32), Color.White);
+
+            for (int i = 0; i < MaxLinked; i++)
+            {
+                if (Wires[i] == null || Wires[i].Hidden || draggingConnected == Wires[i]) continue;
+
+                Connection recipient = Wires[i].OtherConnection(this);
+
+                DrawWire(spriteBatch, Wires[i], (recipient == null) ? Wires[i].Item : recipient.item, position, wirePosition, mouseIn, equippedWire);
+
+                wirePosition.Y += wireInterval;
+            }
+
+            if (draggingConnected != null && Vector2.Distance(position, PlayerInput.MousePosition) < 13.0f)
+            {
+                spriteBatch.Draw(panelTexture, position - new Vector2(21.5f, 21.5f), new Rectangle(106, 250, 43, 43), Color.White);
+
+                if (!PlayerInput.LeftButtonHeld())
+                {
+                    //find an empty cell for the new connection
+                    int index = FindWireIndex(null);
+
+                    if (index > -1 && !Wires.Contains(draggingConnected))
+                    {
+                        bool alreadyConnected = draggingConnected.IsConnectedTo(item);
+
+                        draggingConnected.RemoveConnection(item);
+
+                        if (draggingConnected.Connect(this, !alreadyConnected, true)) Wires[index] = draggingConnected;
+                    }
+                }
+            }
+
+            int screwIndex = (position.Y % 60 < 30) ? 0 : 1;
+
+            if (Wires.Any(w => w != null && w != draggingConnected))
+            {
+                spriteBatch.Draw(panelTexture, position - new Vector2(16.0f, 16.0f), new Rectangle(screwIndex * 32, 256, 32, 32), Color.White);
+            }
+
+        }
+
+        private static void DrawWire(SpriteBatch spriteBatch, Wire wire, Item item, Vector2 end, Vector2 start, bool mouseIn, Wire equippedWire)
+        {
+            if (draggingConnected == wire)
+            {
+                if (!mouseIn) return;
+                end = PlayerInput.MousePosition;
+                start.X = (start.X + end.X) / 2.0f;
+            }
+
+            int textX = (int)start.X;
+            if (start.X < end.X)
+                textX -= 10;
+            else
+                textX += 10;
+
+            bool canDrag = equippedWire == null || equippedWire == wire;
+
+            float alpha = canDrag ? 1.0f : 0.5f;
+
+            bool mouseOn =
+                canDrag &&
+                ((PlayerInput.MousePosition.X > Math.Min(start.X, end.X) &&
+                PlayerInput.MousePosition.X < Math.Max(start.X, end.X) &&
+                MathUtils.LineToPointDistance(start, end, PlayerInput.MousePosition) < 6) ||
+                Vector2.Distance(end, PlayerInput.MousePosition) < 20.0f ||
+                new Rectangle((start.X < end.X) ? textX - 100 : textX, (int)start.Y - 5, 100, 14).Contains(PlayerInput.MousePosition));
+
+            string label = wire.Locked ? item.Name + "\n(Locked)" : item.Name;
+
+            GUI.DrawString(spriteBatch,
+                new Vector2(start.X < end.X ? textX - GUI.SmallFont.MeasureString(label).X : textX, start.Y - 5.0f),
+                label,
+                (mouseOn ? Color.Gold : Color.White) * (wire.Locked ? 0.6f : 1.0f), Color.Black * 0.8f,
+                3, GUI.SmallFont);
+
+            var wireEnd = end + Vector2.Normalize(start - end) * 30.0f;
+
+            float dist = Vector2.Distance(start, wireEnd);
+
+            if (mouseOn)
+            {
+                spriteBatch.Draw(wireVertical.Texture, new Rectangle(wireEnd.ToPoint(), new Point(18, (int)dist)), wireVertical.SourceRect,
+                    Color.Gold,
+                    MathUtils.VectorToAngle(end - start) + MathHelper.PiOver2,     //angle of line (calulated above)
+                    new Vector2(6, 0), // point in line about which to rotate
+                    SpriteEffects.None,
+                    0.0f);
+            }
+            spriteBatch.Draw(wireVertical.Texture, new Rectangle(wireEnd.ToPoint(), new Point(12, (int)dist)), wireVertical.SourceRect,
+                wire.Item.Color * alpha,
+                MathUtils.VectorToAngle(end - start) + MathHelper.PiOver2,     //angle of line (calulated above)
+                new Vector2(6, 0), // point in line about which to rotate
+                SpriteEffects.None,
+                0.0f);
+
+            connector.Draw(spriteBatch, end, Color.White, new Vector2(10.0f, 10.0f), MathUtils.VectorToAngle(end - start) + MathHelper.PiOver2);
+
+            if (draggingConnected == null && canDrag)
+            {
+                if (mouseOn)
+                {
+                    ConnectionPanel.HighlightedWire = wire;
+
+                    if (!wire.Locked)
+                    {
+                        //start dragging the wire
+                        if (PlayerInput.LeftButtonHeld()) draggingConnected = wire;
+                    }
+                }
+            }
+        }
+
+        public void Save(XElement parentElement)
+        {
+            XElement newElement = new XElement(IsOutput ? "output" : "input", new XAttribute("name", Name));
+
+            Array.Sort(Wires, delegate (Wire wire1, Wire wire2)
+            {
+                if (wire1 == null) return 1;
+                if (wire2 == null) return -1;
+                return wire1.Item.ID.CompareTo(wire2.Item.ID);
+            });
+
+            for (int i = 0; i < MaxLinked; i++)
+            {
+                if (Wires[i] == null) continue;
+
+                //Connection recipient = wires[i].OtherConnection(this);
+
+                //int connectionIndex = recipient.item.Connections.FindIndex(x => x == recipient);
+                newElement.Add(new XElement("link",
+                    new XAttribute("w", Wires[i].Item.ID.ToString())));
+            }
+
+            parentElement.Add(newElement);
+        }
+    }
+}

Barotrauma/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;
+        }
+    }
+}

Barotrauma/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;
+        }
+    }
+}

Barotrauma/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;
+            }
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/Components/Turret.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using FarseerPhysics;
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Turret : Powered, IDrawableComponent, IServerSerializable
+    {
+        public void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            Vector2 drawPos = new Vector2(item.Rect.X, item.Rect.Y);
+            if (item.Submarine != null) drawPos += item.Submarine.DrawPosition;
+            drawPos.Y = -drawPos.Y;
+
+            if (barrelSprite != null)
+            {
+                barrelSprite.Draw(spriteBatch,
+                     drawPos + barrelPos, Color.White,
+                    rotation + MathHelper.PiOver2, 1.0f,
+                    SpriteEffects.None, item.Sprite.Depth + 0.01f);
+            }
+
+            if (!editing) return;
+
+            GUI.DrawLine(spriteBatch,
+                drawPos + barrelPos,
+                drawPos + barrelPos + new Vector2((float)Math.Cos(minRotation), (float)Math.Sin(minRotation)) * 60.0f,
+                Color.Green);
+
+            GUI.DrawLine(spriteBatch,
+                drawPos + barrelPos,
+                drawPos + barrelPos + new Vector2((float)Math.Cos(maxRotation), (float)Math.Sin(maxRotation)) * 60.0f,
+                Color.Green);
+
+            GUI.DrawLine(spriteBatch,
+                drawPos + barrelPos,
+                drawPos + barrelPos + new Vector2((float)Math.Cos((maxRotation + minRotation) / 2), (float)Math.Sin((maxRotation + minRotation) / 2)) * 60.0f,
+                Color.LightGreen);
+
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            UInt16 projectileID = msg.ReadUInt16();
+            Item projectile = Entity.FindEntityByID(projectileID) as Item;
+
+            if (projectile == null)
+            {
+                DebugConsole.ThrowError("Failed to launch a projectile - item with the ID \"" + projectileID + " not found");
+                return;
+            }
+
+            Launch(projectile);
+            PlaySound(ActionType.OnUse, item.WorldPosition);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/DockingPort.cs

@@ -0,0 +1,75 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Joints;
+using FarseerPhysics.Factories;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+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.Items.Components
+{
+    partial class DockingPort : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        public void Draw(SpriteBatch spriteBatch, bool editing)
+        {
+            if (dockingState == 0.0f) return;
+
+            Vector2 drawPos = item.DrawPosition;
+            drawPos.Y = -drawPos.Y;
+
+            var rect = overlaySprite.SourceRect;
+
+            if (IsHorizontal)
+            {
+                drawPos.Y -= rect.Height / 2;
+
+                if (dockingDir == 1)
+                {
+                    spriteBatch.Draw(overlaySprite.Texture,
+                        drawPos,
+                        new Rectangle(
+                            rect.Center.X + (int)(rect.Width / 2 * (1.0f - dockingState)), rect.Y,
+                            (int)(rect.Width / 2 * dockingState), rect.Height), Color.White);
+
+                }
+                else
+                {
+                    spriteBatch.Draw(overlaySprite.Texture,
+                        drawPos - Vector2.UnitX * (rect.Width / 2 * dockingState),
+                        new Rectangle(
+                            rect.X, rect.Y,
+                            (int)(rect.Width / 2 * dockingState), rect.Height), Color.White);
+                }
+            }
+            else
+            {
+                drawPos.X -= rect.Width / 2;
+
+                if (dockingDir == 1)
+                {
+                    spriteBatch.Draw(overlaySprite.Texture,
+                        drawPos - Vector2.UnitY * (rect.Height / 2 * dockingState),
+                        new Rectangle(
+                            rect.X, rect.Y,
+                            rect.Width, (int)(rect.Height / 2 * dockingState)), Color.White);
+                }
+                else
+                {
+                    spriteBatch.Draw(overlaySprite.Texture,
+                        drawPos,
+                        new Rectangle(
+                            rect.X, rect.Y + rect.Height / 2 + (int)(rect.Height / 2 * (1.0f - dockingState)),
+                            rect.Width, (int)(rect.Height / 2 * dockingState)), Color.White);
+                }
+            }
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/FixRequirement.cs

@@ -0,0 +1,191 @@
+using Barotrauma.Networking;
+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
+{
+    partial class FixRequirement
+    {
+        private static GUIFrame frame;
+
+        public bool CanBeFixed(Character character, GUIComponent reqFrame = null)
+        {
+            foreach (string itemName in requiredItems)
+            {
+                Item item = character.Inventory.FindItem(itemName);
+                bool itemFound = (item != null);
+
+                if (reqFrame != null)
+                {
+                    GUIComponent component = reqFrame.children.Find(c => c.UserData as string == itemName);
+                    GUITextBlock text = component as GUITextBlock;
+                    if (text != null) text.TextColor = itemFound ? Color.LightGreen : Color.Red;
+                }
+            }
+
+            foreach (Skill skill in requiredSkills)
+            {
+                float characterSkill = character.GetSkillLevel(skill.Name);
+                bool sufficientSkill = characterSkill >= skill.Level;
+
+                if (reqFrame != null)
+                {
+                    GUIComponent component = reqFrame.children.Find(c => c.UserData as Skill == skill);
+                    GUITextBlock text = component as GUITextBlock;
+                    if (text != null) text.TextColor = sufficientSkill ? Color.LightGreen : Color.Red;
+                }
+            }
+
+            return CanBeFixed(character);
+        }
+
+        private static void CreateGUIFrame(Item item)
+        {
+            int width = 400, height = 500;
+            int y = 0;
+
+            frame = new GUIFrame(new Rectangle(0, 0, width, height), null, Alignment.Center, "");
+            frame.Padding = new Vector4(20.0f, 20.0f, 20.0f, 20.0f);
+            frame.UserData = item;
+
+            new GUITextBlock(new Rectangle(0, 0, 200, 20), "Attempting to fix " + item.Name, "", frame);
+
+            y = y + 40;
+            foreach (FixRequirement requirement in item.FixRequirements)
+            {
+                GUIFrame reqFrame = new GUIFrame(
+                    new Rectangle(0, y, 0, 20 + Math.Max(requirement.requiredItems.Count, requirement.requiredSkills.Count) * 15),
+                    Color.Transparent, null, frame);
+                reqFrame.UserData = requirement;
+
+
+                var fixButton = new GUIButton(new Rectangle(0, 0, 50, 20), "Fix", "", reqFrame);
+                fixButton.OnClicked = FixButtonPressed;
+                fixButton.UserData = requirement;
+
+                var tickBox = new GUITickBox(new Rectangle(70, 0, 20, 20), requirement.name, Alignment.Left, reqFrame);
+                tickBox.Enabled = false;
+
+                int y2 = 20;
+                foreach (string itemName in requirement.requiredItems)
+                {
+                    var itemBlock = new GUITextBlock(new Rectangle(30, y2, 200, 15), itemName, "", reqFrame);
+                    itemBlock.Font = GUI.SmallFont;
+                    itemBlock.UserData = itemName;
+
+                    y2 += 15;
+                }
+
+                y2 = 20;
+                foreach (Skill skill in requirement.requiredSkills)
+                {
+                    var skillBlock = new GUITextBlock(new Rectangle(0, y2, 200, 15), skill.Name + " - " + skill.Level, "", Alignment.Right, Alignment.TopLeft, reqFrame);
+                    skillBlock.Font = GUI.SmallFont;
+                    skillBlock.UserData = skill;
+
+
+                    y2 += 15;
+                }
+
+                y += reqFrame.Rect.Height;
+            }
+        }
+
+        private static bool FixButtonPressed(GUIButton button, object obj)
+        {
+            FixRequirement requirement = obj as FixRequirement;
+            if (requirement == null) return true;
+
+            Item item = frame.UserData as Item;
+            if (item == null) return true;
+
+            if (!requirement.CanBeFixed(Character.Controlled, button.Parent)) return true;
+
+            if (GameMain.Client != null)
+            {
+                GameMain.Client.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.Repair, item.FixRequirements.IndexOf(requirement) });
+            }
+            else if (GameMain.Server != null)
+            {
+                GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.Status });
+                requirement.Fixed = true;
+            }
+            else
+            {
+                requirement.Fixed = true;
+            }
+
+            return true;
+        }
+
+        private static void UpdateGUIFrame(Item item, Character character)
+        {
+            if (frame == null) return;
+
+            bool unfixedFound = false;
+            foreach (GUIComponent child in frame.children)
+            {
+                FixRequirement requirement = child.UserData as FixRequirement;
+                if (requirement == null) continue;
+
+                if (requirement.Fixed)
+                {
+                    child.Color = Color.LightGreen * 0.3f;
+                    child.GetChild<GUITickBox>().Selected = true;
+                }
+                else
+                {
+                    bool canBeFixed = requirement.CanBeFixed(character, child);
+                    unfixedFound = true;
+                    //child.GetChild<GUITickBox>().Selected = canBeFixed;
+                    GUITickBox tickBox = child.GetChild<GUITickBox>();
+                    if (tickBox.Selected)
+                    {
+                        tickBox.Selected = canBeFixed;
+                        requirement.Fixed = canBeFixed;
+
+                    }
+                    child.Color = Color.Red * 0.2f;
+                    //tickBox.State = GUIComponent.ComponentState.None;
+                }
+            }
+            if (!unfixedFound)
+            {
+                item.Condition = 100.0f;
+                frame = null;
+            }
+        }
+
+        public static void DrawHud(SpriteBatch spriteBatch, Item item, Character character)
+        {
+            if (frame == null) return;
+
+            frame.Draw(spriteBatch);
+        }
+
+        public static void AddToGUIUpdateList()
+        {
+            if (frame == null) return;
+
+            frame.AddToGUIUpdateList();
+        }
+
+        public static void UpdateHud(Item item, Character character)
+        {
+            if (frame == null || frame.UserData != item)
+            {
+                CreateGUIFrame(item);
+            }
+            UpdateGUIFrame(item, character);
+
+            if (frame == null) return;
+
+            frame.Update((float)Timing.Step);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/Inventory.cs

@@ -0,0 +1,203 @@
+using System.Linq;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Barotrauma.Networking;
+using System;
+using System.Collections.Generic;
+using Barotrauma.Items.Components;
+
+namespace Barotrauma
+{
+    partial class InventorySlot
+    {
+        public GUIComponent.ComponentState State;
+
+        public bool IsHighlighted
+        {
+            get
+            {
+                return State == GUIComponent.ComponentState.Hover;
+            }
+        }
+
+        public Color Color;
+
+        public Color BorderHighlightColor;
+        private CoroutineHandle BorderHighlightCoroutine;
+
+        public void ShowBorderHighlight(Color color, float fadeInDuration, float fadeOutDuration)
+        {
+            if (BorderHighlightCoroutine != null)
+            {
+                BorderHighlightCoroutine = null;
+            }
+
+            BorderHighlightCoroutine = CoroutineManager.StartCoroutine(UpdateBorderHighlight(color, fadeInDuration, fadeOutDuration));
+        }
+
+        private IEnumerable<object> UpdateBorderHighlight(Color color, float fadeInDuration, float fadeOutDuration)
+        {
+            float t = 0.0f;
+            while (t < fadeInDuration + fadeOutDuration)
+            {
+                BorderHighlightColor = (t < fadeInDuration) ?
+                    Color.Lerp(Color.Transparent, color, t / fadeInDuration) :
+                    Color.Lerp(color, Color.Transparent, (t - fadeInDuration) / fadeOutDuration);
+
+                t += CoroutineManager.DeltaTime;
+
+                yield return CoroutineStatus.Running;
+            }
+
+            yield return CoroutineStatus.Success;
+        }
+    }
+
+    partial class Inventory
+    {
+        public virtual void Draw(SpriteBatch spriteBatch, bool subInventory = false)
+        {
+            if (slots == null || isSubInventory != subInventory) return;
+
+            for (int i = 0; i < capacity; i++)
+            {
+                if (slots[i].Disabled) continue;
+
+                //don't draw the item if it's being dragged out of the slot
+                bool drawItem = draggingItem == null || draggingItem != Items[i] || slots[i].IsHighlighted;
+
+                DrawSlot(spriteBatch, slots[i], Items[i], drawItem);
+            }
+
+            if (draggingItem != null &&
+                (draggingSlot == null || (!draggingSlot.Rect.Contains(PlayerInput.MousePosition) && draggingItem.ParentInventory == this)))
+            {
+                Rectangle dragRect = new Rectangle(
+                    (int)PlayerInput.MousePosition.X - 10,
+                    (int)PlayerInput.MousePosition.Y - 10,
+                    40, 40);
+
+                DrawSlot(spriteBatch, new InventorySlot(dragRect), draggingItem);
+            }
+
+            for (int i = 0; i < capacity; i++)
+            {
+                if (slots[i].IsHighlighted && !slots[i].Disabled && Items[i] != null)
+                {
+                    string toolTip = "";
+                    if (GameMain.DebugDraw)
+                    {
+                        toolTip = Items[i].ToString();
+                    }
+                    else
+                    {
+                        toolTip = string.IsNullOrEmpty(Items[i].Description) ?
+                            Items[i].Name :
+                            Items[i].Name + '\n' + Items[i].Description;
+                    }
+
+                    DrawToolTip(spriteBatch, toolTip, slots[i].Rect);
+                    break;
+                }
+            }
+        }
+
+        protected void DrawToolTip(SpriteBatch spriteBatch, string toolTip, Rectangle highlightedSlot)
+        {
+            int maxWidth = 300;
+
+            toolTip = ToolBox.WrapText(toolTip, maxWidth, GUI.Font);
+
+            Vector2 textSize = GUI.Font.MeasureString(toolTip);
+            Vector2 rectSize = textSize * 1.2f;
+
+            Vector2 pos = new Vector2(highlightedSlot.Right, highlightedSlot.Y - rectSize.Y);
+            pos.X = (int)(pos.X + 3);
+            pos.Y = (int)pos.Y;
+
+            GUI.DrawRectangle(spriteBatch, pos, rectSize, Color.Black * 0.8f, true);
+            GUI.Font.DrawString(spriteBatch, toolTip,
+                new Vector2((int)(pos.X + rectSize.X * 0.5f), (int)(pos.Y + rectSize.Y * 0.5f)),
+                Color.White, 0.0f,
+                new Vector2((int)(textSize.X * 0.5f), (int)(textSize.Y * 0.5f)),
+                1.0f, SpriteEffects.None, 0.0f);
+        }
+
+
+        public void DrawSubInventory(SpriteBatch spriteBatch, int slotIndex)
+        {
+            var item = Items[slotIndex];
+            if (item == null) return;
+
+            var container = item.GetComponent<ItemContainer>();
+            if (container == null) return;
+
+            if (container.Inventory.slots == null || !container.Inventory.isSubInventory) return;
+
+            int itemCapacity = container.Capacity;
+
+#if DEBUG
+            System.Diagnostics.Debug.Assert(slotIndex >= 0 && slotIndex < Items.Length);
+#else
+            if (slotIndex < 0 || slotIndex >= Items.Length) return;
+#endif
+
+            var slot = slots[slotIndex];
+            Rectangle containerRect = new Rectangle(slot.Rect.X - 5, slot.Rect.Y - (40 + 10) * itemCapacity - 5,
+                    slot.Rect.Width + 10, slot.Rect.Height + (40 + 10) * itemCapacity + 10);
+
+            GUI.DrawRectangle(spriteBatch, new Rectangle(containerRect.X, containerRect.Y, containerRect.Width, containerRect.Height - slot.Rect.Height - 5), Color.Black * 0.8f, true);
+            GUI.DrawRectangle(spriteBatch, containerRect, Color.White);
+
+            container.Inventory.Draw(spriteBatch, true);
+
+            if (!containerRect.Contains(PlayerInput.MousePosition))
+            {
+                if (draggingItem == null || draggingItem.Container != item) selectedSlot = -1;
+            }
+        }
+
+        protected void DrawSlot(SpriteBatch spriteBatch, InventorySlot slot, Item item, bool drawItem = true)
+        {
+            Rectangle rect = slot.Rect;
+
+            GUI.DrawRectangle(spriteBatch, rect, (slot.IsHighlighted ? Color.Red * 0.4f : slot.Color), true);
+
+            if (item != null && drawItem)
+            {
+                if (item.Condition < 100.0f)
+                {
+                    GUI.DrawRectangle(spriteBatch, new Rectangle(rect.X, rect.Bottom - 8, rect.Width, 8), Color.Black * 0.8f, true);
+                    GUI.DrawRectangle(spriteBatch,
+                        new Rectangle(rect.X, rect.Bottom - 8, (int)(rect.Width * item.Condition / 100.0f), 8),
+                        Color.Lerp(Color.Red, Color.Green, item.Condition / 100.0f) * 0.8f, true);
+                }
+
+                var containedItems = item.ContainedItems;
+                if (containedItems != null && containedItems.Length == 1 && containedItems[0].Condition < 100.0f)
+                {
+                    GUI.DrawRectangle(spriteBatch, new Rectangle(rect.X, rect.Y, rect.Width, 8), Color.Black * 0.8f, true);
+                    GUI.DrawRectangle(spriteBatch,
+                        new Rectangle(rect.X, rect.Y, (int)(rect.Width * containedItems[0].Condition / 100.0f), 8),
+                        Color.Lerp(Color.Red, Color.Green, containedItems[0].Condition / 100.0f) * 0.8f, true);
+                }
+            }
+
+            GUI.DrawRectangle(spriteBatch, rect, (slot.IsHighlighted ? Color.Red * 0.4f : slot.Color), false);
+
+            if (slot.BorderHighlightColor != Color.Transparent)
+            {
+                Rectangle highlightRect = slot.Rect;
+                highlightRect.Inflate(3, 3);
+
+                GUI.DrawRectangle(spriteBatch, highlightRect, slot.BorderHighlightColor, false, 0, 5);
+            }
+
+            if (item == null || !drawItem) return;
+
+            item.Sprite.Draw(spriteBatch, new Vector2(rect.X + rect.Width / 2, rect.Y + rect.Height / 2), item.Color);
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/Item.cs

@@ -0,0 +1,575 @@
+using Barotrauma.Items.Components;
+using Barotrauma.Networking;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Contacts;
+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.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class Item : MapEntity, IDamageable, IPropertyObject, IServerSerializable, IClientSerializable
+    {
+        public override Sprite Sprite
+        {
+            get { return prefab.sprite; }
+        }
+
+
+        public override void Draw(SpriteBatch spriteBatch, bool editing, bool back = true)
+        {
+            if (!Visible) return;
+            Color color = (IsSelected && editing) ? color = Color.Red : spriteColor;
+            if (isHighlighted) color = Color.Orange;
+
+            SpriteEffects oldEffects = prefab.sprite.effects;
+            prefab.sprite.effects ^= SpriteEffects;
+
+            if (prefab.sprite != null)
+            {
+                float depth = Sprite.Depth;
+                depth += (ID % 255) * 0.000001f;
+
+                if (body == null)
+                {
+                    if (prefab.ResizeHorizontal || prefab.ResizeVertical || SpriteEffects.HasFlag(SpriteEffects.FlipHorizontally) || SpriteEffects.HasFlag(SpriteEffects.FlipVertically))
+                    {
+                        prefab.sprite.DrawTiled(spriteBatch, new Vector2(DrawPosition.X - rect.Width / 2, -(DrawPosition.Y + rect.Height / 2)), new Vector2(rect.Width, rect.Height), color);
+                    }
+                    else
+                    {
+                        prefab.sprite.Draw(spriteBatch, new Vector2(DrawPosition.X, -DrawPosition.Y), color, 0.0f, 1.0f, SpriteEffects.None, depth);
+                    }
+
+                }
+                else if (body.Enabled)
+                {
+                    var holdable = GetComponent<Holdable>();
+                    if (holdable != null && holdable.Picker?.AnimController != null)
+                    {
+                        if (holdable.Picker.SelectedItems[0] == this)
+                        {
+                            depth = holdable.Picker.AnimController.GetLimb(LimbType.RightHand).sprite.Depth + 0.000001f;
+                        }
+                        else if (holdable.Picker.SelectedItems[1] == this)
+                        {
+                            depth = holdable.Picker.AnimController.GetLimb(LimbType.LeftArm).sprite.Depth - 0.000001f;
+                        }
+
+                        body.Draw(spriteBatch, prefab.sprite, color, depth);
+                    }
+                    else
+                    {
+                        body.Draw(spriteBatch, prefab.sprite, color, depth);
+                    }
+                }
+            }
+
+            prefab.sprite.effects = oldEffects;
+
+            List<IDrawableComponent> staticDrawableComponents = new List<IDrawableComponent>(drawableComponents); //static list to compensate for drawable toggling
+            for (int i = 0; i < staticDrawableComponents.Count; i++)
+            {
+                staticDrawableComponents[i].Draw(spriteBatch, editing);
+            }
+
+            if (GameMain.DebugDraw && aiTarget != null) aiTarget.Draw(spriteBatch);
+
+            if (!editing || (body != null && !body.Enabled))
+            {
+                return;
+            }
+
+            if (IsSelected || isHighlighted)
+            {
+                GUI.DrawRectangle(spriteBatch, new Vector2(DrawPosition.X - rect.Width / 2, -(DrawPosition.Y + rect.Height / 2)), new Vector2(rect.Width, rect.Height), Color.Green, false, 0, (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+
+                foreach (Rectangle t in prefab.Triggers)
+                {
+                    Rectangle transformedTrigger = TransformTrigger(t);
+
+                    Vector2 rectWorldPos = new Vector2(transformedTrigger.X, transformedTrigger.Y);
+                    if (Submarine != null) rectWorldPos += Submarine.Position;
+                    rectWorldPos.Y = -rectWorldPos.Y;
+
+                    GUI.DrawRectangle(spriteBatch,
+                        rectWorldPos,
+                        new Vector2(transformedTrigger.Width, transformedTrigger.Height),
+                        Color.Green,
+                        false,
+                        0,
+                        (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
+                }
+            }
+
+            if (!ShowLinks) return;
+
+            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 Item != this)
+            {
+                editingHUD = CreateEditingHUD(Screen.Selected != GameMain.EditMapScreen);
+            }
+
+            editingHUD.Update((float)Timing.Step);
+
+            if (Screen.Selected != GameMain.EditMapScreen) return;
+
+            if (!prefab.IsLinkable) return;
+
+            if (!PlayerInput.LeftButtonClicked() || !PlayerInput.KeyDown(Keys.Space)) return;
+
+            Vector2 position = cam.ScreenToWorld(PlayerInput.MousePosition);
+
+            foreach (MapEntity entity in mapEntityList)
+            {
+                if (entity == this || !entity.IsHighlighted) continue;
+                if (linkedTo.Contains(entity)) continue;
+                if (!entity.IsMouseOn(position)) continue;
+
+                linkedTo.Add(entity);
+                if (entity.IsLinkable && entity.linkedTo != null) entity.linkedTo.Add(this);
+            }
+        }
+
+        public override void DrawEditing(SpriteBatch spriteBatch, Camera cam)
+        {
+            if (editingHUD != null) editingHUD.Draw(spriteBatch);
+        }
+
+        private GUIComponent CreateEditingHUD(bool inGame = false)
+        {
+            List<ObjectProperty> editableProperties = inGame ? GetProperties<InGameEditable>() : GetProperties<Editable>();
+
+            int requiredItemCount = 0;
+            if (!inGame)
+            {
+                foreach (ItemComponent ic in components)
+                {
+                    requiredItemCount += ic.requiredItems.Count;
+                }
+            }
+
+            int width = 450;
+            int height = 80 + requiredItemCount * 20;
+            int x = GameMain.GraphicsWidth / 2 - width / 2, y = 10;
+            foreach (var objectProperty in editableProperties)
+            {
+                var editable = objectProperty.Attributes.OfType<Editable>().FirstOrDefault();
+                if (editable != null) height += (int)(Math.Ceiling(editable.MaxLength / 40.0f) * 18.0f) + 5;
+            }
+
+            editingHUD = new GUIFrame(new Rectangle(x, y, width, height), "");
+            editingHUD.Padding = new Vector4(10, 10, 0, 0);
+            editingHUD.UserData = this;
+
+            new GUITextBlock(new Rectangle(0, 0, 100, 20), prefab.Name, "",
+                Alignment.TopLeft, Alignment.TopLeft, editingHUD, false, GUI.LargeFont);
+
+            y += 25;
+
+            if (!inGame)
+            {
+                if (prefab.IsLinkable)
+                {
+                    new GUITextBlock(new Rectangle(0, 5, 0, 20), "Hold space to link to another item",
+                        "", Alignment.TopRight, Alignment.TopRight, editingHUD).Font = GUI.SmallFont;
+                }
+                foreach (ItemComponent ic in components)
+                {
+                    foreach (RelatedItem relatedItem in ic.requiredItems)
+                    {
+                        new GUITextBlock(new Rectangle(0, y, 100, 15), ic.Name + ": " + relatedItem.Type.ToString() + " required", "", Alignment.TopLeft, Alignment.CenterLeft, editingHUD, false, GUI.SmallFont);
+                        GUITextBox namesBox = new GUITextBox(new Rectangle(-10, y, 160, 15), Alignment.Right, "", editingHUD);
+                        namesBox.Font = GUI.SmallFont;
+
+                        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(relatedItem);
+                        PropertyDescriptor property = properties.Find("JoinedNames", false);
+
+                        namesBox.Text = relatedItem.JoinedNames;
+                        namesBox.UserData = new ObjectProperty(property, relatedItem);
+                        namesBox.OnEnterPressed = EnterProperty;
+                        namesBox.OnTextChanged = PropertyChanged;
+
+                        y += 20;
+                    }
+                }
+                if (requiredItemCount > 0) y += 10;
+            }
+
+            foreach (var objectProperty in editableProperties)
+            {
+                int boxHeight = 18;
+                var editable = objectProperty.Attributes.OfType<Editable>().FirstOrDefault();
+                if (editable != null) boxHeight = (int)(Math.Ceiling(editable.MaxLength / 40.0f) * 18.0f);
+
+                object value = objectProperty.GetValue();
+
+                if (value is bool)
+                {
+                    GUITickBox propertyTickBox = new GUITickBox(new Rectangle(10, y, 18, 18), objectProperty.Name,
+                        Alignment.Left, editingHUD);
+                    propertyTickBox.Font = GUI.SmallFont;
+
+                    propertyTickBox.Selected = (bool)value;
+
+                    propertyTickBox.UserData = objectProperty;
+                    propertyTickBox.OnSelected = EnterProperty;
+                }
+                else
+                {
+                    new GUITextBlock(new Rectangle(0, y, 100, 18), objectProperty.Name, "", Alignment.TopLeft, Alignment.Left, editingHUD, false, GUI.SmallFont);
+
+                    GUITextBox propertyBox = new GUITextBox(new Rectangle(180, y, 250, boxHeight), "", editingHUD);
+                    propertyBox.Font = GUI.SmallFont;
+                    if (boxHeight > 18) propertyBox.Wrap = true;
+
+                    if (value != null)
+                    {
+                        if (value is float)
+                        {
+                            propertyBox.Text = ((float)value).ToString("G", System.Globalization.CultureInfo.InvariantCulture);
+                        }
+                        else
+                        {
+
+                            propertyBox.Text = value.ToString();
+                        }
+                    }
+
+                    propertyBox.UserData = objectProperty;
+                    propertyBox.OnEnterPressed = EnterProperty;
+                    propertyBox.OnTextChanged = PropertyChanged;
+
+                }
+                y = y + boxHeight + 5;
+
+            }
+            return editingHUD;
+        }
+
+        public virtual void UpdateHUD(Camera cam, Character character)
+        {
+            if (condition <= 0.0f)
+            {
+                FixRequirement.UpdateHud(this, character);
+                return;
+            }
+
+            if (HasInGameEditableProperties)
+            {
+                UpdateEditing(cam);
+            }
+
+            foreach (ItemComponent ic in components)
+            {
+                if (ic.CanBeSelected) ic.UpdateHUD(character);
+            }
+        }
+
+        public virtual void DrawHUD(SpriteBatch spriteBatch, Camera cam, Character character)
+        {
+            if (condition <= 0.0f)
+            {
+                FixRequirement.DrawHud(spriteBatch, this, character);
+                return;
+            }
+
+            if (HasInGameEditableProperties)
+            {
+                DrawEditing(spriteBatch, cam);
+            }
+
+            foreach (ItemComponent ic in components)
+            {
+                if (ic.CanBeSelected) ic.DrawHUD(spriteBatch, character);
+            }
+        }
+
+        public override void AddToGUIUpdateList()
+        {
+            if (Screen.Selected is EditMapScreen)
+            {
+                if (editingHUD != null) editingHUD.AddToGUIUpdateList();
+            }
+            else
+            {
+                if (HasInGameEditableProperties)
+                {
+                    if (editingHUD != null) editingHUD.AddToGUIUpdateList();
+                }
+            }
+
+            if (Character.Controlled != null && Character.Controlled.SelectedConstruction == this)
+            {
+                if (condition <= 0.0f)
+                {
+                    FixRequirement.AddToGUIUpdateList();
+                    return;
+                }
+
+                foreach (ItemComponent ic in components)
+                {
+                    if (ic.CanBeSelected) ic.AddToGUIUpdateList();
+                }
+            }
+        }
+
+        private bool EnterProperty(GUITickBox tickBox)
+        {
+            var objectProperty = tickBox.UserData as ObjectProperty;
+            if (objectProperty == null) return false;
+
+            objectProperty.TrySetValue(tickBox.Selected);
+
+            return true;
+        }
+
+        private bool EnterProperty(GUITextBox textBox, string text)
+        {
+            textBox.Color = Color.DarkGreen;
+
+            var objectProperty = textBox.UserData as ObjectProperty;
+            if (objectProperty == null) return false;
+
+            object prevValue = objectProperty.GetValue();
+
+            textBox.Deselect();
+
+            if (objectProperty.TrySetValue(text))
+            {
+                textBox.Text = text;
+
+                if (GameMain.Server != null)
+                {
+                    GameMain.Server.CreateEntityEvent(this, new object[] { NetEntityEvent.Type.ChangeProperty, objectProperty });
+                }
+                else if (GameMain.Client != null)
+                {
+                    GameMain.Client.CreateEntityEvent(this, new object[] { NetEntityEvent.Type.ChangeProperty, objectProperty });
+                }
+
+                return true;
+            }
+            else
+            {
+                if (prevValue != null)
+                {
+                    textBox.Text = prevValue.ToString();
+                }
+                return false;
+            }
+        }
+
+        private bool PropertyChanged(GUITextBox textBox, string text)
+        {
+            textBox.Color = Color.Red;
+
+            return true;
+        }
+
+        public override XElement Save(XElement parentElement)
+        {
+            XElement element = new XElement("Item");
+
+            element.Add(new XAttribute("name", prefab.Name),
+                new XAttribute("ID", ID));
+
+            System.Diagnostics.Debug.Assert(Submarine != null);
+
+            if (ResizeHorizontal || ResizeVertical)
+            {
+                element.Add(new XAttribute("rect",
+                    (int)(rect.X - Submarine.HiddenSubPosition.X) + "," +
+                    (int)(rect.Y - Submarine.HiddenSubPosition.Y) + "," +
+                    rect.Width + "," + rect.Height));
+            }
+            else
+            {
+                element.Add(new XAttribute("rect",
+                    (int)(rect.X - Submarine.HiddenSubPosition.X) + "," +
+                    (int)(rect.Y - Submarine.HiddenSubPosition.Y)));
+            }
+
+            if (linkedTo != null && linkedTo.Count > 0)
+            {
+                string[] linkedToIDs = new string[linkedTo.Count];
+
+                for (int i = 0; i < linkedTo.Count; i++)
+                {
+                    linkedToIDs[i] = linkedTo[i].ID.ToString();
+                }
+
+                element.Add(new XAttribute("linked", string.Join(",", linkedToIDs)));
+            }
+
+
+            ObjectProperty.SaveProperties(this, element);
+
+            foreach (ItemComponent ic in components)
+            {
+                ic.Save(element);
+            }
+
+            parentElement.Add(element);
+
+            return element;
+        }
+
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            if (type == ServerNetObject.ENTITY_POSITION)
+            {
+                ClientReadPosition(type, msg, sendingTime);
+                return;
+            }
+
+            NetEntityEvent.Type eventType =
+                (NetEntityEvent.Type)msg.ReadRangedInteger(0, Enum.GetValues(typeof(NetEntityEvent.Type)).Length - 1);
+
+            switch (eventType)
+            {
+                case NetEntityEvent.Type.ComponentState:
+                    int componentIndex = msg.ReadRangedInteger(0, components.Count - 1);
+                    (components[componentIndex] as IServerSerializable).ClientRead(type, msg, sendingTime);
+                    break;
+                case NetEntityEvent.Type.InventoryState:
+                    ownInventory.ClientRead(type, msg, sendingTime);
+                    break;
+                case NetEntityEvent.Type.Status:
+                    condition = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+
+                    if (FixRequirements.Count > 0)
+                    {
+                        if (Condition <= 0.0f)
+                        {
+                            for (int i = 0; i < FixRequirements.Count; i++)
+                                FixRequirements[i].Fixed = msg.ReadBoolean();
+                        }
+                        else
+                        {
+                            for (int i = 0; i < FixRequirements.Count; i++)
+                                FixRequirements[i].Fixed = true;
+                        }
+                    }
+                    break;
+                case NetEntityEvent.Type.ApplyStatusEffect:
+                    ActionType actionType = (ActionType)msg.ReadRangedInteger(0, Enum.GetValues(typeof(ActionType)).Length - 1);
+                    ushort targetID = msg.ReadUInt16();
+
+                    Character target = FindEntityByID(targetID) as Character;
+                    ApplyStatusEffects(actionType, (float)Timing.Step, target, true);
+                    break;
+                case NetEntityEvent.Type.ChangeProperty:
+                    ReadPropertyChange(msg);
+                    break;
+            }
+        }
+
+        public void ClientWrite(NetBuffer msg, object[] extraData = null)
+        {
+            if (extraData == null || extraData.Length == 0 || !(extraData[0] is NetEntityEvent.Type))
+            {
+                return;
+            }
+
+            NetEntityEvent.Type eventType = (NetEntityEvent.Type)extraData[0];
+            msg.WriteRangedInteger(0, Enum.GetValues(typeof(NetEntityEvent.Type)).Length - 1, (int)eventType);
+            switch (eventType)
+            {
+                case NetEntityEvent.Type.ComponentState:
+                    int componentIndex = (int)extraData[1];
+                    msg.WriteRangedInteger(0, components.Count - 1, componentIndex);
+
+                    (components[componentIndex] as IClientSerializable).ClientWrite(msg, extraData);
+                    break;
+                case NetEntityEvent.Type.InventoryState:
+                    ownInventory.ClientWrite(msg, extraData);
+                    break;
+                case NetEntityEvent.Type.Repair:
+                    if (FixRequirements.Count > 0)
+                    {
+                        int requirementIndex = (int)extraData[1];
+                        msg.WriteRangedInteger(0, FixRequirements.Count - 1, requirementIndex);
+                    }
+                    break;
+                case NetEntityEvent.Type.ApplyStatusEffect:
+                    //no further data needed, the server applies the effect
+                    //on the character of the client who sent the message                    
+                    break;
+                case NetEntityEvent.Type.ChangeProperty:
+                    WritePropertyChange(msg, extraData);
+                    break;
+            }
+            msg.WritePadBits();
+        }
+        
+        public void ClientReadPosition(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            Vector2 newPosition = new Vector2(msg.ReadFloat(), msg.ReadFloat());
+            float newRotation = msg.ReadRangedSingle(0.0f, MathHelper.TwoPi, 7);
+            bool awake = msg.ReadBoolean();
+            Vector2 newVelocity = Vector2.Zero;
+
+            if (awake)
+            {
+                newVelocity = new Vector2(
+                    msg.ReadRangedSingle(-MaxVel, MaxVel, 12),
+                    msg.ReadRangedSingle(-MaxVel, MaxVel, 12));
+            }
+
+            if (body == null)
+            {
+                DebugConsole.ThrowError("Received a position update for an item with no physics body (" + Name + ")");
+                return;
+            }
+
+            body.FarseerBody.Awake = awake;
+            if (body.FarseerBody.Awake)
+            {
+                if ((newVelocity - body.LinearVelocity).Length() > 8.0f) body.LinearVelocity = newVelocity;
+            }
+            else
+            {
+                body.FarseerBody.Enabled = false;
+            }
+
+            if ((newPosition - SimPosition).Length() > body.LinearVelocity.Length() * 2.0f)
+            {
+                body.SetTransform(newPosition, newRotation);
+
+                Vector2 displayPos = ConvertUnits.ToDisplayUnits(body.SimPosition);
+                rect.X = (int)(displayPos.X - rect.Width / 2.0f);
+                rect.Y = (int)(displayPos.Y + rect.Height / 2.0f);
+            }
+        }
+
+        public void CreateClientEvent<T>(T ic) where T : ItemComponent, IClientSerializable
+        {
+            if (GameMain.Client == null) return;
+
+            int index = components.IndexOf(ic);
+            if (index == -1) return;
+
+            GameMain.Client.CreateEntityEvent(this, new object[] { NetEntityEvent.Type.ComponentState, index });
+        }
+    }
+}

Barotrauma/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;
+
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Items/Rope.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Collision.Shapes;
+using FarseerPhysics.Common;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Joints;
+using FarseerPhysics.Factories;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Rope : ItemComponent, IDrawableComponent
+    {
+        public void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            if (!IsActive) return;
+
+            RevoluteJoint firstJoint = null;
+
+            for (int i = 0; i < ropeBodies.Length - 1; i++)
+            {
+                if (!ropeBodies[i].Enabled) continue;
+
+                if (firstJoint == null) firstJoint = ropeJoints[i];
+
+                DrawSection(spriteBatch, ropeJoints[i].WorldAnchorA, ropeJoints[i + 1].WorldAnchorA, i);
+            }
+
+            if (gunJoint == null || firstJoint == null) return;
+
+            DrawSection(spriteBatch, gunJoint.WorldAnchorA, firstJoint.WorldAnchorA, 0);
+
+        }
+
+        private void DrawSection(SpriteBatch spriteBatch, Vector2 start, Vector2 end, int i)
+        {
+            start.Y = -start.Y;
+            end.Y = -end.Y;
+
+            spriteBatch.Draw(sprite.Texture,
+                ConvertUnits.ToDisplayUnits(start), null, Color.White,
+                MathUtils.VectorToAngle(end - start),
+                new Vector2(0.0f, sprite.size.Y / 2.0f),
+                new Vector2((ConvertUnits.ToDisplayUnits(Vector2.Distance(start, end))) / sprite.Texture.Width, 1.0f),
+                SpriteEffects.None,
+                sprite.Depth + i * 0.00001f);
+        }
+    }
+}

Barotrauma/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
+    {
+        partial 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;
+        }
+    }
+}

Barotrauma/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;
+
+        partial 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;
+        }
+    }
+}

Barotrauma/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;
+        }
+    }
+}

Barotrauma/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;
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Map/Levels/CaveGenerator.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Voronoi2;
+using Microsoft.Xna.Framework.Graphics;
+using FarseerPhysics;
+using FarseerPhysics.Common;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Factories;
+
+namespace Barotrauma
+{
+    static partial class CaveGenerator
+    {
+        public static List<VertexPositionTexture> GenerateRenderVerticeList(List<Vector2[]> triangles)
+        {
+            var verticeList = new List<VertexPositionTexture>();
+            for (int i = 0; i < triangles.Count; i++)
+            {
+                foreach (Vector2 vertex in triangles[i])
+                {
+                    //shift the coordinates around a bit to make the texture repetition less obvious
+                    Vector2 uvCoords = new Vector2(
+                        vertex.X / 2000.0f + (float)Math.Sin(vertex.X / 500.0f) * 0.15f,
+                        vertex.Y / 2000.0f + (float)Math.Sin(vertex.Y / 700.0f) * 0.15f);
+
+                    verticeList.Add(new VertexPositionTexture(new Vector3(vertex, 1.0f), uvCoords));
+                }
+            }
+
+            return verticeList;
+        }
+
+        public static VertexPositionTexture[] GenerateWallShapes(List<VoronoiCell> cells)
+        {
+            float inwardThickness = 500.0f, outWardThickness = 30.0f;
+
+            List<VertexPositionTexture> verticeList = new List<VertexPositionTexture>();
+
+            foreach (VoronoiCell cell in cells)
+            {
+                //if (cell.body == null) continue;
+                foreach (GraphEdge edge in cell.edges)
+                {
+                    if (edge.cell1 != null && edge.cell1.body == null && edge.cell1.CellType != CellType.Empty) edge.cell1 = null;
+                    if (edge.cell2 != null && edge.cell2.body == null && edge.cell2.CellType != CellType.Empty) edge.cell2 = null;
+
+                    CompareCCW compare = new CompareCCW(cell.Center);
+                    if (compare.Compare(edge.point1, edge.point2) == -1)
+                    {
+                        var temp = edge.point1;
+                        edge.point1 = edge.point2;
+                        edge.point2 = temp;
+                    }
+                }
+            }
+
+            foreach (VoronoiCell cell in cells)
+            {
+                //if (cell.body == null) continue;
+                foreach (GraphEdge edge in cell.edges)
+                {
+                    if (!edge.isSolid) continue;
+
+                    GraphEdge leftEdge = cell.edges.Find(e => e != edge && (edge.point1 == e.point1 || edge.point1 == e.point2));
+                    GraphEdge rightEdge = cell.edges.Find(e => e != edge && (edge.point2 == e.point1 || edge.point2 == e.point2));
+
+                    Vector2 leftNormal = Vector2.Zero, rightNormal = Vector2.Zero;
+
+                    if (leftEdge == null)
+                    {
+                        leftNormal = GetEdgeNormal(edge, cell);
+                    }
+                    else
+                    {
+                        leftNormal = (leftEdge.isSolid) ?
+                            Vector2.Normalize(GetEdgeNormal(leftEdge) + GetEdgeNormal(edge, cell)) :
+                            Vector2.Normalize(leftEdge.Center - edge.point1);
+                    }
+
+
+                    if (!MathUtils.IsValid(leftNormal))
+                    {
+#if DEBUG
+                        DebugConsole.ThrowError("Invalid left normal");
+#endif
+                        if (cell.body != null)
+                        {
+                            GameMain.World.RemoveBody(cell.body);
+                            cell.body = null;
+                        }
+                        leftNormal = Vector2.UnitX;
+                        break;
+                    }
+
+
+                    if (rightEdge == null)
+                    {
+                        rightNormal = GetEdgeNormal(edge, cell);
+                    }
+                    else
+                    {
+                        rightNormal = (rightEdge.isSolid) ?
+                            Vector2.Normalize(GetEdgeNormal(rightEdge) + GetEdgeNormal(edge, cell)) :
+                            Vector2.Normalize(rightEdge.Center - edge.point2);
+                    }
+
+                    if (!MathUtils.IsValid(rightNormal))
+                    {
+#if DEBUG
+                        DebugConsole.ThrowError("Invalid right normal");
+#endif
+                        if (cell.body != null)
+                        {
+                            GameMain.World.RemoveBody(cell.body);
+                            cell.body = null;
+                        }
+                        rightNormal = Vector2.UnitX;
+                        break;
+                    }
+
+                    for (int i = 0; i < 2; i++)
+                    {
+                        Vector2[] verts = new Vector2[3];
+                        VertexPositionTexture[] vertPos = new VertexPositionTexture[3];
+
+
+                        if (i == 0)
+                        {
+                            verts[0] = edge.point1 - leftNormal * outWardThickness;
+                            verts[1] = edge.point2 - rightNormal * outWardThickness;
+                            verts[2] = edge.point1 + leftNormal * inwardThickness;
+
+                            vertPos[0] = new VertexPositionTexture(new Vector3(verts[0], 0.0f), Vector2.Zero);
+                            vertPos[1] = new VertexPositionTexture(new Vector3(verts[1], 0.0f), Vector2.UnitX);
+                            vertPos[2] = new VertexPositionTexture(new Vector3(verts[2], 0.0f), new Vector2(0, 0.5f));
+                        }
+                        else
+                        {
+                            verts[0] = edge.point1 + leftNormal * inwardThickness;
+                            verts[1] = edge.point2 - rightNormal * outWardThickness;
+                            verts[2] = edge.point2 + rightNormal * inwardThickness;
+
+                            vertPos[0] = new VertexPositionTexture(new Vector3(verts[0], 0.0f), new Vector2(0.0f, 0.5f));
+                            vertPos[1] = new VertexPositionTexture(new Vector3(verts[1], 0.0f), Vector2.UnitX);
+                            vertPos[2] = new VertexPositionTexture(new Vector3(verts[2], 0.0f), new Vector2(1.0f, 0.5f));
+                        }
+
+                        var comparer = new CompareCCW((verts[0] + verts[1] + verts[2]) / 3.0f);
+                        Array.Sort(verts, vertPos, comparer);
+
+                        for (int j = 0; j < 3; j++)
+                        {
+                            verticeList.Add(vertPos[j]);
+                        }
+                    }
+                }
+            }
+
+            return verticeList.ToArray();
+        }
+    }
+}

Barotrauma/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);
+        }
+    }
+}

Barotrauma/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();
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Map/Levels/Ruins/RuinGenerator.cs

@@ -0,0 +1,30 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Voronoi2;
+
+namespace Barotrauma.RuinGeneration
+{
+    partial class Ruin
+    {
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            //foreach (BTRoom room in leaves)
+            //{
+            //    GUI.DrawRectangle(spriteBatch, room.Rect, Color.White);
+            //}
+
+            //foreach (Corridor corr in corridors)
+            //{
+            //    GUI.DrawRectangle(spriteBatch, corr.Rect, Color.Blue);
+            //}
+
+            foreach (Line line in walls)
+            {
+                GUI.DrawLine(spriteBatch, new Vector2(line.A.X, -line.A.Y), new Vector2(line.B.X, -line.B.Y), Color.Red, 0.0f, 10);
+            }
+        }
+    }
+}

Barotrauma/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;
+            }
+        }
+
+    }
+}

Barotrauma/BarotraumaClient/Source/Map/Levels/WrappingWall.cs

@@ -0,0 +1,39 @@
+using FarseerPhysics;
+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
+{
+    partial class WrappingWall : IDisposable
+    {
+        private VertexBuffer wallVertices, bodyVertices;
+
+        public VertexBuffer WallVertices
+        {
+            get { return wallVertices; }
+        }
+
+        public VertexBuffer BodyVertices
+        {
+            get { return bodyVertices; }
+        }
+
+        public void SetWallVertices(VertexPositionTexture[] vertices)
+        {
+            wallVertices = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionTexture.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
+            wallVertices.SetData(vertices);
+        }
+
+        public void SetBodyVertices(VertexPositionColor[] vertices)
+        {
+            bodyVertices = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionColor.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
+            bodyVertices.SetData(vertices);
+        }
+    }
+}

Barotrauma/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);
+                }
+            }
+        }
+    }
+
+}

Barotrauma/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; }
+    }
+
+}

Barotrauma/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);
+        }
+    }
+}