Reorganized project to start work on dedicated server

BarotraumaShared/Source/Characters/AI/AIController.cs

@@ -0,0 +1,71 @@
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    class AIController : ISteerable
+    {
+
+        public enum AiState { None, Attack, GoTo, Escape }
+        public enum SteeringState { Wander, Seek, Escape }
+
+        public bool Enabled;
+
+        public readonly Character Character;
+        
+        protected AiState state;
+
+        protected SteeringManager steeringManager;
+
+        public SteeringManager SteeringManager
+        {
+            get { return steeringManager; }
+        }
+
+        public Vector2 Steering
+        {
+            get { return Character.AnimController.TargetMovement; }
+            set { Character.AnimController.TargetMovement = value; }
+        }
+        
+        public Vector2 SimPosition
+        {
+            get { return Character.SimPosition; }
+        }
+
+        public Vector2 WorldPosition
+        {
+            get { return Character.WorldPosition; }
+        }
+
+        public Vector2 Velocity
+        {
+            get { return Character.AnimController.Collider.LinearVelocity; }
+        }
+
+        public AiState State
+        {
+            get { return state; }
+            set { state = value; }
+        }
+
+        public AIController (Character c)
+        {
+            Character = c;
+
+            Enabled = true;
+        }
+
+        public virtual void DebugDraw(SpriteBatch spriteBatch) { }
+
+        public virtual void OnAttacked(IDamageable attacker, float amount) { }
+
+        public virtual void SelectTarget(AITarget target) { }
+
+        public virtual void Update(float deltaTime) { }
+
+        //protected Structure lastStructurePicked;
+        
+    }
+}

BarotraumaShared/Source/Characters/AI/AITarget.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma
+{
+    class AITarget
+    {
+        public static bool ShowAITargets;
+
+        public static List<AITarget> List = new List<AITarget>();
+
+        public readonly Entity Entity;
+
+        private float soundRange;
+        private float sightRange;
+        
+        public float SoundRange
+        {
+            get { return soundRange; }
+            set { soundRange = Math.Max(value, 0.0f); }
+        }
+
+        public float SightRange
+        {
+            get { return sightRange; }
+            set { sightRange = Math.Max(value, 0.0f); }
+        }
+
+        public Vector2 WorldPosition
+        {
+            get { return Entity.WorldPosition; }
+        }
+
+        public Vector2 SimPosition
+        {
+            get { return Entity.SimPosition; }
+        }
+
+        public AITarget(Entity e)
+        {
+            Entity = e;
+            List.Add(this);
+        }
+
+        public void Remove()
+        {
+            List.Remove(this);
+        }
+
+        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);
+        }
+
+    }
+}

BarotraumaShared/Source/Characters/AI/CrewCommander.cs

@@ -0,0 +1,315 @@
+#if CLIENT
+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);
+        }
+    }
+}
+#endif

BarotraumaShared/Source/Characters/AI/EnemyAIController.cs

@@ -0,0 +1,576 @@
+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
+{
+    
+    class EnemyAIController : AIController
+    {
+        private const float UpdateTargetsInterval = 0.5f;
+
+        private const float RaycastInterval = 1.0f;
+
+        private bool attackWhenProvoked;
+        
+        //the preference to attack a specific type of target (-1.0 - 1.0)
+        //0.0 = doesn't attack targets of the type
+        //positive values = attacks targets of this type
+        //negative values = escapes targets of this type        
+        private float attackRooms, attackHumans, attackWeaker, attackStronger;
+
+        private SteeringManager outsideSteering, insideSteering;
+
+        private float updateTargetsTimer;
+
+        private float raycastTimer;
+        
+        //a timer for attacks such as biting that last for a specific amount of time
+        //the duration is determined by the attackDuration of the attacking limb
+        private float attackTimer;
+        
+        //a "cooldown time" after an attack during which the Character doesn't try to attack again
+        private float attackCoolDown;
+        private float coolDownTimer;
+        
+        //a point in a wall which the Character is currently targeting
+        private Vector2 wallAttackPos;
+        //the entity (a wall) which the Character is targeting
+        private IDamageable targetEntity;
+
+        //the limb selected for the current attack
+        private Limb attackingLimb;
+        
+        private AITarget selectedAiTarget;
+        private AITargetMemory selectedTargetMemory;
+        private float targetValue;
+        
+        private Dictionary<AITarget, AITargetMemory> targetMemories;
+
+        //the eyesight of the NPC (0.0 = blind, 1.0 = sees every target within sightRange)
+        private float sight;
+        //how far the NPC can hear targets from (0.0 = deaf, 1.0 = hears every target within soundRange)
+        private float hearing;
+
+        public AITarget SelectedAiTarget
+        {
+            get { return selectedAiTarget; }
+        }
+                        
+        public EnemyAIController(Character c, string file) : base(c)
+        {
+            targetMemories = new Dictionary<AITarget, AITargetMemory>();
+
+            XDocument doc = ToolBox.TryLoadXml(file);
+            if (doc == null || doc.Root == null) return;
+
+            XElement aiElement = doc.Root.Element("ai");
+            if (aiElement == null) return;
+
+            attackRooms     = ToolBox.GetAttributeFloat(aiElement, "attackrooms", 0.0f) / 100.0f;
+            attackHumans    = ToolBox.GetAttributeFloat(aiElement, "attackhumans", 0.0f) / 100.0f;
+            attackWeaker    = ToolBox.GetAttributeFloat(aiElement, "attackweaker", 0.0f) / 100.0f;
+            attackStronger  = ToolBox.GetAttributeFloat(aiElement, "attackstronger", 0.0f) / 100.0f;
+
+            attackCoolDown  = ToolBox.GetAttributeFloat(aiElement, "attackcooldown", 5.0f);
+
+            sight           = ToolBox.GetAttributeFloat(aiElement, "sight", 0.0f);
+            hearing         = ToolBox.GetAttributeFloat(aiElement, "hearing", 0.0f);
+
+            attackWhenProvoked = ToolBox.GetAttributeBool(aiElement, "attackwhenprovoked", false);
+
+            outsideSteering = new SteeringManager(this);
+            insideSteering = new IndoorsSteeringManager(this, false);
+
+            steeringManager = outsideSteering;
+
+            state = AiState.None;
+        }
+
+        public override void SelectTarget(AITarget target)
+        {
+            selectedAiTarget = target;
+            selectedTargetMemory = FindTargetMemory(target);
+
+            targetValue = 100.0f;
+        }
+        
+        public override void Update(float deltaTime)
+        {
+            bool ignorePlatforms = (-Character.AnimController.TargetMovement.Y > Math.Abs(Character.AnimController.TargetMovement.X));
+
+            if (steeringManager is IndoorsSteeringManager)
+            {
+                var currPath = ((IndoorsSteeringManager)steeringManager).CurrentPath;
+                if (currPath != null && currPath.CurrentNode != null)
+                {
+                    if (currPath.CurrentNode.SimPosition.Y < Character.AnimController.GetColliderBottom().Y)
+                    {
+                        ignorePlatforms = true;
+                    }
+                }
+            }
+            
+            Character.AnimController.IgnorePlatforms = ignorePlatforms;
+
+            if (Character.AnimController is HumanoidAnimController)
+            {
+                if (Math.Abs(Character.AnimController.movement.X) > 0.1f && !Character.AnimController.InWater)
+                {
+                    Character.AnimController.TargetDir = Character.AnimController.movement.X > 0.0f ? Direction.Right : Direction.Left;
+                }
+            }
+
+            if (updateTargetsTimer > 0.0)
+            {
+                updateTargetsTimer -= deltaTime;
+            }
+            else
+            {
+                UpdateTargets(Character);
+                updateTargetsTimer = UpdateTargetsInterval;
+
+                if (selectedAiTarget == null)
+                {
+                    state = AiState.None;
+                }
+                else
+                {
+                    state = (targetValue > 0.0f) ? AiState.Attack : AiState.Escape;
+                }
+                //if (coolDownTimer >= 0.0f) return;
+            }
+
+            steeringManager = Character.Submarine == null ? outsideSteering : insideSteering;
+
+            switch (state)
+            {
+                case AiState.None:
+                    UpdateNone(deltaTime);
+                    break;
+                case AiState.Attack:
+                    UpdateAttack(deltaTime);
+                    break;
+            }
+
+            steeringManager.Update();
+        }
+
+        private void UpdateNone(float deltaTime)
+        {
+            //wander around randomly
+            if (Character.Submarine==null && SimPosition.Y < ConvertUnits.ToSimUnits(SubmarineBody.DamageDepth*0.5f))
+            {
+                steeringManager.SteeringManual(deltaTime, Vector2.UnitY);
+            }
+            else
+            {
+                steeringManager.SteeringAvoid(deltaTime, 0.1f);
+                steeringManager.SteeringWander(0.5f);
+            }
+
+            attackingLimb = null;
+            attackTimer = 0.0f;
+
+            coolDownTimer -= deltaTime;  
+        }
+        
+        private void UpdateAttack(float deltaTime)
+        {
+            if (selectedAiTarget == null || selectedAiTarget.Entity == null || selectedAiTarget.Entity.Removed)
+            {
+                state = AiState.None;
+                return;
+            }
+
+            selectedTargetMemory.Priority -= deltaTime;
+
+            Vector2 attackSimPosition = Character.Submarine == null ? ConvertUnits.ToSimUnits(selectedAiTarget.WorldPosition) : selectedAiTarget.SimPosition;
+            if (wallAttackPos != Vector2.Zero && targetEntity != null)
+            {
+                attackSimPosition = wallAttackPos;
+
+                if (selectedAiTarget.Entity != null && Character.Submarine == null && selectedAiTarget.Entity.Submarine != null) attackSimPosition += ConvertUnits.ToSimUnits(selectedAiTarget.Entity.Submarine.Position);
+            }
+            
+            if (Math.Abs(Character.AnimController.movement.X) > 0.1f && !Character.AnimController.InWater)
+            {
+                Character.AnimController.TargetDir = Character.SimPosition.X < attackSimPosition.X ? Direction.Right : Direction.Left;
+            }
+
+            if (coolDownTimer > 0.0f)
+            {
+                UpdateCoolDown(attackSimPosition, deltaTime);
+                return;
+            }
+
+            if (raycastTimer > 0.0)
+            {
+                raycastTimer -= deltaTime;
+            }
+            else
+            {
+                GetTargetEntity();
+
+                raycastTimer = RaycastInterval;
+            }
+
+            //steeringManager.SteeringAvoid(deltaTime, 1.0f);
+
+            Limb attackLimb = attackingLimb;
+            //check if any of the limbs is close enough to attack the target
+            if (attackingLimb == null)
+            {
+                foreach (Limb limb in Character.AnimController.Limbs)
+                {
+                    if (limb.attack==null) continue;
+                    attackLimb = limb;
+
+                    if (ConvertUnits.ToDisplayUnits(Vector2.Distance(limb.SimPosition, attackSimPosition)) > limb.attack.Range) continue;
+                                        
+                    attackingLimb = limb;
+                    break;   
+                }
+
+                if (Character.IsRemotePlayer)
+                {
+                    if (!Character.IsKeyDown(InputType.Attack)) return;
+                }
+            }
+            if (attackLimb != null)
+            {
+                steeringManager.SteeringSeek(attackSimPosition - (attackLimb.SimPosition - SimPosition));
+
+                if (steeringManager is IndoorsSteeringManager)
+                {
+                    var indoorsSteering = (IndoorsSteeringManager)steeringManager;
+                    if (indoorsSteering.CurrentPath!=null && (indoorsSteering.CurrentPath.Finished || indoorsSteering.CurrentPath.Unreachable))
+                    {
+                        steeringManager.SteeringManual(deltaTime, attackSimPosition - attackLimb.SimPosition);
+                    }
+                }
+
+                if (attackingLimb != null) UpdateLimbAttack(deltaTime, attackingLimb, attackSimPosition);
+            }   
+        }
+
+        private void UpdateCoolDown(Vector2 attackPosition, float deltaTime)
+        {
+            coolDownTimer -= deltaTime;
+            attackingLimb = null;
+            
+            if (selectedAiTarget.Entity is Hull ||
+                Vector2.Distance(attackPosition, Character.AnimController.Limbs[0].SimPosition) < ConvertUnits.ToSimUnits(500.0f))
+            {
+                steeringManager.SteeringSeek(attackPosition, -0.8f);
+                steeringManager.SteeringAvoid(deltaTime, 1.0f);
+            }
+            else
+            {
+                steeringManager.SteeringSeek(attackPosition, -0.5f);
+                steeringManager.SteeringAvoid(deltaTime, 1.0f);
+            }
+        }
+
+        private void GetTargetEntity()
+        {
+            targetEntity = null;
+
+            if (Character.AnimController.CurrentHull != null)
+            {
+                wallAttackPos = Vector2.Zero;
+                return;
+            }
+            
+            //check if there's a wall between the target and the Character   
+            Vector2 rayStart = Character.SimPosition;
+            Vector2 rayEnd = selectedAiTarget.SimPosition;
+
+            if (selectedAiTarget.Entity.Submarine!=null && Character.Submarine==null)
+            {
+                rayStart -= ConvertUnits.ToSimUnits(selectedAiTarget.Entity.Submarine.Position);
+            }
+
+            Body closestBody = Submarine.CheckVisibility(rayStart, rayEnd);
+
+            if (Submarine.LastPickedFraction == 1.0f || closestBody == null)
+            {
+                wallAttackPos = Vector2.Zero;
+                return;
+            }
+            
+            Structure wall = closestBody.UserData as Structure;
+            if (wall == null)
+            {
+                wallAttackPos = Submarine.LastPickedPosition;
+                if (selectedAiTarget.Entity.Submarine!=null && Character.Submarine == null) wallAttackPos -= ConvertUnits.ToSimUnits(selectedAiTarget.Entity.Submarine.Position);
+            
+            }
+            else
+            {
+                int sectionIndex = wall.FindSectionIndex(ConvertUnits.ToDisplayUnits(Submarine.LastPickedPosition));
+
+                float sectionDamage = wall.SectionDamage(sectionIndex);
+                for (int i = sectionIndex - 2; i <= sectionIndex + 2; i++)
+                {
+                    if (wall.SectionBodyDisabled(i))
+                    {
+                        sectionIndex = i;
+                        break;
+                    }
+                    if (wall.SectionDamage(i) > sectionDamage) sectionIndex = i;
+                }
+                wallAttackPos = wall.SectionPosition(sectionIndex);
+                //if (wall.Submarine != null) wallAttackPos += wall.Submarine.Position;
+                wallAttackPos = ConvertUnits.ToSimUnits(wallAttackPos);
+            }
+            
+            targetEntity = closestBody.UserData as IDamageable;            
+        }
+
+        public override void OnAttacked(IDamageable attacker, float amount)
+        {
+            updateTargetsTimer = Math.Min(updateTargetsTimer, 0.1f);
+            coolDownTimer *= 0.1f;
+
+            if (amount > 0.1f && attackWhenProvoked)
+            {
+                attackHumans = 100.0f;
+                attackRooms = 100.0f;
+            }
+
+            if (attacker==null || attacker.AiTarget==null) return;
+            AITargetMemory targetMemory = FindTargetMemory(attacker.AiTarget);
+            targetMemory.Priority += amount;
+        }
+
+        private void UpdateLimbAttack(float deltaTime, Limb limb, Vector2 attackPosition)
+        {
+            var damageTarget = (wallAttackPos != Vector2.Zero && targetEntity != null) ? targetEntity : selectedAiTarget.Entity as IDamageable;
+
+            limb.UpdateAttack(deltaTime, attackPosition, damageTarget);
+
+            if (limb.AttackTimer >= limb.attack.Duration)
+            {
+                wallAttackPos = Vector2.Zero;
+                limb.AttackTimer = 0.0f;
+                coolDownTimer = attackCoolDown;                
+            }
+        }
+        
+        //goes through all the AItargets, evaluates how preferable it is to attack the target,
+        //whether the Character can see/hear the target and chooses the most preferable target within
+        //sight/hearing range
+        public void UpdateTargets(Character character)
+        {
+            var prevAiTarget = selectedAiTarget;
+
+            selectedAiTarget = null;
+            selectedTargetMemory = null;
+            targetValue = 0.0f;
+
+            UpdateTargetMemories();
+            
+            foreach (AITarget target in AITarget.List)
+            {
+                if (Level.Loaded != null && target.WorldPosition.Y > Level.Loaded.Size.Y)
+                {
+                    continue;
+                }
+
+                float valueModifier = 0.0f;
+                float dist = 0.0f;
+                
+                IDamageable targetDamageable = target.Entity as IDamageable;
+                if (targetDamageable!=null && targetDamageable.Health <= 0.0f) continue;
+
+                Character targetCharacter = target.Entity as Character;
+
+                //ignore the aitarget if it is the Character itself
+                if (targetCharacter == character) continue;
+                                
+                if (targetCharacter!=null)
+                {
+                    if (attackHumans == 0.0f || targetCharacter.SpeciesName != "human") continue;
+                    
+                    valueModifier = attackHumans;                  
+                }
+                else if (target.Entity!=null && attackRooms != 0.0f)
+                {
+                    //skip the target if it's the room the Character is inside of
+                    if (character.AnimController.CurrentHull != null && character.AnimController.CurrentHull == target.Entity as Hull) continue;
+
+                    valueModifier = attackRooms;
+                }
+
+                dist = Vector2.Distance(character.WorldPosition, target.WorldPosition);
+
+                //if the target has been within range earlier, the character will notice it more easily
+                //(i.e. remember where the target was)
+                if (targetMemories.ContainsKey(target)) dist *= 0.1f;
+
+                //ignore target if it's too far to see or hear
+                if (dist > target.SightRange * sight && dist > target.SoundRange * hearing) continue;
+
+                AITargetMemory targetMemory = FindTargetMemory(target);
+                valueModifier = valueModifier * targetMemory.Priority / dist;
+
+                if (Math.Abs(valueModifier) > Math.Abs(targetValue))
+                {                  
+                    Vector2 rayStart = character.AnimController.Limbs[0].SimPosition;
+                    Vector2 rayEnd = target.SimPosition;
+
+                    if (target.Entity.Submarine != null && character.Submarine==null)
+                    {
+                        rayStart -= ConvertUnits.ToSimUnits(target.Entity.Submarine.Position);
+                    }
+
+                    Body closestBody = Submarine.CheckVisibility(rayStart, rayEnd);
+                    Structure closestStructure = (closestBody == null) ? null : closestBody.UserData as Structure;
+
+                    if (targetDamageable != null)
+                    {
+                        valueModifier = valueModifier / targetDamageable.Health;                            
+                    }
+                    else if (closestStructure!=null)
+                    {
+                        valueModifier = valueModifier / ((IDamageable)closestStructure).Health;
+                    }
+                    else
+                    {
+                        valueModifier = valueModifier / 1000.0f;
+                    }
+
+                    if (selectedAiTarget == null || Math.Abs(valueModifier) > Math.Abs(targetValue))
+                    {
+                        selectedAiTarget = target;
+                        selectedTargetMemory = targetMemory;
+
+                        targetValue = valueModifier;
+                    }
+                }
+            }
+
+            if (selectedAiTarget != prevAiTarget)
+            {
+                wallAttackPos = Vector2.Zero;
+            }
+           
+        }
+
+        //find the targetMemory that corresponds to some AItarget or create if there isn't one yet
+        private AITargetMemory FindTargetMemory(AITarget target)
+        {
+            AITargetMemory memory = null;
+            if (targetMemories.TryGetValue(target, out memory))
+            {
+                return memory;
+            }
+
+            memory = new AITargetMemory(100.0f);
+            targetMemories.Add(target, memory);
+
+            return memory;
+        }
+
+        //go through all the targetmemories and delete ones that don't
+        //have a corresponding AItarget or whose priority is 0.0f
+        private void UpdateTargetMemories()
+        {
+
+            List<AITarget> toBeRemoved = new List<AITarget>();
+            foreach(KeyValuePair<AITarget, AITargetMemory> memory in targetMemories)
+            {
+                memory.Value.Priority += 0.5f;
+                if (Math.Abs(memory.Value.Priority) < 1.0f || !AITarget.List.Contains(memory.Key)) toBeRemoved.Add(memory.Key);
+            }
+
+            foreach (AITarget target in toBeRemoved)
+            {
+                targetMemories.Remove(target);
+            }
+        }
+
+        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);
+            }
+        }
+    }
+
+    //the "memory" of the Character 
+    //keeps track of how preferable it is to attack a specific target
+    //(if the Character can't inflict much damage the target, the priority decreases
+    //and if the target attacks the Character, the priority increases)
+    class AITargetMemory
+    {
+        private float priority;
+        
+        public float Priority
+        {
+            get { return priority; }
+            set { priority = MathHelper.Clamp(value, 1.0f, 100.0f); }
+        }
+
+        public AITargetMemory(float priority)
+        {
+            this.priority = priority;
+        }
+
+    }
+}

BarotraumaShared/Source/Characters/AI/HumanAIController.cs

@@ -0,0 +1,196 @@
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    class HumanAIController : AIController
+    {
+        public static bool DisableCrewAI;
+
+        const float UpdateObjectiveInterval = 0.5f;
+
+        private AIObjectiveManager objectiveManager;
+        
+        private AITarget selectedAiTarget;
+
+        private float updateObjectiveTimer;
+
+        public Order CurrentOrder
+        {
+            get;
+            private set;
+        }
+
+        public string CurrentOrderOption
+        {
+            get;
+            private set;
+        }
+
+        public HumanAIController(Character c) : base(c)
+        {
+            steeringManager = new IndoorsSteeringManager(this, true);
+
+            objectiveManager = new AIObjectiveManager(c);
+            objectiveManager.AddObjective(new AIObjectiveFindSafety(c));
+            objectiveManager.AddObjective(new AIObjectiveIdle(c));
+
+            updateObjectiveTimer = Rand.Range(0.0f, UpdateObjectiveInterval);
+
+            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);
+            }
+
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (DisableCrewAI || Character.IsUnconscious) return;
+
+            Character.ClearInputs();
+
+            //steeringManager = Character.AnimController.CurrentHull == null ? outdoorsSteeringManager : indoorsSteeringManager;
+
+            if (updateObjectiveTimer>0.0f)
+            {
+                updateObjectiveTimer -= deltaTime;
+            }
+            else
+            {
+                objectiveManager.UpdateObjectives();
+                updateObjectiveTimer = UpdateObjectiveInterval;
+            }
+
+            objectiveManager.DoCurrentObjective(deltaTime);
+         
+            float currObjectivePriority = objectiveManager.GetCurrentPriority(Character);
+            float moveSpeed = MathHelper.Clamp(currObjectivePriority/10.0f, 1.0f, 3.0f);
+            
+            steeringManager.Update(moveSpeed);
+
+            bool ignorePlatforms = Character.AnimController.TargetMovement.Y < -0.5f &&
+                (-Character.AnimController.TargetMovement.Y > Math.Abs(Character.AnimController.TargetMovement.X));
+
+            var currPath = (steeringManager as IndoorsSteeringManager).CurrentPath;
+            if (currPath != null && currPath.CurrentNode != null)
+            {
+                if (currPath.CurrentNode.SimPosition.Y < Character.AnimController.GetColliderBottom().Y)
+                {
+                    ignorePlatforms = true;
+                }
+            }
+
+            Character.AnimController.IgnorePlatforms = ignorePlatforms;
+            (Character.AnimController as HumanoidAnimController).Crouching = false;
+
+            if (!Character.AnimController.InWater)
+            {
+                Character.AnimController.TargetMovement = new Vector2(
+                    Character.AnimController.TargetMovement.X,
+                    MathHelper.Clamp(Character.AnimController.TargetMovement.Y, -1.0f, 1.0f)) * Character.SpeedMultiplier;
+
+                Character.SpeedMultiplier = 1.0f;
+            }
+
+            if (Character.SelectedConstruction != null && Character.SelectedConstruction.GetComponent<Items.Components.Ladder>()!=null)
+            {
+                if (currPath != null && currPath.CurrentNode != null && currPath.CurrentNode.Ladders != null)
+                {
+                    Character.AnimController.TargetMovement = new Vector2( 0.0f, Math.Sign(Character.AnimController.TargetMovement.Y));
+                }
+            }
+
+            //suit can be taken off if there character is inside a hull and there's air in the room
+            bool canTakeOffSuit = Character.AnimController.CurrentHull != null &&
+                Character.AnimController.CurrentHull.OxygenPercentage > 30.0f &&
+                Character.AnimController.CurrentHull.Volume < Character.AnimController.CurrentHull.FullVolume * 0.3f;
+
+            //the suit can be taken off and the character is running out of oxygen (couldn't find a tank for the suit?) or idling
+            //-> take the suit off
+            if (canTakeOffSuit && (Character.Oxygen < 50.0f || objectiveManager.CurrentObjective is AIObjectiveIdle))
+            {
+                var divingSuit = Character.Inventory.FindItem("Diving Suit");
+                if (divingSuit != null) divingSuit.Drop(Character);
+            }
+
+            if (Character.IsKeyDown(InputType.Aim))
+            {
+                var cursorDiffX = Character.CursorPosition.X - Character.Position.X;
+                if (cursorDiffX > 10.0f)
+                {
+                    Character.AnimController.TargetDir = Direction.Right;
+                }
+                else if (cursorDiffX < -10.0f)
+                {
+                    Character.AnimController.TargetDir = Direction.Left;
+                }
+
+                if (Character.SelectedConstruction != null) Character.SelectedConstruction.SecondaryUse(deltaTime, Character);
+
+            }
+            else if (Math.Abs(Character.AnimController.TargetMovement.X) > 0.1f && !Character.AnimController.InWater)
+            {
+                Character.AnimController.TargetDir = Character.AnimController.TargetMovement.X > 0.0f ? Direction.Right : Direction.Left;
+            }
+        }
+
+        public override void OnAttacked(IDamageable attacker, float amount)
+        {
+            if (amount <= 0.0f) return;
+
+            var enemy = attacker as Character;
+            if (enemy == null || enemy == Character) return;
+
+            objectiveManager.AddObjective(new AIObjectiveCombat(Character, enemy));
+        }
+
+        public void SetOrder(Order order, string option)
+        {
+            CurrentOrderOption = option;
+            CurrentOrder = order;
+            objectiveManager.SetOrder(order, option);
+
+            GameMain.GameSession.CrewManager.SetCharacterOrder(Character, order);
+        }
+
+        public override void SelectTarget(AITarget target)
+        {
+            selectedAiTarget = target;
+        }
+
+        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);
+            }
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/ISteerable.cs

@@ -0,0 +1,32 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    interface ISteerable
+    {
+
+        Vector2 Steering
+        {
+            get;
+            set;
+        }
+
+        Vector2 Velocity
+        {
+            get;
+        }
+        
+        Vector2 SimPosition 
+        {
+            get;
+        }
+
+        Vector2 WorldPosition
+        { 
+            get;
+        }
+        
+
+
+    }
+}

BarotraumaShared/Source/Characters/AI/IndoorsSteeringManager.cs

@@ -0,0 +1,313 @@
+using System;
+using System.Linq;
+using Microsoft.Xna.Framework;
+using Barotrauma.Items.Components;
+
+namespace Barotrauma
+{
+    class IndoorsSteeringManager : SteeringManager
+    {
+        private PathFinder pathFinder;
+        private SteeringPath currentPath;
+
+        private bool canOpenDoors;
+
+        private Character character;
+
+        private Vector2 currentTarget;
+
+        private float findPathTimer;
+
+        public SteeringPath CurrentPath
+        {
+            get { return currentPath; }
+        }
+
+        public PathFinder PathFinder
+        {
+            get { return pathFinder; }
+        }
+
+        public Vector2 CurrentTarget
+        {
+            get { return currentTarget; }
+        }
+
+        public IndoorsSteeringManager(ISteerable host, bool canOpenDoors)
+            : base(host)
+        {
+            pathFinder = new PathFinder(WayPoint.WayPointList.FindAll(wp => wp.SpawnType == SpawnType.Path), true);
+            pathFinder.GetNodePenalty = GetNodePenalty;
+
+            this.canOpenDoors = canOpenDoors;
+
+            character = (host as AIController).Character;
+
+            findPathTimer = Rand.Range(0.0f, 1.0f);
+        }
+
+        public override void Update(float speed = 1)
+        {
+            base.Update(speed);
+
+            findPathTimer -= 1.0f / 60.0f;
+        }
+
+        public void SetPath(SteeringPath path)
+        {
+            currentPath = path;
+            if (path.Nodes.Any()) currentTarget = path.Nodes[path.Nodes.Count - 1].SimPosition;
+            findPathTimer = 1.0f;
+        }
+
+
+        protected override Vector2 DoSteeringSeek(Vector2 target, float speed = 1)
+        {
+            //find a new path if one hasn't been found yet or the target is different from the current target
+            if (currentPath == null || Vector2.Distance(target, currentTarget)>1.0f || findPathTimer < -5.0f)
+            {
+                if (findPathTimer > 0.0f) return Vector2.Zero;
+
+                currentTarget = target;
+                Vector2 pos = host.SimPosition;
+                if (character != null && character.Submarine == null)
+                {
+                    var targetHull = Hull.FindHull(FarseerPhysics.ConvertUnits.ToDisplayUnits(target), null, false);
+                    if (targetHull!=null && targetHull.Submarine != null)
+                    {
+                        pos -= targetHull.SimPosition;
+                    }
+                }   
+
+                currentPath = pathFinder.FindPath(pos, target);
+
+                findPathTimer = Rand.Range(1.0f,1.2f);
+
+                return DiffToCurrentNode();
+            }
+                        
+            Vector2 diff = DiffToCurrentNode();
+            
+            var collider = character.AnimController.Collider;
+            //if not in water and the waypoint is between the top and bottom of the collider, no need to move vertically
+            if (!character.AnimController.InWater && 
+                character.AnimController.Anim != AnimController.Animation.Climbing &&
+                diff.Y < collider.height / 2 + collider.radius)
+            {
+                diff.Y = 0.0f;
+            }
+
+            if (diff.LengthSquared() < 0.001f) return -host.Steering;
+
+            return Vector2.Normalize(diff) * speed;          
+        }
+
+        private Vector2 DiffToCurrentNode()
+        {
+            if (currentPath == null || currentPath.Finished || currentPath.Unreachable) return Vector2.Zero;
+
+            if (currentPath.Finished)
+            {
+                Vector2 pos2 = host.SimPosition;
+                if (character != null && character.Submarine == null && CurrentPath.Nodes.Last().Submarine != null)
+                {
+                    //todo: take multiple subs into account
+                    pos2 -= CurrentPath.Nodes.Last().Submarine.SimPosition;
+                }   
+                return currentTarget-pos2;
+            }
+
+            if (canOpenDoors && !character.LockHands) CheckDoorsInPath();
+            
+            Vector2 pos = host.SimPosition;
+
+            if (character != null && currentPath.CurrentNode != null)
+            {
+                if (CurrentPath.CurrentNode.Submarine != null)
+                {
+                    if (character.Submarine == null)
+                    {
+                        pos -= CurrentPath.CurrentNode.Submarine.SimPosition;
+                    }
+                    else if (character.Submarine != currentPath.CurrentNode.Submarine)
+                    {
+                        pos -= FarseerPhysics.ConvertUnits.ToSimUnits(currentPath.CurrentNode.Submarine.Position-character.Submarine.Position);
+                    }
+                }
+
+            }
+
+            if (currentPath.CurrentNode!= null && currentPath.CurrentNode.Ladders!=null)
+            {
+                if (character.SelectedConstruction != currentPath.CurrentNode.Ladders.Item && currentPath.CurrentNode.Ladders.Item.IsInsideTrigger(character.WorldPosition))
+                {
+                    currentPath.CurrentNode.Ladders.Item.Pick(character, false, true);
+                }
+            }
+
+            var collider = character.AnimController.Collider;
+            Vector2 colliderBottom = character.AnimController.GetColliderBottom();
+
+            if (Math.Abs(collider.SimPosition.X - currentPath.CurrentNode.SimPosition.X) < collider.radius * 2 &&
+                currentPath.CurrentNode.SimPosition.Y > colliderBottom.Y &&
+                currentPath.CurrentNode.SimPosition.Y < colliderBottom.Y + 1.5f)
+            {
+                currentPath.SkipToNextNode();
+            }
+
+            if (currentPath.CurrentNode == null) return Vector2.Zero;
+            
+            if (character.AnimController.Anim == AnimController.Animation.Climbing)
+            {
+                Vector2 diff = currentPath.CurrentNode.SimPosition - pos;
+                
+                if (currentPath.CurrentNode.Ladders != null)
+                {
+                    //climbing ladders -> don't move horizontally
+                    diff.X = 0.0f;
+
+                    //at the same height as the waypoint
+                    if (Math.Abs(collider.SimPosition.Y - currentPath.CurrentNode.SimPosition.Y) < collider.height / 2 + collider.radius)
+                    {
+                        float heightFromFloor = character.AnimController.GetColliderBottom().Y - character.AnimController.FloorY;
+
+                        //we can safely skip to the next waypoint if the character is at a safe height above the floor,
+                        //or if the next waypoint in the path is also on ladders
+                        if ((heightFromFloor > 0.0f && heightFromFloor < collider.height) || 
+                            (currentPath.NextNode != null && currentPath.NextNode.Ladders != null))
+                        {
+                            currentPath.SkipToNextNode();
+                        }
+                    }
+                }
+
+                character.AnimController.IgnorePlatforms = false;
+                return diff;
+            }
+
+            return currentPath.CurrentNode.SimPosition - pos;
+        }
+
+        private void CheckDoorsInPath()
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                WayPoint node = null;
+                WayPoint nextNode = null;
+                
+                if (i==0)
+                {
+                    node = currentPath.CurrentNode;
+                    nextNode = currentPath.NextNode;
+                }
+                else
+                {
+                    node = currentPath.PrevNode;
+                    nextNode = currentPath.CurrentNode;
+                }
+
+                if (node == null || node.ConnectedGap == null || node.ConnectedGap.ConnectedDoor == null) continue;
+
+                if (nextNode == null) continue;
+
+                var door = node.ConnectedGap.ConnectedDoor;
+
+                bool shouldBeOpen = false;
+
+                if (door.LinkedGap.isHorizontal)
+                {
+                    int currentDir = Math.Sign(nextNode.WorldPosition.X - door.Item.WorldPosition.X);
+
+                    shouldBeOpen = (door.Item.WorldPosition.X - character.WorldPosition.X) * currentDir > -50.0f;
+                }
+                else
+                {
+                    int currentDir = Math.Sign(nextNode.WorldPosition.Y - door.Item.WorldPosition.Y);
+
+                    shouldBeOpen = (door.Item.WorldPosition.Y - character.WorldPosition.Y) * currentDir > -80.0f;
+                }
+                
+
+                //toggle the door if it's the previous node and open, or if it's current node and closed
+                if (door.IsOpen != shouldBeOpen)
+                {
+                    var buttons = door.Item.GetConnectedComponents<Controller>(true);
+
+                    Controller closestButton = null;
+                    float closestDist = 0.0f;
+
+                    foreach (Controller controller in buttons)
+                    {
+                        float dist = Vector2.Distance(controller.Item.WorldPosition, character.WorldPosition);
+                        if (dist > controller.Item.PickDistance * 2.0f) continue;
+
+                        if (dist < closestDist || closestButton == null)
+                        {
+                            closestButton = controller;
+                            closestDist = dist;
+                        }
+                    }
+
+                    if (closestButton != null)
+                    {
+                        if (!closestButton.HasRequiredItems(character, false) && shouldBeOpen)
+                        {
+                            currentPath.Unreachable = true;
+                            return;
+                        }
+
+                        closestButton.Item.Pick(character, false, true);
+                        break;
+                    }
+                }
+            }
+        }
+
+        private float? GetNodePenalty(PathNode node, PathNode nextNode)
+        {
+            if (character == null) return 0.0f;
+            
+            float penalty = 0.0f;
+            if (nextNode.Waypoint.ConnectedGap != null && nextNode.Waypoint.ConnectedGap.Open < 0.9f)
+            {
+                if (nextNode.Waypoint.ConnectedGap.ConnectedDoor == null)
+                {
+                    penalty = 100.0f;
+                }
+
+                //door closed and the character can't open doors -> node can't be traversed
+                if (!canOpenDoors || character.LockHands) return null;
+
+                var doorButtons = nextNode.Waypoint.ConnectedGap.ConnectedDoor.Item.GetConnectedComponents<Controller>();
+                if (!doorButtons.Any()) return null;
+
+                foreach (Controller button in doorButtons)
+                {
+                    if (Math.Sign(button.Item.Position.X - nextNode.Waypoint.Position.X) !=
+                        Math.Sign(node.Position.X - nextNode.Position.X)) continue;
+
+                    if (!button.HasRequiredItems(character, false)) return null;
+                }
+            }
+
+            if (node.Waypoint!=null && node.Waypoint.CurrentHull!=null)
+            {
+                var hull = node.Waypoint.CurrentHull;
+
+                if (hull.FireSources.Count > 0)
+                {
+                    foreach (FireSource fs in hull.FireSources)
+                    {
+                        penalty += fs.Size.X * 10.0f;
+                    }
+                }
+
+                if (character.NeedsAir && hull.Volume / hull.Rect.Width > 100.0f) penalty += 500.0f;
+                if (character.PressureProtection < 10.0f && hull.Volume > hull.FullVolume) penalty += 1000.0f;
+            }
+
+            return penalty;
+        }
+    }
+    
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjective.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjective
+    {
+        protected List<AIObjective> subObjectives;
+
+        protected float priority;
+
+        protected Character character;
+
+        protected string option;
+
+        public virtual bool IsCompleted()
+        {
+            return false;
+        }
+
+        public virtual bool CanBeCompleted
+        {
+            get { return true; }
+        }
+
+        public string Option
+        {
+            get { return option; }
+        }
+            
+
+        public AIObjective(Character character, string option)
+        {
+            subObjectives = new List<AIObjective>();
+
+            this.character = character;
+
+            this.option = option;
+
+#if DEBUG
+            IsDuplicate(null);
+#endif
+        }
+
+        /// <summary>
+        /// makes the character act according to the objective, or according to any subobjectives that
+        /// need to be completed before this one
+        /// </summary>
+        public void TryComplete(float deltaTime)
+        {
+            subObjectives.RemoveAll(s => s.IsCompleted() || !s.CanBeCompleted);
+
+            foreach (AIObjective objective in subObjectives)
+            {
+                objective.TryComplete(deltaTime);
+                return;
+            }
+
+            Act(deltaTime);
+        }
+
+        protected virtual void Act(float deltaTime) { }
+
+        public void AddSubObjective(AIObjective objective)
+        {
+            if (subObjectives.Any(o => o.IsDuplicate(objective))) return;
+
+            subObjectives.Add(objective);
+        }
+
+        public virtual float GetPriority(Character character)
+        {
+            return 0.0f;
+        }
+
+        public virtual bool IsDuplicate(AIObjective otherObjective)
+        {
+#if DEBUG
+            throw new NotImplementedException();
+#else
+            return (this.GetType() == otherObjective.GetType());
+#endif
+
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveCombat.cs

@@ -0,0 +1,130 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveCombat : AIObjective
+    {
+        const float CoolDown = 10.0f;
+
+        private Character enemy;
+
+        private AIObjectiveFindSafety escapeObjective;
+
+        float coolDownTimer;
+
+        private readonly float enemyStrength;
+
+        public AIObjectiveCombat (Character character, Character enemy)
+            : base(character, "")
+        {
+            this.enemy = enemy;
+
+            foreach (Limb limb in enemy.AnimController.Limbs)
+            {
+                if (limb.attack == null) continue;
+                enemyStrength += limb.attack.GetDamage(1.0f);
+            }
+
+            coolDownTimer = CoolDown;
+
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            coolDownTimer -= deltaTime;
+
+            var weapon = character.Inventory.FindItem("weapon");
+            
+            if (weapon==null)
+            {
+                Escape(deltaTime);
+            }
+            else
+            {
+                if (!character.SelectedItems.Contains(weapon))
+                {
+                    character.Inventory.TryPutItem(weapon, 3, false);
+                    weapon.Equip(character);
+                }
+                character.CursorPosition = enemy.Position;
+                character.SetInput(InputType.Aim, false, true);
+
+                Vector2 enemyDiff = Vector2.Normalize(enemy.Position - character.Position);
+                float weaponAngle = ((weapon.body.Dir == 1.0f) ? weapon.body.Rotation : weapon.body.Rotation - MathHelper.Pi);
+                Vector2 weaponDir = new Vector2((float)Math.Cos(weaponAngle), (float)Math.Sin(weaponAngle));
+
+                if (Vector2.Dot(enemyDiff, weaponDir) < 0.9f) return;
+
+                List<FarseerPhysics.Dynamics.Body> ignoredBodies = new List<FarseerPhysics.Dynamics.Body>();
+                foreach (Limb limb in character.AnimController.Limbs)
+                {
+                    ignoredBodies.Add(limb.body.FarseerBody);
+                }
+
+                var pickedBody = Submarine.PickBody(character.SimPosition, enemy.SimPosition, ignoredBodies);
+                if (pickedBody != null && !(pickedBody.UserData is Limb)) return;
+
+               weapon.Use(deltaTime, character);
+            }
+        }
+
+        private void Escape(float deltaTime)
+        {
+            if (escapeObjective == null)
+            {
+                escapeObjective = new AIObjectiveFindSafety(character);
+            }
+            
+            if (enemy.AnimController.CurrentHull == character.AnimController.CurrentHull)
+            {
+                escapeObjective.OverrideCurrentHullSafety = 0.0f;
+            }
+            else
+            {
+                escapeObjective.OverrideCurrentHullSafety = null;
+            }
+
+            escapeObjective.TryComplete(deltaTime);
+
+            //if (Vector2.Distance(character.SimPosition, enemy.SimPosition) < 3.0f)
+            //{
+            //    character.AIController.SteeringManager.SteeringManual(deltaTime, 
+            //        new Vector2(Math.Sign(character.SimPosition.X - enemy.SimPosition.X), 0.0f));            
+            //    coolDownTimer = CoolDown;
+            //}
+        }
+
+        public override bool IsCompleted()
+        {
+            return enemy.IsDead || coolDownTimer <= 0.0f;
+        }
+
+        public override float GetPriority(Character character)
+        {
+            //clamp the strength to the health of this character
+            //(it doesn't make a difference whether the enemy does 200 or 600 damage, it's one hit kill anyway)
+
+            float enemyDanger = Math.Min(enemyStrength, character.Health) + enemy.Health / 10.0f;
+
+            EnemyAIController enemyAI = enemy.AIController as EnemyAIController;
+            if (enemyAI != null)
+            {
+                if (enemyAI.SelectedAiTarget == character.AiTarget) enemyDanger *= 2.0f;
+            }
+
+            return Math.Max(enemyDanger, AIObjectiveManager.OrderPriority);
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveCombat objective = otherObjective as AIObjectiveCombat;
+            if (objective == null) return false;
+
+            return objective.enemy == enemy;
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveContainItem.cs

@@ -0,0 +1,90 @@
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveContainItem: AIObjective
+    {
+        private string itemName;
+
+        private ItemContainer container;
+        
+        bool isCompleted;
+
+        public bool IgnoreAlreadyContainedItems;
+        
+        public AIObjectiveContainItem(Character character, string itemName, ItemContainer container)
+            : base (character, "")
+        {
+            this.itemName = itemName;
+            this.container = container;
+
+            //check if the container has room for more items
+            //canBeCompleted = false;
+            //foreach (Item contained in container.inventory.Items)
+            //{
+            //    if (contained != null) continue;
+            //    canBeCompleted = true;
+            //    break;
+            //}
+        }
+
+        public override bool IsCompleted()
+        {
+            return isCompleted || container.Inventory.FindItem(itemName)!=null;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            if (isCompleted) return;
+
+            //get the item that should be contained
+            var itemToContain = character.Inventory.FindItem(itemName);
+            if (itemToContain == null)
+            {
+                var getItem = new AIObjectiveGetItem(character, itemName);
+                getItem.IgnoreContainedItems = IgnoreAlreadyContainedItems;
+                AddSubObjective(getItem);
+                return;
+            }
+
+            if (container.Item.ParentInventory == character.Inventory)
+            {
+                var containedItems = container.Inventory.Items;
+                //if there's already something in the mask (empty oxygen tank?), drop it
+                var existingItem = containedItems.FirstOrDefault(i => i != null);
+                if (existingItem != null) existingItem.Drop(character);
+                
+                character.Inventory.RemoveItem(itemToContain);
+                container.Inventory.TryPutItem(itemToContain, null);
+            }
+            else
+            {
+                if (Vector2.Distance(character.Position, container.Item.Position) > container.Item.PickDistance
+                    && !container.Item.IsInsideTrigger(character.Position))
+                {
+                    AddSubObjective(new AIObjectiveGoTo(container.Item, character));
+                    return;
+                }
+
+                container.Combine(itemToContain);
+            }
+
+            isCompleted = true;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveContainItem objective = otherObjective as AIObjectiveContainItem;
+            if (objective == null) return false;
+
+            return objective.itemName == itemName && objective.container == container;
+        }
+
+    
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveFindDivingGear.cs

@@ -0,0 +1,89 @@
+using Barotrauma.Items.Components;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveFindDivingGear : AIObjective
+    {
+        private AIObjective subObjective;
+
+        private string gearName;
+
+        public override bool IsCompleted()
+        {
+            var item = character.Inventory.FindItem(gearName);
+            if (item == null) return false;
+
+            var containedItems = item.ContainedItems;
+            var oxygenTank = Array.Find(containedItems, i => i.Name == "Oxygen Tank" && i.Condition > 0.0f);
+            return oxygenTank != null;
+        }
+
+        public AIObjectiveFindDivingGear(Character character, bool needDivingSuit)
+            : base(character, "")
+        {
+            gearName = needDivingSuit ? "Diving Suit" : "diving";
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            var item = character.Inventory.FindItem(gearName);
+            if (item == null)
+            {
+                //get a diving mask/suit first
+                if (!(subObjective is AIObjectiveGetItem))
+                {
+                    subObjective = new AIObjectiveGetItem(character, gearName, true);
+                }
+            }
+            else
+            {
+                var containedItems = item.ContainedItems;
+                if (containedItems == null) return;
+
+                //check if there's an oxygen tank in the mask
+                var oxygenTank = Array.Find(containedItems, i => i.Name == "Oxygen Tank");
+
+                if (oxygenTank != null)
+                {
+                    if (oxygenTank.Condition > 0.0f)
+                    {
+                        return;
+                    }
+                    else
+                    {
+                        oxygenTank.Drop();
+                    }
+                }
+
+
+                if (!(subObjective is AIObjectiveContainItem) || subObjective.IsCompleted())
+                {
+                    subObjective = new AIObjectiveContainItem(character, "Oxygen Tank", item.GetComponent<ItemContainer>());
+                }
+            }
+
+            if (subObjective != null)
+            {
+                subObjective.TryComplete(deltaTime);
+
+                //isCompleted = subObjective.IsCompleted();
+            }
+        }
+
+        public override float GetPriority(Character character)
+        {
+            if (character.AnimController.CurrentHull == null) return 100.0f;
+
+            return 100.0f - character.Oxygen;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            return otherObjective is AIObjectiveFindDivingGear;
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveFindSafety.cs

@@ -0,0 +1,216 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveFindSafety : AIObjective
+    {
+        const float SearchHullInterval = 3.0f;
+        const float MinSafety = 50.0f;
+
+        private AIObjectiveGoTo goToObjective;
+
+        private List<Hull> unreachable;
+
+        private float currenthullSafety;
+
+        private float searchHullTimer;
+
+        private AIObjective divingGearObjective;
+
+        public float? OverrideCurrentHullSafety;
+
+        public AIObjectiveFindSafety(Character character)
+            : base(character, "")
+        {
+            unreachable = new List<Hull>();
+        }
+
+        protected override void Act(float deltaTime)
+        {
+
+            var currentHull = character.AnimController.CurrentHull;
+
+            currenthullSafety = OverrideCurrentHullSafety == null ?
+                GetHullSafety(currentHull, character) : (float)OverrideCurrentHullSafety;
+
+            if (currentHull != null)
+            {
+                if (NeedsDivingGear())
+                {
+                    if (!FindDivingGear(deltaTime)) return;
+                }
+
+                if (currenthullSafety > MinSafety)
+                {
+                    if (Math.Abs(currentHull.WorldPosition.X - character.WorldPosition.X) > 100.0f)
+                    {
+                        character.AIController.SteeringManager.SteeringSeek(currentHull.SimPosition, 0.5f);
+                    }
+                    else
+                    {
+
+                        character.AIController.SteeringManager.Reset();
+                    }
+
+                    character.AIController.SelectTarget(null);
+
+                    goToObjective = null;
+                    return;
+                }
+            }
+
+            if (searchHullTimer > 0.0f)
+            {
+                searchHullTimer -= deltaTime;
+            }
+            else
+            {
+                var bestHull = FindBestHull();
+                if (bestHull != null)
+                {
+                    goToObjective = new AIObjectiveGoTo(bestHull, character);
+                }
+
+                searchHullTimer = SearchHullInterval;
+            }
+
+            if (goToObjective != null)
+            {
+                var pathSteering = character.AIController.SteeringManager as IndoorsSteeringManager;
+                if (pathSteering!=null && pathSteering.CurrentPath!= null && 
+                    pathSteering.CurrentPath.Unreachable && !unreachable.Contains(goToObjective.Target))
+                {
+                    unreachable.Add(goToObjective.Target as Hull);
+                }
+
+
+                goToObjective.TryComplete(deltaTime);
+            }
+        }
+
+        private bool FindDivingGear(float deltaTime)
+        {
+            if (divingGearObjective==null)
+            {
+                divingGearObjective = new AIObjectiveFindDivingGear(character, false);
+            }
+
+            if (divingGearObjective.IsCompleted()) return true;
+
+            divingGearObjective.TryComplete(deltaTime);
+            return divingGearObjective.IsCompleted();
+        }
+
+        private Hull FindBestHull()
+        {
+            Hull bestHull = null;
+            float bestValue = currenthullSafety;
+
+            foreach (Hull hull in Hull.hullList)
+            {
+                if (hull == character.AnimController.CurrentHull || unreachable.Contains(hull)) continue;
+
+                float hullValue = GetHullSafety(hull, character);
+                hullValue -= (float)Math.Sqrt(Math.Abs(character.Position.X - hull.Position.X));
+                hullValue -= (float)Math.Sqrt(Math.Abs(character.Position.Y - hull.Position.Y) * 2.0f);
+
+                if (bestHull == null || hullValue > bestValue)
+                {
+                    bestHull = hull;
+                    bestValue = hullValue;
+                }
+            }
+
+            return bestHull;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            return (otherObjective is AIObjectiveFindSafety);
+        }
+
+        private bool NeedsDivingGear()
+        {
+            var currentHull = character.AnimController.CurrentHull;
+            if (currentHull == null) return true;
+
+            //there's lots of water in the room -> get a suit
+            if (currentHull.Volume / currentHull.FullVolume > 0.5f) return true;
+
+            if (currentHull.OxygenPercentage < 30.0f) return true;
+
+            return false;
+        }
+
+        public override float GetPriority(Character character)
+        {
+            if (character.Oxygen < 80.0f)
+            {
+                return 150.0f - character.Oxygen;
+            }
+
+            if (character.AnimController.CurrentHull == null) return 5.0f;
+            currenthullSafety = GetHullSafety(character.AnimController.CurrentHull, character);
+            priority = 100.0f - currenthullSafety;
+
+            var nearbyHulls = character.AnimController.CurrentHull.GetConnectedHulls(3);
+
+            foreach (Hull hull in nearbyHulls)
+            {
+                foreach (FireSource fireSource in hull.FireSources)
+                {
+                    //increase priority if almost within damage range of a fire
+                    if (character.Position.X > fireSource.Position.X - fireSource.DamageRange * 2 &&
+                        character.Position.X < fireSource.Position.X + fireSource.Size.X + fireSource.DamageRange * 2 &&
+                        character.Position.Y > hull.Rect.Y - hull.Rect.Height &&
+                        character.Position.Y < hull.Rect.Y)
+                    {
+                        priority += Math.Max(fireSource.Size.X, 50.0f);
+                    }
+                }
+            }
+
+
+            if (NeedsDivingGear())
+            {
+                if (divingGearObjective != null && !divingGearObjective.IsCompleted()) priority += 20.0f;
+            }
+           
+            return priority;
+        }
+
+        private static float GetHullSafety(Hull hull, Character character)
+        {
+            if (hull == null) return 0.0f;
+
+            float waterPercentage = (hull.Volume / hull.FullVolume) * 100.0f;
+            float fireAmount = 0.0f;
+
+            var nearbyHulls = hull.GetConnectedHulls(3);
+
+            foreach (Hull hull2 in nearbyHulls)
+            {
+                foreach (FireSource fireSource in hull2.FireSources)
+                {
+                    //increase priority if almost within damage range of a fire
+                    if (character.Position.X > fireSource.Position.X - fireSource.DamageRange * 2 &&
+                        character.Position.X < fireSource.Position.X + fireSource.Size.X + fireSource.DamageRange * 2 &&
+                        character.Position.Y > hull2.Rect.Y - hull2.Rect.Height &&
+                        character.Position.Y < hull2.Rect.Y)
+                    {
+                        fireAmount += Math.Max(fireSource.Size.X, 50.0f);
+                    }
+                }
+            }
+
+            float safety = 100.0f - fireAmount;
+
+            if (waterPercentage > 30.0f && character.OxygenAvailable <= 0.0f) safety -= waterPercentage;
+            if (hull.OxygenPercentage < 30.0f) safety -= (30.0f - hull.OxygenPercentage) * 5.0f;
+
+            return safety;
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveFixLeak.cs

@@ -0,0 +1,98 @@
+using Barotrauma.Items.Components;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveFixLeak : AIObjective
+    {
+        private Gap leak;
+
+        public Gap Leak
+        {
+            get { return leak; }
+        }
+
+        public AIObjectiveFixLeak(Gap leak, Character character)
+            : base (character, "")
+        {
+            this.leak = leak;
+        }
+
+        public override float GetPriority(Character character)
+        {
+            if (leak.Open == 0.0f) return 0.0f;
+
+            float leakSize = (leak.isHorizontal ? leak.Rect.Height : leak.Rect.Width) * Math.Max(leak.Open, 0.1f);
+
+            float dist = Vector2.DistanceSquared(character.SimPosition, leak.SimPosition);
+            dist = Math.Max(dist/100.0f, 1.0f);
+            return Math.Min(leakSize/dist, 40.0f);
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveFixLeak fixLeak = otherObjective as AIObjectiveFixLeak;
+            if (fixLeak == null) return false;
+            return fixLeak.leak == leak;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            var weldingTool = character.Inventory.FindItem("Welding Tool");
+
+            if (weldingTool == null)
+            {
+                subObjectives.Add(new AIObjectiveGetItem(character, "Welding Tool", true));
+                return;
+            }
+            else
+            {
+                var containedItems = weldingTool.ContainedItems;
+                if (containedItems == null) return;
+                
+                var fuelTank = Array.Find(containedItems, i => i.Name == "Welding Fuel Tank" && i.Condition > 0.0f);
+
+                if (fuelTank == null)
+                {
+                    AddSubObjective(new AIObjectiveContainItem(character, "Welding Fuel Tank", weldingTool.GetComponent<ItemContainer>()));
+                }
+            }
+
+            var repairTool = weldingTool.GetComponent<RepairTool>();
+            if (repairTool == null) return;
+
+            if (Vector2.Distance(character.WorldPosition, leak.WorldPosition) > 300.0f)
+            {
+                AddSubObjective(new AIObjectiveGoTo(ConvertUnits.ToSimUnits(GetStandPosition()), character));
+            }
+            else
+            {
+                AddSubObjective(new AIObjectiveOperateItem(repairTool, character, "", leak));
+            }            
+        }
+
+        private Vector2 GetStandPosition()
+        {
+            Vector2 standPos = leak.Position;
+            var hull = leak.FlowTargetHull;
+
+            if (hull == null) return standPos;
+            
+            if (leak.isHorizontal)
+            {
+                standPos += Vector2.UnitX * Math.Sign(hull.Position.X - leak.Position.X) * leak.Rect.Width;
+            }
+            else
+            {
+                standPos += Vector2.UnitY * Math.Sign(hull.Position.Y - leak.Position.Y) * leak.Rect.Height;
+            }
+
+            return standPos;            
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveFixLeaks.cs

@@ -0,0 +1,101 @@
+using System;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveFixLeaks : AIObjective
+    {
+        const float UpdateGapListInterval = 10.0f;
+
+        private float updateGapListTimer;
+
+        private AIObjectiveIdle idleObjective;
+
+        private List<AIObjectiveFixLeak> objectiveList;
+
+        public AIObjectiveFixLeaks(Character character)
+            : base (character, "")
+        {
+            objectiveList = new List<AIObjectiveFixLeak>();
+        }
+
+        public override bool IsCompleted()
+        {
+            return false;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            updateGapListTimer -= deltaTime;
+
+            if (updateGapListTimer<=0.0f)
+            {
+                UpdateGapList();
+
+                updateGapListTimer = UpdateGapListInterval;
+            }
+
+            if (objectiveList.Any())
+            {
+                objectiveList[objectiveList.Count - 1].TryComplete(deltaTime);
+
+                if (!objectiveList[objectiveList.Count - 1].CanBeCompleted ||
+                    objectiveList[objectiveList.Count - 1].IsCompleted())
+                {
+                    objectiveList.RemoveAt(objectiveList.Count - 1);
+                }
+            }
+            else
+            {
+                if (idleObjective == null) idleObjective = new AIObjectiveIdle(character);
+                idleObjective.TryComplete(deltaTime);
+            }
+        }
+
+        private void UpdateGapList()
+        {
+            objectiveList.Clear();
+            
+            foreach (Gap gap in Gap.GapList)
+            {
+                if (gap.ConnectedWall == null) continue;
+                if (gap.ConnectedDoor != null || gap.Open <= 0.0f) continue;
+
+                float gapPriority = GetGapFixPriority(gap);
+
+                int index = 0;
+                while (index < objectiveList.Count &&
+                    GetGapFixPriority(objectiveList[index].Leak) < gapPriority)
+                {
+                    index++;
+                }
+
+                objectiveList.Insert(index, new AIObjectiveFixLeak(gap, character));
+            }
+        }
+
+        private float GetGapFixPriority(Gap gap)
+        {
+            if (gap == null) return 0.0f;
+
+            //larger gap -> higher priority
+            float gapPriority = (gap.isHorizontal ? gap.Rect.Width : gap.Rect.Height) * gap.Open;
+
+            //prioritize gaps that are close
+            gapPriority /= Math.Max(Vector2.Distance(character.WorldPosition, gap.WorldPosition), 1.0f);
+
+            //gaps to outside are much higher priority
+            if (!gap.IsRoomToRoom) gapPriority *= 10.0f;
+
+            return gapPriority;
+
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            return otherObjective is AIObjectiveFixLeaks;
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveGetItem.cs

@@ -0,0 +1,183 @@
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveGetItem : AIObjective
+    {
+        private string itemName;
+
+        private Item targetItem, moveToTarget;
+
+        private int currSearchIndex;
+
+        private bool canBeCompleted;
+
+        public bool IgnoreContainedItems;
+
+        private AIObjectiveGoTo goToObjective;
+
+        private bool equip;
+
+        public override bool CanBeCompleted
+        {
+            get { return canBeCompleted; }
+        }
+
+        public AIObjectiveGetItem(Character character, Item targetItem, bool equip = false)
+            : base(character, "")
+        {
+            canBeCompleted = true;
+
+            this.equip = equip;
+
+            currSearchIndex = 0;
+
+            this.targetItem = targetItem;
+        }
+
+        public AIObjectiveGetItem(Character character, string itemName, bool equip=false)
+            : base (character, "")
+        {
+            canBeCompleted = true;
+
+            this.equip = equip;
+
+            currSearchIndex = 0;
+            
+            this.itemName = itemName;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            FindTargetItem();
+            if (targetItem == null || moveToTarget == null) return;
+
+            if (Vector2.Distance(character.Position, moveToTarget.Position) < targetItem.PickDistance*2.0f)
+            {
+                int targetSlot = -1;
+                if (equip)
+                {
+                    var pickable = targetItem.GetComponent<Pickable>();
+                    if (pickable == null)
+                    {
+                        canBeCompleted = false;
+                        return;
+                    }
+
+                    //check if all the slots required by the item are free
+                    foreach (InvSlotType slots in pickable.AllowedSlots)
+                    {
+                        if (slots.HasFlag(InvSlotType.Any)) continue;
+                            
+                        for (int i = 0; i<character.Inventory.Items.Length; i++)
+                        {
+                            //slot not needed by the item, continue
+                            if (!slots.HasFlag(CharacterInventory.limbSlots[i])) continue;
+
+                            targetSlot = i;
+
+                            //slot free, continue
+                            if (character.Inventory.Items[i] == null) continue;
+
+                            //try to move the existing item to LimbSlot.Any and continue if successful
+                            if (character.Inventory.TryPutItem(character.Inventory.Items[i], new List<InvSlotType>() { InvSlotType.Any })) continue;
+
+                            //if everything else fails, simply drop the existing item
+                            character.Inventory.Items[i].Drop();
+                        }
+                    }
+                }
+
+                targetItem.Pick(character, false, true);
+
+                if (targetSlot > -1 && character.Inventory.IsInLimbSlot(targetItem, InvSlotType.Any))
+                {
+                    character.Inventory.TryPutItem(targetItem, targetSlot, false);
+                }
+            }
+            else
+            {
+                if (goToObjective == null) 
+                {
+                    bool gettingDivingGear = itemName == "diving" || itemName == "Diving Gear";
+                    goToObjective = new AIObjectiveGoTo(moveToTarget, character, false, !gettingDivingGear);
+                }
+
+                goToObjective.TryComplete(deltaTime);
+            }
+            
+        }
+
+        /// <summary>
+        /// searches for an item that matches the desired item and adds a goto subobjective if one is found
+        /// </summary>
+        private void FindTargetItem()
+        {
+            if (itemName == null)
+            {
+                if (targetItem == null) canBeCompleted = false;
+                return;
+            }
+
+            float currDist = moveToTarget == null ? 0.0f : Vector2.DistanceSquared(moveToTarget.Position, character.Position);
+            
+            for (int i = 0; i < 10 && currSearchIndex < Item.ItemList.Count - 2; i++)
+            {
+                currSearchIndex++;
+
+                var item = Item.ItemList[currSearchIndex];
+
+                if (item.CurrentHull == null || item.Condition <= 0.0f) continue;
+                if (IgnoreContainedItems && item.Container != null) continue;
+                if (item.Name != itemName && !item.HasTag(itemName)) continue;
+
+                //if the item is inside a character's inventory, don't steal it
+                if (item.ParentInventory is CharacterInventory) continue;
+
+                //if the item is inside an item, which is inside a character's inventory, don't steal it
+                if (item.ParentInventory != null && item.ParentInventory.Owner is Item)
+                {
+                    if (((Item)item.ParentInventory.Owner).ParentInventory is CharacterInventory) continue;
+                }
+
+                //ignore if item is further away than the currently targeted item
+                Item rootContainer = item.GetRootContainer();
+                if (moveToTarget != null && Vector2.DistanceSquared((rootContainer ?? item).Position, character.Position) > currDist) continue;
+                
+                targetItem = item;
+                moveToTarget = rootContainer ?? item;
+            }
+
+            //if searched through all the items and a target wasn't found, can't be completed
+            if (currSearchIndex >= Item.ItemList.Count && targetItem == null) canBeCompleted = false;
+        }
+                
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveGetItem getItem = otherObjective as AIObjectiveGetItem;
+            if (getItem == null) return false;
+            return (getItem.itemName == itemName);
+        }
+
+        public override bool IsCompleted()
+        {
+            if (itemName!=null)
+            {
+                return character.Inventory.FindItem(itemName) != null;
+            }
+            else if (targetItem!= null)
+            {
+                return character.Inventory.Items.Contains(targetItem);
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveGoTo.cs

@@ -0,0 +1,150 @@
+using Barotrauma.Items.Components;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    class AIObjectiveGoTo : AIObjective
+    {
+        private Entity target;
+
+        private Vector2 targetPos;
+
+        private bool repeat;
+
+        //how long until the path to the target is declared unreachable
+        private float waitUntilPathUnreachable;
+
+        private bool getDivingGearIfNeeded;
+
+        public override bool CanBeCompleted
+        {
+            get
+            {
+                if (repeat || waitUntilPathUnreachable > 0.0f) return true;
+                var pathSteering = character.AIController.SteeringManager as IndoorsSteeringManager;
+
+                //path doesn't exist (= hasn't been searched for yet), assume for now that the target is reachable
+                if (pathSteering.CurrentPath == null) return true;
+
+                return (!pathSteering.CurrentPath.Unreachable);
+            }
+        }
+
+        public Entity Target
+        {
+            get { return target; }
+        }
+
+        public AIObjectiveGoTo(Entity target, Character character, bool repeat = false, bool getDivingGearIfNeeded = true)
+            : base (character, "")
+        {
+            this.target = target;
+            this.repeat = repeat;
+
+            waitUntilPathUnreachable = 5.0f;
+            this.getDivingGearIfNeeded = getDivingGearIfNeeded;
+        }
+
+
+        public AIObjectiveGoTo(Vector2 simPos, Character character, bool repeat = false, bool getDivingGearIfNeeded = true)
+            : base(character, "")
+        {
+            this.targetPos = simPos;
+            this.repeat = repeat;
+
+            waitUntilPathUnreachable = 5.0f;
+            this.getDivingGearIfNeeded = getDivingGearIfNeeded;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            if (target == character)
+            {
+                character.AIController.SteeringManager.Reset();
+
+                return;
+            }
+
+            waitUntilPathUnreachable -= deltaTime;
+
+            if (character.SelectedConstruction!=null && character.SelectedConstruction.GetComponent<Ladder>()==null)
+            {
+                character.SelectedConstruction = null;
+            }
+
+            if (target != null) character.AIController.SelectTarget(target.AiTarget);
+
+            Vector2 currTargetPos = Vector2.Zero;
+
+            if (target == null)
+            {
+                currTargetPos = targetPos;
+            }
+            else
+            {
+                currTargetPos = target.SimPosition;
+                
+                //if character is outside the sub and target isn't, transform the position
+                if (character.Submarine != null && target.Submarine == null)
+                {
+                    currTargetPos -= character.Submarine.SimPosition;
+                }
+            }
+
+            if (Vector2.Distance(currTargetPos, character.SimPosition) < 1.0f)
+            {
+                character.AIController.SteeringManager.Reset();
+                character.AnimController.TargetDir = currTargetPos.X > character.SimPosition.X ? Direction.Right : Direction.Left;
+            }
+            else
+            {
+                character.AIController.SteeringManager.SteeringSeek(currTargetPos);
+
+                var indoorsSteering = character.AIController.SteeringManager as IndoorsSteeringManager;
+
+                if (indoorsSteering.CurrentPath==null || indoorsSteering.CurrentPath.Unreachable)
+                {
+                    indoorsSteering.SteeringWander();
+                }
+                else if (getDivingGearIfNeeded && indoorsSteering.CurrentPath != null && indoorsSteering.CurrentPath.HasOutdoorsNodes)
+                {
+                    AddSubObjective(new AIObjectiveFindDivingGear(character, true));
+                }
+            }
+        }
+
+        public override bool IsCompleted()
+        {
+            if (repeat) return false;
+
+            bool completed = false;
+
+            float allowedDistance = 0.5f;
+            var item = target as Item;
+
+            if (item != null)
+            {
+                allowedDistance = Math.Max(ConvertUnits.ToSimUnits(item.PickDistance), allowedDistance);
+                if (item.IsInsideTrigger(character.WorldPosition)) completed = true;
+            }
+
+            completed = completed || Vector2.Distance(target != null ? target.SimPosition : targetPos, character.SimPosition) < allowedDistance;
+
+            if (completed) character.AIController.SteeringManager.Reset();
+
+            return completed;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveGoTo objective = otherObjective as AIObjectiveGoTo;
+            if (objective == null) return false;
+
+            if (objective.target == target) return true;
+
+            return (objective.targetPos == targetPos);
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveIdle.cs

@@ -0,0 +1,149 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveIdle : AIObjective
+    {
+        const float WallAvoidDistance = 150.0f;
+
+        AITarget currentTarget;
+        private float newTargetTimer;
+
+        public AIObjectiveIdle(Character character) : base(character, "")
+        {
+
+        }
+
+        public override float GetPriority(Character character)
+        {
+            return 1.0f;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+
+            var pathSteering = character.AIController.SteeringManager as IndoorsSteeringManager;
+
+            if (pathSteering==null)
+            {
+                return;
+            }
+
+            if (newTargetTimer <= 0.0f)
+            {
+                currentTarget = FindRandomTarget();
+
+                if (currentTarget != null)
+                {
+                    Vector2 pos = character.SimPosition;
+                    if (character != null && character.Submarine == null) pos -= Submarine.MainSub.SimPosition;
+                    
+                    var path = pathSteering.PathFinder.FindPath(pos, currentTarget.SimPosition);
+                    if (path.Cost > 200.0f && character.AnimController.CurrentHull!=null) return;
+
+                    pathSteering.SetPath(path);
+                }
+
+
+                newTargetTimer = currentTarget == null ? 5.0f : 15.0f;
+            }
+            
+            newTargetTimer -= deltaTime;
+
+                  
+            //wander randomly 
+            // - if reached the end of the path 
+            // - if the target is unreachable
+            // - if the path requires going outside
+            if (pathSteering==null || (pathSteering.CurrentPath != null && 
+                (pathSteering.CurrentPath.NextNode == null || pathSteering.CurrentPath.Unreachable || pathSteering.CurrentPath.HasOutdoorsNodes)))
+            {
+                //steer away from edges of the hull
+                if (character.AnimController.CurrentHull!=null)
+                {
+                    float leftDist = character.Position.X - character.AnimController.CurrentHull.Rect.X;
+                    float rightDist = character.AnimController.CurrentHull.Rect.Right - character.Position.X;
+
+                    if (leftDist < WallAvoidDistance && rightDist < WallAvoidDistance)
+                    {
+                        if (Math.Abs(rightDist - leftDist) > WallAvoidDistance / 2)
+                        {
+                            pathSteering.SteeringManual(deltaTime, Vector2.UnitX * Math.Sign(rightDist - leftDist));
+                        }
+                        else
+                        {
+                            pathSteering.Reset();
+                            return;
+                        }
+                    }
+                    else if (leftDist < WallAvoidDistance)
+                    {
+                        pathSteering.SteeringManual(deltaTime, Vector2.UnitX * (WallAvoidDistance-leftDist)/WallAvoidDistance);
+                        pathSteering.WanderAngle = 0.0f;
+                        return;
+                    }
+                    else if (rightDist < WallAvoidDistance)
+                    {
+                        pathSteering.SteeringManual(deltaTime, -Vector2.UnitX * (WallAvoidDistance-rightDist)/WallAvoidDistance);
+                        pathSteering.WanderAngle = MathHelper.Pi;
+                        return;
+                    }
+                }
+
+                if (character.AnimController.InWater)
+                {
+                    character.AIController.SteeringManager.SteeringManual(deltaTime, new Vector2(0.0f, 0.5f));
+                }
+                else
+                {
+                    character.AIController.SteeringManager.SteeringWander();
+                    //reset vertical steering to prevent dropping down from platforms etc
+                    character.AIController.SteeringManager.ResetY();
+                }
+
+                return;                
+            }
+ 
+            if (currentTarget == null) return;
+            character.AIController.SteeringManager.SteeringSeek(currentTarget.SimPosition, 2.0f);
+        }
+
+        private AITarget FindRandomTarget()
+        {
+            if (Rand.Int(5)==1)
+            {
+                var idCard = character.Inventory.FindItem("ID Card");
+                if (idCard==null) return null;
+
+                foreach (WayPoint wp in WayPoint.WayPointList)
+                {
+                    if (wp.SpawnType != SpawnType.Human || wp.CurrentHull==null) continue;
+                 
+                    foreach (string tag in wp.IdCardTags)
+                    {
+                        if (idCard.HasTag(tag)) return wp.CurrentHull.AiTarget;
+                    }
+                }
+            }
+            else
+            {
+                List<Hull> targetHulls = new List<Hull>(Hull.hullList);
+                //ignore all hulls with fires or water in them
+                targetHulls.RemoveAll(h => h.FireSources.Any() || (h.Volume/h.FullVolume)>0.1f);
+                if (!targetHulls.Any()) return null;
+
+                return targetHulls[Rand.Range(0, targetHulls.Count)].AiTarget;
+            }
+
+            return null;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            return (otherObjective is AIObjectiveIdle);
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveManager.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class AIObjectiveManager
+    {
+        public const float OrderPriority = 50.0f;
+
+        private List<AIObjective> objectives;
+
+        private Character character;
+
+        private AIObjective currentObjective;
+        
+        public AIObjective CurrentObjective
+        {
+            get
+            {
+                if (currentObjective != null) return currentObjective;
+                return objectives.Any() ? objectives[0] : null;
+            }
+        }
+
+        public AIObjectiveManager(Character character)
+        {
+            this.character = character;
+
+            objectives = new List<AIObjective>();
+        }
+
+        public void AddObjective(AIObjective objective)
+        {
+            if (objectives.Find(o => o.IsDuplicate(objective)) != null) return;
+
+            objectives.Add(objective);
+        }
+
+        public float GetCurrentPriority(Character character)
+        {
+            if (currentObjective != null) return OrderPriority;
+            return (CurrentObjective == null) ? 0.0f : CurrentObjective.GetPriority(character);
+        }
+
+        public void UpdateObjectives()
+        {
+            if (!objectives.Any()) return;
+
+            //remove completed objectives and ones that can't be completed
+            objectives = objectives.FindAll(o => !o.IsCompleted() && o.CanBeCompleted);
+
+            //sort objectives according to priority
+            objectives.Sort((x, y) => y.GetPriority(character).CompareTo(x.GetPriority(character)));
+        }
+
+        public void DoCurrentObjective(float deltaTime)
+        {
+            if (currentObjective != null && (!objectives.Any() || objectives[0].GetPriority(character) < OrderPriority))
+            {
+                currentObjective.TryComplete(deltaTime);
+                return;
+            }
+
+            if (!objectives.Any()) return;
+            objectives[0].TryComplete(deltaTime);
+        }
+
+        public void SetOrder(Order order, string option)
+        {
+            if (order == null) return;
+
+            currentObjective = null;
+
+            switch (order.Name.ToLowerInvariant())
+            {
+                case "follow":
+                    currentObjective = new AIObjectiveGoTo(Character.Controlled, character, true);
+                    break;
+                case "wait":
+                    currentObjective = new AIObjectiveGoTo(character, character, true);
+                    break;
+                case "fixleaks":
+                case "fix leaks":
+                    currentObjective = new AIObjectiveFixLeaks(character);
+                    break;
+                default:
+                    if (order.TargetItem == null) return;
+
+                    currentObjective = new AIObjectiveOperateItem(order.TargetItem, character, option, null, order.UseController);
+
+                    break;
+            }
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveOperateItem.cs

@@ -0,0 +1,96 @@
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveOperateItem : AIObjective
+    {
+        private ItemComponent component, controller;
+
+        private Entity operateTarget;
+
+        private bool isCompleted;
+
+        private bool canBeCompleted;
+
+        public override bool CanBeCompleted
+        {
+            get
+            {
+                return canBeCompleted;
+            }
+        }
+
+        public Entity OperateTarget
+        {
+            get { return operateTarget; }
+        }
+
+        public AIObjectiveOperateItem(ItemComponent item, Character character, string option, Entity operateTarget = null, bool useController = false)
+            :base (character, option)
+        {
+            this.component = item;
+
+            this.operateTarget = operateTarget;
+
+            if (useController)
+            {
+                var controllers = item.Item.GetConnectedComponents<Controller>();
+                if (controllers.Any()) controller = controllers[0];
+            }
+
+
+            canBeCompleted = true;
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            ItemComponent target = controller == null ? component : controller;
+
+            if (target.CanBeSelected)
+            { 
+                if (Vector2.Distance(character.Position, target.Item.Position) < target.Item.PickDistance
+                    || target.Item.IsInsideTrigger(character.WorldPosition))
+                {
+                    if (character.SelectedConstruction != target.Item && target.CanBeSelected)
+                    {
+                        target.Item.Pick(character, false, true);
+                    }
+
+                    if (component.AIOperate(deltaTime, character, this)) isCompleted = true;
+                    return;
+                }
+
+                AddSubObjective(new AIObjectiveGoTo(target.Item, character));
+            }
+            else
+            {
+                if (!character.Inventory.Items.Contains(component.Item))
+                {
+                    AddSubObjective(new AIObjectiveGetItem(character, component.Item, true));
+                }
+                else
+                {
+                    if (component.AIOperate(deltaTime, character, this)) isCompleted = true;
+                }
+            }
+        }
+
+        public override bool IsCompleted()
+        {
+            return isCompleted;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveOperateItem operateItem = otherObjective as AIObjectiveOperateItem;
+            if (operateItem == null) return false;
+
+            return (operateItem.component == component);
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveRescue.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    class AIObjectiveRescue : AIObjective
+    {
+        private readonly Character targetCharacter;
+
+        public AIObjectiveRescue(Character character, Character targetCharacter)
+            : base (character, "")
+        {
+            Debug.Assert(character != targetCharacter);
+
+            this.targetCharacter = targetCharacter;
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            AIObjectiveRescue rescueObjective = otherObjective as AIObjectiveRescue;
+            return rescueObjective != null && rescueObjective.targetCharacter == targetCharacter;
+        }
+
+        public override float GetPriority(Character character)
+        {
+            if (targetCharacter.AnimController.CurrentHull == null) return 0.0f;
+
+            float distance = Vector2.DistanceSquared(character.WorldPosition, targetCharacter.WorldPosition);
+
+            return targetCharacter.IsDead ? 1000.0f / distance : 10000.0f / distance;
+        }
+
+    }
+}

BarotraumaShared/Source/Characters/AI/Objectives/AIObjectiveRescureAll.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma
+{
+    class AIObjectiveRescueAll : AIObjective
+    {
+        private List<Character> rescueTargets;
+        
+        public AIObjectiveRescueAll(Character character)
+            : base (character, "")
+        {
+            rescueTargets = new List<Character>();
+        }
+
+        public override bool IsDuplicate(AIObjective otherObjective)
+        {
+            return true;
+        }
+
+        public override float GetPriority(Character character)
+        {
+            GetRescueTargets();
+
+            //if there are targets to rescue, the priority is slightly less 
+            //than the priority of explicit orders given to the character
+            return rescueTargets.Any() ? AIObjectiveManager.OrderPriority - 5.0f : 0.0f;
+        }
+
+        private void GetRescueTargets()
+        {
+            rescueTargets = Character.CharacterList.FindAll(c => 
+                c.AIController is HumanAIController &&
+                c != character &&
+                (c.IsDead || c.IsUnconscious) &&
+                c.AnimController.CurrentHull != null &&
+                AIObjectiveFindSafety.GetHullSafety(c.AnimController.CurrentHull, c) < 50.0f);
+        }
+
+        protected override void Act(float deltaTime)
+        {
+            foreach (Character target in rescueTargets)
+            {
+                AddSubObjective(new AIObjectiveRescue(character, target));
+            }
+        }
+    }
+}

BarotraumaShared/Source/Characters/AI/Order.cs

@@ -0,0 +1,139 @@
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class Order
+    {
+        private static string ConfigFile = Path.Combine("Content", "Orders.xml");
+
+        public static List<Order> PrefabList;
+
+        public readonly string Name;
+        public readonly string DoingText;
+
+        public readonly Sprite SymbolSprite;
+
+        public readonly Type ItemComponentType;
+        public readonly string ItemName;
+
+        public readonly Color Color;
+
+        public readonly bool UseController;
+
+        public ItemComponent TargetItem;
+
+        public readonly string[] Options;
+
+        static Order()
+        {
+            PrefabList = new List<Order>();
+
+            XDocument doc = ToolBox.TryLoadXml(ConfigFile);
+            if (doc == null || doc.Root == null) return;
+
+            foreach (XElement orderElement in doc.Root.Elements())
+            {
+                if (orderElement.Name.ToString().ToLowerInvariant() != "order") continue;
+
+                PrefabList.Add(new Order(orderElement));
+            }
+
+            //PrefabList.Add(new Order("Follow", "Following"));
+
+            //PrefabList.Add(new Order("Dismiss", "Dismissed"));
+
+            //PrefabList.Add(new Order("Wait", "Wait"));
+
+            //PrefabList.Add(new Order("Operate Reactor", "Operating reactor", typeof(Reactor), new string[] {"Power up", "Shutdown"}));
+            //PrefabList.Add(new Order("Operate Railgun", "Operating railgun", typeof(Turret), new string[] { "Fire at will", "Hold fire" }));
+
+
+        }
+
+        private Order(XElement orderElement)
+        {
+            Name = ToolBox.GetAttributeString(orderElement, "name", "Name not found");
+            DoingText = ToolBox.GetAttributeString(orderElement, "doingtext", "");
+
+            string targetItemName = ToolBox.GetAttributeString(orderElement, "targetitemtype", "");
+
+            if (!string.IsNullOrWhiteSpace(targetItemName))
+            {
+                try
+                {
+                    ItemComponentType = Type.GetType("Barotrauma.Items.Components." + targetItemName, true, true);
+                }
+
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError("Error in " + ConfigFile + ", item component type " + targetItemName + " not found", e);
+                }
+            }
+
+            ItemName = ToolBox.GetAttributeString(orderElement, "targetitemname", "");
+
+            Color = new Color(ToolBox.GetAttributeVector4(orderElement, "color", new Vector4(1.0f, 1.0f, 1.0f, 1.0f)));
+
+            UseController = ToolBox.GetAttributeBool(orderElement, "usecontroller", false);
+
+            string optionStr = ToolBox.GetAttributeString(orderElement, "options", "");
+
+            if (string.IsNullOrWhiteSpace(optionStr))
+            {
+                Options = new string[0];
+            }
+            else
+            {
+                Options = optionStr.Split(',');
+
+                for (int i = 0; i<Options.Length; i++)
+                {
+                    Options[i] = Options[i].Trim();
+                }
+            }
+
+
+
+            foreach (XElement subElement in orderElement.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "sprite") continue;
+                SymbolSprite = new Sprite(subElement);
+                break;
+            }
+        }
+
+        private Order(string name, string doingText, Type itemComponentType, string[] parameters = null)
+        {
+            Name = name;
+            DoingText = doingText;
+            ItemComponentType = itemComponentType;
+            Options = parameters == null ? new string[0] : parameters;
+        }
+
+        public Order(Order prefab, ItemComponent targetItem)
+        {
+            Name                = prefab.Name;
+            DoingText           = prefab.DoingText;
+            ItemComponentType   = prefab.ItemComponentType;
+            Options             = prefab.Options;
+            SymbolSprite        = prefab.SymbolSprite;
+            Color               = prefab.Color;
+            UseController       = prefab.UseController;
+
+            TargetItem = targetItem;
+        }
+
+        private Order(string name, string doingText, string[] parameters = null)
+            :this (name,doingText, null, parameters)
+        {
+        }
+    }
+
+}

BarotraumaShared/Source/Characters/AI/PathFinder.cs

@@ -0,0 +1,387 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class PathNode
+    {
+        private WayPoint wayPoint;
+
+        private int wayPointID;
+
+        public int state;
+
+        public PathNode Parent;
+        
+        private Vector2 position;
+
+        public float F,G,H;
+
+        public List<PathNode> connections;
+        public List<float> distances;
+        
+        public WayPoint Waypoint
+        {
+            get { return wayPoint; }
+        }
+
+        public Vector2 Position
+        {
+            get {return position;}
+        }
+
+        public PathNode(WayPoint wayPoint)
+        {
+            this.wayPoint = wayPoint;
+            this.position = wayPoint.SimPosition;
+            wayPointID = wayPoint.ID;
+
+            connections = new List<PathNode>();
+        }
+
+        public static List<PathNode> GenerateNodes(List<WayPoint> wayPoints)
+        {
+            var nodes = new Dictionary<int, PathNode>();
+            foreach (WayPoint wayPoint in wayPoints)
+            {
+                if (wayPoint == null) continue;
+                if (nodes.ContainsKey(wayPoint.ID))
+                {
+                    DebugConsole.ThrowError("Error in PathFinder.GenerateNodes (duplicate ID \"" + wayPoint.ID + "\")");
+                    continue;
+                }
+                nodes.Add(wayPoint.ID, new PathNode(wayPoint));
+            }
+
+            foreach (KeyValuePair<int,PathNode> node in nodes)
+            {
+                foreach (MapEntity linked in node.Value.wayPoint.linkedTo)
+                {
+                    PathNode connectedNode = null;
+                    nodes.TryGetValue(linked.ID, out connectedNode);
+                    if (connectedNode == null) continue;
+
+                    node.Value.connections.Add(connectedNode);                    
+                }
+            }
+
+            var nodeList = nodes.Values.ToList();
+            nodeList.RemoveAll(n => n.connections.Count == 0);
+            foreach (PathNode node in nodeList)
+            {
+                node.distances = new List<float>();
+                for (int i = 0; i< node.connections.Count; i++)
+                {
+                    node.distances.Add(Vector2.Distance(node.position, node.connections[i].position));
+                }                
+            }
+
+            return nodeList;            
+        }
+    }
+
+    class PathFinder
+    {
+        public delegate float? GetNodePenaltyHandler(PathNode node, PathNode prevNode);
+        public GetNodePenaltyHandler GetNodePenalty;
+
+        private List<PathNode> nodes;
+
+        private bool insideSubmarine;
+
+        public PathFinder(List<WayPoint> wayPoints, bool insideSubmarine = false)
+        {
+            nodes = PathNode.GenerateNodes(wayPoints.FindAll(w => w.MoveWithLevel != insideSubmarine));
+
+            foreach (WayPoint wp in wayPoints)
+            {
+                wp.linkedTo.CollectionChanged += WaypointLinksChanged;
+            }
+
+            this.insideSubmarine = insideSubmarine;
+        }
+
+        void WaypointLinksChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            if (Submarine.Unloading) return;
+
+            var waypoints = sender as IEnumerable<MapEntity>;
+
+            foreach (MapEntity me in waypoints)
+            {
+                WayPoint wp = me as WayPoint;
+                if (me == null) continue;
+
+                var node = nodes.Find(n => n.Waypoint == wp);
+                if (node == null) return;
+
+                if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
+                {
+                    for (int i = node.connections.Count - 1; i >= 0; i--)
+                    {
+                        //remove connection if the waypoint isn't connected anymore
+                        if (wp.linkedTo.FirstOrDefault(l => l == node.connections[i].Waypoint) == null)
+                        {
+                            node.connections.RemoveAt(i);
+                            node.distances.RemoveAt(i);
+                        }
+                    }
+                }
+                else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
+                {
+                    for (int i = 0; i < wp.linkedTo.Count; i++)
+                    {
+                        WayPoint connected = wp.linkedTo[i] as WayPoint;
+                        if (connected == null) continue;
+
+                        //already connected, continue
+                        if (node.connections.Any(n => n.Waypoint == connected)) continue;
+
+                        var matchingNode = nodes.Find(n => n.Waypoint == connected);
+                        if (matchingNode == null)
+                        {
+#if DEBUG
+                            DebugConsole.ThrowError("Waypoint connections were changed, no matching path node found in PathFinder");
+#endif
+                            return;
+                        }
+
+                        node.connections.Add(matchingNode);
+                        node.distances.Add(Vector2.Distance(node.Position, matchingNode.Position));
+                    }
+                }
+            }
+        }
+
+        public SteeringPath FindPath(Vector2 start, Vector2 end)
+        {
+            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
+            sw.Start();
+            
+            float closestDist = 0.0f;
+            PathNode startNode = null;
+            foreach (PathNode node in nodes)
+            {
+                Vector2 nodePos = node.Position;
+                
+                float dist = System.Math.Abs(start.X - nodePos.X) +
+                    System.Math.Abs(start.Y - nodePos.Y) * 10.0f; //higher cost for vertical movement
+
+                //prefer nodes that are closer to the end position
+                dist += Vector2.Distance(end, nodePos) / 10.0f;
+
+                if (dist<closestDist || startNode==null)
+                {
+                    //if searching for a path inside the sub, make sure the waypoint is visible
+                    if (insideSubmarine)
+                    {
+                        var body = Submarine.PickBody(
+                            start, node.Waypoint.SimPosition, null, 
+                            Physics.CollisionWall | Physics.CollisionLevel | Physics.CollisionStairs | Physics.CollisionPlatform);
+
+                        if (body != null)
+                        {
+                            if (body.UserData is Structure && !((Structure)body.UserData).IsPlatform) continue;
+                            if (body.UserData is Item && body.FixtureList[0].CollisionCategories.HasFlag(Physics.CollisionWall)) continue;
+
+                        }
+                    }
+
+                    closestDist = dist;
+                    startNode = node;
+                }
+            }
+
+            if (startNode == null)
+            {
+                DebugConsole.NewMessage("Pathfinding error, couldn't find a start node", Color.DarkRed);
+
+                return new SteeringPath();
+            }
+            
+            closestDist = 0.0f;
+            PathNode endNode = null;
+            foreach (PathNode node in nodes)
+            {
+                Vector2 nodePos = node.Position;
+
+                float dist = Vector2.Distance(end, nodePos);
+                if (dist < closestDist || endNode == null)
+                {
+                    //if searching for a path inside the sub, make sure the waypoint is visible
+                    if (insideSubmarine)
+                    {
+                        var body = Submarine.CheckVisibility(end, node.Waypoint.SimPosition);
+                        if (body != null && body.UserData is Structure) continue;
+                    }
+
+                    closestDist = dist;
+                    endNode = node;
+                }
+            }
+
+            if (endNode == null)
+            {
+                DebugConsole.NewMessage("Pathfinding error, couldn't find an end node", Color.DarkRed);
+                return new SteeringPath();
+            }
+
+
+            var path =  FindPath(startNode,endNode);
+
+            sw.Stop();
+            System.Diagnostics.Debug.WriteLine("findpath: " + sw.ElapsedMilliseconds+" ms");
+
+            return path;
+        }
+
+        public SteeringPath FindPath(WayPoint start, WayPoint end)
+        {
+            PathNode startNode=null, endNode=null;
+            foreach (PathNode node in nodes)
+            {
+                if (node.Waypoint == start)
+                {
+                    startNode = node;
+                    if (endNode != null) break;
+                }
+                if (node.Waypoint == end)
+                {
+                    endNode = node;
+                    if (startNode != null) break;
+                }
+            }
+
+
+            if (startNode == null || endNode == null)
+            {
+                DebugConsole.NewMessage("Pathfinding error, couldn't find matching pathnodes to waypoints", Color.DarkRed);
+                return new SteeringPath();
+            }
+
+            return FindPath(startNode, endNode);
+        }
+
+        private SteeringPath FindPath(PathNode start, PathNode end)
+        {
+            if (start == end)
+            {
+                var path1 = new SteeringPath();
+                path1.AddNode(start.Waypoint);
+
+                return path1;
+            }
+
+            foreach (PathNode node in nodes)
+            {
+                node.state = 0;
+                node.F = 0.0f;
+                node.G = 0.0f;
+                node.H = 0.0f;
+            }
+              
+            start.state = 1;
+            while (true)
+            {
+
+                PathNode currNode = null;
+                float dist = 10000.0f;
+                foreach (PathNode node in nodes)
+                {
+                    if (node.state != 1) continue;
+                    if (node.F < dist)
+                    {
+                        dist = node.F;
+                        currNode = node;
+                    }
+                }
+
+                if (currNode == null || currNode == end) break;
+
+                currNode.state = 2;
+
+                for (int i = 0; i < currNode.connections.Count; i++)
+                {
+                    PathNode nextNode = currNode.connections[i];
+                    
+                    //a node that hasn't been searched yet
+                    if (nextNode.state==0)
+                    {
+                        nextNode.H = Vector2.Distance(nextNode.Position,end.Position);
+
+                        if (GetNodePenalty != null)
+                        {
+                            float? nodePenalty =GetNodePenalty(currNode, nextNode);
+                            if (nodePenalty == null)
+                            {
+                                nextNode.state = -1;
+                                continue;
+                            }
+                            nextNode.H += (float)nodePenalty;
+                        }
+
+                        nextNode.G = currNode.G + currNode.distances[i];
+                        nextNode.F = nextNode.G + nextNode.H;
+                        nextNode.Parent = currNode;
+                        nextNode.state = 1;
+                    }
+                    //node that has been searched
+                    else if (nextNode.state==1)
+                    {
+                        float tempG = currNode.G + currNode.distances[i];
+                        //only use if this new route is better than the 
+                        //route the node was a part of
+                        if (tempG < nextNode.G)
+                        {
+                            nextNode.G = tempG;
+                            nextNode.F = nextNode.G + nextNode.H;
+                            nextNode.Parent = currNode;
+                        }
+                    }
+                }
+            }
+
+            if (end.state == 0 || end.Parent == null)
+            {
+                //path not found
+                return new SteeringPath(true);
+            }
+
+            SteeringPath path = new SteeringPath();
+            List<WayPoint> finalPath = new List<WayPoint>();
+
+            PathNode pathNode = end;
+            while (pathNode != start && pathNode != null)
+            {
+                finalPath.Add(pathNode.Waypoint);
+
+                //there was one bug report that seems to have been caused by this loop never terminating:
+                //couldn't reproduce or figure out what caused it, but here's a workaround that prevents the game from crashing in case it happens again
+                if (finalPath.Count > nodes.Count)
+                {
+                    DebugConsole.ThrowError("Pathfinding error: constructing final path failed");
+                    return new SteeringPath(true);
+                }
+
+                path.Cost += pathNode.F;
+                pathNode = pathNode.Parent;
+            }
+
+            finalPath.Add(start.Waypoint);
+
+            finalPath.Reverse();
+
+            foreach (WayPoint wayPoint in finalPath)
+            {
+                path.AddNode(wayPoint);
+            }
+            
+                
+            return path;
+        }
+    }
+}
+
+
+

BarotraumaShared/Source/Characters/AI/SteeringManager.cs

@@ -0,0 +1,190 @@
+using System;
+using Microsoft.Xna.Framework;
+using FarseerPhysics.Dynamics;
+
+namespace Barotrauma
+{
+    class SteeringManager
+    {
+        protected const float CircleDistance = 2.5f;
+        protected const float CircleRadius = 0.3f;
+
+        protected const float RayCastInterval = 0.5f;
+
+        protected ISteerable host;
+
+        private Vector2 steering;
+
+        //the steering amount when avoiding obstacles
+        //(needs a separate variable because it's only updated when a raycast is done to detect any nearby obstacles)
+        private Vector2 avoidSteering;
+        private float rayCastTimer;
+
+        private float wanderAngle;        
+        
+        public float WanderAngle
+        {
+            get { return wanderAngle; }
+            set { wanderAngle = value; }
+        }
+
+        public SteeringManager(ISteerable host)
+        {
+            this.host = host;
+
+            wanderAngle = Rand.Range(0.0f, MathHelper.TwoPi);
+        }
+
+        public void SteeringSeek(Vector2 targetSimPos, float speed = 1.0f)
+        {
+            steering += DoSteeringSeek(targetSimPos, speed);
+        }
+
+        public void SteeringWander(float speed = 1.0f)
+        {
+            steering += DoSteeringWander(speed);
+        }
+
+        public void SteeringAvoid(float deltaTime, float speed)
+        {
+            steering += DoSteeringAvoid(deltaTime, speed);
+        }
+
+        public void SteeringManual(float deltaTime, Vector2 velocity)
+        {
+            steering += velocity;
+        }
+
+        public void Reset()
+        {
+            steering = Vector2.Zero;
+        }
+
+        public void ResetX()
+        {
+            steering.X = 0.0f;
+        }
+
+        public void ResetY()
+        {
+            steering.Y = 0.0f;
+        }
+
+        public virtual void Update(float speed = 1.0f)
+        {
+            if (steering == Vector2.Zero || !MathUtils.IsValid(steering))
+            {
+                steering = Vector2.Zero;
+                host.Steering = Vector2.Zero;
+                return;
+            }
+
+            float steeringSpeed = steering.Length();
+            if (steeringSpeed>speed)
+            {
+               steering = Vector2.Normalize(steering) * Math.Abs(speed);
+            }
+
+            host.Steering = steering;
+        }
+
+        protected virtual Vector2 DoSteeringSeek(Vector2 target, float speed = 1.0f)
+        {
+            Vector2 targetVel = target - host.SimPosition;
+
+            if (targetVel.LengthSquared() < 0.00001f) return Vector2.Zero;
+
+            targetVel = Vector2.Normalize(targetVel) * speed;
+            Vector2 newSteering = targetVel - host.Steering;
+
+            if (newSteering==Vector2.Zero) return Vector2.Zero;
+
+            float steeringSpeed = (newSteering + host.Steering).Length();
+            if (steeringSpeed > Math.Abs(speed))
+            {
+                newSteering = Vector2.Normalize(newSteering)*Math.Abs(speed);
+            }
+
+            return newSteering;
+        }
+
+        protected virtual Vector2 DoSteeringWander(float speed = 1.0f)
+        {
+            Vector2 circleCenter = (host.Steering == Vector2.Zero) ? new Vector2(speed, 0.0f) : host.Steering;
+            circleCenter = Vector2.Normalize(circleCenter) * CircleDistance;
+
+            Vector2 displacement = new Vector2(
+                (float)Math.Cos(wanderAngle),
+                (float)Math.Sin(wanderAngle));
+            displacement = displacement * CircleRadius;
+
+            float angleChange = 1.5f;
+            
+            wanderAngle += Rand.Range(0.0f, 1.0f) * angleChange - angleChange * 0.5f;
+
+            Vector2 newSteering = circleCenter + displacement;
+            float steeringSpeed = (newSteering + host.Steering).Length();
+            if (steeringSpeed > speed)
+            {
+                newSteering = Vector2.Normalize(newSteering) * speed;
+            }
+
+            return newSteering;
+        }
+
+        protected virtual Vector2 DoSteeringAvoid(float deltaTime, float speed = 1.0f)
+        {
+            if (steering == Vector2.Zero || host.Steering == Vector2.Zero) return Vector2.Zero;
+
+            float maxDistance = 2.0f;
+
+            Vector2 ahead = host.SimPosition + Vector2.Normalize(host.Steering) * maxDistance;
+
+            if (rayCastTimer <= 0.0f)
+            {
+                rayCastTimer = RayCastInterval;
+                Body closestBody = Submarine.CheckVisibility(host.SimPosition, ahead);
+                if (closestBody == null)
+                {
+                    avoidSteering = Vector2.Zero;
+                    return Vector2.Zero;
+                }
+                else
+                {
+                    Structure closestStructure = closestBody.UserData as Structure;
+                    if (closestStructure != null)
+                    {
+                        Vector2 obstaclePosition = Submarine.LastPickedPosition;
+                        if (closestStructure.IsHorizontal)
+                        {
+                            obstaclePosition.Y = closestStructure.SimPosition.Y;
+                        }
+                        else
+                        {
+                            obstaclePosition.X = closestStructure.SimPosition.X;
+                        }
+
+                        avoidSteering = Vector2.Normalize(Submarine.LastPickedPosition - obstaclePosition);
+                    }
+                    else if (closestBody.UserData is Item)
+                    {
+                        Item item = (Item)closestBody.UserData;
+                        avoidSteering = Vector2.Normalize(Submarine.LastPickedPosition - item.SimPosition);
+                    }
+                    else
+                    {
+                        avoidSteering = Vector2.Normalize(host.SimPosition - Submarine.LastPickedPosition);
+                    }
+                }
+
+            }
+            else
+            {
+                rayCastTimer -= deltaTime;
+            }
+
+            return avoidSteering * speed;
+        }
+
+    }
+}

BarotraumaShared/Source/Characters/AI/SteeringPath.cs

@@ -0,0 +1,104 @@
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    class SteeringPath
+    {
+        private List<WayPoint> nodes;
+
+        int currentIndex;
+
+        public bool Unreachable
+        {
+            get;
+            set;
+        }
+
+        public SteeringPath(bool unreachable = false)
+        {
+            nodes = new List<WayPoint>();
+            Unreachable = unreachable;
+        }
+
+        public void AddNode(WayPoint node)
+        {
+            if (node == null) return;
+            nodes.Add(node);
+
+            if (node.CurrentHull == null) HasOutdoorsNodes = true;
+        }
+        
+        public bool HasOutdoorsNodes
+        {
+            get;
+            private set;
+        }
+
+        public int CurrentIndex
+        {
+            get { return currentIndex; }
+        }
+
+        public float Cost
+        {
+            get;
+            set;
+        }
+
+        public WayPoint PrevNode
+        {
+            get 
+            {
+                if (currentIndex-1 < 0 || currentIndex-1 > nodes.Count - 1) return null;
+                return nodes[currentIndex-1]; 
+            }
+        }
+
+        public WayPoint CurrentNode
+        {
+            get 
+            {
+                if (currentIndex < 0 || currentIndex > nodes.Count - 1) return null;
+                return nodes[currentIndex]; 
+            }
+        }
+
+        public List<WayPoint> Nodes
+        {
+            get { return nodes; }
+        }
+
+        public WayPoint NextNode
+        {
+            get
+            {
+                if (currentIndex+1 < 0 || currentIndex+1 > nodes.Count - 1) return null;
+                return nodes[currentIndex+1];
+            }
+        }
+
+        public bool Finished
+        {
+            get { return currentIndex >= nodes.Count; }
+        }
+
+        public void SkipToNextNode()
+        {
+            currentIndex++;
+        }
+
+        public WayPoint CheckProgress(Vector2 simPosition, float minSimDistance = 0.1f)
+        {
+            if (nodes.Count == 0 || currentIndex>nodes.Count-1) return null;
+            if (Vector2.Distance(simPosition, nodes[currentIndex].SimPosition) < minSimDistance) currentIndex++;
+
+            return CurrentNode;
+        }
+
+        public void ClearPath()
+        {
+            nodes.Clear();
+        }
+    }
+}

BarotraumaShared/Source/Characters/AICharacter.cs

@@ -0,0 +1,90 @@
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    class AICharacter : Character
+    {
+        private AIController aiController;
+        
+        public override AIController AIController
+        {
+            get { return aiController; }
+        }
+        
+        public AICharacter(string file, Vector2 position, CharacterInfo characterInfo = null, bool isNetworkPlayer = false)
+            : base(file, position, characterInfo, isNetworkPlayer)
+        {
+            soundTimer = Rand.Range(0.0f, soundInterval);
+        }
+
+        public void SetAI(AIController aiController)
+        {
+            this.aiController = aiController;
+        }
+
+        public override void Update(Camera cam, float deltaTime)
+        {
+            base.Update(cam, deltaTime);
+
+            if (!Enabled || IsRemotePlayer) return;
+            
+            float dist = Vector2.DistanceSquared(cam.WorldViewCenter, WorldPosition);
+            if (dist > 8000.0f * 8000.0f)
+            {
+                AnimController.SimplePhysicsEnabled = true;
+            }
+            else if (dist < 7000.0f * 7000.0f)
+            {
+                AnimController.SimplePhysicsEnabled = false;
+            }
+
+            if (IsDead || Health <= 0.0f || IsUnconscious || Stun > 0.0f) return;
+
+            if (Controlled == this || !aiController.Enabled) return;
+
+            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;
+            }
+
+            aiController.Update(deltaTime);
+        }
+
+        public override void DrawFront(Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch,Camera cam)
+        {
+            base.DrawFront(spriteBatch,cam);
+
+            if (GameMain.DebugDraw && !IsDead) aiController.DebugDraw(spriteBatch);
+        }
+
+        public override void AddDamage(CauseOfDeath causeOfDeath, float amount, IDamageable attacker)
+        {
+            base.AddDamage(causeOfDeath, amount, attacker);
+
+            if (attacker!=null) aiController.OnAttacked(attacker, amount);
+        }
+
+        public override AttackResult AddDamage(IDamageable attacker, Vector2 worldPosition, Attack attack, float deltaTime, bool playSound = false)
+        {
+            AttackResult result = base.AddDamage(attacker, worldPosition, attack, deltaTime, playSound);
+
+            aiController.OnAttacked(attacker, (result.Damage + result.Bleeding) / Math.Max(Health, 1.0f));
+
+            return result;
+        }
+    }
+}

BarotraumaShared/Source/Characters/Animation/AnimController.cs

@@ -0,0 +1,44 @@
+using System.Xml.Linq;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class AnimController : Ragdoll
+    {
+        public enum Animation { None, Climbing, UsingConstruction, Struggle, CPR };
+        public Animation Anim;
+
+        protected Character character;
+
+        protected float walkSpeed, swimSpeed;  
+                
+        protected float walkPos;
+
+        protected readonly Vector2 stepSize;
+        protected readonly float legTorque;
+                
+        public AnimController(Character character, XElement element)
+            : base(character, element)
+        {
+            this.character = character;
+
+            stepSize = ToolBox.GetAttributeVector2(element, "stepsize", Vector2.One);
+            stepSize = ConvertUnits.ToSimUnits(stepSize);
+
+            walkSpeed = ToolBox.GetAttributeFloat(element, "walkspeed", 1.0f);
+            swimSpeed = ToolBox.GetAttributeFloat(element, "swimspeed", 1.0f);
+
+            legTorque = ToolBox.GetAttributeFloat(element, "legtorque", 0.0f);
+        }
+
+        public virtual void UpdateAnim(float deltaTime) { }
+
+        public virtual void HoldItem(float deltaTime, Item item, Vector2[] handlePos, Vector2 holdPos, Vector2 aimPos, bool aim, float holdAngle) { }
+
+        public virtual void DragCharacter(Character target, LimbType rightHandTarget = LimbType.RightHand, LimbType leftHandTarget = LimbType.LeftHand) { }
+
+
+   }
+}

BarotraumaShared/Source/Characters/Animation/FishAnimController.cs

@@ -0,0 +1,342 @@
+using System;
+using System.Linq;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics.Joints;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+
+namespace Barotrauma
+{
+    class FishAnimController : AnimController
+    {
+        //amplitude and wave length of the "sine wave" swimming animation
+        //if amplitude = 0, sine wave animation isn't used
+        private float waveAmplitude;
+        private float waveLength;
+
+        private bool rotateTowardsMovement;
+
+        private bool mirror, flip;
+
+        private float flipTimer;
+
+        private float? footRotation;
+
+        public FishAnimController(Character character, XElement element)
+            : base(character, element)
+        {
+            waveAmplitude = ConvertUnits.ToSimUnits(ToolBox.GetAttributeFloat(element, "waveamplitude", 0.0f));
+            waveLength = ConvertUnits.ToSimUnits(ToolBox.GetAttributeFloat(element, "wavelength", 0.0f));
+            
+            flip = ToolBox.GetAttributeBool(element, "flip", true);
+            mirror = ToolBox.GetAttributeBool(element, "mirror", false);
+            
+            float footRot = ToolBox.GetAttributeFloat(element,"footrotation", float.NaN);
+            if (float.IsNaN(footRot))
+            {
+                footRotation = null;
+            }
+            else
+            {
+                footRotation = MathHelper.ToRadians(footRot);
+            }
+
+            rotateTowardsMovement = ToolBox.GetAttributeBool(element, "rotatetowardsmovement", true);
+        }
+
+        public override void UpdateAnim(float deltaTime)
+        {
+            if (Frozen) return;
+
+            if (character.IsDead || character.IsUnconscious || character.Stun > 0.0f)
+            {
+                Collider.FarseerBody.FixedRotation = false;
+
+                if (character.IsRemotePlayer)
+                {
+                    MainLimb.pullJoint.WorldAnchorB = Collider.SimPosition;
+                    MainLimb.pullJoint.Enabled = true;
+                }
+                else
+                {
+                    Collider.LinearVelocity = (MainLimb.SimPosition - Collider.SimPosition) * 60.0f;
+                    Collider.SmoothRotate(MainLimb.Rotation);
+                }
+                
+                return;
+            }
+
+            //re-enable collider
+            if (!Collider.FarseerBody.Enabled)
+            {
+                var lowestLimb = FindLowestLimb();
+
+                Collider.SetTransform(new Vector2(
+                    Collider.SimPosition.X,
+                    Math.Max(lowestLimb.SimPosition.Y + (Collider.radius + Collider.height / 2), Collider.SimPosition.Y)),
+                    0.0f);
+
+                Collider.FarseerBody.Enabled = true;
+            }
+
+            ResetPullJoints();
+
+            if (strongestImpact > 0.0f)
+            {
+                character.Stun = MathHelper.Clamp(strongestImpact * 0.5f, character.Stun, 5.0f);
+                strongestImpact = 0.0f;
+            }
+
+
+            if (inWater)
+            {
+                Collider.FarseerBody.FixedRotation = false;
+                UpdateSineAnim(deltaTime);
+            }
+            else if (currentHull != null && CanEnterSubmarine)
+            {
+                if (Math.Abs(MathUtils.GetShortestAngle(Collider.Rotation, 0.0f)) > 0.001f)
+                {
+                    //rotate collider back upright
+                    Collider.AngularVelocity = MathUtils.GetShortestAngle(Collider.Rotation, 0.0f) * 60.0f;
+                    Collider.FarseerBody.FixedRotation = false;
+                }
+                else
+                {
+                    Collider.FarseerBody.FixedRotation = true;
+                }
+
+                UpdateWalkAnim(deltaTime);
+            }
+            
+
+            if (mirror || !inWater)
+            {
+                if (!character.IsRemotePlayer)
+                {
+                    //targetDir = (movement.X > 0.0f) ? Direction.Right : Direction.Left;
+                    if (targetMovement.X > 0.1f && targetMovement.X > Math.Abs(targetMovement.Y) * 0.5f)
+                    {
+                        TargetDir = Direction.Right;
+                    }
+                    else if (targetMovement.X < -0.1f && targetMovement.X < -Math.Abs(targetMovement.Y) * 0.5f)
+                    {
+                        TargetDir = Direction.Left;
+                    }
+                }
+
+            }
+            else
+            {
+                Limb head = GetLimb(LimbType.Head);
+                if (head == null) head = GetLimb(LimbType.Torso);
+
+                float rotation = MathUtils.WrapAngleTwoPi(head.Rotation);
+                rotation = MathHelper.ToDegrees(rotation);
+
+                if (rotation < 0.0f) rotation += 360;
+
+                if (rotation > 20 && rotation < 160)
+                {
+                    TargetDir = Direction.Left;
+                }
+                else if (rotation > 200 && rotation < 340)
+                {
+                    TargetDir = Direction.Right;
+                }
+            }
+            
+            if (!flip) return;
+
+            flipTimer += deltaTime;
+
+            if (TargetDir != Direction.None && TargetDir != dir) 
+            {   
+                if (flipTimer>1.0f || character.IsRemotePlayer)
+                {
+                    Flip();
+                    if (mirror || !inWater) Mirror();
+                    flipTimer = 0.0f;
+                }              
+            }
+        }
+
+        void UpdateSineAnim(float deltaTime)
+        {
+            movement = TargetMovement*swimSpeed;
+            
+            MainLimb.pullJoint.Enabled = true;
+            MainLimb.pullJoint.WorldAnchorB = Collider.SimPosition;
+
+            if (movement.LengthSquared() < 0.00001f) return;
+
+            float movementAngle = MathUtils.VectorToAngle(movement) - MathHelper.PiOver2;
+            
+            if (rotateTowardsMovement)
+            {
+                Collider.SmoothRotate(movementAngle, 25.0f);
+                MainLimb.body.SmoothRotate(movementAngle, 25.0f);
+            }
+            else
+            {
+                Collider.SmoothRotate(HeadAngle * Dir, 25.0f);
+                MainLimb.body.SmoothRotate(HeadAngle * Dir, 25.0f);
+            }
+
+            Limb tail = GetLimb(LimbType.Tail);
+            if (tail != null && waveAmplitude > 0.0f)
+            {
+                walkPos -= movement.Length();
+
+                float waveRotation = (float)Math.Sin(walkPos / waveLength);
+
+                tail.body.ApplyTorque(waveRotation * tail.Mass * 100.0f * waveAmplitude);
+            }
+
+
+            for (int i = 0; i < Limbs.Length; i++)
+            {
+                if (Limbs[i].SteerForce <= 0.0f) continue;
+
+                Vector2 pullPos = Limbs[i].pullJoint == null ? Limbs[i].SimPosition : Limbs[i].pullJoint.WorldAnchorA;
+                Limbs[i].body.ApplyForce(movement * Limbs[i].SteerForce * Limbs[i].Mass, pullPos);
+
+                /*if (Limbs[i] == MainLimb) continue;
+
+                float dist = (MainLimb.SimPosition - Limbs[i].SimPosition).Length();
+
+                Vector2 limbPos = MainLimb.SimPosition - Vector2.Normalize(movement) * dist;
+
+                Limbs[i].body.ApplyForce(((limbPos - Limbs[i].SimPosition) * 3.0f - Limbs[i].LinearVelocity * 3.0f) * Limbs[i].Mass);*/
+            }
+            
+            Collider.LinearVelocity = Vector2.Lerp(Collider.LinearVelocity, movement, 0.5f);
+                
+            floorY = Limbs[0].SimPosition.Y;            
+        }
+            
+        void UpdateWalkAnim(float deltaTime)
+        {
+            movement = MathUtils.SmoothStep(movement, TargetMovement * walkSpeed, 0.2f);
+            if (movement == Vector2.Zero) return;
+            
+            float mainLimbHeight, mainLimbAngle;
+            if (MainLimb.type == LimbType.Torso)
+            {
+                mainLimbHeight = TorsoPosition;
+                mainLimbAngle = torsoAngle;
+            }
+            else
+            {
+                mainLimbHeight = HeadPosition;
+                mainLimbAngle = headAngle;
+            }
+
+            MainLimb.body.SmoothRotate(mainLimbAngle * Dir, 50.0f);
+            
+            Collider.LinearVelocity = new Vector2(
+                movement.X,
+                Collider.LinearVelocity.Y > 0.0f ? Collider.LinearVelocity.Y * 0.5f : Collider.LinearVelocity.Y);
+
+            MainLimb.MoveToPos(GetColliderBottom() + Vector2.UnitY * mainLimbHeight, 10.0f);
+            
+            MainLimb.pullJoint.Enabled = true;
+            MainLimb.pullJoint.WorldAnchorB = GetColliderBottom() + Vector2.UnitY * mainLimbHeight;
+
+            walkPos -= MainLimb.LinearVelocity.X * 0.05f;
+
+            Vector2 transformedStepSize = new Vector2(
+                (float)Math.Cos(walkPos) * stepSize.X * 3.0f,
+                (float)Math.Sin(walkPos) * stepSize.Y * 2.0f);
+
+            foreach (Limb limb in Limbs)
+            {
+                switch (limb.type)
+                {
+                    case LimbType.LeftFoot:
+                    case LimbType.RightFoot:
+                        Vector2 footPos = new Vector2(limb.SimPosition.X, MainLimb.SimPosition.Y - mainLimbHeight);
+
+                        if (limb.RefJointIndex>-1)
+                        {
+                            RevoluteJoint refJoint = limbJoints[limb.RefJointIndex];
+                            footPos.X = refJoint.WorldAnchorA.X;
+                        }
+                        footPos.X += limb.StepOffset.X * Dir;
+                        footPos.Y += limb.StepOffset.Y;
+
+                        if (limb.type == LimbType.LeftFoot)
+                        {
+                            limb.MoveToPos(footPos +new Vector2(
+                                transformedStepSize.X + movement.X * 0.1f,
+                                (transformedStepSize.Y > 0.0f) ? transformedStepSize.Y : 0.0f),
+                            8.0f);
+                        }
+                        else if (limb.type == LimbType.RightFoot)
+                        {
+                            limb.MoveToPos(footPos + new Vector2(
+                                -transformedStepSize.X + movement.X * 0.1f,
+                                (-transformedStepSize.Y > 0.0f) ? -transformedStepSize.Y : 0.0f),
+                            8.0f);
+                        }
+
+                        if (footRotation != null) limb.body.SmoothRotate((float)footRotation * Dir, 50.0f);
+
+                        break;
+                    case LimbType.LeftLeg:
+                    case LimbType.RightLeg:
+                        if (legTorque != 0.0f) limb.body.ApplyTorque(limb.Mass * legTorque * Dir);
+                        break;
+                }
+            }
+        }
+        
+        void UpdateDying(float deltaTime)
+        {
+            Limb head = GetLimb(LimbType.Head);
+            Limb tail = GetLimb(LimbType.Tail);
+
+            if (head != null) head.body.ApplyTorque(head.Mass * Dir * (float)Math.Sin(walkPos) * 5.0f);
+            if (tail != null) tail.body.ApplyTorque(tail.Mass * -Dir * (float)Math.Sin(walkPos) * 5.0f);
+
+            walkPos += deltaTime * 5.0f;
+
+            Vector2 centerOfMass = GetCenterOfMass();
+
+            foreach (Limb limb in Limbs)
+            {
+                if (limb.type == LimbType.Head || limb.type == LimbType.Tail) continue;
+
+                limb.body.ApplyForce((centerOfMass - limb.SimPosition) * (float)Math.Sin(walkPos) * limb.Mass * 10.0f);
+            }
+        }
+
+        public override void Flip()
+        {
+            base.Flip();
+
+            foreach (Limb l in Limbs)
+            {
+                if (!l.DoesFlip) continue;
+                
+                l.body.SetTransform(l.SimPosition,
+                    -l.body.Rotation);                
+            }
+        }
+
+        private void Mirror()
+        {
+            Vector2 centerOfMass = GetCenterOfMass();
+
+            foreach (Limb l in Limbs)
+            {
+                TrySetLimbPosition(l,
+                    centerOfMass,
+                    new Vector2(centerOfMass.X - (l.SimPosition.X - centerOfMass.X), l.SimPosition.Y),
+                    true);
+            }
+        }
+  
+    }
+}

BarotraumaShared/Source/Characters/Attack.cs

@@ -0,0 +1,159 @@
+using Microsoft.Xna.Framework;
+using Barotrauma.Particles;
+using System;
+using System.Xml.Linq;
+using System.Collections.Generic;
+
+
+namespace Barotrauma
+{
+    enum CauseOfDeath
+    {
+        Damage, Bloodloss, Pressure, Suffocation, Drowning, Burn, Husk, Disconnected
+    }
+
+    public enum DamageType { None, Blunt, Slash, Burn }
+
+    struct AttackResult
+    {
+        public readonly float Damage;
+        public readonly float Bleeding;
+
+        public readonly bool HitArmor;
+
+        public AttackResult(float damage, float bleeding, bool hitArmor=false)
+        {
+            this.Damage = damage;
+            this.Bleeding = bleeding;
+
+            this.HitArmor = hitArmor;
+        }
+    }
+
+    class Attack
+    {
+        public readonly float Range;
+        public readonly float Duration;
+
+        public readonly DamageType DamageType;
+
+        private readonly float structureDamage;
+        private readonly float damage;
+        private readonly float bleedingDamage;
+
+        private readonly List<StatusEffect> statusEffects;
+
+        public readonly float Force;
+
+        public readonly float Torque;
+
+        public readonly float TargetForce;
+
+        private Sound sound;
+
+        private ParticleEmitterPrefab particleEmitterPrefab;
+
+        public readonly float Stun;
+
+        private float priority;
+
+        public float GetDamage(float deltaTime)
+        {
+            return (Duration == 0.0f) ? damage : damage * deltaTime;
+        }
+
+        public float GetBleedingDamage(float deltaTime)
+        {
+            return (Duration == 0.0f) ? bleedingDamage : bleedingDamage * deltaTime;
+        }
+
+        public float GetStructureDamage(float deltaTime)
+        {
+            return (Duration == 0.0f) ? structureDamage : structureDamage * deltaTime;
+        }
+
+        public Attack(XElement element)
+        {
+            try
+            {
+                DamageType = (DamageType)Enum.Parse(typeof(DamageType), ToolBox.GetAttributeString(element, "damagetype", "None"), true);
+            }
+            catch
+            {
+                DamageType = DamageType.None;
+            }
+
+
+            damage = ToolBox.GetAttributeFloat(element, "damage", 0.0f);
+            structureDamage = ToolBox.GetAttributeFloat(element, "structuredamage", 0.0f);
+            bleedingDamage = ToolBox.GetAttributeFloat(element, "bleedingdamage", 0.0f);
+
+            Force = ToolBox.GetAttributeFloat(element,"force", 0.0f);
+            TargetForce = ToolBox.GetAttributeFloat(element, "targetforce", 0.0f);
+
+            Torque = ToolBox.GetAttributeFloat(element, "torque", 0.0f);
+
+            Stun = ToolBox.GetAttributeFloat(element, "stun", 0.0f);
+
+            string soundPath = ToolBox.GetAttributeString(element, "sound", "");
+            if (!string.IsNullOrWhiteSpace(soundPath))
+            {
+                sound = Sound.Load(soundPath);
+            }
+                      
+            Range = ToolBox.GetAttributeFloat(element, "range", 0.0f);
+
+            Duration = ToolBox.GetAttributeFloat(element, "duration", 0.0f); 
+
+            priority = ToolBox.GetAttributeFloat(element, "priority", 1.0f);
+
+            statusEffects = new List<StatusEffect>();
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "particleemitter":
+                        particleEmitterPrefab = new ParticleEmitterPrefab(subElement);
+                        break;
+                    case "statuseffect":
+                        statusEffects.Add(StatusEffect.Load(subElement));
+                        break;
+                }
+
+            }
+        }
+
+
+        public AttackResult DoDamage(IDamageable attacker, IDamageable target, Vector2 worldPosition, float deltaTime, bool playSound = true)
+        {
+            if (particleEmitterPrefab != null)
+            {
+                particleEmitterPrefab.Emit(worldPosition);
+            }
+
+            if (sound != null)
+            {
+                sound.Play(1.0f, 500.0f, worldPosition);
+            }
+            
+            var attackResult = target.AddDamage(attacker, worldPosition, this, deltaTime, playSound);
+
+            var effectType = attackResult.Damage > 0.0f ? ActionType.OnUse : ActionType.OnFailure;
+
+            foreach (StatusEffect effect in statusEffects)
+            {
+                if (effect.Targets.HasFlag(StatusEffect.TargetType.This) && attacker is Character)
+                {
+                    effect.Apply(effectType, deltaTime, (Character)attacker, (Character)attacker);
+                }
+                if (effect.Targets.HasFlag(StatusEffect.TargetType.Character) && target is Character)
+                {
+                    effect.Apply(effectType, deltaTime, (Character)target, (Character)target);
+                }
+            }
+
+            return attackResult;
+        }
+    }
+}

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

BarotraumaShared/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, false)];
+
+                        pos = new Vector2(wp.Rect.X, wp.Rect.Y);
+                        pos += Rand.Vector(200.0f, false);
+                    }
+                    else
+                    {
+                        pos = Rand.Vector(2000.0f, false);
+                    } 
+                }
+                else
+                {
+                    pos = (Vector2)position;
+                }
+
+
+                var prefab = prefabs[Rand.Int(prefabs.Count, false)];
+
+                int amount = Rand.Range(prefab.SwarmMin, prefab.SwarmMax, false);
+                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(Camera cam, float deltaTime)
+        {
+            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);
+            }
+        }
+    }
+}

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

BarotraumaShared/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, false);
+
+                var newSprite = new BackgroundSprite(prefab,
+                    new Vector3((Vector2)pos, Rand.Range(prefab.DepthRange.X, prefab.DepthRange.Y, false)), Rand.Range(prefab.Scale.X, prefab.Scale.Y, false), 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, false), 
+                Rand.Range(0.0f, level.Size.Y, false));
+
+            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, false)];
+
+                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, false);
+            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, false);
+
+            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, false);
+
+            foreach (BackgroundSpritePrefab prefab in prefabs)
+            {
+                if (randomNumber <= prefab.GetCommonness(levelType))
+                {
+                    return prefab;
+                }
+
+                randomNumber -= prefab.GetCommonness(levelType);
+            }
+
+            return null;
+        }
+    }
+}

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

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

BarotraumaShared/Source/Characters/CharacterInfo.cs

@@ -0,0 +1,380 @@
+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
+{
+    public enum Gender { None, Male, Female };        
+
+    class CharacterInfo
+    {
+        public string Name;
+
+        public Character Character;
+
+        public readonly string File;
+        
+        public Job Job;
+
+        private List<ushort> pickedItems;
+
+        public ushort? HullID = null;
+
+        private Vector2[] headSpriteRange;
+
+        private Gender gender;
+
+        public int Salary;
+
+        private int headSpriteId;
+        private Sprite headSprite;
+
+        public bool StartItemsGiven;
+
+        public List<ushort> PickedItemIDs
+        {
+            get { return pickedItems; }
+        }
+        
+        public Sprite HeadSprite
+        {
+            get
+            {
+                if (headSprite == null) LoadHeadSprite();
+                return headSprite;
+            }
+        }
+
+        public List<string> SpriteTags
+        {
+            get;
+            private set;
+        }
+
+        public int HeadSpriteId
+        {
+            get { return headSpriteId; }
+            set
+            {
+                int oldId = headSpriteId;
+
+                headSpriteId = value;
+                Vector2 spriteRange = headSpriteRange[gender == Gender.Male ? 0 : 1];
+                
+                if (headSpriteId < (int)spriteRange.X) headSpriteId = (int)(spriteRange.Y);
+                if (headSpriteId > (int)spriteRange.Y) headSpriteId = (int)(spriteRange.X);
+
+                if (headSpriteId != oldId) headSprite = null;
+            }
+        }
+
+        public Gender Gender
+        {
+            get { return gender; }
+            set
+            {
+                if (gender == value) return;
+                gender = value;
+
+                int genderIndex = (this.gender == Gender.Female) ? 1 : 0;
+                if (headSpriteRange[genderIndex] != Vector2.Zero)
+                {
+                    HeadSpriteId = Rand.Range((int)headSpriteRange[genderIndex].X, (int)headSpriteRange[genderIndex].Y + 1);
+                }
+                else
+                {
+                    HeadSpriteId = 0;
+                }
+
+                LoadHeadSprite();
+            }
+        }
+
+        public CharacterInfo(string file, string name = "", Gender gender = Gender.None, JobPrefab jobPrefab = null)
+        {
+            this.File = file;
+
+            headSpriteRange = new Vector2[2];
+
+            pickedItems = new List<ushort>();
+
+            SpriteTags = new List<string>();
+
+            //ID = -1;
+
+            XDocument doc = ToolBox.TryLoadXml(file);
+            if (doc == null) return;
+
+            if (ToolBox.GetAttributeBool(doc.Root, "genders", false))
+            {
+                if (gender == Gender.None)
+                {
+                    float femaleRatio = ToolBox.GetAttributeFloat(doc.Root, "femaleratio", 0.5f);
+                    this.gender = (Rand.Range(0.0f, 1.0f, false) < femaleRatio) ? Gender.Female : Gender.Male;
+                }
+                else
+                {
+                    this.gender = gender;
+                }
+            }
+                       
+            headSpriteRange[0] = ToolBox.GetAttributeVector2(doc.Root, "headid", Vector2.Zero);
+            headSpriteRange[1] = headSpriteRange[0];
+            if (headSpriteRange[0] == Vector2.Zero)
+            {
+                headSpriteRange[0] = ToolBox.GetAttributeVector2(doc.Root, "maleheadid", Vector2.Zero);
+                headSpriteRange[1] = ToolBox.GetAttributeVector2(doc.Root, "femaleheadid", Vector2.Zero);
+            }
+
+            int genderIndex = (this.gender == Gender.Female) ? 1 : 0;
+            if (headSpriteRange[genderIndex] != Vector2.Zero)
+            {
+                HeadSpriteId = Rand.Range((int)headSpriteRange[genderIndex].X, (int)headSpriteRange[genderIndex].Y + 1);
+            }
+
+            this.Job = (jobPrefab == null) ? Job.Random() : new Job(jobPrefab);
+
+            if (!string.IsNullOrEmpty(name))
+            {
+                this.Name = name;
+                return;
+            }
+
+            name = "";
+
+            if (doc.Root.Element("name") != null)
+            {
+                string firstNamePath = ToolBox.GetAttributeString(doc.Root.Element("name"), "firstname", "");
+                if (firstNamePath != "")
+                {
+                    firstNamePath = firstNamePath.Replace("[GENDER]", (this.gender == Gender.Female) ? "f" : "");
+                    this.Name = ToolBox.GetRandomLine(firstNamePath);
+                }
+
+                string lastNamePath = ToolBox.GetAttributeString(doc.Root.Element("name"), "lastname", "");
+                if (lastNamePath != "")
+                {
+                    lastNamePath = lastNamePath.Replace("[GENDER]", (this.gender == Gender.Female) ? "f" : "");
+                    if (this.Name != "") this.Name += " ";
+                    this.Name += ToolBox.GetRandomLine(lastNamePath);
+                }
+            }
+            
+            Salary = CalculateSalary();
+        }
+
+        private void LoadHeadSprite()
+        {
+            XDocument doc = ToolBox.TryLoadXml(File);
+            if (doc == null) return;
+
+            XElement ragdollElement = doc.Root.Element("ragdoll");
+            foreach (XElement limbElement in ragdollElement.Elements())
+            {
+                if (ToolBox.GetAttributeString(limbElement, "type", "").ToLowerInvariant() != "head") continue;
+
+                XElement spriteElement = limbElement.Element("sprite");
+
+                string spritePath = spriteElement.Attribute("texture").Value;
+
+                spritePath = spritePath.Replace("[GENDER]", (this.gender == Gender.Female) ? "f" : "");
+                spritePath = spritePath.Replace("[HEADID]", HeadSpriteId.ToString());
+                
+                string fileName = Path.GetFileNameWithoutExtension(spritePath);
+
+                //go through the files in the directory to find a matching sprite
+                var files = Directory.GetFiles(Path.GetDirectoryName(spritePath)).ToList();
+                foreach (string file in files)
+                {
+                    string fileWithoutTags = Path.GetFileNameWithoutExtension(file);
+                    fileWithoutTags = fileWithoutTags.Split('[', ']').First();
+
+                    if (fileWithoutTags != fileName) continue;
+                    
+                    headSprite = new Sprite(spriteElement, "", file);
+
+                    //extract the tags out of the filename
+                    SpriteTags = file.Split('[', ']').Skip(1).ToList();
+                    if (SpriteTags.Any())
+                    {
+                        SpriteTags.RemoveAt(SpriteTags.Count-1);
+                    }
+
+                    break;                    
+                }
+
+                break;
+            }
+        }
+        
+        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;
+        }
+
+        public void UpdateCharacterItems()
+        {
+            pickedItems.Clear();
+            foreach (Item item in Character.Inventory.Items)
+            {
+                pickedItems.Add(item == null ? (ushort)0 : item.ID);
+            }
+        }
+
+        public CharacterInfo(XElement element)
+        {
+            Name = ToolBox.GetAttributeString(element, "name", "unnamed");
+
+            string genderStr = ToolBox.GetAttributeString(element, "gender", "male").ToLowerInvariant();
+            gender = (genderStr == "m") ? Gender.Male : Gender.Female;
+
+            File            = ToolBox.GetAttributeString(element, "file", "");
+            Salary          = ToolBox.GetAttributeInt(element, "salary", 1000);
+            headSpriteId    = ToolBox.GetAttributeInt(element, "headspriteid", 1);
+            StartItemsGiven = ToolBox.GetAttributeBool(element, "startitemsgiven", false);
+            
+            int hullId = ToolBox.GetAttributeInt(element, "hull", -1);
+            if (hullId > 0 && hullId <= ushort.MaxValue) this.HullID = (ushort)hullId;            
+
+            pickedItems = new List<ushort>();
+
+            string pickedItemString = ToolBox.GetAttributeString(element, "items", "");
+            if (!string.IsNullOrEmpty(pickedItemString))
+            {
+                string[] itemIds = pickedItemString.Split(',');
+                foreach (string s in itemIds)
+                {
+                    pickedItems.Add((ushort)int.Parse(s));
+                }
+            }
+
+            foreach (XElement subElement in element.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "job") continue;
+
+                Job = new Job(subElement);
+                break;
+            }
+        }
+
+        private int CalculateSalary()
+        {
+            if (Name == null || Job == null) return 0;
+
+            int salary = Math.Abs(Name.GetHashCode()) % 100;
+
+            foreach (Skill skill in Job.Skills)
+            {
+                salary += skill.Level * 10;
+            }
+
+            return salary;
+        }
+
+        public virtual XElement Save(XElement parentElement)
+        {
+            XElement charElement = new XElement("Character");
+
+            charElement.Add(
+                new XAttribute("name", Name),
+                new XAttribute("file", File),
+                new XAttribute("gender", gender == Gender.Male ? "m" : "f"),
+                new XAttribute("salary", Salary),
+                new XAttribute("headspriteid", HeadSpriteId),
+                new XAttribute("startitemsgiven", StartItemsGiven));
+            
+            if (Character != null)
+            {
+                if (Character.Inventory != null)
+                {
+                    UpdateCharacterItems();
+                }
+
+                if (Character.AnimController.CurrentHull != null)
+                {
+                    HullID = Character.AnimController.CurrentHull.ID;
+                    charElement.Add(new XAttribute("hull", Character.AnimController.CurrentHull.ID));
+                }
+            }
+            
+            if (pickedItems.Count > 0)
+            {
+                charElement.Add(new XAttribute("items", string.Join(",", pickedItems)));
+            }
+
+            Job.Save(charElement);
+
+            parentElement.Add(charElement);
+            return charElement;
+        }
+
+        public void Remove()
+        {
+            Character = null;
+            //if (headSprite != null)
+            //{
+            //    headSprite.Remove();
+            //    headSprite = null;
+            //}
+        }
+    }
+}

BarotraumaShared/Source/Characters/CharacterNetworking.cs

@@ -0,0 +1,898 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{    
+    class CharacterStateInfo : PosInfo
+    {
+        public readonly Direction Direction;
+
+        public readonly Entity Interact; //the entity being interacted with
+
+        public readonly AnimController.Animation Animation;
+
+        public CharacterStateInfo(Vector2 pos, float time, Direction dir, Entity interact, AnimController.Animation animation = AnimController.Animation.None)
+            : this(pos, 0, time, dir, interact, animation)
+        {
+        }
+
+        public CharacterStateInfo(Vector2 pos, UInt16 ID, Direction dir, Entity interact, AnimController.Animation animation = AnimController.Animation.None)
+            : this(pos, ID, 0.0f, dir, interact, animation)
+        {
+        }
+
+        protected CharacterStateInfo(Vector2 pos, UInt16 ID, float time, Direction dir, Entity interact, AnimController.Animation animation = AnimController.Animation.None)
+            : base(pos, ID, time)
+        {
+            Direction = dir;
+            Interact = interact;
+
+            Animation = animation;
+        }
+    }
+
+    partial class Character
+    {
+        [Flags]
+        private enum InputNetFlags : ushort
+        {
+            None = 0x0,
+            Left = 0x1,
+            Right = 0x2,
+            Up = 0x4,
+            Down = 0x8,
+            FacingLeft = 0x10,
+            Run = 0x20,
+            Crouch = 0x40,
+            Select = 0x80,
+            Use = 0x100,
+            Aim = 0x200,
+            Attack = 0x400,
+
+            MaxVal = 0x7FF
+        }
+        private InputNetFlags dequeuedInput = 0;
+        private InputNetFlags prevDequeuedInput = 0;
+
+        public UInt16 LastNetworkUpdateID = 0;
+
+        /// <summary>
+        /// ID of the last inputs the server has processed
+        /// </summary>
+        public UInt16 LastProcessedID;
+
+        private struct NetInputMem
+        {
+            public InputNetFlags states; //keys pressed/other boolean states at this step
+            public UInt16 intAim; //aim angle, represented as an unsigned short where 0=0º, 65535=just a bit under 360º
+            public UInt16 interact; //id of the entity being interacted with
+
+            public UInt16 networkUpdateID;
+        }
+
+        private List<NetInputMem> memInput  = new List<NetInputMem>();
+
+        private List<CharacterStateInfo> memState        = new List<CharacterStateInfo>();
+        private List<CharacterStateInfo> memLocalState   = new List<CharacterStateInfo>();
+
+        private bool networkUpdateSent;
+
+        public bool isSynced = false;
+        
+        public List<CharacterStateInfo> MemState
+        {
+            get { return memState; }
+        }
+
+        public List<CharacterStateInfo> MemLocalState
+        {
+            get { return memLocalState; }
+        }
+
+        public void ResetNetState()
+        {
+            memInput.Clear();
+            memState.Clear();
+            memLocalState.Clear();
+
+            LastNetworkUpdateID = 0;
+            LastProcessedID = 0;
+        }
+
+        private void UpdateNetInput()
+        {
+            if (this != Character.Controlled)
+            {
+                if (GameMain.Client != null)
+                {
+                    //freeze AI characters if more than 1 seconds have passed since last update from the server
+                    if (lastRecvPositionUpdateTime < NetTime.Now - 1.0f)
+                    {
+                        AnimController.Frozen = true;
+                        memState.Clear();
+                        //hide after 2 seconds
+                        if (lastRecvPositionUpdateTime < NetTime.Now - 2.0f)
+                        {
+                            Enabled = false;
+                            return;
+                        }
+                    }
+                }
+                else if (GameMain.Server != null && (!(this is AICharacter) || IsRemotePlayer))
+                {
+                    if (!AllowInput)
+                    {
+                        AnimController.Frozen = false;
+                    }
+                    else if (memInput.Count == 0)
+                    {
+                        AnimController.Frozen = true;
+                    }
+                    else
+                    {
+                        AnimController.Frozen = false;
+                        prevDequeuedInput = dequeuedInput;
+
+                        LastProcessedID = memInput[memInput.Count - 1].networkUpdateID;
+                        dequeuedInput = memInput[memInput.Count - 1].states;
+
+                        double aimAngle = ((double)memInput[memInput.Count - 1].intAim / 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;
+
+                        var closestEntity = Entity.FindEntityByID(memInput[memInput.Count - 1].interact);
+                        if (closestEntity is Item)
+                        {
+                            closestItem = (Item)closestEntity;
+                            closestCharacter = null;
+                        }
+                        else if (closestEntity is Character)
+                        {
+                            closestCharacter = (Character)closestEntity;
+                            closestItem = null;
+                        }
+                        
+                        memInput.RemoveAt(memInput.Count - 1);
+
+                        TransformCursorPos();
+
+                        if ((dequeuedInput == InputNetFlags.None || dequeuedInput == InputNetFlags.FacingLeft) && Math.Abs(AnimController.Collider.LinearVelocity.X) < 0.005f && Math.Abs(AnimController.Collider.LinearVelocity.Y) < 0.2f)
+                        {
+                            while (memInput.Count > 5 && memInput[memInput.Count - 1].states == dequeuedInput)
+                            {
+                                //remove inputs where the player is not moving at all
+                                //helps the server catch up, shouldn't affect final position
+                                LastProcessedID = memInput[memInput.Count - 1].networkUpdateID;
+                                memInput.RemoveAt(memInput.Count - 1);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (GameMain.Client != null)
+            {
+                var posInfo = new CharacterStateInfo(
+                    SimPosition,
+                    LastNetworkUpdateID, 
+                    AnimController.TargetDir, 
+                    selectedCharacter == null ? (Entity)selectedConstruction : (Entity)selectedCharacter,
+                    AnimController.Anim);
+
+                memLocalState.Add(posInfo);
+
+                InputNetFlags newInput = InputNetFlags.None;
+                if (IsKeyDown(InputType.Left))      newInput |= InputNetFlags.Left;
+                if (IsKeyDown(InputType.Right))     newInput |= InputNetFlags.Right;
+                if (IsKeyDown(InputType.Up))        newInput |= InputNetFlags.Up;
+                if (IsKeyDown(InputType.Down))      newInput |= InputNetFlags.Down;
+                if (IsKeyDown(InputType.Run))       newInput |= InputNetFlags.Run;
+                if (IsKeyDown(InputType.Crouch))    newInput |= InputNetFlags.Crouch;
+                if (IsKeyHit(InputType.Select))     newInput |= InputNetFlags.Select; //TODO: clean up the way this input is registered
+                if (IsKeyDown(InputType.Use))       newInput |= InputNetFlags.Use;
+                if (IsKeyDown(InputType.Aim))       newInput |= InputNetFlags.Aim;
+                if (IsKeyDown(InputType.Attack))    newInput |= InputNetFlags.Attack;
+
+                if (AnimController.TargetDir == Direction.Left) newInput |= InputNetFlags.FacingLeft;
+
+                Vector2 relativeCursorPos = cursorPosition - (ViewTarget == null ? AnimController.Collider.Position : ViewTarget.Position);
+                relativeCursorPos.Normalize();
+                UInt16 intAngle = (UInt16)(65535.0 * Math.Atan2(relativeCursorPos.Y, relativeCursorPos.X) / (2.0 * Math.PI));
+
+                NetInputMem newMem = new NetInputMem();
+                newMem.states = newInput;
+                newMem.intAim = intAngle;
+                if (closestItem != null)
+                {
+                    newMem.interact = closestItem.ID;
+                }
+                else if (closestCharacter != null)
+                {
+                    newMem.interact = closestCharacter.ID;
+                }
+
+                memInput.Insert(0, newMem);
+                LastNetworkUpdateID++;
+                if (memInput.Count > 60)
+                {
+                    memInput.RemoveRange(60, memInput.Count - 60);
+                }
+            }
+            else //this == Character.Controlled && GameMain.Client == null
+            {                
+                AnimController.Frozen = false;
+            }
+
+            if (networkUpdateSent)
+            {
+                foreach (Key key in keys)
+                {
+                    key.DequeueHit();
+                    key.DequeueHeld();
+                }
+
+                networkUpdateSent = false;
+            }
+        }
+
+        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;
+                }
+                msg.WritePadBits();
+            }
+            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);
+                    }
+                }
+            }
+        }
+        public virtual void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            if (GameMain.Server == null) return;
+
+            switch (type)
+            {
+                case ClientNetObject.CHARACTER_INPUT:
+
+                    if (c.Character != this)
+                    {
+#if DEBUG
+                        DebugConsole.Log("Received a character update message from a client who's not controlling the character");
+#endif
+                        return;
+                    }
+
+                    UInt16 networkUpdateID = msg.ReadUInt16();
+                    byte inputCount = msg.ReadByte();
+
+                    if (AllowInput) Enabled = true;                   
+
+                    for (int i = 0; i < inputCount; i++)
+                    {
+                        InputNetFlags newInput = (InputNetFlags)msg.ReadRangedInteger(0, (int)InputNetFlags.MaxVal);
+                        UInt16 newAim = 0;
+                        UInt16 newInteract = 0;
+
+                        if (newInput.HasFlag(InputNetFlags.Aim))
+                        {
+                            newAim = msg.ReadUInt16();
+                        }
+                        if (newInput.HasFlag(InputNetFlags.Select) || newInput.HasFlag(InputNetFlags.Use))
+                        {
+                            newInteract = msg.ReadUInt16();                 
+                        }
+
+                        if (AllowInput)
+                        {
+                            if (NetIdUtils.IdMoreRecent((ushort)(networkUpdateID - i), LastNetworkUpdateID) && (i < 60))
+                            {
+                                NetInputMem newMem = new NetInputMem();
+                                newMem.states = newInput;
+                                newMem.intAim = newAim;
+                                newMem.interact = newInteract;
+
+                                newMem.networkUpdateID = (ushort)(networkUpdateID - i);
+
+                                memInput.Insert(i, newMem);
+                            }
+                        }
+                    }
+
+                    if (NetIdUtils.IdMoreRecent(networkUpdateID, LastNetworkUpdateID))
+                    {
+                        LastNetworkUpdateID = networkUpdateID;
+                    }
+                    if (memInput.Count > 60)
+                    {
+                        //deleting inputs from the queue here means the server is way behind and data needs to be dropped
+                        //we'll make the server drop down to 30 inputs for good measure
+                        memInput.RemoveRange(30, memInput.Count - 30);
+                    }
+                    break;
+
+                case ClientNetObject.ENTITY_STATE:
+                    int eventType = msg.ReadRangedInteger(0,2);
+                    switch (eventType)
+                    {
+                        case 0:
+                            inventory.ServerRead(type, msg, c);
+                            break;
+                        case 1:
+                            if (c.Character != this)
+                            {
+#if DEBUG
+                                DebugConsole.Log("Received a character update message from a client who's not controlling the character");
+#endif
+                                return;
+                            }
+
+                            bool doingCPR = msg.ReadBoolean();
+                            AnimController.Anim = doingCPR ? AnimController.Animation.CPR : AnimController.Animation.None;
+                            break;
+                        case 2:
+                            if (c.Character != this)
+                            {
+#if DEBUG
+                                DebugConsole.Log("Received a character update message from a client who's not controlling the character");
+#endif
+                                return;
+                            }
+
+                            if (IsUnconscious)
+                            {
+                                Kill(lastAttackCauseOfDeath);
+                            }
+                            break;
+
+                    }
+
+                    msg.ReadPadBits();
+                    break;
+            }
+        }
+
+        public virtual void ServerWrite(NetBuffer msg, Client c, 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.Control:
+                        msg.WriteRangedInteger(0, 2, 1);
+                        Client owner = ((Client)extraData[1]);
+                        msg.Write(owner == null ? (byte)0 : owner.ID);
+                        break;
+                    case NetEntityEvent.Type.Status:
+                        msg.WriteRangedInteger(0, 2, 2);
+                        WriteStatus(msg);
+                        break;
+                }
+                msg.WritePadBits();
+            }
+            else
+            {
+                msg.Write(ID);
+
+                NetBuffer tempBuffer = new NetBuffer();
+
+                if (this == c.Character)
+                {
+                    tempBuffer.Write(true);
+                    if (LastNetworkUpdateID < memInput.Count + 1)
+                    {
+                        tempBuffer.Write((UInt16)0);
+                    }
+                    else
+                    {
+                        tempBuffer.Write((UInt16)(LastNetworkUpdateID - memInput.Count - 1));
+                    }
+                }
+                else
+                {
+                    tempBuffer.Write(false);
+
+                    bool aiming = false;
+                    bool use = false;
+                    bool attack = false;
+
+                    if (IsRemotePlayer)
+                    {
+                        aiming = dequeuedInput.HasFlag(InputNetFlags.Aim);
+                        use = dequeuedInput.HasFlag(InputNetFlags.Use);
+
+                        attack = dequeuedInput.HasFlag(InputNetFlags.Attack);
+                    }
+                    else
+                    {
+                        aiming = keys[(int)InputType.Aim].GetHeldQueue;
+                        use = keys[(int)InputType.Use].GetHeldQueue;
+
+                        attack = keys[(int)InputType.Attack].GetHeldQueue;
+
+                        networkUpdateSent = true;
+                    }
+
+                    tempBuffer.Write(aiming);
+                    tempBuffer.Write(use);
+
+                    bool hasAttackLimb = AnimController.Limbs.Any(l => l != null && l.attack != null);
+                    tempBuffer.Write(hasAttackLimb);
+                    if (hasAttackLimb) tempBuffer.Write(attack);
+
+                    if (aiming)
+                    {
+                        Vector2 relativeCursorPos = cursorPosition - (ViewTarget == null ? AnimController.Collider.Position : ViewTarget.Position);
+                        tempBuffer.Write((UInt16)(65535.0 * Math.Atan2(relativeCursorPos.Y, relativeCursorPos.X) / (2.0 * Math.PI)));
+                    }
+
+                    tempBuffer.Write(AnimController.TargetDir == Direction.Right);
+                }
+
+                if (selectedCharacter != null || selectedConstruction != null)
+                {
+                    tempBuffer.Write(true);
+                    tempBuffer.Write(selectedCharacter != null ? selectedCharacter.ID : selectedConstruction.ID);
+                    if (selectedCharacter != null)
+                    {
+                        tempBuffer.Write(AnimController.Anim == AnimController.Animation.CPR);
+                    }
+                }
+                else
+                {
+                    tempBuffer.Write(false);
+                }
+
+                tempBuffer.Write(SimPosition.X);
+                tempBuffer.Write(SimPosition.Y);
+
+                tempBuffer.WritePadBits();
+
+                msg.Write((byte)tempBuffer.LengthBytes);
+                msg.Write(tempBuffer);
+            }
+        }
+
+        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;
+            }
+        }
+
+        private void WriteStatus(NetBuffer msg)
+        {
+            if (GameMain.Client != null)
+            {
+                DebugConsole.ThrowError("Client attempted to write character status to a networked message");
+                return;
+            }
+
+            msg.Write(isDead);
+            if (isDead)
+            {
+                msg.Write((byte)causeOfDeath);
+            }
+            else
+            {
+                msg.WriteRangedSingle(health, minHealth, maxHealth, 8);
+
+                msg.Write(oxygen < 100.0f);
+                if (oxygen < 100.0f)
+                {
+                    msg.WriteRangedSingle(oxygen, -100.0f, 100.0f, 8);
+                }
+
+                msg.Write(bleeding > 0.0f);
+                if (bleeding > 0.0f)
+                {
+                    msg.WriteRangedSingle(bleeding, 0.0f, 5.0f, 8);
+                }
+
+                msg.Write(Stun > 0.0f);
+                if (Stun > 0.0f)
+                {
+                    msg.WriteRangedSingle(MathHelper.Clamp(Stun, 0.0f, MaxStun), 0.0f, MaxStun, 8);
+                }
+
+                msg.Write(HuskInfectionState > 0.0f);
+            }
+        }
+
+        private void ReadStatus(NetBuffer msg)
+        {
+            if (GameMain.Server != null)
+            {
+                DebugConsole.ThrowError("Server attempted to read character status from a networked message");
+                return;
+            }
+
+            bool isDead = msg.ReadBoolean();
+            if (isDead)
+            {
+                causeOfDeath = (CauseOfDeath)msg.ReadByte();
+                if (causeOfDeath == CauseOfDeath.Pressure)
+                {
+                    Implode(true);
+                }
+                else
+                {
+                    Kill(causeOfDeath, true);
+                }
+            }
+            else
+            {
+                health = msg.ReadRangedSingle(minHealth, maxHealth, 8);
+
+                bool lowOxygen = msg.ReadBoolean();
+                if (lowOxygen)
+                {
+                    Oxygen = msg.ReadRangedSingle(-100.0f, 100.0f, 8);
+                }
+                else
+                {
+                    Oxygen = 100.0f;
+                }
+
+                bool isBleeding = msg.ReadBoolean();
+                if (isBleeding)
+                {
+                    bleeding = msg.ReadRangedSingle(0.0f, 5.0f, 8);
+                }
+                else
+                {
+                    bleeding = 0.0f;
+                }
+
+                bool stunned = msg.ReadBoolean();
+                if (stunned)
+                {
+                    float newStunTimer = msg.ReadRangedSingle(0.0f, 60.0f, 8);
+                    SetStun(newStunTimer, true, true);
+                }
+                else
+                {
+                    SetStun(0.0f, true, true);
+                }
+
+                bool huskInfected = msg.ReadBoolean();
+                if (huskInfected)
+                {
+                    HuskInfectionState = Math.Max(HuskInfectionState, 0.01f);
+                }
+                else
+                {
+                    HuskInfectionState = 0.0f;
+                }
+
+            }
+        }
+
+        public void WriteSpawnData(NetBuffer msg)
+        {
+            if (GameMain.Server == null) return;
+
+            msg.Write(Info == null);
+            msg.Write(ID);
+            msg.Write(ConfigPath);
+
+            msg.Write(WorldPosition.X);
+            msg.Write(WorldPosition.Y);
+
+            msg.Write(Enabled);
+
+            //character with no characterinfo (e.g. some monster)
+            if (Info == null) return;
+
+            Client ownerClient = GameMain.Server.ConnectedClients.Find(c => c.Character == this);
+            if (ownerClient != null)
+            {
+                msg.Write(true);
+                msg.Write(ownerClient.ID);
+            }
+            else if (GameMain.Server.Character == this)
+            {
+                msg.Write(true);
+                msg.Write((byte)0);
+            }
+            else
+            {
+                msg.Write(false);
+            }
+
+            msg.Write(Info.Name);
+            msg.Write(TeamID);
+
+            msg.Write(this is AICharacter);
+            msg.Write(Info.Gender == Gender.Female);
+            msg.Write((byte)Info.HeadSpriteId);
+            if (info.Job != null)
+            {
+                msg.Write(Info.Job.Name);
+                msg.Write((byte)info.Job.Skills.Count);
+                foreach (Skill skill in info.Job.Skills)
+                {
+                    msg.Write(skill.Name);
+                    msg.WriteRangedInteger(0, 100, MathHelper.Clamp(skill.Level, 0, 100));
+                }
+            }
+            else
+            {
+                msg.Write("");
+            }
+        }
+
+        public static Character ReadSpawnData(NetBuffer inc, bool spawn = true)
+        {
+            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;
+        }
+    }
+}

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

BarotraumaShared/Source/Characters/DelayedEffect.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class DelayedEffect : StatusEffect
+    {
+        public static List<DelayedEffect> List = new List<DelayedEffect>();
+
+        private float delay;
+
+        private float startTimer;
+
+        private Entity entity;
+
+        private List<IPropertyObject> targets;
+        
+        public float StartTimer
+        {
+            get { return startTimer; }
+        }
+
+        public DelayedEffect(XElement element)
+            : base(element)
+        {
+            delay = ToolBox.GetAttributeFloat(element, "delay", 1.0f);
+        }
+
+        public override void Apply(ActionType type, float deltaTime, Entity entity, List<IPropertyObject> targets)
+        {
+            if (this.type != type) return;
+            
+            startTimer = delay;
+            this.entity = entity;
+
+            this.targets = targets;
+
+            List.Add(this);
+        }
+
+        public void Update(float deltaTime)
+        {
+            startTimer -= deltaTime;
+
+            if (startTimer > 0.0f) return;
+
+            base.Apply(1.0f, entity, targets);
+            List.Remove(this);
+        }
+
+    }
+}

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

BarotraumaShared/Source/Characters/HuskInfection.cs

@@ -0,0 +1,184 @@
+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
+{
+    class HuskInfection
+    {
+        public enum InfectionState
+        {
+            Dormant, Transition, Active
+        }
+
+        const float IncubationDuration = 300.0f;
+
+        private InfectionState state;
+
+        private float incubationTimer;
+        public float IncubationTimer
+        {
+            get { return incubationTimer; }
+            set
+            {
+                incubationTimer = MathHelper.Clamp(value, 0.0f, 1.0f);
+            }
+        }
+
+        public InfectionState State
+        {
+            get { return state; }
+        }
+        
+        public bool CanSpeak
+        {
+            get { return IncubationTimer < 0.5f; }
+        }
+
+        public HuskInfection(Character character)
+        {
+            character.OnDeath += CharacterDead;
+        }
+
+        public void Update(float deltaTime, Character character)
+        {
+            if (IncubationTimer < 0.5f)
+            {
+                UpdateDormantState(deltaTime, character);   
+            }
+            else if (IncubationTimer < 1.0f)
+            {
+                UpdateTransitionState(deltaTime, character);
+            }
+            else
+            {
+                UpdateActiveState(deltaTime, character);
+            }
+        }
+
+        private void UpdateDormantState(float deltaTime, Character character)
+        {
+            float prevTimer = IncubationTimer;
+
+            state = InfectionState.Dormant;
+
+            IncubationTimer += deltaTime / IncubationDuration;
+
+            if (Character.Controlled != character) return;
+            
+            if (prevTimer % 0.1f > 0.05f && IncubationTimer % 0.1f < 0.05f)
+            {
+                GUI.AddMessage(InfoTextManager.GetInfoText("HuskDormant"), Color.Red, 4.0f);
+            }
+        }
+
+        private void UpdateTransitionState(float deltaTime, Character character)
+        {
+            IncubationTimer += deltaTime / IncubationDuration;
+
+            if (state == InfectionState.Dormant && Character.Controlled == character)
+            {
+                new GUIMessageBox("", InfoTextManager.GetInfoText("HuskCantSpeak"));
+            }
+
+            state = InfectionState.Transition;
+        }
+
+        private void UpdateActiveState(float deltaTime, Character character)
+        {
+            if (state != InfectionState.Active)
+            {
+                if (Character.Controlled==character) new GUIMessageBox("", InfoTextManager.GetInfoText("HuskActivate"));
+                ActivateHusk(character);
+                state = InfectionState.Active;
+            }
+
+            character.AddDamage(CauseOfDeath.Husk, 0.5f*deltaTime, null);
+        }
+
+
+        private void ActivateHusk(Character character)
+        {
+            character.NeedsAir = false;
+            AttachHuskAppendage(character);
+        }
+
+        private void AttachHuskAppendage(Character character)
+        {
+            XDocument doc = ToolBox.TryLoadXml(Path.Combine("Content", "Characters", "Human", "huskappendage.xml"));
+            if (doc == null || doc.Root == null) return;
+
+            var limbElement = doc.Root.Element("limb");
+            if (limbElement == null)
+            {
+                DebugConsole.ThrowError("Error in huskappendage.xml - limb element not found");
+                return;
+            }
+
+            var jointElement = doc.Root.Element("joint");
+            if (jointElement == null)
+            {
+                DebugConsole.ThrowError("Error in huskappendage.xml - joint element not found");
+                return;
+            }
+
+            character.SetStun(0.5f);
+            if (character.AnimController.Dir < 1.0f)
+            {
+                character.AnimController.Flip();
+            }
+
+            var torso = character.AnimController.GetLimb(LimbType.Torso);
+
+            var newLimb = new Limb(character, limbElement);
+            newLimb.body.Submarine = character.Submarine;
+            newLimb.body.SetTransform(torso.SimPosition, torso.Rotation);
+            
+            character.AnimController.AddLimb(newLimb);
+            character.AnimController.AddJoint(jointElement);
+        }
+
+        public void Remove(Character character)
+        {
+            if (character != null)
+                character.OnDeath -= CharacterDead;
+        }
+
+        private void CharacterDead(Character character, CauseOfDeath causeOfDeath)
+        {
+            if (GameMain.Client != null) return;
+
+            var husk = Character.Create(
+                Path.Combine("Content", "Characters", "Human", "humanhusk.xml"),
+                character.WorldPosition,
+                character.Info, 
+                false, true);
+            
+            foreach (Limb limb in husk.AnimController.Limbs)
+            {
+                if (limb.type == LimbType.None)
+                {
+                    limb.body.SetTransform(character.SimPosition, 0.0f);
+                    continue;
+                }
+
+                var matchingLimb = character.AnimController.GetLimb(limb.type);                
+                limb.body.SetTransform(matchingLimb.SimPosition, matchingLimb.Rotation);
+            }
+
+            for (int i = 0; i < character.Inventory.Items.Length; i++)
+            {
+                if (character.Inventory.Items[i] == null) continue;
+                husk.Inventory.TryPutItem(character.Inventory.Items[i], i, true);
+            }
+            
+            character.Enabled = false;
+            Entity.Spawner.AddToRemoveQueue(character);
+        }
+    }
+}

BarotraumaShared/Source/Characters/Jobs/Job.cs

@@ -0,0 +1,158 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class Job
+    {
+
+        private readonly JobPrefab prefab;
+
+        private Dictionary<string, Skill> skills;
+
+        public string Name
+        {
+            get { return prefab.Name; }
+        }
+
+        public string Description
+        {
+            get { return prefab.Description; }
+        }
+
+        public JobPrefab Prefab
+        {
+            get { return prefab; }
+        }
+
+        public XElement SpawnItems
+        {
+            get { return prefab.Items; }
+        }
+
+        //public List<bool> EquipSpawnItem
+        //{
+        //    get { return prefab.EquipItem; }
+        //}
+
+        public List<Skill> Skills
+        {
+            get { return skills.Values.ToList(); }
+        }
+
+        public Job(JobPrefab jobPrefab)
+        {
+            prefab = jobPrefab;
+
+            skills = new Dictionary<string, Skill>();
+            foreach (SkillPrefab skillPrefab in prefab.Skills)
+            {
+                skills.Add(skillPrefab.Name, new Skill(skillPrefab));
+            }
+        }
+
+        public Job(XElement element)
+        {
+            string name = ToolBox.GetAttributeString(element, "name", "").ToLowerInvariant();
+            prefab = JobPrefab.List.Find(jp => jp.Name.ToLowerInvariant() == name);
+
+            skills = new Dictionary<string, Skill>();
+            foreach (XElement subElement in element.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "skill") continue;
+                string skillName = ToolBox.GetAttributeString(subElement, "name", "");
+                if (string.IsNullOrEmpty(name)) continue;
+                skills.Add(
+                    skillName,
+                    new Skill(skillName, ToolBox.GetAttributeInt(subElement, "level", 0)));
+            }
+        }
+        
+        public static Job Random()
+        {
+            JobPrefab prefab = JobPrefab.List[Rand.Int(JobPrefab.List.Count - 1, false)];
+
+            return new Job(prefab);
+        }
+
+        public int GetSkillLevel(string skillName)
+        {
+            Skill skill = null;
+            skills.TryGetValue(skillName, out skill);
+
+            return (skill==null) ? 0 : skill.Level;
+        }
+
+        public void GiveJobItems(Character character, WayPoint spawnPoint)
+        {
+            if (SpawnItems == null) return;
+
+            foreach (XElement itemElement in SpawnItems.Elements())
+            {
+                InitializeJobItem(character, spawnPoint, itemElement);
+            }            
+        }
+
+        private void InitializeJobItem(Character character, WayPoint spawnPoint, XElement itemElement, Item parentItem = null)
+        {
+            string itemName = ToolBox.GetAttributeString(itemElement, "name", "");
+              
+            ItemPrefab itemPrefab = ItemPrefab.list.Find(ip => ip.Name == itemName) as ItemPrefab;
+            if (itemPrefab == null)
+            {
+                DebugConsole.ThrowError("Tried to spawn \"" + Name + "\" with the item \"" + itemName + "\". Matching item prefab not found.");
+                return;
+            }
+
+            Item item = new Item(itemPrefab, character.Position, null);
+            
+            if (GameMain.Server != null && Entity.Spawner != null)
+            {
+                Entity.Spawner.CreateNetworkEvent(item, false);
+            }
+
+            if (ToolBox.GetAttributeBool(itemElement, "equip", false))
+            {
+                List<InvSlotType> allowedSlots = new List<InvSlotType>(item.AllowedSlots);
+                allowedSlots.Remove(InvSlotType.Any);
+
+                character.Inventory.TryPutItem(item, allowedSlots);
+            }
+            else
+            {
+                character.Inventory.TryPutItem(item, item.AllowedSlots);
+            }
+
+            if (item.Prefab.Name == "ID Card" && spawnPoint != null)
+            {
+                foreach (string s in spawnPoint.IdCardTags)
+                {
+                    item.AddTag(s);
+                }
+            }
+            
+            if (parentItem != null) parentItem.Combine(item);
+
+            foreach (XElement childItemElement in itemElement.Elements())
+            {
+                InitializeJobItem(character, spawnPoint, childItemElement, item);
+            } 
+        }
+
+        public XElement Save(XElement parentElement)
+        {
+            XElement jobElement = new XElement("job");
+
+            jobElement.Add(new XAttribute("name", Name));
+
+            foreach (KeyValuePair<string, Skill> skill in skills)
+            {
+                jobElement.Add(new XElement("skill", new XAttribute("name", skill.Value.Name), new XAttribute("level", skill.Value.Level)));
+            }
+            
+            parentElement.Add(jobElement);
+            return jobElement;
+        }
+    }
+}

BarotraumaShared/Source/Characters/Jobs/JobPrefab.cs

@@ -0,0 +1,168 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Xml.Linq;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class JobPrefab
+    {
+        public static List<JobPrefab> List;
+                
+        public readonly XElement Items;
+        public readonly List<string> ItemNames;
+
+        public List<SkillPrefab> Skills;
+
+        public string Name
+        {
+            get;
+            private set;
+        }
+
+        public string Description
+        {
+            get;
+            private set;
+        }
+
+
+        //if set to true, a client that has chosen this as their preferred job will get it no matter what
+        public bool AllowAlways
+        {
+            get;
+            private set;
+        }
+
+        //how many crew members can have the job (only one captain etc)    
+        public int MaxNumber
+        {
+            get;
+            private set;
+        }
+
+        //how many crew members are REQUIRED to have the job 
+        //(i.e. if one captain is required, one captain is chosen even if all the players have set captain to lowest preference)
+        public int MinNumber
+        {
+            get;
+            private set;
+        }
+
+        public float Commonness
+        {
+            get;
+            private set;
+        }
+
+        public JobPrefab(XElement element)
+        {
+            Name = ToolBox.GetAttributeString(element, "name", "name not found");
+
+            Description = ToolBox.GetAttributeString(element, "description", "");
+
+            MinNumber = ToolBox.GetAttributeInt(element, "minnumber", 0);
+            MaxNumber = ToolBox.GetAttributeInt(element, "maxnumber", 10);
+
+            Commonness = ToolBox.GetAttributeInt(element, "commonness", 10);
+
+            AllowAlways = ToolBox.GetAttributeBool(element, "allowalways", false);
+
+            ItemNames = new List<string>();
+
+            Skills = new List<SkillPrefab>();
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "items":
+                        Items = subElement;
+                        foreach (XElement itemElement in subElement.Elements())
+                        {
+                            string itemName = ToolBox.GetAttributeString(itemElement, "name", "");
+                            if (!string.IsNullOrWhiteSpace(itemName)) ItemNames.Add(itemName);
+                        }
+                        break;
+                    case "skills":
+                        foreach (XElement skillElement in subElement.Elements())
+                        {
+                            Skills.Add(new SkillPrefab(skillElement));
+                        } 
+                        break;
+                }
+            }
+
+            Skills.Sort((x,y) => y.LevelRange.X.CompareTo(x.LevelRange.X));
+        }
+
+        public static JobPrefab Random()
+        {
+            return List[Rand.Int(List.Count)];
+        }
+
+        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;
+        }
+
+        public static void LoadAll(List<string> filePaths)
+        {
+            List = new List<JobPrefab>();
+
+            foreach (string filePath in filePaths)
+            {
+                XDocument doc = ToolBox.TryLoadXml(filePath);
+                if (doc == null || doc.Root == null) return;
+
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    JobPrefab job = new JobPrefab(element);
+                    List.Add(job);
+                }
+            }
+        }
+    }
+}

BarotraumaShared/Source/Characters/Jobs/Skill.cs

@@ -0,0 +1,55 @@
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Barotrauma
+{
+    class Skill
+    {
+        SkillPrefab prefab;
+
+        string name;
+        int level;
+
+        static string[] levelNames = new string[] { 
+            "Untrained", "Incompetent", "Novice", 
+            "Adequate", "Competent", "Proficient", 
+            "Professional", "Master", "Legendary" };
+
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public int Level
+        {
+            get { return level; }
+            set { level = MathHelper.Clamp(value, 0, 100); }
+        }
+
+        public Skill(SkillPrefab prefab)
+        {
+            this.prefab = prefab;
+            this.name = prefab.Name;
+
+            this.level = (int)Rand.Range(prefab.LevelRange.X, prefab.LevelRange.Y);
+        }
+
+        public Skill(string name, int level)
+        {
+            this.name = name;
+
+            this.level = level;
+        }
+
+        /// <summary>
+        /// returns the "name" of some skill level (0-10 -> untrained, etc)
+        /// </summary>
+        public static string GetLevelName(int level)
+        {
+            level = MathHelper.Clamp(level, 0, 100);
+            int scaledLevel = (int)Math.Floor((level / 100.0f) * levelNames.Length);
+
+            return levelNames[Math.Min(scaledLevel, levelNames.Length - 1)];
+        }
+    }
+}

BarotraumaShared/Source/Characters/Jobs/SkillPrefab.cs

@@ -0,0 +1,47 @@
+using Microsoft.Xna.Framework;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class SkillPrefab
+    {
+        private string name;
+
+        private string description;
+
+        private Vector2 levelRange;
+
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public string Description
+        {
+            get { return description; }
+        }
+
+        public Vector2 LevelRange
+        {
+            get { return levelRange; }
+        }
+
+        public SkillPrefab(XElement element) 
+        {
+            name = ToolBox.GetAttributeString(element, "name", "");
+            
+            var levelString = ToolBox.GetAttributeString(element, "level", "");
+            if (levelString.Contains(","))
+            {
+                levelRange = ToolBox.ParseToVector2(levelString, false);
+            }
+            else
+            {
+                float skillLevel = float.Parse(levelString, System.Globalization.CultureInfo.InvariantCulture);
+                levelRange = new Vector2(skillLevel, skillLevel);
+            }
+        }
+
+
+    }
+}

BarotraumaShared/Source/Characters/Limb.cs

@@ -0,0 +1,584 @@
+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
+{
+    public enum LimbType
+    {
+        None, LeftHand, RightHand, LeftArm, RightArm,
+        LeftLeg, RightLeg, LeftFoot, RightFoot, Head, Torso, Tail, Legs, RightThigh, LeftThigh, Waist
+    };
+
+    class Limb
+    {
+        private const float LimbDensity = 15;
+        private const float LimbAngularDamping = 7;
+
+        public readonly Character character;
+        
+        //the physics body of the limb
+        public PhysicsBody body;
+
+        private readonly int refJointIndex;
+
+        private readonly float steerForce;
+
+        private readonly bool doesFlip;
+        
+        protected readonly Vector2 stepOffset;
+        
+        public Sprite sprite, damagedSprite;
+
+        public bool inWater;
+
+        public FixedMouseJoint pullJoint;
+
+        public readonly Lights.LightSource LightSource;
+
+        public readonly LimbType type;
+
+        public readonly bool ignoreCollisions;
+        
+        private float damage, burnt;
+
+        private readonly Vector2 armorSector;
+        private readonly float armorValue;
+
+        Sound hitSound;
+        //a timer for delaying when a hitsound/attacksound can be played again
+        public float soundTimer;
+        public const float SoundInterval = 0.4f;
+
+        public readonly Attack attack;
+
+        private Direction dir;
+
+        private List<WearableSprite> wearingItems;
+
+        private Vector2 animTargetPos;
+        
+        public bool DoesFlip
+        {
+            get { return doesFlip; }
+        }
+
+        public Vector2 WorldPosition
+        {
+            get { return character.Submarine == null ? Position : Position + character.Submarine.Position; }
+        }
+
+        public Vector2 Position
+        {
+            get { return ConvertUnits.ToDisplayUnits(body.SimPosition); }
+        }
+
+        public Vector2 SimPosition
+        {
+            get { return body.SimPosition; }
+        }
+
+        public float Rotation
+        {
+            get { return body.Rotation; }
+        }
+
+        //where an animcontroller is trying to pull the limb, only used for debug visualization
+        public Vector2 AnimTargetPos
+        {
+            get { return animTargetPos; }
+        }
+
+        public float SteerForce
+        {
+            get { return steerForce; }
+        }
+
+        public float Mass
+        {
+            get { return body.Mass; }
+        }
+
+        public bool Disabled { get; set; }
+
+        public Sound HitSound
+        {
+            get { return hitSound; }
+        }
+                
+        public Vector2 LinearVelocity
+        {
+            get { return body.LinearVelocity; }
+        }
+
+        public float Dir
+        {
+            get { return ((dir == Direction.Left) ? -1.0f : 1.0f); }
+            set { dir = (value==-1.0f) ? Direction.Left : Direction.Right; }
+        }
+
+        public int RefJointIndex
+        {
+            get { return refJointIndex; }
+        }
+
+        public Vector2 StepOffset
+        {
+            get { return stepOffset; }
+        }
+
+        public float Burnt
+        {
+            get { return burnt; }
+            set { burnt = MathHelper.Clamp(value,0.0f,100.0f); }
+        }
+
+        private float scale;
+
+        public float AttackTimer;
+
+        //public float Damage
+        //{
+        //    get { return damage; }
+        //    set 
+        //    { 
+        //        damage = Math.Max(value, 0.0f);
+        //        if (damage >=maxHealth) Character.Kill();
+        //    }
+        //}
+
+        //public float MaxHealth
+        //{
+        //    get { return maxHealth; }
+        //}
+
+        //public float Bleeding
+        //{
+        //    get { return bleeding; }
+        //    set { bleeding = MathHelper.Clamp(value, 0.0f, 100.0f); }
+        //}
+
+        public List<WearableSprite> WearingItems
+        {
+            get { return wearingItems; }
+            set { wearingItems = value; }
+        }
+
+        //public WearableSprite WearingItemSprite
+        //{
+        //    get { return wearingItemSprite; }
+        //    set { wearingItemSprite = value; }
+        //}
+
+        public Limb (Character character, XElement element, float scale = 1.0f)
+        {
+            this.character = character;
+
+            WearingItems = new List<WearableSprite>();
+            
+            dir = Direction.Right;
+
+            doesFlip = ToolBox.GetAttributeBool(element, "flip", false);
+
+            this.scale = scale;
+
+            body = new PhysicsBody(element, scale);
+
+            if (ToolBox.GetAttributeBool(element, "ignorecollisions", false))
+            {
+                body.CollisionCategories = Category.None;
+                body.CollidesWith = Category.None;
+
+                ignoreCollisions = true;
+            }
+            else
+            {
+                //limbs don't collide with each other
+                body.CollisionCategories = Physics.CollisionCharacter;
+                body.CollidesWith = Physics.CollisionAll & ~Physics.CollisionCharacter & ~Physics.CollisionItem;
+            }
+            
+            body.UserData = this;
+
+            refJointIndex = -1;
+
+            Vector2 pullJointPos = Vector2.Zero;
+
+            if (element.Attribute("type") != null)
+            {
+                try
+                {
+                    type = (LimbType)Enum.Parse(typeof(LimbType), element.Attribute("type").Value, true);
+                }
+                catch
+                {
+                    type = LimbType.None;
+                    DebugConsole.ThrowError("Error in "+element+"! \""+element.Attribute("type").Value+"\" is not a valid limb type");
+                }
+
+
+                pullJointPos = ToolBox.GetAttributeVector2(element, "pullpos", Vector2.Zero) * scale;
+                pullJointPos = ConvertUnits.ToSimUnits(pullJointPos);
+
+                stepOffset = ToolBox.GetAttributeVector2(element, "stepoffset", Vector2.Zero) * scale;
+                stepOffset = ConvertUnits.ToSimUnits(stepOffset);
+
+                refJointIndex = ToolBox.GetAttributeInt(element, "refjoint", -1);
+
+            }
+            else
+            {
+                type = LimbType.None;
+            }
+
+            pullJoint = new FixedMouseJoint(body.FarseerBody, pullJointPos);
+            pullJoint.Enabled = false;
+            pullJoint.MaxForce = ((type == LimbType.LeftHand || type == LimbType.RightHand) ? 400.0f : 150.0f) * body.Mass;
+
+            GameMain.World.AddJoint(pullJoint);
+
+            steerForce = ToolBox.GetAttributeFloat(element, "steerforce", 0.0f);
+
+            //maxHealth = Math.Max(ToolBox.GetAttributeFloat(element, "health", 100.0f),1.0f);
+
+            armorSector = ToolBox.GetAttributeVector2(element, "armorsector", Vector2.Zero);
+            armorSector.X = MathHelper.ToRadians(armorSector.X);
+            armorSector.Y = MathHelper.ToRadians(armorSector.Y);
+
+            armorValue = Math.Max(ToolBox.GetAttributeFloat(element, "armor", 0.0f), 0.0f);
+            
+            body.BodyType = BodyType.Dynamic;
+            body.FarseerBody.AngularDamping = LimbAngularDamping;
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        string spritePath = subElement.Attribute("texture").Value;
+
+                        string spritePathWithTags = spritePath;
+
+                        if (character.Info != null)
+                        {
+                            spritePath = spritePath.Replace("[GENDER]", (character.Info.Gender == Gender.Female) ? "f" : "");
+                            spritePath = spritePath.Replace("[HEADID]", character.Info.HeadSpriteId.ToString());
+
+                            if (character.Info.HeadSprite != null && character.Info.SpriteTags.Any())
+                            {
+                                string tags = "";
+                                character.Info.SpriteTags.ForEach(tag => tags += "[" + tag + "]");
+
+                                spritePathWithTags = Path.Combine(
+                                    Path.GetDirectoryName(spritePath),
+                                    Path.GetFileNameWithoutExtension(spritePath) + tags + Path.GetExtension(spritePath));
+                            }
+                        }
+
+                        if (File.Exists(spritePathWithTags))
+                        {
+                            sprite = new Sprite(subElement, "", spritePathWithTags);
+                        }
+                        else
+                        {
+
+                            sprite = new Sprite(subElement, "", spritePath);
+                        }
+
+                        break;
+                    case "damagedsprite":
+                        string damagedSpritePath = subElement.Attribute("texture").Value;
+
+                        if (character.Info != null)
+                        {
+                            damagedSpritePath = damagedSpritePath.Replace("[GENDER]", (character.Info.Gender == Gender.Female) ? "f" : "");
+                            damagedSpritePath = damagedSpritePath.Replace("[HEADID]", character.Info.HeadSpriteId.ToString());
+                        }
+
+                        damagedSprite = new Sprite(subElement, "", damagedSpritePath);
+                        break;
+                    case "lightsource":
+                        LightSource = new LightSource(subElement);
+
+                        break;
+                    case "attack":
+                        attack = new Attack(subElement);
+                        break;
+                    case "sound":
+                        hitSound = Sound.Load(ToolBox.GetAttributeString(subElement, "file", ""));
+                        break;
+                }
+            }
+        }
+
+        public void MoveToPos(Vector2 pos, float force, bool pullFromCenter=false)
+        {
+            Vector2 pullPos = body.SimPosition;
+            if (pullJoint!=null && !pullFromCenter)
+            {
+                pullPos = pullJoint.WorldAnchorA;
+            }
+
+            animTargetPos = pos;
+
+            body.MoveToPos(pos, force, pullPos);
+        }
+
+        public AttackResult AddDamage(Vector2 position, DamageType damageType, float amount, float bleedingAmount, bool playSound)
+        {
+            DamageSoundType damageSoundType = (damageType == DamageType.Blunt) ? DamageSoundType.LimbBlunt : DamageSoundType.LimbSlash;
+
+            bool hitArmor = false;
+            float totalArmorValue = 0.0f;
+
+            if (armorValue>0.0f && SectorHit(armorSector, position))
+            {
+                hitArmor = true;
+                totalArmorValue += armorValue;
+            }
+
+            foreach (WearableSprite wearable in wearingItems)
+            {
+                if (wearable.WearableComponent.ArmorValue > 0.0f &&
+                    SectorHit(wearable.WearableComponent.ArmorSectorLimits, position))
+                {
+                    hitArmor = true;
+                    totalArmorValue += wearable.WearableComponent.ArmorValue;
+                }       
+            }
+              
+            
+            if (hitArmor)
+            {
+                totalArmorValue = Math.Max(totalArmorValue, 0.0f);
+
+                damageSoundType = DamageSoundType.LimbArmor;
+                amount = Math.Max(0.0f, amount - totalArmorValue);
+                bleedingAmount = Math.Max(0.0f, bleedingAmount - totalArmorValue);
+            }
+
+            if (playSound)
+            {
+                SoundPlayer.PlayDamageSound(damageSoundType, amount, position);
+            }
+
+            //Bleeding += bleedingAmount;
+            //Damage += amount;
+
+            float bloodAmount = hitArmor || bleedingAmount<=0.0f ? 0 : (int)Math.Min((int)(amount * 2.0f), 20);
+            
+            for (int i = 0; i < bloodAmount; i++)
+            {
+                Vector2 particleVel = SimPosition - position;
+                if (particleVel != Vector2.Zero) particleVel = Vector2.Normalize(particleVel);
+
+                GameMain.ParticleManager.CreateParticle("blood",
+                    WorldPosition,
+                    particleVel * Rand.Range(100.0f, 300.0f), 0.0f, character.AnimController.CurrentHull);
+            }
+
+            for (int i = 0; i < bloodAmount / 2; i++)
+            {
+                GameMain.ParticleManager.CreateParticle("waterblood", WorldPosition, Vector2.Zero, 0.0f, character.AnimController.CurrentHull);
+            }
+
+            damage += Math.Max(amount,bleedingAmount) / character.MaxHealth * 100.0f;
+
+
+            return new AttackResult(amount, bleedingAmount, hitArmor);
+        }
+
+        public bool SectorHit(Vector2 armorSector, Vector2 simPosition)
+        {
+            if (armorSector == Vector2.Zero) return false;
+            
+            float rot = body.Rotation;
+            if (Dir == -1) rot -= MathHelper.Pi;
+
+            Vector2 armorLimits = new Vector2(rot - armorSector.X * Dir, rot - armorSector.Y * Dir);
+
+            float mid = (armorLimits.X + armorLimits.Y) / 2.0f;
+            float angleDiff = MathUtils.GetShortestAngle(MathUtils.VectorToAngle(simPosition - SimPosition), mid);
+
+            return (Math.Abs(angleDiff) < (armorSector.Y - armorSector.X) / 2.0f);
+        }
+
+        public void Update(float deltaTime)
+        {
+            if (LightSource != null)
+            {
+                LightSource.ParentSub = body.Submarine;
+            }
+
+            if (!character.IsDead) damage = Math.Max(0.0f, damage-deltaTime*0.1f);
+
+            if (burnt > 0.0f) Burnt -= deltaTime;
+
+            if (LinearVelocity.X > 500.0f)
+            {
+                //DebugConsole.ThrowError("CHARACTER EXPLODED");
+                body.ResetDynamics();
+                body.SetTransform(character.SimPosition, 0.0f);           
+            }
+
+            if (inWater)
+            {
+                body.ApplyWaterForces();
+            }
+
+            if (character.IsDead) return;
+
+            soundTimer -= deltaTime;
+
+            //if (MathUtils.RandomFloat(0.0f, 1000.0f) < Bleeding)
+            //{
+            //    Game1.particleManager.CreateParticle(
+            //        !inWater ? "blood" : "waterblood",
+            //        SimPosition, Vector2.Zero);
+            //}
+        }
+
+        public void ActivateDamagedSprite()
+        {
+            damage = 100.0f;
+        }
+
+        public void UpdateAttack(float deltaTime, Vector2 attackPosition, IDamageable damageTarget)
+        {
+            float dist = ConvertUnits.ToDisplayUnits(Vector2.Distance(SimPosition, attackPosition));
+
+            AttackTimer += deltaTime;
+
+            body.ApplyTorque(Mass * character.AnimController.Dir * attack.Torque);
+
+            if (dist < attack.Range * 0.5f)
+            {
+                if (AttackTimer >= attack.Duration && damageTarget != null)
+                {
+                    attack.DoDamage(character, damageTarget, WorldPosition, 1.0f, (soundTimer <= 0.0f));
+
+                    soundTimer = Limb.SoundInterval;
+                }
+            }
+
+            Vector2 diff = attackPosition - SimPosition;
+            if (diff.LengthSquared() > 0.00001f)
+            {
+                Vector2 pos = pullJoint == null ? body.SimPosition : pullJoint.WorldAnchorA;
+                body.ApplyLinearImpulse(Mass * attack.Force *
+                    Vector2.Normalize(attackPosition - SimPosition), pos);
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            float brightness = 1.0f - (burnt / 100.0f) * 0.5f;
+            Color color = new Color(brightness, brightness, brightness);
+
+            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);
+            }           
+        }
+        
+
+        public void Remove()
+        {
+            if (sprite != null)
+            {
+                sprite.Remove();
+                sprite = null;
+            }
+
+            if (LightSource != null)
+            {
+                LightSource.Remove();
+            }
+            if (damagedSprite != null)
+            {
+                damagedSprite.Remove();
+                damagedSprite = null;
+            }
+
+            if (body != null)
+            {
+                body.Remove();
+                body = null;
+            }
+
+            if (hitSound != null)
+            {                                
+                hitSound.Remove();
+                hitSound = null;
+            }
+        }
+    }
+}

BarotraumaShared/Source/Characters/StatusEffect.cs

@@ -0,0 +1,337 @@
+using Barotrauma.Particles;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class StatusEffect
+    {
+        [Flags]
+        public enum TargetType
+        {
+            This = 1, Parent = 2, Character = 4, Contained = 8, Nearby = 16, UseTarget = 32, Hull = 64
+        }
+
+        private TargetType targetTypes;
+        private HashSet<string> targetNames;
+
+        private List<RelatedItem> requiredItems;
+
+        public string[] propertyNames;
+        private object[] propertyEffects;
+
+        private bool setValue;
+        
+        private bool disableDeltaTime;
+
+        private HashSet<string> onContainingNames;
+        
+        private readonly float duration;
+
+        private readonly bool useItem;
+
+        public readonly ActionType type;
+
+        private Explosion explosion;
+
+        private List<ParticleEmitterPrefab> particleEmitters;
+
+        public readonly float FireSize;
+
+        private Sound sound;
+        
+        public TargetType Targets
+        {
+            get { return targetTypes; }
+        }
+
+        public HashSet<string> TargetNames
+        {
+            get { return targetNames; }
+        }
+
+        public HashSet<string> OnContainingNames
+        {
+            get { return onContainingNames; }
+        }
+
+        public static StatusEffect Load(XElement element)
+        {
+            if (element.Attribute("delay")!=null)
+            {
+                return new DelayedEffect(element);
+            }
+                
+            return new StatusEffect(element);
+        }
+                
+        protected StatusEffect(XElement element)
+        {
+            requiredItems = new List<RelatedItem>();
+            particleEmitters = new List<ParticleEmitterPrefab>();
+
+            IEnumerable<XAttribute> attributes = element.Attributes();            
+            List<XAttribute> propertyAttributes = new List<XAttribute>();
+            
+            foreach (XAttribute attribute in attributes)
+            {
+                switch (attribute.Name.ToString())
+                {
+                    case "type":
+                        try
+                        {
+                            type = (ActionType)Enum.Parse(typeof(ActionType), attribute.Value, true);
+                        }
+
+                        catch
+                        {
+                            string[] split = attribute.Value.Split('=');
+                            type = (ActionType)Enum.Parse(typeof(ActionType), split[0], true);
+
+                            string[] containingNames = split[1].Split(',');
+                            onContainingNames = new HashSet<string>();
+                            for (int i = 0; i < containingNames.Length; i++)
+                            {
+                                onContainingNames.Add(containingNames[i].Trim());
+                            }
+                        }
+
+                        break;
+                    case "target":
+                        string[] Flags = attribute.Value.Split(',');
+                        foreach (string s in Flags)
+                        {
+                            targetTypes |= (TargetType)Enum.Parse(typeof(TargetType), s, true);
+                        }
+
+                        break;
+                    case "disabledeltatime":                        
+                        disableDeltaTime = ToolBox.GetAttributeBool(attribute, false);
+                        break;
+                    case "setvalue":                        
+                        setValue = ToolBox.GetAttributeBool(attribute, false);
+                        break;
+                    case "targetnames":
+                        string[] names = attribute.Value.Split(',');
+                        targetNames = new HashSet<string>();
+                        for (int i=0; i < names.Length; i++ )
+                        {
+                            targetNames.Add(names[i].Trim());
+                        }
+                        break;
+                    case "sound":
+                        sound = Sound.Load(attribute.Value.ToString());
+                        break;
+                    case "duration":
+                        duration = ToolBox.GetAttributeFloat(attribute, 0.0f);
+                        break;
+                    default:
+                        propertyAttributes.Add(attribute);
+                        break;
+                }
+            }
+
+            int count = propertyAttributes.Count;
+            propertyNames = new string[count];
+            propertyEffects = new object[count];
+
+            int n = 0;
+            foreach (XAttribute attribute in propertyAttributes)
+            {
+                propertyNames[n] = attribute.Name.ToString().ToLowerInvariant();
+                propertyEffects[n] = ToolBox.GetAttributeObject(attribute);
+                n++;
+            }
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "explosion":
+                        explosion = new Explosion(subElement);
+                        break;
+                    case "fire":
+                        FireSize = ToolBox.GetAttributeFloat(subElement,"size",10.0f);
+                        break;
+                    case "use":
+                    case "useitem":
+                        useItem = true;
+                        break;
+                    case "particleemitter":
+                        particleEmitters.Add(new ParticleEmitterPrefab(subElement));
+                        break;
+                    case "requireditem":
+                    case "requireditems":
+                        RelatedItem newRequiredItem = RelatedItem.Load(subElement);
+
+                        if (newRequiredItem == null) continue;
+                        
+                        requiredItems.Add(newRequiredItem);
+                        break;
+                }
+            }
+        }
+
+        private bool HasRequiredItems(Entity entity)
+        {
+            if (requiredItems == null) return true;
+            foreach (RelatedItem requiredItem in requiredItems)
+            {
+                Item item = entity as Item;
+                if (item != null)
+                {
+                    if (!requiredItem.CheckRequirements(null, item)) return false;
+                }
+                Character character = entity as Character;
+                if (character != null)
+                {
+                    if (!requiredItem.CheckRequirements(character, null)) return false;
+                }
+            }
+            return true;
+        }
+
+        public virtual void Apply(ActionType type, float deltaTime, Entity entity, IPropertyObject target)
+        {
+            if (this.type != type || !HasRequiredItems(entity)) return;
+
+            if (targetNames != null && !targetNames.Contains(target.Name)) return;
+
+            List<IPropertyObject> targets = new List<IPropertyObject>();
+            targets.Add(target);
+
+            Apply(deltaTime, entity, targets);
+        }
+
+        public virtual void Apply(ActionType type, float deltaTime, Entity entity, List<IPropertyObject> targets)
+        {
+            if (this.type != type || !HasRequiredItems(entity)) return;
+
+            Apply(deltaTime, entity, targets);
+        }
+
+        protected void Apply(float deltaTime, Entity entity, List<IPropertyObject> targets)
+        {      
+            if (sound != null) sound.Play(1.0f, 1000.0f, entity.WorldPosition);
+
+            if (useItem)
+            {
+                foreach (Item item in targets.FindAll(t => t is Item).Cast<Item>())
+                {
+                    item.Use(deltaTime, targets.FirstOrDefault(t => t is Character) as Character);
+                }
+            }
+
+            foreach (IPropertyObject target in targets)
+            {
+                for (int i = 0; i < propertyNames.Length; i++)
+                {
+                    ObjectProperty property;
+
+                    if (!target.ObjectProperties.TryGetValue(propertyNames[i], out property)) continue;
+
+                    if (duration > 0.0f)
+                    {
+                        CoroutineManager.StartCoroutine(
+                            ApplyToPropertyOverDuration(duration, property, propertyEffects[i]), "statuseffect");
+
+                    }
+                    else
+                    {
+                        ApplyToProperty(property, propertyEffects[i], deltaTime);                          
+                    }
+                }
+            }
+
+            if (explosion != null) explosion.Explode(entity.WorldPosition);
+
+            
+            Hull hull = null;
+            if (entity is Character) 
+            {
+                hull = ((Character)entity).AnimController.CurrentHull;
+            }
+            else if (entity is Item)
+            {
+                hull = ((Item)entity).CurrentHull;
+            }
+
+            if (FireSize > 0.0f)
+            {
+                var fire = new FireSource(entity.WorldPosition, hull);
+
+                fire.Size = new Vector2(FireSize, fire.Size.Y);
+            }   
+
+            foreach (ParticleEmitterPrefab emitter in particleEmitters)
+            {
+                emitter.Emit(entity.WorldPosition, hull);
+            }
+        }
+
+        private IEnumerable<object> ApplyToPropertyOverDuration(float duration, ObjectProperty property, object value)
+        {
+            float timer = duration;
+            while (timer > 0.0f)
+            {
+                ApplyToProperty(property, value, CoroutineManager.UnscaledDeltaTime);
+
+                timer -= CoroutineManager.DeltaTime;
+
+                yield return CoroutineStatus.Running;
+            }
+
+            yield return CoroutineStatus.Success;
+        }
+
+        private void ApplyToProperty(ObjectProperty property, object value, float deltaTime)
+        {
+            if (disableDeltaTime || setValue) deltaTime = 1.0f;
+
+            Type type = value.GetType();
+            if (type == typeof(float) ||
+                (type == typeof(int) && property.GetValue() is float))
+            {
+                float floatValue = Convert.ToSingle(value) * deltaTime;
+                
+                if (!setValue) floatValue += (float)property.GetValue();
+                property.TrySetValue(floatValue);
+            }
+            else if (type == typeof(int) && value is int)
+            {
+                int intValue = (int)((int)value * deltaTime);
+                if (!setValue) intValue += (int)property.GetValue();
+                property.TrySetValue(intValue);
+            }
+            else if (type == typeof(bool) && value is bool)
+            {
+                property.TrySetValue((bool)value);
+            }
+            else if (type == typeof(string))
+            {
+                property.TrySetValue((string)value);
+            }
+            else
+            {
+                DebugConsole.ThrowError("Couldn't apply value "+value.ToString()+" ("+type+") to property \""+property.Name+"\" ("+property.GetValue().GetType()+")! "
+                    +"Make sure the type of the value set in the config files matches the type of the property.");
+            }
+        }
+
+        public static void UpdateAll(float deltaTime)
+        {
+            for (int i = DelayedEffect.List.Count-1; i>= 0; i--)
+            {
+                DelayedEffect.List[i].Update(deltaTime);
+            }
+        }
+
+        public static void StopAll()
+        {
+            CoroutineManager.StopCoroutines("statuseffect");
+        }
+    }
+}

BarotraumaShared/Source/ContentPackage.cs

@@ -0,0 +1,241 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    public enum ContentType
+    {
+        None, 
+        Jobs, 
+        Item, 
+        Character, 
+        Structure, 
+        Executable, 
+        LocationTypes, 
+        LevelGenerationParameters,
+        RandomEvents, 
+        Missions, 
+        BackgroundCreaturePrefabs, BackgroundSpritePrefabs
+    }
+
+    public class ContentPackage
+    {
+
+        public static string Folder = "Data/ContentPackages/";
+
+        public static List<ContentPackage> list = new List<ContentPackage>();
+
+
+        string name;
+
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public string Path
+        {
+            get;
+            private set;
+        }
+
+        private Md5Hash md5Hash;
+
+        public Md5Hash MD5hash
+        {
+            get 
+            {
+                if (md5Hash == null) CalculateHash();
+                return md5Hash; 
+            }
+        }
+
+        public List<ContentFile> files;
+
+        private ContentPackage()
+        {
+            files = new List<ContentFile>();
+        }
+
+        public ContentPackage(string filePath)
+            : this()
+        {
+            XDocument doc = ToolBox.TryLoadXml(filePath);
+
+            Path = filePath;
+
+            if (doc==null)
+            {
+                DebugConsole.ThrowError("Couldn't load content package \""+filePath+"\"!");
+                return;
+            }
+
+
+            name = ToolBox.GetAttributeString(doc.Root, "name", "");
+            
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                ContentType type = (ContentType)Enum.Parse(typeof(ContentType), subElement.Name.ToString(), true);
+                files.Add(new ContentFile(ToolBox.GetAttributeString(subElement, "file", ""), type));                
+            }
+        }
+
+        public override string ToString()
+        {
+            return name;
+        }
+
+        public static ContentPackage CreatePackage(string name)
+        {
+            ContentPackage newPackage = new ContentPackage("Content/Data/"+name);
+            newPackage.name = name;
+            newPackage.Path = Folder + name;
+            list.Add(newPackage);
+
+            return newPackage;
+        }
+
+        public ContentFile AddFile(string path, ContentType type)
+        {
+            if (files.Find(file => file.path == path && file.type == type) != null) return null;
+
+            ContentFile cf = new ContentFile(path, type);
+            files.Add(cf);
+
+            return cf;
+        }
+
+        public void RemoveFile(ContentFile file)
+        {
+            files.Remove(file);
+        }
+
+        public void Save(string filePath)
+        {
+            XDocument doc = new XDocument();
+            doc.Add(new XElement("contentpackage", 
+                new XAttribute("name", name), 
+                new XAttribute("path", Path)));
+
+            //doc.Root.Add(
+            //    new XElement("jobs", new XAttribute("file", JobFile)),
+            //    new XElement("structures", new XAttribute("file", StructureFile)));
+
+            foreach (ContentFile file in files)
+            {
+                doc.Root.Add(new XElement(file.type.ToString(), new XAttribute("file", file.path)));
+            }
+
+            //foreach (string itemFile in itemFiles)
+            //{
+            //    doc.Root.Add(new XElement("item", new XAttribute("file", itemFile)));
+            //}
+            doc.Save(System.IO.Path.Combine(filePath, name+".xml"));
+        }
+
+        private void CalculateHash()
+        {
+            List<byte[]> hashes = new List<byte[]>();
+
+            //foreach (ContentFile file in files)
+            //{
+            //    if (file.path.EndsWith(".xml", true, System.Globalization.CultureInfo.InvariantCulture))
+            //    {
+            //        XDocument doc = ToolBox.TryLoadXml(file.path);
+            //        sb.Append(doc.ToString());
+            //    }          
+            //}
+            var md5 = MD5.Create();
+            foreach (ContentFile file in files)
+            {
+                if (file.type == ContentType.Executable) continue;
+
+                try 
+                {
+                    using (var stream = File.OpenRead(file.path))
+                    {
+                        hashes.Add(md5.ComputeHash(stream));
+                    }               
+                }
+
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError("Error while calculating content package hash: ", e);
+                }
+             
+            }
+
+            //string str = sb.ToString();
+            byte[] bytes = new byte[hashes.Count*16];
+            for (int i = 0; i < hashes.Count; i++ )
+            {
+                hashes[i].CopyTo(bytes, i*16);
+            }
+                //System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
+
+            md5Hash = new Md5Hash(bytes);
+        }
+
+        public List<string> GetFilesOfType(ContentType type)
+        {
+            List<ContentFile> contentFiles = files.FindAll(f => f.type == type);
+
+            List<string> filePaths = new List<string>();
+            foreach (ContentFile contentFile in contentFiles)
+            {
+                filePaths.Add(contentFile.path);
+            }
+            return filePaths;
+        }
+
+        public static void LoadAll(string folder)
+        {
+            if (!Directory.Exists(folder))
+            {
+                try
+                {
+                    Directory.CreateDirectory(folder);
+                }
+                catch
+                {
+                    return;
+                }
+            }
+
+            string[] files = Directory.GetFiles(folder, "*.xml");
+
+            list.Clear();
+
+            foreach (string filePath in files)
+            {
+                ContentPackage package = new ContentPackage(filePath);
+                list.Add(package);
+            }
+        }
+    }
+
+    public class ContentFile
+    {
+        public string path;
+        public ContentType type;
+
+        public ContentFile(string path, ContentType type)
+        {
+            Directory.GetCurrentDirectory();
+            //Path.get
+            this.path = path;
+            this.type = type;
+        }
+
+        public override string ToString()
+        {
+            return path;
+        }
+    }
+
+}

BarotraumaShared/Source/CoroutineManager.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    enum CoroutineStatus
+    {
+        Running, Success, Failure
+    }
+
+    class CoroutineHandle
+    {
+        public readonly IEnumerator<object> Coroutine;
+        public readonly string Name;
+
+        public CoroutineHandle(IEnumerator<object> coroutine, string name = "")
+        {
+            Coroutine = coroutine;
+            Name = string.IsNullOrWhiteSpace(name) ? coroutine.ToString() : name;
+        }
+
+    }
+
+    // Keeps track of all running coroutines, and runs them till the end.
+    static class CoroutineManager
+    {
+        static readonly List<CoroutineHandle> Coroutines = new List<CoroutineHandle>();
+
+        public static float UnscaledDeltaTime, DeltaTime;
+
+        public static CoroutineHandle StartCoroutine(IEnumerable<object> func, string name = "")
+        {
+            var handle = new CoroutineHandle(func.GetEnumerator(), name);
+            Coroutines.Add(handle);
+
+            return handle;
+        }
+
+        public static bool IsCoroutineRunning(string name)
+        {
+            return Coroutines.Any(c => c.Name == name);
+        }
+
+        public static bool IsCoroutineRunning(CoroutineHandle handle)
+        {
+            return Coroutines.Contains(handle);
+        }
+        
+        public static void StopCoroutines(string name)
+        {
+            Coroutines.RemoveAll(c => c.Name == name);
+        }
+
+        public static void StopCoroutines(CoroutineHandle handle)
+        {
+            Coroutines.RemoveAll(c => c == handle);
+        }
+        private static bool IsDone(CoroutineHandle handle)
+        {
+            try
+            {
+                if (handle.Coroutine.Current != null)
+                {
+                    WaitForSeconds wfs = handle.Coroutine.Current as WaitForSeconds;
+                    if (wfs != null)
+                    {
+                        if (!wfs.CheckFinished(UnscaledDeltaTime)) return false;
+                    }
+                    else
+                    {
+                        switch ((CoroutineStatus)handle.Coroutine.Current)
+                        {
+                            case CoroutineStatus.Success:
+                                return true;
+
+                            case CoroutineStatus.Failure:
+                                DebugConsole.ThrowError("Coroutine \"" + handle.Name + "\" has failed");
+                                return true;
+                        }
+                    }
+                }
+
+                handle.Coroutine.MoveNext();
+                return false;
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Coroutine " + handle.Name + " threw an exception: " + e.Message + "\n" + e.StackTrace.ToString());
+                return true;
+            }
+        }
+        // Updating just means stepping through all the coroutines
+        public static void Update(float unscaledDeltaTime, float deltaTime)
+        {
+            UnscaledDeltaTime = unscaledDeltaTime;
+            DeltaTime = deltaTime;
+
+            foreach (var x in Coroutines.ToList())
+                if(IsDone(x))
+                    Coroutines.Remove(x);
+        }
+    }
+  
+    class WaitForSeconds
+    {
+        float timer;
+
+        public WaitForSeconds(float time)
+        {
+            timer = time;
+        }
+
+        public bool CheckFinished(float deltaTime) 
+        {
+            timer -= deltaTime;
+            return timer<=0.0f;
+        }
+    }
+
+
+}

BarotraumaShared/Source/Events/ArtifactEvent.cs

@@ -0,0 +1,79 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class ArtifactEvent : ScriptedEvent
+    {
+        private ItemPrefab itemPrefab;
+
+        private Item item;
+
+        private int state;
+
+        public override string ToString()
+        {
+            return "ScriptedEvent (" + (itemPrefab==null ? "null" : itemPrefab.Name) + ")";
+        }
+        
+        public ArtifactEvent(XElement element)
+            : base(element)
+        {
+            string itemName = ToolBox.GetAttributeString(element, "itemname", "");
+
+            itemPrefab = ItemPrefab.list.Find(ip => ip.Name == itemName) as ItemPrefab;
+
+            if (itemPrefab == null)
+            {
+                DebugConsole.ThrowError("Error in SalvageMission: couldn't find an item prefab with the name "+itemName);
+            }
+        }
+
+        public override void Init()
+        {
+            base.Init();
+
+            Vector2 position = Level.Loaded.GetRandomItemPos(
+                Level.PositionType.Cave | Level.PositionType.MainPath | Level.PositionType.Ruin, 500.0f, 30.0f);
+
+            item = new Item(itemPrefab, position, null);
+            item.MoveWithLevel = true;
+            item.body.FarseerBody.IsKinematic = true;
+
+            //try to find a nearby artifact holder (or any alien itemcontainer) and place the artifact inside it
+            foreach (Item it in Item.ItemList)
+            {
+                if (it.Submarine != null || !it.HasTag("alien")) continue;
+
+                if (Math.Abs(item.WorldPosition.X - it.WorldPosition.X) > 2000.0f) continue;
+                if (Math.Abs(item.WorldPosition.Y - it.WorldPosition.Y) > 2000.0f) continue;
+
+                var itemContainer = it.GetComponent<Items.Components.ItemContainer>();
+                if (itemContainer == null) continue;
+
+                itemContainer.Combine(item);
+                break;
+            }
+        }
+
+        public override void Update(float deltaTime)
+        {
+            switch (state)
+            {
+                case 0:
+                    if (item.ParentInventory!=null) item.body.FarseerBody.IsKinematic = false;
+                    if (item.CurrentHull == null) return;
+
+                    state = 1;
+                    break;
+                case 1:
+                    if (!Submarine.MainSub.AtEndPosition && !Submarine.MainSub.AtStartPosition) return;
+
+                    Finished();
+                    state = 2;
+                    break;
+            }    
+        }
+    }
+}

BarotraumaShared/Source/Events/Missions/CargoMission.cs

@@ -0,0 +1,115 @@
+using Barotrauma.Items.Components;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class CargoMission : Mission
+    {
+        private XElement itemConfig;
+
+        private List<Item> items;
+
+        private int requiredDeliveryAmount;
+
+        public CargoMission(XElement element, Location[] locations)
+            : base(element, locations)
+        {
+            itemConfig = element.Element("Items");
+
+            requiredDeliveryAmount = ToolBox.GetAttributeInt(element, "requireddeliveryamount", 0);
+        }
+
+        private void InitItems()
+        {
+            items = new List<Item>();
+
+            if (itemConfig==null)
+            {
+                DebugConsole.ThrowError("Failed to initialize items for cargo mission (itemConfig == null)");
+                return;
+            }
+
+            foreach (XElement subElement in itemConfig.Elements())
+            {
+                LoadItemAsChild(subElement, null);
+            }
+
+            if (requiredDeliveryAmount == 0) requiredDeliveryAmount = items.Count;
+        }
+
+        private void LoadItemAsChild(XElement element, Item parent)
+        {
+            string itemName = ToolBox.GetAttributeString(element, "name", "");
+
+            ItemPrefab itemPrefab = ItemPrefab.list.Find(ip => ip.Name == itemName) as ItemPrefab;
+            if (itemPrefab==null)
+            {
+                DebugConsole.ThrowError("Couldn't spawn item for cargo mission: item prefab \""+element.Name.ToString()+"\" not found");
+                return;
+            }
+
+            WayPoint cargoSpawnPos = WayPoint.GetRandom(SpawnType.Cargo, null, Submarine.MainSub, true);
+            if (cargoSpawnPos==null)
+            {
+                DebugConsole.ThrowError("Couldn't spawn items for cargo mission, cargo spawnpoint not found");
+                return;
+            }
+
+            var cargoRoom = cargoSpawnPos.CurrentHull;
+
+            if (cargoRoom == null)
+            {
+                DebugConsole.ThrowError("A waypoint marked as Cargo must be placed inside a room!");
+                return;
+            }
+
+            Vector2 position = new Vector2(
+                cargoSpawnPos.Position.X + Rand.Range(-20.0f, 20.0f, false),
+                cargoRoom.Rect.Y - cargoRoom.Rect.Height + itemPrefab.Size.Y / 2);
+
+            var item = new Item(itemPrefab, position, cargoRoom.Submarine);
+            item.FindHull();
+
+
+            items.Add(item);
+            
+            if (parent != null) parent.Combine(item);
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                int amount = ToolBox.GetAttributeInt(subElement, "amount", 1);
+                for (int i = 0; i < amount; i++)
+                {
+                    LoadItemAsChild(subElement, item);
+                }                    
+            }
+        }
+
+        public override void Start(Level level)
+        {
+            InitItems();
+        }
+
+        public override void End()
+        {
+            if (Submarine.MainSub != null && Submarine.MainSub.AtEndPosition)
+            {
+                int deliveredItemCount = items.Count(i => i.CurrentHull != null && i.Condition > 0.0f);
+
+                if (deliveredItemCount >= requiredDeliveryAmount)
+                {
+                    GiveReward();
+
+                    completed = true;
+                }
+            }
+
+            items.ForEach(i => i.Remove());
+        }
+    }
+}

BarotraumaShared/Source/Events/Missions/CombatMission.cs

@@ -0,0 +1,235 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class CombatMission : Mission
+    {
+        private Submarine[] subs;
+        private List<Character>[] crews;
+
+        private int state = 0;
+        private int winner = -1;
+
+        private string[] descriptions;
+
+        private static string[] teamNames = { "Team A", "Team B" };
+
+        private bool initialized = false;
+
+        public override bool AllowRespawn
+        {
+            get { return false; }
+        }
+
+        public override string Description
+        {
+            get
+            {
+                if (GameMain.NetworkMember==null || GameMain.NetworkMember.Character==null)
+                {
+                    //non-team-specific description
+                    return descriptions[0];
+                }
+
+                //team specific
+                return descriptions[GameMain.NetworkMember.Character.TeamID];
+            }
+        }
+
+
+        public override string SuccessMessage
+        {
+            get 
+            {
+                if (winner == -1) return "";
+
+                return successMessage
+                    .Replace("[loser]", teamNames[1 - winner])
+                    .Replace("[winner]", teamNames[winner]);
+            }
+        }
+
+        public CombatMission(XElement element, Location[] locations)
+            : base(element, locations)
+        {
+            descriptions = new string[]
+            {
+                ToolBox.GetAttributeString(element, "descriptionneutral", ""),
+                ToolBox.GetAttributeString(element, "description1", ""),
+                ToolBox.GetAttributeString(element, "description2", "")
+            };
+
+            for (int i = 0; i < descriptions.Length; i++)
+            {
+                for (int n = 0; n < 2; n++)
+                {
+                    descriptions[i] = descriptions[i].Replace("[location" + (n + 1) + "]", locations[n].Name);
+                }
+            }
+
+            teamNames = new string[]
+            {
+                ToolBox.GetAttributeString(element, "teamname1", "Team A"),
+                ToolBox.GetAttributeString(element, "teamname2", "Team B")
+            };
+        }
+
+        public static string GetTeamName(int teamID)
+        {
+            //team IDs start from 1, while teamName array starts from 0
+            teamID--;
+
+            if (teamID < 0 || teamID >= teamNames.Length)
+            {
+                return "Team " + teamID;
+            }
+
+            return teamNames[teamID];
+        }
+
+        public override bool AssignTeamIDs(List<Client> clients, out byte hostTeam)
+        {
+            List<Client> randList = new List<Client>(clients);
+            for (int i = 0; i < randList.Count; i++)
+            {
+                Client a = randList[i];
+                int oi = Rand.Range(0, randList.Count - 1);
+                Client b = randList[oi];
+                randList[i] = b;
+                randList[oi] = a;
+            }
+            int halfPlayers = randList.Count / 2;
+            for (int i = 0; i < randList.Count; i++)
+            {
+                if (i < halfPlayers)
+                {
+                    randList[i].TeamID = 1;
+                }
+                else
+                {
+                    randList[i].TeamID = 2;
+                }
+            }
+            if (halfPlayers * 2 == randList.Count)
+            {
+                hostTeam = (byte)Rand.Range(1, 2);
+            }
+            else if (halfPlayers * 2 < randList.Count)
+            {
+                hostTeam = 1;
+            }
+            else
+            {
+                hostTeam = 2;
+            }
+
+            return true;
+        }
+
+        public override void Start(Level level)
+        {
+            if (GameMain.NetworkMember == null)
+            {
+                DebugConsole.ThrowError("Combat missions cannot be played in the single player mode.");
+                return;
+            }
+            
+            subs = new Submarine[] { Submarine.MainSubs[0], Submarine.MainSubs[1] };
+            subs[1].SetPosition(Level.Loaded.EndPosition - new Vector2(0.0f, 2000.0f));
+            subs[1].FlipX();
+
+            crews = new List<Character>[] { new List<Character>(), new List<Character>() };
+
+            foreach (Submarine submarine in Submarine.Loaded)
+            {
+                //hide all subs from radar to make sneak attacks possible
+                submarine.OnRadar = false;
+            }
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (!initialized)
+            {
+                crews[0].Clear();
+                crews[1].Clear();
+                foreach (Character character in Character.CharacterList)
+                {
+                    if (character.TeamID == 1)
+                    {
+                        crews[0].Add(character);
+                    }
+                    else if (character.TeamID == 2)
+                    {
+                        crews[1].Add(character);
+                    }
+                }
+
+                if (GameMain.Client != null)
+                {
+                    //no characters in one of the teams, the client may not have received all spawn messages yet
+                    if (crews[0].Count == 0 || crews[1].Count == 0) return;
+                }
+
+                initialized = true;
+            }
+            
+            bool[] teamDead = 
+            { 
+                crews[0].All(c => c.IsDead || c.IsUnconscious),
+                crews[1].All(c => c.IsDead || c.IsUnconscious)
+            };
+
+            if (state == 0)
+            {
+                for (int i = 0; i < teamDead.Length; i++)
+                {
+                    if (!teamDead[i] && teamDead[1-i])
+                    {
+                        //make sure nobody in the other team can be revived because that would be pretty weird
+                        crews[1-i].ForEach(c => { if (!c.IsDead) c.Kill(CauseOfDeath.Damage); });
+
+                        winner = i;
+
+                        ShowMessage(i);
+                        state = 1;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                if (winner>=0 && subs[winner] != null && 
+                    (winner == 0 && subs[winner].AtStartPosition) || (winner == 1 && subs[winner].AtEndPosition) &&
+                    crews[winner].Any(c => !c.IsDead && c.Submarine == subs[winner]))
+                {
+                    GameMain.GameSession.CrewManager.WinningTeam = winner+1;
+                    if (GameMain.Server != null) GameMain.Server.EndGame();
+                }
+            }
+
+            if (teamDead[0] && teamDead[1])
+            {
+                GameMain.GameSession.CrewManager.WinningTeam = 0;
+                winner = -1;
+                if (GameMain.Server != null) GameMain.Server.EndGame();
+            }
+        }
+
+        public override void End()
+        {
+            if (GameMain.NetworkMember == null) return;            
+            
+            if (winner > -1)
+            {
+                GiveReward();
+                completed = true;
+            }
+        }
+    }
+}

BarotraumaShared/Source/Events/Missions/Mission.cs

@@ -0,0 +1,270 @@
+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
+{
+    class Mission
+    {
+        public static List<string> MissionTypes = new List<string>() { "Random" };
+        
+        private string name;
+
+        private string description;
+
+        protected bool completed;
+
+        protected string successMessage;
+        protected string failureMessage;
+
+        protected string radarLabel;
+
+        protected List<string> headers;
+        protected List<string> messages;
+
+        private int reward;
+        
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public virtual string Description
+        {
+            get { return description; }
+        }
+
+        public int Reward
+        {
+            get { return reward; }
+        }
+
+        public bool Completed
+        {
+            get { return completed; }
+            set { completed = value; }
+        }
+
+        public virtual bool AllowRespawn
+        {
+            get { return true; }
+        }
+
+        public virtual string RadarLabel
+        {
+            get { return radarLabel; }
+        }
+
+        public virtual Vector2 RadarPosition
+        {
+            get { return Vector2.Zero; }
+        }
+
+        virtual public string SuccessMessage
+        {
+            get { return successMessage; }
+        }
+
+        public string FailureMessage
+        {
+            get { return failureMessage; }
+        }
+
+        public static void Init()
+        {
+            var files = GameMain.SelectedPackage.GetFilesOfType(ContentType.Missions);
+            foreach (string file in files)
+            {
+                XDocument doc = ToolBox.TryLoadXml(file);
+                if (doc == null || doc.Root == null) continue;
+
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    string missionTypeName = element.Name.ToString();
+                    missionTypeName = missionTypeName.Replace("Mission", "");
+
+                    if (!MissionTypes.Contains(missionTypeName)) MissionTypes.Add(missionTypeName);
+                }
+
+            }
+        }
+
+        public Mission(XElement element, Location[] locations)
+        {
+            name = ToolBox.GetAttributeString(element, "name", "");
+
+            description = ToolBox.GetAttributeString(element, "description", "");
+
+            reward = ToolBox.GetAttributeInt(element, "reward", 1);
+
+            successMessage = ToolBox.GetAttributeString(element, "successmessage", 
+                "Mission completed successfully");
+            failureMessage = ToolBox.GetAttributeString(element, "failuremessage", 
+                "Mission failed");
+
+            radarLabel = ToolBox.GetAttributeString(element, "radarlabel", "");
+
+            messages = new List<string>();
+            headers = new List<string>();
+            foreach (XElement subElement in element.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "message") continue;
+                headers.Add(ToolBox.GetAttributeString(subElement, "header", ""));
+                messages.Add(ToolBox.GetAttributeString(subElement, "text", ""));
+            }
+            
+            for (int n = 0; n < 2; n++)
+            {
+                description = description.Replace("[location" + (n + 1) + "]", locations[n].Name);
+
+                successMessage = successMessage.Replace("[location" + (n + 1) + "]", locations[n].Name);
+                failureMessage = failureMessage.Replace("[location" + (n + 1) + "]", locations[n].Name);
+
+                for (int m = 0; m < messages.Count; m++)
+                {
+                    messages[m] = messages[m].Replace("[location" + (n + 1) + "]", locations[n].Name);
+                }
+            }
+        }
+
+        public static Mission LoadRandom(Location[] locations, MTRandom rand, string missionType = "", bool isSinglePlayer = false)
+        {
+            missionType = missionType.ToLowerInvariant();
+
+            var files = GameMain.SelectedPackage.GetFilesOfType(ContentType.Missions);
+            string configFile = files[rand.Next(files.Count)];
+
+            XDocument doc = ToolBox.TryLoadXml(configFile);
+            if (doc == null) return null;
+
+            int eventCount = doc.Root.Elements().Count();
+            //int[] commonness = new int[eventCount];
+            float[] eventProbability = new float[eventCount];
+
+            float probabilitySum = 0.0f;
+
+            List<XElement> matchingElements = new List<XElement>();
+
+            if (missionType == "random")
+            {
+                matchingElements = doc.Root.Elements().ToList();
+            }
+            else if (missionType == "none")
+            {
+                return null;
+            }
+            else if (string.IsNullOrWhiteSpace(missionType))
+            {
+                matchingElements = doc.Root.Elements().ToList();           
+            }
+            else
+            {
+                matchingElements = doc.Root.Elements().ToList().FindAll(m => m.Name.ToString().ToLowerInvariant().Replace("mission", "") == missionType);
+            }
+
+            if (isSinglePlayer)
+            {
+                matchingElements.RemoveAll(m => ToolBox.GetAttributeBool(m, "multiplayeronly", false));
+            }
+            else
+            {
+                matchingElements.RemoveAll(m => ToolBox.GetAttributeBool(m, "singleplayeronly", false));
+            }
+            
+            int i = 0;
+            foreach (XElement element in matchingElements)
+            {
+                eventProbability[i] = ToolBox.GetAttributeInt(element, "commonness", 1);
+
+                probabilitySum += eventProbability[i];
+
+                i++;
+            }
+
+            float randomNumber = (float)rand.NextDouble() * probabilitySum;
+
+            i = 0;
+            foreach (XElement element in matchingElements)
+            {
+                if (randomNumber <= eventProbability[i])
+                {
+                    Type t;
+                    string type = element.Name.ToString();
+
+                    try
+                    {
+                        t = Type.GetType("Barotrauma." + type, true, true);
+                        if (t == null)
+                        {
+                            DebugConsole.ThrowError("Error in " + configFile + "! Could not find a mission class of the type \"" + type + "\".");
+                            continue;
+                        }
+                    }
+                    catch
+                    {
+                        DebugConsole.ThrowError("Error in " + configFile + "! Could not find a mission class of the type \"" + type + "\".");
+                        continue;
+                    }
+                    
+                    ConstructorInfo constructor = t.GetConstructor(new[] { typeof(XElement), typeof(Location[]) });
+                    
+                    object instance = constructor.Invoke(new object[] { element, locations });
+
+                    Mission mission = (Mission)instance;
+                    
+                    return mission;
+                }
+
+                randomNumber -= eventProbability[i];
+                i++;
+            }
+
+            return null;
+        }
+
+        public virtual void Start(Level level) { }
+
+        public virtual void Update(float deltaTime) { }
+
+        public virtual bool AssignTeamIDs(List<Networking.Client> clients, out byte hostTeam)
+        {
+            clients.ForEach(c => c.TeamID = 1);
+            hostTeam = 1; 
+            return false; 
+        }
+
+        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);
+        }
+
+        /// <summary>
+        /// End the mission and give a reward if it was completed successfully
+        /// </summary>
+        public virtual void End()
+        {
+            completed = true;
+
+            GiveReward();
+        }
+
+        public void GiveReward()
+        {
+            var mode = GameMain.GameSession.gameMode as SinglePlayerMode;
+            if (mode == null) return;
+
+            mode.Money += reward;
+        }
+    }
+}

BarotraumaShared/Source/Events/Missions/MonsterMission.cs

@@ -0,0 +1,64 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using System;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class MonsterMission : Mission
+    {
+        private string monsterFile;
+
+        private int state;
+
+        private Character monster;
+
+        private Vector2 radarPosition;
+
+        public override Vector2 RadarPosition
+        {
+            get { return monster != null && !monster.IsDead ? radarPosition : Vector2.Zero; }
+        }
+
+        public MonsterMission(XElement element, Location[] locations)
+            : base(element, locations)
+        {
+            monsterFile = ToolBox.GetAttributeString(element, "monsterfile", "");
+        }
+
+        public override void Start(Level level)
+        {
+            Vector2 spawnPos = Level.Loaded.GetRandomInterestingPosition(true, Level.PositionType.MainPath, true);
+
+            monster = Character.Create(monsterFile, spawnPos, null, GameMain.Client != null);
+            monster.Enabled = false;
+            radarPosition = spawnPos;
+        }
+
+        public override void Update(float deltaTime)
+        {
+            switch (state)
+            {
+                case 0:
+                    if (monster.Enabled)
+                    {
+                        radarPosition = monster.Position;
+                    }
+
+                    if (!monster.IsDead) return;
+                    ShowMessage(state);
+                    state = 1;
+                    break;
+            }
+        }
+        
+        public override void End()
+        {
+            if (!monster.IsDead) return;
+                        
+            GiveReward();
+
+            completed = true;
+        }
+    }
+}

BarotraumaShared/Source/Events/Missions/SalvageMission.cs

@@ -0,0 +1,107 @@
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class SalvageMission : Mission
+    {
+        private ItemPrefab itemPrefab;
+
+        private Item item;
+
+        private Level.PositionType spawnPositionType;
+
+        private int state;
+
+        public override Vector2 RadarPosition
+        {
+            get
+            {
+                return state>0 ? Vector2.Zero : ConvertUnits.ToDisplayUnits(item.SimPosition);
+            }
+        }
+
+        public SalvageMission(XElement element, Location[] locations)
+            : base(element, locations)
+        {
+            string itemName = ToolBox.GetAttributeString(element, "itemname", "");
+
+            itemPrefab = ItemPrefab.list.Find(ip => ip.Name == itemName) as ItemPrefab;
+            
+            string spawnPositionTypeStr = ToolBox.GetAttributeString(element, "spawntype", "");
+
+            if (string.IsNullOrWhiteSpace(spawnPositionTypeStr) ||
+                !Enum.TryParse<Level.PositionType>(spawnPositionTypeStr, true, out spawnPositionType))
+            {
+                spawnPositionType = Level.PositionType.Cave | Level.PositionType.Ruin;
+            }
+
+            if (itemPrefab == null)
+            {
+                DebugConsole.ThrowError("Error in SalvageMission: couldn't find an item prefab with the name "+itemName);
+            }
+        }
+
+        public override void Start(Level level)
+        {
+            Vector2 position = Level.Loaded.GetRandomItemPos(spawnPositionType, 100.0f, 30.0f);
+            
+            item = new Item(itemPrefab, position, null);
+            item.MoveWithLevel = true;
+            item.body.FarseerBody.IsKinematic = true;
+
+            if (item.HasTag("alien"))
+            {
+                //try to find a nearby artifact holder (or any alien itemcontainer) and place the artifact inside it
+                foreach (Item it in Item.ItemList)
+                {
+                    if (it.Submarine != null || !it.HasTag("alien")) continue;
+
+                    if (Math.Abs(item.WorldPosition.X - it.WorldPosition.X) > 2000.0f) continue;
+                    if (Math.Abs(item.WorldPosition.Y - it.WorldPosition.Y) > 2000.0f) continue;
+
+                    var itemContainer = it.GetComponent<Items.Components.ItemContainer>();
+                    if (itemContainer == null) continue;
+
+                    itemContainer.Combine(item);
+                    break;
+                }
+            }
+        }
+
+        public override void Update(float deltaTime)
+        {
+            switch (state)
+            {
+                case 0:
+                    //item.body.LinearVelocity = Vector2.Zero;
+                    if (item.ParentInventory!=null) item.body.FarseerBody.IsKinematic = false;
+                    if (item.CurrentHull == null) return;
+                    
+                    ShowMessage(state);
+                    state = 1;
+                    break;
+                case 1:
+                    if (!Submarine.MainSub.AtEndPosition && !Submarine.MainSub.AtStartPosition) return;
+                    ShowMessage(state);
+                    state = 2;
+                    break;
+            }    
+        }
+
+        public override void End()
+        {
+            if (item.CurrentHull == null || !item.CurrentHull.Submarine.AtEndPosition || item.Removed) return;
+            item.Remove();
+
+            GiveReward();
+
+            completed = true;
+        }
+    }
+}

BarotraumaShared/Source/Events/MonsterEvent.cs

@@ -0,0 +1,134 @@
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class MonsterEvent : ScriptedEvent
+    {
+        private string characterFile;
+
+        private int minAmount, maxAmount;
+
+        private Character[] monsters;
+
+        private bool spawnDeep;
+
+        private bool disallowed;
+        
+        private Level.PositionType spawnPosType;
+
+        public override string ToString()
+        {
+            return "ScriptedEvent (" + characterFile + ")";
+        }
+
+        private bool isActive;
+        public override bool IsActive
+        {
+            get
+            {
+                return isActive;
+            }
+        }
+
+        public MonsterEvent(XElement element)
+            : base (element)
+        {
+            characterFile = ToolBox.GetAttributeString(element, "characterfile", "");
+
+            minAmount = ToolBox.GetAttributeInt(element, "minamount", 1);
+            maxAmount = Math.Max(ToolBox.GetAttributeInt(element, "maxamount", 1), minAmount);
+
+            var spawnPosTypeStr = ToolBox.GetAttributeString(element, "spawntype", "");
+
+            if (string.IsNullOrWhiteSpace(spawnPosTypeStr) ||
+                !Enum.TryParse<Level.PositionType>(spawnPosTypeStr, true, out spawnPosType))
+            {
+                spawnPosType = Level.PositionType.MainPath;
+            }
+
+            spawnDeep = ToolBox.GetAttributeBool(element, "spawndeep", false);
+
+            if (GameMain.NetworkMember != null)
+            {
+                List<string> monsterNames = GameMain.NetworkMember.monsterEnabled.Keys.ToList();
+                string tryKey = monsterNames.Find(s => characterFile.ToLower().Contains(s.ToLower()));
+                if (!string.IsNullOrWhiteSpace(tryKey))
+                {
+                    if (!GameMain.NetworkMember.monsterEnabled[tryKey]) disallowed = true; //spawn was disallowed by host
+                }
+            }
+        }
+
+        public override void Init()
+        {
+            base.Init();
+
+            SpawnMonsters();
+        }
+
+        private void SpawnMonsters()
+        {
+            if (disallowed) return;
+            
+            Vector2 spawnPos = Level.Loaded.GetRandomInterestingPosition(true, spawnPosType, true);
+            
+            int amount = Rand.Range(minAmount, maxAmount, false);
+
+            monsters = new Character[amount];
+
+            if (spawnDeep) spawnPos.Y -= Level.Loaded.Size.Y;
+                
+            for (int i = 0; i < amount; i++)
+            {
+                spawnPos.X += Rand.Range(-0.5f, 0.5f, false);
+                spawnPos.Y += Rand.Range(-0.5f, 0.5f, false);
+                monsters[i] = Character.Create(characterFile, spawnPos, null, GameMain.Client != null);
+            }
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (disallowed)
+            {
+                Finished();
+                return;
+            }
+            if (monsters == null) SpawnMonsters();
+
+            if (isFinished) return;
+
+            isActive = false;
+
+            Entity targetEntity = null;
+            if (Character.Controlled != null)
+            {
+                targetEntity = Character.Controlled;
+            }
+            else
+            {
+                targetEntity = Submarine.FindClosest(GameMain.GameScreen.Cam.WorldViewCenter);
+            }
+
+            bool monstersDead = true;
+            foreach (Character monster in monsters)
+            {
+                if (!monster.IsDead)
+                {
+                    monstersDead = false;
+
+                    if (targetEntity != null && Vector2.DistanceSquared(monster.WorldPosition, targetEntity.WorldPosition) < 5000.0f * 5000.0f)
+                    {
+                        isActive = true;
+                        break;
+                    }
+                }
+            }
+
+            if (monstersDead) Finished();
+        }
+    }
+}

BarotraumaShared/Source/Events/PropertyTask.cs

@@ -0,0 +1,28 @@
+namespace Barotrauma
+{
+    class PropertyTask : Task
+    {
+        Item item;
+
+        
+        public delegate bool IsFinishedHandler();
+        private IsFinishedHandler IsFinishedChecker;
+
+        public PropertyTask(Item item, IsFinishedHandler isFinished, float priority, string name)
+            : base(priority, name)
+        {
+            if (taskManager == null) return;
+
+            this.item = item;
+            IsFinishedChecker = isFinished;
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (IsFinishedChecker())
+            {
+                Finished();
+            }
+        }
+    }
+}

BarotraumaShared/Source/Events/RepairTask.cs

@@ -0,0 +1,20 @@
+namespace Barotrauma
+{
+    class RepairTask : Task
+    {
+        Item item;
+
+        public RepairTask(Item item, float priority, string name)
+            : base(priority, name)
+        {
+            if (taskManager == null) return;
+
+            this.item = item;
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (item.Condition > 50.0f) Finished();
+        }
+    }
+}

BarotraumaShared/Source/Events/ScriptedEvent.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class ScriptedEvent
+    {
+        protected string name;
+        protected string description;
+
+        protected int commonness;
+        protected int difficulty;
+
+        protected bool isFinished;
+        
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public string Description
+        {
+            get { return description; }
+        }
+
+        public int Commonness
+        {
+            get { return commonness; }
+        }
+
+        public string MusicType
+        {
+            get;
+            set;
+        }
+
+        public virtual bool IsActive
+        {
+            get { return true; }
+        }
+        
+        public bool IsFinished
+        {
+            get { return isFinished; }
+        }
+
+        public int Difficulty
+        {
+            get { return difficulty; }
+        }
+
+        public override string ToString()
+        {
+            return "ScriptedEvent ("+name+")";
+        }
+
+        public ScriptedEvent(XElement element)
+        {
+            name = ToolBox.GetAttributeString(element, "name", "");
+            description = ToolBox.GetAttributeString(element, "description", "");
+
+            difficulty = ToolBox.GetAttributeInt(element, "difficulty", 1);
+            commonness = ToolBox.GetAttributeInt(element, "commonness", 1);
+
+            MusicType = ToolBox.GetAttributeString(element, "musictype", "default");
+        }
+
+
+        public static ScriptedEvent LoadRandom(Random rand)
+        {
+            var configFiles = GameMain.Config.SelectedContentPackage.GetFilesOfType(ContentType.RandomEvents);
+
+            if (!configFiles.Any())
+            {
+                DebugConsole.ThrowError("No config files for random events found in the selected content package");
+                return null;
+            }
+
+            string configFile = configFiles[0];
+
+            XDocument doc = ToolBox.TryLoadXml(configFile);
+            if (doc == null) return null;
+            
+            int eventCount = doc.Root.Elements().Count();
+            //int[] commonness = new int[eventCount];
+            float[] eventProbability = new float[eventCount];
+
+            float probabilitySum = 0.0f;
+
+            int i = 0;
+            foreach (XElement element in doc.Root.Elements())
+            {
+                eventProbability[i] = ToolBox.GetAttributeInt(element, "commonness", 1);
+
+                //if the event has been previously selected, it's less likely to be selected now
+                //int previousEventIndex = previousEvents.FindIndex(x => x == i);
+                //if (previousEventIndex >= 0)
+                //{
+                //    //how many shifts ago was the event last selected
+                //    int eventDist = eventCount - previousEventIndex;
+
+                //    float weighting = (1.0f / eventDist) * PreviouslyUsedWeight;
+
+                //    eventProbability[i] *= weighting;
+                //}
+
+                probabilitySum += eventProbability[i];
+
+                i++;
+            }
+
+            float randomNumber = (float)rand.NextDouble() * probabilitySum;
+
+            i = 0;
+            foreach (XElement element in doc.Root.Elements())
+            {
+                if (randomNumber <= eventProbability[i])
+                {
+                    Type t;
+                    string type = element.Name.ToString();
+
+                    try
+                    {
+                        t = Type.GetType("Barotrauma." + type, true, true);
+                        if (t == null)
+                        {
+                            DebugConsole.ThrowError("Error in " + configFile + "! Could not find an event class of the type \"" + type + "\".");
+                            continue;
+                        }
+                    }
+                    catch
+                    {
+                        DebugConsole.ThrowError("Error in " + configFile + "! Could not find an event class of the type \"" + type + "\".");
+                        continue;
+                    }
+
+                    ConstructorInfo constructor = t.GetConstructor(new[] { typeof(XElement) });
+                    object instance = null;
+                    try
+                    {
+                        instance = constructor.Invoke(new object[] { element });
+                    }
+                    catch (Exception ex)
+                    {
+                        DebugConsole.ThrowError(ex.InnerException!=null ? ex.InnerException.ToString() : ex.ToString());
+                    }
+
+                    //previousEvents.Add(i);
+
+                    return (ScriptedEvent)instance;
+                }
+
+                randomNumber -= eventProbability[i];
+                i++;
+            }
+
+            return null;
+        }
+
+        public virtual void Init()
+        {
+            isFinished = false;
+        }
+
+        public virtual void Update(float deltaTime)
+        {
+        }
+
+        public virtual void Finished()
+        {
+            isFinished = true;
+        }
+    }
+}

BarotraumaShared/Source/Events/ScriptedTask.cs

@@ -0,0 +1,32 @@
+namespace Barotrauma
+{
+    class ScriptedTask : Task
+    {
+        private ScriptedEvent scriptedEvent;
+
+        public override bool IsStarted
+        {
+            get
+            {
+                return scriptedEvent.IsActive;
+            }
+        }
+
+        public ScriptedTask(ScriptedEvent scriptedEvent)
+            : base(scriptedEvent.Difficulty, scriptedEvent.Name)
+        {
+            if (taskManager == null) return;
+
+            this.musicType = scriptedEvent.MusicType;
+
+            this.scriptedEvent = scriptedEvent;
+            scriptedEvent.Init();
+        }
+
+        public override void Update(float deltaTime)
+        {
+            scriptedEvent.Update(deltaTime);
+            if (scriptedEvent.IsFinished) Finished();
+        }
+    }
+}

BarotraumaShared/Source/Events/Task.cs

@@ -0,0 +1,64 @@
+
+namespace Barotrauma
+{
+    class Task
+    {
+      
+        protected string name;
+
+        private float priority;
+
+        protected string musicType;
+
+        protected TaskManager taskManager;
+
+        protected bool isFinished;
+
+        public string Name
+        {
+            get { return name; }
+        }
+
+        public float Priority
+        {
+            get { return priority; }
+        }
+
+        public string MusicType
+        {
+            get { return musicType; }
+        }
+
+        public bool IsFinished
+        {
+            get { return isFinished; }
+        }
+
+        public virtual bool IsStarted
+        {
+            get { return true; }
+        }
+
+        public Task(float priority, string name)
+        {
+            if (GameMain.GameSession==null || GameMain.GameSession.TaskManager == null) return;
+
+            taskManager = GameMain.GameSession.TaskManager;
+            musicType = "repair";
+            this.priority = priority;
+            this.name = name;
+
+            taskManager.AddTask(this);
+        }
+
+        public virtual void Update(float deltaTime)
+        {
+
+        }
+
+        protected virtual void Finished()
+        {
+            isFinished = true;
+        }
+    }
+}

BarotraumaShared/Source/Events/TaskManager.cs

@@ -0,0 +1,87 @@
+using System.Collections.Generic;
+using System;
+using System.Linq;
+
+namespace Barotrauma
+{
+    class TaskManager
+    {
+        const float CriticalPriority = 50.0f;
+
+        private List<Task> tasks;
+
+        public List<Task> Tasks
+        {
+            get { return tasks; }
+        }
+
+        public bool CriticalTasks
+        {
+            get
+            {
+                return tasks.Any(task => task.Priority >= CriticalPriority);
+            }
+        }
+
+        public TaskManager(GameSession session)
+        {
+            tasks = new List<Task>();        
+        }
+
+        public void AddTask(Task newTask)
+        {
+            if (tasks.Contains(newTask)) return;
+            
+            tasks.Add(newTask);
+        }
+
+        public void StartShift(Level level)
+        {
+            CreateScriptedEvents(level);
+        }
+
+
+        public void EndShift()
+        {
+            tasks.Clear();
+        }
+
+        private void CreateScriptedEvents(Level level)
+        {
+            MTRandom rand = new MTRandom(ToolBox.StringToInt(level.Seed));
+
+            float totalDifficulty = level.Difficulty;
+
+            int tries = 0;
+            while (tries < 5)
+            {
+                ScriptedEvent scriptedEvent = ScriptedEvent.LoadRandom(rand);
+                if (scriptedEvent==null || scriptedEvent.Difficulty > totalDifficulty)
+                {
+                    tries++;
+                    continue;
+                }
+                DebugConsole.Log("Created scripted event " + scriptedEvent.ToString());
+
+                AddTask(new ScriptedTask(scriptedEvent));
+                totalDifficulty -= scriptedEvent.Difficulty;
+                tries = 0;
+            } 
+
+        }
+        
+        public void Update(float deltaTime)
+        {
+            foreach (Task task in tasks)
+            {
+                if (!task.IsFinished)
+                {             
+                    task.Update(deltaTime);
+                }
+            }
+
+            tasks.RemoveAll(t => t.IsFinished);
+        }
+
+    }
+}

BarotraumaShared/Source/FrameCounter.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+        public class FrameCounter
+        {
+            public long TotalFrames { get; private set; }
+            public double TotalSeconds { get; private set; }
+            public double AverageFramesPerSecond { get; private set; }
+            public double CurrentFramesPerSecond { get; private set; }
+
+            public const int MaximumSamples = 10;
+
+            private Queue<double> sampleBuffer = new Queue<double>();
+
+            public bool Update(double deltaTime)
+            {
+                //float deltaTime = stopwatch.ElapsedMilliseconds / 1000.0f;
+
+                if (deltaTime == 0.0f) { return false; }
+                //stopwatch.Restart();
+
+                CurrentFramesPerSecond = (1.0 / deltaTime);
+
+                sampleBuffer.Enqueue(CurrentFramesPerSecond);
+
+                if (sampleBuffer.Count > MaximumSamples)
+                {
+                    sampleBuffer.Dequeue();
+                    AverageFramesPerSecond = sampleBuffer.Average(i => i);
+                }
+                else
+                {
+                    AverageFramesPerSecond = CurrentFramesPerSecond;
+                }
+
+                if (AverageFramesPerSecond < 0 || AverageFramesPerSecond > 500) { }
+                  
+                TotalFrames++;
+                TotalSeconds += deltaTime;
+                return true;
+            }
+        }
+    
+}

BarotraumaShared/Source/GameMain.cs

@@ -0,0 +1,420 @@
+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
+{
+#if CLIENT
+    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;
+
+            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()
+        {
+            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));
+            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;
+        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);
+        }
+
+    }
+#endif
+}

BarotraumaShared/Source/GameSession/CargoManager.cs

@@ -0,0 +1,50 @@
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class CargoManager
+    {
+        private List<ItemPrefab> purchasedItems;
+        
+        public CargoManager()
+        {
+            purchasedItems = new List<ItemPrefab>();
+        }
+
+        public void AddItem(ItemPrefab item)
+        {
+            purchasedItems.Add(item);
+        }
+
+        public void CreateItems()
+        {
+            WayPoint wp = WayPoint.GetRandom(SpawnType.Cargo, null, Submarine.MainSub);
+
+            if (wp==null)
+            {
+                DebugConsole.ThrowError("The submarine must have a waypoint marked as Cargo for bought items to be placed correctly!");
+                return;
+            }
+
+            Hull cargoRoom = Hull.FindHull(wp.WorldPosition);
+
+            if (cargoRoom == null)
+            {
+                DebugConsole.ThrowError("A waypoint marked as Cargo must be placed inside a room!");
+                return;
+            }
+
+            foreach (ItemPrefab prefab in purchasedItems)
+            {
+                Vector2 position = new Vector2(
+                    Rand.Range(cargoRoom.Rect.X + 20, cargoRoom.Rect.Right - 20),
+                    cargoRoom.Rect.Y - cargoRoom.Rect.Height + prefab.Size.Y/2);
+
+                new Item(prefab, position, wp.Submarine);
+            }
+
+            purchasedItems.Clear();
+        }
+    }
+}

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

BarotraumaShared/Source/GameSession/GameModes/GameMode.cs

@@ -0,0 +1,108 @@
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class GameMode
+    {
+        public static List<GameModePreset> PresetList = new List<GameModePreset>();
+
+        protected DateTime startTime;
+
+        //public readonly bool IsSinglePlayer;
+
+        protected bool isRunning;
+
+        //protected string name;
+
+        protected GameModePreset preset;
+
+        private string endMessage;
+
+        public virtual Mission Mission
+        {
+            get { return null; }
+        }
+
+        public bool IsRunning
+        {
+            get { return isRunning; }
+        }
+
+        public bool IsSinglePlayer
+        {
+            get { return preset.IsSinglePlayer; }
+        }
+
+        public string Name
+        {
+            get { return preset.Name; }
+        }
+
+        public string EndMessage
+        {
+            get { return endMessage; }
+        }
+
+        public GameModePreset Preset
+        {
+            get { return preset; }
+        }
+
+        public GameMode(GameModePreset preset, object param)
+        {
+            this.preset = preset;
+        }
+
+        public virtual void Draw(SpriteBatch spriteBatch)
+        {
+        }
+
+        public virtual void Start()
+        {
+            startTime = DateTime.Now;
+            //if (duration!=TimeSpan.Zero)
+            //{
+            //    endTime = startTime + duration;
+            //    this.duration = duration;
+
+            //    timerBar = new GUIProgressBar(new Rectangle(GameMain.GraphicsWidth - 120, 20, 100, 25), Color.Gold, 0.0f, null);  
+            //}
+
+            endMessage = "The round has ended!";
+
+            isRunning = true;
+        }
+
+        public virtual void MsgBox() { }
+
+        public virtual void AddToGUIUpdateList() { }
+
+        public virtual void Update(float deltaTime)
+        {
+            //if (!isRunning) return;
+
+            //if (duration != TimeSpan.Zero)
+            //{
+            //    double elapsedTime = (DateTime.Now - startTime).TotalSeconds;
+            //    timerBar.BarSize = (float)(elapsedTime / duration.TotalSeconds);
+            //}
+            //if (DateTime.Now >= endTime)
+            //{
+            //    End(endMessage);                
+            //}
+        }
+
+        public virtual void End(string endMessage = "")
+        {
+            isRunning = false;
+
+            if (endMessage != "" || this.endMessage == null) this.endMessage = endMessage;
+
+            GameMain.GameSession.EndShift(endMessage);
+        }
+        
+
+    }
+}

BarotraumaShared/Source/GameSession/GameModes/GameModePreset.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace Barotrauma
+{
+    class GameModePreset
+    {
+        public static List<GameModePreset> list = new List<GameModePreset>();
+
+        public ConstructorInfo Constructor;
+        public string Name;
+        public bool IsSinglePlayer;
+
+        public string Description;
+
+        public GameModePreset(string name, Type type, bool isSinglePlayer = false)
+        {
+            this.Name = name;
+
+            Constructor = type.GetConstructor(new Type[] { typeof(GameModePreset), typeof(object) });
+
+            IsSinglePlayer = isSinglePlayer;
+
+            list.Add(this);
+        }
+
+        public GameMode Instantiate(object param)
+        {
+            object[] lobject = new object[] { this, param };
+            return (GameMode)Constructor.Invoke(lobject);
+        }
+
+        public static void Init()
+        {
+            new GameModePreset("Single Player", typeof(SinglePlayerMode), true);
+            new GameModePreset("Tutorial", typeof(TutorialMode), true);
+
+            var mode = new GameModePreset("SandBox", typeof(GameMode), false);
+            mode.Description = "A game mode with no specific objectives.";
+
+            //mode = new GameModePreset("Traitor", typeof(TraitorMode), false);
+            //mode.Description = "One of the players is selected as a traitor and given a secret objective. "
+            //    + "The rest of the crew will win if they reach the end of the level or kill the traitor "
+            //    + "before the objective is completed.";
+
+            mode = new GameModePreset("Mission", typeof(MissionMode), false);
+            mode.Description = "The crew must work together to complete a specific task, such as retrieving "
+                + "an alien artifact or killing a creature that's terrorizing nearby outposts. The game ends "
+                + "when the task is completed or everyone in the crew has died.";
+        }
+    }
+}

BarotraumaShared/Source/GameSession/GameModes/MissionMode.cs

@@ -0,0 +1,37 @@
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    class MissionMode : GameMode
+    {
+        private Mission mission;
+
+        public override Mission Mission
+        {
+            get
+            {
+                return mission;
+            }
+        }
+
+        public MissionMode(GameModePreset preset, object param)
+            : base(preset, param)
+        {
+            Location[] locations = { GameMain.GameSession.StartLocation, GameMain.GameSession.EndLocation };
+
+            MTRandom rand = new MTRandom(ToolBox.StringToInt(GameMain.NetLobbyScreen.LevelSeed));
+            mission = Mission.LoadRandom(locations, rand, param as string);
+        }
+
+        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);
+        }
+    }
+}

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

BarotraumaShared/Source/GameSession/GameModes/TraitorManager.cs

@@ -0,0 +1,130 @@
+using Barotrauma.Networking;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    class TraitorManager
+    {
+        public Character TraitorCharacter
+        {
+            get { return traitorCharacter; }
+        }
+
+        public Character TargetCharacter
+        {
+            get { return targetCharacter; }
+        }
+
+        private Character traitorCharacter, targetCharacter;
+        
+        public TraitorManager(GameServer server)
+        {
+            Start(server);
+        }
+
+        private void Start(GameServer server)
+        {
+            if (server == null) return;
+
+            List<Character> characters = new List<Character>();
+            foreach (Client client in server.ConnectedClients)
+            {
+                if (client.Character != null)
+                    characters.Add(client.Character);
+            }
+
+            if (server.Character!= null) characters.Add(server.Character);
+
+            if (characters.Count < 2)
+            {
+                traitorCharacter = null;
+                targetCharacter = null;
+                return;
+            }
+
+            int traitorIndex = Rand.Range(0, characters.Count);
+
+            int targetIndex = Rand.Range(0, characters.Count);
+            while (targetIndex == traitorIndex)
+            {
+                targetIndex = Rand.Range(0, characters.Count);
+            }
+
+            traitorCharacter = characters[traitorIndex];
+            targetCharacter = characters[targetIndex];
+
+            if (server.Character == null)
+            {               
+                new GUIMessageBox("New traitor", traitorCharacter.Name + " is the traitor and the target is " + targetCharacter.Name+".");
+            }
+            else if (server.Character == traitorCharacter)
+            {
+                CreateStartPopUp(traitorCharacter.Name);
+                return;
+            }
+        }
+
+        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);
+        }
+        
+        public string GetEndMessage()
+        {
+            if (GameMain.Server == null || traitorCharacter == null || targetCharacter == null) return "";
+
+            string endMessage = "";
+
+            if (targetCharacter.IsDead && !traitorCharacter.IsDead)
+            {
+                endMessage = traitorCharacter.Name + " was a traitor! ";
+                endMessage += (traitorCharacter.Info.Gender == Gender.Male) ? "His" : "Her";
+                endMessage += " task was to assassinate " + targetCharacter.Name + ". The task was successful.";
+            }
+            else if (targetCharacter.IsDead && traitorCharacter.IsDead)
+            {
+                endMessage = traitorCharacter.Name + " was a traitor! ";
+                endMessage += (traitorCharacter.Info.Gender == Gender.Male) ? "His" : "Her";
+                endMessage += " task was to assassinate " + targetCharacter.Name + ". The task was successful, but luckily the bastard didn't make it out alive either.";
+            }
+            else if (traitorCharacter.IsDead)
+            {
+                endMessage = traitorCharacter.Name + " was a traitor! ";
+                endMessage += (traitorCharacter.Info.Gender == Gender.Male) ? "His" : "Her";
+                endMessage += " task was to assassinate " + targetCharacter.Name + ", but ";
+                endMessage += (traitorCharacter.Info.Gender == Gender.Male) ? "he" : "she";
+                endMessage += " got " + ((traitorCharacter.Info.Gender == Gender.Male) ? "himself" : "herself");
+                endMessage += " killed before completing it.";
+            }
+            else
+            {
+                endMessage = traitorCharacter.Name + " was a traitor! ";
+                endMessage += (traitorCharacter.Info.Gender == Gender.Male) ? "His" : "Her";
+                endMessage += " task was to assassinate " + targetCharacter.Name + ". ";
+                endMessage += (Submarine.MainSub.AtEndPosition) ?
+                    "The task was unsuccessful - the submarine has reached its destination." : 
+                    "The task was unsuccessful.";
+            }
+
+            return endMessage;          
+        }
+
+        //public void CharacterLeft(Character character)
+        //{
+        //    if (character != traitorCharacter && character != targetCharacter) return;
+
+        //    if (character == traitorCharacter)
+        //    {
+        //        string endMessage = "The traitor has disconnected from the server.";
+        //        End(endMessage);
+        //    }
+        //    else if (character == targetCharacter)
+        //    {
+        //        string endMessage = "The traitor's target has disconnected from the server.";
+        //        End(endMessage);
+        //    }
+        //}
+    }
+}

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

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

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

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

BarotraumaShared/Source/GameSession/GameSession.cs

@@ -0,0 +1,434 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class GameSession
+    {
+        public enum InfoFrameTab { Crew, Mission, ManagePlayers };
+
+        public readonly TaskManager TaskManager;
+        
+        public readonly GameMode gameMode;
+
+        //two locations used as the start and end in the MP mode
+        private Location[] dummyLocations;
+
+        private InfoFrameTab selectedTab;
+        private GUIButton infoButton;
+        private GUIFrame infoFrame;
+        
+        private string saveFile;
+
+        private Submarine submarine;
+
+        public CrewManager CrewManager;
+        
+        private ShiftSummary shiftSummary;
+
+        private Mission currentMission;
+
+        public Mission Mission
+        {
+            get
+            {
+                return currentMission;
+            }
+        }
+
+        private Level level;
+
+        public Level Level
+        {
+            get { return level; }
+        }
+
+        public Map Map
+        {
+            get 
+            {
+                SinglePlayerMode mode = (gameMode as SinglePlayerMode);
+                return (mode == null) ? null : mode.Map;
+            }
+        }
+
+        public Location StartLocation
+        {
+            get 
+            {
+                if (Map != null) return Map.CurrentLocation;
+
+                if (dummyLocations==null)
+                {
+                    CreateDummyLocations();
+                }
+
+                return dummyLocations[0]; 
+            }
+        }
+         
+        public Location EndLocation
+        {
+            get
+            {
+                if (Map != null) return Map.SelectedLocation;
+
+                if (dummyLocations == null)
+                {
+                    CreateDummyLocations();
+                }
+
+                return dummyLocations[1];
+            }
+        }  
+     
+        public Submarine Submarine
+        {
+            get { return submarine; }
+            set { submarine = value; }
+        }
+
+        public string SaveFile
+        {
+            get { return saveFile; }
+        }
+
+        public ShiftSummary ShiftSummary
+        {
+            get { return shiftSummary; }
+        }
+
+        public GameSession(Submarine submarine, string saveFile, GameModePreset gameModePreset = null, string missionType="")
+        {
+            Submarine.MainSub = submarine;
+
+            GameMain.GameSession = this;
+                        
+            CrewManager = new CrewManager();
+
+            TaskManager = new TaskManager(this);
+            
+            this.saveFile = saveFile;
+
+            infoButton = new GUIButton(new Rectangle(10, 10, 100, 20), "Info", "", null);
+            infoButton.OnClicked = ToggleInfoFrame;
+
+            if (gameModePreset != null) gameMode = gameModePreset.Instantiate(missionType);
+            this.submarine = submarine;
+        }
+        
+        public GameSession(Submarine selectedSub, string saveFile, XDocument doc)
+            : this(selectedSub, saveFile)
+        {
+            Submarine.MainSub = submarine;
+
+            GameMain.GameSession = this;
+
+            CrewManager = new CrewManager();
+
+            selectedSub.Name = ToolBox.GetAttributeString(doc.Root, "submarine", selectedSub.Name);
+
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "gamemode") continue;
+
+                gameMode = new SinglePlayerMode(subElement);
+            }
+        }
+
+        private void CreateDummyLocations()
+        {
+            dummyLocations = new Location[2];
+
+            string seed = "";
+            if (GameMain.GameSession != null && GameMain.GameSession.Level != null)
+            {
+                seed = GameMain.GameSession.Level.Seed;
+            }
+            else if (GameMain.NetLobbyScreen != null)
+            {
+                seed = GameMain.NetLobbyScreen.LevelSeed;
+            }
+
+            MTRandom rand = new MTRandom(ToolBox.StringToInt(seed));
+            for (int i = 0; i < 2; i++)
+            {
+                dummyLocations[i] = Location.CreateRandom(new Vector2((float)rand.NextDouble() * 10000.0f, (float)rand.NextDouble() * 10000.0f));
+            }
+        }
+
+        public void StartShift(string levelSeed, bool loadSecondSub = false)
+        {
+            Level randomLevel = Level.CreateRandom(levelSeed);
+
+            StartShift(randomLevel, true, loadSecondSub);
+        }
+
+        public void StartShift(Level level, bool reloadSub = true, bool loadSecondSub = false)
+        {
+            GameMain.LightManager.LosEnabled = GameMain.NetworkMember == null || GameMain.NetworkMember.CharacterInfo != null;
+                        
+            this.level = level;
+
+            if (submarine==null)
+            {
+                DebugConsole.ThrowError("Couldn't start game session, submarine not selected");
+                return;
+            }
+
+            if (reloadSub || Submarine.MainSub != submarine) submarine.Load(true);
+            Submarine.MainSub = submarine;
+            if (loadSecondSub)
+            {
+                if (Submarine.MainSubs[1] == null)
+                {
+                    Submarine.MainSubs[1] = new Submarine(Submarine.MainSub.FilePath,Submarine.MainSub.MD5Hash.Hash,true);
+                    Submarine.MainSubs[1].Load(false);
+                }
+                else if (reloadSub)
+                {
+                    Submarine.MainSubs[1].Load(false);
+                }
+            }
+            
+            if (level != null)
+            {
+                level.Generate();
+
+                submarine.SetPosition(submarine.FindSpawnPos(level.StartPosition - new Vector2(0.0f, 2000.0f)));
+                
+                GameMain.GameScreen.BackgroundCreatureManager.SpawnSprites(80);
+            }
+
+            if (gameMode.Mission != null)
+            {
+                currentMission = gameMode.Mission;
+            }
+
+            shiftSummary = new ShiftSummary(this);
+
+            if (gameMode!=null) gameMode.Start();
+
+            if (gameMode.Mission != null) Mission.Start(Level.Loaded);
+            
+            TaskManager.StartShift(level);
+
+            if (gameMode != null) gameMode.MsgBox();
+
+            Entity.Spawner = new EntitySpawner();
+
+            GameMain.GameScreen.ColorFade(Color.Black, Color.TransparentBlack, 5.0f);
+            SoundPlayer.SwitchMusic();
+        }
+
+        public void EndShift(string endMessage)
+        {
+            if (Mission != null) Mission.End();
+
+            if (GameMain.Server != null)
+            {
+                //CoroutineManager.StartCoroutine(GameMain.Server.EndGame(endMessage));
+
+            }
+            else if (GameMain.Client == null)
+            {
+                //Submarine.Unload();
+                GameMain.LobbyScreen.Select();
+            }
+
+            if (shiftSummary != null)
+            {
+                GUIFrame summaryFrame = shiftSummary.CreateSummaryFrame(endMessage);
+                GUIMessageBox.MessageBoxes.Add(summaryFrame);
+                var okButton = new GUIButton(new Rectangle(0, 0, 100, 30), "Ok", Alignment.BottomRight, "", summaryFrame.children[0]);
+                okButton.OnClicked = (GUIButton button, object obj) => { GUIMessageBox.MessageBoxes.Remove(summaryFrame); return true; };
+            }
+
+            TaskManager.EndShift();
+
+            currentMission = null;
+
+            StatusEffect.StopAll();
+        }
+        
+        
+        public void KillCharacter(Character character)
+        {
+            CrewManager.KillCharacter(character);
+        }
+
+        public void ReviveCharacter(Character character)
+        {
+            CrewManager.ReviveCharacter(character);
+        }
+
+        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!");
+            }
+        }
+    }
+}

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

BarotraumaShared/Source/GameSession/InfoTextManager.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    static class InfoTextManager
+    {
+
+        private static Dictionary<string, List<string>> infoTexts;
+
+        static InfoTextManager()
+        {
+            LoadInfoTexts(Path.Combine("Content", "InfoTexts.xml"));            
+        }
+
+
+        private static void LoadInfoTexts(string file)
+        {
+            infoTexts = new Dictionary<string, List<string>>();
+
+            XDocument doc = ToolBox.TryLoadXml(file);
+            if (doc == null || doc.Root == null) return;            
+
+            foreach (XElement subElement in doc.Root.Elements())
+            {
+                string infoName = subElement.Name.ToString().ToLowerInvariant();
+                List<string> infoList = null;
+                if (!infoTexts.TryGetValue(infoName, out infoList))
+                {
+                    infoList = new List<string>();
+                    infoTexts.Add(infoName, infoList);
+                }
+
+                infoList.Add(subElement.ElementInnerText());
+            }
+        }
+
+        public static string GetInfoText(string infoName)
+        {
+            List<string> infoList = null;
+            if (!infoTexts.TryGetValue(infoName.ToLowerInvariant(), out infoList) || !infoList.Any())
+            {
+#if DEBUG
+                return "Info text \"" + infoName + "\" not found";
+#else
+                return "";
+#endif
+            }
+
+            string text = infoList[Rand.Int(infoList.Count)];
+
+            foreach (InputType inputType in Enum.GetValues(typeof(InputType)))
+            {
+                text = text.Replace("[" + inputType.ToString() + "]", GameMain.Config.KeyBind(inputType).ToString());
+            }
+
+            if (Submarine.MainSub != null) text = text.Replace("[sub]", Submarine.MainSub.Name);
+            if (GameMain.GameSession != null && GameMain.GameSession.StartLocation != null)
+            {
+                text = text.Replace("[location]", GameMain.GameSession.StartLocation.Name);
+            }
+
+            return text;
+        }
+    }
+}

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

BarotraumaShared/Source/GameSettings.cs

@@ -0,0 +1,517 @@
+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 class GameSettings
+    {
+        private GUIFrame settingsFrame;
+        private GUIButton applyButton;
+
+        private float soundVolume, musicVolume;
+
+        private WindowMode windowMode;
+
+        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 FullScreenEnabled { get; set; }
+
+        public WindowMode WindowMode
+        {
+            get { return windowMode; }
+            set { windowMode = value; }
+        }
+
+        public ContentPackage SelectedContentPackage { get; set; }
+
+        public string   MasterServerUrl { get; set; }
+        public bool     AutoCheckUpdates { get; set; }
+        public bool     WasGameUpdated { get; set; }
+
+        public static bool VerboseLogging { get; set; }
+
+        public bool EnableSplashScreen { get; set; }
+
+        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;
+            }
+        }
+
+        public GameSettings(string filePath)
+        {
+            ContentPackage.LoadAll(ContentPackage.Folder);
+
+            Load(filePath);
+        }
+
+        public void Load(string filePath)
+        {
+            XDocument doc = ToolBox.TryLoadXml(filePath);
+
+            if (doc == null)
+            {
+                DebugConsole.ThrowError("No config file found");
+
+                GraphicsWidth = 1024;
+                GraphicsHeight = 678;
+
+                MasterServerUrl = "";
+                
+                SelectedContentPackage = ContentPackage.list.Any() ? ContentPackage.list[0] : new ContentPackage("");
+
+                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;
+            }
+
+            MasterServerUrl = ToolBox.GetAttributeString(doc.Root, "masterserverurl", "");
+
+            AutoCheckUpdates = ToolBox.GetAttributeBool(doc.Root, "autocheckupdates", true);
+            WasGameUpdated = ToolBox.GetAttributeBool(doc.Root, "wasgameupdated", false);
+
+            SoundVolume = ToolBox.GetAttributeFloat(doc.Root, "soundvolume", 1.0f);
+            MusicVolume = ToolBox.GetAttributeFloat(doc.Root, "musicvolume", 0.3f);
+
+            VerboseLogging = ToolBox.GetAttributeBool(doc.Root, "verboselogging", false);
+
+            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 "contentpackage":
+                        string path = ToolBox.GetAttributeString(subElement, "path", "");
+
+
+                        SelectedContentPackage = ContentPackage.list.Find(cp => cp.Path == path);
+
+                        if (SelectedContentPackage == null) SelectedContentPackage = new ContentPackage(path);
+                        break;
+                    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;
+                }
+            }
+
+            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));
+                }
+
+
+            }
+
+            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 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;
+        }
+    }
+}

BarotraumaShared/Source/IPropertyObject.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    interface IPropertyObject
+    {
+        string Name
+        {
+            get;
+        }
+
+        Dictionary<string, ObjectProperty> ObjectProperties
+        {
+            get;
+        }
+    }
+}

BarotraumaShared/Source/Items/CharacterInventory.cs

@@ -0,0 +1,486 @@
+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
+{
+    [Flags]
+    public enum InvSlotType
+    {
+        None = 0, Any = 1, RightHand = 2, LeftHand = 4, Head = 8, Torso = 16, Legs = 32, Face=64
+    };
+
+    class CharacterInventory : Inventory
+    {
+        private static Texture2D icons;
+
+        private Character character;
+
+        public static InvSlotType[] limbSlots = new InvSlotType[] { 
+            InvSlotType.Head, InvSlotType.Torso, InvSlotType.Legs, InvSlotType.LeftHand, InvSlotType.RightHand, InvSlotType.Face,
+            InvSlotType.Any, InvSlotType.Any, InvSlotType.Any, InvSlotType.Any, InvSlotType.Any,
+            InvSlotType.Any, InvSlotType.Any, InvSlotType.Any, InvSlotType.Any, InvSlotType.Any};
+
+        public Vector2[] SlotPositions;
+
+        private GUIButton[] useOnSelfButton;
+
+        public CharacterInventory(int capacity, Character character)
+            : base(character, capacity)
+        {
+            this.character = character;
+
+            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;
+
+            if (Items[slotIndex] == null) return false;
+                        
+            if (GameMain.Client != null)
+            {
+                GameMain.Client.CreateEntityEvent(Items[slotIndex], new object[] { NetEntityEvent.Type.ApplyStatusEffect });
+                return true;
+            }
+
+            if (GameMain.Server != null)
+            {
+                GameMain.Server.CreateEntityEvent(Items[slotIndex], new object[] { NetEntityEvent.Type.ApplyStatusEffect, ActionType.OnUse, character.ID });
+            }
+
+            Items[slotIndex].ApplyStatusEffects(ActionType.OnUse, 1.0f, character);
+
+            return true;
+        }
+        
+        public int FindLimbSlot(InvSlotType limbSlot)
+        {
+            for (int i = 0; i < Items.Length; i++)
+            {
+                if (limbSlots[i] == limbSlot) return i;
+            }
+            return -1;
+        }
+
+        public bool IsInLimbSlot(Item item, InvSlotType limbSlot)
+        {
+            for (int i = 0; i<Items.Length; i++)
+            {
+                if (Items[i] == item && limbSlots[i] == limbSlot) return true;
+            }
+            return false;
+        }
+
+        public override bool CanBePut(Item item, int i)
+        {
+            return base.CanBePut(item, i) && item.AllowedSlots.Contains(limbSlots[i]);
+        } 
+
+        /// <summary>
+        /// If there is room, puts the item in the inventory and returns true, otherwise returns false
+        /// </summary>
+        public override bool TryPutItem(Item item, List<InvSlotType> allowedSlots = null, bool createNetworkEvent = true)
+        {
+            if (allowedSlots == null || !allowedSlots.Any()) return false;
+
+            for (int i = 0; i < capacity; i++)
+            {
+                //already in the inventory and in a suitable slot
+                if (Items[i] == item && allowedSlots.Any(a => a.HasFlag(limbSlots[i])))
+                {
+                    return true;
+                }
+            }
+
+            //try to place the item in LimBlot.Any slot if that's allowed
+            if (allowedSlots.Contains(InvSlotType.Any))
+            {
+                for (int i = 0; i < capacity; i++)
+                {
+                    if (Items[i] != null || limbSlots[i] != InvSlotType.Any) continue;
+
+                    PutItem(item, i, true, createNetworkEvent);
+                    item.Unequip(character);
+                    return true;
+                }
+            }
+
+            bool placed = false;
+            foreach (InvSlotType allowedSlot in allowedSlots)
+            {
+                //check if all the required slots are free
+                bool free = true;
+                for (int i = 0; i < capacity; i++)
+                {
+                    if (allowedSlot.HasFlag(limbSlots[i]) && Items[i]!=null && Items[i]!=item)
+                    {
+                        free = false;
+                        if (slots != null) slots[i].ShowBorderHighlight(Color.Red, 0.1f, 0.9f);
+                    }
+                }
+
+                if (!free) continue;
+
+                for (int i = 0; i < capacity; i++)
+                {
+                    if (allowedSlot.HasFlag(limbSlots[i]) && Items[i] == null)
+                    {
+                        PutItem(item, i, !placed, createNetworkEvent);
+                        item.Equip(character);
+                        placed = true;
+                    }
+                }
+
+                if (placed)
+                {
+                    return true;
+                }
+            }
+
+
+            return placed;
+        }
+
+        public override bool TryPutItem(Item item, int index, bool allowSwapping, bool createNetworkEvent = true)
+        {
+            //there's already an item in the slot
+            if (Items[index] != null)
+            {
+                if (Items[index] == item) return false;
+
+                bool combined = false;
+                if (Items[index].Combine(item))
+                {
+                    System.Diagnostics.Debug.Assert(Items[index] != null);
+                 
+                    Inventory otherInventory = Items[index].ParentInventory;
+                    if (otherInventory != null && otherInventory.Owner!=null)
+                    {
+                        
+                    }
+
+                    combined = true;
+                }
+                //if moving the item between slots in the same inventory
+                else if (item.ParentInventory == this && allowSwapping)
+                {
+                    int currentIndex = Array.IndexOf(Items, item);
+
+                    Item existingItem = Items[index];
+
+                    Items[currentIndex] = null;
+                    Items[index] = null;
+                    //if the item in the slot can be moved to the slot of the moved item
+                    if (TryPutItem(existingItem, currentIndex, false, createNetworkEvent) &&
+                        TryPutItem(item, index, false, createNetworkEvent))
+                    {
+                        
+                    }
+                    else
+                    {
+                        Items[currentIndex] = null;
+                        Items[index] = null;
+
+                        //swapping the items failed -> move them back to where they were
+                        TryPutItem(item, currentIndex, false, createNetworkEvent);
+                        TryPutItem(existingItem, index, false, createNetworkEvent);
+                    }
+                }
+                
+                return combined;
+            }
+
+            if (limbSlots[index] == InvSlotType.Any)
+            {
+                if (!item.AllowedSlots.Contains(InvSlotType.Any)) return false;
+                if (Items[index] != null) return Items[index] == item;
+
+                PutItem(item, index, true, createNetworkEvent);
+                return true;
+            }
+
+            InvSlotType placeToSlots = InvSlotType.None;
+
+            bool slotsFree = true;
+            List<InvSlotType> allowedSlots = item.AllowedSlots;
+            foreach (InvSlotType allowedSlot in allowedSlots)
+            {
+                if (!allowedSlot.HasFlag(limbSlots[index])) continue;
+
+                for (int i = 0; i < capacity; i++)
+                {
+                    if (allowedSlot.HasFlag(limbSlots[i]) && Items[i] != null && Items[i] != item)
+                    {
+                        slotsFree = false;
+                        break;
+                    }
+
+                    placeToSlots = allowedSlot;
+                }
+            }
+
+            if (!slotsFree) return false;
+            
+            return TryPutItem(item, new List<InvSlotType>() {placeToSlots}, createNetworkEvent);
+        }
+
+        protected override void PutItem(Item item, int i, bool removeItem = true, bool createNetworkEvent = true)
+        {
+            base.PutItem(item, i, removeItem, createNetworkEvent);
+            CreateSlots();
+        }
+
+        public override void RemoveItem(Item item)
+        {
+            base.RemoveItem(item);
+            CreateSlots();
+        }
+
+        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 override void Update(float deltaTime, bool subInventory = false)
+        {
+            base.Update(deltaTime);
+
+            if (doubleClickedItem != null)
+            {
+                if (doubleClickedItem.ParentInventory != this)
+                {
+                    TryPutItem(doubleClickedItem, doubleClickedItem.AllowedSlots, true);
+                }
+                else
+                {
+                    if (character.SelectedConstruction != null)
+                    {
+                        var selectedContainer = character.SelectedConstruction.GetComponent<ItemContainer>();
+                        if (selectedContainer != null && selectedContainer.Inventory != null)
+                        {
+                            selectedContainer.Inventory.TryPutItem(doubleClickedItem, doubleClickedItem.AllowedSlots, true);
+                        }
+                    }
+                    else if (character.SelectedCharacter != null && character.SelectedCharacter.Inventory != null)
+                    {
+                        character.SelectedCharacter.Inventory.TryPutItem(doubleClickedItem, doubleClickedItem.AllowedSlots, true);
+                    }
+                    else //doubleclicked and no other inventory is selected
+                    {
+                        //not equipped -> attempt to equip
+                        if (IsInLimbSlot(doubleClickedItem, InvSlotType.Any))
+                        {
+                            TryPutItem(doubleClickedItem, doubleClickedItem.AllowedSlots.FindAll(i => i != InvSlotType.Any), true);
+                        }
+                        //equipped -> attempt to unequip
+                        else if (doubleClickedItem.AllowedSlots.Contains(InvSlotType.Any))
+                        {
+                            TryPutItem(doubleClickedItem, new List<InvSlotType>() { InvSlotType.Any }, true);
+                        }
+                    }
+                }
+            }
+
+            if (selectedSlot > -1)
+            {
+                UpdateSubInventory(deltaTime, selectedSlot);
+            }
+
+            if (character == Character.Controlled)
+            {
+                for (int i = 0; i < capacity; i++)
+                {
+                    if (selectedSlot != i &&
+                        Items[i] != null && Items[i].CanUseOnSelf && character.HasSelectedItem(Items[i]))
+                    {
+                        //-3 because selected items are in slots 3 and 4 (hands)
+                        useOnSelfButton[i - 3].Update(deltaTime);
+                    }
+                }
+            }
+
+            //cancel dragging if too far away from the container of the dragged item
+            if (draggingItem != null)
+            {
+                var rootContainer = draggingItem.GetRootContainer();
+                var rootInventory = draggingItem.ParentInventory;
+
+                if (rootContainer != null)
+                {
+                    rootInventory = rootContainer.ParentInventory != null ?
+                        rootContainer.ParentInventory : rootContainer.GetComponent<Items.Components.ItemContainer>().Inventory;
+                }
+
+                if (rootInventory != null &&
+                    rootInventory.Owner != Character.Controlled &&
+                    rootInventory.Owner != Character.Controlled.SelectedConstruction &&
+                    rootInventory.Owner != Character.Controlled.SelectedCharacter)
+                {
+                    draggingItem = null;
+                }
+            }
+
+
+            doubleClickedItem = null;
+        }
+
+        private void MergeSlots()
+        {
+            for (int i = 0; i < capacity-1; i++)
+            {
+                if (slots[i].Disabled || Items[i] == null) continue;
+                
+                for (int n = i+1; n < capacity; n++)
+                {
+                    if (Items[n] == Items[i])
+                    {
+                        slots[i].Rect = Rectangle.Union(slots[i].Rect, slots[n].Rect);
+                        slots[n].Disabled = true;
+                    }
+                }               
+            }
+
+            selectedSlot = -1;
+        }
+                 
+        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;
+                }
+            }
+        }
+        
+    }
+}

BarotraumaShared/Source/Items/Components/DockingPort.cs

@@ -0,0 +1,835 @@
+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
+{
+
+    class DockingPort : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        public static List<DockingPort> list = new List<DockingPort>();
+        
+        private Sprite overlaySprite;
+        
+        private Vector2 distanceTolerance;
+
+        private DockingPort dockingTarget;
+
+        private float dockingState;
+        private int dockingDir;
+
+        private Joint joint;
+
+        private Hull[] hulls;
+        private ushort?[] hullIds;
+
+        private Door door;
+
+        private Body[] bodies;
+
+        private Body doorBody;
+
+        private Gap gap;
+        private ushort? gapId;
+
+        private bool docked;
+
+        public int DockingDir
+        {
+            get { return dockingDir; }
+            set { dockingDir = value; }
+        }
+
+        [HasDefaultValue("32.0,32.0", false)]
+        public string DistanceTolerance
+        {
+            get { return ToolBox.Vector2ToString(distanceTolerance); }
+            set { distanceTolerance = ToolBox.ParseToVector2(value); }
+        }
+
+        [HasDefaultValue(32.0f, false)]
+        public float DockedDistance
+        {
+            get;
+            set;
+        }
+
+        [HasDefaultValue(true, false)]
+        public bool IsHorizontal
+        {
+            get;
+            set;
+        }
+
+        public DockingPort DockingTarget
+        {
+            get { return dockingTarget; }
+            set { dockingTarget = value; }
+        }
+
+        public bool Docked
+        {
+            get
+            {
+                return docked;
+            }
+            set
+            {
+                if (!docked && value)
+                {
+                    if (dockingTarget == null) AttemptDock();
+                    if (dockingTarget == null) return;
+
+                    docked = true;
+                }
+                else if (docked && !value)
+                {
+                    Undock();
+                }
+
+                //base.IsActive = value;
+            }
+        }
+
+        public DockingPort(Item item, XElement element)
+            : base(item, element)
+        {
+            // isOpen = false;
+            foreach (XElement subElement in element.Elements())
+            {
+                string texturePath = ToolBox.GetAttributeString(subElement, "texture", "");
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        overlaySprite = new Sprite(subElement, texturePath.Contains("/") ? "" : Path.GetDirectoryName(item.Prefab.ConfigFile));
+                        break;
+                }
+            }
+            
+            IsActive = true;
+
+            hullIds = new ushort?[2];
+
+            list.Add(this);
+        }
+
+        public override void FlipX()
+        {
+            base.FlipX();
+
+            if (dockingTarget != null)
+            {
+                if (joint != null)
+                {
+                    CreateJoint(joint is WeldJoint);
+                    LinkHullsToGap();
+                }
+                else if (dockingTarget.joint != null)
+                {
+                    if (!GameMain.World.BodyList.Contains(dockingTarget.joint.BodyA) ||
+                        !GameMain.World.BodyList.Contains(dockingTarget.joint.BodyB))
+                    {
+                        dockingTarget.CreateJoint(dockingTarget.joint is WeldJoint);
+                    }
+                    dockingTarget.LinkHullsToGap();
+                }
+            }
+        }
+
+        private DockingPort FindAdjacentPort()
+        {
+            foreach (DockingPort port in list)
+            {
+                if (port == this || port.item.Submarine == item.Submarine) continue;
+
+                if (Math.Abs(port.item.WorldPosition.X - item.WorldPosition.X) > distanceTolerance.X) continue;
+                if (Math.Abs(port.item.WorldPosition.Y - item.WorldPosition.Y) > distanceTolerance.Y) continue;
+
+                return port;
+            }
+
+            return null;
+        }
+
+        private void AttemptDock()
+        {
+            var adjacentPort = FindAdjacentPort();
+
+            if (adjacentPort != null) Dock(adjacentPort);
+        }
+
+        public void Dock(DockingPort target)
+        {
+            if (item.Submarine.DockedTo.Contains(target.item.Submarine)) return;
+                        
+            if (dockingTarget != null)
+            {
+                Undock();
+            }
+
+            if (target.item.Submarine == item.Submarine)
+            {
+                DebugConsole.ThrowError("Error - tried to dock a submarine to itself");
+                dockingTarget = null;
+                return;
+            }
+
+            PlaySound(ActionType.OnUse, item.WorldPosition);
+
+            if (!item.linkedTo.Contains(target.item)) item.linkedTo.Add(target.item);
+            if (!target.item.linkedTo.Contains(item)) target.item.linkedTo.Add(item);
+
+            if (!target.item.Submarine.DockedTo.Contains(item.Submarine)) target.item.Submarine.DockedTo.Add(item.Submarine);
+            if (!item.Submarine.DockedTo.Contains(target.item.Submarine)) item.Submarine.DockedTo.Add(target.item.Submarine);
+
+            dockingTarget = target;
+            dockingTarget.dockingTarget = this;
+
+            docked = true;
+            dockingTarget.Docked = true;
+
+            if (Character.Controlled != null &&
+                (Character.Controlled.Submarine == dockingTarget.item.Submarine || Character.Controlled.Submarine == item.Submarine))
+            {
+                GameMain.GameScreen.Cam.Shake = Vector2.Distance(dockingTarget.item.Submarine.Velocity, item.Submarine.Velocity);
+            }
+
+            dockingDir = IsHorizontal ? 
+                Math.Sign(dockingTarget.item.WorldPosition.X - item.WorldPosition.X) :
+                Math.Sign(dockingTarget.item.WorldPosition.Y - item.WorldPosition.Y);
+            dockingTarget.dockingDir = -dockingDir;
+            
+
+            foreach (WayPoint wp in WayPoint.WayPointList)
+            {
+                if (wp.Submarine != item.Submarine || wp.SpawnType != SpawnType.Path) continue;
+
+                if (!Submarine.RectContains(item.Rect, wp.Position)) continue;
+
+                foreach (WayPoint wp2 in WayPoint.WayPointList)
+                {
+                    if (wp2.Submarine != dockingTarget.item.Submarine || wp2.SpawnType != SpawnType.Path) continue;
+
+                    if (!Submarine.RectContains(dockingTarget.item.Rect, wp2.Position)) continue;
+
+                    wp.linkedTo.Add(wp2);
+                    wp2.linkedTo.Add(wp);
+                }
+            }
+            
+            CreateJoint(false);
+
+            if (GameMain.Server != null)
+            {
+                item.CreateServerEvent(this);
+            }
+        }
+
+        public void Lock(bool isNetworkMessage)
+        {
+            if (GameMain.Client != null && !isNetworkMessage) return;
+
+            if (dockingTarget==null)
+            {
+                DebugConsole.ThrowError("Error - attempted to lock a docking port that's not connected to anything");
+                return;
+            }
+            else if (joint is WeldJoint)
+            {
+                //DebugConsole.ThrowError("Error - attempted to lock a docking port that's already locked");
+                return;
+            }
+
+            dockingDir = IsHorizontal ?
+                Math.Sign(dockingTarget.item.WorldPosition.X - item.WorldPosition.X) :
+                Math.Sign(dockingTarget.item.WorldPosition.Y - item.WorldPosition.Y);
+            dockingTarget.dockingDir = -dockingDir;            
+            
+            PlaySound(ActionType.OnSecondaryUse, item.WorldPosition);
+
+            ConnectWireBetweenPorts();
+
+            CreateJoint(true);
+
+            if (GameMain.Server != null)
+            {
+                item.CreateServerEvent(this);
+            }
+
+            if (!item.linkedTo.Any(e => e is Hull) && !dockingTarget.item.linkedTo.Any(e => e is Hull))
+            {
+                CreateHull();
+            }
+        }
+
+
+        private void CreateJoint(bool useWeldJoint)
+        {
+            if (joint != null)
+            {
+                GameMain.World.RemoveJoint(joint);
+                joint = null;
+            }
+
+            Vector2 offset = (IsHorizontal ?
+                Vector2.UnitX * dockingDir :
+                Vector2.UnitY * dockingDir);
+            offset *= DockedDistance * 0.5f;
+            
+            Vector2 pos1 = item.WorldPosition + offset;
+
+            Vector2 pos2 = dockingTarget.item.WorldPosition - offset;
+
+            if (useWeldJoint)
+            {
+                joint = JointFactory.CreateWeldJoint(GameMain.World,
+                    item.Submarine.PhysicsBody.FarseerBody, dockingTarget.item.Submarine.PhysicsBody.FarseerBody,
+                    ConvertUnits.ToSimUnits(pos1), FarseerPhysics.ConvertUnits.ToSimUnits(pos2), true);
+
+                ((WeldJoint)joint).FrequencyHz = 1.0f;
+            }
+            else
+            {
+                var distanceJoint = JointFactory.CreateDistanceJoint(GameMain.World,
+                    item.Submarine.PhysicsBody.FarseerBody, dockingTarget.item.Submarine.PhysicsBody.FarseerBody,
+                    ConvertUnits.ToSimUnits(pos1), FarseerPhysics.ConvertUnits.ToSimUnits(pos2), true);
+
+                distanceJoint.Length = 0.01f;
+                distanceJoint.Frequency = 1.0f;
+                distanceJoint.DampingRatio = 0.8f;
+
+                joint = distanceJoint;
+            }
+
+
+            joint.CollideConnected = true;
+        }
+
+        private void ConnectWireBetweenPorts()
+        {
+            Wire wire = item.GetComponent<Wire>();
+            if (wire == null) return;
+
+            wire.Hidden = true;
+            wire.Locked = true;
+
+            if (Item.Connections == null) return;
+
+            var powerConnection = Item.Connections.Find(c => c.IsPower);
+            if (powerConnection == null) return;
+
+            if (dockingTarget == null || dockingTarget.item.Connections == null) return;
+            var recipient = dockingTarget.item.Connections.Find(c => c.IsPower);
+            if (recipient == null) return;
+
+            wire.RemoveConnection(item);
+            wire.RemoveConnection(dockingTarget.item);
+
+
+            powerConnection.TryAddLink(wire);
+            wire.Connect(powerConnection, false, false);
+            recipient.TryAddLink(wire);
+            wire.Connect(recipient, false, false);
+        }
+
+        private void CreateDoorBody()
+        {
+            doorBody = BodyFactory.CreateRectangle(GameMain.World,
+                dockingTarget.door.Body.width,
+                dockingTarget.door.Body.height,
+                1.0f,
+                dockingTarget.door);
+
+            doorBody.CollisionCategories = Physics.CollisionWall;
+            doorBody.BodyType = BodyType.Static;
+            doorBody.SetTransform(
+                ConvertUnits.ToSimUnits(item.Position + (dockingTarget.door.Item.WorldPosition - item.WorldPosition)),
+                0.0f);
+        }
+
+        private void CreateHull()
+        {
+            var hullRects = new Rectangle[] { item.WorldRect, dockingTarget.item.WorldRect };
+            var subs = new Submarine[] { item.Submarine, dockingTarget.item.Submarine };
+
+            hulls = new Hull[2];
+            bodies = new Body[4];
+
+            if (dockingTarget.door != null)
+            {
+                CreateDoorBody();
+            }
+
+            if (door != null)
+            {
+                dockingTarget.CreateDoorBody();
+            }
+            
+            if (IsHorizontal)
+            {
+                if (hullRects[0].Center.X > hullRects[1].Center.X)
+                {
+                    hullRects = new Rectangle[] { dockingTarget.item.WorldRect, item.WorldRect };
+                    subs = new Submarine[] { dockingTarget.item.Submarine,item.Submarine };
+                }
+
+                hullRects[0] = new Rectangle(hullRects[0].Center.X, hullRects[0].Y, ((int)DockedDistance / 2), hullRects[0].Height);
+                hullRects[1] = new Rectangle(hullRects[1].Center.X - ((int)DockedDistance / 2), hullRects[1].Y, ((int)DockedDistance / 2), hullRects[1].Height);
+
+                for (int i = 0; i < 2; i++)
+                {
+                    hullRects[i].Location -= (subs[i].WorldPosition - subs[i].HiddenSubPosition).ToPoint();
+                    hulls[i] = new Hull(MapEntityPrefab.list.Find(m => m.Name == "Hull"), hullRects[i], subs[i]);
+                    hulls[i].AddToGrid(subs[i]);
+
+                    for (int j = 0; j < 2; j++)
+                    {
+                        bodies[i + j * 2] = BodyFactory.CreateEdge(GameMain.World,
+                            ConvertUnits.ToSimUnits(new Vector2(hullRects[i].X, hullRects[i].Y - hullRects[i].Height * j)),
+                            ConvertUnits.ToSimUnits(new Vector2(hullRects[i].Right, hullRects[i].Y - hullRects[i].Height * j)));
+                    }
+                }
+
+                gap = new Gap(new Rectangle(hullRects[0].Right - 2, hullRects[0].Y, 4, hullRects[0].Height), true, subs[0]);
+                if (gapId != null) gap.ID = (ushort)gapId;
+
+                LinkHullsToGap();
+            }
+            else
+            {
+                if (hullRects[0].Center.Y > hullRects[1].Center.Y)
+                {
+                    hullRects = new Rectangle[] { dockingTarget.item.WorldRect, item.WorldRect };
+                    subs = new Submarine[] { dockingTarget.item.Submarine, item.Submarine };
+                }
+
+                hullRects[0] = new Rectangle(hullRects[0].X, hullRects[0].Y + (int)(-hullRects[0].Height+DockedDistance)/2, hullRects[0].Width, ((int)DockedDistance / 2));
+                hullRects[1] = new Rectangle(hullRects[1].X, hullRects[1].Y - hullRects[1].Height/2, hullRects[1].Width, ((int)DockedDistance / 2));
+
+                for (int i = 0; i < 2; i++)
+                {
+                    hullRects[i].Location -= (subs[i].WorldPosition - subs[i].HiddenSubPosition).ToPoint();
+                    hulls[i] = new Hull(MapEntityPrefab.list.Find(m => m.Name == "Hull"), hullRects[i], subs[i]);
+                    hulls[i].AddToGrid(subs[i]);
+
+                    if (hullIds[i] != null) hulls[i].ID = (ushort)hullIds[i];
+                }
+
+                gap = new Gap(new Rectangle(hullRects[0].X, hullRects[0].Y+2, hullRects[0].Width, 4), false, subs[0]);
+                if (gapId != null) gap.ID = (ushort)gapId;
+
+                LinkHullsToGap();
+            }
+
+            item.linkedTo.Add(hulls[0]);
+            item.linkedTo.Add(hulls[1]);
+
+            hullIds[0] = hulls[0].ID;
+            hullIds[1] = hulls[1].ID;
+
+            gap.DisableHullRechecks = true;
+            gapId = gap.ID;
+
+            item.linkedTo.Add(gap);
+
+            foreach (Body body in bodies)
+            {
+                if (body == null) continue;
+                body.BodyType = BodyType.Static;
+                body.Friction = 0.5f;
+
+                body.CollisionCategories = Physics.CollisionWall;
+            }
+        }
+
+        private void LinkHullsToGap()
+        {
+            if (gap == null || hulls == null || hulls[0] == null || hulls[1] == null)
+            {
+#if DEBUG
+                DebugConsole.ThrowError("Failed to link dockingport hulls to gap");
+#endif
+                return;
+            }
+
+            gap.linkedTo.Clear();
+
+            if (IsHorizontal)
+            {
+                if (hulls[0].WorldRect.X < hulls[1].WorldRect.X)
+                {
+                    gap.linkedTo.Add(hulls[0]);
+                    gap.linkedTo.Add(hulls[1]);
+                }
+                else
+                {
+                    gap.linkedTo.Add(hulls[1]);
+                    gap.linkedTo.Add(hulls[0]);
+                }
+            }
+            else
+            {
+                if (hulls[0].WorldRect.Y > hulls[1].WorldRect.Y)
+                {
+                    gap.linkedTo.Add(hulls[0]);
+                    gap.linkedTo.Add(hulls[1]);
+                }
+                else
+                {
+                    gap.linkedTo.Add(hulls[1]);
+                    gap.linkedTo.Add(hulls[0]);
+                }
+            }
+        }
+
+        public void Undock()
+        {
+            if (dockingTarget == null || !docked) return;
+            
+            PlaySound(ActionType.OnUse, item.WorldPosition);
+
+            dockingTarget.item.Submarine.DockedTo.Remove(item.Submarine);
+            item.Submarine.DockedTo.Remove(dockingTarget.item.Submarine);
+            
+            //remove all waypoint links between this sub and the dockingtarget
+            foreach (WayPoint wp in WayPoint.WayPointList)
+            {
+                if (wp.Submarine != item.Submarine || wp.SpawnType != SpawnType.Path) continue;
+
+                for (int i = wp.linkedTo.Count - 1; i >= 0; i--)
+                {
+                    var wp2 = wp.linkedTo[i] as WayPoint;
+                    if (wp2 == null) continue;
+
+                    if (wp.Submarine == dockingTarget.item.Submarine)
+                    {
+                        wp.linkedTo.RemoveAt(i);
+                        wp2.linkedTo.Remove(wp);
+                    }
+                }
+            }
+
+            item.linkedTo.Clear();
+
+            docked = false;
+
+            dockingTarget.Undock();
+            dockingTarget = null;
+
+            if (doorBody != null)
+            {
+                GameMain.World.RemoveBody(doorBody);
+                doorBody = null;
+            }
+
+            var wire = item.GetComponent<Wire>();
+            if (wire != null)
+            {
+                wire.Drop(null);
+            }
+
+            if (joint != null)
+            {
+                GameMain.World.RemoveJoint(joint);
+                joint = null;
+            }
+
+            if (hulls != null)
+            {
+                hulls[0].Remove();
+                hulls[1].Remove();
+                hulls = null;
+            }
+
+            if (gap != null)
+            {
+                gap.Remove();
+                gap = null;
+            }
+
+            hullIds[0] = null;
+            hullIds[1] = null;
+
+            gapId = null;
+            
+            if (bodies!=null)
+            {
+                foreach (Body body in bodies)
+                {
+                    if (body == null) continue;
+                    GameMain.World.RemoveBody(body);
+                }
+                bodies = null;
+            }
+
+            if (GameMain.Server != null)
+            {
+                item.CreateServerEvent(this);
+            }
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            if (dockingTarget == null)
+            {
+                dockingState = MathHelper.Lerp(dockingState, 0.0f, deltaTime * 10.0f);
+                if (dockingState < 0.01f) docked = false;
+
+                item.SendSignal(0, "0", "state_out", null);
+                item.SendSignal(0, (FindAdjacentPort() != null) ? "1" : "0", "proximity_sensor", null);
+
+            }
+            else
+            {
+                if (!docked)
+                {
+                    Dock(dockingTarget);
+                    if (dockingTarget == null) return;
+                }
+
+                if (joint is DistanceJoint)
+                {
+                    item.SendSignal(0, "0", "state_out", null);
+                    dockingState = MathHelper.Lerp(dockingState, 0.5f, deltaTime * 10.0f);
+
+                    if (Vector2.Distance(joint.WorldAnchorA, joint.WorldAnchorB) < 0.05f)
+                    {
+                        Lock(false);
+                    }
+                }
+                else
+                {
+                    if (dockingTarget.door != null && doorBody != null)
+                    {
+                        doorBody.Enabled = dockingTarget.door.Body.Enabled;
+                    }
+
+                    item.SendSignal(0, "1", "state_out", null);
+
+                    dockingState = MathHelper.Lerp(dockingState, 1.0f, deltaTime * 10.0f);
+                }
+            }
+        }
+
+        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);
+                }
+            }
+        }
+
+        protected override void RemoveComponentSpecific()
+        {
+            list.Remove(this);
+        }
+
+        public override void OnMapLoaded()
+        {
+            foreach (Item it in Item.ItemList)
+            {
+                if (it.Submarine != item.Submarine) continue;
+
+                var doorComponent = it.GetComponent<Door>();
+                if (doorComponent == null) continue;
+
+                if (Vector2.Distance(item.Position, doorComponent.Item.Position) < Submarine.GridSize.X)
+                {
+                    this.door = doorComponent;
+                    break;
+                }
+            }
+
+            if (!item.linkedTo.Any()) return;
+
+            List<MapEntity> linked = new List<MapEntity>(item.linkedTo);
+            foreach (MapEntity entity in linked)
+            {
+                var hull = entity as Hull;
+                if (hull != null)
+                {
+                    hull.Remove();
+                    item.linkedTo.Remove(hull);
+                    continue;
+                }
+
+                var gap = entity as Gap;
+                if (gap != null)
+                {
+                    gap.Remove();
+                    continue;
+                }
+
+                Item linkedItem = entity as Item;
+                if (linkedItem == null) continue;
+
+                var dockingPort = linkedItem.GetComponent<DockingPort>();
+                if (dockingPort != null)
+                {
+                    Dock(dockingPort);
+                }
+            }
+        }
+
+        public override void ReceiveSignal(int stepsTaken, string signal, Connection connection, Item source, Character sender, float power = 0.0f)
+        {
+            if (GameMain.Client != null) return;
+
+            bool wasDocked = docked;
+            DockingPort prevDockingTarget = dockingTarget;
+
+            switch (connection.Name)
+            {
+                case "toggle":
+                    Docked = !docked;
+                    break;
+                case "set_active":
+                case "set_state":
+                    Docked = signal != "0";
+                    break;
+            }
+
+            if (sender != null && docked != wasDocked)
+            {
+                if (docked)
+                {
+                    if (item.Submarine != null && dockingTarget?.item?.Submarine != null)
+                        GameServer.Log(sender.Name + " docked " + item.Submarine.Name + " to " + dockingTarget.item.Submarine.Name, ServerLog.MessageType.ItemInteraction);
+                }
+                else
+                {
+                    if (item.Submarine != null && prevDockingTarget?.item?.Submarine != null)
+                        GameServer.Log(sender.Name + " undocked " + item.Submarine.Name + " from " + prevDockingTarget.item.Submarine.Name, ServerLog.MessageType.ItemInteraction);
+                }
+            }
+        }
+
+        public void ServerWrite(Lidgren.Network.NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(docked);
+
+            if (docked)
+            {
+                msg.Write(dockingTarget.item.ID);
+
+                if (hullIds[0] != null && hullIds[1] != null && gapId != null)
+                {
+                    msg.Write(true);
+                    msg.Write((ushort)hullIds[0]);
+                    msg.Write((ushort)hullIds[1]);
+                    msg.Write((ushort)gapId);
+                }
+                else
+                {
+                    msg.Write(false);
+                }
+            }
+        }
+
+        public void ClientRead(ServerNetObject type, Lidgren.Network.NetBuffer msg, float sendingTime)
+        {
+            bool isDocked = msg.ReadBoolean();
+
+            if (isDocked)
+            {
+                ushort dockingTargetID = msg.ReadUInt16();
+
+                bool isLocked = msg.ReadBoolean();
+
+                if (isLocked)
+                {
+                    hullIds[0] = msg.ReadUInt16();
+                    hullIds[1] = msg.ReadUInt16();
+                    gapId = msg.ReadUInt16();
+                }
+
+                Entity targetEntity = Entity.FindEntityByID(dockingTargetID);
+                if (targetEntity == null || !(targetEntity is Item))
+                {
+                    DebugConsole.ThrowError("Invalid docking port network event (can't dock to " + targetEntity.ToString() + ")");
+                    return;
+                }
+
+                dockingTarget = (targetEntity as Item).GetComponent<DockingPort>();
+                if (dockingTarget == null)
+                {
+                    DebugConsole.ThrowError("Invalid docking port network event (" + targetEntity + " doesn't have a docking port component)");
+                    return;
+                }
+
+                Dock(dockingTarget);
+
+                if (isLocked)
+                {
+                    Lock(true);
+
+                    hulls[0].ID = (ushort)hullIds[0];
+                    hulls[1].ID = (ushort)hullIds[1];
+                    gap.ID = (ushort)gapId;
+                }
+            }
+            else
+            {
+                Undock();
+            }
+        }
+
+    }
+}

BarotraumaShared/Source/Items/Components/Door.cs

@@ -0,0 +1,554 @@
+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
+{
+    class Door : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        private Gap linkedGap;
+
+        private Rectangle window;
+
+        private ConvexHull convexHull;
+        private ConvexHull convexHull2;
+
+        private bool isOpen;
+
+        private float openState;
+
+        private PhysicsBody body;
+
+        private Sprite doorSprite, weldedSprite;
+
+        private bool isHorizontal;
+
+        private bool isStuck;
+        
+        private bool? predictedState;
+        private float resetPredictionTimer;
+
+        public PhysicsBody Body
+        {
+            get { return body; }
+        }
+
+        private float stuck;
+        public float Stuck
+        {
+            get { return stuck; }
+            set 
+            {
+                if (isOpen) return;
+                stuck = MathHelper.Clamp(value, 0.0f, 100.0f);
+                if (stuck == 0.0f) isStuck = false;
+                if (stuck == 100.0f) isStuck = true;
+            }
+        }
+
+        public Gap LinkedGap
+        {
+            get
+            {
+                if (linkedGap != null) return linkedGap;
+
+                foreach (MapEntity e in item.linkedTo)
+                {
+                    linkedGap = e as Gap;
+                    if (linkedGap != null)
+                    {
+                        linkedGap.PassAmbientLight = window != Rectangle.Empty;
+                        return linkedGap;
+                    }
+                }
+                Rectangle rect = item.Rect;
+                if (isHorizontal)
+                {
+                    rect.Y += 5;
+                    rect.Height += 10;
+                }
+                else
+                {
+                    rect.X -= 5;
+                    rect.Width += 10;
+                }
+
+                linkedGap = new Gap(rect, Item.Submarine);
+                linkedGap.Submarine = item.Submarine;
+                linkedGap.PassAmbientLight = window != Rectangle.Empty;
+                linkedGap.Open = openState;
+                item.linkedTo.Add(linkedGap);
+                return linkedGap;
+            }
+        }
+        
+        [HasDefaultValue("0.0,0.0,0.0,0.0", false)]
+        public string Window
+        {
+            get { return ToolBox.Vector4ToString(new Vector4(window.X, window.Y, window.Width, window.Height)); }
+            set
+            {
+                Vector4 vector = ToolBox.ParseToVector4(value);
+                if (vector.Z!=0.0f || vector.W !=0.0f)
+                {
+                    window = new Rectangle((int)vector.X, (int)vector.Y, (int)vector.Z, (int)vector.W);
+                }
+            }
+        }
+
+        public Rectangle WindowRect
+        {
+            get { return window; }
+        }
+
+        [Editable, HasDefaultValue(false, true)]
+        public bool IsOpen
+        {
+            get { return isOpen; }
+            set 
+            {
+                isOpen = value;
+                OpenState = (isOpen) ? 1.0f : 0.0f;
+            }
+        }
+
+        private Rectangle doorRect;
+                
+        public float OpenState
+        {
+            get { return openState; }
+            set 
+            {
+                
+                float prevValue = openState;
+                openState = MathHelper.Clamp(value, 0.0f, 1.0f);
+                if (openState == prevValue) return;
+
+                UpdateConvexHulls();
+            }
+        }
+        
+        public Door(Item item, XElement element)
+            : base(item, element)
+        {
+            //Vector2 position = new Vector2(newRect.X, newRect.Y);
+
+            isHorizontal = ToolBox.GetAttributeBool(element, "horizontal", false);
+
+           // isOpen = false;
+            foreach (XElement subElement in element.Elements())
+            {
+                string texturePath = ToolBox.GetAttributeString(subElement, "texture", "");
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        doorSprite = new Sprite(subElement, texturePath.Contains("/") ? "" : Path.GetDirectoryName(item.Prefab.ConfigFile));
+                        break;
+                    case "weldedsprite":
+                        weldedSprite = new Sprite(subElement, texturePath.Contains("/") ? "" : Path.GetDirectoryName(item.Prefab.ConfigFile));
+                        break;
+                }
+            }
+
+            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);
+
+            body = new PhysicsBody(
+                ConvertUnits.ToSimUnits(Math.Max(doorRect.Width, 1)),
+                ConvertUnits.ToSimUnits(Math.Max(doorRect.Height, 1)),
+                0.0f,
+                1.5f);
+
+            body.UserData = item;
+            body.CollisionCategories = Physics.CollisionWall;
+            body.BodyType = BodyType.Static;
+            body.SetTransform(
+                ConvertUnits.ToSimUnits(new Vector2(doorRect.Center.X, doorRect.Y - doorRect.Height / 2)),
+                0.0f);
+            body.Friction = 0.5f;
+
+
+            //string spritePath = Path.GetDirectoryName(item.Prefab.ConfigFile) + "\\"+ ToolBox.GetAttributeString(element, "sprite", "");
+            
+            IsActive = true;
+        }
+
+        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));
+            }
+        }
+
+        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;
+        }
+
+        public override void Move(Vector2 amount)
+        {
+            base.Move(amount);
+
+            //LinkedGap.Move(amount);
+
+            body.SetTransform(body.SimPosition + ConvertUnits.ToSimUnits(amount), 0.0f);
+
+            UpdateConvexHulls();
+
+            //convexHull.Move(amount);
+            //if (convexHull2 != null) convexHull2.Move(amount);
+        }
+
+
+        public override bool Pick(Character picker)
+        {
+            isOpen = !isOpen;
+
+            return true;
+        }
+
+        public override bool Select(Character character)
+        {
+            //can only be selected if the item is broken
+            return item.Condition <= 0.0f;
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            bool isClosing = false;
+            if (!isStuck)
+            {
+                if (predictedState == null)
+                {
+                    OpenState += deltaTime * ((isOpen) ? 2.0f : -2.0f);
+                    isClosing = openState > 0.0f && openState < 1.0f && !isOpen;
+                }
+                else
+                {
+                    OpenState += deltaTime * (((bool)predictedState) ? 2.0f : -2.0f);
+                    isClosing = openState > 0.0f && openState < 1.0f && !(bool)predictedState;
+
+                    resetPredictionTimer -= deltaTime;
+                    if (resetPredictionTimer <= 0.0f)
+                    {
+                        predictedState = null;
+                    }
+                }
+
+                LinkedGap.Open = openState;
+            }
+            
+            if (isClosing)
+            {
+                PushCharactersAway();
+            }
+            else
+            {
+                body.Enabled = openState < 1.0f;
+            }
+
+            //don't use the predicted state here, because it might set
+            //other items to an incorrect state if the prediction is wrong
+            item.SendSignal(0, (isOpen) ? "1" : "0", "state_out", null);
+        }
+
+        public override void UpdateBroken(float deltaTime, Camera cam)
+        {
+            body.Enabled = false;
+
+            linkedGap.Open = 1.0f;
+        }
+        
+        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);  
+            }
+          
+        }
+
+        public override void OnMapLoaded()
+        {
+            LinkedGap.ConnectedDoor = this;
+            LinkedGap.Open = openState;
+
+            Vector2[] corners = GetConvexHullCorners(Rectangle.Empty);
+
+            convexHull = new ConvexHull(corners, Color.Black, item);
+            if (window != Rectangle.Empty) convexHull2 = new ConvexHull(corners, Color.Black, item);
+
+            UpdateConvexHulls();
+        }
+
+        protected override void RemoveComponentSpecific()
+        {
+            base.RemoveComponentSpecific();
+
+            if (body != null)
+            {                
+                body.Remove();
+                body = null;
+            }
+
+
+            if (linkedGap!=null) linkedGap.Remove();
+
+            doorSprite.Remove();
+            if (weldedSprite != null) weldedSprite.Remove();
+
+            if (convexHull!=null) convexHull.Remove();
+            if (convexHull2 != null) convexHull2.Remove();
+        }
+
+        private void PushCharactersAway()
+        {
+            //push characters out of the doorway when the door is closing/opening
+            Vector2 simPos = ConvertUnits.ToSimUnits(new Vector2(item.Rect.X, item.Rect.Y));
+
+            Vector2 currSize = isHorizontal ?
+                new Vector2(item.Rect.Width * (1.0f - openState), doorSprite.size.Y) :
+                new Vector2(doorSprite.size.X, item.Rect.Height * (1.0f - openState));
+
+            Vector2 simSize = ConvertUnits.ToSimUnits(currSize);
+
+            foreach (Character c in Character.CharacterList)
+            {
+                int dir = isHorizontal ? Math.Sign(c.SimPosition.Y - item.SimPosition.Y) : Math.Sign(c.SimPosition.X - item.SimPosition.X);
+
+                List<PhysicsBody> bodies = c.AnimController.Limbs.Select(l => l.body).ToList();
+                bodies.Add(c.AnimController.Collider);
+
+                foreach (PhysicsBody body in bodies)
+                {
+                    float diff = 0.0f;
+
+                    if (isHorizontal)
+                    {
+                        if (body.SimPosition.X < simPos.X || body.SimPosition.X > simPos.X + simSize.X) continue;
+
+                        diff = body.SimPosition.Y - item.SimPosition.Y;
+                    }
+                    else
+                    {
+                        if (body.SimPosition.Y > simPos.Y || body.SimPosition.Y < simPos.Y - simSize.Y) continue;
+
+                        diff = body.SimPosition.X - item.SimPosition.X;
+                    }
+                   
+                    if (Math.Sign(diff) != dir)
+                    {
+                        SoundPlayer.PlayDamageSound(DamageSoundType.LimbBlunt, 1.0f, body);
+
+                        if (isHorizontal)
+                        {
+                            body.SetTransform(new Vector2(body.SimPosition.X, item.SimPosition.Y + dir * simSize.Y * 2.0f), body.Rotation);
+                            body.ApplyLinearImpulse(new Vector2(isOpen ? 0.0f : 1.0f, dir * 2.0f));
+                        }
+                        else
+                        {
+                            body.SetTransform(new Vector2(item.SimPosition.X + dir * simSize.X * 1.2f, body.SimPosition.Y), body.Rotation);
+                            body.ApplyLinearImpulse(new Vector2(dir * 0.5f, isOpen ? 0.0f : -1.0f));
+                        }
+                    }
+
+                    if (isHorizontal)
+                    {
+                        if (Math.Abs(body.SimPosition.Y - item.SimPosition.Y) > simSize.Y * 0.5f) continue;
+
+                        body.ApplyLinearImpulse(new Vector2(isOpen ? 0.0f : 1.0f, dir * 0.5f));
+                    }
+                    else
+                    {
+                        if (Math.Abs(body.SimPosition.X - item.SimPosition.X) > simSize.X * 0.5f) continue;
+
+                        body.ApplyLinearImpulse(new Vector2(dir * 0.5f, isOpen ? 0.0f : -1.0f));
+                    }
+
+                    c.SetStun(0.2f);
+                }
+            }
+        }
+
+        public override void ReceiveSignal(int stepsTaken, string signal, Connection connection, Item source, Character sender, float power = 0.0f)
+        {
+            if (isStuck) return;
+
+            bool wasOpen = predictedState == null ? isOpen : predictedState.Value;
+
+            if (connection.Name == "toggle")
+            {
+                SetState(!wasOpen, false, true);
+            }
+            else if (connection.Name == "set_state")
+            {
+                SetState(signal != "0", false, true);
+            }
+
+            bool newState = predictedState == null ? isOpen : predictedState.Value;
+            if (sender != null && wasOpen != newState)
+            {
+                GameServer.Log(sender.Name + (newState ? " opened " : " closed ") + item.Name, ServerLog.MessageType.ItemInteraction);
+            }
+        }
+
+        public void SetState(bool open, bool isNetworkMessage, bool sendNetworkMessage = false)
+        {
+            if (isStuck || (predictedState == null && isOpen == open) || (predictedState != null && isOpen == predictedState.Value)) return;
+
+            if (GameMain.Client != null && !isNetworkMessage)
+            {
+                //clients can "predict" that the door opens/closes when a signal is received
+
+                //the prediction will be reset after 1 second, setting the door to a state
+                //sent by the server, or reverting it back to its old state if no msg from server was received
+
+                if (open != predictedState) PlaySound(ActionType.OnUse, item.WorldPosition);
+
+                predictedState = open;
+                resetPredictionTimer = CorrectionDelay;
+                
+            }
+            else
+            {
+                if (!isNetworkMessage || open != predictedState) PlaySound(ActionType.OnUse, item.WorldPosition);
+
+                isOpen = open;
+            }
+
+            //opening a partially stuck door makes it less stuck
+            if (isOpen) stuck = MathHelper.Clamp(stuck - 30.0f, 0.0f, 100.0f);
+
+            if (sendNetworkMessage)
+            {
+                item.CreateServerEvent(this);
+            }
+        }
+
+        public void ServerWrite(Lidgren.Network.NetBuffer msg, Barotrauma.Networking.Client c, object[] extraData = null)
+        {
+            msg.Write(isOpen);
+            msg.WriteRangedSingle(stuck, 0.0f, 100.0f, 8);
+        }
+
+        public void ClientRead(ServerNetObject type, Lidgren.Network.NetBuffer msg, float sendingTime)
+        {
+            SetState(msg.ReadBoolean(), true);
+            Stuck = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+
+            predictedState = null;
+        }
+    }
+}

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

@@ -0,0 +1,296 @@
+using System.Xml.Linq;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Barotrauma.Items.Components
+{
+    class Holdable : Pickable
+    {
+        //the position(s) in the item that the Character grabs
+        protected Vector2[] handlePos;
+
+        private List<RelatedItem> prevRequiredItems;
+
+        string prevMsg;
+
+        //the distance from the holding characters elbow to center of the physics body of the item
+        protected Vector2 holdPos;
+
+        protected Vector2 aimPos;
+
+        //protected bool aimable;
+
+        private bool attachable, attached, attachedByDefault;
+        private PhysicsBody body;
+
+        //the angle in which the Character holds the item
+        protected float holdAngle;
+
+        [HasDefaultValue(false, true)]
+        public bool Attached
+        {
+            get { return attached && item.ParentInventory == null; }
+            set { attached = value; }
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool ControlPose
+        {
+            get;
+            set;
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool Attachable
+        {
+            get { return attachable; }
+            set { attachable = value; }
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool AttachedByDefault
+        {
+            get { return attachedByDefault; }
+            set { attachedByDefault = value; }
+        }
+
+        [HasDefaultValue("0.0,0.0", false)]
+        public string HoldPos
+        {
+            get { return ToolBox.Vector2ToString(ConvertUnits.ToDisplayUnits(holdPos)); }
+            set { holdPos = ConvertUnits.ToSimUnits(ToolBox.ParseToVector2(value)); }
+        }
+
+        [HasDefaultValue("0.0,0.0", false)]
+        public string AimPos
+        {
+            get { return ToolBox.Vector2ToString(ConvertUnits.ToDisplayUnits(aimPos)); }
+            set { aimPos = ConvertUnits.ToSimUnits(ToolBox.ParseToVector2(value)); }
+        }
+
+        [HasDefaultValue(0.0f, false)]
+        public float HoldAngle
+        {
+            get { return MathHelper.ToDegrees(holdAngle); }
+            set { holdAngle = MathHelper.ToRadians(value); }
+        }
+
+        public Holdable(Item item, XElement element)
+            : base(item, element)
+        {
+            body = item.body;
+
+            handlePos = new Vector2[2];
+
+            for (int i = 1; i < 3; i++)
+            {
+                handlePos[i - 1] = ToolBox.GetAttributeVector2(element, "handle" + i, Vector2.Zero);
+
+                handlePos[i - 1] = ConvertUnits.ToSimUnits(handlePos[i - 1]);
+            }
+
+            canBePicked = true;
+
+            if (attachable)
+            {
+                prevRequiredItems = new List<RelatedItem>(requiredItems);
+                prevMsg = Msg;
+
+                requiredItems.Clear();
+                Msg = "";
+            }
+
+            if (attachedByDefault || (Screen.Selected == GameMain.EditMapScreen)) Use(1.0f);
+
+
+            //holdAngle = ToolBox.GetAttributeFloat(element, "holdangle", 0.0f);
+            //holdAngle = MathHelper.ToRadians(holdAngle);
+        }
+
+        public override void Drop(Character dropper)
+        {
+            DropConnectedWires(dropper);
+
+            if (body != null) item.body = body;
+
+            if (item.body != null) item.body.Enabled = true;
+            IsActive = false;
+
+            if (picker == null)
+            {
+                if (dropper == null) return;
+                picker = dropper;
+
+            }
+            if (picker.Inventory == null) return;
+            
+            item.Submarine = picker.Submarine;
+            if (item.body != null)
+            {
+                item.body.ResetDynamics();
+                item.SetTransform(picker.SimPosition, 0.0f);
+            }
+
+            picker.DeselectItem(item);
+            picker.Inventory.RemoveItem(item);
+            picker = null;
+        }
+
+        public override void Equip(Character character)
+        {
+            picker = character;
+
+            if (character != null) item.Submarine = character.Submarine;
+
+            if (item.body == null)
+            {
+                if (body != null)
+                {
+                    item.body = body;
+                }
+                else
+                {
+                    return;
+                }
+            }
+
+            if (!item.body.Enabled)
+            {
+                Limb rightHand = picker.AnimController.GetLimb(LimbType.RightHand);
+                item.SetTransform(rightHand.SimPosition, 0.0f);
+            }
+
+            bool alreadySelected = character.HasSelectedItem(item);
+            if (picker.TrySelectItem(item))
+            {
+                item.body.Enabled = true;
+                IsActive = true;
+
+                if (!alreadySelected) Networking.GameServer.Log(character.Name + " equipped " + item.Name, Networking.ServerLog.MessageType.ItemInteraction);
+            }
+        }
+
+        public override void Unequip(Character character)
+        {
+            if (picker == null) return;
+
+            picker.DeselectItem(item);
+
+            Networking.GameServer.Log(character.Name + " unequipped " + item.Name, Networking.ServerLog.MessageType.ItemInteraction);
+
+            item.body.Enabled = false;
+            IsActive = false;
+        }
+
+        public override bool Pick(Character picker)
+        {
+            if (!attachable)
+            {
+                return base.Pick(picker);
+            }
+
+            if (!base.Pick(picker))
+            {
+                return false;
+            }
+            else
+            {
+                requiredItems.Clear();
+                Msg = "";
+            }
+
+            attached = false;
+            if (body != null) item.body = body;
+            //item.body.Enabled = true;
+
+            return true;
+        }
+
+        public override bool Use(float deltaTime, Character character = null)
+        {
+            if (!attachable || item.body == null) return true;
+            if (character != null && !character.IsKeyDown(InputType.Aim)) return false;
+
+            item.Drop();
+
+            var containedItems = item.ContainedItems;
+            if (containedItems != null)
+            {
+                foreach (Item contained in containedItems)
+                {
+                    if (contained.body == null) continue;
+                    contained.SetTransform(item.SimPosition, contained.body.Rotation);
+                }
+            }
+
+            item.body.Enabled = false;
+            item.body = null;
+
+            requiredItems = new List<RelatedItem>(prevRequiredItems);
+            Msg = prevMsg;
+
+            attached = true;
+            
+            return true;
+        }
+
+        public override void UpdateBroken(float deltaTime, Camera cam)
+        {
+            Update(deltaTime, cam);
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            if (item.body == null || !item.body.Enabled) return;
+            if (picker == null || !picker.HasSelectedItem(item))
+            {
+                IsActive = false;
+                return;
+            }
+
+            ApplyStatusEffects(ActionType.OnActive, deltaTime, picker);
+
+            if (item.body.Dir != picker.AnimController.Dir) Flip(item);
+
+            item.Submarine = picker.Submarine;
+
+            picker.AnimController.HoldItem(deltaTime, item, handlePos, holdPos, aimPos, picker.IsKeyDown(InputType.Aim), holdAngle);
+        }
+
+        protected void Flip(Item item)
+        {
+            handlePos[0].X = -handlePos[0].X;
+            handlePos[1].X = -handlePos[1].X;
+            item.body.Dir = -item.body.Dir;
+        }
+
+        public override void OnMapLoaded()
+        {
+            //prevRequiredItems = new List<RelatedItem>(requiredItems);
+
+            if (!attachable) return;
+
+            if (Attached)
+            {
+                Use(1.0f);
+            }
+            else
+            {
+                if (item.ParentInventory != null)
+                {
+                    if (body != null)
+                    {
+                        item.body = body;
+                        body.Enabled = false;
+                    }
+                    attached = false;
+                }
+
+                requiredItems.Clear();
+                Msg = "";
+            }
+        }
+        
+    }
+}

BarotraumaShared/Source/Items/Components/Holdable/MeleeWeapon.cs

@@ -0,0 +1,261 @@
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Contacts;
+using Microsoft.Xna.Framework;
+using System;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    class MeleeWeapon : Holdable
+    {
+        private float hitPos;
+
+        private bool hitting;
+
+        private Attack attack;
+
+        private float range;
+
+        private Character user;
+
+        private float reload;
+
+        private float reloadTimer;
+
+        [HasDefaultValue(0.0f, false)]
+        public float Range
+        {
+            get { return ConvertUnits.ToDisplayUnits(range); }
+            set { range = ConvertUnits.ToSimUnits(value); }
+        }
+
+        [HasDefaultValue(0.5f, false)]
+        public float Reload
+        {
+            get { return reload; }
+            set { reload = Math.Max(0.0f, value); }
+        }
+
+        public MeleeWeapon(Item item, XElement element)
+            : base(item, element)
+        {
+            //throwForce = ToolBox.GetAttributeFloat(element, "throwforce", 1.0f);
+
+            foreach (XElement subElement in element.Elements())
+            {
+                if (subElement.Name.ToString().ToLowerInvariant() != "attack") continue;
+                attack = new Attack(subElement);
+            }
+        }
+
+        public override bool Use(float deltaTime, Character character = null)
+        {
+            if (character == null || reloadTimer>0.0f) return false;
+            if (!character.IsKeyDown(InputType.Aim) || hitting) return false;
+
+            //don't allow hitting if the character is already hitting with another weapon
+            for (int i = 0; i < 2; i++ )
+            {
+                if (character.SelectedItems[i] == null || character.SelectedItems[i] == Item) continue;
+
+                var otherWeapon = character.SelectedItems[i].GetComponent<MeleeWeapon>();
+                if (otherWeapon == null) continue;
+
+                if (otherWeapon.hitting) return false;
+            }
+
+            SetUser(character);
+
+            if (hitPos < MathHelper.Pi * 0.69f) return false;
+
+            reloadTimer = reload;
+
+            item.body.FarseerBody.CollisionCategories = Physics.CollisionProjectile;
+            item.body.FarseerBody.CollidesWith = Physics.CollisionCharacter | Physics.CollisionWall;
+            item.body.FarseerBody.OnCollision += OnCollision;
+
+            foreach (Limb l in character.AnimController.Limbs)
+            {
+                //item.body.FarseerBody.IgnoreCollisionWith(l.body.FarseerBody);
+
+                if (character.AnimController.InWater) continue;
+                if (l.type == LimbType.LeftFoot || l.type == LimbType.LeftThigh || l.type == LimbType.LeftLeg) continue;
+
+                if (l.type == LimbType.Head || l.type == LimbType.Torso)
+                {
+                    l.body.ApplyLinearImpulse(new Vector2(character.AnimController.Dir * 7.0f, -4.0f));                   
+                }
+                else
+                {
+                    l.body.ApplyLinearImpulse(new Vector2(character.AnimController.Dir * 5.0f, -2.0f));
+                }                
+            }
+            
+            hitting = true;
+
+            IsActive = true;
+            return false;
+        }
+        
+        public override void Drop(Character dropper)
+        {
+            base.Drop(dropper);
+
+            hitting = false;
+            hitPos = 0.0f;
+        }
+
+        public override void UpdateBroken(float deltaTime, Camera cam)
+        {
+            Update(deltaTime, cam);
+        }
+        
+        public override void Update(float deltaTime, Camera cam)
+        {
+            if (!item.body.Enabled) return;
+            if (!picker.HasSelectedItem(item)) IsActive = false;
+
+            reloadTimer -= deltaTime;
+
+            if (!picker.IsKeyDown(InputType.Aim) && !hitting) hitPos = 0.0f;
+
+            ApplyStatusEffects(ActionType.OnActive, deltaTime, picker);
+
+            if (item.body.Dir != picker.AnimController.Dir) Flip(item);
+
+            AnimController ac = picker.AnimController;
+
+            if (!hitting)
+            {
+                if (picker.IsKeyDown(InputType.Aim))
+                {
+                    hitPos = Math.Min(hitPos+deltaTime*5.0f, MathHelper.Pi*0.7f);
+
+                    ac.HoldItem(deltaTime, item, handlePos, new Vector2(0.6f, -0.1f), new Vector2(-0.3f, 0.2f), false, hitPos);
+                }
+                else
+                {
+                    ac.HoldItem(deltaTime, item, handlePos, new Vector2(hitPos, 0.0f), aimPos, false, holdAngle);
+                }
+            }
+            else
+            {
+                //Vector2 diff = Vector2.Normalize(picker.CursorPosition - ac.RefLimb.Position);
+                //diff.X = diff.X * ac.Dir;
+
+                hitPos -= deltaTime*15.0f;
+
+                //angl = -hitPos * 2.0f;
+                //    System.Diagnostics.Debug.WriteLine("<1.0f "+hitPos);
+
+
+
+                ac.HoldItem(deltaTime, item, handlePos, new Vector2(0.6f, -0.1f), new Vector2(-0.3f, 0.2f), false, hitPos);
+                //}
+                //else
+                //{
+                //    System.Diagnostics.Debug.WriteLine(">1.0f " + hitPos);
+                //    ac.HoldItem(deltaTime, item, handlePos, new Vector2(0.5f, 0.2f), new Vector2(1.0f, 0.2f), false, 0.0f);
+                //}
+
+                if (hitPos < -MathHelper.PiOver4*1.2f)
+                {
+                    RestoreCollision();
+                    hitting = false;
+                }
+            }
+        }
+
+
+        private void SetUser(Character character)
+        {
+            if (user == character) return;
+
+            if (user != null)
+            {
+                foreach (Limb limb in user.AnimController.Limbs)
+                {
+                    try
+                    {
+                        item.body.FarseerBody.RestoreCollisionWith(limb.body.FarseerBody);
+                    }
+
+                    catch
+                    {
+                        continue;
+                    }
+                }
+            }
+
+            foreach (Limb limb in character.AnimController.Limbs)
+            {
+                item.body.FarseerBody.IgnoreCollisionWith(limb.body.FarseerBody);
+            }
+
+            user = character;
+        }
+
+        private void RestoreCollision()
+        {
+            item.body.FarseerBody.OnCollision -= OnCollision;
+
+            item.body.CollisionCategories = Physics.CollisionItem;
+            item.body.CollidesWith = Physics.CollisionWall;
+
+            //foreach (Limb l in picker.AnimController.Limbs)
+            //{
+            //    item.body.FarseerBody.RestoreCollisionWith(l.body.FarseerBody);
+            //}
+        }
+
+
+        private bool OnCollision(Fixture f1, Fixture f2, Contact contact)
+        {
+            Character target = null;
+
+            Limb limb = f2.Body.UserData as Limb;
+            if (limb != null)
+            {
+                if (limb.character == picker) return false;
+                target = limb.character;
+            }
+            else
+            {
+                return false;
+            }
+
+            if (target == null)
+            {
+                target = f2.Body.UserData as Character;
+            }
+
+            if (target == null) return false;
+
+            if (attack != null) attack.DoDamage(user, target, item.WorldPosition, 1.0f);
+
+            RestoreCollision();
+            hitting = false;
+
+            if (GameMain.Client != null) return true;
+
+            if (GameMain.Server != null)
+            {
+                GameMain.Server.CreateEntityEvent(item, new object[] { Networking.NetEntityEvent.Type.ApplyStatusEffect, ActionType.OnUse, target.ID });
+
+                string logStr = picker?.Name + " used " + item.Name;
+                if (item.ContainedItems != null && item.ContainedItems.Length > 0)
+                {
+                    logStr += "(" + string.Join(", ", item.ContainedItems.Select(i => i?.Name)) + ")";
+                }
+                logStr += " on " + target + ".";
+                Networking.GameServer.Log(logStr, Networking.ServerLog.MessageType.Attack);
+            }
+
+            ApplyStatusEffects(ActionType.OnUse, 1.0f, limb.character);
+
+            return true;
+        }
+    }
+}

BarotraumaShared/Source/Items/Components/Holdable/Pickable.cs

@@ -0,0 +1,209 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    class Pickable : ItemComponent
+    {
+        protected Character picker;
+
+        protected List<InvSlotType> allowedSlots;
+
+        private float pickTimer;
+
+
+        public List<InvSlotType> AllowedSlots
+        {
+            get { return allowedSlots; }
+        }
+
+        public Character Picker
+        {
+            get { return picker; }
+        }
+        
+        public Pickable(Item item, XElement element)
+            : base(item, element)
+        {
+            allowedSlots = new List<InvSlotType>();
+
+            string slotString = ToolBox.GetAttributeString(element, "slots", "Any");
+            string[] slotCombinations = slotString.Split(',');
+            foreach (string slotCombination in slotCombinations)
+            {
+                string[] slots = slotCombination.Split('+');
+                InvSlotType allowedSlot = InvSlotType.None;
+                foreach (string slot in slots)                
+                {
+                    if (slot.ToLowerInvariant() == "bothhands")
+                    {
+                        allowedSlot = InvSlotType.LeftHand | InvSlotType.RightHand;
+                    }
+                    else
+                    {
+                        allowedSlot = allowedSlot | (InvSlotType)Enum.Parse(typeof(InvSlotType), slot.Trim());
+                    }
+                }
+                allowedSlots.Add(allowedSlot);
+            }
+
+            canBePicked = true;            
+        }
+
+        public override bool Pick(Character picker)
+        {
+            //return if someone is already trying to pick the item
+            if (pickTimer>0.0f) return false;
+            if (picker == null || picker.Inventory == null) return false;
+
+            if (PickingTime>0.0f)
+            {
+                CoroutineManager.StartCoroutine(WaitForPick(picker, PickingTime));
+                
+                return false;
+            }
+            else
+            {
+                return OnPicked(picker);
+            }
+
+
+        }
+
+        private bool OnPicked(Character picker)
+        {
+            if (picker.Inventory.TryPutItem(item, allowedSlots))
+            {
+                if (!picker.HasSelectedItem(item) && item.body != null) item.body.Enabled = false;
+                this.picker = picker;
+
+                for (int i = item.linkedTo.Count - 1; i >= 0; i--)
+                {
+                    item.linkedTo[i].RemoveLinked(item);
+                }
+                item.linkedTo.Clear();
+
+                DropConnectedWires(picker);
+
+                ApplyStatusEffects(ActionType.OnPicked, 1.0f, picker);
+                
+                return true;
+            }
+
+            return false;
+        }
+
+        private IEnumerable<object> WaitForPick(Character picker, float requiredTime)
+        {
+            var leftHand = picker.AnimController.GetLimb(LimbType.LeftHand);
+            var rightHand = picker.AnimController.GetLimb(LimbType.RightHand);
+
+            pickTimer = 0.0f;
+            while (pickTimer < requiredTime && Screen.Selected != GameMain.EditMapScreen)
+            {
+                if (picker.IsKeyDown(InputType.Aim) || 
+                    !item.IsInPickRange(picker.WorldPosition) ||
+                    picker.Stun > 0.0f || picker.IsDead)
+                {
+                    StopPicking(picker);
+                    yield return CoroutineStatus.Success;
+                }
+
+                picker.UpdateHUDProgressBar(
+                    this,
+                    item.WorldPosition,
+                    pickTimer / requiredTime,
+                    Color.Red, Color.Green);
+
+                picker.AnimController.Anim = AnimController.Animation.UsingConstruction;
+
+                picker.AnimController.TargetMovement = Vector2.Zero;
+
+                leftHand.Disabled = true;
+                leftHand.pullJoint.Enabled = true;
+                leftHand.pullJoint.WorldAnchorB = item.SimPosition + Vector2.UnitY * ((pickTimer / 10.0f) % 0.1f);
+
+                rightHand.Disabled = true;
+                rightHand.pullJoint.Enabled = true;
+                rightHand.pullJoint.WorldAnchorB = item.SimPosition + Vector2.UnitY * ((pickTimer / 10.0f) % 0.1f);
+
+                pickTimer += CoroutineManager.DeltaTime;
+
+                yield return CoroutineStatus.Running;
+            }
+
+            StopPicking(picker);
+
+            if (!picker.IsRemotePlayer) OnPicked(picker);
+
+            yield return CoroutineStatus.Success;
+        }
+
+        private void StopPicking(Character picker)
+        {
+            picker.AnimController.Anim = AnimController.Animation.None;
+            pickTimer = 0.0f;         
+        }
+
+        protected void DropConnectedWires(Character character)
+        {
+            Vector2 pos = character == null ? item.SimPosition : character.SimPosition;
+
+            var connectionPanel = item.GetComponent<ConnectionPanel>();
+            if (connectionPanel == null) return;
+            
+            foreach (Connection c in connectionPanel.Connections)
+            {
+                foreach (Wire w in c.Wires)
+                {
+                    if (w == null) continue;
+
+                    w.Item.Drop(character);
+                    w.Item.SetTransform(pos, 0.0f);
+                }
+            }            
+        }
+        
+        public override void Drop(Character dropper)
+        {            
+            if (picker == null)
+            {
+                picker = dropper;
+            }
+
+            Vector2 bodyDropPos = Vector2.Zero;
+
+            if (picker == null || picker.Inventory == null)
+            {
+                if (item.ParentInventory != null && item.ParentInventory.Owner != null)
+                {
+                    bodyDropPos = item.ParentInventory.Owner.SimPosition;
+
+                    if (item.body != null) item.body.ResetDynamics();                    
+                }
+            }
+            else
+            {
+                DropConnectedWires(picker);
+
+                item.Submarine = picker.Submarine;
+                bodyDropPos = picker.SimPosition;
+                
+                picker.Inventory.RemoveItem(item);
+                picker = null;
+            }
+
+            if (item.body != null && !item.body.Enabled)
+            {
+                    item.body.ResetDynamics();
+                item.SetTransform(bodyDropPos, 0.0f);
+                item.body.Enabled = true;
+            }
+        }
+
+    }
+}

BarotraumaShared/Source/Items/Components/Holdable/Propulsion.cs

@@ -0,0 +1,104 @@
+using System.Xml.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Barotrauma.Particles;
+
+namespace Barotrauma.Items.Components
+{
+    class Propulsion : ItemComponent
+    {
+        private float force;
+
+        private string particles;
+
+        private float useState;
+
+        private ParticlePrefab.DrawTargetType usableIn;
+                
+        [HasDefaultValue(0.0f, false)]
+        public float Force
+        {
+            get { return force; }
+            set { force = value; }
+        }
+        
+        [HasDefaultValue("", false)]
+        public string Particles
+        {
+            get { return particles; }
+            set { particles = value; }
+        }
+
+        public Propulsion(Item item, XElement element)
+            : base(item,element)
+        {
+            switch (ToolBox.GetAttributeString(element, "usablein", "both").ToLowerInvariant())
+            {
+                case "air":
+                    usableIn = ParticlePrefab.DrawTargetType.Air;
+                    break;
+                case "water":
+                    usableIn = ParticlePrefab.DrawTargetType.Water;
+                    break;
+                case "both":
+                default:
+                    usableIn = ParticlePrefab.DrawTargetType.Both;
+                    break;
+            }
+        }
+        
+        public override bool Use(float deltaTime, Character character = null)
+        {
+            if (character == null) return false;
+            if (!character.IsKeyDown(InputType.Aim) || character.Stun>0.0f) return false;
+
+            IsActive = true;
+            useState = 0.1f;
+
+
+            if (character.AnimController.InWater)
+            {
+                if (usableIn == ParticlePrefab.DrawTargetType.Air) return true;
+            }
+            else
+            {
+                if (usableIn == ParticlePrefab.DrawTargetType.Water) return true;
+            }
+
+            Vector2 dir = Vector2.Normalize(character.CursorPosition - character.Position);
+
+            Vector2 propulsion = dir * force;
+
+            if (character.AnimController.InWater) character.AnimController.TargetMovement = dir;
+
+            foreach (Limb limb in character.AnimController.Limbs)
+            {
+                if (limb.WearingItems.Find(w => w.WearableComponent.Item == this.item)==null) continue;
+
+                limb.body.ApplyForce(propulsion);
+            }
+
+            character.AnimController.Collider.ApplyForce(propulsion);
+
+            if (character.SelectedItems[0] == item) character.AnimController.GetLimb(LimbType.RightHand).body.ApplyForce(propulsion);
+            if (character.SelectedItems[1] == item) character.AnimController.GetLimb(LimbType.LeftHand).body.ApplyForce(propulsion);
+            
+
+            if (!string.IsNullOrWhiteSpace(particles))
+            {
+                GameMain.ParticleManager.CreateParticle(particles, item.WorldPosition,
+                    item.body.Rotation + ((item.body.Dir > 0.0f) ? 0.0f : MathHelper.Pi), 0.0f, item.CurrentHull);
+            }
+
+            return true;
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            useState -= deltaTime;
+
+            if (useState <= 0.0f) IsActive = false;
+        }
+        
+    }
+}

BarotraumaShared/Source/Items/Components/Holdable/RangedWeapon.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Items.Components
+{
+    class RangedWeapon : ItemComponent
+    {
+        private float reload, reloadTimer;
+
+        private Vector2 barrelPos;
+
+        [HasDefaultValue("0.0,0.0", false)]
+        public string BarrelPos
+        {
+            get { return ToolBox.Vector2ToString(ConvertUnits.ToDisplayUnits(barrelPos)); }
+            set { barrelPos = ConvertUnits.ToSimUnits(ToolBox.ParseToVector2(value)); }
+        }
+
+        [HasDefaultValue(1.0f, false)]
+        public float Reload
+        {
+            get { return reload; }
+            set { reload = Math.Max(value, 0.0f); }
+        }
+
+        public Vector2 TransformedBarrelPos
+        {
+            get
+            {
+                Matrix bodyTransform = Matrix.CreateRotationZ(item.body.Rotation);
+                Vector2 flippedPos = barrelPos;
+                if (item.body.Dir < 0.0f) flippedPos.X = -flippedPos.X;
+                return (Vector2.Transform(flippedPos, bodyTransform) + item.body.SimPosition);
+            }
+        }
+                
+        public RangedWeapon(Item item, XElement element)
+            : base(item, element)
+        {
+            //barrelPos = ToolBox.GetAttributeVector2(element, "barrelpos", Vector2.Zero);
+            //barrelPos = ConvertUnits.ToSimUnits(barrelPos);
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            reloadTimer -= deltaTime;
+
+            if (reloadTimer < 0.0f)
+            {
+                reloadTimer = 0.0f;
+                IsActive = false;
+            }
+        }
+        
+        public override bool Use(float deltaTime, Character character = null)
+        {
+            if (character == null) return false;
+            if (!character.IsKeyDown(InputType.Aim) || reloadTimer > 0.0f) return false;
+            IsActive = true;
+            reloadTimer = reload;
+
+            List<Body> limbBodies = new List<Body>();
+            foreach (Limb l in character.AnimController.Limbs)
+            {
+                limbBodies.Add(l.body.FarseerBody);
+            }
+
+            float degreeOfFailure = (100.0f - DegreeOfSuccess(character))/100.0f;
+
+            degreeOfFailure *= degreeOfFailure;
+
+            if (degreeOfFailure > Rand.Range(0.0f, 1.0f))
+            {
+                ApplyStatusEffects(ActionType.OnFailure, 1.0f, character);
+            }
+
+            Item[] containedItems = item.ContainedItems;
+            if (containedItems != null)
+            {
+                foreach (Item projectile in containedItems)
+                {
+                    if (projectile == null) continue;
+                    //find the projectile-itemcomponent of the projectile,
+                    //and add the limbs of the shooter to the list of bodies to be ignored
+                    //so that the player can't shoot himself
+                    Projectile projectileComponent= projectile.GetComponent<Projectile>();
+                    if (projectileComponent == null) continue;
+                
+                    projectile.body.ResetDynamics();
+                    projectile.SetTransform(TransformedBarrelPos, 
+                        ((item.body.Dir == 1.0f) ? item.body.Rotation : item.body.Rotation - MathHelper.Pi)
+                        + Rand.Range(-degreeOfFailure, degreeOfFailure));
+
+                    projectile.Use(deltaTime);
+                    projectileComponent.User = character;
+
+                    projectile.body.ApplyTorque(projectile.body.Mass * degreeOfFailure * Rand.Range(-10.0f, 10.0f));
+
+                    //recoil
+                    item.body.ApplyLinearImpulse(
+                        new Vector2((float)Math.Cos(projectile.body.Rotation), (float)Math.Sin(projectile.body.Rotation)) * item.body.Mass * -50.0f);
+                
+                    projectileComponent.IgnoredBodies = limbBodies;
+
+                    item.RemoveContained(projectile);
+                
+                    Rope rope = item.GetComponent<Rope>();
+                    if (rope != null) rope.Attach(projectile);
+
+                    return true;
+                }
+            }
+
+
+
+
+            return true;      
+        }
+            
+    }
+}

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

@@ -0,0 +1,271 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Barotrauma.Items.Components
+{
+    class RepairTool : ItemComponent
+    {
+        private readonly List<string> fixableEntities;
+
+        private float range;
+
+        private Vector2 pickedPosition;
+
+        private Vector2 barrelPos;
+
+        private string particles;
+
+        private float activeTimer;
+
+        [HasDefaultValue(0.0f, false)]
+        public float Range
+        {
+            get { return range; }
+            set { range = value; }
+        }
+
+        [HasDefaultValue(0.0f, false)]
+        public float StructureFixAmount
+        {
+            get; set;
+        }
+
+        [HasDefaultValue(0.0f, false)]
+        public float LimbFixAmount
+        {
+            get; set;
+        }
+        [HasDefaultValue(0.0f, false)]
+        public float ExtinquishAmount
+        {
+            get; set;
+        }
+
+        [HasDefaultValue("", false)]
+        public string Particles
+        {
+            get { return particles; }
+            set { particles = value; }
+        }
+
+        [HasDefaultValue(0.0f, false)]
+        public float ParticleSpeed
+        {
+            get; set;
+        }
+
+        [HasDefaultValue("0.0,0.0", false)]
+        public string BarrelPos
+        {
+            get { return ToolBox.Vector2ToString(barrelPos); }
+            set { barrelPos = ToolBox.ParseToVector2(value); }
+        }
+
+        public Vector2 TransformedBarrelPos
+        {
+            get
+            {
+                Matrix bodyTransform = Matrix.CreateRotationZ(item.body.Rotation);
+                Vector2 flippedPos = barrelPos;
+                if (item.body.Dir < 0.0f) flippedPos.X = -flippedPos.X;
+                return (Vector2.Transform(flippedPos, bodyTransform));
+            }
+        }
+
+        public RepairTool(Item item, XElement element)
+            : base(item, element)
+        {
+            this.item = item;
+
+            fixableEntities = new List<string>();
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "fixable":
+                        fixableEntities.Add(subElement.Attribute("name").Value);
+                        break;
+                }
+            }
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            activeTimer -= deltaTime;
+            if (activeTimer <= 0.0f) IsActive = false;
+        }
+
+        public override bool Use(float deltaTime, Character character = null)
+        {
+            if (character == null) return false;
+            if (!character.IsKeyDown(InputType.Aim)) return false;
+
+            //if (DoesUseFail(Character)) return false;
+
+            //targetPosition = targetPosition.X, -targetPosition.Y);
+
+            float degreeOfSuccess = DegreeOfSuccess(character)/100.0f;
+
+            if (Rand.Range(0.0f, 0.5f) > degreeOfSuccess)
+            {
+                ApplyStatusEffects(ActionType.OnFailure, deltaTime, character);
+                return false;
+            }
+
+            Vector2 targetPosition = item.WorldPosition;
+            targetPosition += new Vector2(
+                (float)Math.Cos(item.body.Rotation),
+                (float)Math.Sin(item.body.Rotation)) * range * item.body.Dir;
+
+            List<Body> ignoredBodies = new List<Body>();
+            foreach (Limb limb in character.AnimController.Limbs)
+            {
+                if (Rand.Range(0.0f, 0.5f) > degreeOfSuccess) continue;
+                ignoredBodies.Add(limb.body.FarseerBody);
+            }
+
+            IsActive = true;
+            activeTimer = 0.1f;
+
+            Vector2 rayStart    = ConvertUnits.ToSimUnits(item.WorldPosition);
+            Vector2 rayEnd      = ConvertUnits.ToSimUnits(targetPosition);
+
+            if (character.Submarine == null)
+            {
+                foreach (Submarine sub in Submarine.Loaded)
+                {
+                    Repair(rayStart - sub.SimPosition, rayEnd - sub.SimPosition, deltaTime, character, degreeOfSuccess, ignoredBodies);
+                }
+                Repair(rayStart, rayEnd, deltaTime, character, degreeOfSuccess, ignoredBodies);
+            }
+            else
+            {
+                Repair(rayStart - character.Submarine.SimPosition, rayEnd - character.Submarine.SimPosition, deltaTime, character, degreeOfSuccess, ignoredBodies);
+            }
+
+            GameMain.ParticleManager.CreateParticle(particles, item.WorldPosition + TransformedBarrelPos,
+                -item.body.Rotation + ((item.body.Dir > 0.0f) ? 0.0f : MathHelper.Pi), ParticleSpeed);
+          
+            return true;
+        }
+
+        private void Repair(Vector2 rayStart, Vector2 rayEnd, float deltaTime, Character user, float degreeOfSuccess, List<Body> ignoredBodies)
+        {
+            if (ExtinquishAmount > 0.0f && item.CurrentHull != null)
+            {
+                Vector2 displayPos = ConvertUnits.ToDisplayUnits(rayStart + (rayEnd - rayStart) * Submarine.LastPickedFraction * 0.9f);
+
+                displayPos += item.CurrentHull.Submarine.Position;
+
+                Hull hull = Hull.FindHull(displayPos, item.CurrentHull);
+                if (hull != null)
+                {
+                    hull.Extinquish(deltaTime, ExtinquishAmount, displayPos);
+                    if (hull != item.CurrentHull)
+                    {
+                        item.CurrentHull.Extinquish(deltaTime, ExtinquishAmount, displayPos);
+                    }
+                }
+
+            }
+
+            Body targetBody = Submarine.PickBody(rayStart, rayEnd, ignoredBodies);
+
+            if (targetBody == null || targetBody.UserData == null) return;
+
+            pickedPosition = Submarine.LastPickedPosition;
+
+            Structure targetStructure;
+            Limb targetLimb;
+            Item targetItem;
+            if ((targetStructure = (targetBody.UserData as Structure)) != null)
+            {
+                if (!fixableEntities.Contains("structure") && !fixableEntities.Contains(targetStructure.Name)) return;
+                if (targetStructure.IsPlatform) return;
+
+                int sectionIndex = targetStructure.FindSectionIndex(ConvertUnits.ToDisplayUnits(pickedPosition));
+                if (sectionIndex < 0) return;
+
+                Vector2 progressBarPos = targetStructure.SectionPosition(sectionIndex);
+                if (targetStructure.Submarine != null)
+                {
+                    progressBarPos += targetStructure.Submarine.DrawPosition;
+                }
+
+                var progressBar = user.UpdateHUDProgressBar(
+                    targetStructure,
+                    progressBarPos,
+                    1.0f - targetStructure.SectionDamage(sectionIndex) / targetStructure.Health,
+                    Color.Red, Color.Green);
+
+                if (progressBar != null) progressBar.Size = new Vector2(60.0f, 20.0f);
+
+                targetStructure.AddDamage(sectionIndex, -StructureFixAmount * degreeOfSuccess);
+
+                //if the next section is small enough, apply the effect to it as well
+                //(to make it easier to fix a small "left-over" section)
+                for (int i = -1; i < 2; i += 2)
+                {
+                    int nextSectionLength = targetStructure.SectionLength(sectionIndex + i);
+                    if ((sectionIndex == 1 && i == -1) ||
+                        (sectionIndex == targetStructure.SectionCount - 2 && i == 1) ||
+                        (nextSectionLength > 0 && nextSectionLength < Structure.wallSectionSize * 0.3f))
+                    {
+                        //targetStructure.HighLightSection(sectionIndex + i);
+                        targetStructure.AddDamage(sectionIndex + i, -StructureFixAmount * degreeOfSuccess);
+                    }
+                }
+            }
+            else if ((targetLimb = (targetBody.UserData as Limb)) != null)
+            {
+                targetLimb.character.AddDamage(CauseOfDeath.Damage, -LimbFixAmount * degreeOfSuccess, user);                
+            }
+            else if ((targetItem = (targetBody.UserData as Item)) != null)
+            {
+                targetItem.IsHighlighted = true;
+
+                ApplyStatusEffects(ActionType.OnUse, targetItem.AllPropertyObjects, deltaTime);
+            }        
+        }
+        
+        public override bool AIOperate(float deltaTime, Character character, AIObjectiveOperateItem objective)
+        {
+            Gap leak = objective.OperateTarget as Gap;
+            if (leak == null) return true;
+
+            float dist = Vector2.Distance(leak.WorldPosition, item.WorldPosition);
+
+            //too far away -> consider this done and hope the AI is smart enough to move closer
+            if (dist > range * 5.0f) return true;
+            
+            //steer closer if almost in range
+            if (dist > range)
+            {
+                Vector2 standPos = leak.isHorizontal ?
+                    new Vector2(Math.Sign(item.WorldPosition.X - leak.WorldPosition.X), 0.0f)
+                    : new Vector2(0.0f, Math.Sign(item.WorldPosition.Y - leak.WorldPosition.Y));
+
+                standPos = leak.WorldPosition + standPos * range;
+
+                character.AIController.SteeringManager.SteeringManual(deltaTime, (standPos - character.WorldPosition) / 1000.0f);   
+            }
+            else
+            {
+                //close enough -> stop moving
+                character.AIController.SteeringManager.Reset();
+            }
+
+            character.CursorPosition = leak.Position;
+            character.SetInput(InputType.Aim, false, true);
+
+            Use(deltaTime, character);
+
+            return leak.Open <= 0.0f;
+        }
+    }
+}

BarotraumaShared/Source/Items/Components/Holdable/Throwable.cs

@@ -0,0 +1,143 @@
+using Microsoft.Xna.Framework;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    class Throwable : Holdable
+    {
+        float throwForce;
+
+        float throwPos;
+
+        bool throwing;
+
+        [HasDefaultValue(1.0f, false)]
+        public float ThrowForce
+        {
+            get { return throwForce; }
+            set { throwForce = value; }
+        }
+
+        public Throwable(Item item, XElement element)
+            : base(item, element)
+        {
+            //throwForce = ToolBox.GetAttributeFloat(element, "throwforce", 1.0f);
+        }
+
+        public override bool Use(float deltaTime, Character character = null)
+        {
+            if (character == null) return false;
+            if (!character.IsKeyDown(InputType.Aim) || throwing) return false;
+
+            //Vector2 diff = Vector2.Normalize(Character.CursorPosition - Character.AnimController.RefLimb.Position);
+
+            //if (Character.SelectedItems[1]==item)
+            //{
+            //    Limb leftHand = Character.AnimController.GetLimb(LimbType.LeftHand);
+            //    leftHand.body.ApplyLinearImpulse(diff * 20.0f);
+            //    leftHand.Disabled = true;
+            //}
+
+            //if (Character.SelectedItems[0] == item)
+            //{
+            //    Limb rightHand = Character.AnimController.GetLimb(LimbType.RightHand);
+            //    rightHand.body.ApplyLinearImpulse(diff * 20.0f);
+            //    rightHand.Disabled = true;
+            //}
+
+            throwing = true;
+
+            IsActive = true;
+            return true;
+        }
+
+        public override void SecondaryUse(float deltaTime, Character character = null)
+        {
+            if (throwing) return;
+        }
+
+        public override void Drop(Character dropper)
+        {
+            base.Drop(dropper);
+
+            throwing = false;
+            throwPos = 0.0f;
+        }
+
+        public override void UpdateBroken(float deltaTime, Camera cam)
+        {
+            Update(deltaTime, cam);
+        }
+        
+        public override void Update(float deltaTime, Camera cam)
+        {
+            if (!item.body.Enabled) return;
+            if (!picker.HasSelectedItem(item)) IsActive = false;
+
+            if (!picker.IsKeyDown(InputType.Aim) && !throwing) throwPos = 0.0f;
+
+            ApplyStatusEffects(ActionType.OnActive, deltaTime, picker);
+
+            if (item.body.Dir != picker.AnimController.Dir) Flip(item);
+
+            AnimController ac = picker.AnimController;
+
+            item.Submarine = picker.Submarine;
+
+            if (!throwing)
+            {
+                if (picker.IsKeyDown(InputType.Aim))
+                {
+                    throwPos = (float)System.Math.Min(throwPos+deltaTime*5.0f, MathHelper.Pi*0.7f);
+
+                    ac.HoldItem(deltaTime, item, handlePos, new Vector2(0.6f, -0.0f), new Vector2(-0.3f, 0.2f), false, throwPos);
+                }
+                else
+                {
+                    ac.HoldItem(deltaTime, item, handlePos, new Vector2(throwPos, 0.0f), aimPos, false, 0.0f);
+                }
+
+
+            }
+            else
+            {
+                //Vector2 diff = Vector2.Normalize(picker.CursorPosition - ac.RefLimb.Position);
+                //diff.X = diff.X * ac.Dir;
+
+                throwPos -= deltaTime*15.0f;
+
+                //angl = -hitPos * 2.0f;
+                //    System.Diagnostics.Debug.WriteLine("<1.0f "+hitPos);
+
+
+
+                ac.HoldItem(deltaTime, item, handlePos, new Vector2(0.6f, 0.0f), new Vector2(-0.3f, 0.2f), false, throwPos);
+                //}
+                //else
+                //{
+                //    System.Diagnostics.Debug.WriteLine(">1.0f " + hitPos);
+                //    ac.HoldItem(deltaTime, item, handlePos, new Vector2(0.5f, 0.2f), new Vector2(1.0f, 0.2f), false, 0.0f);
+                //}
+
+
+                if (throwPos < -0.0)
+                {
+
+                    Vector2 throwVector = picker.CursorWorldPosition - picker.WorldPosition;
+                    throwVector = Vector2.Normalize(throwVector);
+
+                    item.Drop();
+                    item.body.ApplyLinearImpulse(throwVector * throwForce * item.body.Mass * 3.0f);
+
+                    ac.GetLimb(LimbType.Head).body.ApplyLinearImpulse(throwVector*10.0f);
+                    ac.GetLimb(LimbType.Torso).body.ApplyLinearImpulse(throwVector * 10.0f);
+
+                    Limb rightHand = ac.GetLimb(LimbType.RightHand);
+                    item.body.AngularVelocity = rightHand.body.AngularVelocity;
+
+                    throwing = false;
+                }
+            }
+        }    
+    }
+}

BarotraumaShared/Source/Items/Components/ItemComponent.cs

@@ -0,0 +1,811 @@
+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
+{
+    interface IDrawableComponent
+    {
+        void Draw(SpriteBatch spriteBatch, bool editing);
+    }
+
+    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;
+        }
+    }
+
+    /// <summary>
+    /// The base class for components holding the different functionalities of the item
+    /// </summary>
+    class ItemComponent : IPropertyObject
+    {
+        protected Item item;
+
+        protected string name;
+
+        private bool isActive;
+
+        protected bool characterUsable;
+
+        protected bool canBePicked;
+        protected bool canBeSelected;
+
+        public bool WasUsed;
+
+        public readonly Dictionary<ActionType, List<StatusEffect>> statusEffectLists;
+                
+        public List<RelatedItem> requiredItems;
+
+        public List<Skill> requiredSkills;
+
+        private Dictionary<ActionType,List<ItemSound>> sounds;
+
+        private GUIFrame guiFrame;
+
+        public ItemComponent Parent;
+
+        protected const float CorrectionDelay = 1.0f;
+        protected CoroutineHandle delayedCorrectionCoroutine;
+        protected float correctionTimer;
+
+        private string msg;
+        
+        [HasDefaultValue(0.0f, false)]
+        public float PickingTime
+        {
+            get;
+            private set;
+        }
+
+        public readonly Dictionary<string, ObjectProperty> properties;
+        public Dictionary<string, ObjectProperty> ObjectProperties
+        {
+            get { return properties; }
+        }
+                
+        public virtual bool IsActive
+        {
+            get { return isActive; }
+            set 
+            {
+                if (!value && isActive)
+                {
+                    StopSounds(ActionType.OnActive);                    
+                }
+
+                isActive = value; 
+            }
+        }
+
+        private bool drawable = true;
+
+        public bool Drawable
+        {
+            get { return drawable; }
+            set 
+            {
+                if (value == drawable) return;
+                if (!(this is IDrawableComponent))
+                {
+                    DebugConsole.ThrowError("Couldn't make \""+this+"\" drawable (the component doesn't implement the IDrawableComponent interface)");
+                    return;
+                }  
+              
+                drawable = value;
+                if (drawable)
+                {
+                    if (!item.drawableComponents.Contains((IDrawableComponent)this))
+                        item.drawableComponents.Add((IDrawableComponent)this);
+                }
+                else
+                {
+                    item.drawableComponents.Remove((IDrawableComponent)this);
+                }                
+            }
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool CanBePicked
+        {
+            get { return canBePicked; }
+            set { canBePicked = value; }
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool DrawHudWhenEquipped
+        {
+            get;
+            private set;
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool CanBeSelected
+        {
+            get { return canBeSelected; }
+            set { canBeSelected = value; }
+        }
+
+        public InputType PickKey
+        {
+            get;
+            private set;
+        }
+
+        public InputType SelectKey
+        {
+            get;
+            private set;
+        }
+
+        [HasDefaultValue(false, false)]
+        public bool DeleteOnUse
+        {
+            get;
+            set;
+        }
+
+        public Item Item
+        {
+            get { return item; }
+        }
+
+        public string Name
+        {
+            get { return name; }
+        }
+
+        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; 
+            }
+        }
+
+        [HasDefaultValue("", false)]
+        public string Msg
+        {
+            get { return msg; }
+            set { msg = value; }
+        }
+        
+        public ItemComponent(Item item, XElement element) 
+        {
+            this.item = item;
+
+            properties = ObjectProperty.GetProperties(this);
+
+            //canBePicked = ToolBox.GetAttributeBool(element, "canbepicked", false);
+            //canBeSelected = ToolBox.GetAttributeBool(element, "canbeselected", false);
+            
+            //msg = ToolBox.GetAttributeString(element, "msg", "");
+            
+            requiredItems = new List<RelatedItem>();
+
+            requiredSkills = new List<Skill>();
+
+            sounds = new Dictionary<ActionType, List<ItemSound>>();
+
+            SelectKey = InputType.Select;
+
+            try
+            {
+                string selectKeyStr = ToolBox.GetAttributeString(element, "selectkey", "Select");
+                selectKeyStr = ToolBox.ConvertInputType(selectKeyStr);
+                SelectKey = (InputType)Enum.Parse(typeof(InputType), selectKeyStr, true);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Invalid select key in " + element + "!", e);
+            }
+
+            PickKey = InputType.Select;
+
+            try
+            {
+                string pickKeyStr = ToolBox.GetAttributeString(element, "selectkey", "Select");
+                pickKeyStr = ToolBox.ConvertInputType(pickKeyStr);
+                PickKey = (InputType)Enum.Parse(typeof(InputType),pickKeyStr, true);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Invalid pick key in " + element + "!", e);
+            }
+            
+            properties = ObjectProperty.InitProperties(this, element);
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "requireditem":
+                    case "requireditems":
+                        RelatedItem ri = RelatedItem.Load(subElement);
+                        if (ri != null) requiredItems.Add(ri);
+                        break;
+
+                    case "requiredskill":
+                    case "requiredskills":
+                        string skillName = ToolBox.GetAttributeString(subElement, "name", "");
+                        requiredSkills.Add(new Skill(skillName, ToolBox.GetAttributeInt(subElement, "level", 0)));
+                        break;
+                    case "statuseffect":
+                        var statusEffect = StatusEffect.Load(subElement);
+
+                        if (statusEffectLists == null) statusEffectLists = new Dictionary<ActionType, List<StatusEffect>>();
+
+                        List<StatusEffect> effectList;
+                        if (!statusEffectLists.TryGetValue(statusEffect.type, out effectList))
+                        {
+                            effectList = new List<StatusEffect>();
+                            statusEffectLists.Add(statusEffect.type, effectList);
+                        }
+
+                        effectList.Add(statusEffect);
+
+                        break;
+                    case "guiframe":
+                        string rectStr = ToolBox.GetAttributeString(subElement, "rect", "0.0,0.0,0.5,0.5");
+
+                        string[] components = rectStr.Split(',');
+                        if (components.Length < 4) continue;
+
+                        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 " + element + "! \"" + element.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");
+                            continue;
+                        }
+                
+                        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:
+                        ItemComponent ic = Load(subElement, item, item.ConfigFile, false);                        
+                        if (ic == null) break;
+
+                        ic.Parent = this;
+                        item.components.Add(ic);
+                        break;
+                }
+                
+            }        
+        }
+
+        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 Move(Vector2 amount) { }
+        
+        /// <summary>a Character has picked the item</summary>
+        public virtual bool Pick(Character picker) 
+        {
+            return false;
+        }
+
+        public virtual bool Select(Character character)
+        {
+            return CanBeSelected;
+        }
+        
+        /// <summary>a Character has dropped the item</summary>
+        public virtual void Drop(Character dropper)  { }
+
+        //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) { }
+        
+        /// <returns>true if the operation was completed</returns>
+        public virtual bool AIOperate(float deltaTime, Character character, AIObjectiveOperateItem objective) 
+        {
+            return false;
+        }
+
+        //called when isActive is true and condition > 0.0f
+        public virtual void Update(float deltaTime, Camera cam) { }
+
+        //called when isActive is true and condition == 0.0f
+        public virtual void UpdateBroken(float deltaTime, Camera cam) 
+        {
+            StopSounds(ActionType.OnActive);          
+        }
+
+        //called when the item is equipped and left mouse button is pressed
+        //returns true if the item was used succesfully (not out of ammo, reloading, etc)
+        public virtual bool Use(float deltaTime, Character character = null) 
+        {
+            return false;
+        }
+
+        //called when the item is equipped and right mouse button is pressed
+        public virtual void SecondaryUse(float deltaTime, Character character = null) { }  
+
+        //called when the item is placed in a "limbslot"
+        public virtual void Equip(Character character) { }
+
+        //called then the item is dropped or dragged out of a "limbslot"
+        public virtual void Unequip(Character character) { }
+        
+        public virtual void ReceiveSignal(int stepsTaken, string signal, Connection connection, Item source, Character sender, float power = 0.0f) 
+        {
+        
+            switch (connection.Name)
+            {
+                case "activate":
+                case "use":
+                    item.Use(1.0f);
+                    break;
+                case "toggle":
+                    IsActive = !isActive;
+                    break;
+                case "set_active":
+                case "set_state":
+                    IsActive = signal != "0";
+                    break;
+            }
+        }
+
+        public virtual bool Combine(Item item) 
+        {
+            return false;
+        }
+
+        public void Remove()
+        {
+            if (loopingSound != null)
+            {
+                Sounds.SoundManager.Stop(loopingSoundIndex);
+            }
+
+            if (delayedCorrectionCoroutine != null)
+            {
+                CoroutineManager.StopCoroutines(delayedCorrectionCoroutine);
+                delayedCorrectionCoroutine = null;
+            }
+
+            RemoveComponentSpecific();
+        }
+
+        /// <summary>
+        /// Remove the component so that it doesn't appear to exist in the game world (stop sounds, remove bodies etc)
+        /// but don't reset anything that's required for cloning the item
+        /// </summary>
+        public void ShallowRemove()
+        {
+            if (loopingSound != null)
+            {
+                Sounds.SoundManager.Stop(loopingSoundIndex);
+            }
+
+            ShallowRemoveComponentSpecific();
+        }
+
+        protected virtual void ShallowRemoveComponentSpecific()
+        {
+            RemoveComponentSpecific();
+        }
+
+        protected virtual void RemoveComponentSpecific() 
+        { }
+
+        public bool HasRequiredSkills(Character character)
+        {
+            Skill temp;
+            return HasRequiredSkills(character, out temp);
+        }
+
+        public bool HasRequiredSkills(Character character, out Skill insufficientSkill)
+        {
+            foreach (Skill skill in requiredSkills)
+            {
+                int characterLevel = character.GetSkillLevel(skill.Name);
+                if (characterLevel < skill.Level)
+                {
+                    insufficientSkill = skill;
+                    return false;
+                }
+            }
+            insufficientSkill = null;
+            return true;
+        }
+
+        /// <summary>
+        /// Returns 0.0f-1.0f based on how well the Character can use the itemcomponent
+        /// </summary>
+        /// <returns>0.5f if all the skills meet the skill requirements exactly, 1.0f if they're way above and 0.0f if way less</returns>
+        protected float DegreeOfSuccess(Character character)
+        {
+            if (requiredSkills.Count == 0) return 100.0f;
+
+            float[] skillSuccess = new float[requiredSkills.Count];
+
+            for (int i = 0; i < requiredSkills.Count; i++ )
+            {
+                int characterLevel = character.GetSkillLevel(requiredSkills[i].Name);
+
+                skillSuccess[i] = (characterLevel - requiredSkills[i].Level);
+            }
+
+            float average = skillSuccess.Average();
+
+            return (average+100.0f)/2.0f;        
+        }
+
+        public virtual void FlipX() { }
+
+        public bool HasRequiredContainedItems(bool addMessage)
+        {
+            List<RelatedItem> requiredContained = requiredItems.FindAll(ri=> ri.Type == RelatedItem.RelationType.Contained);
+
+            if (!requiredContained.Any()) return true;
+
+            Item[] containedItems = item.ContainedItems;
+            if (containedItems == null || !containedItems.Any()) return false;
+
+            foreach (RelatedItem ri in requiredContained)
+            {
+                Item containedItem = Array.Find(containedItems, x => x != null && x.Condition > 0.0f && ri.MatchesItem(x));
+                if (containedItem == null)
+                {
+                    if (addMessage && !string.IsNullOrEmpty(ri.Msg)) GUI.AddMessage(ri.Msg, Color.Red);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public bool HasRequiredItems(Character character, bool addMessage)
+        {
+            if (!requiredItems.Any()) return true;
+                       
+            foreach (RelatedItem ri in requiredItems)
+            {
+                if (!ri.Type.HasFlag(RelatedItem.RelationType.Equipped) && !ri.Type.HasFlag(RelatedItem.RelationType.Picked)) continue;
+
+                bool hasItem = false;
+                if (ri.Type.HasFlag(RelatedItem.RelationType.Equipped))
+                {
+                    if (character.SelectedItems.FirstOrDefault(it => it != null && it.Condition > 0.0f && ri.MatchesItem(it)) != null) hasItem = true;
+                }
+                if (!hasItem && ri.Type.HasFlag(RelatedItem.RelationType.Picked))
+                {
+                    if (character.Inventory.Items.FirstOrDefault(x => x!=null && x.Condition>0.0f && ri.MatchesItem(x))!=null) hasItem = true;
+                }
+                if (!hasItem)
+                {
+                    if (addMessage && !string.IsNullOrEmpty(ri.Msg)) GUI.AddMessage(ri.Msg, Color.Red);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        
+        public void ApplyStatusEffects(ActionType type, float deltaTime, Character character = null)
+        {
+            if (statusEffectLists == null) return;
+
+            List<StatusEffect> statusEffects;
+            if (!statusEffectLists.TryGetValue(type, out statusEffects)) return;
+
+            foreach (StatusEffect effect in statusEffects)
+            {
+                item.ApplyStatusEffect(effect, type, deltaTime, character);
+            }
+        }
+
+        public void ApplyStatusEffects(ActionType type, List<IPropertyObject> targets, float deltaTime)
+        {
+            if (statusEffectLists == null) return;
+
+            List<StatusEffect> statusEffects;
+            if (!statusEffectLists.TryGetValue(type, out statusEffects)) return;
+
+            foreach (StatusEffect effect in statusEffects)
+            {
+                effect.Apply(type, deltaTime, item, targets);
+            }
+        }
+
+        //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;
+        }
+
+        public virtual void Load(XElement componentElement)
+        {
+            if (componentElement == null) return;            
+
+            foreach (XAttribute attribute in componentElement.Attributes())
+            {
+                ObjectProperty property = null;
+                if (!properties.TryGetValue(attribute.Name.ToString().ToLowerInvariant(), out property)) continue;
+                
+                property.TrySetValue(attribute.Value);
+            }
+
+            List<RelatedItem> prevRequiredItems = new List<RelatedItem>(requiredItems);
+            requiredItems.Clear();
+
+            foreach (XElement subElement in componentElement.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "requireditem":
+                        RelatedItem newRequiredItem = RelatedItem.Load(subElement);
+                        
+                        if (newRequiredItem == null) continue;
+
+                        var prevRequiredItem = prevRequiredItems.Find(ri => ri.JoinedNames == newRequiredItem.JoinedNames);
+                        if (prevRequiredItem!=null)
+                        {
+                            newRequiredItem.statusEffects = prevRequiredItem.statusEffects;
+                            newRequiredItem.Msg = prevRequiredItem.Msg;
+                        }
+
+                        requiredItems.Add(newRequiredItem);
+                        break;
+                }
+            }
+        }
+
+        public virtual void OnMapLoaded() { }
+        
+        public static ItemComponent Load(XElement element, Item item, string file, bool errorMessages = true)
+        {
+            Type t;
+            string type = element.Name.ToString().ToLowerInvariant();
+            try
+            {
+                // Get the type of a specified class.                
+                t = Type.GetType("Barotrauma.Items.Components." + type + "", false, true);
+                if (t == null)
+                {
+                    if (errorMessages) DebugConsole.ThrowError("Could not find the component \"" + type + "\" (" + file + ")");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                if (errorMessages) DebugConsole.ThrowError("Could not find the component \"" + type + "\" (" + file + ")", e);
+                return null;
+            }
+
+            ConstructorInfo constructor;
+            try
+            {
+                if (t != typeof(ItemComponent) && !t.IsSubclassOf(typeof(ItemComponent))) return null;
+                constructor = t.GetConstructor(new Type[] { typeof(Item), typeof(XElement) });
+                if (constructor == null)
+                {
+                    DebugConsole.ThrowError("Could not find the constructor of the component \"" + type + "\" (" + file + ")");
+                    return null;
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Could not find the constructor of the component \"" + type + "\" (" + file + ")", e);
+                return null;
+            }
+
+            object[] lobject = new object[] { item, element };
+            object component = constructor.Invoke(lobject);
+
+            ItemComponent ic = (ItemComponent)component;
+            ic.name = element.Name.ToString();
+
+            return ic;
+        }
+        
+    }
+}

BarotraumaShared/Source/Items/Components/ItemContainer.cs

@@ -0,0 +1,320 @@
+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
+{
+    class ItemContainer : ItemComponent, IDrawableComponent
+    {
+        public const int MaxInventoryCount = 4;
+
+        List<RelatedItem> containableItems;
+        public ItemInventory Inventory;
+
+        private List<Pair<Item, StatusEffect>> itemsWithStatusEffects;
+
+        //how many items can be contained
+        [HasDefaultValue(5, false)]
+        public int Capacity
+        {
+            get { return capacity; }
+            set { capacity = Math.Max(value, 1); }
+        }
+        private int capacity;
+
+        [HasDefaultValue(true, false)]
+        public bool HideItems
+        {
+            get { return hideItems; }
+            set 
+            { 
+                hideItems = value;
+                Drawable = !hideItems;
+            }
+        }
+        private bool hideItems;
+
+        [HasDefaultValue(false, false)]
+        public bool DrawInventory
+        {
+            get { return drawInventory; }
+            set { drawInventory = value; }
+        }
+        private bool drawInventory;
+
+        //the position of the first item in the container
+        [HasDefaultValue("0.0,0.0", false)]
+        public string ItemPos
+        {
+            get { return ToolBox.Vector2ToString(itemPos); }
+            set { itemPos = ToolBox.ParseToVector2(value); }
+        }
+        private Vector2 itemPos;
+
+        //item[i].Pos = itemPos + itemInterval*i 
+        [HasDefaultValue("0.0,0.0", false)]
+        public string ItemInterval
+        {
+            get { return ToolBox.Vector2ToString(itemInterval); }
+            set { itemInterval = ToolBox.ParseToVector2(value); }
+        }
+        private Vector2 itemInterval;
+
+        [HasDefaultValue(0.0f, false)]
+        public float ItemRotation
+        {
+            get { return MathHelper.ToDegrees(itemRotation); }
+            set { itemRotation = MathHelper.ToRadians(value); }
+        }
+        private float itemRotation;
+
+
+        [HasDefaultValue("0.5,0.9", false)]
+        public string HudPos
+        {
+            get { return ToolBox.Vector2ToString(hudPos); }
+            set 
+            { 
+                hudPos = ToolBox.ParseToVector2(value);
+                //inventory.CenterPos = hudPos;
+            }
+        }
+        private Vector2 hudPos;
+
+        [HasDefaultValue(5, false)]
+        public int SlotsPerRow
+        {
+            get { return slotsPerRow; }
+            set { slotsPerRow = value; }
+        }
+        private int slotsPerRow;
+
+        public List<RelatedItem> ContainableItems
+        {
+            get { return containableItems; }
+        }
+
+        public ItemContainer(Item item, XElement element)
+            : base (item, element)
+        {
+            Inventory = new ItemInventory(item, this, capacity, hudPos, slotsPerRow);            
+            containableItems = new List<RelatedItem>();
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "containable":
+                        RelatedItem containable = RelatedItem.Load(subElement);
+                        if (containable == null) continue;
+                        
+                        containableItems.Add(containable);
+
+                        break;
+                }
+            }
+
+            itemsWithStatusEffects = new List<Pair<Item, StatusEffect>>();
+        }
+
+        public void OnItemContained(Item containedItem)
+        {
+            item.SetContainedItemPositions();
+            
+            RelatedItem ri = containableItems.Find(x => x.MatchesItem(containedItem));
+            if (ri != null)
+            {
+                foreach (StatusEffect effect in ri.statusEffects)
+                {
+                    itemsWithStatusEffects.Add(Pair<Item, StatusEffect>.Create(containedItem, effect));
+                }
+            }
+
+            //no need to Update() if this item has no statuseffects and no physics body
+            IsActive = itemsWithStatusEffects.Count > 0 || containedItem.body != null;
+        }
+
+        public void OnItemRemoved(Item item)
+        {
+            itemsWithStatusEffects.RemoveAll(i => i.First == item);
+
+            //deactivate if the inventory is empty
+            IsActive = itemsWithStatusEffects.Count > 0 || item.body != null;
+        }
+
+        public bool CanBeContained(Item item)
+        {
+            if (containableItems.Count == 0) return true;
+            return (containableItems.Find(x => x.MatchesItem(item)) != null);
+        }
+
+        public override void Update(float deltaTime, Camera cam)
+        {
+            if (item.body != null && 
+                item.body.Enabled &&
+                item.body.FarseerBody.Awake)
+            {
+                item.SetContainedItemPositions();
+            }
+
+            foreach (Pair<Item, StatusEffect> itemAndEffect in itemsWithStatusEffects)
+            {
+                Item contained = itemAndEffect.First;
+                if (contained.Condition < 0.0f) continue;
+
+                StatusEffect effect = itemAndEffect.Second;
+
+                if (effect.Targets.HasFlag(StatusEffect.TargetType.This))                 
+                    effect.Apply(ActionType.OnContaining, deltaTime, item, item.AllPropertyObjects);
+                if (effect.Targets.HasFlag(StatusEffect.TargetType.Contained)) 
+                    effect.Apply(ActionType.OnContaining, deltaTime, item, contained.AllPropertyObjects);               
+            }
+        }
+
+        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 bool Pick(Character picker)
+        {
+            return (picker != null);
+        }
+
+
+        public override bool Combine(Item item)
+        {
+            if (!containableItems.Any(x => x.MatchesItem(item))) return false;
+            
+            if (Inventory.TryPutItem(item))
+            {            
+                IsActive = true;
+                if (hideItems && item.body != null) item.body.Enabled = false;
+                            
+                return true;
+            }
+
+            return false;            
+        }
+
+        public override void OnMapLoaded()
+        {
+            if (itemIds == null) return;
+
+            for (ushort i = 0; i < itemIds.Length; i++)
+            {
+                Item item = MapEntity.FindEntityByID(itemIds[i]) as Item;
+                if (item == null) continue;
+
+                Inventory.TryPutItem(item, i, false, false);
+            }
+
+            itemIds = null;
+        }
+
+        protected override void ShallowRemoveComponentSpecific()
+        {
+        }
+
+        protected override void RemoveComponentSpecific()
+        {
+            foreach (Item item in Inventory.Items)
+            {
+                if (item == null) continue;
+                item.Remove();
+            }
+        }
+
+        public override void Load(XElement componentElement)
+        {
+            base.Load(componentElement);
+
+            string containedString = ToolBox.GetAttributeString(componentElement, "contained", "");
+
+            string[] itemIdStrings = containedString.Split(',');
+
+            itemIds = new ushort[itemIdStrings.Length];
+            for (int i = 0; i < itemIdStrings.Length; i++)
+            {
+                ushort id = 0;
+                if (!ushort.TryParse(itemIdStrings[i], out id)) continue;
+
+                itemIds[i] = id;
+            }
+        }
+
+        ushort[] itemIds;
+
+        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;
+        }
+    }
+}

BarotraumaShared/Source/Items/Components/ItemLabel.cs

@@ -0,0 +1,87 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Xml.Linq;
+namespace Barotrauma.Items.Components
+{
+    class ItemLabel : ItemComponent, IDrawableComponent
+    {
+        private GUITextBlock textBlock;
+
+        [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;
+            }
+        }
+
+        private Color textColor;
+        [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());
+        }
+    }
+}

BarotraumaShared/Source/Items/Components/Ladder.cs

@@ -0,0 +1,23 @@
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    class Ladder : ItemComponent
+    {
+
+        public Ladder(Item item, XElement element)
+            : base(item, element)
+        {
+        }
+
+        public override bool Select(Character character)
+        {
+            if (character == null) return false;
+
+            character.AnimController.Anim = AnimController.Animation.Climbing;
+            //picker.SelectedConstruction = item;
+
+            return true;
+        }
+    }
+}

BarotraumaShared/Source/Items/Components/Machines/Controller.cs

@@ -0,0 +1,289 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics.Joints;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Items.Components
+{
+    struct LimbPos
+    {
+        public LimbType limbType;
+        public Vector2 position;
+
+        public LimbPos(LimbType limbType, Vector2 position)
+        {
+            this.limbType = limbType;
+            this.position = position;
+        }
+    }
+
+    class Controller : ItemComponent
+    {
+        //where the limbs of the user should be positioned when using the controller
+        private List<LimbPos> limbPositions;
+
+        private Direction dir;
+
+        //the position where the user walks to when using the controller 
+        //(relative to the position of the item)
+        private Vector2 userPos;
+
+        private Camera cam;
+
+        private Character character;
+
+        public Vector2 UserPos
+        {
+            get { return userPos; }
+            set { userPos = value; }
+        }
+
+        public Controller(Item item, XElement element)
+            : base(item, element)
+        {
+            limbPositions = new List<LimbPos>();
+
+            userPos = ToolBox.GetAttributeVector2(element, "UserPos", Vector2.Zero);
+
+            Enum.TryParse<Direction>(ToolBox.GetAttributeString(element, "direction", "None"), out dir);
+                
+            foreach (XElement el in element.Elements())
+            {
+                if (el.Name != "limbposition") continue;
+
+                LimbPos lp = new LimbPos();
+
+                try
+                {
+                    lp.limbType = (LimbType)Enum.Parse(typeof(LimbType), el.Attribute("limb").Value, true);
+                }
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError("Error in " + element + ": " + e.Message, e);
+                }
+
+                lp.position = ToolBox.GetAttributeVector2(el, "position", Vector2.Zero);
+
+                limbPositions.Add(lp);
+            }
+
+            IsActive = true;
+        }
+
+        public override void Update(float deltaTime, Camera cam) 
+        {
+            this.cam = cam;
+
+            if (character == null 
+                || character.IsDead
+                || character.Stun > 0.0f
+                || character.SelectedConstruction != item
+                || Vector2.Distance(character.Position, item.Position) > item.PickDistance * 2.0f)
+            {
+                if (character != null)
+                {
+                    CancelUsing(character);
+                    character = null;
+                }
+                IsActive = false;
+                return;
+            }
+
+            character.AnimController.Anim = AnimController.Animation.UsingConstruction;
+
+            if (userPos != Vector2.Zero)
+            {
+                Vector2 diff = (item.WorldPosition + userPos) - character.WorldPosition;
+
+                if (character.AnimController.InWater)
+                {
+                    if (diff.Length() > 30.0f)
+                    {
+                        character.AnimController.TargetMovement = Vector2.Clamp(diff*0.01f, -Vector2.One, Vector2.One);
+                        character.AnimController.TargetDir = diff.X > 0.0f ? Direction.Right : Direction.Left;
+                    }
+                    else
+                    {
+                        character.AnimController.TargetMovement = Vector2.Zero;
+                    }
+                }
+                else
+                {
+                    diff.Y = 0.0f;
+                    if (diff != Vector2.Zero && diff.Length() > 10.0f)
+                    {
+                        character.AnimController.TargetMovement = Vector2.Normalize(diff);
+                        character.AnimController.TargetDir = diff.X > 0.0f ? Direction.Right : Direction.Left;
+                        return;
+                    }
+                    character.AnimController.TargetMovement = Vector2.Zero;                    
+                }
+            }
+
+            ApplyStatusEffects(ActionType.OnActive, deltaTime, character);
+
+            if (limbPositions.Count == 0) return;
+
+            character.AnimController.Anim = AnimController.Animation.UsingConstruction;
+
+            character.AnimController.ResetPullJoints();
+
+            if (dir != 0) character.AnimController.TargetDir = dir;
+
+            foreach (LimbPos lb in limbPositions)
+            {
+                Limb limb = character.AnimController.GetLimb(lb.limbType);
+                if (limb == null) continue;
+
+                limb.Disabled = true;
+
+                if (limb.pullJoint == null) continue;
+
+                Vector2 position = ConvertUnits.ToSimUnits(lb.position + new Vector2(item.Rect.X, item.Rect.Y));
+                limb.pullJoint.Enabled = true;
+                limb.pullJoint.WorldAnchorB = position;
+            }
+            
+        }
+
+        public override bool Use(float deltaTime, Character activator = null)
+        {
+            if (character == null || activator != character || character.SelectedConstruction != item)
+            {
+                character = null;
+                return false;
+            }
+
+            item.SendSignal(0, "1", "trigger_out", character);
+            
+            ApplyStatusEffects(ActionType.OnUse, 1.0f, activator);
+            
+            return true;
+        }
+
+        public override void SecondaryUse(float deltaTime, Character character = null)
+        {
+            if (this.character == null || this.character != character || this.character.SelectedConstruction != item)
+            {
+                character = null;
+                return;
+            }
+
+            Entity focusTarget = null;
+
+            if (character == null) return;
+            
+
+            foreach (Connection c in item.Connections)
+            {
+                if (c.Name != "position_out") continue;
+
+                foreach (Connection c2 in c.Recipients)
+                {
+                    if (c2 == null || c2.Item == null || !c2.Item.Prefab.FocusOnSelected) continue;
+
+                    focusTarget = c2.Item;
+
+                    break;
+                }
+            }
+
+            if (focusTarget == null)
+            {
+                item.SendSignal(0, ToolBox.Vector2ToString(character.CursorWorldPosition), "position_out", character);
+                return;
+            }
+
+            character.ViewTarget = focusTarget;
+            if (character == Character.Controlled && cam != null)
+            {
+                Lights.LightManager.ViewTarget = focusTarget;
+                cam.TargetPos = focusTarget.WorldPosition;
+
+                cam.OffsetAmount = MathHelper.Lerp(cam.OffsetAmount, (focusTarget as Item).Prefab.OffsetOnSelected, deltaTime*10.0f);
+            }
+            
+            if (!character.IsRemotePlayer || character.ViewTarget == focusTarget)
+            {
+                item.SendSignal(0, ToolBox.Vector2ToString(character.CursorWorldPosition), "position_out", character);
+            }
+        }
+
+        public override bool Pick(Character picker)
+        {
+            item.SendSignal(0, "1", "signal_out", picker);
+
+            PlaySound(ActionType.OnUse, item.WorldPosition);
+
+            return true;
+        }
+
+        private void CancelUsing(Character character)
+        {
+            foreach (LimbPos lb in limbPositions)
+            {
+                Limb limb = character.AnimController.GetLimb(lb.limbType);
+                if (limb == null) continue;
+
+                limb.Disabled = false;
+
+                limb.pullJoint.Enabled = false;
+            }
+
+            if (character.SelectedConstruction == this.item) character.SelectedConstruction = null;
+
+            character.AnimController.Anim = AnimController.Animation.None;
+        }
+
+        public override bool Select(Character activator)
+        {
+            if (activator == null) return false;
+
+            //someone already using the item
+            if (character != null)
+            {
+                if (character == activator)
+                {
+                    IsActive = false;
+                    CancelUsing(character);
+                    character = null;
+                    return false;
+                }
+            }
+            else
+            {
+                character = activator;
+                    
+                IsActive = true;
+            }
+
+            item.SendSignal(0, "1", "signal_out", character);
+            return true;
+        }
+
+        public override void FlipX()
+        {
+            if (dir != Direction.None)
+            {
+                dir = dir == Direction.Left ? Direction.Right : Direction.Left;
+            }
+
+            userPos.X = -UserPos.X;            
+
+            for (int i = 0; i < limbPositions.Count; i++)
+            {
+                float diff = (item.Rect.X + limbPositions[i].position.X) - item.Rect.Center.X;
+
+                Vector2 flippedPos =
+                    new Vector2(
+                        item.Rect.Center.X - diff - item.Rect.X,
+                        limbPositions[i].position.Y);
+
+                limbPositions[i] = new LimbPos(limbPositions[i].limbType, flippedPos);
+            }
+        }
+
+    }
+}