2f107db...5202af9

Barotrauma/BarotraumaServer/Source/Characters/Character.cs

@@ -5,21 +5,50 @@ namespace Barotrauma
 {
     partial class Character : Entity, IDamageable, ISerializableEntity, IClientSerializable, IServerSerializable
     {
-        //the Character that the player is currently controlling
-        private const Character controlled = null;
-
-        public static Character Controlled
-        {
-            get { return controlled; }
-            set
-            {
-                //do nothing
-            }
-        }
+        public static Character Controlled = null;
 
         partial void InitProjSpecific(XDocument doc)
         {
-            keys = null;
+        }
+
+        partial void AdjustKarma(Character attacker, AttackResult attackResult)
+        {
+            if (attacker == null) return;
+
+            Client attackerClient = GameMain.Server.ConnectedClients.Find(c => c.Character == attacker);
+            if (attackerClient == null) return;
+
+            Client targetClient = GameMain.Server.ConnectedClients.Find(c => c.Character == this);
+            if (targetClient != null)
+            {
+                if (attacker.TeamID == TeamID)
+                {
+                    attackerClient.Karma -= attackResult.Damage * 0.01f;
+                    if (CharacterHealth.MaxVitality <= CharacterHealth.MinVitality) attackerClient.Karma = 0.0f;
+                }
+            }
+        }
+
+        partial void KillProjSpecific(CauseOfDeathType causeOfDeath, Affliction causeOfDeathAffliction)
+        {
+            if (causeOfDeath == CauseOfDeathType.Affliction)
+            {
+                GameServer.Log(LogName + " has died (Cause of death: " + causeOfDeathAffliction.Prefab.Name + ")", ServerLog.MessageType.Attack);
+            }
+            else
+            {
+                GameServer.Log(LogName + " has died (Cause of death: " + causeOfDeath + ")", ServerLog.MessageType.Attack);
+            }
+
+            healthUpdateTimer = 0.0f;
+
+            foreach (Client client in GameMain.Server.ConnectedClients)
+            {
+                if (client.InGame)
+                {
+                    client.PendingPositionUpdates.Enqueue(this);
+                }
+            }
         }
     }
 }

Barotrauma/BarotraumaServer/Source/Characters/CharacterInfo.cs

@@ -0,0 +1,40 @@
+using Lidgren.Network;
+
+namespace Barotrauma
+{
+    partial class CharacterInfo
+    {
+        partial void SpawnInventoryItemProjSpecific(Item item)
+        {
+            Entity.Spawner.CreateNetworkEvent(item, false);
+        }
+
+        public void ServerWrite(NetBuffer msg)
+        {
+            msg.Write(ID);
+            msg.Write(Name);
+            msg.Write((byte)Gender);
+            msg.Write((byte)Race);
+            msg.Write((byte)HeadSpriteId);
+            msg.Write((byte)Head.HairIndex);
+            msg.Write((byte)Head.BeardIndex);
+            msg.Write((byte)Head.MoustacheIndex);
+            msg.Write((byte)Head.FaceAttachmentIndex);
+            msg.Write(ragdollFileName);
+
+            if (Job != null)
+            {
+                msg.Write(Job.Prefab.Identifier);
+                foreach (Skill skill in Job.Skills)
+                {
+                    msg.Write(skill.Level);
+                }
+            }
+            else
+            {
+                msg.Write("");
+            }
+            // TODO: animations
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Characters/CharacterNetworking.cs

@@ -0,0 +1,483 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    partial class Character
+    {
+        public string OwnerClientIP;
+        public string OwnerClientName;
+        public bool ClientDisconnected;
+        public float KillDisconnectedTimer;
+
+        private bool networkUpdateSent;
+
+        public float GetPositionUpdateInterval(Client recipient)
+        {
+            if (!Enabled) { return 1000.0f; }
+
+            if (recipient.Character == null)
+            {
+                return 0.1f;
+            }
+            else
+            {
+                float distance = Vector2.Distance(recipient.Character.WorldPosition, WorldPosition);
+                float priority = 1.0f - MathUtils.InverseLerp(
+                    NetConfig.HighPrioCharacterPositionUpdateDistance, 
+                    NetConfig.LowPrioCharacterPositionUpdateDistance,
+                    distance);
+
+                float interval = MathHelper.Lerp(
+                    NetConfig.LowPrioCharacterPositionUpdateInterval, 
+                    NetConfig.HighPrioCharacterPositionUpdateInterval,
+                    priority);
+
+                if (IsDead)
+                {
+                    interval = Math.Max(interval * 2, 0.1f);
+                }
+                return interval;
+            }
+        }
+
+        partial void UpdateNetInput()
+        {
+            if (!(this is AICharacter) || IsRemotePlayer)
+            {
+                if (!AllowInput)
+                {
+                    AnimController.Frozen = false;
+                    if (memInput.Count > 0)
+                    {
+                        prevDequeuedInput = dequeuedInput;
+                        dequeuedInput = memInput[memInput.Count - 1].states;
+                        memInput.RemoveAt(memInput.Count - 1);
+                    }
+                }
+                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 = AimRefPosition + new Vector2((float)Math.Cos(aimAngle), (float)Math.Sin(aimAngle)) * 60.0f;
+
+                    //reset focus when attempting to use/select something
+                    if (memInput[memInput.Count - 1].states.HasFlag(InputNetFlags.Use) ||
+                        memInput[memInput.Count - 1].states.HasFlag(InputNetFlags.Select) ||
+                        memInput[memInput.Count - 1].states.HasFlag(InputNetFlags.Health) ||
+                        memInput[memInput.Count - 1].states.HasFlag(InputNetFlags.Grab))
+                    {
+                        focusedItem = null;
+                        focusedCharacter = null;
+                    }
+                    var closestEntity = FindEntityByID(memInput[memInput.Count - 1].interact);
+                    if (closestEntity is Item)
+                    {
+                        if (CanInteractWith((Item)closestEntity))
+                        {
+                            focusedItem = (Item)closestEntity;
+                            focusedCharacter = null;
+                        }
+                    }
+                    else if (closestEntity is Character)
+                    {
+                        if (CanInteractWith((Character)closestEntity))
+                        {
+                            focusedCharacter = (Character)closestEntity;
+                            focusedItem = 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);
+                        }
+                    }
+                }
+            }
+            AnimController.Frozen = false;
+
+            if (networkUpdateSent)
+            {
+                foreach (Key key in keys)
+                {
+                    key.DequeueHit();
+                    key.DequeueHeld();
+                }
+
+                networkUpdateSent = false;
+            }
+        }
+
+        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 != InputNetFlags.None && newInput != InputNetFlags.FacingLeft)
+                        {
+                            c.KickAFKTimer = 0.0f;
+                        }
+                        else if (AnimController.Dir < 0.0f != newInput.HasFlag(InputNetFlags.FacingLeft))
+                        {
+                            //character changed the direction they're facing
+                            c.KickAFKTimer = 0.0f;
+                        }
+
+                        if (newInput.HasFlag(InputNetFlags.Aim))
+                        {
+                            newAim = msg.ReadUInt16();
+                        }
+                        if (newInput.HasFlag(InputNetFlags.Select) ||
+                            newInput.HasFlag(InputNetFlags.Use) ||
+                            newInput.HasFlag(InputNetFlags.Health) ||
+                            newInput.HasFlag(InputNetFlags.Grab))
+                        {
+                            newInteract = msg.ReadUInt16();
+                        }
+                        
+                        if (NetIdUtils.IdMoreRecent((ushort)(networkUpdateID - i), LastNetworkUpdateID) && (i < 60))
+                        {
+                            NetInputMem newMem = new NetInputMem
+                            {
+                                states = newInput,
+                                intAim = newAim,
+                                interact = newInteract,
+
+                                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, 3);
+                    switch (eventType)
+                    {
+                        case 0:
+                            Inventory.ServerRead(type, msg, c);
+                            break;
+                        case 1:
+                            bool doingCPR = msg.ReadBoolean();
+                            if (c.Character != this)
+                            {
+#if DEBUG
+                                DebugConsole.Log("Received a character update message from a client who's not controlling the character");
+#endif
+                                return;
+                            }
+
+                            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)
+                            {
+                                var causeOfDeath = CharacterHealth.GetCauseOfDeath();
+                                Kill(causeOfDeath.First, causeOfDeath.Second);
+                            }
+                            break;
+                    }
+                    break;
+            }
+            msg.ReadPadBits();
+        }
+
+        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, 3, 0);
+                        Inventory.SharedWrite(msg, extraData);
+                        break;
+                    case NetEntityEvent.Type.Control:
+                        msg.WriteRangedInteger(0, 3, 1);
+                        Client owner = ((Client)extraData[1]);
+                        msg.Write(owner == null ? (byte)0 : owner.ID);
+                        break;
+                    case NetEntityEvent.Type.Status:
+                        msg.WriteRangedInteger(0, 3, 2);
+                        WriteStatus(msg);
+                        break;
+                    case NetEntityEvent.Type.UpdateSkills:
+                        msg.WriteRangedInteger(0, 3, 3);
+                        if (Info?.Job == null)
+                        {
+                            msg.Write((byte)0);
+                        }
+                        else
+                        {
+                            msg.Write((byte)Info.Job.Skills.Count);
+                            foreach (Skill skill in Info.Job.Skills)
+                            {
+                                msg.Write(skill.Identifier);
+                                msg.Write(skill.Level);
+                            }
+                        }
+                        break;
+                    default:
+                        DebugConsole.ThrowError("Invalid NetworkEvent type for entity " + ToString() + " (" + (NetEntityEvent.Type)extraData[0] + ")");
+                        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 if (keys != null)
+                    {
+                        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);
+                    if (AnimController is HumanoidAnimController)
+                    {
+                        tempBuffer.Write(((HumanoidAnimController)AnimController).Crouching);
+                    }
+                    tempBuffer.Write(attack);
+
+                    if (aiming)
+                    {
+                        Vector2 relativeCursorPos = cursorPosition - AimRefPosition;
+                        tempBuffer.Write((UInt16)(65535.0 * Math.Atan2(relativeCursorPos.Y, relativeCursorPos.X) / (2.0 * Math.PI)));
+                    }
+                    tempBuffer.Write(IsRagdolled);
+
+                    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);
+                float MaxVel = NetConfig.MaxPhysicsBodyVelocity;
+                tempBuffer.WriteRangedSingle(MathHelper.Clamp(AnimController.Collider.LinearVelocity.X, -MaxVel, MaxVel), -MaxVel, MaxVel, 12);
+                tempBuffer.WriteRangedSingle(MathHelper.Clamp(AnimController.Collider.LinearVelocity.Y, -MaxVel, MaxVel), -MaxVel, MaxVel, 12);
+
+                bool fixedRotation = AnimController.Collider.FarseerBody.FixedRotation;
+                tempBuffer.Write(fixedRotation);
+                if (!fixedRotation)
+                {
+                    tempBuffer.Write(AnimController.Collider.Rotation);
+                    float MaxAngularVel = NetConfig.MaxPhysicsBodyAngularVelocity;
+                    tempBuffer.WriteRangedSingle(MathHelper.Clamp(AnimController.Collider.AngularVelocity, -MaxAngularVel, MaxAngularVel), -MaxAngularVel, MaxAngularVel, 8);
+                }
+
+                bool writeStatus = healthUpdateTimer <= 0.0f;
+                tempBuffer.Write(writeStatus);
+                if (writeStatus)
+                {
+                    WriteStatus(tempBuffer);
+                }
+
+                tempBuffer.WritePadBits();
+
+                msg.Write((byte)tempBuffer.LengthBytes);
+                msg.Write(tempBuffer);
+            }
+        }
+
+        private void WriteStatus(NetBuffer msg)
+        {
+            msg.Write(IsDead);
+            if (IsDead)
+            {
+                msg.WriteRangedInteger(0, Enum.GetValues(typeof(CauseOfDeathType)).Length - 1, (int)CauseOfDeath.Type);
+                if (CauseOfDeath.Type == CauseOfDeathType.Affliction)
+                {
+                    msg.WriteRangedInteger(0, AfflictionPrefab.List.Count - 1, AfflictionPrefab.List.IndexOf(CauseOfDeath.Affliction));
+                }
+
+                if (AnimController?.LimbJoints == null)
+                {
+                    //0 limbs severed
+                    msg.Write((byte)0);
+                }
+                else
+                {
+                    List<int> severedJointIndices = new List<int>();
+                    for (int i = 0; i < AnimController.LimbJoints.Length; i++)
+                    {
+                        if (AnimController.LimbJoints[i] != null && AnimController.LimbJoints[i].IsSevered)
+                        {
+                            severedJointIndices.Add(i);
+                        }
+                    }
+                    msg.Write((byte)severedJointIndices.Count);
+                    foreach (int jointIndex in severedJointIndices)
+                    {
+                        msg.Write((byte)jointIndex);
+                    }
+                }
+            }
+            else
+            {
+                CharacterHealth.ServerWrite(msg);
+            }
+        }
+
+        public void WriteSpawnData(NetBuffer msg)
+        {
+            if (GameMain.Server == null) return;
+            
+            int msgLength = msg.LengthBytes;
+
+            msg.Write(Info == null);
+            msg.Write(ID);
+            msg.Write(SpeciesName);
+            msg.Write(seed);
+
+            if (Removed)
+            {
+                msg.Write(0.0f);
+                msg.Write(0.0f);
+            }
+            else
+            {
+                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((byte)TeamID);
+            msg.Write(this is AICharacter);
+            msg.Write(info.SpeciesName);
+            info.ServerWrite(msg);
+
+            DebugConsole.Log("Character spawn message length: " + (msg.LengthBytes - msgLength));
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Events/Missions/CombatMission.cs

@@ -0,0 +1,103 @@
+using Barotrauma.Networking;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    partial class CombatMission
+    {
+        private bool[] teamDead = new bool[2];
+
+        public override string Description
+        {
+            get
+            {
+                if (descriptions == null) return "";
+                
+                //non-team-specific description
+                return descriptions[0];
+            }
+        }
+
+        public override bool AssignTeamIDs(List<Client> clients)
+        {
+            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 = Character.TeamType.Team1;
+                }
+                else
+                {
+                    randList[i].TeamID = Character.TeamType.Team2;
+                }
+            }
+            return true;
+        }
+
+        public override void Update(float deltaTime)
+        {
+            if (!initialized)
+            {
+                crews[0].Clear();
+                crews[1].Clear();
+                foreach (Character character in Character.CharacterList)
+                {
+                    if (character.TeamID == Character.TeamType.Team1)
+                    {
+                        crews[0].Add(character);
+                    }
+                    else if (character.TeamID == Character.TeamType.Team2)
+                    {
+                        crews[1].Add(character);
+                    }
+                }
+
+                initialized = true;
+            }
+
+            teamDead[0] = crews[0].All(c => c.IsDead || c.IsUnconscious);
+            teamDead[1] = 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(CauseOfDeathType.Unknown, null); });
+
+                        GameMain.GameSession.WinningTeam = i == 0 ? Character.TeamType.Team1 : Character.TeamType.Team2;
+
+                        state = 1;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                if (teamDead[0] && teamDead[1])
+                {
+                    GameMain.GameSession.WinningTeam = Character.TeamType.None;
+                    if (GameMain.Server != null) GameMain.Server.EndGame();
+                }
+                else if (GameMain.GameSession.WinningTeam != Character.TeamType.None)
+                {
+                    GameMain.Server.EndGame();
+                }
+            }
+
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/GameMain.cs

@@ -22,7 +22,6 @@ namespace Barotrauma
         public static GameSettings Config;
 
         public static GameServer Server;
-        public const GameClient Client = null;
         public static NetworkMember NetworkMember
         {
             get { return Server as NetworkMember; }
@@ -47,29 +46,29 @@ namespace Barotrauma
         
         public static bool ShouldRun = true;
 
+        private static Stopwatch stopwatch;
+
         public static HashSet<ContentPackage> SelectedPackages
         {
             get { return Config.SelectedContentPackages; }
         }
 
-        public GameMain()
+        public readonly string[] CommandLineArgs;
+
+        public GameMain(string[] args)
         {
             Instance = this;
-            
+
+            CommandLineArgs = args;
+
             World = new World(new Vector2(0, -9.82f));
             FarseerPhysics.Settings.AllowSleep = true;
             FarseerPhysics.Settings.ContinuousPhysics = false;
             FarseerPhysics.Settings.VelocityIterations = 1;
             FarseerPhysics.Settings.PositionIterations = 1;
 
-            Config = new GameSettings("config.xml");
-            if (Config.WasGameUpdated)
-            {
-                UpdaterUtil.CleanOldFiles();
-                Config.WasGameUpdated = false;
-                Config.Save();
-            }
-            
+            Config = new GameSettings();
+
             SteamManager.Initialize();
             if (GameSettings.SendUserStatistics) GameAnalyticsManager.Init();            
             
@@ -87,6 +86,7 @@ namespace Barotrauma
             StructurePrefab.LoadAll(GetFilesOfType(ContentType.Structure));
             ItemPrefab.LoadAll(GetFilesOfType(ContentType.Item));
             JobPrefab.LoadAll(GetFilesOfType(ContentType.Jobs));
+            ItemAssemblyPrefab.LoadAll();
             NPCConversation.LoadAll(GetFilesOfType(ContentType.NPCConversations));
             ItemAssemblyPrefab.LoadAll();
             LevelObjectPrefab.LoadAll();
@@ -140,22 +140,81 @@ namespace Barotrauma
 
         public void StartServer()
         {
-            XDocument doc = XMLExtensions.TryLoadXml(GameServer.SettingsFile);
-            if (doc == null)
+            string name = "Server";
+            int port = NetConfig.DefaultPort;
+            int queryPort = NetConfig.DefaultQueryPort;
+            bool publiclyVisible = false;
+            string password = "";
+            bool enableUpnp = false;
+            int maxPlayers = 10;
+            int ownerKey = 0;
+
+            XDocument doc = XMLExtensions.TryLoadXml(ServerSettings.SettingsFile);
+            if (doc?.Root == null)
             {
-                DebugConsole.ThrowError("File \"" + GameServer.SettingsFile + "\" not found. Starting the server with default settings.");
-                Server = new GameServer("Server", NetConfig.DefaultPort, NetConfig.DefaultQueryPort, false, "", false, 10);
-                return;
+                DebugConsole.ThrowError("File \"" + ServerSettings.SettingsFile + "\" not found. Starting the server with default settings.");
+            }
+            else
+            {
+                name = doc.Root.GetAttributeString("name", "Server");
+                port = doc.Root.GetAttributeInt("port", NetConfig.DefaultPort);
+                queryPort = doc.Root.GetAttributeInt("queryport", NetConfig.DefaultQueryPort);
+                publiclyVisible = doc.Root.GetAttributeBool("public", false);
+                password = doc.Root.GetAttributeString("password", "");
+                enableUpnp = doc.Root.GetAttributeBool("enableupnp", false);
+                maxPlayers = doc.Root.GetAttributeInt("maxplayers", 10);
+                ownerKey = 0;
+            }
+            
+            for (int i = 0; i < CommandLineArgs.Length; i++)
+            {
+                switch (CommandLineArgs[i].Trim())
+                {
+                    case "-name":
+                        name = CommandLineArgs[i + 1];
+                        i++;
+                        break;
+                    case "-port":
+                        int.TryParse(CommandLineArgs[i + 1], out port);
+                        i++;
+                        break;
+                    case "-queryport":
+                        int.TryParse(CommandLineArgs[i + 1], out queryPort);
+                        i++;
+                        break;
+                    case "-public":
+                        bool.TryParse(CommandLineArgs[i + 1], out publiclyVisible);
+                        i++;
+                        break;
+                    case "-password":
+                        password = CommandLineArgs[i + 1];
+                        i++;
+                        break;
+                    case "-upnp":
+                    case "-enableupnp":
+                        bool.TryParse(CommandLineArgs[i + 1], out enableUpnp);
+                        i++;
+                        break;
+                    case "-maxplayers":
+                        int.TryParse(CommandLineArgs[i + 1], out maxPlayers);
+                        i++;
+                        break;
+                    case "-ownerkey":
+                        int.TryParse(CommandLineArgs[i + 1], out ownerKey);
+                        i++;
+                        break;
+                }
             }
 
             Server = new GameServer(
-                doc.Root.GetAttributeString("name", "Server"),
-                doc.Root.GetAttributeInt("port", NetConfig.DefaultPort),
-                doc.Root.GetAttributeInt("queryport", NetConfig.DefaultQueryPort),
-                doc.Root.GetAttributeBool("public", false),
-                doc.Root.GetAttributeString("password", ""),
-                doc.Root.GetAttributeBool("enableupnp", false),
-                doc.Root.GetAttributeInt("maxplayers", 10));
+                name,
+                port,
+                queryPort,
+                publiclyVisible,
+                password,
+                enableUpnp,
+                maxPlayers,
+                ownerKey);
         }
 
         public void CloseServer()
@@ -174,7 +233,7 @@ namespace Barotrauma
             Init();
             StartServer();
 
-            Timing.Accumulator = 0.0;
+            ResetFrameTime();
 
             double frequency = (double)Stopwatch.Frequency;
             if (frequency <= 1500)
@@ -182,13 +241,18 @@ namespace Barotrauma
                 DebugConsole.NewMessage("WARNING: Stopwatch frequency under 1500 ticks per second. Expect significant syncing accuracy issues.", Color.Yellow);
             }
 
-            Stopwatch stopwatch = Stopwatch.StartNew();
+            stopwatch = Stopwatch.StartNew();
             long prevTicks = stopwatch.ElapsedTicks;
             while (ShouldRun)
             {
                 long currTicks = stopwatch.ElapsedTicks;
-                double elapsedTime = (currTicks - prevTicks) / frequency;
+                double elapsedTime = Math.Max(currTicks - prevTicks, 0) / frequency;
                 Timing.Accumulator += elapsedTime;
+                if (Timing.Accumulator > 1.0)
+                {
+                    //prevent spiral of death
+                    Timing.Accumulator = Timing.Step;
+                }
                 Timing.TotalTime += elapsedTime;
                 prevTicks = currTicks;
                 while (Timing.Accumulator >= Timing.Step)
@@ -202,6 +266,7 @@ namespace Barotrauma
                     Timing.Accumulator -= Timing.Step;
                 }
                 int frameTime = (int)(((double)(stopwatch.ElapsedTicks - prevTicks) / frequency) * 1000.0);
+                frameTime = Math.Max(0, frameTime);
                 Thread.Sleep(Math.Max(((int)(Timing.Step * 1000.0) - frameTime) / 2, 0));
             }
             stopwatch.Stop();
@@ -211,19 +276,14 @@ namespace Barotrauma
             SteamManager.ShutDown();
             if (GameSettings.SendUserStatistics) GameAnalytics.OnStop();
         }
-        
-        public void ProcessInput()
-        {
-            while (true)
-            {
-                string input = Console.ReadLine();
-                lock (DebugConsole.QueuedCommands)
-                {
-                    DebugConsole.QueuedCommands.Add(input);
-                }
-            }
-        }
 
+        public static void ResetFrameTime()
+        {
+            Timing.Accumulator = 0.0f;
+            stopwatch?.Reset();
+            stopwatch?.Start();
+        }
+        
         public CoroutineHandle ShowLoading(IEnumerable<object> loader, bool waitKeyHit = true)
         {
             return CoroutineManager.StartCoroutine(loader);

Barotrauma/BarotraumaServer/Source/GameSession/CrewManager.cs

@@ -0,0 +1,23 @@
+using Barotrauma.Networking;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    partial class CrewManager
+    {
+        partial void CreateRandomConversation()
+        {
+            List<Character> availableSpeakers = Character.CharacterList.FindAll(c =>
+                c.AIController is HumanAIController &&
+                !c.IsDead &&
+                c.SpeechImpediment <= 100.0f);
+
+            foreach (Client client in GameMain.Server.ConnectedClients)
+            {
+                if (client.Character != null) availableSpeakers.Remove(client.Character);
+            }
+
+            pendingConversationLines.AddRange(NPCConversation.CreateRandom(availableSpeakers));
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/GameSession/GameModes/CharacterCampaignData.cs

@@ -0,0 +1,31 @@
+using Barotrauma.Networking;
+
+namespace Barotrauma
+{
+    partial class CharacterCampaignData
+    {
+        partial void InitProjSpecific(Client client)
+        {
+            ClientIP = client.Connection.RemoteEndPoint.Address.ToString();
+            SteamID = client.SteamID;
+            CharacterInfo = client.CharacterInfo;
+        }
+
+        public bool MatchesClient(Client client)
+        {
+            if (SteamID > 0)
+            {
+                return SteamID == client.SteamID;
+            }
+            else
+            {
+                return ClientIP == client.Connection.RemoteEndPoint.Address.ToString();
+            }
+        }
+
+        public void SpawnInventoryItems(CharacterInfo characterInfo, Inventory inventory)
+        {
+            characterInfo.SpawnInventoryItems(inventory, itemData);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/GameSession/GameModes/MultiPlayerCampaign.cs

@@ -0,0 +1,206 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    partial class MultiPlayerCampaign : CampaignMode
+    {
+        public static void StartNewCampaign(string savePath, string subName, string seed)
+        {
+            if (string.IsNullOrWhiteSpace(savePath)) return;
+
+            GameMain.GameSession = new GameSession(new Submarine(subName, ""), savePath, 
+                GameModePreset.List.Find(g => g.Identifier == "multiplayercampaign"));
+            var campaign = ((MultiPlayerCampaign)GameMain.GameSession.GameMode);
+            campaign.GenerateMap(seed);
+            campaign.SetDelegates();
+
+            GameMain.NetLobbyScreen.ToggleCampaignMode(true);
+            GameMain.GameSession.Map.SelectRandomLocation(true);
+            SaveUtil.SaveGame(GameMain.GameSession.SavePath);
+            campaign.LastSaveID++;
+
+            DebugConsole.NewMessage("Campaign started!", Color.Cyan);
+            DebugConsole.NewMessage(GameMain.GameSession.Map.CurrentLocation.Name + " -> " + GameMain.GameSession.Map.SelectedLocation.Name, Color.Cyan);
+        }
+
+        public static void LoadCampaign(string selectedSave)
+        {
+            SaveUtil.LoadGame(selectedSave);
+            ((MultiPlayerCampaign)GameMain.GameSession.GameMode).LastSaveID++;
+            GameMain.NetLobbyScreen.ToggleCampaignMode(true);
+            GameMain.GameSession.Map.SelectRandomLocation(true);
+
+            DebugConsole.NewMessage("Campaign loaded!", Color.Cyan);
+            DebugConsole.NewMessage(GameMain.GameSession.Map.CurrentLocation.Name + " -> " + GameMain.GameSession.Map.SelectedLocation.Name, Color.Cyan);
+        }
+
+        public static void StartCampaignSetup()
+        {
+            DebugConsole.NewMessage("********* CAMPAIGN SETUP *********", Color.White);
+            DebugConsole.ShowQuestionPrompt("Do you want to start a new campaign? Y/N", (string arg) =>
+            {
+                if (arg.ToLowerInvariant() == "y" || arg.ToLowerInvariant() == "yes")
+                {
+                    DebugConsole.ShowQuestionPrompt("Enter a save name for the campaign:", (string saveName) =>
+                    {
+                        StartNewCampaign(saveName, GameMain.NetLobbyScreen.SelectedSub.FilePath, GameMain.NetLobbyScreen.LevelSeed);
+                    });
+                }
+                else
+                {
+                    string[] saveFiles = SaveUtil.GetSaveFiles(SaveUtil.SaveType.Multiplayer);
+                    DebugConsole.NewMessage("Saved campaigns:", Color.White);
+                    for (int i = 0; i < saveFiles.Length; i++)
+                    {
+                        DebugConsole.NewMessage("   " + i + ". " + saveFiles[i], Color.White);
+                    }
+                    DebugConsole.ShowQuestionPrompt("Select a save file to load (0 - " + (saveFiles.Length - 1) + "):", (string selectedSave) =>
+                    {
+                        int saveIndex = -1;
+                        if (!int.TryParse(selectedSave, out saveIndex)) return;
+
+                        LoadCampaign(saveFiles[saveIndex]);
+                    });
+                }
+            });
+        }
+
+        protected override void WatchmanInteract(Character watchman, Character interactor)
+        {
+            if ((watchman.Submarine == Level.Loaded.StartOutpost && !Submarine.MainSub.AtStartPosition) ||
+                (watchman.Submarine == Level.Loaded.EndOutpost && !Submarine.MainSub.AtEndPosition))
+            {
+                CreateDialog(new List<Character> { watchman }, "WatchmanInteractNoLeavingSub", 5.0f);                
+                return;
+            }
+
+            bool hasPermissions = true;
+            if (GameMain.Server != null)
+            {
+                var client = GameMain.Server.ConnectedClients.Find(c => c.Character == interactor);
+                hasPermissions = client != null &&
+                    (client.HasPermission(ClientPermissions.ManageRound) || client.HasPermission(ClientPermissions.ManageCampaign));
+                CreateDialog(new List<Character> { watchman }, hasPermissions ? "WatchmanInteract" : "WatchmanInteractNotAllowed", 1.0f);
+            }
+        }
+
+        partial void SetDelegates()
+        {
+            if (GameMain.Server != null)
+            {
+                CargoManager.OnItemsChanged += () => { LastUpdateID++; };
+                Map.OnLocationSelected += (loc, connection) => { LastUpdateID++; };
+                Map.OnMissionSelected += (loc, mission) => { LastUpdateID++; };
+            }
+        }
+
+        public void DiscardClientCharacterData(Client client)
+        {
+            characterData.RemoveAll(cd => cd.MatchesClient(client));
+        }
+
+        public CharacterCampaignData GetClientCharacterData(Client client)
+        {
+            return characterData.Find(cd => cd.MatchesClient(client));
+        }
+        
+        public void AssignClientCharacterInfos(IEnumerable<Client> connectedClients)
+        {
+            foreach (Client client in connectedClients)
+            {
+                if (client.SpectateOnly && GameMain.Server.ServerSettings.AllowSpectating) { continue; }
+                var matchingData = GetClientCharacterData(client);
+                if (matchingData != null) client.CharacterInfo = matchingData.CharacterInfo;
+            }
+        }
+
+        public Dictionary<Client, Job> GetAssignedJobs(IEnumerable<Client> connectedClients)
+        {
+            var assignedJobs = new Dictionary<Client, Job>();
+            foreach (Client client in connectedClients)
+            {
+                var matchingData = GetClientCharacterData(client);
+                if (matchingData != null) assignedJobs.Add(client, matchingData.CharacterInfo.Job);
+            }
+            return assignedJobs;
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c)
+        {
+            System.Diagnostics.Debug.Assert(map.Locations.Count < UInt16.MaxValue);
+
+            msg.Write(CampaignID);
+            msg.Write(lastUpdateID);
+            msg.Write(lastSaveID);
+            msg.Write(map.Seed);
+            msg.Write(map.CurrentLocationIndex == -1 ? UInt16.MaxValue : (UInt16)map.CurrentLocationIndex);
+            msg.Write(map.SelectedLocationIndex == -1 ? UInt16.MaxValue : (UInt16)map.SelectedLocationIndex);
+            msg.Write(map.SelectedMissionIndex == -1 ? byte.MaxValue : (byte)map.SelectedMissionIndex);
+
+            msg.Write(isRunning && startWatchman != null ? startWatchman.ID : (UInt16)0);
+            msg.Write(isRunning && endWatchman != null ? endWatchman.ID : (UInt16)0);
+
+            msg.Write(Money);
+
+            msg.Write((UInt16)CargoManager.PurchasedItems.Count);
+            foreach (PurchasedItem pi in CargoManager.PurchasedItems)
+            {
+                msg.Write((UInt16)MapEntityPrefab.List.IndexOf(pi.ItemPrefab));
+                msg.Write((UInt16)pi.Quantity);
+            }
+
+            var characterData = GetClientCharacterData(c);
+            if (characterData?.CharacterInfo == null)
+            {
+                msg.Write(false);
+            }
+            else
+            {
+                msg.Write(true);
+                characterData.CharacterInfo.ServerWrite(msg);
+            }
+        }
+
+        public void ServerRead(NetBuffer msg, Client sender)
+        {
+            UInt16 selectedLocIndex = msg.ReadUInt16();
+            byte selectedMissionIndex = msg.ReadByte();
+            UInt16 purchasedItemCount = msg.ReadUInt16();
+
+            List<PurchasedItem> purchasedItems = new List<PurchasedItem>();
+            for (int i = 0; i < purchasedItemCount; i++)
+            {
+                UInt16 itemPrefabIndex = msg.ReadUInt16();
+                UInt16 itemQuantity = msg.ReadUInt16();
+                purchasedItems.Add(new PurchasedItem(MapEntityPrefab.List[itemPrefabIndex] as ItemPrefab, itemQuantity));
+            }
+
+            if (!sender.HasPermission(ClientPermissions.ManageCampaign))
+            {
+                DebugConsole.ThrowError("Client \"" + sender.Name + "\" does not have a permission to manage the campaign");
+                return;
+            }
+
+            Map.SelectLocation(selectedLocIndex == UInt16.MaxValue ? -1 : selectedLocIndex);
+            if (Map.SelectedConnection != null)
+            {
+                Map.SelectMission(selectedMissionIndex);
+            }
+
+            List<PurchasedItem> currentItems = new List<PurchasedItem>(CargoManager.PurchasedItems);
+            foreach (PurchasedItem pi in currentItems)
+            {
+                CargoManager.SellItem(pi, pi.Quantity);
+            }
+
+            foreach (PurchasedItem pi in purchasedItems)
+            {
+                CargoManager.PurchaseItem(pi.ItemPrefab, pi.Quantity);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,179 @@
+using Barotrauma.Networking;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Barotrauma
+{
+    partial class Traitor
+    {
+        public readonly Character Character;
+        public Character TargetCharacter; //TODO: make a modular objective system (similar to crew missions) that allows for things OTHER than assasinations.
+
+        public Traitor(Character character)
+        {
+            Character = character;
+        }
+
+        public void Greet(GameServer server, string codeWords, string codeResponse)
+        {
+            string greetingMessage = TextManager.Get("TraitorStartMessage").Replace("[targetname]", TargetCharacter.Name);
+            string moreAgentsMessage = TextManager.Get("TraitorMoreAgentsMessage")
+                .Replace("[codewords]", codeWords)
+                .Replace("[coderesponse]", codeResponse);
+            
+            var greetingChatMsg = ChatMessage.Create(null, greetingMessage, ChatMessageType.Server, null);
+            var moreAgentsChatMsg = ChatMessage.Create(null, moreAgentsMessage, ChatMessageType.Server, null);
+
+            var greetingMsgBox = ChatMessage.Create(null, greetingMessage, ChatMessageType.MessageBox, null);
+            var moreAgentsMsgBox = ChatMessage.Create(null, moreAgentsMessage, ChatMessageType.MessageBox, null);
+
+            Client client = server.ConnectedClients.Find(c => c.Character == Character);
+            GameMain.Server.SendDirectChatMessage(greetingChatMsg, client);
+            GameMain.Server.SendDirectChatMessage(moreAgentsChatMsg, client);
+            GameMain.Server.SendDirectChatMessage(greetingMsgBox, client);
+            GameMain.Server.SendDirectChatMessage(moreAgentsMsgBox, client);
+
+            Client ownerClient = server.ConnectedClients.Find(c => c.Connection == server.OwnerConnection);
+            if (client != ownerClient)
+            {
+                var ownerMsg = ChatMessage.Create(
+                    null,//TextManager.Get("NewTraitor"),
+                    TextManager.Get("TraitorStartMessageServer").Replace("[targetname]", TargetCharacter.Name).Replace("[traitorname]", Character.Name),
+                    ChatMessageType.MessageBox,
+                    null
+                );
+                GameMain.Server.SendDirectChatMessage(ownerMsg, ownerClient);
+            }
+        }
+    }
+
+    partial class TraitorManager
+    {
+        private static string wordsTxt = Path.Combine("Content", "CodeWords.txt");
+
+        public List<Traitor> TraitorList
+        {
+            get { return traitorList; }
+        }
+
+        private List<Traitor> traitorList = new List<Traitor>();
+
+        public string codeWords, codeResponse;
+
+        public TraitorManager(GameServer server, int traitorCount)
+        {
+            if (traitorCount < 1) //what why how
+            {
+                traitorCount = 1;
+                DebugConsole.ThrowError("Traitor Manager: TraitorCount somehow ended up less than 1, setting it to 1.");
+            }
+            Start(server, traitorCount);
+        }
+
+        private void Start(GameServer server, int traitorCount)
+        {
+            if (server == null) return;
+
+            List<Character> characters = new List<Character>(); //ANYONE can be a target.
+            List<Character> traitorCandidates = new List<Character>(); //Keep this to not re-pick traitors twice
+            foreach (Client client in server.ConnectedClients)
+            {
+                if (client.Character != null)
+                {
+                    characters.Add(client.Character);
+                    traitorCandidates.Add(client.Character);
+                }
+            }
+
+            if (server.Character != null)
+            {
+                characters.Add(server.Character); //Add host character
+                traitorCandidates.Add(server.Character);
+            }
+
+            if (characters.Count < 2)
+            {
+                return;
+            }
+
+            codeWords = ToolBox.GetRandomLine(wordsTxt) + ", " + ToolBox.GetRandomLine(wordsTxt);
+            codeResponse = ToolBox.GetRandomLine(wordsTxt) + ", " + ToolBox.GetRandomLine(wordsTxt);
+
+            while (traitorCount-- > 0)
+            {
+                if (traitorCandidates.Count <= 0) break;
+
+                int traitorIndex = Rand.Int(traitorCandidates.Count);
+                Character traitorCharacter = traitorCandidates[traitorIndex];
+                traitorCandidates.Remove(traitorCharacter);
+
+                //Add them to the list
+                traitorList.Add(new Traitor(traitorCharacter));
+            }
+
+            //Now that traitors have been decided, let's do objectives in post for deciding things like Document Exchange.
+            foreach (Traitor traitor in traitorList)
+            {
+                Character traitorCharacter = traitor.Character;
+                int targetIndex = Rand.Int(characters.Count);
+                while (characters[targetIndex] == traitorCharacter) //Cannot target self
+                {
+                    targetIndex = Rand.Int(characters.Count);
+                }
+
+                Character targetCharacter = characters[targetIndex];
+                traitor.TargetCharacter = targetCharacter;
+                traitor.Greet(server, codeWords, codeResponse);
+            }
+        }
+
+        public string GetEndMessage()
+        {
+            if (GameMain.Server == null || traitorList.Count <= 0) return "";
+
+            string endMessage = "";
+
+            foreach (Traitor traitor in traitorList)
+            {
+                Character traitorCharacter = traitor.Character;
+                Character targetCharacter = traitor.TargetCharacter;
+                string messageTag;
+
+                if (targetCharacter.IsDead) //Partial or complete mission success
+                {
+                    if (traitorCharacter.IsDead)
+                    {
+                        messageTag = "TraitorEndMessageSuccessTraitorDead";
+                    }
+                    else if (traitorCharacter.LockHands)
+                    {
+                        messageTag = "TraitorEndMessageSuccessTraitorDetained";
+                    }
+                    else
+                        messageTag = "TraitorEndMessageSuccess";
+                }
+                else //Partial or complete failure
+                {
+                    if (traitorCharacter.IsDead)
+                    {
+                        messageTag = "TraitorEndMessageFailureTraitorDead";
+                    }
+                    else if (traitorCharacter.LockHands)
+                    {
+                        messageTag = "TraitorEndMessageFailureTraitorDetained";
+                    }
+                    else
+                    {
+                        messageTag = "TraitorEndMessageFailure";
+                    }
+                }
+
+                endMessage += (TextManager.ReplaceGenderPronouns(TextManager.Get(messageTag), traitorCharacter.Info.Gender) + "\n")
+                    .Replace("[traitorname]", traitorCharacter.Name)
+                    .Replace("[targetname]", targetCharacter.Name);
+            }
+
+            return endMessage;
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/GameSession/MultiPlayerCampaign.cs

@@ -1,57 +0,0 @@
-using Microsoft.Xna.Framework;
-
-namespace Barotrauma
-{
-    partial class MultiPlayerCampaign
-    {
-        public static void StartCampaignSetup()
-        {
-            DebugConsole.NewMessage("********* CAMPAIGN SETUP *********", Color.White);
-            DebugConsole.ShowQuestionPrompt("Do you want to start a new campaign? Y/N", (string arg) =>
-            {
-                if (arg.ToLowerInvariant() == "y" || arg.ToLowerInvariant() == "yes")
-                {
-                    DebugConsole.ShowQuestionPrompt("Enter a save name for the campaign:", (string saveName) =>
-                    {
-                        if (string.IsNullOrWhiteSpace(saveName)) return;
-
-                        string savePath = SaveUtil.CreateSavePath(SaveUtil.SaveType.Multiplayer, saveName);
-                        GameMain.GameSession = new GameSession(new Submarine(GameMain.NetLobbyScreen.SelectedSub.FilePath, ""), savePath, 
-                            GameModePreset.List.Find(g => g.Identifier == "multiplayercampaign"));
-                        var campaign = ((MultiPlayerCampaign)GameMain.GameSession.GameMode);
-                        campaign.GenerateMap(GameMain.NetLobbyScreen.LevelSeed);
-                        campaign.SetDelegates();
-
-                        GameMain.NetLobbyScreen.ToggleCampaignMode(true);
-                        GameMain.GameSession.Map.SelectRandomLocation(true);
-                        SaveUtil.SaveGame(GameMain.GameSession.SavePath);
-                        campaign.LastSaveID++;
-
-                        DebugConsole.NewMessage("Campaign started!", Color.Cyan);
-                    });
-                }
-                else
-                {
-                    string[] saveFiles = SaveUtil.GetSaveFiles(SaveUtil.SaveType.Multiplayer);
-                    DebugConsole.NewMessage("Saved campaigns:", Color.White);
-                    for (int i = 0; i < saveFiles.Length; i++)
-                    {
-                        DebugConsole.NewMessage("   " + i + ". " + saveFiles[i], Color.White);
-                    }
-                    DebugConsole.ShowQuestionPrompt("Select a save file to load (0 - " + (saveFiles.Length - 1) + "):", (string selectedSave) =>
-                    {
-                        int saveIndex = -1;
-                        if (!int.TryParse(selectedSave, out saveIndex)) return;
-
-                        SaveUtil.LoadGame(saveFiles[saveIndex]);
-                        ((MultiPlayerCampaign)GameMain.GameSession.GameMode).LastSaveID++;
-                        GameMain.NetLobbyScreen.ToggleCampaignMode(true);
-                        GameMain.GameSession.Map.SelectRandomLocation(true);
-
-                        DebugConsole.NewMessage("Campaign loaded!", Color.Cyan);
-                    });
-                }
-            });
-        }
-    }
-}

Barotrauma/BarotraumaServer/Source/Items/Components/Door.cs

@@ -0,0 +1,33 @@
+using Microsoft.Xna.Framework;
+using Barotrauma.Networking;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Door
+    {
+        partial void SetState(bool open, bool isNetworkMessage, bool sendNetworkMessage)
+        {
+            if (isStuck || isOpen == open)
+            {
+                return;
+            }
+            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 override void ServerWrite(Lidgren.Network.NetBuffer msg, Client c, object[] extraData = null)
+        {
+            base.ServerWrite(msg, c, extraData);
+
+            msg.Write(isOpen);
+            msg.WriteRangedSingle(stuck, 0.0f, 100.0f, 8);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Deconstructor.cs

@@ -0,0 +1,27 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Deconstructor : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            bool active = msg.ReadBoolean();
+
+            item.CreateServerEvent(this);
+
+            if (item.CanClientAccess(c))
+            {
+                SetActive(active, c.Character);
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(IsActive);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Engine.cs

@@ -0,0 +1,36 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Globalization;
+using System.Xml.Linq;
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Engine : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            //force can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger(-10, 10, (int)(targetForce / 10.0f));
+        }
+
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            float newTargetForce = msg.ReadRangedInteger(-10, 10) * 10.0f;
+
+            if (item.CanClientAccess(c))
+            {
+                if (Math.Abs(newTargetForce - targetForce) > 0.01f)
+                {
+                    GameServer.Log(c.Character.LogName + " set the force of " + item.Name + " to " + (int)(newTargetForce) + " %", ServerLog.MessageType.ItemInteraction);
+                }
+
+                targetForce = newTargetForce;
+            }
+
+            //notify all clients of the changed state
+            item.CreateServerEvent(this);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Fabricator.cs

@@ -0,0 +1,43 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Fabricator : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            int itemIndex = msg.ReadRangedInteger(-1, fabricableItems.Count - 1);
+
+            item.CreateServerEvent(this);
+
+            if (!item.CanClientAccess(c)) return;
+
+            if (itemIndex == -1)
+            {
+                CancelFabricating(c.Character);
+            }
+            else
+            {
+                //if already fabricating the selected item, return
+                if (fabricatedItem != null && fabricableItems.IndexOf(fabricatedItem) == itemIndex) return;
+                if (itemIndex < 0 || itemIndex >= fabricableItems.Count) return;
+
+                StartFabricating(fabricableItems[itemIndex], c.Character);
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            int itemIndex = fabricatedItem == null ? -1 : fabricableItems.IndexOf(fabricatedItem);
+            msg.WriteRangedInteger(-1, fabricableItems.Count - 1, itemIndex);
+            UInt16 userID = fabricatedItem == null || user == null ? (UInt16)0 : user.ID;
+            msg.Write(userID);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Pump.cs

@@ -0,0 +1,42 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using System;
+using System.Globalization;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Pump : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, Lidgren.Network.NetBuffer msg, Client c)
+        {
+            float newFlowPercentage = msg.ReadRangedInteger(-10, 10) * 10.0f;
+            bool newIsActive = msg.ReadBoolean();
+
+            if (item.CanClientAccess(c))
+            {
+                if (newFlowPercentage != FlowPercentage)
+                {
+                    GameServer.Log(c.Character.LogName + " set the pumping speed of " + item.Name + " to " + (int)(newFlowPercentage) + " %", ServerLog.MessageType.ItemInteraction);
+                }
+                if (newIsActive != IsActive)
+                {
+                    GameServer.Log(c.Character.LogName + (newIsActive ? " turned on " : " turned off ") + item.Name, ServerLog.MessageType.ItemInteraction);
+                }
+
+                FlowPercentage = newFlowPercentage;
+                IsActive = newIsActive;
+            }
+
+            //notify all clients of the changed state
+            item.CreateServerEvent(this);
+        }
+
+        public void ServerWrite(Lidgren.Network.NetBuffer msg, Client c, object[] extraData = null)
+        {
+            //flowpercentage can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger(-10, 10, (int)(flowPercentage / 10.0f));
+            msg.Write(IsActive);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Reactor.cs

@@ -0,0 +1,53 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Reactor
+    {
+        private Client blameOnBroken;
+
+        private float? nextServerLogWriteTime;
+        private float lastServerLogWriteTime;
+
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            bool autoTemp = msg.ReadBoolean();
+            bool shutDown = msg.ReadBoolean();
+            float fissionRate = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            float turbineOutput = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+
+            if (!item.CanClientAccess(c)) return;
+
+            if (!autoTemp && AutoTemp) blameOnBroken = c;
+            if (turbineOutput < targetTurbineOutput) blameOnBroken = c;
+            if (fissionRate > targetFissionRate) blameOnBroken = c;
+            if (!this.shutDown && shutDown) blameOnBroken = c;
+
+            AutoTemp = autoTemp;
+            this.shutDown = shutDown;
+            targetFissionRate = fissionRate;
+            targetTurbineOutput = turbineOutput;
+
+            LastUser = c.Character;
+            if (nextServerLogWriteTime == null)
+            {
+                nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+            }
+
+            //need to create a server event to notify all clients of the changed state
+            unsentChanges = true;
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(autoTemp);
+            msg.Write(shutDown);
+            msg.WriteRangedSingle(temperature, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(targetFissionRate, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(targetTurbineOutput, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(degreeOfSuccess, 0.0f, 1.0f, 8);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Power/PowerContainer.cs

@@ -0,0 +1,32 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class PowerContainer : Powered, IDrawableComponent, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            float newRechargeSpeed = msg.ReadRangedInteger(0, 10) / 10.0f * maxRechargeSpeed;
+
+            if (item.CanClientAccess(c))
+            {
+                RechargeSpeed = newRechargeSpeed;
+                GameServer.Log(c.Character.LogName + " set the recharge speed of " + item.Name + " to " + (int)((rechargeSpeed / maxRechargeSpeed) * 100.0f) + " %", ServerLog.MessageType.ItemInteraction);
+            }
+
+            item.CreateServerEvent(this);
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.WriteRangedInteger(0, 10, (int)(rechargeSpeed / MaxRechargeSpeed * 10));
+
+            float chargeRatio = MathHelper.Clamp(charge / capacity, 0.0f, 1.0f);
+            msg.WriteRangedSingle(chargeRatio, 0.0f, 1.0f, 8);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Repairable.cs

@@ -0,0 +1,18 @@
+using Barotrauma.Networking;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Repairable : ItemComponent, IServerSerializable, IClientSerializable
+    {
+        void InitProjSpecific()
+        {
+            //let the clients know the initial deterioration delay
+            item.CreateServerEvent(this);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Signal/ConnectionPanel.cs

@@ -0,0 +1,153 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class ConnectionPanel : ItemComponent, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            List<Wire>[] wires = new List<Wire>[Connections.Count];
+
+            //read wire IDs for each connection
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                wires[i] = new List<Wire>();
+                for (int j = 0; j < Connection.MaxLinked; j++)
+                {
+                    ushort wireId = msg.ReadUInt16();
+
+                    Item wireItem = Entity.FindEntityByID(wireId) as Item;
+                    if (wireItem == null) continue;
+
+                    Wire wireComponent = wireItem.GetComponent<Wire>();
+                    if (wireComponent != null)
+                    {
+                        wires[i].Add(wireComponent);
+                    }
+                }
+            }
+
+            //don't allow rewiring locked panels
+            if (Locked) return;
+
+            item.CreateServerEvent(this);
+
+            //check if the character can access this connectionpanel 
+            //and all the wires they're trying to connect
+            if (!item.CanClientAccess(c)) return;
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                foreach (Wire wire in wires[i])
+                {
+                    //wire not found in any of the connections yet (client is trying to connect a new wire)
+                    //  -> we need to check if the client has access to it
+                    if (!Connections.Any(connection => connection.Wires.Contains(wire)))
+                    {
+                        if (!wire.Item.CanClientAccess(c)) return;
+                    }
+                }
+            }
+
+            //go through existing wire links
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                int j = -1;
+                foreach (Wire existingWire in Connections[i].Wires)
+                {
+                    j++;
+                    if (existingWire == null) continue;
+
+                    //existing wire not in the list of new wires -> disconnect it
+                    if (!wires[i].Contains(existingWire))
+                    {
+                        if (existingWire.Locked)
+                        {
+                            //this should not be possible unless the client is running a modified version of the game
+                            GameServer.Log(c.Character.LogName + " attempted to disconnect a locked wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ")", ServerLog.MessageType.Error);
+                            continue;
+                        }
+
+                        existingWire.RemoveConnection(item);
+
+                        if (existingWire.Connections[0] == null && existingWire.Connections[1] == null)
+                        {
+                            GameServer.Log(c.Character.LogName + " disconnected a wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ")", ServerLog.MessageType.ItemInteraction);
+                        }
+                        else if (existingWire.Connections[0] != null)
+                        {
+                            GameServer.Log(c.Character.LogName + " disconnected a wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ") to " + existingWire.Connections[0].Item.Name + " (" + existingWire.Connections[0].Name + ")", ServerLog.MessageType.ItemInteraction);
+
+                            //wires that are not in anyone's inventory (i.e. not currently being rewired) 
+                            //can never be connected to only one connection
+                            // -> the client must have dropped the wire from the connection panel
+                            if (existingWire.Item.ParentInventory == null && !wires.Any(w => w.Contains(existingWire)))
+                            {
+                                //let other clients know the item was also disconnected from the other connection
+                                existingWire.Connections[0].Item.CreateServerEvent(existingWire.Connections[0].Item.GetComponent<ConnectionPanel>());
+                                existingWire.Item.Drop(c.Character);
+                            }
+                        }
+                        else if (existingWire.Connections[1] != null)
+                        {
+                            GameServer.Log(c.Character.LogName + " disconnected a wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ") to " + existingWire.Connections[1].Item.Name + " (" + existingWire.Connections[1].Name + ")", ServerLog.MessageType.ItemInteraction);
+
+                            if (existingWire.Item.ParentInventory == null && !wires.Any(w => w.Contains(existingWire)))
+                            {
+                                //let other clients know the item was also disconnected from the other connection
+                                existingWire.Connections[1].Item.CreateServerEvent(existingWire.Connections[1].Item.GetComponent<ConnectionPanel>());
+                                existingWire.Item.Drop(c.Character);
+                            }
+                        }
+
+                        Connections[i].SetWire(j, null);
+                    }
+                }
+            }
+
+            //go through new wires
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                foreach (Wire newWire in wires[i])
+                {
+                    //already connected, no need to do anything
+                    if (Connections[i].Wires.Contains(newWire)) continue;
+
+                    Connections[i].TryAddLink(newWire);
+                    newWire.Connect(Connections[i], true, true);
+
+                    var otherConnection = newWire.OtherConnection(Connections[i]);
+
+                    if (otherConnection == null)
+                    {
+                        GameServer.Log(c.Character.LogName + " connected a wire to " +
+                            Connections[i].Item.Name + " (" + Connections[i].Name + ")",
+                            ServerLog.MessageType.ItemInteraction);
+                    }
+                    else
+                    {
+                        GameServer.Log(c.Character.LogName + " connected a wire from " +
+                            Connections[i].Item.Name + " (" + Connections[i].Name + ") to " +
+                            (otherConnection == null ? "none" : otherConnection.Item.Name + " (" + (otherConnection.Name) + ")"),
+                            ServerLog.MessageType.ItemInteraction);
+                    }
+                }
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            ClientWrite(msg, extraData);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Signal/CustomInterface.cs

@@ -0,0 +1,63 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class CustomInterface : ItemComponent, IClientSerializable, IServerSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            bool[] elementStates = new bool[customInterfaceElementList.Count];
+            for (int i = 0; i < customInterfaceElementList.Count; i++)
+            {
+                elementStates[i] = msg.ReadBoolean();
+            }
+
+            CustomInterfaceElement clickedButton = null;
+            if (item.CanClientAccess(c))
+            {
+                for (int i = 0; i < customInterfaceElementList.Count; i++)
+                {
+                    if (customInterfaceElementList[i].ContinuousSignal)
+                    {
+                        TickBoxToggled(customInterfaceElementList[i], elementStates[i]);
+                    }
+                    else if (elementStates[i])
+                    {
+                        clickedButton = customInterfaceElementList[i];
+                        ButtonClicked(customInterfaceElementList[i]);
+                    }
+                }
+            }
+
+            //notify all clients of the new state
+            GameMain.Server.CreateEntityEvent(item, new object[]
+            {
+                NetEntityEvent.Type.ComponentState,
+                item.GetComponentIndex(this),
+                clickedButton
+            });
+
+            item.CreateServerEvent(this);
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            //extradata contains an array of buttons clicked by a client (or nothing if nothing was clicked)
+            for (int i = 0; i < customInterfaceElementList.Count; i++)
+            {
+                if (customInterfaceElementList[i].ContinuousSignal)
+                {
+                    msg.Write(customInterfaceElementList[i].State);
+                }
+                else
+                {
+                    msg.Write(extraData != null && extraData.Any(d => d as CustomInterfaceElement == customInterfaceElementList[i]));
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Signal/Wire.cs

@@ -0,0 +1,41 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Wire : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        private void CreateNetworkEvent()
+        {
+            if (GameMain.Server == null) return;
+            //split into multiple events because one might not be enough to fit all the nodes
+            int eventCount = Math.Max((int)Math.Ceiling(nodes.Count / (float)MaxNodesPerNetworkEvent), 1);
+            for (int i = 0; i < eventCount; i++)
+            {
+                GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.ComponentState, item.GetComponentIndex(this), i });
+            }
+
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            int eventIndex = (int)extraData[2];
+            int nodeStartIndex = eventIndex * MaxNodesPerNetworkEvent;
+            int nodeCount = MathHelper.Clamp(nodes.Count - nodeStartIndex, 0, MaxNodesPerNetworkEvent);
+
+            msg.WriteRangedInteger(0, (int)Math.Ceiling(MaxNodeCount / (float)MaxNodesPerNetworkEvent), eventIndex);
+            msg.WriteRangedInteger(0, MaxNodesPerNetworkEvent, nodeCount);
+            for (int i = nodeStartIndex; i < nodeStartIndex + nodeCount; i++)
+            {
+                msg.Write(nodes[i].X);
+                msg.Write(nodes[i].Y);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Inventory.cs

@@ -0,0 +1,138 @@
+using Barotrauma.Items.Components;
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
+{
+    partial class Inventory : IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            List<Item> prevItems = new List<Item>(Items);
+            ushort[] newItemIDs = new ushort[capacity];
+
+            for (int i = 0; i < capacity; i++)
+            {
+                newItemIDs[i] = msg.ReadUInt16();
+            }
+
+            
+            if (c == null || c.Character == null) return;
+
+            bool accessible = c.Character.CanAccessInventory(this);
+            if (this is CharacterInventory && accessible)
+            {
+                if (Owner == null || !(Owner is Character))
+                {
+                    accessible = false;
+                }
+                else if (!((CharacterInventory)this).AccessibleWhenAlive && !((Character)Owner).IsDead)
+                {
+                    accessible = false;
+                }
+            }
+
+            if (!accessible)
+            {
+                //create a network event to correct the client's inventory state
+                //otherwise they may have an item in their inventory they shouldn't have been able to pick up,
+                //and receiving an event for that inventory later will cause the item to be dropped
+                CreateNetworkEvent();
+                for (int i = 0; i < capacity; i++)
+                {
+                    var item = Entity.FindEntityByID(newItemIDs[i]) as Item;
+                    if (item == null) continue;
+                    if (item.ParentInventory != null && item.ParentInventory != this)
+                    {
+                        item.ParentInventory.CreateNetworkEvent();
+                    }
+                }
+                return;
+            }
+            
+            List<Inventory> prevItemInventories = new List<Inventory>(Items.Select(i => i?.ParentInventory));
+
+            for (int i = 0; i < capacity; i++)
+            {
+                Item newItem = newItemIDs[i] == 0 ? null : Entity.FindEntityByID(newItemIDs[i]) as Item;
+                prevItemInventories.Add(newItem?.ParentInventory);
+
+                if (newItemIDs[i] == 0 || (newItem != Items[i]))
+                {
+                    if (Items[i] != null) Items[i].Drop();
+                    System.Diagnostics.Debug.Assert(Items[i] == null);
+                }
+            }
+
+            for (int i = 0; i < capacity; i++)
+            {
+                if (newItemIDs[i] > 0)
+                {
+                    var item = Entity.FindEntityByID(newItemIDs[i]) as Item;
+                    if (item == null || item == Items[i]) continue;
+
+                    if (GameMain.Server != null)
+                    {
+                        var holdable = item.GetComponent<Holdable>();
+                        if (holdable != null && !holdable.CanBeDeattached()) continue;
+
+                        if (!item.CanClientAccess(c)) continue;
+                    }
+                    TryPutItem(item, i, true, true, c.Character, false);
+                    for (int j = 0; j < capacity; j++)
+                    {
+                        if (Items[j] == item && newItemIDs[j] != item.ID)
+                        {
+                            Items[j] = null;
+                        }
+                    }
+                }
+            }
+
+            CreateNetworkEvent();
+            foreach (Inventory prevInventory in prevItemInventories.Distinct())
+            {
+                if (prevInventory != this) prevInventory?.CreateNetworkEvent();
+            }
+
+            foreach (Item item in Items.Distinct())
+            {
+                if (item == null) continue;
+                if (!prevItems.Contains(item))
+                {
+                    if (Owner == c.Character)
+                    {
+                        GameServer.Log(c.Character.LogName+ " picked up " + item.Name, ServerLog.MessageType.Inventory);
+                    }
+                    else
+                    {
+                        GameServer.Log(c.Character.LogName + " placed " + item.Name + " in " + Owner, ServerLog.MessageType.Inventory);
+                    }
+                }
+            }
+            foreach (Item item in prevItems.Distinct())
+            {
+                if (item == null) continue;
+                if (!Items.Contains(item))
+                {
+                    if (Owner == c.Character)
+                    {
+                        GameServer.Log(c.Character.LogName + " dropped " + item.Name, ServerLog.MessageType.Inventory);
+                    }
+                    else
+                    {
+                        GameServer.Log(c.Character.LogName + " removed " + item.Name + " from " + Owner, ServerLog.MessageType.Inventory);
+                    }
+                }
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            SharedWrite(msg, extraData);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Item.cs

@@ -0,0 +1,294 @@
+using Barotrauma.Items.Components;
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Linq;
+
+namespace Barotrauma
+{
+    partial class Item : MapEntity, IDamageable, ISerializableEntity, IServerSerializable, IClientSerializable
+    {
+        private bool prevBodyAwake;
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            string errorMsg = "";
+            if (extraData == null || extraData.Length == 0 || !(extraData[0] is NetEntityEvent.Type))
+            {
+                if (extraData == null)
+                {
+                    errorMsg = "Failed to write a network event for the item \"" + Name + "\" - event data was null.";
+                }
+                else if (extraData.Length == 0)
+                {
+                    errorMsg = "Failed to write a network event for the item \"" + Name + "\" - event data was empty.";
+                }
+                else
+                {
+                    errorMsg = "Failed to write a network event for the item \"" + Name + "\" - event type not set.";
+                }
+                msg.WriteRangedInteger(0, Enum.GetValues(typeof(NetEntityEvent.Type)).Length - 1, (int)NetEntityEvent.Type.Invalid);
+                DebugConsole.Log(errorMsg);
+                GameAnalyticsManager.AddErrorEventOnce("Item.ServerWrite:InvalidData" + Name, GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
+                return;
+            }
+
+            int initialWritePos = msg.LengthBits;
+
+            NetEntityEvent.Type eventType = (NetEntityEvent.Type)extraData[0];
+            msg.WriteRangedInteger(0, Enum.GetValues(typeof(NetEntityEvent.Type)).Length - 1, (int)eventType);
+            switch (eventType)
+            {
+                case NetEntityEvent.Type.ComponentState:
+                    if (extraData.Length < 2 || !(extraData[1] is int))
+                    {
+                        errorMsg = "Failed to write a component state event for the item \"" + Name + "\" - component index not given.";
+                        break;
+                    }
+                    int componentIndex = (int)extraData[1];
+                    if (componentIndex < 0 || componentIndex >= components.Count)
+                    {
+                        errorMsg = "Failed to write a component state event for the item \"" + Name + "\" - component index out of range (" + componentIndex + ").";
+                        break;
+                    }
+                    else if (!(components[componentIndex] is IServerSerializable))
+                    {
+                        errorMsg = "Failed to write a component state event for the item \"" + Name + "\" - component \"" + components[componentIndex] + "\" is not server serializable.";
+                        break;
+                    }
+                    msg.WriteRangedInteger(0, components.Count - 1, componentIndex);
+                    (components[componentIndex] as IServerSerializable).ServerWrite(msg, c, extraData);
+                    break;
+                case NetEntityEvent.Type.InventoryState:
+                    if (extraData.Length < 2 || !(extraData[1] is int))
+                    {
+                        errorMsg = "Failed to write an inventory state event for the item \"" + Name + "\" - component index not given.";
+                        break;
+                    }
+                    int containerIndex = (int)extraData[1];
+                    if (containerIndex < 0 || containerIndex >= components.Count)
+                    {
+                        errorMsg = "Failed to write an inventory state event for the item \"" + Name + "\" - container index out of range (" + containerIndex + ").";
+                        break;
+                    }
+                    else if (!(components[containerIndex] is ItemContainer))
+                    {
+                        errorMsg = "Failed to write an inventory state event for the item \"" + Name + "\" - component \"" + components[containerIndex] + "\" is not server serializable.";
+                        break;
+                    }
+                    msg.WriteRangedInteger(0, components.Count - 1, containerIndex);
+                    (components[containerIndex] as ItemContainer).Inventory.ServerWrite(msg, c);
+                    break;
+                case NetEntityEvent.Type.Status:
+                    msg.Write(condition);
+                    break;
+                case NetEntityEvent.Type.Treatment:
+                    {
+                        ItemComponent targetComponent = (ItemComponent)extraData[1];
+                        ActionType actionType = (ActionType)extraData[2];
+                        ushort targetID = (ushort)extraData[3];
+                        Limb targetLimb = (Limb)extraData[4];
+
+                        Character targetCharacter = FindEntityByID(targetID) as Character;
+                        byte targetLimbIndex = targetLimb != null && targetCharacter != null ? (byte)Array.IndexOf(targetCharacter.AnimController.Limbs, targetLimb) : (byte)255;
+
+                        msg.Write((byte)components.IndexOf(targetComponent));
+                        msg.WriteRangedInteger(0, Enum.GetValues(typeof(ActionType)).Length - 1, (int)actionType);
+                        msg.Write(targetID);
+                        msg.Write(targetLimbIndex);
+                    }
+                    break;
+                case NetEntityEvent.Type.ApplyStatusEffect:
+                    {
+                        ActionType actionType = (ActionType)extraData[1];
+                        ItemComponent targetComponent = extraData.Length > 2 ? (ItemComponent)extraData[2] : null;
+                        ushort targetID = extraData.Length > 3 ? (ushort)extraData[3] : (ushort)0;
+                        Limb targetLimb = extraData.Length > 4 ? (Limb)extraData[4] : null;
+
+                        Character targetCharacter = FindEntityByID(targetID) as Character;
+                        byte targetLimbIndex = targetLimb != null && targetCharacter != null ? (byte)Array.IndexOf(targetCharacter.AnimController.Limbs, targetLimb) : (byte)255;
+
+                        msg.WriteRangedInteger(0, Enum.GetValues(typeof(ActionType)).Length - 1, (int)actionType);
+                        msg.Write((byte)(targetComponent == null ? 255 : components.IndexOf(targetComponent)));
+                        msg.Write(targetID);
+                        msg.Write(targetLimbIndex);
+                    }
+                    break;
+                case NetEntityEvent.Type.ChangeProperty:
+                    try
+                    {
+                        WritePropertyChange(msg, extraData, false);
+                    }
+                    catch (Exception e)
+                    {
+                        errorMsg = "Failed to write a ChangeProperty network event for the item \"" + Name + "\" (" + e.Message + ")";
+                    }
+                    break;
+                default:
+                    errorMsg = "Failed to write a network event for the item \"" + Name + "\" - \"" + eventType + "\" is not a valid entity event type for items.";
+                    break;
+            }
+
+            if (!string.IsNullOrEmpty(errorMsg))
+            {
+                //something went wrong - rewind the write position and write invalid event type to prevent creating an unreadable event
+                msg.ReadBits(msg.Data, 0, initialWritePos);
+                msg.LengthBits = initialWritePos;
+                msg.WriteRangedInteger(0, Enum.GetValues(typeof(NetEntityEvent.Type)).Length - 1, (int)NetEntityEvent.Type.Invalid);
+                DebugConsole.Log(errorMsg);
+                GameAnalyticsManager.AddErrorEventOnce("Item.ServerWrite:" + errorMsg, GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg);
+            }
+
+        }
+
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            NetEntityEvent.Type eventType =
+                (NetEntityEvent.Type)msg.ReadRangedInteger(0, Enum.GetValues(typeof(NetEntityEvent.Type)).Length - 1);
+
+            c.KickAFKTimer = 0.0f;
+
+            switch (eventType)
+            {
+                case NetEntityEvent.Type.ComponentState:
+                    int componentIndex = msg.ReadRangedInteger(0, components.Count - 1);
+                    (components[componentIndex] as IClientSerializable).ServerRead(type, msg, c);
+                    break;
+                case NetEntityEvent.Type.InventoryState:
+                    int containerIndex = msg.ReadRangedInteger(0, components.Count - 1);
+                    (components[containerIndex] as ItemContainer).Inventory.ServerRead(type, msg, c);
+                    break;
+                case NetEntityEvent.Type.Treatment:
+                    if (c.Character == null || !c.Character.CanInteractWith(this)) return;
+
+                    UInt16 characterID = msg.ReadUInt16();
+                    byte limbIndex = msg.ReadByte();
+
+                    Character targetCharacter = FindEntityByID(characterID) as Character;
+                    if (targetCharacter == null) break;
+                    if (targetCharacter != c.Character && c.Character.SelectedCharacter != targetCharacter) break;
+
+                    Limb targetLimb = limbIndex < targetCharacter.AnimController.Limbs.Length ? targetCharacter.AnimController.Limbs[limbIndex] : null;
+
+                    if (ContainedItems == null || ContainedItems.All(i => i == null))
+                    {
+                        GameServer.Log(c.Character.LogName + " used item " + Name, ServerLog.MessageType.ItemInteraction);
+                    }
+                    else
+                    {
+                        GameServer.Log(
+                            c.Character.LogName + " used item " + Name + " (contained items: " + string.Join(", ", ContainedItems.Select(i => i.Name)) + ")",
+                            ServerLog.MessageType.ItemInteraction);
+                    }
+
+                    ApplyTreatment(c.Character, targetCharacter, targetLimb);
+
+                    break;
+                case NetEntityEvent.Type.ChangeProperty:
+                    ReadPropertyChange(msg, true, c);
+                    break;
+            }
+        }
+
+        public void WriteSpawnData(NetBuffer msg)
+        {
+            if (GameMain.Server == null) return;
+
+            msg.Write(Prefab.Name);
+            msg.Write(Prefab.Identifier);
+            msg.Write(Description != prefab.Description);
+            if (Description != prefab.Description)
+            {
+                msg.Write(Description);
+            }
+
+            msg.Write(ID);
+
+            if (ParentInventory == null || ParentInventory.Owner == null)
+            {
+                msg.Write((ushort)0);
+
+                msg.Write(Position.X);
+                msg.Write(Position.Y);
+                msg.Write(Submarine != null ? Submarine.ID : (ushort)0);
+            }
+            else
+            {
+                msg.Write(ParentInventory.Owner.ID);
+
+                //find the index of the ItemContainer this item is inside to get the item to
+                //spawn in the correct inventory in multi-inventory items like fabricators
+                byte containerIndex = 0;
+                if (Container != null)
+                {
+                    for (int i = 0; i < Container.components.Count; i++)
+                    {
+                        if (Container.components[i] is ItemContainer container &&
+                            container.Inventory == ParentInventory)
+                        {
+                            containerIndex = (byte)i;
+                            break;
+                        }
+                    }
+                }
+                msg.Write(containerIndex);
+
+                int slotIndex = ParentInventory.FindIndex(this);
+                msg.Write(slotIndex < 0 ? (byte)255 : (byte)slotIndex);
+            }
+
+            byte teamID = 0;
+            foreach (WifiComponent wifiComponent in GetComponents<WifiComponent>())
+            {
+                teamID = (byte)wifiComponent.TeamID;
+                break;
+            }
+
+            msg.Write(teamID);
+            bool tagsChanged = tags.Count != prefab.Tags.Count || !tags.All(t => prefab.Tags.Contains(t));
+            msg.Write(tagsChanged);
+            if (tagsChanged)
+            {
+                msg.Write(Tags);
+            }
+
+        }
+
+        partial void UpdateNetPosition()
+        {
+            if (parentInventory != null) return;
+
+            if (prevBodyAwake != body.FarseerBody.Awake || 
+                Vector2.DistanceSquared(lastSentPos, SimPosition) > NetConfig.ItemPosUpdateDistance * NetConfig.ItemPosUpdateDistance)
+            {
+                needsPositionUpdate = true;
+            }
+
+            prevBodyAwake = body.FarseerBody.Awake;
+        }
+
+        public void ServerWritePosition(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(ID);
+
+            NetBuffer tempBuffer = new NetBuffer();
+            body.ServerWrite(tempBuffer, c, extraData);
+            msg.Write((byte)tempBuffer.LengthBytes);
+            msg.Write(tempBuffer);
+            msg.WritePadBits();
+
+            lastSentPos = SimPosition;
+        }
+
+        public void CreateServerEvent<T>(T ic) where T : ItemComponent, IServerSerializable
+        {
+            if (GameMain.Server == null) return;
+
+            int index = components.IndexOf(ic);
+            if (index == -1) return;
+
+            GameMain.Server.CreateEntityEvent(this, new object[] { NetEntityEvent.Type.ComponentState, index });
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Map/Hull.cs

@@ -1,13 +1,121 @@
 using Barotrauma.Networking;
+using Lidgren.Network;
 using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Barotrauma
 {
-    partial class Hull : MapEntity, ISerializableEntity, IServerSerializable
+    partial class Hull : MapEntity, ISerializableEntity, IServerSerializable, IClientSerializable
     {
+        private float lastSentVolume, lastSentOxygen;
+        private float sendUpdateTimer;
+
         public override bool IsMouseOn(Vector2 position)
         {
             return false;
         }
+
+        partial void UpdateProjSpecific(float deltaTime, Camera cam)
+        {
+            if (IdFreed) { return; }
+            //update client hulls if the amount of water has changed by >10%
+            //or if oxygen percentage has changed by 5%
+            if (Math.Abs(lastSentVolume - waterVolume) > Volume * 0.1f ||
+                Math.Abs(lastSentOxygen - OxygenPercentage) > 5f)
+            {
+                sendUpdateTimer -= deltaTime;
+                if (sendUpdateTimer < 0.0f)
+                {
+                    GameMain.NetworkMember.CreateEntityEvent(this);
+                    lastSentVolume = waterVolume;
+                    lastSentOxygen = OxygenPercentage;
+                    sendUpdateTimer = NetworkUpdateInterval;
+                }                
+            }
+        }
+
+        public void ServerWrite(NetBuffer message, Client c, object[] extraData = null)
+        {
+            message.WriteRangedSingle(MathHelper.Clamp(waterVolume / Volume, 0.0f, 1.5f), 0.0f, 1.5f, 8);
+            message.WriteRangedSingle(MathHelper.Clamp(OxygenPercentage, 0.0f, 100.0f), 0.0f, 100.0f, 8);
+
+            message.Write(FireSources.Count > 0);
+            if (FireSources.Count > 0)
+            {
+                message.WriteRangedInteger(0, 16, Math.Min(FireSources.Count, 16));
+                for (int i = 0; i < Math.Min(FireSources.Count, 16); i++)
+                {
+                    var fireSource = FireSources[i];
+                    Vector2 normalizedPos = new Vector2(
+                        (fireSource.Position.X - rect.X) / rect.Width,
+                        (fireSource.Position.Y - (rect.Y - rect.Height)) / rect.Height);
+
+                    message.WriteRangedSingle(MathHelper.Clamp(normalizedPos.X, 0.0f, 1.0f), 0.0f, 1.0f, 8);
+                    message.WriteRangedSingle(MathHelper.Clamp(normalizedPos.Y, 0.0f, 1.0f), 0.0f, 1.0f, 8);
+                    message.WriteRangedSingle(MathHelper.Clamp(fireSource.Size.X / rect.Width, 0.0f, 1.0f), 0, 1.0f, 8);
+                }
+            }
+        }
+
+        //used when clients use the water/fire console commands
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            float newWaterVolume  = msg.ReadRangedSingle(0.0f, 1.5f, 8) * Volume;
+
+            bool hasFireSources = msg.ReadBoolean();
+            int fireSourceCount = 0;
+            List<Vector3> newFireSources = new List<Vector3>();
+            if (hasFireSources)
+            {
+                fireSourceCount = msg.ReadRangedInteger(0, 16);
+                for (int i = 0; i < fireSourceCount; i++)
+                {
+                    newFireSources.Add(new Vector3(
+                        MathHelper.Clamp(msg.ReadRangedSingle(0.0f, 1.0f, 8), 0.05f, 0.95f),
+                        MathHelper.Clamp(msg.ReadRangedSingle(0.0f, 1.0f, 8), 0.05f, 0.95f),
+                        msg.ReadRangedSingle(0.0f, 1.0f, 8)));                    
+                }
+            }
+
+            if (!c.HasPermission(ClientPermissions.ConsoleCommands) || 
+                !c.PermittedConsoleCommands.Any(command => command.names.Contains("fire") || command.names.Contains("editfire")))
+            {
+                return;
+            }
+
+            WaterVolume = newWaterVolume;
+
+            for (int i = 0; i < fireSourceCount; i++)
+            {
+                Vector2 pos = new Vector2(
+                    rect.X + rect.Width * newFireSources[i].X,
+                    rect.Y - rect.Height + (rect.Height * newFireSources[i].Y));
+                float size = newFireSources[i].Z * rect.Width;
+
+                var newFire = i < FireSources.Count ?
+                    FireSources[i] :
+                    new FireSource(Submarine == null ? pos : pos + Submarine.Position, null, true);
+                newFire.Position = pos;
+                newFire.Size = new Vector2(size, newFire.Size.Y);
+
+                //ignore if the fire wasn't added to this room (invalid position)?
+                if (!FireSources.Contains(newFire))
+                {
+                    newFire.Remove();
+                    continue;
+                }
+            }
+
+            for (int i = FireSources.Count - 1; i >= fireSourceCount; i--)
+            {
+                FireSources[i].Remove();
+                if (i < FireSources.Count)
+                {
+                    FireSources.RemoveAt(i);
+                }
+            }
+        }
     }
 }

Barotrauma/BarotraumaServer/Source/Map/Structure.cs

@@ -0,0 +1,36 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma
+{
+    partial class Structure : MapEntity, IDamageable, IServerSerializable, ISerializableEntity
+    {
+        partial void AdjustKarma(IDamageable attacker, float amount)
+        {
+            if (GameMain.Server != null)
+            {
+                if (Submarine == null) return;
+                if (attacker == null) return;
+                if (attacker is Character attackerCharacter)
+                {
+                    Client attackerClient = GameMain.Server.ConnectedClients.Find(c => c.Character == attackerCharacter);
+                    if (attackerClient != null)
+                    {
+                        if (attackerCharacter.TeamID == Submarine.TeamID)
+                        {
+                            attackerClient.Karma -= amount * 0.001f;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            for (int i = 0; i < Sections.Length; i++)
+            {
+                msg.WriteRangedSingle(Sections[i].damage / Health, 0.0f, 1.0f, 8);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Map/Submarine.cs

@@ -0,0 +1,18 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma
+{
+    partial class Submarine
+    {
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(ID);
+            NetBuffer tempBuffer = new NetBuffer();
+            subBody.Body.ServerWrite(tempBuffer, c, extraData);
+            msg.Write((byte)tempBuffer.LengthBytes);
+            msg.Write(tempBuffer);
+            msg.WritePadBits();
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/BanList.cs

@@ -0,0 +1,315 @@
+using Lidgren.Network;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+
+namespace Barotrauma.Networking
+{
+    partial class BannedPlayer
+    {
+        private static UInt16 LastIdentifier = 0;
+
+        public BannedPlayer(string name, string ip, string reason, DateTime? expirationTime)
+        {
+            this.Name = name;
+            this.IP = ip;
+            this.Reason = reason;
+            this.ExpirationTime = expirationTime;
+            this.UniqueIdentifier = LastIdentifier; LastIdentifier++;
+
+            this.IsRangeBan = IP.IndexOf(".x")>-1;
+        }
+
+        public BannedPlayer(string name, ulong steamID, string reason, DateTime? expirationTime)
+        {
+            this.Name = name;
+            this.SteamID = steamID;
+            this.Reason = reason;
+            this.ExpirationTime = expirationTime;
+            this.UniqueIdentifier = LastIdentifier; LastIdentifier++;
+
+            this.IsRangeBan = false;
+        }
+
+        public bool CompareTo(string ipCompare)
+        {
+            if (!IsRangeBan)
+            {
+                return ipCompare == IP;
+            }
+            else
+            {
+                int rangeBanIndex = IP.IndexOf(".x");
+                if (ipCompare.Length < rangeBanIndex) return false;
+                return ipCompare.Substring(0, rangeBanIndex) == IP.Substring(0, rangeBanIndex);
+            }
+        }
+
+        public bool CompareTo(IPAddress ipCompare)
+        {
+            if (ipCompare.IsIPv4MappedToIPv6 && CompareTo(ipCompare.MapToIPv4().ToString()))
+            {
+                return true;
+            }
+            return CompareTo(ipCompare.ToString());
+        }
+    }
+
+    partial class BanList
+    {
+        partial void InitProjectSpecific()
+        {
+            if (!File.Exists(SavePath)) { return; }
+
+            string[] lines;
+            try
+            {
+                lines = File.ReadAllLines(SavePath);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Failed to open the list of banned players in " + SavePath, e);
+                return;
+            }
+
+            foreach (string line in lines)
+            {
+                string[] separatedLine = line.Split(',');
+                if (separatedLine.Length < 2) continue;
+
+                string name = separatedLine[0];
+                string identifier = separatedLine[1];
+
+                DateTime? expirationTime = null;
+                if (separatedLine.Length > 2 && !string.IsNullOrEmpty(separatedLine[2]))
+                {
+                    if (DateTime.TryParse(separatedLine[2], out DateTime parsedTime))
+                    {
+                        expirationTime = parsedTime;
+                    }
+                }
+                string reason = separatedLine.Length > 3 ? string.Join(",", separatedLine.Skip(3)) : "";
+
+                if (expirationTime.HasValue && DateTime.Now > expirationTime.Value) continue;
+
+                if (identifier.Contains(".") || identifier.Contains(":"))
+                {
+                    //identifier is an ip
+                    bannedPlayers.Add(new BannedPlayer(name, identifier, reason, expirationTime));
+                }
+                else
+                {
+                    //identifier should be a steam id
+                    if (ulong.TryParse(identifier, out ulong steamID))
+                    {
+                        bannedPlayers.Add(new BannedPlayer(name, steamID, reason, expirationTime));
+                    }
+                    else
+                    {
+                        DebugConsole.ThrowError("Error in banlist: \"" + identifier + "\" is not a valid IP or a Steam ID");
+                    }
+                }
+            }
+        }
+
+        public bool IsBanned(IPAddress IP, ulong steamID)
+        {
+            bannedPlayers.RemoveAll(bp => bp.ExpirationTime.HasValue && DateTime.Now > bp.ExpirationTime.Value);
+            return bannedPlayers.Any(bp => bp.CompareTo(IP) || (steamID > 0 && bp.SteamID == steamID));
+        }
+
+        public void BanPlayer(string name, IPAddress ip, string reason, TimeSpan? duration)
+        {
+            string ipStr = ip.IsIPv4MappedToIPv6 ? ip.MapToIPv4().ToString() : ip.ToString();
+            BanPlayer(name, ipStr, 0, reason, duration);
+        }
+
+        public void BanPlayer(string name, string ip, string reason, TimeSpan? duration)
+        {
+            BanPlayer(name, ip, 0, reason, duration);
+        }
+
+        public void BanPlayer(string name, ulong steamID, string reason, TimeSpan? duration)
+        {
+            BanPlayer(name, "", steamID, reason, duration);
+        }
+
+        private void BanPlayer(string name, string ip, ulong steamID, string reason, TimeSpan? duration)
+        {
+            var existingBan = bannedPlayers.Find(bp => bp.IP == ip && bp.SteamID == steamID);
+            if (existingBan != null)
+            {
+                if (!duration.HasValue) return;
+
+                DebugConsole.Log("Set \"" + name + "\"'s ban duration to " + duration.Value);
+                existingBan.ExpirationTime = DateTime.Now + duration.Value;
+                Save();
+                return;
+            }
+
+            System.Diagnostics.Debug.Assert(!name.Contains(','));
+
+            string logMsg = "Banned " + name;
+            if (!string.IsNullOrEmpty(reason)) logMsg += ", reason: " + reason;
+            if (duration.HasValue) logMsg += ", duration: " + duration.Value.ToString();
+
+            DebugConsole.Log(logMsg);
+
+            DateTime? expirationTime = null;
+            if (duration.HasValue)
+            {
+                expirationTime = DateTime.Now + duration.Value;
+            }
+
+            bannedPlayers.Add(new BannedPlayer(name, ip, reason, expirationTime));
+            Save();
+        }
+
+        public void UnbanPlayer(string name)
+        {
+            var player = bannedPlayers.Find(bp => bp.Name == name);
+            if (player == null)
+            {
+                DebugConsole.Log("Could not unban player \"" + name + "\". Matching player not found.");
+            }
+            else
+            {
+                RemoveBan(player);
+            }
+        }
+
+        public void UnbanIP(string ip)
+        {
+            var player = bannedPlayers.Find(bp => bp.IP == ip);
+            if (player == null)
+            {
+                DebugConsole.Log("Could not unban IP \"" + ip + "\". Matching player not found.");
+            }
+            else
+            {
+                RemoveBan(player);
+            }
+        }
+
+        private void RemoveBan(BannedPlayer banned)
+        {
+            DebugConsole.Log("Removing ban from " + banned.Name);
+            GameServer.Log("Removing ban from " + banned.Name, ServerLog.MessageType.ServerMessage);
+
+            bannedPlayers.Remove(banned);
+
+            Save();
+        }
+
+        private void RangeBan(BannedPlayer banned)
+        {
+            banned.IP = ToRange(banned.IP);
+
+            BannedPlayer bp;
+            while ((bp = bannedPlayers.Find(x => banned.CompareTo(x.IP))) != null)
+            {
+                //remove all specific bans that are now covered by the rangeban
+                bannedPlayers.Remove(bp);
+            }
+
+            bannedPlayers.Add(banned);
+
+            Save();
+        }
+
+        public void Save()
+        {
+            GameServer.Log("Saving banlist", ServerLog.MessageType.ServerMessage);
+
+            bannedPlayers.RemoveAll(bp => bp.ExpirationTime.HasValue && DateTime.Now > bp.ExpirationTime.Value);
+
+            List<string> lines = new List<string>();
+            foreach (BannedPlayer banned in bannedPlayers)
+            {
+                string line = banned.Name;
+                line += "," + ((banned.SteamID > 0) ? banned.SteamID.ToString() : banned.IP);
+                line += "," + (banned.ExpirationTime.HasValue ? banned.ExpirationTime.Value.ToString() : "");
+                if (!string.IsNullOrWhiteSpace(banned.Reason)) line += "," + banned.Reason;
+
+                lines.Add(line);
+            }
+
+            try
+            {
+                File.WriteAllLines(SavePath, lines);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Saving the list of banned players to " + SavePath + " failed", e);
+            }
+        }
+
+        public void ServerAdminWrite(NetBuffer outMsg, Client c)
+        {
+            if (!c.HasPermission(ClientPermissions.Ban))
+            {
+                outMsg.Write(false); outMsg.WritePadBits();
+                return;
+            }
+            outMsg.Write(true);
+            outMsg.Write(c.Connection == GameMain.Server.OwnerConnection);
+
+            outMsg.WritePadBits();
+            outMsg.WriteVariableInt32(bannedPlayers.Count);
+            for (int i = 0; i < bannedPlayers.Count; i++)
+            {
+                BannedPlayer bannedPlayer = bannedPlayers[i];
+
+                outMsg.Write(bannedPlayer.Name);
+                outMsg.Write(bannedPlayer.UniqueIdentifier);
+                outMsg.Write(bannedPlayer.IsRangeBan); outMsg.WritePadBits();
+                if (c.Connection == GameMain.Server.OwnerConnection)
+                {
+                    outMsg.Write(bannedPlayer.IP);
+                    outMsg.Write(bannedPlayer.SteamID);
+                }
+            }
+        }
+
+        public bool ServerAdminRead(NetBuffer incMsg, Client c)
+        {
+            if (!c.HasPermission(ClientPermissions.Ban))
+            {
+                UInt16 removeCount = incMsg.ReadUInt16();
+                incMsg.Position += removeCount * 4 * 8;
+                UInt16 rangeBanCount = incMsg.ReadUInt16();
+                incMsg.Position += rangeBanCount * 4 * 8;
+                return false;
+            }
+            else
+            {
+                UInt16 removeCount = incMsg.ReadUInt16();
+                for (int i = 0; i < removeCount; i++)
+                {
+                    UInt16 id = incMsg.ReadUInt16();
+                    BannedPlayer bannedPlayer = bannedPlayers.Find(p => p.UniqueIdentifier == id);
+                    if (bannedPlayer != null)
+                    {
+                        GameServer.Log(c.Name + " unbanned " + bannedPlayer.Name + " (" + bannedPlayer.IP + ")", ServerLog.MessageType.ConsoleUsage);
+                        RemoveBan(bannedPlayer);
+                    }
+                }
+                Int16 rangeBanCount = incMsg.ReadInt16();
+                for (int i = 0; i < rangeBanCount; i++)
+                {
+                    UInt16 id = incMsg.ReadUInt16();
+                    BannedPlayer bannedPlayer = bannedPlayers.Find(p => p.UniqueIdentifier == id);
+                    if (bannedPlayer != null)
+                    {
+                        GameServer.Log(c.Name + " rangebanned " + bannedPlayer.Name + " (" + bannedPlayer.IP + ")", ServerLog.MessageType.ConsoleUsage);
+                        RangeBan(bannedPlayer);
+                    }
+                }
+
+                return removeCount > 0 || rangeBanCount > 0;
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/ChatMessage.cs

@@ -0,0 +1,180 @@
+using Barotrauma.Items.Components;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Linq;
+using System.Text;
+
+namespace Barotrauma.Networking
+{
+    partial class ChatMessage
+    {
+        public static void ServerRead(NetIncomingMessage msg, Client c)
+        {
+            c.KickAFKTimer = 0.0f;
+
+            UInt16 ID = msg.ReadUInt16();
+            ChatMessageType type = (ChatMessageType)msg.ReadByte();
+            string txt = "";
+
+            int orderIndex = -1;
+            Character orderTargetCharacter = null;
+            Entity orderTargetEntity = null;
+            int orderOptionIndex = -1;
+            OrderChatMessage orderMsg = null;
+            if (type == ChatMessageType.Order)
+            {
+                orderIndex = msg.ReadByte();
+                orderTargetCharacter = Entity.FindEntityByID(msg.ReadUInt16()) as Character;
+                orderTargetEntity = Entity.FindEntityByID(msg.ReadUInt16()) as Entity;
+                orderOptionIndex = msg.ReadByte();
+
+                if (orderIndex < 0 || orderIndex >= Order.PrefabList.Count)
+                {
+                    DebugConsole.ThrowError("Invalid order message from client \"" + c.Name + "\" - order index out of bounds.");
+                    return;
+                }
+
+                Order order = Order.PrefabList[orderIndex];
+                string orderOption = orderOptionIndex < 0 || orderOptionIndex >= order.Options.Length ? "" : order.Options[orderOptionIndex];
+                orderMsg = new OrderChatMessage(order, orderOption, orderTargetEntity, orderTargetCharacter, c.Character);
+                txt = orderMsg.Text;
+            }
+            else
+            {
+                txt = msg.ReadString() ?? "";
+            }
+
+            if (!NetIdUtils.IdMoreRecent(ID, c.LastSentChatMsgID)) return;
+
+            c.LastSentChatMsgID = ID;
+
+            if (txt.Length > MaxLength)
+            {
+                txt = txt.Substring(0, MaxLength);
+            }
+
+            c.LastSentChatMessages.Add(txt);
+            if (c.LastSentChatMessages.Count > 10)
+            {
+                c.LastSentChatMessages.RemoveRange(0, c.LastSentChatMessages.Count - 10);
+            }
+
+            float similarity = 0.0f;
+            //don't do message similarity checks on order messages
+            if (orderMsg == null)
+            {
+                for (int i = 0; i < c.LastSentChatMessages.Count; i++)
+                {
+                    float closeFactor = 1.0f / (c.LastSentChatMessages.Count - i);
+                    if (string.IsNullOrEmpty(txt))
+                    {
+                        similarity += closeFactor;
+                    }
+                    else
+                    {
+                        int levenshteinDist = ToolBox.LevenshteinDistance(txt, c.LastSentChatMessages[i]);
+                        similarity += Math.Max((txt.Length - levenshteinDist) / (float)txt.Length * closeFactor, 0.0f);
+                    }
+                }
+            }
+
+            bool isOwner = GameMain.Server.OwnerConnection != null && c.Connection == GameMain.Server.OwnerConnection;
+
+            if (similarity + c.ChatSpamSpeed > 5.0f && !isOwner)
+            {
+                c.ChatSpamCount++;
+
+                if (c.ChatSpamCount > 3)
+                {
+                    //kick for spamming too much
+                    GameMain.Server.KickClient(c, TextManager.Get("SpamFilterKicked"));
+                }
+                else
+                {
+                    ChatMessage denyMsg = Create("", TextManager.Get("SpamFilterBlocked"), ChatMessageType.Server, null);
+                    c.ChatSpamTimer = 10.0f;
+                    GameMain.Server.SendDirectChatMessage(denyMsg, c);
+                }
+                return;
+            }
+
+            c.ChatSpamSpeed += similarity + 0.5f;
+
+            if (c.ChatSpamTimer > 0.0f && !isOwner)
+            {
+                ChatMessage denyMsg = Create("", TextManager.Get("SpamFilterBlocked"), ChatMessageType.Server, null);
+                c.ChatSpamTimer = 10.0f;
+                GameMain.Server.SendDirectChatMessage(denyMsg, c);
+                return;
+            }
+
+            if (type == ChatMessageType.Order)
+            {
+                if (c.Character == null || c.Character.SpeechImpediment >= 100.0f || c.Character.IsDead) return;
+
+                ChatMessageType messageType = CanUseRadio(orderMsg.Sender) ? ChatMessageType.Radio : ChatMessageType.Default;
+                if (orderMsg.Order.TargetAllCharacters)
+                {
+#if CLIENT
+                    //add the order to the crewmanager only if the host is not controlling a character 
+                    //OR the character is close enough to hear it
+                    if (Character.Controlled == null || 
+                        !string.IsNullOrEmpty(ApplyDistanceEffect(orderMsg.Text, messageType, orderMsg.Sender, Character.Controlled)))
+                    {
+                        GameMain.GameSession?.CrewManager?.AddOrder(
+                            new Order(orderMsg.Order.Prefab, orderTargetEntity, (orderTargetEntity as Item)?.GetComponent<ItemComponent>()),
+                            orderMsg.Order.Prefab.FadeOutTime);
+                    }
+#endif
+                }
+                else if (orderTargetCharacter != null)
+                {
+                    orderTargetCharacter.SetOrder(
+                        new Order(orderMsg.Order.Prefab, orderTargetEntity, (orderTargetEntity as Item)?.GetComponent<ItemComponent>()),
+                            orderMsg.OrderOption, orderMsg.Sender);
+                }
+
+                GameMain.Server.SendOrderChatMessage(orderMsg);
+            }
+            else
+            {
+                GameMain.Server.SendChatMessage(txt, null, c);
+            }
+        }
+
+        public int EstimateLengthBytesServer(Client c)
+        {
+            int length = 1 + //(byte)ServerNetObject.CHAT_MESSAGE
+                            2 + //(UInt16)NetStateID
+                            1 + //(byte)Type
+                            Encoding.UTF8.GetBytes(Text).Length + 2;
+
+            if (Sender != null && c.InGame)
+            {
+                length += 2; //sender ID (UInt16)
+            }
+            else if (SenderName != null)
+            {
+                length += Encoding.UTF8.GetBytes(SenderName).Length + 2;
+            }
+
+            return length;
+        }
+
+        public virtual void ServerWrite(NetOutgoingMessage msg, Client c)
+        {
+            msg.Write((byte)ServerNetObject.CHAT_MESSAGE);
+            msg.Write(NetStateID);
+            msg.Write((byte)Type);
+            msg.Write(Text);
+
+            msg.Write(SenderName);
+            msg.Write(Sender != null && c.InGame);
+            if (Sender != null && c.InGame)
+            {
+                msg.Write(Sender.ID);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/Client.cs

@@ -0,0 +1,172 @@
+using Lidgren.Network;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.Networking
+{
+    partial class Client : IDisposable
+    {
+        public ulong SteamID;
+
+        public bool VoiceEnabled = true;
+
+        public UInt16 LastRecvClientListUpdate = 0;
+
+        public UInt16 LastRecvLobbyUpdate = 0;
+
+        public UInt16 LastSentChatMsgID = 0; //last msg this client said
+        public UInt16 LastRecvChatMsgID = 0; //last msg this client knows about
+
+        public UInt16 LastSentEntityEventID = 0;
+        public UInt16 LastRecvEntityEventID = 0;
+
+        public UInt16 LastRecvCampaignUpdate = 0;
+        public UInt16 LastRecvCampaignSave = 0;
+
+        public Pair<UInt16, float> LastCampaignSaveSendTime;
+
+        public readonly List<ChatMessage> ChatMsgQueue = new List<ChatMessage>();
+        public UInt16 LastChatMsgQueueID;
+
+        //latest chat messages sent by this client
+        public readonly List<string> LastSentChatMessages = new List<string>();
+        public float ChatSpamSpeed;
+        public float ChatSpamTimer;
+        public int ChatSpamCount;
+
+        public float KickAFKTimer;
+
+        public double MidRoundSyncTimeOut;
+
+        public bool NeedsMidRoundSync;
+        //how many unique events the client missed before joining the server
+        public UInt16 UnreceivedEntityEventCount;
+        public UInt16 FirstNewEventID;
+        
+        //when was a specific entity event last sent to the client
+        //  key = event id, value = NetTime.Now when sending
+        public readonly Dictionary<UInt16, float> EntityEventLastSent = new Dictionary<UInt16, float>();
+        
+        //when was a position update for a given entity last sent to the client
+        //  key = entity id, value = NetTime.Now when sending
+        public readonly Dictionary<UInt16, float> PositionUpdateLastSent = new Dictionary<UInt16, float>();
+        public readonly Queue<Entity> PendingPositionUpdates = new Queue<Entity>();
+
+        public bool ReadyToStart;
+
+        public List<JobPrefab> JobPreferences;
+        public JobPrefab AssignedJob;
+
+        public float DeleteDisconnectedTimer;
+
+        public CharacterInfo CharacterInfo;
+        public NetConnection Connection { get; set; }
+
+        public bool SpectateOnly;
+        
+        private float karma = 1.0f;
+        public float Karma
+        {
+            get
+            {
+                if (GameMain.Server == null) return 1.0f;
+                if (!GameMain.Server.ServerSettings.KarmaEnabled) return 1.0f;
+                return karma;
+            }
+            set
+            {
+                if (GameMain.Server == null) return;
+                if (!GameMain.Server.ServerSettings.KarmaEnabled) return;
+                karma = Math.Min(Math.Max(value, 0.0f), 1.0f);
+            }
+        }
+
+        partial void InitProjSpecific()
+        {
+            JobPreferences = new List<JobPrefab>(JobPrefab.List.GetRange(0, Math.Min(JobPrefab.List.Count, 3)));
+
+            VoipQueue = new VoipQueue(ID, true, true);
+            GameMain.Server.VoipServer.RegisterQueue(VoipQueue);
+        }
+
+        partial void DisposeProjSpecific()
+        {
+            GameMain.Server.VoipServer.UnregisterQueue(VoipQueue);
+            VoipQueue.Dispose();
+        }
+
+        public void InitClientSync()
+        {
+            LastSentChatMsgID = 0;
+            LastRecvChatMsgID = ChatMessage.LastID;
+
+            LastRecvLobbyUpdate = 0;
+
+            LastRecvEntityEventID = 0;
+
+            UnreceivedEntityEventCount = 0;
+            NeedsMidRoundSync = false;
+        }
+
+        public static bool IsValidName(string name, GameServer server)
+        {
+            char[] disallowedChars = new char[] { ';', ',', '<', '>', '/', '\\', '[', ']', '"', '?' };
+            if (name.Any(c => disallowedChars.Contains(c))) return false;
+
+            foreach (char character in name)
+            {
+                if (!server.ServerSettings.AllowedClientNameChars.Any(charRange => (int)character >= charRange.First && (int)character <= charRange.Second)) return false;
+            }
+
+            return true;
+        }
+
+        public bool IPMatches(string ip)
+        {
+            if (Connection?.RemoteEndPoint == null) { return false; }
+            if (Connection.RemoteEndPoint.Address.IsIPv4MappedToIPv6 && 
+                Connection.RemoteEndPoint.Address.MapToIPv4().ToString() == ip)
+            {
+                return true;
+            }
+            return Connection.RemoteEndPoint.Address.ToString() == ip;
+        }
+
+        public void SetPermissions(ClientPermissions permissions, List<DebugConsole.Command> permittedConsoleCommands)
+        {
+            this.Permissions = permissions;
+            this.PermittedConsoleCommands = new List<DebugConsole.Command>(permittedConsoleCommands);
+        }
+
+        public void GivePermission(ClientPermissions permission)
+        {
+            if (!this.Permissions.HasFlag(permission)) this.Permissions |= permission;
+        }
+
+        public void RemovePermission(ClientPermissions permission)
+        {
+            if (this.Permissions.HasFlag(permission)) this.Permissions &= ~permission;
+        }
+
+        public bool HasPermission(ClientPermissions permission)
+        {
+            return this.Permissions.HasFlag(permission);
+        }
+
+        public static string SanitizeName(string name)
+        {
+            name = name.Trim();
+            if (name.Length > 20)
+            {
+                name = name.Substring(0, 20);
+            }
+            string rName = "";
+            for (int i = 0; i < name.Length; i++)
+            {
+                rName += name[i] < 32 ? '?' : name[i];
+            }
+            return rName;
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/EntitySpawner.cs

@@ -0,0 +1,44 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    partial class EntitySpawner : Entity, IServerSerializable
+    {
+        public void CreateNetworkEvent(Entity entity, bool remove)
+        {
+            if (GameMain.Server != null && entity != null)
+            {
+                GameMain.Server.CreateEntityEvent(this, new object[] { new SpawnOrRemove(entity, remove) });
+            }
+        }
+
+        public void ServerWrite(Lidgren.Network.NetBuffer message, Client client, object[] extraData = null)
+        {
+            if (GameMain.Server == null) return;
+
+            SpawnOrRemove entities = (SpawnOrRemove)extraData[0];
+
+            message.Write(entities.Remove);
+
+            if (entities.Remove)
+            {
+                message.Write(entities.Entity.ID);
+            }
+            else
+            {
+                if (entities.Entity is Item)
+                {
+                    message.Write((byte)SpawnableType.Item);
+                    ((Item)entities.Entity).WriteSpawnData(message);
+                }
+                else if (entities.Entity is Character)
+                {
+                    message.Write((byte)SpawnableType.Character);
+                    DebugConsole.NewMessage("WRITING CHARACTER DATA: " + (entities.Entity).ToString() + " (ID: " + entities.Entity.ID + ")", Color.Cyan);
+                    ((Character)entities.Entity).WriteSpawnData(message);
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/FileTransfer/FileSender.cs

@@ -0,0 +1,285 @@
+using Lidgren.Network;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Barotrauma.Networking
+{
+    class FileSender
+    {
+        public class FileTransferOut
+        {
+            private byte[] data;
+
+            private DateTime startingTime;
+
+            private NetConnection connection;
+
+            public FileTransferStatus Status;
+            
+            public string FileName
+            {
+                get;
+                private set;
+            }
+
+            public string FilePath
+            {
+                get;
+                private set;
+            }
+
+            public FileTransferType FileType
+            {
+                get;
+                private set;
+            }
+
+            public float Progress
+            {
+                get { return SentOffset / (float)Data.Length; }
+            }
+
+            public float WaitTimer
+            {
+                get;
+                set;
+            }
+
+            public byte[] Data
+            {
+                get { return data; }
+            }
+
+            public int SentOffset
+            {
+                get;
+                set;
+            }
+
+            public NetConnection Connection
+            {
+                get { return connection; }
+            }
+
+            public int SequenceChannel;
+
+            public FileTransferOut(NetConnection recipient, FileTransferType fileType, string filePath)
+            {
+                connection = recipient;
+
+                FileType = fileType;
+                FilePath = filePath;
+                FileName = Path.GetFileName(filePath);
+
+                Status = FileTransferStatus.NotStarted;
+                
+                startingTime = DateTime.Now;
+
+                data = File.ReadAllBytes(filePath);
+            }
+        }
+
+        const int MaxTransferCount = 16;
+        const int MaxTransferCountPerRecipient = 5;
+
+        public static TimeSpan MaxTransferDuration = new TimeSpan(0, 2, 0);
+        
+        public delegate void FileTransferDelegate(FileTransferOut fileStreamReceiver);
+        public FileTransferDelegate OnStarted;
+        public FileTransferDelegate OnEnded;
+
+        private List<FileTransferOut> activeTransfers;
+
+        private int chunkLen;
+
+        private NetPeer peer;
+
+        public List<FileTransferOut> ActiveTransfers
+        {
+            get { return activeTransfers; }
+        }
+
+        public FileSender(NetworkMember networkMember)
+        {
+            peer = networkMember.NetPeer;
+            chunkLen = peer.Configuration.MaximumTransmissionUnit - 100;
+
+            activeTransfers = new List<FileTransferOut>();
+        }
+
+        public FileTransferOut StartTransfer(NetConnection recipient, FileTransferType fileType, string filePath)
+        {
+            if (activeTransfers.Count >= MaxTransferCount)
+            {
+                return null;
+            }
+
+            if (activeTransfers.Count(t => t.Connection == recipient) > MaxTransferCountPerRecipient)
+            {
+                return null;
+            }
+
+            if (!File.Exists(filePath))
+            {
+                DebugConsole.ThrowError("Failed to initiate file transfer (file \"" + filePath + "\" not found.");
+                return null;
+            }
+
+            FileTransferOut transfer = null;
+            try
+            {
+                transfer = new FileTransferOut(recipient, fileType, filePath)
+                {
+                    SequenceChannel = 1
+                };
+                while (activeTransfers.Any(t => t.Connection == recipient && t.SequenceChannel == transfer.SequenceChannel))
+                {
+                    transfer.SequenceChannel++;
+                }
+                activeTransfers.Add(transfer);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Failed to initiate file transfer", e);
+                return null;
+            }
+
+            OnStarted(transfer);
+
+            return transfer;
+        }
+
+        public void Update(float deltaTime)
+        {
+            activeTransfers.RemoveAll(t => t.Connection.Status != NetConnectionStatus.Connected);
+
+            var endedTransfers = activeTransfers.FindAll(t => 
+                t.Connection.Status != NetConnectionStatus.Connected ||
+                t.Status == FileTransferStatus.Finished ||
+                t.Status == FileTransferStatus.Canceled || 
+                t.Status == FileTransferStatus.Error);
+
+            foreach (FileTransferOut transfer in endedTransfers)
+            {
+                activeTransfers.Remove(transfer);
+                OnEnded(transfer);
+            }
+
+            foreach (FileTransferOut transfer in activeTransfers)
+            {
+                transfer.WaitTimer -= deltaTime;
+                if (transfer.WaitTimer > 0.0f) continue;
+                
+                if (!transfer.Connection.CanSendImmediately(NetDeliveryMethod.ReliableOrdered, 1)) continue;
+
+                transfer.WaitTimer = 0.05f;// transfer.Connection.AverageRoundtripTime;
+
+                // send another part of the file
+                long remaining = transfer.Data.Length - transfer.SentOffset;
+                int sendByteCount = (remaining > chunkLen ? chunkLen : (int)remaining);
+                
+                NetOutgoingMessage message;
+
+                //first message; send length, chunk length, file name etc
+                if (transfer.SentOffset == 0)
+                {
+                    message = peer.CreateMessage();
+                    message.Write((byte)ServerPacketHeader.FILE_TRANSFER);
+                    message.Write((byte)FileTransferMessageType.Initiate);
+                    message.Write((byte)transfer.FileType);
+                    message.Write((ushort)chunkLen);
+                    message.Write((ulong)transfer.Data.Length);
+                    message.Write(transfer.FileName);
+                    GameMain.Server.CompressOutgoingMessage(message);
+                    transfer.Connection.SendMessage(message, NetDeliveryMethod.ReliableOrdered, transfer.SequenceChannel);
+
+                    transfer.Status = FileTransferStatus.Sending;
+
+                    if (GameSettings.VerboseLogging)
+                    {
+                        DebugConsole.Log("Sending file transfer initiation message: ");
+                        DebugConsole.Log("  File: " + transfer.FileName);
+                        DebugConsole.Log("  Size: " + transfer.Data.Length);
+                        DebugConsole.Log("  Sequence channel: " + transfer.SequenceChannel);
+                    }
+                }
+
+                message = peer.CreateMessage(1 + 1 + sendByteCount);
+                message.Write((byte)ServerPacketHeader.FILE_TRANSFER);
+                message.Write((byte)FileTransferMessageType.Data);
+
+                byte[] sendBytes = new byte[sendByteCount];
+                Array.Copy(transfer.Data, transfer.SentOffset, sendBytes, 0, sendByteCount);
+
+                message.Write(sendBytes);
+
+                GameMain.Server.CompressOutgoingMessage(message);
+                transfer.Connection.SendMessage(message, NetDeliveryMethod.ReliableOrdered, transfer.SequenceChannel);
+                transfer.SentOffset += sendByteCount;
+
+                if (GameSettings.VerboseLogging)
+                {
+                    DebugConsole.Log("Sending " + sendByteCount + " bytes of the file " + transfer.FileName + " (" + transfer.SentOffset + "/" + transfer.Data.Length + " sent)");
+                }
+
+                if (remaining - sendByteCount <= 0)
+                {
+                    transfer.Status = FileTransferStatus.Finished;
+                }
+            }
+        }
+
+        public void CancelTransfer(FileTransferOut transfer)
+        {
+            transfer.Status = FileTransferStatus.Canceled;
+            activeTransfers.Remove(transfer);
+
+            OnEnded(transfer);
+
+            GameMain.Server.SendCancelTransferMsg(transfer);
+        }
+
+        public void ReadFileRequest(NetIncomingMessage inc, Client client)
+        {
+            byte messageType = inc.ReadByte();
+
+            if (messageType == (byte)FileTransferMessageType.Cancel)
+            {
+                byte sequenceChannel = inc.ReadByte();
+                var matchingTransfer = activeTransfers.Find(t => t.Connection == inc.SenderConnection && t.SequenceChannel == sequenceChannel);
+                if (matchingTransfer != null) CancelTransfer(matchingTransfer);
+
+                return;
+            }
+
+            byte fileType = inc.ReadByte();
+            switch (fileType)
+            {
+                case (byte)FileTransferType.Submarine:
+                    string fileName = inc.ReadString();
+                    string fileHash = inc.ReadString();
+                    var requestedSubmarine = Submarine.SavedSubmarines.FirstOrDefault(s => s.Name == fileName && s.MD5Hash.Hash == fileHash);
+
+                    if (requestedSubmarine != null)
+                    {
+                        StartTransfer(inc.SenderConnection, FileTransferType.Submarine, requestedSubmarine.FilePath);
+                    }
+                    break;
+                case (byte)FileTransferType.CampaignSave:
+                    if (GameMain.GameSession != null &&
+                        !ActiveTransfers.Any(t => t.Connection == inc.SenderConnection && t.FileType == FileTransferType.CampaignSave))
+                    {                       
+                        StartTransfer(inc.SenderConnection, FileTransferType.CampaignSave, GameMain.GameSession.SavePath);
+                        if (GameMain.GameSession?.GameMode is MultiPlayerCampaign campaign)
+                        {
+                            client.LastCampaignSaveSendTime = new Pair<ushort, float>(campaign.LastSaveID, (float)NetTime.Now);
+                        }
+                    }
+                    break;
+            }
+        }
+
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/GameClient.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace Barotrauma.Networking
-{
-    class GameClient : NetworkMember
-    {
-        public GameClient(string newName)
-        {
-            throw new Exception("Tried to create GameClient in dedicated server build");
-        }
-    }
-}

Barotrauma/BarotraumaServer/Source/Networking/NetEntityEvent/ServerEntityEventManager.cs

@@ -0,0 +1,504 @@
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.Networking
+{
+    class ServerEntityEvent : NetEntityEvent
+    {
+        private IServerSerializable serializable;
+
+        public bool Sent;
+
+#if DEBUG
+        public string StackTrace;
+#endif
+
+        private double createTime;
+        public double CreateTime
+        {
+            get { return createTime; }
+        }
+
+        public ServerEntityEvent(IServerSerializable entity, UInt16 id)
+            : base(entity, id)
+        {
+            serializable = entity;
+
+            createTime = Timing.TotalTime;
+
+#if DEBUG
+            StackTrace = Environment.StackTrace.ToString();
+#endif
+        }
+
+        public void Write(NetBuffer msg, Client recipient)
+        {
+            serializable.ServerWrite(msg, recipient, Data);
+        }
+    }
+
+    class ServerEntityEventManager : NetEntityEventManager
+    {
+        private List<ServerEntityEvent> events;
+
+        //list of unique events (i.e. !IsDuplicate) created during the round
+        //used for syncing clients who join mid-round
+        private List<ServerEntityEvent> uniqueEvents;
+
+        private UInt16 lastSentToAll;
+
+        public List<ServerEntityEvent> Events
+        {
+            get { return events; }
+        }
+
+        public List<ServerEntityEvent> UniqueEvents
+        {
+            get { return uniqueEvents; }
+        }
+
+        private class BufferedEvent
+        {
+            public readonly Client Sender;
+
+            public readonly UInt16 CharacterStateID;
+            public readonly NetBuffer Data;
+
+            public readonly Character Character;
+
+            public readonly IClientSerializable TargetEntity;
+
+            public bool IsProcessed;
+
+            public BufferedEvent(Client sender, Character senderCharacter, UInt16 characterStateID, IClientSerializable targetEntity, NetBuffer data)
+            {
+                this.Sender = sender;
+                this.Character = senderCharacter;
+                this.CharacterStateID = characterStateID;
+
+                this.TargetEntity = targetEntity;
+
+                this.Data = data;
+            }
+        }
+
+        private List<BufferedEvent> bufferedEvents;
+
+        private UInt16 ID;
+
+        private GameServer server;
+        
+        public ServerEntityEventManager(GameServer server) 
+        {
+            events = new List<ServerEntityEvent>();
+
+            this.server = server;
+
+            bufferedEvents = new List<BufferedEvent>();
+
+            uniqueEvents = new List<ServerEntityEvent>();
+        }
+
+        public void CreateEvent(IServerSerializable entity, object[] extraData = null)
+        {
+            if (entity == null || !(entity is Entity))
+            {
+                DebugConsole.ThrowError("Can't create an entity event for " + entity + "!");
+                return;
+            }
+
+            if (((Entity)entity).Removed && !(entity is Level))
+            {
+                DebugConsole.ThrowError("Can't create an entity event for " + entity + " - the entity has been removed.\n"+Environment.StackTrace);
+                return;
+            }
+            if (((Entity)entity).IdFreed)
+            {
+                DebugConsole.ThrowError("Can't create an entity event for " + entity + " - the ID of the entity has been freed.\n"+Environment.StackTrace);
+                return;
+            }
+
+            var newEvent = new ServerEntityEvent(entity, (UInt16)(ID + 1));
+            if (extraData != null) newEvent.SetData(extraData);
+            
+            //remove events that have been sent to all clients, they are redundant now
+            //keep at least one event in the list (lastSentToAll == e.ID) so we can use it to keep track of the latest ID
+            events.RemoveAll(e => NetIdUtils.IdMoreRecent(lastSentToAll, e.ID));
+
+            if (server.ConnectedClients.Count(c => c.InGame) == 0 && events.Count > 1)
+            {
+                events.RemoveRange(0, events.Count - 1);
+            }
+
+            for (int i = events.Count - 1; i >= 0; i--)
+            {
+                //we already have an identical event that's waiting to be sent
+                // -> no need to add a new one
+                if (events[i].IsDuplicate(newEvent) && !events[i].Sent) return;
+            }
+
+            ID++;
+
+            events.Add(newEvent);
+
+            if (!uniqueEvents.Any(e => e.IsDuplicate(newEvent)))
+            {
+                //create a copy of the event and give it a new ID
+                var uniqueEvent = new ServerEntityEvent(entity, (UInt16)(uniqueEvents.Count + 1));
+                uniqueEvent.SetData(extraData);
+
+                uniqueEvents.Add(uniqueEvent);
+            }
+        }
+
+        public void Update(List<Client> clients)
+        {
+            foreach (BufferedEvent bufferedEvent in bufferedEvents)
+            {
+                if (bufferedEvent.Character == null || bufferedEvent.Character.IsDead)
+                {
+                    bufferedEvent.IsProcessed = true;
+                    continue;
+                }
+
+                //delay reading the events until the inputs for the corresponding frame have been processed
+
+                //UNLESS the character is unconscious, in which case we'll read the messages immediately (because further inputs will be ignored)
+                //atm the "give in" command is the only thing unconscious characters can do, other types of events are ignored
+                if (!bufferedEvent.Character.IsUnconscious &&
+                    NetIdUtils.IdMoreRecent(bufferedEvent.CharacterStateID, bufferedEvent.Character.LastProcessedID))
+                {
+                    continue;
+                }
+                
+                try
+                {
+                    ReadEvent(bufferedEvent.Data, bufferedEvent.TargetEntity, bufferedEvent.Sender);
+                }
+
+                catch (Exception e)
+                {
+                    string entityName = bufferedEvent.TargetEntity == null ? "null" : bufferedEvent.TargetEntity.ToString();
+                    if (GameSettings.VerboseLogging)
+                    {
+                        DebugConsole.ThrowError("Failed to read server event for entity \"" + entityName + "\"!", e);
+                    }
+                    GameAnalyticsManager.AddErrorEventOnce("ServerEntityEventManager.Read:ReadFailed" + entityName,
+                        GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
+                        "Failed to read server event for entity \"" + entityName + "\"!\n" + e.StackTrace);
+                }
+
+                bufferedEvent.IsProcessed = true;
+            }
+            
+            var inGameClients = clients.FindAll(c => c.InGame && !c.NeedsMidRoundSync);
+            if (inGameClients.Count > 0)
+            {
+                lastSentToAll = inGameClients[0].LastRecvEntityEventID;
+                if (server.OwnerConnection != null)
+                {
+                    var owner = clients.Find(c => c.Connection == server.OwnerConnection);
+                    if (owner != null)
+                    {
+                        lastSentToAll = owner.LastRecvEntityEventID;
+                    }
+                }
+
+                inGameClients.ForEach(c => { if (NetIdUtils.IdMoreRecent(lastSentToAll, c.LastRecvEntityEventID)) lastSentToAll = c.LastRecvEntityEventID; });
+
+                ServerEntityEvent firstEventToResend = events.Find(e => e.ID == (ushort)(lastSentToAll + 1));
+                if (firstEventToResend != null && (Timing.TotalTime - firstEventToResend.CreateTime) > 10.0f)
+                {
+                    //it's been 10 seconds since this event was created
+                    //kick everyone that hasn't received it yet, this is way too old
+                    List<Client> toKick = inGameClients.FindAll(c => NetIdUtils.IdMoreRecent((UInt16)(lastSentToAll + 1), c.LastRecvEntityEventID));
+                    toKick.ForEach(c =>
+                        {
+                            DebugConsole.NewMessage(c.Name + " was kicked due to excessive desync (expected old event " + (c.LastRecvEntityEventID + 1).ToString() + ")", Color.Red);
+                            GameServer.Log("Disconnecting client " + c.Name + " due to excessive desync (expected old event " 
+                                + (c.LastRecvEntityEventID + 1).ToString() +
+                                " (created " + (Timing.TotalTime - firstEventToResend.CreateTime).ToString("0.##") + " s ago)" +
+                                " Events queued: " + events.Count + ", last sent to all: " + lastSentToAll, ServerLog.MessageType.ServerMessage);
+                            server.DisconnectClient(c, "", "ServerMessage.ExcessiveDesync");
+                        }
+                    );
+                }
+
+                if (events.Count > 0)
+                {
+                    //the client is waiting for an event that we don't have anymore
+                    //(the ID they're expecting is smaller than the ID of the first event in our list)
+                    List<Client> toKick = inGameClients.FindAll(c => NetIdUtils.IdMoreRecent(events[0].ID, (UInt16)(c.LastRecvEntityEventID + 1)));
+                    toKick.ForEach(c =>
+                    {
+                        DebugConsole.NewMessage(c.Name + " was kicked due to excessive desync (expected removed event " + (c.LastRecvEntityEventID + 1).ToString() + ", last available is " + events[0].ID.ToString() + ")", Color.Red);
+                        GameServer.Log("Disconnecting client " + c.Name + " due to excessive desync (expected removed event" + (c.LastRecvEntityEventID + 1).ToString() + ", last available is " + events[0].ID.ToString() + ")", ServerLog.MessageType.ServerMessage);
+                        server.DisconnectClient(c, "", "ServerMessage.ExcessiveDesync");
+                    });
+                }
+            }
+            
+            var timedOutClients = clients.FindAll(c => c.InGame && c.NeedsMidRoundSync && Timing.TotalTime > c.MidRoundSyncTimeOut);
+            foreach (Client timedOutClient in timedOutClients)
+            {
+                GameServer.Log("Disconnecting client " + timedOutClient.Name + ". Syncing the client with the server took too long.", ServerLog.MessageType.ServerMessage);
+                GameMain.Server.DisconnectClient(timedOutClient, "", "ServerMessage.SyncTimeout");
+            }
+            
+            bufferedEvents.RemoveAll(b => b.IsProcessed);           
+        }
+
+        private void BufferEvent(BufferedEvent bufferedEvent)
+        {
+            if (bufferedEvents.Count > 512)
+            {
+                //should normally never happen
+
+                //a client could potentially spam events with a much higher character state ID 
+                //than the state of their character and/or stop sending character inputs,
+                //so we'll drop some events to make sure no-one blows up our buffer
+                bufferedEvents.RemoveRange(0, 256);
+            }
+
+            bufferedEvents.Add(bufferedEvent);
+        }
+
+
+        /// <summary>
+        /// Writes all the events that the client hasn't received yet into the outgoing message
+        /// </summary>
+        public void Write(Client client, NetOutgoingMessage msg)
+        {
+            Write(client, msg, out _);
+        }
+
+        /// <summary>
+        /// Writes all the events that the client hasn't received yet into the outgoing message
+        /// </summary>
+        public void Write(Client client, NetOutgoingMessage msg, out List<NetEntityEvent> sentEvents)
+        {
+            List<NetEntityEvent> eventsToSync = null;
+            if (client.NeedsMidRoundSync)
+            {
+                eventsToSync = GetEventsToSync(client, uniqueEvents);
+            }
+            else
+            {
+                eventsToSync = GetEventsToSync(client, events);
+            }
+
+            if (eventsToSync.Count == 0)
+            {
+                sentEvents = eventsToSync;
+                return;
+            }
+
+            //too many events for one packet
+            if (eventsToSync.Count > MaxEventsPerWrite)
+            {
+                if (eventsToSync.Count > MaxEventsPerWrite * 3 && !client.NeedsMidRoundSync)
+                {
+                    Color color = eventsToSync.Count > MaxEventsPerWrite * 20 ? Color.Red : Color.Orange;
+                    if (eventsToSync.Count < MaxEventsPerWrite * 5) { color = Color.Yellow; }
+                    DebugConsole.NewMessage("WARNING: event count very high: " + eventsToSync.Count + "/" + MaxEventsPerWrite, color);
+                }
+
+                eventsToSync.RemoveRange(MaxEventsPerWrite, eventsToSync.Count - MaxEventsPerWrite);
+            }
+
+            foreach (NetEntityEvent entityEvent in eventsToSync)
+            {
+                (entityEvent as ServerEntityEvent).Sent = true;
+                client.EntityEventLastSent[entityEvent.ID] = (float)NetTime.Now;
+            }
+
+            if (client.NeedsMidRoundSync)
+            {
+                msg.Write((byte)ServerNetObject.ENTITY_EVENT_INITIAL);
+
+                //how many (unique) events the clients had missed before joining
+                client.UnreceivedEntityEventCount = (UInt16)uniqueEvents.Count;
+                //ID of the first event sent after the client joined 
+                //(after the client has been synced they'll switch their lastReceivedID 
+                //to the one before this, and the eventmanagers will start to function "normally")
+                client.FirstNewEventID = events.Count == 0 ? (UInt16)0 : events[events.Count - 1].ID;
+
+                msg.Write(client.UnreceivedEntityEventCount);
+                msg.Write(client.FirstNewEventID);
+
+                Write(msg, eventsToSync, client);
+            }
+            else
+            {
+                msg.Write((byte)ServerNetObject.ENTITY_EVENT);
+                Write(msg, eventsToSync, client);
+            }
+            sentEvents = eventsToSync;
+        }
+
+        /// <summary>
+        /// Returns a list of events that should be sent to the client from the eventList 
+        /// </summary>
+        /// <param name="client"></param>
+        /// <param name="eventList"></param>
+        /// <returns></returns>
+        private List<NetEntityEvent> GetEventsToSync(Client client, List<ServerEntityEvent> eventList)
+        {
+            List<NetEntityEvent> eventsToSync = new List<NetEntityEvent>();
+            if (eventList.Count == 0) return eventsToSync;
+
+            //find the index of the first event the client hasn't received
+            int startIndex = eventList.Count;
+            while (startIndex > 0 &&
+                NetIdUtils.IdMoreRecent(eventList[startIndex - 1].ID,client.LastRecvEntityEventID))
+            {
+                startIndex--;
+            }
+            
+            for (int i = startIndex; i < eventList.Count; i++)
+            {
+                //find the first event that hasn't been sent in 1.5 * roundtriptime or at all
+                client.EntityEventLastSent.TryGetValue(eventList[i].ID, out float lastSent);
+
+                float minInterval = Math.Max(client.Connection.AverageRoundtripTime * 1.5f, (float)server.UpdateInterval.TotalSeconds * 2);
+
+                if (lastSent > NetTime.Now - Math.Min(minInterval, 0.5f))
+                {
+                    continue;
+                }
+
+                eventsToSync.AddRange(eventList.GetRange(i, eventList.Count - i));
+                break;
+            }
+
+            return eventsToSync;
+        }
+
+        public void InitClientMidRoundSync(Client client)
+        {
+            //no need for midround syncing if no events have been created,
+            //or if the first created unique event is still in the event list
+            if (uniqueEvents.Count == 0 || (events.Count > 0 && events[0].ID == uniqueEvents[0].ID))
+            {
+                client.UnreceivedEntityEventCount = 0;
+                client.FirstNewEventID = 0;
+                client.NeedsMidRoundSync = false;
+            }
+            else
+            {
+                double midRoundSyncTimeOut = uniqueEvents.Count / MaxEventsPerWrite * server.UpdateInterval.TotalSeconds;
+                midRoundSyncTimeOut = Math.Max(10.0f, midRoundSyncTimeOut * 10.0f);
+
+                client.UnreceivedEntityEventCount = (UInt16)uniqueEvents.Count;
+                client.FirstNewEventID = 0;
+                client.NeedsMidRoundSync = true;
+                client.MidRoundSyncTimeOut = Timing.TotalTime + midRoundSyncTimeOut;
+            }
+        }
+
+        /// <summary>
+        /// Read the events from the message, ignoring ones we've already received
+        /// </summary>
+        public void Read(NetIncomingMessage msg, Client sender = null)
+        {
+            UInt16 firstEventID = msg.ReadUInt16();
+            int eventCount = msg.ReadByte();
+
+            for (int i = 0; i < eventCount; i++)
+            {
+                UInt16 thisEventID = (UInt16)(firstEventID + (UInt16)i);
+                UInt16 entityID = msg.ReadUInt16();
+
+                if (entityID == Entity.NullEntityID)
+                {
+                    msg.ReadPadBits();
+                    if (thisEventID == (UInt16)(sender.LastSentEntityEventID + 1)) sender.LastSentEntityEventID++;
+                    continue;
+                }
+
+                byte msgLength = msg.ReadByte();
+
+                IClientSerializable entity = Entity.FindEntityByID(entityID) as IClientSerializable;
+
+                //skip the event if we've already received it
+                if (thisEventID != (UInt16)(sender.LastSentEntityEventID + 1))
+                {
+                    if (GameSettings.VerboseLogging)
+                    {
+                        DebugConsole.NewMessage("received msg " + thisEventID, Microsoft.Xna.Framework.Color.Red);
+                    }
+                    msg.Position += msgLength * 8;
+                }
+                else if (entity == null)
+                {
+                    //entity not found -> consider the even read and skip over it
+                    //(can happen, for example, when a client uses a medical item repeatedly 
+                    //and creates an event for it before receiving the event about it being removed)
+                    if (GameSettings.VerboseLogging)
+                    {
+                        DebugConsole.NewMessage(
+                            "Received msg " + thisEventID + ", entity " + entityID + " not found",
+                            Microsoft.Xna.Framework.Color.Orange);
+                    }
+                    sender.LastSentEntityEventID++;
+                    msg.Position += msgLength * 8;
+                }
+                else
+                {
+                    if (GameSettings.VerboseLogging)
+                    {
+                        DebugConsole.NewMessage("Received msg " + thisEventID, Microsoft.Xna.Framework.Color.Green);
+                    }
+
+                    UInt16 characterStateID = msg.ReadUInt16();
+
+                    NetBuffer buffer = new NetBuffer();
+                    buffer.Write(msg.ReadBytes(msgLength - 2));
+                    BufferEvent(new BufferedEvent(sender, sender.Character, characterStateID, entity, buffer));
+
+                    sender.LastSentEntityEventID++;
+                }
+                msg.ReadPadBits();
+            }
+        }
+
+        protected override void WriteEvent(NetBuffer buffer, NetEntityEvent entityEvent, Client recipient = null)
+        {
+            var serverEvent = entityEvent as ServerEntityEvent;
+            if (serverEvent == null) return;
+
+            serverEvent.Write(buffer, recipient);
+        }
+
+        protected void ReadEvent(NetBuffer buffer, INetSerializable entity, Client sender = null)
+        {
+            var clientEntity = entity as IClientSerializable;
+            if (clientEntity == null) return;
+            
+            clientEntity.ServerRead(ClientNetObject.ENTITY_STATE, buffer, sender);
+        }
+        
+        public void Clear()
+        {
+            ID = 0;
+            events.Clear();
+
+            bufferedEvents.Clear();
+
+            lastSentToAll = 0;
+
+            uniqueEvents.Clear();
+
+            foreach (Client c in server.ConnectedClients)
+            {
+                c.PositionUpdateLastSent.Clear();
+                c.EntityEventLastSent.Clear();
+                c.LastRecvEntityEventID = 0;
+                c.LastSentEntityEventID = 0;
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/NetworkMember.cs

@@ -2,27 +2,9 @@
 {
     abstract partial class NetworkMember
     {
-        protected const CharacterInfo characterInfo = null;
-
-        protected const Character myCharacter = null;
-
-        public CharacterInfo CharacterInfo
-        {
-            get { return null; }
-            set
-            { 
-                //do nothing 
-            }
-        }
-
         public Character Character
         {
             get { return null; }
         }
-
-        private void InitProjSpecific()
-        {
-            //do nothing
-        }
     }
 }

Barotrauma/BarotraumaServer/Source/Networking/OrderChatMessage.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Lidgren.Network;
+
+namespace Barotrauma.Networking
+{
+    partial class OrderChatMessage : ChatMessage
+    {
+        public override void ServerWrite(NetOutgoingMessage msg, Client c)
+        {
+            msg.Write((byte)ServerNetObject.CHAT_MESSAGE);
+            msg.Write(NetStateID);
+            msg.Write((byte)ChatMessageType.Order);
+
+            msg.Write(SenderName);
+            msg.Write(Sender != null && c.InGame);
+            if (Sender != null && c.InGame)
+            {
+                msg.Write(Sender.ID);
+            }
+
+            msg.Write((byte)Order.PrefabList.IndexOf(Order.Prefab));
+            msg.Write(TargetCharacter == null ? (UInt16)0 : TargetCharacter.ID);
+            msg.Write(TargetEntity == null ? (UInt16)0 : TargetEntity.ID);
+            msg.Write((byte)Array.IndexOf(Order.Prefab.Options, OrderOption));
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/RespawnManager.cs

@@ -0,0 +1,235 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.Networking
+{
+    partial class RespawnManager : Entity, IServerSerializable
+    {
+        private List<Client> GetClientsToRespawn()
+        {
+            return networkMember.ConnectedClients.FindAll(c =>
+                c.InGame &&
+                (!c.SpectateOnly || !((GameServer)networkMember).ServerSettings.AllowSpectating) &&
+                (c.Character == null || c.Character.IsDead));
+        }
+
+        private List<CharacterInfo> GetBotsToRespawn()
+        {
+            GameServer server = networkMember as GameServer;
+
+            if (server.ServerSettings.BotSpawnMode == BotSpawnMode.Normal)
+            {
+                return Character.CharacterList
+                    .FindAll(c => c.TeamID == Character.TeamType.Team1 && c.AIController != null && c.Info != null && c.IsDead)
+                    .Select(c => c.Info)
+                    .ToList();
+            }
+
+            int currPlayerCount = server.ConnectedClients.Count(c => c.InGame && (!c.SpectateOnly || !server.ServerSettings.AllowSpectating));
+            //if (server.CharacterInfo != null) currPlayerCount++;
+
+            var existingBots = Character.CharacterList
+                .FindAll(c => c.TeamID == Character.TeamType.Team1 && c.AIController != null && c.Info != null);
+
+            int requiredBots = server.ServerSettings.BotCount - currPlayerCount;
+            requiredBots -= existingBots.Count(b => !b.IsDead);
+
+            List<CharacterInfo> botsToRespawn = new List<CharacterInfo>();
+            for (int i = 0; i < requiredBots; i++)
+            {
+                CharacterInfo botToRespawn = existingBots.Find(b => b.IsDead)?.Info;
+                if (botToRespawn == null)
+                {
+                    botToRespawn = new CharacterInfo(Character.HumanConfigFile);
+                }
+                else
+                {
+                    existingBots.Remove(botToRespawn.Character);
+                }
+                botsToRespawn.Add(botToRespawn);
+            }
+            return botsToRespawn;
+        }
+
+        partial void UpdateWaiting(float deltaTime)
+        {
+            var server = networkMember as GameServer;
+
+            int characterToRespawnCount = GetClientsToRespawn().Count;
+            int totalCharacterCount = server.ConnectedClients.Count;
+            /*if (server.Character != null)
+            {
+                totalCharacterCount++;
+                if (server.Character.IsDead) characterToRespawnCount++;
+            }*/
+            bool startCountdown = (float)characterToRespawnCount >= Math.Max((float)totalCharacterCount * server.ServerSettings.MinRespawnRatio, 1.0f);
+
+            if (startCountdown != CountdownStarted)
+            {
+                CountdownStarted = startCountdown;
+                server.CreateEntityEvent(this);                
+            }
+
+            if (!CountdownStarted) return;
+
+            respawnTimer -= deltaTime;
+            if (respawnTimer <= 0.0f)
+            {
+                respawnTimer = server.ServerSettings.RespawnInterval;
+
+                DispatchShuttle();
+            }
+
+            if (respawnShuttle == null) return;
+
+            respawnShuttle.Velocity = Vector2.Zero;
+
+            if (shuttleSteering != null)
+            {
+                shuttleSteering.AutoPilot = false;
+                shuttleSteering.MaintainPos = false;
+            }
+        }
+
+        partial void DispatchShuttle()
+        {
+            var server = networkMember as GameServer;
+            if (server == null) return;
+
+            if (respawnShuttle != null)
+            {
+                state = State.Transporting;
+                server.CreateEntityEvent(this);
+
+                ResetShuttle();
+
+                if (shuttleSteering != null)
+                {
+                    shuttleSteering.TargetVelocity = Vector2.Zero;
+                }
+
+                GameServer.Log("Dispatching the respawn shuttle.", ServerLog.MessageType.Spawning);
+
+                RespawnCharacters();
+
+                CoroutineManager.StopCoroutines("forcepos");
+                CoroutineManager.StartCoroutine(ForceShuttleToPos(Level.Loaded.StartPosition - Vector2.UnitY * Level.ShaftHeight, 100.0f), "forcepos");
+            }
+            else
+            {
+                state = State.Waiting;
+                GameServer.Log("Respawning everyone in main sub.", ServerLog.MessageType.Spawning);
+                server.CreateEntityEvent(this);
+
+                RespawnCharacters();
+            }
+        }
+
+        partial void RespawnCharactersProjSpecific()
+        {
+            var server = networkMember as GameServer;
+            if (server == null) return;
+
+            var respawnSub = respawnShuttle ?? Submarine.MainSub;
+
+            var clients = GetClientsToRespawn();
+            foreach (Client c in clients)
+            {
+                //all characters are in Team 1 in game modes/missions with only one team.
+                //if at some point we add a game mode with multiple teams where respawning is possible, this needs to be reworked
+                c.TeamID = Character.TeamType.Team1;
+                if (c.CharacterInfo == null) c.CharacterInfo = new CharacterInfo(Character.HumanConfigFile, c.Name);
+            }
+            List<CharacterInfo> characterInfos = clients.Select(c => c.CharacterInfo).ToList();
+
+            var botsToSpawn = GetBotsToRespawn();
+            characterInfos.AddRange(botsToSpawn);
+            
+            server.AssignJobs(clients);
+            foreach (Client c in clients)
+            {
+                c.CharacterInfo.Job = new Job(c.AssignedJob);
+            }
+
+            //the spawnpoints where the characters will spawn
+            var shuttleSpawnPoints = WayPoint.SelectCrewSpawnPoints(characterInfos, respawnSub);
+            //the spawnpoints where they would spawn if they were spawned inside the main sub
+            //(in order to give them appropriate ID card tags)
+            var mainSubSpawnPoints = WayPoint.SelectCrewSpawnPoints(characterInfos, Submarine.MainSub);
+
+            ItemPrefab divingSuitPrefab = MapEntityPrefab.Find(null, "divingsuit") as ItemPrefab;
+            ItemPrefab oxyPrefab = MapEntityPrefab.Find(null, "oxygentank") as ItemPrefab;
+            ItemPrefab scooterPrefab = MapEntityPrefab.Find(null, "underwaterscooter") as ItemPrefab;
+            ItemPrefab batteryPrefab = MapEntityPrefab.Find(null, "batterycell") as ItemPrefab;
+
+            var cargoSp = WayPoint.WayPointList.Find(wp => wp.Submarine == respawnSub && wp.SpawnType == SpawnType.Cargo);
+
+            for (int i = 0; i < characterInfos.Count; i++)
+            {
+                bool bot = i >= clients.Count;
+
+                var character = Character.Create(characterInfos[i], shuttleSpawnPoints[i].WorldPosition, characterInfos[i].Name, !bot, bot);
+                character.TeamID = Character.TeamType.Team1;
+                
+                if (bot)
+                {
+                    GameServer.Log(string.Format("Respawning bot {0} as {1}", character.Info.Name, characterInfos[i].Job.Name), ServerLog.MessageType.Spawning);
+                }
+                else
+                {
+                    clients[i].Character = character;
+                    character.OwnerClientIP = clients[i].Connection.RemoteEndPoint.Address.ToString();
+                    character.OwnerClientName = clients[i].Name;
+                    GameServer.Log(string.Format("Respawning {0} ({1}) as {2}", clients[i].Name, clients[i].Connection?.RemoteEndPoint?.Address, characterInfos[i].Job.Name), ServerLog.MessageType.Spawning);
+                }
+
+                if (divingSuitPrefab != null && oxyPrefab != null && respawnShuttle != null)
+                {
+                    Vector2 pos = cargoSp == null ? character.Position : cargoSp.Position;
+                    if (divingSuitPrefab != null && oxyPrefab != null)
+                    {
+                        var divingSuit = new Item(divingSuitPrefab, pos, respawnSub);
+                        Spawner.CreateNetworkEvent(divingSuit, false);
+                        respawnItems.Add(divingSuit);
+
+                        var oxyTank = new Item(oxyPrefab, pos, respawnSub);
+                        Spawner.CreateNetworkEvent(oxyTank, false);
+                        divingSuit.Combine(oxyTank);
+                        respawnItems.Add(oxyTank);
+                    }
+
+                    if (scooterPrefab != null && batteryPrefab != null)
+                    {
+                        var scooter = new Item(scooterPrefab, pos, respawnSub);
+                        Spawner.CreateNetworkEvent(scooter, false);
+
+                        var battery = new Item(batteryPrefab, pos, respawnSub);
+                        Spawner.CreateNetworkEvent(battery, false);
+
+                        scooter.Combine(battery);
+                        respawnItems.Add(scooter);
+                        respawnItems.Add(battery);
+                    }
+                }
+
+                //give the character the items they would've gotten if they had spawned in the main sub
+                character.GiveJobItems(mainSubSpawnPoints[i]);
+
+                //add the ID card tags they should've gotten when spawning in the shuttle
+                foreach (Item item in character.Inventory.Items)
+                {
+                    if (item == null || item.Prefab.Name != "ID Card") continue;
+                    foreach (string s in shuttleSpawnPoints[i].IdCardTags)
+                    {
+                        item.AddTag(s);
+                    }
+                    if (!string.IsNullOrWhiteSpace(shuttleSpawnPoints[i].IdCardDesc))
+                        item.Description = shuttleSpawnPoints[i].IdCardDesc;
+                }
+            }
+
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/SteamManager.cs

@@ -0,0 +1,103 @@
+using Facepunch.Steamworks;
+using System.Linq;
+
+namespace Barotrauma.Steam
+{
+    partial class SteamManager
+    {
+        #region Server
+
+        public static bool CreateServer(Networking.GameServer server, bool isPublic)
+        {
+            Instance.isInitialized = true;
+
+            ServerInit options = new ServerInit("Barotrauma", "Barotrauma")
+            {
+                GamePort = (ushort)server.Port,
+                QueryPort = (ushort)server.QueryPort
+            };
+            //options.QueryShareGamePort();
+
+            instance.server = new Server(AppID, options, isPublic);
+            if (!instance.server.IsValid)
+            {
+                instance.server.Dispose();
+                instance.server = null;
+                DebugConsole.ThrowError("Initializing Steam server failed.");
+                return false;
+            }
+
+            RefreshServerDetails(server);
+
+            instance.server.Auth.OnAuthChange = server.OnAuthChange;
+            Instance.server.LogOnAnonymous();
+
+            return true;
+        }
+
+        public static bool RefreshServerDetails(Networking.GameServer server)
+        {
+            if (instance == null || !instance.isInitialized)
+            {
+                return false;
+            }
+
+            // These server state variables may be changed at any time.  Note that there is no longer a mechanism
+            // to send the player count.  The player count is maintained by steam and you should use the player
+            // creation/authentication functions to maintain your player count.
+            instance.server.ServerName = server.Name;
+            instance.server.MaxPlayers = server.ServerSettings.MaxPlayers;
+            instance.server.Passworded = server.ServerSettings.HasPassword;
+            Instance.server.SetKey("message", GameMain.Server.ServerSettings.ServerMessageText);
+            Instance.server.SetKey("version", GameMain.Version.ToString());
+            Instance.server.SetKey("contentpackage", string.Join(",", GameMain.Config.SelectedContentPackages.Select(cp => cp.Name)));
+            Instance.server.SetKey("contentpackagehash", string.Join(",", GameMain.Config.SelectedContentPackages.Select(cp => cp.MD5hash.Hash)));
+            Instance.server.SetKey("contentpackageurl", string.Join(",", GameMain.Config.SelectedContentPackages.Select(cp => cp.SteamWorkshopUrl ?? "")));
+            Instance.server.SetKey("usingwhitelist", (server.ServerSettings.Whitelist != null && server.ServerSettings.Whitelist.Enabled).ToString());
+            Instance.server.SetKey("modeselectionmode", server.ServerSettings.ModeSelectionMode.ToString());
+            Instance.server.SetKey("subselectionmode", server.ServerSettings.SubSelectionMode.ToString());
+            Instance.server.SetKey("allowspectating", server.ServerSettings.AllowSpectating.ToString());
+            Instance.server.SetKey("allowrespawn", server.ServerSettings.AllowRespawn.ToString());
+            Instance.server.SetKey("traitors", server.ServerSettings.TraitorsEnabled.ToString());
+            Instance.server.SetKey("gamestarted", server.GameStarted.ToString());
+            Instance.server.SetKey("gamemode", server.ServerSettings.GameModeIdentifier);
+            
+            instance.server.DedicatedServer = true;
+
+            return true;
+        }
+
+        public static bool StartAuthSession(byte[] authTicketData, ulong clientSteamID)
+        {
+            if (instance == null || !instance.isInitialized || instance.server == null) return false;
+
+            DebugConsole.Log("SteamManager authenticating Steam client " + clientSteamID);
+            if (!instance.server.Auth.StartSession(authTicketData, clientSteamID))
+            {
+                DebugConsole.Log("Authentication failed");
+                return false;
+            }
+            return true;
+        }
+
+        public static void StopAuthSession(ulong clientSteamID)
+        {
+            if (instance == null || !instance.isInitialized || instance.server == null) return;
+
+            DebugConsole.Log("SteamManager ending auth session with Steam client " + clientSteamID);
+            instance.server.Auth.EndSession(clientSteamID);
+        }
+
+        public static bool CloseServer()
+        {
+            if (instance == null || !instance.isInitialized || instance.server == null) return false;
+
+            instance.server.Dispose();
+            instance.server = null;
+
+            return true;
+        }
+
+        #endregion
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/Voip/VoipServer.cs

@@ -0,0 +1,100 @@
+using Barotrauma.Items.Components;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Barotrauma.Networking
+{
+    class VoipServer
+    {
+        private NetServer netServer;
+        private List<VoipQueue> queues;
+        private Dictionary<VoipQueue,DateTime> lastSendTime;
+
+        public VoipServer(NetServer server)
+        {
+            this.netServer = server;
+            queues = new List<VoipQueue>();
+            lastSendTime = new Dictionary<VoipQueue, DateTime>();
+        }
+
+        public void RegisterQueue(VoipQueue queue)
+        {
+            if (!queues.Contains(queue)) queues.Add(queue);
+        }
+
+        public void UnregisterQueue(VoipQueue queue)
+        {
+            if (queues.Contains(queue)) queues.Remove(queue);
+        }
+
+        public void SendToClients(List<Client> clients)
+        {
+            foreach (VoipQueue queue in queues)
+            {
+                if (queue.LastReadTime < DateTime.Now - VoipConfig.SEND_INTERVAL) { continue; }
+
+                if (lastSendTime.ContainsKey(queue))
+                {
+                    if ((lastSendTime[queue] + VoipConfig.SEND_INTERVAL) > DateTime.Now) { continue; }
+                    lastSendTime[queue] = DateTime.Now;
+                }
+                else
+                {
+                    lastSendTime.Add(queue, DateTime.Now);
+                }
+
+                Client sender = clients.Find(c => c.VoipQueue == queue);
+
+                foreach (Client recipient in clients)
+                {
+                    if (recipient == sender) { continue; }
+
+                    if (!CanReceive(sender, recipient)) { continue; }
+
+                    NetOutgoingMessage msg = netServer.CreateMessage();
+
+                    msg.Write((byte)ServerPacketHeader.VOICE);
+                    msg.Write((byte)queue.QueueID);
+                    queue.Write(msg);
+
+                    GameMain.Server.CompressOutgoingMessage(msg);
+
+                    netServer.SendMessage(msg, recipient.Connection, NetDeliveryMethod.Unreliable);
+                }
+            }
+        }
+
+        private bool CanReceive(Client sender, Client recipient)
+        {
+            if (Screen.Selected != GameMain.GameScreen) { return true; }
+
+            //no-one can hear muted players
+            if (sender.Muted) { return false; }
+
+            bool recipientSpectating = recipient.Character == null || recipient.Character.IsDead;
+            bool senderSpectating = sender.Character == null || sender.Character.IsDead;
+
+            //spectators cannot speak with in-game players or vice versa
+            if (recipientSpectating != senderSpectating) { return false; }
+
+            //both spectating, no need to do radio/distance checks
+            if (recipientSpectating && senderSpectating) { return true; }
+
+            //sender can't speak
+            if (sender.Character != null && sender.Character.SpeechImpediment >= 100.0f) { return false; }
+
+            //check if the message can be sent via radio
+            if (ChatMessage.CanUseRadio(sender.Character, out WifiComponent senderRadio) && 
+                ChatMessage.CanUseRadio(recipient.Character, out WifiComponent recipientRadio))
+            {
+                if (recipientRadio.CanReceive(senderRadio)) { return true; }
+            }
+
+            //otherwise do a distance check
+            return ChatMessage.GetGarbleAmount(recipient.Character, sender.Character, ChatMessage.SpeakRange) < 1.0f;
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Networking/Voting.cs

@@ -1,4 +1,10 @@
-namespace Barotrauma
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma
 {
     partial class Voting
     {
@@ -12,6 +18,118 @@
             get { return allowModeVoting; }
             set { allowModeVoting = value; }
         }
-        
+
+        public void ServerRead(NetIncomingMessage inc, Client sender)
+        {
+            if (GameMain.Server == null || sender == null) return;
+
+            byte voteTypeByte = inc.ReadByte();
+            VoteType voteType = VoteType.Unknown;
+            try
+            {
+                voteType = (VoteType)voteTypeByte;
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Failed to cast vote type \"" + voteTypeByte + "\"", e);
+                return;
+            }
+
+            switch (voteType)
+            {
+                case VoteType.Sub:
+                    string subName = inc.ReadString();
+                    Submarine sub = Submarine.SavedSubmarines.FirstOrDefault(s => s.Name == subName);
+                    sender.SetVote(voteType, sub);
+                    break;
+
+                case VoteType.Mode:
+                    string modeIdentifier = inc.ReadString();
+                    GameModePreset mode = GameModePreset.List.Find(gm => gm.Identifier == modeIdentifier);
+                    if (!mode.Votable) break;
+
+                    sender.SetVote(voteType, mode);
+                    break;
+                case VoteType.EndRound:
+                    if (!sender.HasSpawned) return;
+                    sender.SetVote(voteType, inc.ReadBoolean());
+
+                    GameMain.NetworkMember.EndVoteCount = GameMain.Server.ConnectedClients.Count(c => c.HasSpawned && c.GetVote<bool>(VoteType.EndRound));
+                    GameMain.NetworkMember.EndVoteMax = GameMain.Server.ConnectedClients.Count(c => c.HasSpawned);
+
+                    break;
+                case VoteType.Kick:
+                    byte kickedClientID = inc.ReadByte();
+
+                    Client kicked = GameMain.Server.ConnectedClients.Find(c => c.ID == kickedClientID);
+                    if (kicked != null && !kicked.HasKickVoteFrom(sender))
+                    {
+                        kicked.AddKickVote(sender);
+                        Client.UpdateKickVotes(GameMain.Server.ConnectedClients);
+
+                        GameMain.Server.SendChatMessage($"ServerMessage.HasVotedToKick_[initiator]={sender.Name}_[target]={kicked.Name}", ChatMessageType.Server, null);
+                    }
+
+                    break;
+                case VoteType.StartRound:
+                    bool ready = inc.ReadBoolean();
+                    if (ready != sender.GetVote<bool>(VoteType.StartRound))
+                    {
+                        sender.SetVote(VoteType.StartRound, ready);
+                        GameServer.Log(sender.Name + (ready ? " is ready to start the game." : " is not ready to start the game."), ServerLog.MessageType.ServerMessage);
+                    }
+
+                    break;
+            }
+
+            inc.ReadPadBits();
+
+            GameMain.Server.UpdateVoteStatus();
+        }
+
+        public void ServerWrite(NetBuffer msg)
+        {
+            if (GameMain.Server == null) return;
+
+            msg.Write(allowSubVoting);
+            if (allowSubVoting)
+            {
+                List<Pair<object, int>> voteList = GetVoteList(VoteType.Sub, GameMain.Server.ConnectedClients);
+                msg.Write((byte)voteList.Count);
+                foreach (Pair<object, int> vote in voteList)
+                {
+                    msg.Write((byte)vote.Second);
+                    msg.Write(((Submarine)vote.First).Name);
+                }
+            }
+            msg.Write(AllowModeVoting);
+            if (allowModeVoting)
+            {
+                List<Pair<object, int>> voteList = GetVoteList(VoteType.Mode, GameMain.Server.ConnectedClients);
+                msg.Write((byte)voteList.Count);
+                foreach (Pair<object, int> vote in voteList)
+                {
+                    msg.Write((byte)vote.Second);
+                    msg.Write(((GameModePreset)vote.First).Identifier);
+                }
+            }
+            msg.Write(AllowEndVoting);
+            if (AllowEndVoting)
+            {
+                msg.Write((byte)GameMain.Server.ConnectedClients.Count(v => v.GetVote<bool>(VoteType.EndRound)));
+                msg.Write((byte)GameMain.Server.ConnectedClients.Count);
+            }
+
+            msg.Write(AllowVoteKick);
+
+            var readyClients = GameMain.Server.ConnectedClients.FindAll(c => c.GetVote<bool>(VoteType.StartRound));
+            msg.Write((byte)readyClients.Count);
+            foreach (Client c in readyClients)
+            {
+                msg.Write(c.ID);
+            }
+
+            msg.WritePadBits();
+        }
     }
 }

Barotrauma/BarotraumaServer/Source/Networking/WhiteList.cs

@@ -0,0 +1,209 @@
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+
+namespace Barotrauma.Networking
+{
+    partial class WhiteListedPlayer
+    {
+        private static UInt16 LastIdentifier = 0;
+
+        public WhiteListedPlayer(string name,string ip)
+        {
+            Name = name;
+            IP = ip;
+
+            UniqueIdentifier = LastIdentifier; LastIdentifier++;
+        }
+    }
+
+    partial class WhiteList
+    {
+        partial void InitProjSpecific()
+        {
+            if (File.Exists(SavePath))
+            {
+                string[] lines;
+                try
+                {
+                    lines = File.ReadAllLines(SavePath);
+                }
+                catch (Exception e)
+                {
+                    DebugConsole.ThrowError("Failed to open whitelist in " + SavePath, e);
+                    return;
+                }
+
+                foreach (string line in lines)
+                {
+                    if (line[0] == '#')
+                    {
+                        string lineval = line.Substring(1, line.Length - 1);
+                        int intVal = 0;
+                        Int32.TryParse(lineval, out intVal);
+                        if (lineval.ToLower() == "true" || intVal != 0)
+                        {
+                            Enabled = true;
+                        }
+                        else
+                        {
+                            Enabled = false;
+                        }
+                    }
+                    else
+                    {
+                        string[] separatedLine = line.Split(',');
+                        if (separatedLine.Length < 2) continue;
+
+                        string name = String.Join(",", separatedLine.Take(separatedLine.Length - 1));
+                        string ip = separatedLine.Last();
+
+                        whitelistedPlayers.Add(new WhiteListedPlayer(name, ip));
+                    }
+                }
+            }
+        }
+
+        public void Save()
+        {
+            GameServer.Log("Saving whitelist", ServerLog.MessageType.ServerMessage);
+
+            List<string> lines = new List<string>();
+
+            if (Enabled)
+            {
+                lines.Add("#true");
+            }
+            else
+            {
+                lines.Add("#false");
+            }
+            foreach (WhiteListedPlayer wlp in whitelistedPlayers)
+            {
+                lines.Add(wlp.Name + "," + wlp.IP);
+            }
+
+            try
+            {
+                File.WriteAllLines(SavePath, lines);
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Saving the whitelist to " + SavePath + " failed", e);
+            }
+        }
+
+        public bool IsWhiteListed(string name, IPAddress address)
+        {
+            if (!Enabled) return true;
+            WhiteListedPlayer wlp = whitelistedPlayers.Find(p => p.Name == name);
+            if (wlp == null) return false;
+            if (!string.IsNullOrWhiteSpace(wlp.IP))
+            {
+                if (address.IsIPv4MappedToIPv6 && wlp.IP == address.MapToIPv4().ToString())
+                {
+                    return true;
+                }
+                else
+                {
+                    return wlp.IP == address.ToString();
+                }
+            }
+            return true;
+        }
+
+        private void RemoveFromWhiteList(WhiteListedPlayer wlp)
+        {
+            GameServer.Log("Removing " + wlp.Name + " from whitelist", ServerLog.MessageType.ServerMessage);
+
+            whitelistedPlayers.Remove(wlp);
+            Save();
+        }
+
+        private void AddToWhiteList(string name, string ip)
+        {
+            if (string.IsNullOrWhiteSpace(name)) return;
+            if (whitelistedPlayers.Any(x => x.Name.ToLower() == name.ToLower() && x.IP == ip)) return;
+            whitelistedPlayers.Add(new WhiteListedPlayer(name, ip));
+            Save();
+        }
+
+        public void ServerAdminWrite(NetBuffer outMsg, Client c)
+        {
+            if (!c.HasPermission(ClientPermissions.ManageSettings))
+            {
+                outMsg.Write(false); outMsg.WritePadBits();
+                return;
+            }
+            outMsg.Write(true);
+            outMsg.Write(c.Connection == GameMain.Server.OwnerConnection);
+            outMsg.Write(Enabled);
+
+            outMsg.WritePadBits();
+            outMsg.WriteVariableInt32(whitelistedPlayers.Count);
+            for (int i = 0; i < whitelistedPlayers.Count; i++)
+            {
+                WhiteListedPlayer whitelistedPlayer = whitelistedPlayers[i];
+
+                outMsg.Write(whitelistedPlayer.Name);
+                outMsg.Write(whitelistedPlayer.UniqueIdentifier);
+                if (c.Connection == GameMain.Server.OwnerConnection)
+                {
+                    outMsg.Write(whitelistedPlayer.IP);
+                    //outMsg.Write(whitelistedPlayer.SteamID); //TODO: add steamid to whitelisted players
+                }
+            }
+        }
+
+        public bool ServerAdminRead(NetBuffer incMsg, Client c)
+        {
+            if (!c.HasPermission(ClientPermissions.ManageSettings))
+            {
+                bool enabled = incMsg.ReadBoolean(); incMsg.ReadPadBits();
+                UInt16 removeCount = incMsg.ReadUInt16();
+                incMsg.Position += removeCount * 4 * 8;
+                UInt16 addCount = incMsg.ReadUInt16();
+                for (int i = 0; i < addCount; i++)
+                {
+                    incMsg.ReadString(); //skip name
+                    incMsg.ReadString(); //skip ip
+                }
+                return false;
+            }
+            else
+            {
+                bool prevEnabled = Enabled;
+                bool enabled = incMsg.ReadBoolean(); incMsg.ReadPadBits();
+                Enabled = enabled;
+                
+                UInt16 removeCount = incMsg.ReadUInt16();
+                for (int i = 0; i < removeCount; i++)
+                {
+                    UInt16 id = incMsg.ReadUInt16();
+                    WhiteListedPlayer whitelistedPlayer = whitelistedPlayers.Find(p => p.UniqueIdentifier == id);
+                    if (whitelistedPlayer != null)
+                    {
+                        GameServer.Log(c.Name + " removed " + whitelistedPlayer.Name + " from whitelist (" + whitelistedPlayer.IP + ")", ServerLog.MessageType.ConsoleUsage);
+                        RemoveFromWhiteList(whitelistedPlayer);
+                    }
+                }
+
+                UInt16 addCount = incMsg.ReadUInt16();
+                for (int i = 0; i < addCount; i++)
+                {
+                    string name = incMsg.ReadString();
+                    string ip = incMsg.ReadString();
+
+                    GameServer.Log(c.Name + " added " + name + " to whitelist (" + ip + ")", ServerLog.MessageType.ConsoleUsage);
+                    AddToWhiteList(name, ip);
+                }
+                
+                return removeCount > 0 || addCount > 0 || prevEnabled!=enabled;
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Physics/PhysicsBody.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma
+{
+    partial class PhysicsBody
+    {
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            float MaxVel = NetConfig.MaxPhysicsBodyVelocity;
+            float MaxAngularVel = NetConfig.MaxPhysicsBodyAngularVelocity;
+
+            msg.Write(SimPosition.X);
+            msg.Write(SimPosition.Y);
+
+#if DEBUG
+            if (Math.Abs(body.LinearVelocity.X) > MaxVel || 
+                Math.Abs(body.LinearVelocity.Y) > MaxVel)
+            {
+                DebugConsole.ThrowError("Item velocity out of range (" + body.LinearVelocity + ")");
+            }
+#endif
+
+            msg.Write(FarseerBody.Awake);
+            msg.Write(FarseerBody.FixedRotation);
+
+            if (!FarseerBody.FixedRotation)
+            {
+                msg.WriteRangedSingle(MathUtils.WrapAngleTwoPi(body.Rotation), 0.0f, MathHelper.TwoPi, 8);
+            }
+            if (FarseerBody.Awake)
+            {
+                body.Enabled = true;
+                msg.WriteRangedSingle(MathHelper.Clamp(body.LinearVelocity.X, -MaxVel, MaxVel), -MaxVel, MaxVel, 12);
+                msg.WriteRangedSingle(MathHelper.Clamp(body.LinearVelocity.Y, -MaxVel, MaxVel), -MaxVel, MaxVel, 12);
+                if (!FarseerBody.FixedRotation)
+                {
+                    msg.WriteRangedSingle(MathHelper.Clamp(body.AngularVelocity, -MaxAngularVel, MaxAngularVel), -MaxAngularVel, MaxAngularVel, 8);
+                }
+            }
+
+            msg.WritePadBits();
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/PlayerInput.cs

@@ -96,6 +96,36 @@ namespace Barotrauma
             return false;
         }
 
+        public static bool Mouse4ButtonClicked()
+        {
+            return false;
+        }
+
+        public static bool Mouse4ButtonHeld()
+        {
+            return false;
+        }
+
+        public static bool Mouse5ButtonClicked()
+        {
+            return false;
+        }
+
+        public static bool Mouse5ButtonHeld()
+        {
+            return false;
+        }
+
+        public static bool MouseWheelUpClicked()
+        {
+            return false;
+        }
+
+        public static bool MouseWheelDownClicked()
+        {
+            return false;
+        }
+
         public static bool DoubleClicked()
         {
             return false;
@@ -133,7 +163,7 @@ namespace Barotrauma
 
         public static void Update(double deltaTime)
         {
-            
+
         }
 
         public static void UpdateVariable()

Barotrauma/BarotraumaServer/Source/Program.cs

@@ -21,26 +21,30 @@ namespace Barotrauma
         /// The main entry point for the application.
         /// </summary>
         [STAThread]
-        static void Main()
+        static void Main(string[] args)
         {
             GameMain game = null;
             Thread inputThread = null;
-            
+
+#if !DEBUG
             try
             {
-                game = new GameMain();
-                inputThread = new Thread(new ThreadStart(game.ProcessInput));
+#endif
+                game = new GameMain(args);
+                inputThread = new Thread(new ThreadStart(DebugConsole.UpdateCommandLine));
                 inputThread.Start();
                 game.Run();
                 inputThread.Abort(); inputThread.Join();
                 if (GameSettings.SendUserStatistics) GameAnalytics.OnStop();
                 SteamManager.ShutDown();
+#if !DEBUG
             }
             catch (Exception e)
             {
                 CrashDump(game, "servercrashreport.log", e);
                 inputThread.Abort(); inputThread.Join();
             }
+#endif
         }
         
         static void CrashDump(GameMain game, string filePath, Exception exception)

Barotrauma/BarotraumaServer/Source/Screens/NetLobbyScreen.cs

@@ -66,8 +66,6 @@ namespace Barotrauma
             get { return gameModes[SelectedModeIndex]; }
         }
 
-        public string ServerMessageText;
-
         private int missionTypeIndex;
         public int MissionTypeIndex
         {
@@ -93,12 +91,12 @@ namespace Barotrauma
 
         public void ChangeServerName(string n)
         {
-            ServerName = n; lastUpdateID++;
+            GameMain.Server.ServerSettings.ServerName = n; lastUpdateID++;
         }
 
         public void ChangeServerMessage(string m)
         {
-            ServerMessageText = m; lastUpdateID++;
+            GameMain.Server.ServerSettings.ServerMessageText = m; lastUpdateID++;
         }
         
         public List<JobPrefab> JobPreferences
@@ -150,13 +148,7 @@ namespace Barotrauma
                 LocationType.Random(levelSeed); //call to sync up with clients
             }
         }
-
-        public bool StartButtonEnabled
-        {
-            get { return true; }
-            set { /* do nothing */ }
-        }
-
+        
         public void ToggleCampaignMode(bool enabled)
         {
             for (int i = 0; i < GameModes.Length; i++)
@@ -174,19 +166,19 @@ namespace Barotrauma
         public override void Select()
         {
             base.Select();
-            GameMain.Server.Voting.ResetVotes(GameMain.Server.ConnectedClients);
+            GameMain.Server.ServerSettings.Voting.ResetVotes(GameMain.Server.ConnectedClients);
         }
 
         public void RandomizeSettings()
         {
-            if (GameMain.Server.RandomizeSeed) LevelSeed = ToolBox.RandomSeed(8);
+            if (GameMain.Server.ServerSettings.RandomizeSeed) LevelSeed = ToolBox.RandomSeed(8);
 
-            if (GameMain.Server.SubSelectionMode == SelectionMode.Random)
+            if (GameMain.Server.ServerSettings.SubSelectionMode == SelectionMode.Random)
             {
                 var nonShuttles = Submarine.SavedSubmarines.Where(c => !c.HasTag(SubmarineTag.Shuttle) && !c.HasTag(SubmarineTag.HideInMenus)).ToList();
                 SelectedSub = nonShuttles[Rand.Range(0, nonShuttles.Count)];
             }
-            if (GameMain.Server.ModeSelectionMode == SelectionMode.Random)
+            if (GameMain.Server.ServerSettings.ModeSelectionMode == SelectionMode.Random)
             {
                 var allowedGameModes = Array.FindAll(gameModes, m => !m.IsSinglePlayer && m.Identifier != "multiplayercampaign");
                 SelectedModeIdentifier = allowedGameModes[Rand.Range(0, allowedGameModes.Length)].Identifier;

Barotrauma/BarotraumaServer/Source/Utils/XnaToConsoleColor.cs

@@ -12,22 +12,24 @@ namespace Barotrauma
         {
             if (dictionary == null)
             {
-                dictionary = new Dictionary<Color, ConsoleColor>();
-                dictionary.Add(Color.White, ConsoleColor.White);
-                dictionary.Add(Color.Gray, ConsoleColor.Gray);
-                dictionary.Add(Color.LightGray, ConsoleColor.Gray);
-                dictionary.Add(Color.DarkGray, ConsoleColor.Gray);
-                dictionary.Add(Color.Red, ConsoleColor.Red);
-                dictionary.Add(Color.DarkRed, ConsoleColor.DarkRed);
-                dictionary.Add(Color.Yellow, ConsoleColor.Yellow);
-                dictionary.Add(Color.Orange, ConsoleColor.Yellow);
-                dictionary.Add(Color.Green, ConsoleColor.Green);
-                dictionary.Add(Color.Lime, ConsoleColor.Green);
-                dictionary.Add(Color.Blue, ConsoleColor.Blue);
-                dictionary.Add(Color.Cyan, ConsoleColor.Cyan);
-                dictionary.Add(Color.DarkBlue, ConsoleColor.DarkBlue);
-                dictionary.Add(Color.Pink, ConsoleColor.Magenta);
-                dictionary.Add(Color.Magenta, ConsoleColor.Magenta);
+                dictionary = new Dictionary<Color, ConsoleColor>
+                {
+                    { Color.White, ConsoleColor.White },
+                    { Color.Gray, ConsoleColor.Gray },
+                    { Color.LightGray, ConsoleColor.Gray },
+                    { Color.DarkGray, ConsoleColor.Gray },
+                    { Color.Red, ConsoleColor.Red },
+                    { Color.DarkRed, ConsoleColor.DarkRed },
+                    { Color.Yellow, ConsoleColor.Yellow },
+                    { Color.Orange, ConsoleColor.Yellow },
+                    { Color.Green, ConsoleColor.Green },
+                    { Color.Lime, ConsoleColor.Green },
+                    { Color.Blue, ConsoleColor.Blue },
+                    { Color.Cyan, ConsoleColor.Cyan },
+                    { Color.DarkBlue, ConsoleColor.DarkBlue },
+                    { Color.Pink, ConsoleColor.Magenta },
+                    { Color.Magenta, ConsoleColor.Magenta }
+                };
             }
 
             ConsoleColor val = ConsoleColor.White;
@@ -35,8 +37,48 @@ namespace Barotrauma
             {
                 return val;
             }
+            
+            return GetClosestConsoleColor(xnaCol);
+        }
 
-            return ConsoleColor.White;
+        public static ConsoleColor GetClosestConsoleColor(Color color)
+        {
+            Vector3 hls = ToolBox.RgbToHLS(color.ToVector3());
+            if (hls.Z < 0.5)
+            {
+                // we have a grayish color
+                switch ((int)(hls.Y * 3.5))
+                {
+                    case 0: return ConsoleColor.Black;
+                    case 1: return ConsoleColor.DarkGray;
+                    case 2: return ConsoleColor.Gray;
+                    default: return ConsoleColor.White;
+                }
+            }
+            int hue = (int)Math.Round(hls.X / 60, MidpointRounding.AwayFromZero);
+            if (hls.Y < 0.4)
+            {
+                // dark color
+                switch (hue)
+                {
+                    case 1: return ConsoleColor.DarkYellow;
+                    case 2: return ConsoleColor.DarkGreen;
+                    case 3: return ConsoleColor.DarkCyan;
+                    case 4: return ConsoleColor.DarkBlue;
+                    case 5: return ConsoleColor.DarkMagenta;
+                    default: return ConsoleColor.DarkRed;
+                }
+            }
+            // bright color
+            switch (hue)
+            {
+                case 1: return ConsoleColor.Yellow;
+                case 2: return ConsoleColor.Green;
+                case 3: return ConsoleColor.Cyan;
+                case 4: return ConsoleColor.Blue;
+                case 5: return ConsoleColor.Magenta;
+                default: return ConsoleColor.Red;
+            }
         }
     }
 }