2f107db...5202af9

Barotrauma/BarotraumaClient/Source/Map/Gap.cs

@@ -16,14 +16,17 @@ namespace Barotrauma
             }
         }
 
+        public override bool IsVisible(Rectangle worldView)
+        {
+            return Screen.Selected == GameMain.SubEditorScreen || GameMain.DebugDraw;
+        }
+
         public override void Draw(SpriteBatch sb, bool editing, bool back = true)
         {
             if (GameMain.DebugDraw)
             {
                 Vector2 center = new Vector2(WorldRect.X + rect.Width / 2.0f, -(WorldRect.Y - rect.Height / 2.0f));
-
                 GUI.DrawLine(sb, center, center + new Vector2(flowForce.X, -flowForce.Y) / 10.0f, Color.Red);
-
                 GUI.DrawLine(sb, center + Vector2.One * 5.0f, center + new Vector2(lerpedFlowForce.X, -lerpedFlowForce.Y) / 10.0f + Vector2.One * 5.0f, Color.Orange);
             }
 

Barotrauma/BarotraumaClient/Source/Map/Hull.cs

@@ -7,15 +7,21 @@ using System;
 using System.Collections.Generic;
 using Microsoft.Xna.Framework.Input;
 using System.Linq;
+using Lidgren.Network;
 
 namespace Barotrauma
 {
-    partial class Hull : MapEntity, ISerializableEntity, IServerSerializable
+    partial class Hull : MapEntity, ISerializableEntity, IServerSerializable, IClientSerializable
     {
         public const int MaxDecalsPerHull = 10;
         
         private List<Decal> decals = new List<Decal>();
 
+        private float serverUpdateDelay;
+
+        private bool networkUpdatePending;
+        private float networkUpdateTimer;
+
         public override bool SelectableInEditor
         {
             get
@@ -39,7 +45,20 @@ namespace Barotrauma
                 return true;
             }
         }
-        
+
+        public override bool IsVisible(Rectangle worldView)
+        {
+            if (Screen.Selected != GameMain.SubEditorScreen && !GameMain.DebugDraw)
+            {
+                if (decals.Count == 0) { return false; }
+
+                Rectangle worldRect = WorldRect;
+                if (worldRect.X > worldView.Right || worldRect.Right < worldView.X) { return false; }
+                if (worldRect.Y < worldView.Y - worldView.Height || worldRect.Y - worldRect.Height > worldView.Y) { return false; }
+            }
+            return true;
+        }
+
         public override bool IsMouseOn(Vector2 position)
         {
             if (!GameMain.DebugDraw && !ShowHulls) return false;
@@ -118,6 +137,19 @@ namespace Barotrauma
 
         partial void UpdateProjSpecific(float deltaTime, Camera cam)
         {
+            serverUpdateDelay -= deltaTime;
+
+            if (networkUpdatePending)
+            {
+                networkUpdateTimer += deltaTime;
+                if (networkUpdateTimer > 0.2f)
+                {
+                    GameMain.NetworkMember?.CreateEntityEvent(this);
+                    networkUpdatePending = false;
+                    networkUpdateTimer = 0.0f;
+                }
+            }
+
             if (EditWater)
             {
                 Vector2 position = cam.ScreenToWorld(PlayerInput.MousePosition);
@@ -126,10 +158,14 @@ namespace Barotrauma
                     if (PlayerInput.LeftButtonHeld())
                     {
                         WaterVolume += 1500.0f;
+                        networkUpdatePending = true;
+                        serverUpdateDelay = 0.5f;
                     }
                     else if (PlayerInput.RightButtonHeld())
                     {
                         WaterVolume -= 1500.0f;
+                        networkUpdatePending = true;
+                        serverUpdateDelay = 0.5f;
                     }
                 }
             }
@@ -140,7 +176,9 @@ namespace Barotrauma
                 {
                     if (PlayerInput.LeftButtonClicked())
                     {
-                        new FireSource(position, this);
+                        new FireSource(position, this, isNetworkMessage: true);
+                        networkUpdatePending = true;
+                        serverUpdateDelay = 0.5f;
                     }
                 }
             }
@@ -189,8 +227,7 @@ namespace Barotrauma
                 return;
             }
 
-            Rectangle drawRect;
-            if (!Visible)
+            /*if (!Visible)
             {
                 drawRect =
                     Submarine == null ? rect : new Rectangle((int)(Submarine.DrawPosition.X + rect.X), (int)(Submarine.DrawPosition.Y + rect.Y), rect.Width, rect.Height);
@@ -200,7 +237,7 @@ namespace Barotrauma
                     new Vector2(rect.Width, rect.Height),
                     Color.Black, true,
                     0, (int)Math.Max((1.5f / GameScreen.Selected.Cam.Zoom), 1.0f));
-            }
+            }*/
 
             if (!ShowHulls && !GameMain.DebugDraw) return;
 
@@ -208,7 +245,7 @@ namespace Barotrauma
 
             if (aiTarget != null) aiTarget.Draw(spriteBatch);
 
-            drawRect =
+           Rectangle drawRect =
                 Submarine == null ? rect : new Rectangle((int)(Submarine.DrawPosition.X + rect.X), (int)(Submarine.DrawPosition.Y + rect.Y), rect.Width, rect.Height);
 
             GUI.DrawRectangle(spriteBatch,
@@ -483,6 +520,84 @@ namespace Barotrauma
                     width -= (int)Math.Max((x + WaveWidth) - (Submarine == null ? rect.Right : (rect.Right + Submarine.DrawPosition.X)), 0);
                 }
             }
+        }
+
+        public void ClientWrite(NetBuffer msg, object[] extraData = null)
+        {
+            msg.WriteRangedSingle(MathHelper.Clamp(waterVolume / Volume, 0.0f, 1.5f), 0.0f, 1.5f, 8);
+
+            msg.Write(FireSources.Count > 0);
+            if (FireSources.Count > 0)
+            {
+                msg.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);
+
+                    msg.WriteRangedSingle(MathHelper.Clamp(normalizedPos.X, 0.0f, 1.0f), 0.0f, 1.0f, 8);
+                    msg.WriteRangedSingle(MathHelper.Clamp(normalizedPos.Y, 0.0f, 1.0f), 0.0f, 1.0f, 8);
+                    msg.WriteRangedSingle(MathHelper.Clamp(fireSource.Size.X / rect.Width, 0.0f, 1.0f), 0, 1.0f, 8);
+                }
+            }
+        }
+
+        public void ClientRead(ServerNetObject type, NetBuffer message, float sendingTime)
+        {
+            float newWaterVolume = message.ReadRangedSingle(0.0f, 1.5f, 8) * Volume;
+            float newOxygenPercentage = message.ReadRangedSingle(0.0f, 100.0f, 8);
+
+            bool hasFireSources = message.ReadBoolean();
+            int fireSourceCount = 0;
+            List<Vector3> newFireSources = new List<Vector3>();
+            if (hasFireSources)
+            {
+                fireSourceCount = message.ReadRangedInteger(0, 16);
+                for (int i = 0; i < fireSourceCount; i++)
+                {
+                    newFireSources.Add(new Vector3(
+                        MathHelper.Clamp(message.ReadRangedSingle(0.0f, 1.0f, 8), 0.05f, 0.95f),
+                        MathHelper.Clamp(message.ReadRangedSingle(0.0f, 1.0f, 8), 0.05f, 0.95f),
+                        message.ReadRangedSingle(0.0f, 1.0f, 8)));
+                }
+            }
+
+            if (serverUpdateDelay > 0.0f) { return; }
+
+            WaterVolume = newWaterVolume;
+            OxygenPercentage = newOxygenPercentage;
+            
+            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/BarotraumaClient/Source/Map/Levels/Level.cs

@@ -93,8 +93,6 @@ namespace Barotrauma
         
         public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
         {
-            if (GameMain.Server != null) return;
-
             foreach (LevelWall levelWall in extraWalls)
             {
                 if (levelWall.Body.BodyType == BodyType.Static) continue;

Barotrauma/BarotraumaClient/Source/Map/Levels/LevelObjects/LevelObject.cs

@@ -194,6 +194,7 @@ namespace Barotrauma
 
             for (int i = 0; i < Sounds.Length; i++)
             {
+                if (Sounds[i] == null) { continue; }
                 if (SoundTriggers[i] == null || SoundTriggers[i].IsTriggered)
                 {
                     RoundSound roundSound = Sounds[i];

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

@@ -322,8 +322,14 @@ namespace Barotrauma
 
             Matrix transformMatrix = cam.ShaderTransform
                 * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 100) * 0.5f;
-                        
+
+            wallEdgeEffect.Texture = specular && level.GenerationParams.WallEdgeSpriteSpecular != null ?
+                level.GenerationParams.WallEdgeSpriteSpecular.Texture :
+                level.GenerationParams.WallEdgeSprite.Texture;
             wallEdgeEffect.World = transformMatrix;
+            wallCenterEffect.Texture = specular && level.GenerationParams.WallSpriteSpecular != null ?
+                level.GenerationParams.WallSpriteSpecular.Texture :
+                level.GenerationParams.WallSprite.Texture;
             wallCenterEffect.World = transformMatrix;
             
             graphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;

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

@@ -34,8 +34,8 @@ namespace Barotrauma
         public const int DefaultBufferSize = 2000;
         public const int DefaultIndoorsBufferSize = 3000;
 
-        public static Vector2 DistortionScale = new Vector2(0.5f, 0.5f);
-        public static Vector2 DistortionStrength = new Vector2(0.5f, 0.5f);
+        public static Vector2 DistortionScale = new Vector2(2f, 2f);
+        public static Vector2 DistortionStrength = new Vector2(0.25f, 0.25f);
         public static float BlurAmount = 0.0f;
 
         public Vector2 WavePos
@@ -103,7 +103,6 @@ namespace Barotrauma
             }
             else
             {   WaterEffect.CurrentTechnique = WaterEffect.Techniques["WaterShader"];
-                WaterEffect.Parameters["xBlurDistance"].SetValue(BlurAmount / 100.0f);
             }
 
             Vector2 offset = WavePos;

Barotrauma/BarotraumaClient/Source/Map/Lights/LightManager.cs

@@ -20,18 +20,11 @@ namespace Barotrauma.Lights
         /// the time being because it makes the lighting behave unpredictably and may cause rooms to appear
         /// excessively bright if different lighting conditions aren't tested and accounted for.
         /// </summary>
-        private static bool UseHullSpecificAmbientLight = false;
+        private static readonly bool UseHullSpecificAmbientLight = false;
 
-        private static Entity viewTarget;
+        public static Entity ViewTarget { get; set; }
 
-        public static Entity ViewTarget
-        {
-            get { return viewTarget; }
-            set {
-                if (viewTarget == value) return;
-                viewTarget = value; 
-            }
-        }
+        private float currLightMapScale;
 
         private float currLightMapScale;
 
@@ -55,10 +48,7 @@ namespace Barotrauma.Lights
 
         private BasicEffect lightEffect;
 
-        public Effect LosEffect
-        {
-            get; private set;
-        }
+        public Effect LosEffect { get; private set; }
         
         private List<LightSource> lights;
 
@@ -99,11 +89,12 @@ namespace Barotrauma.Lights
 
             if (lightEffect == null)
             {
-                lightEffect = new BasicEffect(GameMain.Instance.GraphicsDevice);
-                lightEffect.VertexColorEnabled = true;
-
-                lightEffect.TextureEnabled = true;
-                lightEffect.Texture = LightSource.LightTexture;
+                lightEffect = new BasicEffect(GameMain.Instance.GraphicsDevice)
+                {
+                    VertexColorEnabled = true,
+                    TextureEnabled = true,
+                    Texture = LightSource.LightTexture
+                };
             }
 
             hullAmbientLights = new Dictionary<Hull, Color>();
@@ -284,11 +275,14 @@ namespace Barotrauma.Lights
                     Character.Controlled.FocusedCharacter.Draw(spriteBatch, cam);
                 }
 
-                foreach (Item item in Item.ItemList)
+                if (!GUI.DisableItemHighlights)
                 {
-                    if (item.IsHighlighted)
+                    foreach (Item item in Item.ItemList)
                     {
-                        item.Draw(spriteBatch, false, true);
+                        if (item.IsHighlighted)
+                        {
+                            item.Draw(spriteBatch, false, true);
+                        }
                     }
                 }
             }
@@ -391,7 +385,7 @@ namespace Barotrauma.Lights
             graphics.SetRenderTarget(SpecularMap);
             
             //clear the lightmap
-            graphics.Clear(Color.Gray);
+            graphics.Clear(Color.Black);
             graphics.BlendState = BlendState.AlphaBlend;
 
             spriteBatch.Begin(sortMode: SpriteSortMode.Deferred, blendState: BlendState.AlphaBlend, transformMatrix: spriteBatchTransform);
@@ -400,41 +394,22 @@ namespace Barotrauma.Lights
             {
                 Level.Loaded.LevelObjectManager.DrawObjects(spriteBatch, cam, drawFront: false, specular: true);
             }
-            
-            Dictionary<Hull, Rectangle> visibleHulls = new Dictionary<Hull, Rectangle>();
-            foreach (Hull hull in Hull.hullList)
-            {
-                var drawRect =
-                    hull.Submarine == null ?
-                    hull.Rect :
-                    new Rectangle((int)(hull.Submarine.DrawPosition.X + hull.Rect.X), (int)(hull.Submarine.DrawPosition.Y + hull.Rect.Y), hull.Rect.Width, hull.Rect.Height);
-
-                if (drawRect.Right < cam.WorldView.X || drawRect.X > cam.WorldView.Right ||
-                    drawRect.Y - drawRect.Height > cam.WorldView.Y || drawRect.Y < cam.WorldView.Y - cam.WorldView.Height)
-                {
-                    continue;
-                }
-                visibleHulls.Add(hull, drawRect);
-            }
-            
-            foreach (Rectangle drawRect in visibleHulls.Values)
-            {
-                GUI.DrawRectangle(spriteBatch,
-                    new Vector2(drawRect.X, -drawRect.Y),
-                    new Vector2(drawRect.Width, drawRect.Height),
-                    Color.Gray, true);
-            }
             spriteBatch.End();
 
-            //TODO: use renderTargetFront to obstruct the things behind the sub (has to be drawn with a solid gray color)
-            /*spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
-            spriteBatch.Draw(renderTargetFront, new Rectangle(0, 0,
-                (int)(GameMain.GraphicsWidth * currLightMapScale), (int)(GameMain.GraphicsHeight * currLightMapScale)), Color.White);
-            spriteBatch.End();*/
-
             //TODO: specular maps for level walls
             Level.Loaded?.Renderer?.RenderWalls(graphics, cam, specular: true);
 
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
+            if (backgroundObstructor != null)
+            {
+                spriteBatch.Draw(backgroundObstructor, new Rectangle(0, 0,
+                    (int)(GameMain.GraphicsWidth * currLightMapScale), (int)(GameMain.GraphicsHeight * currLightMapScale)), Color.Black);
+            }
+            GUI.DrawRectangle(spriteBatch, new Rectangle(0, 0,
+                    (int)(GameMain.GraphicsWidth * currLightMapScale), (int)(GameMain.GraphicsHeight * currLightMapScale)),
+                    Color.White * 0.4f, isFilled: true);
+            spriteBatch.End();
+
             graphics.SetRenderTarget(null);
             graphics.BlendState = BlendState.AlphaBlend;
         }
@@ -491,14 +466,14 @@ namespace Barotrauma.Lights
 
             if (LosEnabled && LosMode != LosMode.None && ViewTarget != null)
             {
-                Vector2 pos = ViewTarget.WorldPosition;
+                Vector2 pos = ViewTarget.DrawPosition;
 
                 Rectangle camView = new Rectangle(cam.WorldView.X, cam.WorldView.Y - cam.WorldView.Height, cam.WorldView.Width, cam.WorldView.Height);
 
                 Matrix shadowTransform = cam.ShaderTransform
                     * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
 
-                var convexHulls = ConvexHull.GetHullsInRange(viewTarget.Position, cam.WorldView.Width*0.75f, viewTarget.Submarine);
+                var convexHulls = ConvexHull.GetHullsInRange(ViewTarget.Position, cam.WorldView.Width*0.75f, ViewTarget.Submarine);
                 if (convexHulls != null)
                 {
                     List<VertexPositionColor> shadowVerts = new List<VertexPositionColor>();

Barotrauma/BarotraumaClient/Source/Map/Lights/LightSource.cs

@@ -718,7 +718,11 @@ namespace Barotrauma.Lights
             if (OverrideLightTexture != null)
             {
                 overrideTextureDims = new Vector2(OverrideLightTexture.SourceRect.Width, OverrideLightTexture.SourceRect.Height);
-                uvOffset = (OverrideLightTexture.Origin / overrideTextureDims) - new Vector2(0.5f, 0.5f);
+
+                Vector2 origin = OverrideLightTexture.Origin;
+                if (LightSpriteEffect == SpriteEffects.FlipHorizontally) origin.X = OverrideLightTexture.SourceRect.Width - origin.X;
+                if (LightSpriteEffect == SpriteEffects.FlipVertically) origin.Y = (OverrideLightTexture.SourceRect.Height - origin.Y);
+                uvOffset = (origin / overrideTextureDims) - new Vector2(0.5f, 0.5f);
             }
 
             // Add a vertex for the center of the mesh

Barotrauma/BarotraumaClient/Source/Map/Map/Map.cs

@@ -258,7 +258,7 @@ namespace Barotrauma
             if (change.Messages.Count > 0)
             {
                 mapAnim.EndMessage = change.Messages[Rand.Range(0,change.Messages.Count)]
-                    .Replace("[prevname]", prevName)
+                    .Replace("[previousname]", prevName)
                     .Replace("[name]", location.Name);
             }
             mapAnimQueue.Enqueue(mapAnim);
@@ -634,7 +634,7 @@ namespace Barotrauma
                 GUI.DrawString(spriteBatch, pos, 
                     location.Name, Color.White * hudOpenState * 1.5f, font: GUI.LargeFont);
                 GUI.DrawString(spriteBatch, pos + Vector2.UnitY * 25, 
-                    location.Type.DisplayName, Color.White * hudOpenState * 1.5f);
+                    location.Type.Name, Color.White * hudOpenState * 1.5f);
             }
                         
             GameMain.Instance.GraphicsDevice.ScissorRectangle = prevScissorRect;

Barotrauma/BarotraumaClient/Source/Map/MapEntity.cs

@@ -85,6 +85,11 @@ namespace Barotrauma
             get { return selectedList.Contains(this); }
         }
 
+        public virtual bool IsVisible(Rectangle worldView)
+        {
+            return true;
+        }
+
         public virtual void Draw(SpriteBatch spriteBatch, bool editing, bool back = true) { }
 
         public virtual void DrawDamage(SpriteBatch spriteBatch, Effect damageEffect) { }

Barotrauma/BarotraumaClient/Source/Map/Structure.cs

@@ -1,10 +1,10 @@
 using Barotrauma.Lights;
 using Barotrauma.Networking;
+using Lidgren.Network;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace Barotrauma
 {
@@ -105,7 +105,17 @@ namespace Barotrauma
 
             return editingHUD;
         }
-        
+
+        public override bool IsVisible(Rectangle worldView)
+        {
+            Rectangle worldRect = WorldRect;
+
+            if (worldRect.X > worldView.Right || worldRect.Right < worldView.X) return false;
+            if (worldRect.Y < worldView.Y - worldView.Height || worldRect.Y - worldRect.Height > worldView.Y) return false;
+
+            return true;
+        }
+
         public override void Draw(SpriteBatch spriteBatch, bool editing, bool back = true)
         {
             if (prefab.sprite == null) return;
@@ -159,13 +169,13 @@ namespace Barotrauma
 
             if (back && damageEffect == null)
             {
-                if (prefab.BackgroundSprite != null)
+                if (Prefab.BackgroundSprite != null)
                 {
                     bool drawDropShadow = Submarine != null && HasBody;
                     Vector2 dropShadowOffset = Vector2.Zero;
                     if (drawDropShadow)
                     {
-                        dropShadowOffset = Submarine.WorldPosition - WorldPosition;
+                        dropShadowOffset = Submarine.HiddenSubPosition - Position;
                         if (dropShadowOffset != Vector2.Zero)
                         {
                             if (IsHorizontal)
@@ -182,14 +192,14 @@ namespace Barotrauma
 
                     if (DrawTiled)
                     {
-                        SpriteEffects oldEffects = prefab.BackgroundSprite.effects;
-                        prefab.BackgroundSprite.effects ^= SpriteEffects;
+                        SpriteEffects oldEffects = Prefab.BackgroundSprite.effects;
+                        Prefab.BackgroundSprite.effects ^= SpriteEffects;
 
                         Point backGroundOffset = new Point(
-                            MathUtils.PositiveModulo((int)-textureOffset.X, prefab.BackgroundSprite.SourceRect.Width),
-                            MathUtils.PositiveModulo((int)-textureOffset.Y, prefab.BackgroundSprite.SourceRect.Height));
+                            MathUtils.PositiveModulo((int)-textureOffset.X, Prefab.BackgroundSprite.SourceRect.Width),
+                            MathUtils.PositiveModulo((int)-textureOffset.Y, Prefab.BackgroundSprite.SourceRect.Height));
 
-                        prefab.BackgroundSprite.DrawTiled(
+                        Prefab.BackgroundSprite.DrawTiled(
                             spriteBatch,
                             new Vector2(rect.X + drawOffset.X, -(rect.Y + drawOffset.Y)),
                             new Vector2(rect.Width, rect.Height),
@@ -199,21 +209,21 @@ namespace Barotrauma
 
                         if (drawDropShadow)
                         {
-                            prefab.BackgroundSprite.DrawTiled(
+                            Prefab.BackgroundSprite.DrawTiled(
                                 spriteBatch,
                                 new Vector2(rect.X + drawOffset.X, -(rect.Y + drawOffset.Y)) + dropShadowOffset,
                                 new Vector2(rect.Width, rect.Height),
                                 color: Color.Black * 0.5f,
                                 textureScale: TextureScale * Scale,
                                 startOffset: backGroundOffset,
-                                depth: (depth + prefab.BackgroundSprite.Depth) / 2.0f);
+                                depth: (depth + Prefab.BackgroundSprite.Depth) / 2.0f);
                         }
 
-                        prefab.BackgroundSprite.effects = oldEffects;
+                        Prefab.BackgroundSprite.effects = oldEffects;
                     }
                     else
                     {
-                        prefab.BackgroundSprite.Draw(
+                        Prefab.BackgroundSprite.Draw(
                             spriteBatch,
                             new Vector2(rect.X + drawOffset.X, -(rect.Y + drawOffset.Y)),
                             color,
@@ -224,7 +234,7 @@ namespace Barotrauma
 
                         if (drawDropShadow)
                         {
-                            prefab.BackgroundSprite.Draw(
+                            Prefab.BackgroundSprite.Draw(
                                 spriteBatch,
                                 new Vector2(rect.X + drawOffset.X, -(rect.Y + drawOffset.Y)) + dropShadowOffset,
                                 Color.Black * 0.5f,
@@ -232,7 +242,7 @@ namespace Barotrauma
                                 scale: Scale,
                                 rotate: 0,
                                 spriteEffect: SpriteEffects,
-                                depth: (depth + prefab.BackgroundSprite.Depth) / 2.0f);
+                                depth: (depth + Prefab.BackgroundSprite.Depth) / 2.0f);
                         }
                     }
                 }
@@ -248,7 +258,7 @@ namespace Barotrauma
                     if (damageEffect != null)
                     {
                         float newCutoff = Sections[i].damage > 0 ?
-                            MathHelper.Lerp(0.2f, 0.65f, Sections[i].damage / prefab.Health) : 0.0f;
+                            MathHelper.Lerp(0.2f, 0.65f, Sections[i].damage / Prefab.Health) : 0.0f;
 
                         if (Math.Abs(newCutoff - Submarine.DamageEffectCutoff) > 0.01f || color != Submarine.DamageEffectColor)
                         {
@@ -317,5 +327,14 @@ namespace Barotrauma
                 }
             }
         }
+
+        public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
+        {
+            for (int i = 0; i < Sections.Length; i++)
+            {
+                float damage = msg.ReadRangedSingle(0.0f, 1.0f, 8) * Health;
+                SetDamage(i, damage);
+            }
+        }
     }
 }

Barotrauma/BarotraumaClient/Source/Map/Submarine.cs

@@ -1,4 +1,5 @@
 using Barotrauma.Networking;
+using Barotrauma.RuinGeneration;
 using Barotrauma.Sounds;
 using FarseerPhysics;
 using Lidgren.Network;
@@ -62,7 +63,15 @@ namespace Barotrauma
 
             if (existingSound == null)
             {
-                existingSound = GameMain.SoundManager.LoadSound(filename, stream);
+                try
+                {
+                    existingSound = GameMain.SoundManager.LoadSound(filename, stream);
+                }
+                catch (FileNotFoundException e)
+                {
+                    DebugConsole.ThrowError("Failed to load sound file \"" + filename + "\".", e);
+                    return null;
+                }
             }
 
             RoundSound newSound = new RoundSound(element, existingSound);
@@ -91,6 +100,71 @@ namespace Barotrauma
                 RemoveRoundSound(roundSounds[i]);
             }
         }
+        
+        //drawing ----------------------------------------------------
+
+        public static void CullEntities(Camera cam)
+        {
+            HashSet<Submarine> visibleSubs = new HashSet<Submarine>();
+            foreach (Submarine sub in Loaded)
+            {
+                if (sub.WorldPosition.Y < Level.MaxEntityDepth) continue;
+
+                Rectangle worldBorders = new Rectangle(
+                    sub.Borders.X + (int)sub.WorldPosition.X - 500,
+                    sub.Borders.Y + (int)sub.WorldPosition.Y + 500,
+                    sub.Borders.Width + 1000,
+                    sub.Borders.Height + 1000);
+
+                if (RectsOverlap(worldBorders, cam.WorldView))
+                {
+                    visibleSubs.Add(sub);
+                }
+            }
+
+            HashSet<Ruin> visibleRuins = new HashSet<Ruin>();
+            if (Level.Loaded != null)
+            {
+                foreach (Ruin ruin in Level.Loaded.Ruins)
+                {
+                    Rectangle worldBorders = new Rectangle(
+                        ruin.Area.X - 500,
+                        ruin.Area.Y + ruin.Area.Height + 500,
+                        ruin.Area.Width + 1000,
+                        ruin.Area.Height + 1000);
+
+                    if (RectsOverlap(worldBorders, cam.WorldView))
+                    {
+                        visibleRuins.Add(ruin);
+                    }
+                }
+            }
+
+            if (visibleEntities == null)
+            {
+                visibleEntities = new List<MapEntity>(MapEntity.mapEntityList.Count);
+            }
+            else
+            {
+                visibleEntities.Clear();
+            }
+
+            Rectangle worldView = cam.WorldView;
+            foreach (MapEntity entity in MapEntity.mapEntityList)
+            {
+                if (entity.Submarine != null)
+                {
+                    if (!visibleSubs.Contains(entity.Submarine)) { continue; }
+                }
+                else if (entity.ParentRuin != null)
+                {
+                    if (!visibleRuins.Contains(entity.ParentRuin)) { continue; }
+                }
+
+                if (entity.IsVisible(worldView)) { visibleEntities.Add(entity); }
+            }
+        }
+
 
         public static void Draw(SpriteBatch spriteBatch, bool editing = false)
         {
@@ -128,14 +202,14 @@ namespace Barotrauma
 
                     GUI.DrawRectangle(spriteBatch, worldBorders, Color.White, false, 0, 5);
 
-                    if (sub.subBody.MemPos.Count < 2) continue;
+                    if (sub.subBody.PositionBuffer.Count < 2) continue;
 
-                    Vector2 prevPos = ConvertUnits.ToDisplayUnits(sub.subBody.MemPos[0].Position);
+                    Vector2 prevPos = ConvertUnits.ToDisplayUnits(sub.subBody.PositionBuffer[0].Position);
                     prevPos.Y = -prevPos.Y;
 
-                    for (int i = 1; i < sub.subBody.MemPos.Count; i++)
+                    for (int i = 1; i < sub.subBody.PositionBuffer.Count; i++)
                     {
-                        Vector2 currPos = ConvertUnits.ToDisplayUnits(sub.subBody.MemPos[i].Position);
+                        Vector2 currPos = ConvertUnits.ToDisplayUnits(sub.subBody.PositionBuffer[i].Position);
                         currPos.Y = -currPos.Y;
 
                         GUI.DrawRectangle(spriteBatch, new Rectangle((int)currPos.X - 10, (int)currPos.Y - 10, 20, 20), Color.Blue * 0.6f, true, 0.01f);
@@ -372,30 +446,19 @@ namespace Barotrauma
         
         public void ClientRead(ServerNetObject type, NetBuffer msg, float sendingTime)
         {
-            var newTargetPosition = new Vector2(
-                msg.ReadFloat(),
-                msg.ReadFloat());
-            
-            //already interpolating with more up-to-date data -> ignore
-            if (subBody.MemPos.Count > 1 && subBody.MemPos[0].Timestamp > sendingTime)
-            {
-                return;
-            }
+            var posInfo = PhysicsBody.ClientRead(type, msg, sendingTime, parentDebugName: Name);
+            msg.ReadPadBits();
 
-            int index = 0;
-            while (index < subBody.MemPos.Count && sendingTime > subBody.MemPos[index].Timestamp)
+            if (posInfo != null)
             {
-                index++;
-            }
+                int index = 0;
+                while (index < subBody.PositionBuffer.Count && sendingTime > subBody.PositionBuffer[index].Timestamp)
+                {
+                    index++;
+                }
 
-            //position with the same timestamp already in the buffer (duplicate packet?)
-            //  -> no need to add again
-            if (index < subBody.MemPos.Count && sendingTime == subBody.MemPos[index].Timestamp)
-            {
-                return;
+                subBody.PositionBuffer.Insert(index, posInfo);
             }
-            
-            subBody.MemPos.Insert(index, new PosInfo(newTargetPosition, 0.0f, sendingTime));
         }
     }
 }

Barotrauma/BarotraumaClient/Source/Map/SubmarineBody.cs

@@ -0,0 +1,61 @@
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+
+namespace Barotrauma
+{
+    partial class SubmarineBody
+    {
+        partial void ClientUpdatePosition(float deltaTime)
+        {
+            if (GameMain.Client == null) { return; }
+
+            Vector2 newVelocity = Body.LinearVelocity;
+            Vector2 newPosition = Body.SimPosition;
+
+            Body.CorrectPosition(positionBuffer, out newPosition, out newVelocity, out _, out _);
+            Vector2 moveAmount = ConvertUnits.ToDisplayUnits(newPosition - Body.SimPosition);
+            newVelocity = newVelocity.ClampLength(100.0f);
+            if (!MathUtils.IsValid(newVelocity) || moveAmount.LengthSquared() < 0.0001f)
+            {
+                return;
+            }
+
+            List<Submarine> subsToMove = submarine.GetConnectedSubs();
+            foreach (Submarine dockedSub in subsToMove)
+            {
+                if (dockedSub == submarine) continue;
+                //clear the position buffer of the docked subs to prevent unnecessary position corrections
+                dockedSub.SubBody.positionBuffer.Clear();
+            }
+
+            Submarine closestSub = null;
+            if (Character.Controlled == null)
+            {
+                closestSub = Submarine.FindClosest(GameMain.GameScreen.Cam.Position);
+            }
+            else
+            {
+                closestSub = Character.Controlled.Submarine;
+            }
+
+            bool displace = moveAmount.LengthSquared() > 100.0f * 100.0f;
+            foreach (Submarine sub in subsToMove)
+            {
+                sub.PhysicsBody.SetTransform(sub.PhysicsBody.SimPosition + ConvertUnits.ToSimUnits(moveAmount), 0.0f);
+                sub.PhysicsBody.LinearVelocity = newVelocity;
+
+                if (displace) sub.SubBody.DisplaceCharacters(moveAmount);
+            }
+
+            if (closestSub != null && subsToMove.Contains(closestSub))
+            {
+                GameMain.GameScreen.Cam.Position += moveAmount;
+                if (GameMain.GameScreen.Cam.TargetPos != Vector2.Zero) GameMain.GameScreen.Cam.TargetPos += moveAmount;
+
+                if (Character.Controlled != null) Character.Controlled.CursorPosition += moveAmount;
+            }
+
+        }
+    }
+}

Barotrauma/BarotraumaClient/Source/Map/WayPoint.cs

@@ -10,6 +10,11 @@ namespace Barotrauma
         private const int IconSize = 32;
         private static int[] iconIndices = { 3, 0, 1, 2 };
 
+        public override bool IsVisible(Rectangle worldView)
+        {
+            return Screen.Selected == GameMain.SubEditorScreen || GameMain.DebugDraw;
+        }
+
         public override void Draw(SpriteBatch spriteBatch, bool editing, bool back = true)
         {
             if (!editing && !GameMain.DebugDraw) return;