Build 1.1.4.0

Barotrauma/BarotraumaClient/ClientSource/Map/Gap.cs

@@ -2,6 +2,7 @@
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using System;
+using System.Linq;
 
 namespace Barotrauma
 {
@@ -320,5 +321,45 @@ namespace Barotrauma
                 return IsHorizontal ? rect.Height : rect.Width;
             }
         }
+
+        public override void UpdateEditing(Camera cam, float deltaTime)
+        {
+            if (editingHUD == null || editingHUD.UserData != this)
+            {
+                editingHUD = CreateEditingHUD();
+            }
+        }
+        private GUIComponent CreateEditingHUD(bool inGame = false)
+        {
+
+            editingHUD = new GUIFrame(new RectTransform(new Vector2(0.3f, 0.15f), GUI.Canvas, Anchor.CenterRight) { MinSize = new Point(400, 0) })
+            {
+                UserData = this
+            };
+
+            var paddedFrame = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.85f), editingHUD.RectTransform, Anchor.Center))
+            {
+                Stretch = true,
+                AbsoluteSpacing = (int)(GUI.Scale * 5)
+            };
+
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.2f), paddedFrame.RectTransform), TextManager.Get("entityname.gap"), font: GUIStyle.LargeFont);
+            var hiddenInGameTickBox = new GUITickBox(new RectTransform(new Vector2(0.5f, 1.0f), paddedFrame.RectTransform), TextManager.Get("sp.hiddeningame.name"))
+            {
+                Selected = HiddenInGame
+            };
+            hiddenInGameTickBox.OnSelected += (GUITickBox tickbox) =>
+            {
+                HiddenInGame = tickbox.Selected;
+                return true;
+            };
+            editingHUD.RectTransform.Resize(new Point(
+                editingHUD.Rect.Width,
+                (int)(paddedFrame.Children.Sum(c => c.Rect.Height + paddedFrame.AbsoluteSpacing) / paddedFrame.RectTransform.RelativeSize.Y * 1.25f)));
+
+            PositionEditingHUD();
+
+            return editingHUD;
+        }
     }
 }

Barotrauma/BarotraumaClient/ClientSource/Map/Hull.cs

@@ -129,20 +129,15 @@ namespace Barotrauma
 
             Vector2 position = cam.ScreenToWorld(PlayerInput.MousePosition);
 
-            foreach (MapEntity entity in mapEntityList)
+            foreach (MapEntity entity in HighlightedEntities)
             {
-                if (entity == this || !entity.IsHighlighted) { continue; }
+                if (entity == this) { continue; }
                 if (!entity.IsMouseOn(position)) { continue; }
                 if (entity.linkedTo == null || !entity.Linkable) { continue; }
                 if (entity.linkedTo.Contains(this) || linkedTo.Contains(entity) || rClick)
                 {
-                    if (entity == this || !entity.IsHighlighted) { continue; }
-                    if (!entity.IsMouseOn(position)) { continue; }
-                    if (entity.linkedTo.Contains(this))
-                    {
-                        entity.linkedTo.Remove(this);
-                        linkedTo.Remove(entity);
-                    }
+                    entity.linkedTo.Remove(this);
+                    linkedTo.Remove(entity);                    
                 }
                 else
                 {
@@ -329,13 +324,13 @@ namespace Barotrauma
                 }
 
 
-                /*GUI.DrawLine(spriteBatch, new Vector2(drawRect.X, -WorldSurface), new Vector2(drawRect.Right, -WorldSurface), Color.Cyan * 0.5f);
+                GUI.DrawLine(spriteBatch, new Vector2(drawRect.X, -WorldSurface), new Vector2(drawRect.Right, -WorldSurface), Color.Cyan * 0.5f);
                 for (int i = 0; i < waveY.Length - 1; i++)
                 {
                     GUI.DrawLine(spriteBatch,
                         new Vector2(drawRect.X + WaveWidth * i, -WorldSurface - waveY[i] - 10),
                         new Vector2(drawRect.X + WaveWidth * (i + 1), -WorldSurface - waveY[i + 1] - 10), Color.Blue * 0.5f);
-                }*/
+                }
             }
 
             foreach (MapEntity e in linkedTo)

Barotrauma/BarotraumaClient/ClientSource/Map/Levels/Level.cs

@@ -114,7 +114,11 @@ namespace Barotrauma
 
             graphics.Clear(BackgroundColor);
 
-            renderer?.DrawBackground(spriteBatch, cam, LevelObjectManager, backgroundCreatureManager);
+            if (renderer != null)
+            {
+                GameMain.LightManager.AmbientLight = GameMain.LightManager.AmbientLight.Add(renderer.FlashColor);
+                renderer?.DrawBackground(spriteBatch, cam, LevelObjectManager, backgroundCreatureManager);
+            }
         }
 
         public void DrawFront(SpriteBatch spriteBatch, Camera cam)

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

@@ -22,7 +22,7 @@ namespace Barotrauma
 
         public float CurrentRotation;
 
-        private List<SpriteDeformation> spriteDeformations = new List<SpriteDeformation>();
+        private readonly List<SpriteDeformation> spriteDeformations = new List<SpriteDeformation>();
 
         public Vector2 CurrentScale
         {
@@ -86,6 +86,8 @@ namespace Barotrauma
             private set;
         }
 
+        public bool CanBeVisible { get; private set; }
+
         partial void InitProjSpecific()
         {
             Sprite?.EnsureLazyLoaded();
@@ -156,6 +158,11 @@ namespace Barotrauma
             {
                 SonarRadius = Triggers.Select(t => t.ColliderRadius * 1.5f).Max();
             }
+
+            CanBeVisible =
+                Sprite != null ||
+                Prefab.DeformableSprite != null ||
+                Prefab.OverrideProperties.Any(p => p != null && (p.Sprites.Any() || p.DeformableSprite != null));
         }
 
         public void Update(float deltaTime)

Barotrauma/BarotraumaClient/ClientSource/Map/Levels/LevelObjects/LevelObjectManager.cs

@@ -56,63 +56,84 @@ namespace Barotrauma
 
             float minSizeToDraw = MathHelper.Lerp(10.0f, 5.0f, Math.Min(zoom * 20.0f, 1.0f));
 
+            //start from the grid cell at the center of the view
+            //(if objects needs to be culled, better to cull at the edges of the view)
+            int midIndexX = (currentIndices.X + currentIndices.Width) / 2;
+            int midIndexY = (currentIndices.Y + currentIndices.Height) / 2;
+            CheckIndex(midIndexX, midIndexY);
+
             for (int x = currentIndices.X; x <= currentIndices.Width; x++)
             {
                 for (int y = currentIndices.Y; y <= currentIndices.Height; y++)
                 {
-                    if (objectGrid[x, y] == null) { continue; }
-                    foreach (LevelObject obj in objectGrid[x, y])
+                    if (x != midIndexX || y != midIndexY) { CheckIndex(x, y); }
+                }
+            }
+
+            void CheckIndex(int x, int y)
+            {
+                if (objectGrid[x, y] == null) { return; }
+                foreach (LevelObject obj in objectGrid[x, y])
+                {
+                    if (!obj.CanBeVisible) { continue; }
+                    if (obj.Prefab.HideWhenBroken && obj.Health <= 0.0f) { continue; }
+
+                    if (zoom < 0.05f)
                     {
-                        if (obj.Prefab.HideWhenBroken && obj.Health <= 0.0f) { continue; }
-
-                        if (zoom < 0.05f)
+                        //hide if the sprite is very small when zoomed this far out
+                        if ((obj.Sprite != null && Math.Min(obj.Sprite.size.X * zoom, obj.Sprite.size.Y * zoom) < 5.0f) ||
+                            (obj.ActivePrefab?.DeformableSprite != null && Math.Min(obj.ActivePrefab.DeformableSprite.Sprite.size.X * zoom, obj.ActivePrefab.DeformableSprite.Sprite.size.Y * zoom) < minSizeToDraw))
                         {
-                            //hide if the sprite is very small when zoomed this far out
-                            if ((obj.Sprite != null && Math.Min(obj.Sprite.size.X * zoom, obj.Sprite.size.Y * zoom) < 5.0f) ||
-                                (obj.ActivePrefab?.DeformableSprite != null && Math.Min(obj.ActivePrefab.DeformableSprite.Sprite.size.X * zoom, obj.ActivePrefab.DeformableSprite.Sprite.size.Y * zoom) < minSizeToDraw))
-                            {
-                                continue;
-                            }
-
-                            float zCutoff = MathHelper.Lerp(5000.0f, 500.0f, (0.05f - zoom) * 20.0f);
-                            if (obj.Position.Z > zCutoff)
-                            {
-                                continue;
-                            }
+                            continue;
                         }
 
-                        var objectList = 
-                            obj.Position.Z >= 0 ? 
-                                visibleObjectsBack : 
-                                (obj.Position.Z < -1 ? visibleObjectsFront : visibleObjectsMid);
-                        int drawOrderIndex = 0;
-                        for (int i = 0; i < objectList.Count; i++)
+                        float zCutoff = MathHelper.Lerp(5000.0f, 500.0f, (0.05f - zoom) * 20.0f);
+                        if (obj.Position.Z > zCutoff)
                         {
-                            if (objectList[i] == obj)
-                            {
-                                drawOrderIndex = -1;
-                                break;
-                            }
+                            continue;
+                        }
+                    }
 
-                            if (objectList[i].Position.Z < obj.Position.Z)
-                            {
-                                break;
-                            }
-                            else
-                            {
-                                drawOrderIndex = i + 1;
-                            }
+                    var objectList =
+                        obj.Position.Z >= 0 ?
+                            visibleObjectsBack :
+                            (obj.Position.Z < -1 ? visibleObjectsFront : visibleObjectsMid);
+                    if (objectList.Count >= MaxVisibleObjects) { continue; }
+
+                    int drawOrderIndex = 0;
+                    for (int i = 0; i < objectList.Count; i++)
+                    {
+                        if (objectList[i] == obj)
+                        {
+                            drawOrderIndex = -1;
+                            break;
                         }
 
-                        if (drawOrderIndex >= 0)
+                        if (objectList[i].Position.Z > obj.Position.Z)
                         {
-                            objectList.Insert(drawOrderIndex, obj);
-                            if (objectList.Count >= MaxVisibleObjects) { break; }
+                            break;
                         }
+                        else
+                        {
+                            drawOrderIndex = i + 1;
+                            if (drawOrderIndex >= MaxVisibleObjects) { break; }
+                        }
+                    }
+
+                    if (drawOrderIndex >= 0 && drawOrderIndex < MaxVisibleObjects)
+                    {
+                        objectList.Insert(drawOrderIndex, obj);
                     }
                 }
             }
 
+            //object grid is sorted in an ascending order
+            //(so we prefer the objects in the foreground instead of ones in the background if some need to be culled)
+            //rendering needs to be done in a descending order though to get the background objects to be drawn first -> reverse the lists
+            visibleObjectsBack.Reverse();
+            visibleObjectsMid.Reverse();
+            visibleObjectsFront.Reverse();
+
             currentGridIndices = currentIndices;
         }
 
@@ -144,14 +165,14 @@ namespace Barotrauma
         {
             Rectangle indices = Rectangle.Empty;
             indices.X = (int)Math.Floor(cam.WorldView.X / (float)GridSize);
-            if (indices.X >= objectGrid.GetLength(0)) return;
+            if (indices.X >= objectGrid.GetLength(0)) { return; }
             indices.Y = (int)Math.Floor((cam.WorldView.Y - cam.WorldView.Height - Level.Loaded.BottomPos) / (float)GridSize);
-            if (indices.Y >= objectGrid.GetLength(1)) return;
+            if (indices.Y >= objectGrid.GetLength(1)) { return; }
 
             indices.Width = (int)Math.Floor(cam.WorldView.Right / (float)GridSize) + 1;
-            if (indices.Width < 0) return;
+            if (indices.Width < 0) { return; }
             indices.Height = (int)Math.Floor((cam.WorldView.Y - Level.Loaded.BottomPos) / (float)GridSize) + 1;
-            if (indices.Height < 0) return;
+            if (indices.Height < 0) { return; }
 
             indices.X = Math.Max(indices.X, 0);
             indices.Y = Math.Max(indices.Y, 0);

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

@@ -1,4 +1,4 @@
-using FarseerPhysics;
+using Barotrauma.Extensions;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using System;
@@ -71,9 +71,12 @@ namespace Barotrauma
     {
         private static BasicEffect wallEdgeEffect, wallCenterEffect;
 
-        private Vector2 dustOffset;
-        private Vector2 defaultDustVelocity;
-        private Vector2 dustVelocity;
+        private Vector2 waterParticleOffset;
+        private Vector2 waterParticleVelocity;
+
+        private float flashCooldown;
+        private float flashTimer;
+        public Color FlashColor { get; private set; }
 
         private readonly RasterizerState cullNone;
 
@@ -81,10 +84,26 @@ namespace Barotrauma
 
         private readonly List<LevelWallVertexBuffer> vertexBuffers = new List<LevelWallVertexBuffer>();
 
+        private float chromaticAberrationStrength;
+        public float ChromaticAberrationStrength
+        {
+            get { return chromaticAberrationStrength; }
+            set { chromaticAberrationStrength = MathHelper.Clamp(value, 0.0f, 100.0f); }
+        }
+        public float CollapseEffectStrength
+        {
+            get;
+            set;
+        }
+        public Vector2 CollapseEffectOrigin
+        {
+            get;
+            set;
+        }
+
+
         public LevelRenderer(Level level)
         {
-            defaultDustVelocity = Vector2.UnitY * 10.0f;
-
             cullNone = new RasterizerState() { CullMode = CullMode.None };
 
             if (wallEdgeEffect == null)
@@ -120,12 +139,50 @@ namespace Barotrauma
             level.GenerationParams.WallSprite.ReloadTexture();
             wallCenterEffect.Texture = level.GenerationParams.WallSprite.Texture;
         }
+
+        public void Flash()
+        {
+            flashTimer = 1.0f;
+        }
         
         public void Update(float deltaTime, Camera cam)
         {
+            if (CollapseEffectStrength > 0.0f)
+            {
+                CollapseEffectStrength = Math.Max(0.0f, CollapseEffectStrength - deltaTime);
+            }
+            if (ChromaticAberrationStrength > 0.0f)
+            {
+                ChromaticAberrationStrength = Math.Max(0.0f, ChromaticAberrationStrength - deltaTime * 10.0f);
+            }
+
+            if (level.GenerationParams.FlashInterval.Y > 0)
+            {
+                flashCooldown -= deltaTime;
+                if (flashCooldown <= 0.0f)
+                {
+                    flashTimer = 1.0f;
+                    if (level.GenerationParams.FlashSound != null)
+                    {
+                        level.GenerationParams.FlashSound.Play(1.0f, "default");
+                    }
+                    flashCooldown = Rand.Range(level.GenerationParams.FlashInterval.X, level.GenerationParams.FlashInterval.Y, Rand.RandSync.Unsynced);
+                }
+                if (flashTimer > 0.0f)
+                {
+                    float brightness = flashTimer * 1.1f - PerlinNoise.GetPerlin((float)Timing.TotalTime, (float)Timing.TotalTime * 0.66f) * 0.1f;
+                    FlashColor = level.GenerationParams.FlashColor.Multiply(MathHelper.Clamp(brightness, 0.0f, 1.0f));
+                    flashTimer -= deltaTime * 0.5f;
+                }
+                else
+                {
+                    FlashColor = Color.TransparentBlack;
+                }
+            }
+
             //calculate the sum of the forces of nearby level triggers
-            //and use it to move the dust texture and water distortion effect
-            Vector2 currentDustVel = defaultDustVelocity;
+            //and use it to move the water texture and water distortion effect
+            Vector2 currentWaterParticleVel = level.GenerationParams.WaterParticleVelocity;
             foreach (LevelObject levelObject in level.LevelObjectManager.GetVisibleObjects())
             {
                 if (levelObject.Triggers == null) { continue; }
@@ -139,21 +196,21 @@ namespace Barotrauma
                         objectMaxFlow = vel;
                     }
                 }
-                currentDustVel += objectMaxFlow;
+                currentWaterParticleVel += objectMaxFlow;
             }
+
+            waterParticleVelocity = Vector2.Lerp(waterParticleVelocity, currentWaterParticleVel, deltaTime);
             
-            dustVelocity = Vector2.Lerp(dustVelocity, currentDustVel, deltaTime);
-            
-            WaterRenderer.Instance?.ScrollWater(dustVelocity, deltaTime);
+            WaterRenderer.Instance?.ScrollWater(waterParticleVelocity, deltaTime);
 
             if (level.GenerationParams.WaterParticles != null)
             {
                 Vector2 waterTextureSize = level.GenerationParams.WaterParticles.size * level.GenerationParams.WaterParticleScale;
-                dustOffset += new Vector2(dustVelocity.X, -dustVelocity.Y) * level.GenerationParams.WaterParticleScale * deltaTime;
-                while (dustOffset.X <= -waterTextureSize.X) dustOffset.X += waterTextureSize.X;
-                while (dustOffset.X >= waterTextureSize.X) dustOffset.X -= waterTextureSize.X;
-                while (dustOffset.Y <= -waterTextureSize.Y) dustOffset.Y += waterTextureSize.Y;
-                while (dustOffset.Y >= waterTextureSize.Y) dustOffset.Y -= waterTextureSize.Y;
+                waterParticleOffset += new Vector2(waterParticleVelocity.X, -waterParticleVelocity.Y) * level.GenerationParams.WaterParticleScale * deltaTime;
+                while (waterParticleOffset.X <= -waterTextureSize.X) { waterParticleOffset.X += waterTextureSize.X; }
+                while (waterParticleOffset.X >= waterTextureSize.X){ waterParticleOffset.X -= waterTextureSize.X; }
+                while (waterParticleOffset.Y <= -waterTextureSize.Y) { waterParticleOffset.Y += waterTextureSize.Y; }
+                while (waterParticleOffset.Y >= waterTextureSize.Y) { waterParticleOffset.Y -= waterTextureSize.Y; }
             }
         }
 
@@ -234,7 +291,7 @@ namespace Barotrauma
 
                 Rectangle srcRect = new Rectangle(0, 0, 2048, 2048);
                 Vector2 origin = new Vector2(cam.WorldView.X, -cam.WorldView.Y);
-                Vector2 offset = -origin + dustOffset;
+                Vector2 offset = -origin + waterParticleOffset;
                 while (offset.X <= -srcRect.Width * textureScale) offset.X += srcRect.Width * textureScale;
                 while (offset.X > 0.0f) offset.X -= srcRect.Width * textureScale;
                 while (offset.Y <= -srcRect.Height * textureScale) offset.Y += srcRect.Height * textureScale;
@@ -261,7 +318,7 @@ namespace Barotrauma
                     level.GenerationParams.WaterParticles.DrawTiled(
                         spriteBatch, origin + offsetS, 
                         new Vector2(cam.WorldView.Width - offsetS.X, cam.WorldView.Height - offsetS.Y), 
-                        color: Color.White * alpha, textureScale: new Vector2(texScale));                    
+                        color: level.GenerationParams.WaterParticleColor * alpha, textureScale: new Vector2(texScale));                    
                 }
             }
             spriteBatch.End();

Barotrauma/BarotraumaClient/ClientSource/Map/Lights/ConvexHull.cs

@@ -1,8 +1,6 @@
-using Barotrauma.Extensions;
-using Barotrauma.Items.Components;
+using Barotrauma.Items.Components;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
-using SharpFont;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -12,28 +10,14 @@ namespace Barotrauma.Lights
 {
     class ConvexHullList
     {
-        private List<ConvexHull> list;
-        public HashSet<ConvexHull> IsHidden;
 
         public readonly Submarine Submarine;
-        public List<ConvexHull> List
-        {
-            get { return list; }
-            set
-            {
-                Debug.Assert(value != null);
-                Debug.Assert(!list.Contains(null));
-                list = value;
-                IsHidden.RemoveWhere(ch => !list.Contains(ch));
-            }
-        }
-        
+        public HashSet<ConvexHull> IsHidden = new HashSet<ConvexHull>();
+        public readonly List<ConvexHull> List = new List<ConvexHull>();
 
         public ConvexHullList(Submarine submarine)
         {
             Submarine = submarine;
-            list = new List<ConvexHull>();
-            IsHidden = new HashSet<ConvexHull>();
         }
     }
 
@@ -47,13 +31,13 @@ namespace Barotrauma.Lights
         public bool IsHorizontal;
         public bool IsAxisAligned;
 
+        public Vector2 SubmarineDrawPos;
+
         public Segment(SegmentPoint start, SegmentPoint end, ConvexHull convexHull)
         {
             if (start.Pos.Y > end.Pos.Y)
             {
-                var temp = start;
-                start = end;
-                end = temp;
+                (end, start) = (start, end);
             }
 
             Start = start;
@@ -102,14 +86,15 @@ namespace Barotrauma.Lights
 
         private readonly Segment[] segments = new Segment[4];
         private readonly SegmentPoint[] vertices = new SegmentPoint[4];
-        private readonly SegmentPoint[] losVertices = new SegmentPoint[4];
-        private readonly VectorPair[] losOffsets = new VectorPair[4];
-        
-        private readonly bool[] backFacing;
-        private readonly bool[] ignoreEdge;
+        private readonly SegmentPoint[] losVertices = new SegmentPoint[2];
+        private readonly Vector2[] losOffsets = new Vector2[2];
 
         private readonly bool isHorizontal;
 
+        private readonly int thickness;
+
+        public bool IsExteriorWall;
+
         public VertexPositionColor[] ShadowVertices { get; private set; }
         public VertexPositionTexture[] PenumbraVertices { get; private set; }
         public int ShadowVertexCount { get; private set; }
@@ -145,47 +130,27 @@ namespace Barotrauma.Lights
 
         public Rectangle BoundingBox { get; private set; }
 
-        public ConvexHull(Vector2[] points, Color color, MapEntity parent)
+        public ConvexHull(Rectangle rect, bool? isHorizontal, MapEntity parent)
         {
-            if (shadowEffect == null)
-            {
-                shadowEffect = new BasicEffect(GameMain.Instance.GraphicsDevice)
+            shadowEffect ??= new BasicEffect(GameMain.Instance.GraphicsDevice)
                 {
                     VertexColorEnabled = true
                 };
-            }
-            if (penumbraEffect == null)
-            {
-                penumbraEffect = new BasicEffect(GameMain.Instance.GraphicsDevice)
+            penumbraEffect ??= new BasicEffect(GameMain.Instance.GraphicsDevice)
                 {
                     TextureEnabled = true,
                     LightingEnabled = false,
                     Texture = TextureLoader.FromFile("Content/Lights/penumbra.png")
                 };
-            }
 
             ParentEntity = parent;
 
             ShadowVertices = new VertexPositionColor[6 * 4];
             PenumbraVertices = new VertexPositionTexture[6 * 4];
             
-            backFacing = new bool[4];
-            ignoreEdge = new bool[4];
+            BoundingBox = rect;
 
-            float minX = points[0].X, minY = points[0].Y, maxX = points[0].X, maxY = points[0].Y;
-
-            for (int i = 1; i < vertices.Length; i++)
-            {
-                if (points[i].X < minX) minX = points[i].X;
-                if (points[i].Y < minY) minY = points[i].Y;
-
-                if (points[i].X > maxX) maxX = points[i].X;
-                if (points[i].Y > minY) maxY = points[i].Y;
-            }
-
-            BoundingBox = new Rectangle((int)minX, (int)minY, (int)(maxX - minX), (int)(maxY - minY));
-
-            isHorizontal = BoundingBox.Width > BoundingBox.Height;
+            this.isHorizontal = isHorizontal ?? BoundingBox.Width > BoundingBox.Height;
             if (ParentEntity is Structure structure)
             {
                 System.Diagnostics.Debug.Assert(!structure.Removed);
@@ -198,8 +163,26 @@ namespace Barotrauma.Lights
                 if (door != null) { isHorizontal = door.IsHorizontal; }
             }
 
-            SetVertices(points);          
-            
+            Vector2[] verts = new Vector2[]
+            {
+                new Vector2(rect.X, rect.Bottom),
+                new Vector2(rect.Right, rect.Bottom),
+                new Vector2(rect.Right, rect.Y),
+                new Vector2(rect.X, rect.Y),
+            };
+
+            Vector2[] losVerts;
+            if (this.isHorizontal)
+            {
+                thickness = rect.Height;
+                losVerts = new Vector2[] { new Vector2(rect.X, rect.Center.Y), new Vector2(rect.Right, rect.Center.Y) };
+            }
+            else
+            {
+                thickness = rect.Width;
+                losVerts = new Vector2[] { new Vector2(rect.Center.X, rect.Y), new Vector2(rect.Center.X, rect.Bottom) };
+            }
+            SetVertices(verts, losVerts);
             Enabled = true;
 
             var chList = HullLists.Find(h => h.Submarine == parent.Submarine);
@@ -211,257 +194,72 @@ namespace Barotrauma.Lights
             
             foreach (ConvexHull ch in chList.List)
             {
-                MergeOverlappingSegments(ch);
-                ch.MergeOverlappingSegments(this);
+                MergeLosVertices(ch);
+                ch.MergeLosVertices(this);
             }
 
             chList.List.Add(this);
         }
 
-        private void MergeOverlappingSegments(ConvexHull ch)
+        private void MergeLosVertices(ConvexHull ch, bool refreshOtherOverlappingHulls = true)
         {
             if (ch == this) { return; }
 
-            if (isHorizontal == ch.isHorizontal)
+            //hide segments that are roughly at the some position as some other segment (e.g. the ends of two adjacent wall pieces)
+            float mergeDist = MathHelper.Clamp(ch.thickness * 0.55f, 16, 512);
+            mergeDist = Math.Min(mergeDist, Vector2.Distance(losVertices[0].Pos, losVertices[1].Pos) / 2);
+
+            float mergeDistSqr = mergeDist * mergeDist;
+
+            bool changed = false;
+            for (int i = 0; i < losVertices.Length; i++)
             {
-                //hide segments that are roughly at the some position as some other segment (e.g. the ends of two adjacent wall pieces)
-                float mergeDist = 16;
-                float mergeDistSqr = mergeDist * mergeDist;
+                //find the closest point on the other convex hull segment
+                Vector2 closest = MathUtils.GetClosestPointOnLineSegment(
+                    ch.losVertices[0].Pos + ch.losOffsets[0], 
+                    ch.losVertices[1].Pos + ch.losOffsets[1], 
+                    losVertices[i].Pos);
+                if (Vector2.DistanceSquared(closest, losVertices[i].Pos) > mergeDistSqr) { continue; }
 
-                Rectangle intersection = Rectangle.Intersect(BoundingBox, ch.BoundingBox);
-                int intersectionArea = intersection.Width * intersection.Height;
-                int bboxArea = BoundingBox.Width * BoundingBox.Height;
-                int otherBboxArea = ch.BoundingBox.Width * ch.BoundingBox.Height;
-                if (Math.Abs(intersectionArea - bboxArea) < mergeDistSqr) { return; }
-                if (Math.Abs(intersectionArea - otherBboxArea) < mergeDistSqr) { return; }
-
-                for (int i = 0; i < segments.Length; i++)
+                //find where the segments would intersect if they had infinite length
+                //   if it's close to the closest point, let's use that instead to keep
+                //   the direction of the segment unchanged (i.e. vertical segment stays vertical)
+                if (MathUtils.GetLineIntersection(
+                    ch.losVertices[0].Pos + ch.losOffsets[0],
+                    ch.losVertices[1].Pos + ch.losOffsets[1],
+                    losVertices[0].Pos,
+                    losVertices[1].Pos,
+                    out Vector2 intersection))
                 {
-                    for (int j = 0; j < ch.segments.Length; j++)
+                    if (Vector2.DistanceSquared(intersection, losVertices[i].Pos) < mergeDistSqr ||
+                        Vector2.DistanceSquared(intersection, closest) < 16.0f * 16.0f)
                     {
-                        if (segments[i].IsHorizontal != ch.segments[j].IsHorizontal) { continue; }
-                        if (ignoreEdge[i] || ch.ignoreEdge[j]) { continue; }
-
-                        //the segments must be at different sides of the convex hulls to be merged
-                        //(e.g. the right edge of a wall piece and the left edge of another one)
-                        var segment1Center = (segments[i].Start.Pos + segments[i].End.Pos) / 2.0f;
-                        var segment2Center = (ch.segments[j].Start.Pos + ch.segments[j].End.Pos) / 2.0f;
-                        if (Vector2.Dot(segment1Center - BoundingBox.Center.ToVector2(), segment2Center - ch.BoundingBox.Center.ToVector2()) > 0) { continue; }
-
-                        if (Vector2.DistanceSquared(segments[i].Start.Pos, ch.segments[j].Start.Pos) < mergeDistSqr &&
-                            Vector2.DistanceSquared(segments[i].End.Pos, ch.segments[j].End.Pos) < mergeDistSqr)
-                        {
-                            ignoreEdge[i] = true;
-                            ch.ignoreEdge[j] = true;
-                            MergeSegments(segments[i], ch.segments[j], true);
-                        }
-                        else if (Vector2.DistanceSquared(segments[i].Start.Pos, ch.segments[j].End.Pos) < mergeDistSqr &&
-                                Vector2.DistanceSquared(segments[i].End.Pos, ch.segments[j].Start.Pos) < mergeDistSqr)
-                        {
-                            ignoreEdge[i] = true;
-                            ch.ignoreEdge[j] = true;
-                            MergeSegments(segments[i], ch.segments[j], false);
-                        }
-                    }             
-                }
-            }
-
-            for (int i = 0; i < segments.Length; i++)
-            {
-                if (ignoreEdge[i]) { continue; }
-                if (Vector2.DistanceSquared(segments[i].Start.Pos, segments[i].End.Pos) < 1.0f) { continue; }
-                for (int j = 0; j < ch.segments.Length; j++)
-                {
-                    if (ch.ignoreEdge[j]) { continue; }
-                    if (Vector2.DistanceSquared(ch.segments[j].Start.Pos, ch.segments[j].End.Pos) < 1.0f) { continue; }
-                    if (IsSegmentAInB(segments[i], ch.segments[j]))
-                    {
-                        ignoreEdge[i] = true;
-                        if (Vector2.DistanceSquared(ch.segments[j].Start.Pos, segments[i].Start.Pos) < 4.0f)
-                        {
-                            ch.ShiftSegmentPoint(j, false, segments[i].End.Pos);
-                        }
-                        else if (Vector2.DistanceSquared(ch.segments[j].Start.Pos, segments[i].End.Pos) < 4.0f)
-                        {
-                            ch.ShiftSegmentPoint(j, false, segments[i].Start.Pos);
-                        }
-
-                        if (Vector2.DistanceSquared(ch.segments[j].End.Pos, segments[i].Start.Pos) < 4.0f)
-                        {
-                            ch.ShiftSegmentPoint(j, true, segments[i].End.Pos);
-                        }
-                        else if (Vector2.DistanceSquared(ch.segments[j].End.Pos, segments[i].End.Pos) < 4.0f)
-                        {
-                            ch.ShiftSegmentPoint(j, true, segments[i].Start.Pos);
-                        }
-                    }
-                    else if (IsSegmentAInB(ch.segments[j], segments[i]))
-                    {
-                        ch.ignoreEdge[j] = true;
-
-                        if (Vector2.DistanceSquared(segments[i].Start.Pos, ch.segments[j].Start.Pos) < 4.0f)
-                        {
-                            ShiftSegmentPoint(i, false, ch.segments[j].End.Pos);
-                        }
-                        else if (Vector2.DistanceSquared(segments[i].Start.Pos, ch.segments[j].End.Pos) < 4.0f)
-                        {
-                            ShiftSegmentPoint(i, false, ch.segments[j].Start.Pos);
-                        }
-
-                        if (Vector2.DistanceSquared(segments[i].End.Pos, ch.segments[j].Start.Pos) < 4.0f)
-                        {
-                            ShiftSegmentPoint(i, true, ch.segments[j].End.Pos);
-                        }
-                        else if (Vector2.DistanceSquared(segments[i].End.Pos, ch.segments[j].End.Pos) < 4.0f)
-                        {
-                            ShiftSegmentPoint(i, true, ch.segments[j].Start.Pos);
-                        }
+                        closest = intersection;
                     }
                 }
+
+                losOffsets[i] = closest - losVertices[i].Pos;
+                overlappingHulls.Add(ch);
+                ch.overlappingHulls.Add(this);
+                changed = true;
+                
             }
-            
-            //ignore edges that are inside some other convex hull
-            for (int i = 0; i < vertices.Length; i++)
+            if (changed && refreshOtherOverlappingHulls)
             {
-                if (ch.IsPointInside(vertices[i].Pos))
+                foreach (var overlapping in overlappingHulls)
                 {
-                    if (ch.IsPointInside(vertices[(i + 1) % vertices.Length].Pos))
-                    {
-                        ignoreEdge[i] = true;
-                        overlappingHulls.Add(ch);
-                    }
+                    overlapping.MergeLosVertices(this, refreshOtherOverlappingHulls: false);
                 }
             }
         }
 
-        private void ShiftSegmentPoint(int segmentIndex, bool end, Vector2 newPos)
-        {
-            var segment = segments[segmentIndex];
-
-            losOffsets[segmentIndex] ??= new VectorPair();
-            bool flipped = false;
-            if (Vector2.DistanceSquared(vertices[segmentIndex].Pos, segment.Start.Pos) > Vector2.DistanceSquared(vertices[segmentIndex].Pos, segment.End.Pos))
-            {
-                flipped = true;
-            }
-            if (end == !flipped)
-            {
-                losOffsets[segmentIndex].B = newPos;
-            }
-            else
-            {
-                losOffsets[segmentIndex].A = newPos;
-            }
-        }
-
-        public bool IsSegmentAInB(Segment a, Segment b)
-        {
-            if (Vector2.DistanceSquared(a.Start.Pos, a.End.Pos) > Vector2.DistanceSquared(b.Start.Pos, b.End.Pos))
-            {
-                return false;
-            }
-
-            Vector2 min = new Vector2(Math.Min(b.Start.Pos.X, b.End.Pos.X), Math.Min(b.Start.Pos.Y, b.End.Pos.Y));
-            Vector2 max = new Vector2(Math.Max(b.Start.Pos.X, b.End.Pos.X), Math.Max(b.Start.Pos.Y, b.End.Pos.Y));
-            min.X -= 1.0f; min.Y -= 1.0f;
-            max.X += 1.0f; max.Y += 1.0f;
-
-            if (a.Start.Pos.X < min.X) { return false; }
-            if (a.Start.Pos.Y < min.Y) { return false; }
-            if (a.End.Pos.X < min.X) { return false; }
-            if (a.End.Pos.Y < min.Y) { return false; }
-
-            if (a.Start.Pos.X > max.X) { return false; }
-            if (a.Start.Pos.Y > max.Y) { return false; }
-            if (a.End.Pos.X > max.X) { return false; }
-            if (a.End.Pos.Y > max.Y) { return false; }
-
-            float startDist = MathUtils.LineToPointDistanceSquared(b.Start.Pos, b.End.Pos, a.Start.Pos);
-            if (startDist > 1.0f) { return false; }
-            float endDist = MathUtils.LineToPointDistanceSquared(b.Start.Pos, b.End.Pos, a.End.Pos);
-            if (endDist > 1.0f) { return false; }
-            return true;
-        }
-
-        public bool IsPointInside(Vector2 point)
-        {
-            if (!BoundingBox.Contains(point)) { return false; }
-
-            Vector2 center = (vertices[0].Pos + vertices[1].Pos + vertices[2].Pos + vertices[3].Pos) * 0.25f;
-            for (int i = 0; i < 4; i++)
-            {
-                Vector2 segmentVector = vertices[(i + 1) % 4].Pos - vertices[i].Pos;
-                Vector2 centerToVertex = center - vertices[i].Pos;
-                Vector2 pointToVertex = point - vertices[i].Pos;
-
-                float dotCenter = Vector2.Dot(centerToVertex, segmentVector);
-                float dotPoint = Vector2.Dot(pointToVertex, segmentVector);
-
-                if ((dotCenter > 0f && dotPoint < 0f) || (dotCenter < 0f && dotPoint > 0f)) { return false; }
-            }
-
-            return true;
-        }
-
-        private void MergeSegments(Segment segment1, Segment segment2, bool startPointsMatch)
-        {
-            int startPointIndex = -1, endPointIndex = -1;
-            for (int i = 0; i < vertices.Length; i++)
-            {
-                if (vertices[i].Pos.NearlyEquals(segment1.Start.Pos))                
-                    startPointIndex = i;                
-                else if (vertices[i].Pos.NearlyEquals(segment1.End.Pos))                
-                    endPointIndex = i;                
-            }
-            if (startPointIndex == -1 || endPointIndex == -1) { return; }
-
-            int startPoint2Index = -1, endPoint2Index = -1;
-            for (int i = 0; i < segment2.ConvexHull.vertices.Length; i++)
-            {
-                if (segment2.ConvexHull.vertices[i].Pos.NearlyEquals(segment2.Start.Pos))                
-                    startPoint2Index = i;                
-                else if (segment2.ConvexHull.vertices[i].Pos.NearlyEquals(segment2.End.Pos))                
-                    endPoint2Index = i;
-            }
-            if (startPoint2Index == -1 || endPoint2Index == -1) { return; }
-
-            if (startPointsMatch)
-            {
-                losVertices[startPointIndex].Pos = segment2.ConvexHull.losVertices[startPoint2Index].Pos =
-                    (segment1.Start.Pos + segment2.Start.Pos) / 2.0f;
-                losVertices[endPointIndex].Pos = segment2.ConvexHull.losVertices[endPoint2Index].Pos =
-                    (segment1.End.Pos + segment2.End.Pos) / 2.0f;
-            }
-            else
-            {
-                if (Vector2.DistanceSquared(losVertices[startPointIndex].Pos, segment1.Start.Pos) < 
-                    Vector2.DistanceSquared(losVertices[startPointIndex].Pos, segment1.End.Pos))
-                {
-                    losVertices[startPointIndex].Pos = segment2.ConvexHull.losVertices[startPoint2Index].Pos =
-                        (segment1.Start.Pos + segment2.End.Pos) / 2.0f;
-                    losVertices[endPointIndex].Pos = segment2.ConvexHull.losVertices[endPoint2Index].Pos =
-                        (segment1.End.Pos + segment2.Start.Pos) / 2.0f;
-                }
-                else
-                {
-                    losVertices[startPointIndex].Pos = segment2.ConvexHull.losVertices[startPoint2Index].Pos =
-                        (segment1.End.Pos + segment2.Start.Pos) / 2.0f;
-                    losVertices[endPointIndex].Pos = segment2.ConvexHull.losVertices[endPoint2Index].Pos =
-                        (segment1.Start.Pos + segment2.End.Pos) / 2.0f;
-                }
-            }
-
-            overlappingHulls.Add(segment2.ConvexHull);
-            segment2.ConvexHull.overlappingHulls.Add(this);
-        }
-
         public void Rotate(Vector2 origin, float amount)
         {
             Matrix rotationMatrix = 
                 Matrix.CreateTranslation(-origin.X, -origin.Y, 0.0f) * 
                 Matrix.CreateRotationZ(amount) *
                 Matrix.CreateTranslation(origin.X, origin.Y, 0.0f);
-            SetVertices(vertices.Select(v => v.Pos).ToArray(), rotationMatrix: rotationMatrix);
+            SetVertices(vertices.Select(v => v.Pos).ToArray(), losVertices.Select(v => v.Pos).ToArray(), rotationMatrix: rotationMatrix);
         }
 
         private void CalculateDimensions()
@@ -470,11 +268,10 @@ namespace Barotrauma.Lights
 
             for (int i = 1; i < vertices.Length; i++)
             {
-                if (vertices[i].Pos.X < minX) minX = vertices[i].Pos.X;
-                if (vertices[i].Pos.Y < minY) minY = vertices[i].Pos.Y;
-
-                if (vertices[i].Pos.X > maxX) maxX = vertices[i].Pos.X;
-                if (vertices[i].Pos.Y > minY) maxY = vertices[i].Pos.Y;
+                minX = Math.Min(minX, vertices[i].Pos.X);
+                minY = Math.Min(minY, vertices[i].Pos.Y);
+                maxX = Math.Max(maxX, vertices[i].Pos.X);
+                maxY = Math.Max(maxY, vertices[i].Pos.Y);
             }
 
             BoundingBox = new Rectangle((int)minX, (int)minY, (int)(maxX - minX), (int)(maxY - minY));
@@ -485,21 +282,17 @@ namespace Barotrauma.Lights
             for (int i = 0; i < vertices.Length; i++)
             {
                 vertices[i].Pos         += amount;
-                losVertices[i].Pos      += amount;
-
-                losOffsets[i] = null;
-
                 segments[i].Start.Pos   += amount;
                 segments[i].End.Pos     += amount;
             }
+            for (int i = 0; i < losVertices.Length; i++)
+            {
+                losVertices[i].Pos += amount;
+            }
 
             LastVertexChangeTime = (float)Timing.TotalTime;
 
             overlappingHulls.Clear();
-            for (int i = 0; i < 4; i++)
-            {
-                ignoreEdge[i] = false;
-            }
 
             CalculateDimensions();
 
@@ -511,8 +304,8 @@ namespace Barotrauma.Lights
                 overlappingHulls.Clear();
                 foreach (ConvexHull ch in chList.List)
                 {
-                    MergeOverlappingSegments(ch);
-                    ch.MergeOverlappingSegments(this);
+                    MergeLosVertices(ch);
+                    ch.MergeLosVertices(this);
                 }
             }
         }
@@ -525,23 +318,23 @@ namespace Barotrauma.Lights
                 foreach (ConvexHull ch in chList.List)
                 {
                     ch.overlappingHulls.Clear();
-                    for (int i = 0; i < 4; i++)
+                    for (int i = 0; i < ch.losOffsets.Length; i++)
                     {
-                        ch.ignoreEdge[i] = false;
+                        ch.losOffsets[i] = Vector2.Zero;
                     }
                 }
                 for (int i = 0; i < chList.List.Count; i++)
                 {
                     for (int j = i + 1; j < chList.List.Count; j++)
                     {
-                        chList.List[i].MergeOverlappingSegments(chList.List[j]);
-                        chList.List[j].MergeOverlappingSegments(chList.List[i]);
+                        chList.List[i].MergeLosVertices(chList.List[j]);
+                        chList.List[j].MergeLosVertices(chList.List[i]);
                     }
                 }
             }
         }
 
-        public void SetVertices(Vector2[] points, bool mergeOverlappingSegments = true, Matrix? rotationMatrix = null)
+        public void SetVertices(Vector2[] points, Vector2[] losPoints, bool mergeOverlappingSegments = true, Matrix? rotationMatrix = null)
         {
             Debug.Assert(points.Length == 4, "Only rectangular convex hulls are supported");
 
@@ -549,39 +342,23 @@ namespace Barotrauma.Lights
 
             for (int i = 0; i < 4; i++)
             {
-                vertices[i]     = new SegmentPoint(points[i], this);
-                losVertices[i]  = new SegmentPoint(points[i], this);
-                losOffsets[i] = null;
+                vertices[i] = new SegmentPoint(points[i], this);
             }
-
-            for (int i = 0; i < 4; i++)
+            for (int i = 0; i < 2; i++)
             {
-                ignoreEdge[i] = false;
+                losVertices[i] = new SegmentPoint(losPoints[i], this);
             }
 
             overlappingHulls.Clear();
 
-            int margin = 0;
-            if (Math.Abs(points[0].X - points[2].X) < Math.Abs(points[0].Y - points[2].Y))
-            {
-                losVertices[0].Pos = new Vector2(points[0].X + margin, points[0].Y);
-                losVertices[1].Pos = new Vector2(points[1].X + margin, points[1].Y);
-                losVertices[2].Pos = new Vector2(points[2].X - margin, points[2].Y);
-                losVertices[3].Pos = new Vector2(points[3].X - margin, points[3].Y);
-            }
-            else
-            {
-                losVertices[0].Pos = new Vector2(points[0].X, points[0].Y + margin);
-                losVertices[1].Pos = new Vector2(points[1].X, points[1].Y - margin);
-                losVertices[2].Pos = new Vector2(points[2].X, points[2].Y - margin);
-                losVertices[3].Pos = new Vector2(points[3].X, points[3].Y + margin);
-            }
-
             if (rotationMatrix.HasValue)
             {
                 for (int i = 0; i < vertices.Length; i++)
                 {
                     vertices[i].Pos = Vector2.Transform(vertices[i].Pos, rotationMatrix.Value);
+                }
+                for (int i = 0; i < losVertices.Length; i++)
+                {
                     losVertices[i].Pos = Vector2.Transform(losVertices[i].Pos, rotationMatrix.Value);
                 }
             }
@@ -602,7 +379,7 @@ namespace Barotrauma.Lights
                     overlappingHulls.Clear();
                     foreach (ConvexHull ch in chList.List)
                     {
-                        MergeOverlappingSegments(ch);
+                        MergeLosVertices(ch);
                     }
                 }
             }
@@ -624,31 +401,17 @@ namespace Barotrauma.Lights
         /// <summary>
         /// Returns the segments that are facing towards viewPosition
         /// </summary>
-        public void GetVisibleSegments(Vector2 viewPosition, List<Segment> visibleSegments, bool ignoreEdges)
+        public void GetVisibleSegments(Vector2 viewPosition, List<Segment> visibleSegments)
         {            
             for (int i = 0; i < 4; i++)
             {
-                if (ignoreEdge[i] && ignoreEdges) continue;
-
-                Vector2 pos1 = vertices[i].WorldPos;
-                Vector2 pos2 = vertices[(i + 1) % 4].WorldPos;
-
-                Vector2 middle = (pos1 + pos2) / 2;
-
-                Vector2 L = viewPosition - middle;
-
-                Vector2 N = new Vector2(
-                    -(pos2.Y - pos1.Y),
-                    pos2.X - pos1.X);
-
-                if (Vector2.Dot(N, L) > 0)
+                if (IsSegmentFacing(vertices[i].WorldPos, vertices[(i + 1) % 4].WorldPos, viewPosition))
                 {
                     visibleSegments.Add(segments[i]);
                 }
             }
         }
 
-
         public void RefreshWorldPositions()
         {
             for (int i = 0; i < 4; i++)
@@ -676,34 +439,12 @@ namespace Barotrauma.Lights
 
             ShadowVertexCount = 0;
 
-            //compute facing of each edge, using N*L
-            for (int i = 0; i < 4; i++)
+            for (int i = 0; i < losVertices.Length; i++)
             {
-                if (ignoreEdge[i])
-                {
-                    backFacing[i] = false;
-                    continue;
-                }
-
-                Vector2 firstVertex = losVertices[i].Pos;
-                Vector2 secondVertex = losVertices[(i+1) % 4].Pos;
-
-                Vector2 L = lightSourcePos - ((firstVertex + secondVertex) / 2.0f);
-
-                Vector2 N = new Vector2(
-                    -(secondVertex.Y - firstVertex.Y),
-                    secondVertex.X - firstVertex.X);
-
-                backFacing[i] = (Vector2.Dot(N, L) < 0);
-            }
-
-            ShadowVertexCount = 0;
-            for (int i = 0; i < 4; i++)
-            {
-                if (!backFacing[i]) { continue; }
                 int currentIndex = i;
-                Vector3 vertexPos0 = new Vector3(losOffsets[currentIndex]?.A ?? losVertices[currentIndex].Pos, 0.0f);
-                Vector3 vertexPos1 = new Vector3(losOffsets[currentIndex]?.B ?? losVertices[(currentIndex + 1) % 4].Pos, 0.0f);
+                int nextIndex = (currentIndex + 1) % 2;
+                Vector3 vertexPos0 = new Vector3(losVertices[currentIndex].Pos + losOffsets[currentIndex], 0.0f);
+                Vector3 vertexPos1 = new Vector3(losVertices[nextIndex].Pos + losOffsets[nextIndex], 0.0f);
 
                 if (Vector3.DistanceSquared(vertexPos0, vertexPos1) < 1.0f) { continue; }
 
@@ -754,9 +495,24 @@ namespace Barotrauma.Lights
                 ShadowVertexCount += 6;
             }
 
+            if (IsSegmentFacing(losVertices[0].Pos, losVertices[1].Pos, lightSourcePos))
+            {
+                Array.Reverse(ShadowVertices);
+            }
+
             CalculateLosPenumbraVertices(lightSourcePos);
         }
 
+        private static bool IsSegmentFacing(Vector2 segmentPos1, Vector2 segmentPos2, Vector2 viewPosition)
+        {
+            Vector2 segmentMid = (segmentPos1 + segmentPos2) / 2;
+            Vector2 segmentDiff = segmentPos2 - segmentPos1;
+            Vector2 segmentNormal = new Vector2(-segmentDiff.Y, segmentDiff.X);
+
+            Vector2 viewDirection = viewPosition - segmentMid;
+            return Vector2.Dot(segmentNormal, viewDirection) > 0;
+        }
+
         private void CalculateLosPenumbraVertices(Vector2 lightSourcePos)
         {
             Vector3 offset = Vector3.Zero;
@@ -766,73 +522,101 @@ namespace Barotrauma.Lights
             }
 
             PenumbraVertexCount = 0;
-            for (int i = 0; i < 4; i++)
+            for (int i = 0; i < losVertices.Length; i++)
             {
                 int currentIndex = i;
-                int prevIndex = (i + 3) % 4;
-                int nextIndex = (i + 1) % 4;
-                bool disjointed = losOffsets[i]?.A != null;
-                Vector2 vertexPos0 = losOffsets[currentIndex]?.A ?? losVertices[currentIndex].Pos;
-                Vector2 vertexPos1 = losOffsets[currentIndex]?.B ?? losVertices[nextIndex].Pos;
+                int nextIndex = (i + 1) % 2;
+                Vector2 vertexPos0 = losVertices[currentIndex].Pos + losOffsets[currentIndex];
+                Vector2 vertexPos1 = losVertices[nextIndex].Pos + losOffsets[nextIndex];
 
                 if (Vector2.DistanceSquared(vertexPos0, vertexPos1) < 1.0f) { continue; }
+                      
+                Vector3 penumbraStart = new Vector3(vertexPos0, 0.0f);
 
-                if (backFacing[currentIndex] && (disjointed || (!backFacing[prevIndex])))
+                PenumbraVertices[PenumbraVertexCount] = new VertexPositionTexture
                 {
-                    Vector3 penumbraStart = new Vector3(vertexPos0, 0.0f);
+                    Position = penumbraStart + offset,
+                    TextureCoordinate = new Vector2(0.0f, 1.0f)
+                };
 
-                    PenumbraVertices[PenumbraVertexCount] = new VertexPositionTexture
-                    {
-                        Position = penumbraStart + offset,
-                        TextureCoordinate = new Vector2(0.0f, 1.0f)
-                    };
+                for (int j = 0; j < 2; j++)
+                {
+                    PenumbraVertices[PenumbraVertexCount + j + 1] = new VertexPositionTexture();
+                    Vector3 vertexDir = penumbraStart - new Vector3(lightSourcePos, 0);
+                    vertexDir.Normalize();
 
-                    for (int j = 0; j < 2; j++)
-                    {
-                        PenumbraVertices[PenumbraVertexCount + j + 1] = new VertexPositionTexture();
-                        Vector3 vertexDir = penumbraStart - new Vector3(lightSourcePos, 0);
-                        vertexDir.Normalize();
+                    Vector3 normal = (j == 0) ? new Vector3(-vertexDir.Y, vertexDir.X, 0.0f) : new Vector3(vertexDir.Y, -vertexDir.X, 0.0f) * 0.05f;
 
-                        Vector3 normal = (j == 0) ? new Vector3(-vertexDir.Y, vertexDir.X, 0.0f) : new Vector3(vertexDir.Y, -vertexDir.X, 0.0f) * 0.05f;
+                    vertexDir = penumbraStart - (new Vector3(lightSourcePos, 0) - normal * 20.0f);
+                    vertexDir.Normalize();
+                    PenumbraVertices[PenumbraVertexCount + j + 1].Position = new Vector3(lightSourcePos, 0) + vertexDir * 9000 + offset;
 
-                        vertexDir = penumbraStart - (new Vector3(lightSourcePos, 0) - normal * 20.0f);
-                        vertexDir.Normalize();
-                        PenumbraVertices[PenumbraVertexCount + j + 1].Position = new Vector3(lightSourcePos, 0) + vertexDir * 9000 + offset;
-
-                        PenumbraVertices[PenumbraVertexCount + j + 1].TextureCoordinate = (j == 0) ? new Vector2(0.05f, 0.0f) : new Vector2(1.0f, 0.0f);
-                    }
-
-                    PenumbraVertexCount += 3;
+                    PenumbraVertices[PenumbraVertexCount + j + 1].TextureCoordinate = (j == 0) ? new Vector2(0.05f, 0.0f) : new Vector2(1.0f, 0.0f);
                 }
 
-                disjointed = losOffsets[i]?.B != null;
-                if (backFacing[currentIndex] && (disjointed || (!backFacing[nextIndex])))
+                PenumbraVertexCount += 3;
+                
+                penumbraStart = new Vector3(vertexPos1, 0.0f);
+
+                PenumbraVertices[PenumbraVertexCount] = new VertexPositionTexture
                 {
-                    Vector3 penumbraStart = new Vector3(vertexPos1, 0.0f);
+                    Position = penumbraStart + offset,
+                    TextureCoordinate = new Vector2(0.0f, 1.0f)
+                };
 
-                    PenumbraVertices[PenumbraVertexCount] = new VertexPositionTexture
-                    {
-                        Position = penumbraStart + offset,
-                        TextureCoordinate = new Vector2(0.0f, 1.0f)
-                    };
+                for (int j = 0; j < 2; j++)
+                {
+                    PenumbraVertices[PenumbraVertexCount + (1 - j) + 1] = new VertexPositionTexture();
+                    Vector3 vertexDir = penumbraStart - new Vector3(lightSourcePos, 0);
+                    vertexDir.Normalize();
 
-                    for (int j = 0; j < 2; j++)
-                    {
-                        PenumbraVertices[PenumbraVertexCount + (1 - j) + 1] = new VertexPositionTexture();
-                        Vector3 vertexDir = penumbraStart - new Vector3(lightSourcePos, 0);
-                        vertexDir.Normalize();
+                    Vector3 normal = (j == 0) ? new Vector3(-vertexDir.Y, vertexDir.X, 0.0f) : new Vector3(vertexDir.Y, -vertexDir.X, 0.0f) * 0.05f;
 
-                        Vector3 normal = (j == 0) ? new Vector3(-vertexDir.Y, vertexDir.X, 0.0f) : new Vector3(vertexDir.Y, -vertexDir.X, 0.0f) * 0.05f;
+                    vertexDir = penumbraStart - (new Vector3(lightSourcePos, 0) + normal * 20.0f);
+                    vertexDir.Normalize();
+                    PenumbraVertices[PenumbraVertexCount + (1 - j) + 1].Position = new Vector3(lightSourcePos, 0) + vertexDir * 9000 + offset;
 
-                        vertexDir = penumbraStart - (new Vector3(lightSourcePos, 0) + normal * 20.0f);
-                        vertexDir.Normalize();
-                        PenumbraVertices[PenumbraVertexCount + (1 - j) + 1].Position = new Vector3(lightSourcePos, 0) + vertexDir * 9000 + offset;
-
-                        PenumbraVertices[PenumbraVertexCount + (1 - j) + 1].TextureCoordinate = (j == 0) ? new Vector2(0.05f, 0.0f) : new Vector2(1.0f, 0.0f);
-                    }
-
-                    PenumbraVertexCount += 3;
+                    PenumbraVertices[PenumbraVertexCount + (1 - j) + 1].TextureCoordinate = (j == 0) ? new Vector2(0.05f, 0.0f) : new Vector2(1.0f, 0.0f);
                 }
+
+                PenumbraVertexCount += 3;                
+            }
+        }
+
+        public void DebugDraw(SpriteBatch spriteBatch)
+        {
+            //RecalculateAll(Submarine.MainSub);
+            //RefreshWorldPositions();
+
+            DrawLine(losVertices[0].Pos, losVertices[1].Pos, Color.Gray * 0.5f, width: 3);
+            DrawLine(losVertices[0].Pos + losOffsets[0], losVertices[1].Pos + losOffsets[1], Color.LightGreen, width: 2);
+            DrawLine(GameMain.GameScreen.Cam.Position + Vector2.One * 1000, GameMain.GameScreen.Cam.Position - Vector2.One * 1000, Color.Magenta, width: 2);
+
+            if (GameMain.LightManager.LightingEnabled)
+            {
+                for (int i = 0; i < vertices.Length; i++)
+                {
+                    Vector2 start = vertices[i].Pos;
+                    Vector2 end = vertices[(i + 1) % 4].Pos;
+                    DrawLine(
+                       start,
+                       end, Color.Yellow * 0.5f,
+                       width: 4);
+                }
+            }
+
+            void DrawLine(Vector2 vertexPos0, Vector2 vertexPos1, Color color, int width)
+            {
+                if (ParentEntity != null && ParentEntity.Submarine != null)
+                {
+                    vertexPos0 += ParentEntity.Submarine.DrawPosition;
+                    vertexPos1 += ParentEntity.Submarine.DrawPosition;
+                }
+                Vector2 viewTargetPos = LightManager.ViewTarget.WorldPosition;
+                float alpha = IsSegmentFacing(vertexPos0, vertexPos1, viewTargetPos) ? 1.0f : 0.5f;
+                vertexPos0.Y = -vertexPos0.Y;
+                vertexPos1.Y = -vertexPos1.Y;
+                GUI.DrawLine(spriteBatch, vertexPos0, vertexPos1, color * alpha, width: width);
             }
         }
 
@@ -903,16 +687,13 @@ namespace Barotrauma.Lights
                 {
                     HullLists.Remove(chList);
                 }
-                foreach (ConvexHull ch2 in overlappingHulls)
+                //create a new list because MergeLosVertices can edit overlappingHulls
+                foreach (ConvexHull ch2 in overlappingHulls.ToList())
                 {
-                    for (int i = 0; i < 4; i++)
-                    {
-                        ch2.ignoreEdge[i] = false;
-                    }
                     ch2.overlappingHulls.Remove(this);
                     foreach (ConvexHull ch in chList.List)
                     {
-                        ch.MergeOverlappingSegments(ch2);
+                        ch.MergeLosVertices(ch2);
                     }
                 }
             }

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

@@ -5,6 +5,7 @@ using System.Linq;
 using System;
 using Barotrauma.Items.Components;
 using Barotrauma.Extensions;
+using System.Threading;
 
 namespace Barotrauma.Lights
 {
@@ -22,6 +23,9 @@ namespace Barotrauma.Lights
         /// </summary>
         const float ObstructLightsBehindCharactersZoomThreshold = 0.5f;
 
+        private Thread rayCastThread;
+        private Queue<RayCastTask> pendingRayCasts = new Queue<RayCastTask>();
+
         public static Entity ViewTarget { get; set; }
 
         private float currLightMapScale;
@@ -58,6 +62,8 @@ namespace Barotrauma.Lights
 
         private readonly List<LightSource> lights;
 
+        public bool DebugLos;
+
         public bool LosEnabled = true;
         public float LosAlpha = 1f;
         public LosMode LosMode = LosMode.Transparent;
@@ -68,6 +74,8 @@ namespace Barotrauma.Lights
 
         private readonly Texture2D visionCircle;
 
+        private readonly Texture2D gapGlowTexture;
+
         private Vector2 losOffset;
 
         private int recalculationCount;
@@ -85,8 +93,16 @@ namespace Barotrauma.Lights
 
             AmbientLight = new Color(20, 20, 20, 255);
 
+            rayCastThread = new Thread(UpdateRayCasts)
+            {
+                Name = "LightManager Raycast thread",
+                IsBackground = true //this should kill the thread if the game crashes
+            };
+            rayCastThread.Start();
+
             visionCircle = Sprite.LoadTexture("Content/Lights/visioncircle.png");
             highlightRaster = Sprite.LoadTexture("Content/UI/HighlightRaster.png");
+            gapGlowTexture = Sprite.LoadTexture("Content/Lights/pointlight_rays.png");
 
             GameMain.Instance.ResolutionChanged += () =>
             {
@@ -100,15 +116,12 @@ namespace Barotrauma.Lights
                 LosEffect = EffectLoader.Load("Effects/losshader");
                 SolidColorEffect = EffectLoader.Load("Effects/solidcolor");
 
-                if (lightEffect == null)
-                {
-                    lightEffect = new BasicEffect(GameMain.Instance.GraphicsDevice)
+                lightEffect ??= new BasicEffect(GameMain.Instance.GraphicsDevice)
                     {
                         VertexColorEnabled = true,
                         TextureEnabled = true,
                         Texture = LightSource.LightTexture
                     };
-                }
             });
         }
 
@@ -155,7 +168,7 @@ namespace Barotrauma.Lights
         {
             foreach (LightSource light in lights)
             {
-                light.NeedsHullCheck = true;
+                light.HullsUpToDate.Clear();
                 light.NeedsRecalculation = true;
             }
         }
@@ -176,6 +189,51 @@ namespace Barotrauma.Lights
             }
         }
 
+        private class RayCastTask
+        {
+            public LightSource LightSource;
+            public Vector2 DrawPos;
+            public float Rotation;
+
+            public RayCastTask(LightSource lightSource, Vector2 drawPos, float rotation)
+            {
+                LightSource = lightSource;
+                DrawPos = drawPos;
+                Rotation = rotation;
+            }
+
+            public void Calculate()
+            {
+                LightSource.RayCastTask(DrawPos, Rotation);
+            }
+        }
+
+        private static readonly object mutex = new object();
+
+        public void AddRayCastTask(LightSource lightSource, Vector2 drawPos, float rotation)
+        {
+            lock (mutex)
+            {
+                if (pendingRayCasts.Any(p => p.LightSource == lightSource)) { return; }
+                pendingRayCasts.Enqueue(new RayCastTask(lightSource, drawPos, rotation));
+            }
+        }
+
+        private void UpdateRayCasts()
+        {
+            while (true)
+            {
+                lock (mutex)
+                {
+                    while (pendingRayCasts.Count > 0)
+                    {
+                        pendingRayCasts.Dequeue().Calculate();
+                    }
+                }
+                Thread.Sleep(10);
+            }
+        }
+
         public void RenderLightMap(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, RenderTarget2D backgroundObstructor = null)
         {
             if (!LightingEnabled) { return; }
@@ -287,8 +345,8 @@ namespace Barotrauma.Lights
             foreach (LightSource light in activeLights)
             {
                 if (!light.IsBackground || light.CurrentBrightness <= 0.0f) { continue; }
-                light.DrawSprite(spriteBatch, cam);
                 light.DrawLightVolume(spriteBatch, lightEffect, transform, recalculationCount < MaxLightVolumeRecalculationsPerFrame, ref recalculationCount);
+                light.DrawSprite(spriteBatch, cam);
             }
             GameMain.ParticleManager.Draw(spriteBatch, true, null, Particles.ParticleBlendState.Additive);
             spriteBatch.End();
@@ -307,15 +365,46 @@ namespace Barotrauma.Lights
             }
             spriteBatch.End();
 
-            SolidColorEffect.CurrentTechnique = SolidColorEffect.Techniques["SolidColor"];
-            SolidColorEffect.Parameters["color"].SetValue(AmbientLight.Opaque().ToVector4());
-            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, transformMatrix: spriteBatchTransform, effect: SolidColorEffect);
-            Submarine.DrawDamageable(spriteBatch, null);
+            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, transformMatrix: spriteBatchTransform);
+            Vector3 glowColorHSV = ToolBox.RGBToHSV(AmbientLight);
+            glowColorHSV.Z = Math.Max(glowColorHSV.Z, 0.4f);
+            Color glowColor = ToolBox.HSVToRGB(glowColorHSV.X, glowColorHSV.Y, glowColorHSV.Z);
+            Vector2 glowSpriteSize = new Vector2(gapGlowTexture.Width, gapGlowTexture.Height);
+            foreach (var gap in Gap.GapList)
+            {
+                if (gap.IsRoomToRoom || gap.Open <= 0.0f || gap.ConnectedWall == null) { continue; }
+
+                float a = MathHelper.Lerp(0.5f, 1.0f,
+                    PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.05f, gap.GlowEffectT));
+
+                float scale = MathHelper.Lerp(0.5f, 2.0f,
+                    PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.01f, gap.GlowEffectT));
+
+                float rot = PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.001f, gap.GlowEffectT) * MathHelper.TwoPi;
+
+                Vector2 spriteScale = new Vector2(gap.Rect.Width, gap.Rect.Height) / glowSpriteSize;
+                Vector2 drawPos = new Vector2(gap.DrawPosition.X, -gap.DrawPosition.Y);
+
+                spriteBatch.Draw(gapGlowTexture,
+                    drawPos,
+                    null,
+                    glowColor * a,
+                    rot,
+                    glowSpriteSize / 2,
+                    scale: Math.Max(spriteScale.X, spriteScale.Y) * scale,
+                    SpriteEffects.None,
+                    layerDepth: 0);
+            }
+            spriteBatch.End();
+
+            GameMain.GameScreen.DamageEffect.CurrentTechnique = GameMain.GameScreen.DamageEffect.Techniques["StencilShaderSolidColor"];
+            GameMain.GameScreen.DamageEffect.Parameters["solidColor"].SetValue(Color.Black.ToVector4());
+            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied, SamplerState.LinearWrap, transformMatrix: spriteBatchTransform, effect: GameMain.GameScreen.DamageEffect);
+            Submarine.DrawDamageable(spriteBatch, GameMain.GameScreen.DamageEffect);
             spriteBatch.End();
 
             graphics.BlendState = BlendState.Additive;
 
-
             //draw the focused item and character to highlight them,
             //and light sprites (done before drawing the actual light volumes so we can make characters obstruct the highlights and sprites)
             //---------------------------------------------------------------------------------------------------
@@ -449,9 +538,9 @@ namespace Barotrauma.Lights
                 {
                     highlightedEntities.Add(Character.Controlled.FocusedCharacter);
                 }
-                foreach (Item item in Item.ItemList)
+                foreach (MapEntity me in MapEntity.HighlightedEntities)
                 {
-                    if ((item.IsHighlighted || item.IconStyle != null) && !highlightedEntities.Contains(item))
+                    if (me is Item item && item != Character.Controlled.FocusedItem)
                     {
                         highlightedEntities.Add(item);
                     }
@@ -565,7 +654,7 @@ namespace Barotrauma.Lights
 
         public void UpdateObstructVision(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, Vector2 lookAtPosition)
         {
-            if ((!LosEnabled || LosMode == LosMode.None) && !ObstructVision) return;
+            if ((!LosEnabled || LosMode == LosMode.None) && !ObstructVision) { return; }
             if (ViewTarget == null) return;
 
             graphics.SetRenderTarget(LosTexture);
@@ -597,23 +686,30 @@ namespace Barotrauma.Lights
             if (LosEnabled && LosMode != LosMode.None && ViewTarget != null)
             {
                 Vector2 pos = ViewTarget.DrawPosition;
+                if (ViewTarget is Character character && 
+                    character.AnimController?.GetLimb(LimbType.Head) is Limb head &&
+                    !head.IsSevered && !head.Removed)
+                {
+                    pos = head.body.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>();
                     List<VertexPositionTexture> penumbraVerts = new List<VertexPositionTexture>();
                     foreach (ConvexHull convexHull in convexHulls)
                     {
-                        if (!convexHull.Enabled || !convexHull.Intersects(camView)) continue;
+                        if (!convexHull.Enabled || !convexHull.Intersects(camView)) { continue; }
+                        if (LosMode == LosMode.BlockOutsideView && !convexHull.IsExteriorWall) { continue; };
 
                         Vector2 relativeLightPos = pos;
-                        if (convexHull.ParentEntity?.Submarine != null) relativeLightPos -= convexHull.ParentEntity.Submarine.Position;
+                        if (convexHull.ParentEntity?.Submarine != null) { relativeLightPos -= convexHull.ParentEntity.Submarine.Position; }
 
                         convexHull.CalculateLosVertices(relativeLightPos);
 
@@ -646,6 +742,20 @@ namespace Barotrauma.Lights
             graphics.SetRenderTarget(null);
         }
 
+        public void DebugDrawLos(SpriteBatch spriteBatch, Camera cam)
+        {
+            if (ViewTarget == null) { return; }
+            spriteBatch.Begin(SpriteSortMode.Deferred, transformMatrix: cam.Transform);
+            var convexHulls = ConvexHull.GetHullsInRange(ViewTarget.Position, cam.WorldView.Width * 0.75f, ViewTarget?.Submarine);
+            Rectangle camView = new Rectangle(cam.WorldView.X, cam.WorldView.Y - cam.WorldView.Height, cam.WorldView.Width, cam.WorldView.Height);
+            foreach (ConvexHull convexHull in convexHulls)
+            {
+                if (!convexHull.Enabled || !convexHull.Intersects(camView)) { continue; }
+                convexHull.DebugDraw(spriteBatch);
+            }
+            spriteBatch.End();
+        }
+
         public void ClearLights()
         {
             lights.Clear();

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

@@ -15,6 +15,7 @@ namespace Barotrauma.Lights
 
         public bool Persistent;
 
+
         public Dictionary<Identifier, SerializableProperty> SerializableProperties { get; private set; } = new Dictionary<Identifier, SerializableProperty>();
 
         [Serialize("1.0,1.0,1.0,1.0", IsPropertySaveable.Yes, alwaysUseInstanceValues: true), Editable]
@@ -52,6 +53,10 @@ namespace Barotrauma.Lights
         [Serialize(0f, IsPropertySaveable.Yes), Editable(MinValueFloat = -360, MaxValueFloat = 360, ValueStep = 1, DecimalCount = 0)]
         public float Rotation { get; set; }
 
+        [Serialize(false, IsPropertySaveable.Yes, "Directional lights only shine in \"one direction\", meaning no shadows are cast behind them."+
+            " Note that this does not affect how the light texture is drawn: if you want something like a conical spotlight, you should use an appropriate texture for that.")]
+        public bool Directional { get; set; }
+
         public Vector2 GetOffset() => Vector2.Transform(Offset, Matrix.CreateRotationZ(MathHelper.ToRadians(Rotation)));
 
         private float flicker;
@@ -203,7 +208,7 @@ namespace Barotrauma.Lights
         private VertexPositionColorTexture[] vertices;
         private short[] indices;
 
-        private readonly List<ConvexHullList> hullsInRange;
+        private readonly List<ConvexHullList> convexHullsInRange;
 
         public Texture2D texture;
 
@@ -222,9 +227,10 @@ namespace Barotrauma.Lights
         private float prevCalculatedRange;
         private Vector2 prevCalculatedPosition;
 
-        //do we need to recheck which convex hulls are within range
-        //(e.g. position or range of the lightsource has changed)
-        public bool NeedsHullCheck = true;
+        //Which submarines' convex hulls are up to date? Resets when the item moves/rotates relative to the submarine.
+        //Can contain null (means convex hulls that aren't part of any submarine).
+        public HashSet<Submarine> HullsUpToDate = new HashSet<Submarine>();
+
         //do we need to recalculate the vertices of the light volume
         private bool needsRecalculation;
         public bool NeedsRecalculation
@@ -234,7 +240,7 @@ namespace Barotrauma.Lights
             {
                 if (!needsRecalculation && value)
                 {
-                    foreach (ConvexHullList chList in hullsInRange)
+                    foreach (ConvexHullList chList in convexHullsInRange)
                     {
                         chList.IsHidden.Clear();
                     }
@@ -246,6 +252,18 @@ namespace Barotrauma.Lights
         //when were the vertices of the light volume last calculated
         public float LastRecalculationTime { get; private set; }
 
+
+        private enum LightVertexState
+        {
+            UpToDate,
+            PendingRayCasts,
+            PendingVertexRecalculation,
+        }
+
+        private LightVertexState state;
+
+        private Vector2 calculatedDrawPos;
+
         private readonly Dictionary<Submarine, Vector2> diffToSub;
 
         private DynamicVertexBuffer lightVolumeBuffer;
@@ -254,7 +272,6 @@ namespace Barotrauma.Lights
         private int indexCount;
 
         private Vector2 translateVertices;
-        private float rotateVertices;
 
         private readonly LightSourceParams lightSourceParams;
 
@@ -277,7 +294,7 @@ namespace Barotrauma.Lights
                     return;
                 }
 
-                NeedsHullCheck = true;
+                HullsUpToDate.Clear();
                 NeedsRecalculation = true;
             }
         }
@@ -292,17 +309,20 @@ namespace Barotrauma.Lights
                 if (Math.Abs(value - rotation) < 0.001f) { return; }
                 rotation = value;
 
+                dir = new Vector2(MathF.Cos(rotation), -MathF.Sin(rotation));
+
                 if (Math.Abs(rotation - prevCalculatedRotation) < RotationRecalculationThreshold && vertices != null)
                 {
-                    rotateVertices = rotation - prevCalculatedRotation;
                     return;
                 }
 
-                NeedsHullCheck = true;
+                HullsUpToDate.Clear();
                 NeedsRecalculation = true;
             }
         }
 
+        private Vector2 dir = Vector2.UnitX;
+
         private Vector2 _spriteScale = Vector2.One;
 
         public Vector2 SpriteScale
@@ -368,7 +388,7 @@ namespace Barotrauma.Lights
                 lightSourceParams.Range = value;
                 if (Math.Abs(prevCalculatedRange - lightSourceParams.Range) < 10.0f) return;
 
-                NeedsHullCheck = true;
+                HullsUpToDate.Clear();
                 NeedsRecalculation = true;
                 prevCalculatedRange = lightSourceParams.Range;
             }
@@ -384,8 +404,8 @@ namespace Barotrauma.Lights
             set
             {
                 NeedsRecalculation = true;
-                NeedsHullCheck = true;
                 lightTextureTargetSize = value;
+                HullsUpToDate.Clear();
             }
         }
 
@@ -424,7 +444,7 @@ namespace Barotrauma.Lights
         public bool Enabled = true;
 
         private readonly ISerializableEntity conditionalTarget;
-        private readonly PropertyConditional.Comparison comparison;
+        private readonly PropertyConditional.LogicalOperatorType logicalOperator;
         private readonly List<PropertyConditional> conditionals = new List<PropertyConditional>();
 
         public LightSource(ContentXElement element, ISerializableEntity conditionalTarget = null)
@@ -432,11 +452,8 @@ namespace Barotrauma.Lights
         {
             lightSourceParams = new LightSourceParams(element);
             CastShadows = element.GetAttributeBool("castshadows", true);
-            string comparison = element.GetAttributeString("comparison", null);
-            if (comparison != null)
-            {
-                Enum.TryParse(comparison, ignoreCase: true, out this.comparison);
-            }
+            logicalOperator = element.GetAttributeEnum(nameof(logicalOperator),
+                element.GetAttributeEnum("comparison", logicalOperator));
 
             if (lightSourceParams.DeformableLightSpriteElement != null)
             {
@@ -449,13 +466,7 @@ namespace Barotrauma.Lights
                 switch (subElement.Name.ToString().ToLowerInvariant())
                 {
                     case "conditional":
-                        foreach (XAttribute attribute in subElement.Attributes())
-                        {
-                            if (PropertyConditional.IsValid(attribute))
-                            {
-                                conditionals.Add(new PropertyConditional(attribute));
-                            }
-                        }
+                        conditionals.AddRange(PropertyConditional.FromXElement(subElement));
                         break;
                 }
             }
@@ -474,7 +485,7 @@ namespace Barotrauma.Lights
 
         public LightSource(Vector2 position, float range, Color color, Submarine submarine, bool addLight=true)
         {
-            hullsInRange = new List<ConvexHullList>();
+            convexHullsInRange = new List<ConvexHullList>();
             this.ParentSub = submarine;
             this.position = position;
             lightSourceParams = new LightSourceParams(range, color);
@@ -515,19 +526,46 @@ namespace Barotrauma.Lights
         /// </summary>
         private void RefreshConvexHullList(ConvexHullList chList, Vector2 lightPos, Submarine sub)
         {
-            var fullChList = ConvexHull.HullLists.Find(x => x.Submarine == sub);
+            var fullChList = ConvexHull.HullLists.FirstOrDefault(chList => chList.Submarine == sub);
             if (fullChList == null) { return; }
 
-            chList.List = fullChList.List.FindAll(ch => ch.Enabled && MathUtils.CircleIntersectsRectangle(lightPos, TextureRange, ch.BoundingBox));
+            //used to check whether the lightsource hits the target hull if the light is directional
+            Vector2 ray = new Vector2(dir.X, -dir.Y) * TextureRange;
+            Vector2 normal = new Vector2(-ray.Y, ray.X);
 
-            NeedsHullCheck = true;
+            chList.List.Clear();
+            foreach (var convexHull in fullChList.List)
+            {
+                if (!convexHull.Enabled) { continue; }
+                if (!MathUtils.CircleIntersectsRectangle(lightPos, TextureRange, convexHull.BoundingBox)) { continue; }
+                if (lightSourceParams.Directional && false)
+                {
+                    Rectangle bounds = convexHull.BoundingBox;
+                    //invert because GetLineRectangleIntersection uses the messed up rects that start from top-left
+                    bounds.Y -= bounds.Height;
+
+                    //the ray can't hit if
+                    //  center is in the opposite direction from the ray (cheapest check first)
+                    if (Vector2.Dot(ray, convexHull.BoundingBox.Center.ToVector2() - lightPos) <= 0 &&
+                        /*ray doesn't hit the convex hull*/
+                        !MathUtils.GetLineRectangleIntersection(lightPos, lightPos + ray, bounds, out _) &&
+                        /*normal vectors of the ray don't hit the convex hull */
+                        !MathUtils.GetLineRectangleIntersection(lightPos + normal, lightPos - normal, bounds, out _))
+                    {
+                        continue;
+                    }
+                }
+                chList.List.Add(convexHull);
+            }
+            chList.IsHidden.RemoveWhere(ch => !chList.List.Contains(ch));
+            HullsUpToDate.Add(sub);    
         }
 
         /// <summary>
         /// Recheck which convex hulls are in range (if needed),
         /// and check if we need to recalculate vertices due to changes in the convex hulls
         /// </summary>
-        private void CheckHullsInRange()
+        private void CheckConvexHullsInRange()
         {
             foreach (Submarine sub in Submarine.Loaded)
             {
@@ -540,21 +578,13 @@ namespace Barotrauma.Lights
         private void CheckHullsInRange(Submarine sub)
         {
             //find the list of convexhulls that belong to the sub
-            ConvexHullList chList = null; 
-            foreach (var ch in hullsInRange)
-            {
-                if (ch.Submarine == sub)
-                {
-                    chList = ch;
-                    break;
-                }
-            }
-                
+            ConvexHullList chList = convexHullsInRange.FirstOrDefault(chList => chList.Submarine == sub);
+            
             //not found -> create one
             if (chList == null)
             {
                 chList = new ConvexHullList(sub);
-                hullsInRange.Add(chList);
+                convexHullsInRange.Add(chList);
                 NeedsRecalculation = true;
             }
 
@@ -573,7 +603,7 @@ namespace Barotrauma.Lights
                 //light and the convexhulls are both outside
                 if (sub == null)
                 {
-                    if (NeedsHullCheck)
+                    if (!HullsUpToDate.Contains(null))
                     {
                         RefreshConvexHullList(chList, lightPos, null);
                     }
@@ -605,7 +635,7 @@ namespace Barotrauma.Lights
                 //light and convexhull are both inside the same sub
                 if (sub == ParentSub)
                 {
-                    if (NeedsHullCheck)
+                    if (!HullsUpToDate.Contains(sub))
                     {
                         RefreshConvexHullList(chList, lightPos, sub);
                     }
@@ -613,7 +643,7 @@ namespace Barotrauma.Lights
                 //light and convexhull are inside different subs
                 else
                 {
-                    if (sub.DockedTo.Contains(ParentSub) && !NeedsHullCheck) { return; }
+                    if (sub.DockedTo.Contains(ParentSub) && HullsUpToDate.Contains(sub)) { return; }
 
                     lightPos -= (sub.Position - ParentSub.Position);
 
@@ -646,19 +676,45 @@ namespace Barotrauma.Lights
             }            
         }
 
-        private List<Vector2> FindRaycastHits()
+        private static readonly object mutex = new object();
+
+        private readonly List<Segment> visibleSegments = new List<Segment>();
+        private readonly List<SegmentPoint> points = new List<SegmentPoint>();
+        private readonly List<Vector2> verts = new List<Vector2>();
+        private readonly SegmentPoint[] boundaryCorners = new SegmentPoint[4];
+        private void FindRaycastHits()
         {
-            if (!CastShadows || Range < 1.0f || Color.A < 1) { return null; }
+            if (!CastShadows || Range < 1.0f || Color.A < 1) 
+            {
+                state = LightVertexState.PendingVertexRecalculation;
+                return;            
+            }
 
             Vector2 drawPos = position;
             if (ParentSub != null) { drawPos += ParentSub.DrawPosition; }
 
-            var hulls = new List<ConvexHull>();
-            foreach (ConvexHullList chList in hullsInRange)
+            visibleSegments.Clear();
+            foreach (ConvexHullList chList in convexHullsInRange)
             {
                 foreach (ConvexHull hull in chList.List)
                 {
-                    if (!chList.IsHidden.Contains(hull)) { hulls.Add(hull); }
+                    if (!chList.IsHidden.Contains(hull)) 
+                    {
+                        //find convexhull segments that are close enough and facing towards the light source
+                        lock (mutex)
+                        {
+                            hull.RefreshWorldPositions();
+                            hull.GetVisibleSegments(drawPos, visibleSegments);
+                            foreach (var visibleSegment in visibleSegments)
+                            {
+                                if (visibleSegment.ConvexHull?.ParentEntity?.Submarine != null)
+                                {
+                                    visibleSegment.SubmarineDrawPos = visibleSegment.ConvexHull.ParentEntity.Submarine.DrawPosition;
+                                }
+                            }
+                        }
+                        
+                    }
                 }
                 foreach (ConvexHull hull in chList.List)
                 {
@@ -666,27 +722,19 @@ namespace Barotrauma.Lights
                 }
             }
 
-            float bounds = TextureRange;
-            //find convexhull segments that are close enough and facing towards the light source
-            List<Segment> visibleSegments = new List<Segment>();
-            List<SegmentPoint> points = new List<SegmentPoint>();
-            foreach (ConvexHull hull in hulls)
-            {
-                hull.RefreshWorldPositions();
-                hull.GetVisibleSegments(drawPos, visibleSegments, ignoreEdges: false);
-            }
+            state = LightVertexState.PendingRayCasts;
+            GameMain.LightManager.AddRayCastTask(this, drawPos, rotation);
+        }
 
-            //add a square-shaped boundary to make sure we've got something to construct the triangles from
-            //even if there aren't enough hull segments around the light source
-
-            //(might be more effective to calculate if we actually need these extra points)
 
+        public void RayCastTask(Vector2 drawPos, float rotation)
+        {
             Vector2 drawOffset = Vector2.Zero;
-            float boundsExtended = bounds;
+            float boundsExtended = TextureRange;
             if (OverrideLightTexture != null)
             {
-                float cosAngle = (float)Math.Cos(Rotation);
-                float sinAngle = -(float)Math.Sin(Rotation);
+                float cosAngle = (float)Math.Cos(rotation);
+                float sinAngle = -(float)Math.Sin(rotation);
 
                 var overrideTextureDims = new Vector2(OverrideLightTexture.SourceRect.Width, OverrideLightTexture.SourceRect.Height);
 
@@ -706,12 +754,16 @@ namespace Barotrauma.Lights
                 drawOffset.Y = origin.X * sinAngle + origin.Y * cosAngle;
             }
 
-            var boundaryCorners = new SegmentPoint[] {
-                new SegmentPoint(new Vector2(drawPos.X + drawOffset.X + boundsExtended, drawPos.Y + drawOffset.Y + boundsExtended), null),
-                new SegmentPoint(new Vector2(drawPos.X + drawOffset.X + boundsExtended, drawPos.Y + drawOffset.Y - boundsExtended), null),
-                new SegmentPoint(new Vector2(drawPos.X + drawOffset.X - boundsExtended, drawPos.Y + drawOffset.Y - boundsExtended), null),
-                new SegmentPoint(new Vector2(drawPos.X + drawOffset.X - boundsExtended, drawPos.Y + drawOffset.Y + boundsExtended), null)
-            };
+            //add a square-shaped boundary to make sure we've got something to construct the triangles from
+            //even if there aren't enough hull segments around the light source
+
+            //(might be more effective to calculate if we actually need these extra points)
+            Vector2 boundsMin = drawPos + drawOffset + new Vector2(-boundsExtended, -boundsExtended);
+            Vector2 boundsMax = drawPos + drawOffset + new Vector2(boundsExtended, boundsExtended);
+            boundaryCorners[0] = new SegmentPoint(boundsMax, null);
+            boundaryCorners[1] = new SegmentPoint(new Vector2(boundsMax.X, boundsMin.Y), null);
+            boundaryCorners[2] = new SegmentPoint(boundsMin, null);
+            boundaryCorners[3] = new SegmentPoint(new Vector2(boundsMin.X, boundsMax.Y), null);
 
             for (int i = 0; i < 4; i++)
             {
@@ -719,199 +771,200 @@ namespace Barotrauma.Lights
                 visibleSegments.Add(s);
             }
 
-            //Generate new points at the intersections between segments
-            //This is necessary for the light volume to generate properly on some subs
-            for (int i = 0; i < visibleSegments.Count; i++)
+            lock (mutex)
             {
-                Vector2 p1a = visibleSegments[i].Start.WorldPos;
-                Vector2 p1b = visibleSegments[i].End.WorldPos;
-
-                for (int j = i + 1; j < visibleSegments.Count; j++)
+                //Generate new points at the intersections between segments
+                //This is necessary for the light volume to generate properly on some subs
+                for (int i = 0; i < visibleSegments.Count; i++)
                 {
-                    //ignore intersections between parallel axis-aligned segments
-                    if (visibleSegments[i].IsAxisAligned && visibleSegments[j].IsAxisAligned &&
-                        visibleSegments[i].IsHorizontal == visibleSegments[j].IsHorizontal)
-                    {
-                        continue;
-                    }
+                    Vector2 p1a = visibleSegments[i].Start.WorldPos;
+                    Vector2 p1b = visibleSegments[i].End.WorldPos;
 
-                    Vector2 p2a = visibleSegments[j].Start.WorldPos;
-                    Vector2 p2b = visibleSegments[j].End.WorldPos;
-
-                    if (Vector2.DistanceSquared(p1a, p2a) < 5.0f ||
-                        Vector2.DistanceSquared(p1a, p2b) < 5.0f ||
-                        Vector2.DistanceSquared(p1b, p2a) < 5.0f ||
-                        Vector2.DistanceSquared(p1b, p2b) < 5.0f)
+                    for (int j = i + 1; j < visibleSegments.Count; j++)
                     {
-                        continue;
-                    }
-
-                    bool intersects;
-                    Vector2 intersection = Vector2.Zero;
-                    if (visibleSegments[i].IsAxisAligned)
-                    {
-                        intersects = MathUtils.GetAxisAlignedLineIntersection(p2a, p2b, p1a, p1b, visibleSegments[i].IsHorizontal, out intersection);
-                    }
-                    else if (visibleSegments[j].IsAxisAligned)
-                    {
-                        intersects = MathUtils.GetAxisAlignedLineIntersection(p1a, p1b, p2a, p2b, visibleSegments[j].IsHorizontal, out intersection);
-                    }
-                    else
-                    {
-                        intersects = MathUtils.GetLineIntersection(p1a, p1b, p2a, p2b, out intersection);
-                    }
-
-                    if (intersects)
-                    {
-                        SegmentPoint start = visibleSegments[i].Start;
-                        SegmentPoint end = visibleSegments[i].End;
-                        SegmentPoint mid = new SegmentPoint(intersection, null);
-                        if (visibleSegments[i].ConvexHull?.ParentEntity?.Submarine != null)
-                        {
-                            mid.Pos -= visibleSegments[i].ConvexHull.ParentEntity.Submarine.DrawPosition;
-                        }
-
-                        if (Vector2.DistanceSquared(start.WorldPos, mid.WorldPos) < 5.0f ||
-                            Vector2.DistanceSquared(end.WorldPos, mid.WorldPos) < 5.0f)
+                        //ignore intersections between parallel axis-aligned segments
+                        if (visibleSegments[i].IsAxisAligned && visibleSegments[j].IsAxisAligned &&
+                            visibleSegments[i].IsHorizontal == visibleSegments[j].IsHorizontal)
                         {
                             continue;
                         }
 
-                        Segment seg1 = new Segment(start, mid, visibleSegments[i].ConvexHull)
-                        {
-                            IsHorizontal = visibleSegments[i].IsHorizontal,
-                        };
+                        Vector2 p2a = visibleSegments[j].Start.WorldPos;
+                        Vector2 p2b = visibleSegments[j].End.WorldPos;
 
-                        Segment seg2 = new Segment(mid, end, visibleSegments[i].ConvexHull)
+                        if (Vector2.DistanceSquared(p1a, p2a) < 5.0f ||
+                            Vector2.DistanceSquared(p1a, p2b) < 5.0f ||
+                            Vector2.DistanceSquared(p1b, p2a) < 5.0f ||
+                            Vector2.DistanceSquared(p1b, p2b) < 5.0f)
                         {
-                            IsHorizontal = visibleSegments[i].IsHorizontal
-                        };
+                            continue;
+                        }
 
-                        visibleSegments[i] = seg1;
-                        visibleSegments.Insert(i + 1, seg2);
+                        bool intersects;
+                        Vector2 intersection = Vector2.Zero;
+                        if (visibleSegments[i].IsAxisAligned)
+                        {
+                            intersects = MathUtils.GetAxisAlignedLineIntersection(p2a, p2b, p1a, p1b, visibleSegments[i].IsHorizontal, out intersection);
+                        }
+                        else if (visibleSegments[j].IsAxisAligned)
+                        {
+                            intersects = MathUtils.GetAxisAlignedLineIntersection(p1a, p1b, p2a, p2b, visibleSegments[j].IsHorizontal, out intersection);
+                        }
+                        else
+                        {
+                            intersects = MathUtils.GetLineIntersection(p1a, p1b, p2a, p2b, out intersection);
+                        }
+
+                        if (intersects)
+                        {
+                            SegmentPoint start = visibleSegments[i].Start;
+                            SegmentPoint end = visibleSegments[i].End;
+                            SegmentPoint mid = new SegmentPoint(intersection, null);
+                            mid.Pos -= visibleSegments[i].SubmarineDrawPos;
+
+                            if (Vector2.DistanceSquared(start.WorldPos, mid.WorldPos) < 5.0f ||
+                                Vector2.DistanceSquared(end.WorldPos, mid.WorldPos) < 5.0f)
+                            {
+                                continue;
+                            }
+
+                            Segment seg1 = new Segment(start, mid, visibleSegments[i].ConvexHull)
+                            {
+                                IsHorizontal = visibleSegments[i].IsHorizontal,
+                            };
+
+                            Segment seg2 = new Segment(mid, end, visibleSegments[i].ConvexHull)
+                            {
+                                IsHorizontal = visibleSegments[i].IsHorizontal
+                            };
+
+                            visibleSegments[i] = seg1;
+                            visibleSegments.Insert(i + 1, seg2);
+                            i--;
+                            break;
+                        }
+                    }
+                }
+
+                points.Clear();
+                //remove segments that fall out of bounds
+                for (int i = 0; i < visibleSegments.Count; i++)
+                {
+                    Segment s = visibleSegments[i];
+                    if (Math.Abs(s.Start.WorldPos.X - drawPos.X - drawOffset.X) > boundsExtended + 1.0f ||
+                        Math.Abs(s.Start.WorldPos.Y - drawPos.Y - drawOffset.Y) > boundsExtended + 1.0f ||
+                        Math.Abs(s.End.WorldPos.X - drawPos.X - drawOffset.X) > boundsExtended + 1.0f ||
+                        Math.Abs(s.End.WorldPos.Y - drawPos.Y - drawOffset.Y) > boundsExtended + 1.0f)
+                    {
+                        visibleSegments.RemoveAt(i);
                         i--;
-                        break;
+                    }
+                    else
+                    {
+                        points.Add(s.Start);
+                        points.Add(s.End);
                     }
                 }
-            }
 
-            //remove segments that fall out of bounds
-            for (int i = 0; i < visibleSegments.Count; i++)
-            {
-                Segment s = visibleSegments[i];
-                if (Math.Abs(s.Start.WorldPos.X - drawPos.X - drawOffset.X) > boundsExtended + 1.0f ||
-                    Math.Abs(s.Start.WorldPos.Y - drawPos.Y - drawOffset.Y) > boundsExtended + 1.0f ||
-                    Math.Abs(s.End.WorldPos.X - drawPos.X - drawOffset.X) > boundsExtended + 1.0f ||
-                    Math.Abs(s.End.WorldPos.Y - drawPos.Y - drawOffset.Y) > boundsExtended + 1.0f)
+                //remove points that are very close to each other
+                for (int i = 0; i < points.Count; i++)
                 {
-                    visibleSegments.RemoveAt(i);
-                    i--;
+                    for (int j = Math.Min(i + 4, points.Count - 1); j > i; j--)
+                    {
+                        if (Math.Abs(points[i].WorldPos.X - points[j].WorldPos.X) < 6 &&
+                            Math.Abs(points[i].WorldPos.Y - points[j].WorldPos.Y) < 6)
+                        {
+                            points.RemoveAt(j);
+                        }
+                    }
                 }
-                else
+
+                var compareCCW = new CompareSegmentPointCW(drawPos);
+                try
                 {
-                    points.Add(s.Start);
-                    points.Add(s.End);
+                    points.Sort(compareCCW);
                 }
-            }
-
-            visibleSegments = visibleSegments.OrderBy(s => MathUtils.LineToPointDistanceSquared(s.Start.WorldPos, s.End.WorldPos, drawPos)).ToList();
-
-            var compareCCW = new CompareSegmentPointCW(drawPos);
-            try
-            {
-                points.Sort(compareCCW);
-            }
-            catch (Exception e)
-            {
-                StringBuilder sb = new StringBuilder("Constructing light volumes failed! Light pos: " + drawPos + ", Hull verts:\n");
-                foreach (SegmentPoint sp in points)
+                catch (Exception e)
                 {
-                    sb.AppendLine(sp.Pos.ToString());
+                    StringBuilder sb = new StringBuilder("Constructing light volumes failed! Light pos: " + drawPos + ", Hull verts:\n");
+                    foreach (SegmentPoint sp in points)
+                    {
+                        sb.AppendLine(sp.Pos.ToString());
+                    }
+                    DebugConsole.ThrowError(sb.ToString(), e);
                 }
-                DebugConsole.ThrowError(sb.ToString(), e);
-            }
 
-            List<Vector2> output = new List<Vector2>();
-            //List<Pair<int, Vector2>> preOutput = new List<Pair<int, Vector2>>();
+                visibleSegments.Sort((s1, s2) =>
+                    MathUtils.LineToPointDistanceSquared(s1.Start.WorldPos, s1.End.WorldPos, drawPos)
+                    .CompareTo(MathUtils.LineToPointDistanceSquared(s2.Start.WorldPos, s2.End.WorldPos, drawPos)));
+
+                verts.Clear();
+                foreach (SegmentPoint p in points)
+                {
+                    Vector2 dir = Vector2.Normalize(p.WorldPos - drawPos);
+                    Vector2 dirNormal = new Vector2(-dir.Y, dir.X) * 3;
+
+                    //do two slightly offset raycasts to hit the segment itself and whatever's behind it
+                    var intersection1 = RayCast(drawPos, drawPos + dir * boundsExtended * 2 - dirNormal, visibleSegments);
+                    if (intersection1.index < 0) { return; }
+                    var intersection2 = RayCast(drawPos, drawPos + dir * boundsExtended * 2 + dirNormal, visibleSegments);
+                    if (intersection2.index < 0) { return; }
+
+                    Segment seg1 = visibleSegments[intersection1.index];
+                    Segment seg2 = visibleSegments[intersection2.index];
+
+                    bool isPoint1 = MathUtils.LineToPointDistanceSquared(seg1.Start.WorldPos, seg1.End.WorldPos, p.WorldPos) < 25.0f;
+                    bool isPoint2 = MathUtils.LineToPointDistanceSquared(seg2.Start.WorldPos, seg2.End.WorldPos, p.WorldPos) < 25.0f;
+
+                    if (isPoint1 && isPoint2)
+                    {
+                        //hit at the current segmentpoint -> place the segmentpoint into the list
+                        verts.Add(p.WorldPos);
+
+                        foreach (ConvexHullList hullList in convexHullsInRange)
+                        {
+                            hullList.IsHidden.Remove(p.ConvexHull);
+                            hullList.IsHidden.Remove(seg1.ConvexHull);
+                            hullList.IsHidden.Remove(seg2.ConvexHull);
+                        }
+                    }
+                    else if (intersection1.index != intersection2.index)
+                    {
+                        //the raycasts landed on different segments
+                        //we definitely want to generate new geometry here
+                        verts.Add(isPoint1 ? p.WorldPos : intersection1.pos);
+                        verts.Add(isPoint2 ? p.WorldPos : intersection2.pos);
+
+                        foreach (ConvexHullList hullList in convexHullsInRange)
+                        {
+                            hullList.IsHidden.Remove(p.ConvexHull);
+                            hullList.IsHidden.Remove(seg1.ConvexHull);
+                            hullList.IsHidden.Remove(seg2.ConvexHull);
+                        }
+                    }
+                    //if neither of the conditions above are met, we just assume
+                    //that the raycasts both resulted on the same segment
+                    //and creating geometry here would be wasteful
+                }
+            }           
 
             //remove points that are very close to each other
-            for (int i = 0; i < points.Count; i++)
+            for (int i = 0; i < verts.Count - 1; i++)
             {
-                for (int j = Math.Min(i + 4, points.Count-1); j > i; j--)
+                for (int j = Math.Min(i + 4, verts.Count - 1); j > i; j--)
                 {
-                    if (Math.Abs(points[i].WorldPos.X - points[j].WorldPos.X) < 6 &&
-                        Math.Abs(points[i].WorldPos.Y - points[j].WorldPos.Y) < 6)
+                    if (Math.Abs(verts[i].X - verts[j].X) < 6 &&
+                       Math.Abs(verts[i].Y - verts[j].Y) < 6)
                     {
-                        points.RemoveAt(j);
+                        verts.RemoveAt(j);
                     }
                 }
             }
-
-            foreach (SegmentPoint p in points)
-            {
-                Vector2 dir = Vector2.Normalize(p.WorldPos - drawPos);
-                Vector2 dirNormal = new Vector2(-dir.Y, dir.X) * 3;
-
-                //do two slightly offset raycasts to hit the segment itself and whatever's behind it
-                var intersection1 = RayCast(drawPos, drawPos + dir * boundsExtended * 2 - dirNormal, visibleSegments);
-                var intersection2 = RayCast(drawPos, drawPos + dir * boundsExtended * 2 + dirNormal, visibleSegments);
-
-                if (intersection1.index < 0) return null;
-                if (intersection2.index < 0) return null;
-                Segment seg1 = visibleSegments[intersection1.index];
-                Segment seg2 = visibleSegments[intersection2.index];
-
-                bool isPoint1 = MathUtils.LineToPointDistanceSquared(seg1.Start.WorldPos, seg1.End.WorldPos, p.WorldPos) < 25.0f;
-                bool isPoint2 = MathUtils.LineToPointDistanceSquared(seg2.Start.WorldPos, seg2.End.WorldPos, p.WorldPos) < 25.0f;
-
-                if (isPoint1 && isPoint2)
-                {
-                    //hit at the current segmentpoint -> place the segmentpoint into the list
-                    output.Add(p.WorldPos);
-
-                    foreach (ConvexHullList hullList in hullsInRange)
-                    {
-                        hullList.IsHidden.Remove(p.ConvexHull);
-                        hullList.IsHidden.Remove(seg1.ConvexHull);
-                        hullList.IsHidden.Remove(seg2.ConvexHull);
-                    }
-                }
-                else if (intersection1.index != intersection2.index)
-                {
-                    //the raycasts landed on different segments
-                    //we definitely want to generate new geometry here
-                    output.Add(isPoint1 ? p.WorldPos : intersection1.pos);
-                    output.Add(isPoint2 ? p.WorldPos : intersection2.pos);
-
-                    foreach (ConvexHullList hullList in hullsInRange)
-                    {
-                        hullList.IsHidden.Remove(p.ConvexHull);
-                        hullList.IsHidden.Remove(seg1.ConvexHull);
-                        hullList.IsHidden.Remove(seg2.ConvexHull);
-                    }
-                }
-                //if neither of the conditions above are met, we just assume
-                //that the raycasts both resulted on the same segment
-                //and creating geometry here would be wasteful
-            }
-
-            //remove points that are very close to each other
-            for (int i = 0; i < output.Count - 1; i++)
-            {
-                for (int j = Math.Min(i + 4, output.Count - 1); j > i; j--)
-                {
-                    if (Math.Abs(output[i].X - output[j].X) < 6 &&
-                       Math.Abs(output[i].Y - output[j].Y) < 6)
-                    {
-                        output.RemoveAt(j);
-                    }
-                }
-            }
-
-            return output;
+            calculatedDrawPos = drawPos;
+            state = LightVertexState.PendingVertexRecalculation;
         }
 
-        private (int index, Vector2 pos) RayCast(Vector2 rayStart, Vector2 rayEnd, List<Segment> segments)
+        private static (int index, Vector2 pos) RayCast(Vector2 rayStart, Vector2 rayEnd, List<Segment> segments)
         {
             Vector2? closestIntersection = null;
             int segment = -1;
@@ -936,13 +989,13 @@ namespace Barotrauma.Lights
                 //same for the x-axis
                 if (s.Start.WorldPos.X > s.End.WorldPos.X)
                 {
-                    if (s.Start.WorldPos.X < minX) continue;
-                    if (s.End.WorldPos.X > maxX) continue;
+                    if (s.Start.WorldPos.X < minX) { continue; }
+                    if (s.End.WorldPos.X > maxX) { continue; }
                 }
                 else
                 {
-                    if (s.End.WorldPos.X < minX) continue;
-                    if (s.Start.WorldPos.X > maxX) continue;
+                    if (s.End.WorldPos.X < minX) { continue; }
+                    if (s.Start.WorldPos.X > maxX) { continue; }
                 }
 
                 bool intersects;
@@ -986,14 +1039,11 @@ namespace Barotrauma.Lights
                 indices = new short[indexCount];
             }
 
-            Vector2 drawPos = position;
-            if (ParentSub != null) { drawPos += ParentSub.DrawPosition; }
-
-            float cosAngle = (float)Math.Cos(Rotation);
-            float sinAngle = -(float)Math.Sin(Rotation);
+            Vector2 drawPos = calculatedDrawPos;
 
             Vector2 uvOffset = Vector2.Zero;
             Vector2 overrideTextureDims = Vector2.One;
+            Vector2 dir = this.dir;
             if (OverrideLightTexture != null)
             {
                 overrideTextureDims = new Vector2(OverrideLightTexture.SourceRect.Width, OverrideLightTexture.SourceRect.Height);
@@ -1002,8 +1052,7 @@ namespace Barotrauma.Lights
                 if (LightSpriteEffect == SpriteEffects.FlipHorizontally)
                 {
                     origin.X = OverrideLightTexture.SourceRect.Width - origin.X;
-                    cosAngle = -cosAngle;
-                    sinAngle = -sinAngle;
+                    dir = -dir;
                 }
                 if (LightSpriteEffect == SpriteEffects.FlipVertically) { origin.Y = OverrideLightTexture.SourceRect.Height - origin.Y; }
                 uvOffset = (origin / overrideTextureDims) - new Vector2(0.5f, 0.5f);
@@ -1041,7 +1090,7 @@ namespace Barotrauma.Lights
 
                 //calculate normal of first segment
                 Vector2 nDiff1 = vertex - nextVertex;
-                float tx = nDiff1.X; nDiff1.X = -nDiff1.Y; nDiff1.Y = tx;
+                nDiff1 = new Vector2(-nDiff1.Y, nDiff1.X);
                 nDiff1 /= Math.Max(Math.Abs(nDiff1.X), Math.Abs(nDiff1.Y));
                 //if the normal is pointing towards the light origin
                 //rather than away from it, invert it
@@ -1049,21 +1098,23 @@ namespace Barotrauma.Lights
 
                 //calculate normal of second segment
                 Vector2 nDiff2 = prevVertex - vertex;
-                tx = nDiff2.X; nDiff2.X = -nDiff2.Y; nDiff2.Y = tx;
-                nDiff2 /= Math.Max(Math.Abs(nDiff2.X),Math.Abs(nDiff2.Y));
+                nDiff2 = new Vector2(-nDiff2.Y, nDiff2.X);
+                nDiff2 /= Math.Max(Math.Abs(nDiff2.X), Math.Abs(nDiff2.Y));
                 //if the normal is pointing towards the light origin
                 //rather than away from it, invert it
                 if (Vector2.DistanceSquared(nDiff2, rawDiff) > Vector2.DistanceSquared(-nDiff2, rawDiff)) nDiff2 = -nDiff2;
 
                 //add the normals together and use some magic numbers to create
                 //a somewhat useful/good-looking blur
-                Vector2 nDiff = nDiff1 * 40.0f;
-                if (MathUtils.GetLineIntersection(vertex + (nDiff1 * 40.0f), nextVertex + (nDiff1 * 40.0f), vertex + (nDiff2 * 40.0f), prevVertex + (nDiff2 * 40.0f), true, out Vector2 intersection))
+                float blurDistance = 40.0f;
+                Vector2 nDiff = nDiff1 * blurDistance;
+                if (MathUtils.GetLineIntersection(vertex + (nDiff1 * blurDistance), nextVertex + (nDiff1 * blurDistance), vertex + (nDiff2 * blurDistance), prevVertex + (nDiff2 * blurDistance), true, out Vector2 intersection))
                 {
                     nDiff = intersection - vertex;
-                    if (nDiff.LengthSquared() > 10000.0f)
+                    if (nDiff.LengthSquared() > 100.0f * 100.0f)
                     {
-                        nDiff /= Math.Max(Math.Abs(nDiff.X), Math.Abs(nDiff.Y)); nDiff *= 100.0f;
+                        nDiff /= Math.Max(Math.Abs(nDiff.X), Math.Abs(nDiff.Y)); 
+                        nDiff *= 100.0f;
                     }
                 }
 
@@ -1074,8 +1125,8 @@ namespace Barotrauma.Lights
                     //calculate texture coordinates based on the light's rotation
                     Vector2 originDiff = diff;
 
-                    diff.X = originDiff.X * cosAngle - originDiff.Y * sinAngle;
-                    diff.Y = originDiff.X * sinAngle + originDiff.Y * cosAngle;
+                    diff.X = originDiff.X * dir.X - originDiff.Y * dir.Y;
+                    diff.Y = originDiff.X * dir.Y + originDiff.Y * dir.X;
                     diff *= (overrideTextureDims / OverrideLightTexture.size);// / (1.0f - Math.Max(Math.Abs(uvOffset.X), Math.Abs(uvOffset.Y)));
                     diff += uvOffset;
                 }
@@ -1161,7 +1212,6 @@ namespace Barotrauma.Lights
             }
 
             translateVertices = Vector2.Zero;
-            rotateVertices = 0.0f;
             prevCalculatedPosition = position;
             prevCalculatedRotation = rotation;
         }
@@ -1181,9 +1231,6 @@ namespace Barotrauma.Lights
                 }
                 drawPos.Y = -drawPos.Y;
 
-                float cosAngle = (float)Math.Cos(Rotation);
-                float sinAngle = -(float)Math.Sin(Rotation);
-
                 float bounds = TextureRange;
 
                 if (OverrideLightTexture != null)
@@ -1195,8 +1242,8 @@ namespace Barotrauma.Lights
                     origin /= Math.Max(overrideTextureDims.X, overrideTextureDims.Y);
                     origin *= TextureRange;
 
-                    drawPos.X += origin.X * sinAngle + origin.Y * cosAngle;
-                    drawPos.Y += origin.X * cosAngle + origin.Y * sinAngle;
+                    drawPos.X += origin.X * dir.Y + origin.Y * dir.X;
+                    drawPos.Y += origin.X * dir.X + origin.Y * dir.Y;
                 }
 
                 //add a square-shaped boundary to make sure we've got something to construct the triangles from
@@ -1302,7 +1349,7 @@ namespace Barotrauma.Lights
         {
             if (conditionals.None()) { return; }
             if (conditionalTarget == null) { return; }
-            if (comparison == PropertyConditional.Comparison.And)
+            if (logicalOperator == PropertyConditional.LogicalOperatorType.And)
             {
                 Enabled = conditionals.All(c => c.Matches(conditionalTarget));
             }
@@ -1335,35 +1382,43 @@ namespace Barotrauma.Lights
                 return;
             }
 
-            CheckHullsInRange();
+            CheckConvexHullsInRange();
 
             if (NeedsRecalculation && allowRecalculation)
             {
-                recalculationCount++;
-                var verts = FindRaycastHits();
-                if (verts == null)
+                if (state == LightVertexState.UpToDate)
                 {
-#if DEBUG
-                    DebugConsole.ThrowError($"Failed to generate vertices for a light source. Range: {Range}, color: {Color}, brightness: {CurrentBrightness}, parent: {ParentBody?.UserData ?? "Unknown"}");
-#endif
-                    Enabled = false;
-                    return;
+                    recalculationCount++;
+                    FindRaycastHits();
                 }
+                else if (state == LightVertexState.PendingVertexRecalculation)
+                {
+                    if (verts == null)
+                    {
+    #if DEBUG
+                        DebugConsole.ThrowError($"Failed to generate vertices for a light source. Range: {Range}, color: {Color}, brightness: {CurrentBrightness}, parent: {ParentBody?.UserData ?? "Unknown"}");
+    #endif
+                        Enabled = false;
+                        return;
+                    }
 
-                CalculateLightVertices(verts);
+                    CalculateLightVertices(verts);
 
-                LastRecalculationTime = (float)Timing.TotalTime;
-                NeedsRecalculation = false;
+                    LastRecalculationTime = (float)Timing.TotalTime;
+                    NeedsRecalculation = false;
+                    state = LightVertexState.UpToDate;
+                }
             }
 
+            if (vertexCount == 0) { return; }
+
             Vector2 offset = ParentSub == null ? Vector2.Zero : ParentSub.DrawPosition;
             lightEffect.World =
                 Matrix.CreateTranslation(-new Vector3(position, 0.0f)) *
-                Matrix.CreateRotationZ(rotateVertices - MathHelper.ToRadians(LightSourceParams.Rotation)) *
+                Matrix.CreateRotationZ(MathHelper.ToRadians(LightSourceParams.Rotation)) *
                 Matrix.CreateTranslation(new Vector3(position + offset + translateVertices, 0.0f)) *
                 transform;
 
-            if (vertexCount == 0) { return; }
 
             lightEffect.DiffuseColor = (new Vector3(Color.R, Color.G, Color.B) * (Color.A / 255.0f * CurrentBrightness)) / 255.0f;
             if (OverrideLightTexture != null)
@@ -1387,9 +1442,9 @@ namespace Barotrauma.Lights
 
         public void Reset()
         {
-            hullsInRange.Clear();
+            HullsUpToDate.Clear();
+            convexHullsInRange.Clear();
             diffToSub.Clear();
-            NeedsHullCheck = true;
             NeedsRecalculation = true;
 
             vertexCount = 0;

Barotrauma/BarotraumaClient/ClientSource/Map/LinkedSubmarine.cs

@@ -70,9 +70,9 @@ namespace Barotrauma
 
             Vector2 position = cam.ScreenToWorld(PlayerInput.MousePosition);
 
-            foreach (MapEntity entity in mapEntityList)
+            foreach (MapEntity entity in HighlightedEntities)
             {
-                if (entity == this || !entity.IsHighlighted || !(entity is Item) || !entity.IsMouseOn(position)) { continue; }
+                if (entity == this|| entity is not Item || !entity.IsMouseOn(position)) { continue; }
                 if (((Item)entity).GetComponent<DockingPort>() == null) { continue; }
                 if (linkedTo.Contains(entity))
                 {

Barotrauma/BarotraumaClient/ClientSource/Map/Map/Map.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.Xna.Framework.Input;
+using Barotrauma.Extensions;
 
 namespace Barotrauma
 {
@@ -72,6 +73,8 @@ namespace Barotrauma
 
         private RichString beaconStationActiveText, beaconStationInactiveText;
 
+        private GUIComponent locationInfoOverlay;
+
         /*private (Rectangle targetArea, string tip)? connectionTooltip;
         private string sanitizedConnectionTooltip;
         private List<RichTextData> connectionTooltipRichTextData;
@@ -98,7 +101,7 @@ namespace Barotrauma
                 OnClicked = (btn, userData) =>
                 {
                     Rand.SetSyncedSeed(ToolBox.StringToInt(this.Seed));
-                    Generate(GameMain.GameSession.GameMode is CampaignMode campaign ? campaign.Settings : CampaignSettings.Empty);
+                    Generate(GameMain.GameSession?.Campaign);
                     InitProjectSpecific();
                     return true;
                 }
@@ -186,7 +189,7 @@ namespace Barotrauma
 
         private void LocationChanged(Location prevLocation, Location newLocation)
         {
-            if (prevLocation == newLocation) return;
+            if (prevLocation == newLocation) { return; }
             //focus on starting location
             if (prevLocation != null)
             {
@@ -210,11 +213,17 @@ namespace Barotrauma
                 currLocationIndicatorPos = CurrentLocation.MapPosition;
             }
 
-            RemoveFogOfWar(newLocation);
+            if (newLocation.Visited)
+            {
+                RemoveFogOfWar(newLocation);
+            }
         }
 
+        partial void RemoveFogOfWarProjSpecific(Location location) => RemoveFogOfWar(location);
+
         private void RemoveFogOfWar(Location location, bool removeFromAdjacentLocations = true)
         {
+            if (mapTiles == null) { return; }
             if (location == null) { return; }
 
             var mapTile = generationParams.MapTiles.Values.FirstOrDefault().FirstOrDefault();
@@ -252,27 +261,223 @@ namespace Barotrauma
             return !tileDiscovered[MathHelper.Clamp(x, 0, tileDiscovered.Length), MathHelper.Clamp(y, 0, tileDiscovered.Length)];
         }
 
+        private class MapNotification
+        {
+            public readonly RichString Text;
+            public readonly GUIFont Font;
+
+            public readonly Vector2 TextSize;
+
+            public int TimesShown;
+
+            public float Offset;
+
+            public readonly Location RelatedLocation;
+
+            public bool IsCurrentlyVisible;
+
+            public MapNotification(string text, GUIFont font, List<MapNotification> existingNotifications, Location relatedLocation)
+            {
+                Text = RichString.Rich(text);
+                Font = font;
+                TextSize = Font.MeasureString(Font.ForceUpperCase ? Text.SanitizedValue.ToUpper() : Text.SanitizedValue);
+                if (existingNotifications.Any())
+                {
+                    Offset = existingNotifications.Max(n => n.Offset + n.TextSize.X + GUI.IntScale(60));
+                }
+                RelatedLocation = relatedLocation;
+            }
+        }
+
+        private readonly List<MapNotification> mapNotifications = new List<MapNotification>();
+
         partial void ChangeLocationTypeProjSpecific(Location location, string prevName, LocationTypeChange change)
         {
-            if (change.Messages.Any())
+            var messages = change.GetMessages(location.Faction);
+            if (!messages.Any()) { return; }
+
+            string msg = messages.GetRandom(Rand.RandSync.Unsynced)
+                .Replace("[previousname]", $"‖color:gui.yellow‖{prevName}‖end‖")
+                .Replace("[name]", $"‖color:gui.yellow‖{location.Name}‖end‖");
+            location.LastTypeChangeMessage = msg;
+
+            mapNotifications.Add(new MapNotification(msg, GUIStyle.SubHeadingFont, mapNotifications, location));           
+        }
+
+        public void DrawNotifications(SpriteBatch spriteBatch, GUICustomComponent container)
+        {
+            Vector2 pos = new Vector2(container.Rect.Right, container.Rect.Center.Y);
+            foreach (var notification in mapNotifications)
             {
-                string msg = change.Messages[Rand.Range(0, change.Messages.Count)]
-                    .Replace("[previousname]", $"‖color:gui.orange‖{prevName}‖end‖")
-                    .Replace("[name]", $"‖color:gui.orange‖{location.Name}‖end‖");
-                location.LastTypeChangeMessage = msg;
-                if (GameMain.Client != null)
+                Vector2 textPos = pos + new Vector2(notification.Offset, -notification.TextSize.Y / 2);
+
+                notification.Font.DrawStringWithColors(
+                    spriteBatch, 
+                    notification.Text.SanitizedValue,
+                   textPos, 
+                    Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, 0, 
+                    notification.Text.RichTextData);
+
+                int margin = container.Rect.Width / 5;
+                notification.IsCurrentlyVisible = 
+                    textPos.X < container.Rect.Right - margin &&
+                    textPos.X + notification.TextSize.X > container.Rect.X + margin;
+            }
+        }
+
+        private void UpdateNotifications(float deltaTime, GUICustomComponent mapContainer)
+        {
+            if (mapNotifications.Count < 5)
+            {
+                int maxIndex = 1;
+                while (TextManager.ContainsTag("randomnews" + maxIndex))
                 {
-                    GameMain.Client.AddChatMessage(msg, Networking.ChatMessageType.Default, TextManager.Get("RadioAnnouncerName").Value);
+                    maxIndex++;
                 }
-                else
+                string textTag = "randomnews" + Rand.Range(0, maxIndex);
+                if (TextManager.ContainsTag(textTag))
                 {
-                    GameMain.GameSession?.GameMode.CrewManager.AddSinglePlayerChatMessage(
-                        TextManager.Get("RadioAnnouncerName").Value,
-                        msg,
-                        Networking.ChatMessageType.Default,
-                        sender: null);
+                    mapNotifications.Add(new MapNotification(TextManager.Get(textTag).Value, GUIStyle.SubHeadingFont, mapNotifications, relatedLocation: null));
                 }
-            }         
+            }
+
+            for (int i = mapNotifications.Count - 1; i >= 0; i--)
+            {
+                var notification = mapNotifications[i];
+                notification.Offset -= deltaTime * 75.0f;
+                if (notification.Offset < -notification.TextSize.X - mapContainer.Rect.Width)
+                {
+                    notification.Offset = Math.Max(mapNotifications.Max(n => n.Offset + n.TextSize.X) + GUI.IntScale(60), 0);
+                    notification.TimesShown++;
+                    if (mapNotifications.Count > 5)
+                    {
+                        mapNotifications.RemoveAt(i);
+                    }
+                    else if (mapNotifications.Count > 3 && notification.TimesShown > 2)
+                    {
+                        mapNotifications.RemoveAt(i);
+                    }
+                }
+            }
+        }
+
+        private void CreateLocationInfoOverlay(Location location)
+        {
+            locationInfoOverlay = new GUIFrame(new RectTransform(new Point(GUI.IntScale(350), GUI.IntScale(350)), GUI.Canvas), style: "GUIToolTip")
+            {
+                UserData = location
+            };
+            locationInfoOverlay.Color *= 0.8f;
+
+            var content = new GUILayoutGroup(new RectTransform(new Vector2(0.9f, 0.85f), locationInfoOverlay.RectTransform, Anchor.Center))
+            {
+                Stretch = true,
+                RelativeSpacing = 0.02f
+            };
+
+            bool showReputation = hudVisibility > 0.0f && location.Type.HasOutpost && location.Reputation != null;
+
+            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), content.RectTransform), location.Name, font: GUIStyle.LargeFont) { Padding = Vector4.Zero };
+            if (!location.Type.Name.IsNullOrEmpty())
+            {
+                new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), content.RectTransform), location.Type.Name, font: GUIStyle.SubHeadingFont) { Padding = Vector4.Zero };
+            }
+
+            CreateSpacing(10);
+
+            if (!location.Type.Description.IsNullOrEmpty())
+            {
+                CreateTextWithIcon(location.Type.Description, location.Type.Sprite);
+            }
+
+            int highestSubTier = location.HighestSubmarineTierAvailable();
+            List<(SubmarineClass subClass, int tier)> overrideTiers = null;
+            if (location.CanHaveSubsForSale())
+            {
+                overrideTiers = new List<(SubmarineClass subClass, int tier)>();
+                foreach (SubmarineClass subClass in Enum.GetValues(typeof(SubmarineClass)))
+                {
+                    if (subClass == SubmarineClass.Undefined) { continue; }
+                    int highestClassTier = location.HighestSubmarineTierAvailable(subClass);
+                    if (highestClassTier > 0 && highestClassTier > highestSubTier)
+                    {
+                        overrideTiers.Add((subClass, highestClassTier));
+                    }
+                }
+            }
+            if (highestSubTier > 0)
+            {
+                CreateTextWithIcon(TextManager.GetWithVariable("advancedsub.all", "[tiernumber]", highestSubTier.ToString()), icon: null, style: "LocationOverlaySubmarineIcon");
+            }
+            if (overrideTiers != null)
+            {
+                foreach (var (subClass, tier) in overrideTiers)
+                {
+                    CreateTextWithIcon(TextManager.GetWithVariable($"advancedsub.{subClass}", "[tiernumber]", tier.ToString()), icon: null, style: "LocationOverlaySubmarineIcon");
+                }
+            }
+
+            CreateSpacing(10);
+
+            void CreateTextWithIcon(LocalizedString text, Sprite icon, string style = null)
+            {
+                var textHolder = new GUILayoutGroup(new RectTransform(new Point(content.Rect.Width, (int)GUIStyle.Font.MeasureString(text).Y), content.RectTransform), isHorizontal: true)
+                {
+                    Stretch = true,
+                    CanBeFocused = true
+                };
+                var guiIcon =
+                    style == null ? 
+                    new GUIImage(new RectTransform(Vector2.One * 1.25f, textHolder.RectTransform, scaleBasis: ScaleBasis.BothHeight), icon) :
+                    new GUIImage(new RectTransform(Vector2.One * 1.25f, textHolder.RectTransform, scaleBasis: ScaleBasis.BothHeight), style);
+                var textBlock = new GUITextBlock(new RectTransform(new Vector2(0.9f, 1.0f), textHolder.RectTransform), text);
+                textBlock.RectTransform.MinSize = new Point((int)textBlock.TextSize.X, 0);
+                textHolder.RectTransform.MinSize = new Point((int)textBlock.TextSize.X + guiIcon.Rect.Width, 0);
+            }
+
+            void CreateSpacing(int height)
+            {
+                new GUIFrame(new RectTransform(new Point(content.Rect.Width, GUI.IntScale(height)), content.RectTransform), style: null);
+            }
+
+            if (location.Faction != null)
+            {
+                new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), content.RectTransform),
+                    RichString.Rich(TextManager.GetWithVariables("reputationgainnotification",
+                        ("[value]", string.Empty),
+                        ("[reputationname]", $"‖color:{XMLExtensions.ToStringHex(location.Faction.Prefab.IconColor)}‖{location.Faction.Prefab.Name}‖end‖"))))
+                { 
+                    Padding = Vector4.Zero 
+                };
+
+                CreateSpacing(10);
+
+                var repBarHolder = new GUILayoutGroup(new RectTransform(new Point(content.Rect.Width, GUI.IntScale(25)), content.RectTransform), isHorizontal: true)
+                {
+                    Stretch = true,
+                    RelativeSpacing = 0.05f
+                };
+                new GUICustomComponent(new RectTransform(new Vector2(0.6f, 1.0f), repBarHolder.RectTransform), onDraw: (sb, component) =>
+                {
+                    if (location.Reputation == null) { return; }
+                    RoundSummary.DrawReputationBar(sb, component.Rect, location.Reputation.NormalizedValue);
+                });
+
+                new GUITextBlock(new RectTransform(new Vector2(0.4f, 1.0f), repBarHolder.RectTransform),
+                    location.Reputation.GetFormattedReputationText(), textAlignment: Alignment.CenterRight);
+
+                new GUIImage(new RectTransform(new Vector2(0.25f, 0.5f), locationInfoOverlay.RectTransform, Anchor.BottomRight) { RelativeOffset = new Vector2(0.05f) }, 
+                    location.Faction.Prefab.Icon, scaleToFit: true)
+                {
+                    Color = location.Faction.Prefab.IconColor * 0.5f
+                };
+                CreateSpacing(20);
+            }
+
+            locationInfoOverlay.RectTransform.NonScaledSize =
+                new Point(
+                    Math.Max(locationInfoOverlay.Rect.Width, (int)(content.Children.Max(c => c is GUITextBlock textBlock ? textBlock.TextSize.X : c.RectTransform.MinSize.X) * 1.2f)),
+                    (int)(content.Children.Sum(c => c.Rect.Height) / content.RectTransform.RelativeSize.Y));
         }
 
         partial void ClearAnimQueue()
@@ -280,12 +485,13 @@ namespace Barotrauma
             mapAnimQueue.Clear();
         }
 
-        public void Update(float deltaTime, GUICustomComponent mapContainer)
+        public void Update(CampaignMode campaign, float deltaTime, GUICustomComponent mapContainer)
         {
             Rectangle rect = mapContainer.Rect;
 
-            var currentDisplayLocation = GameMain.GameSession?.Campaign?.GetCurrentDisplayLocation();
+            UpdateNotifications(deltaTime, mapContainer);
 
+            var currentDisplayLocation = campaign?.GetCurrentDisplayLocation();
             if (currentDisplayLocation != null)
             {
                 if (!currentDisplayLocation.Discovered)
@@ -345,10 +551,39 @@ namespace Barotrauma
             
             Vector2 rectCenter = new Vector2(rect.Center.X, rect.Center.Y);
             Vector2 viewOffset = DrawOffset + drawOffsetNoise;
+            if (HighlightedLocation != null)
+            {
+                Vector2 highlightedLocationDrawPos = rectCenter + (HighlightedLocation.MapPosition + viewOffset) * zoom;
+                if (locationInfoOverlay == null || locationInfoOverlay.UserData != HighlightedLocation)
+                {
+                    CreateLocationInfoOverlay(HighlightedLocation);
+                }
+
+                Point offsetFromLocationIcon = new Point(GUI.IntScale(25));
+                var locationInfoRt = locationInfoOverlay.RectTransform;
+                if (locationInfoRt.Pivot == Pivot.BottomLeft || locationInfoRt.Pivot == Pivot.BottomRight)
+                {
+                    offsetFromLocationIcon.Y = -offsetFromLocationIcon.Y;
+                }
+                if (locationInfoRt.Pivot == Pivot.TopRight || locationInfoRt.Pivot == Pivot.BottomRight)
+                {
+                    offsetFromLocationIcon.X = -offsetFromLocationIcon.X;
+                }
+                locationInfoRt.ScreenSpaceOffset = highlightedLocationDrawPos.ToPoint() + offsetFromLocationIcon;
+                if (locationInfoOverlay.Rect.Bottom > rect.Bottom)
+                {
+                    locationInfoRt.Pivot = Pivot.BottomLeft;
+                }
+                if (locationInfoOverlay.Rect.Right > rect.Right)
+                {
+                    locationInfoRt.Pivot = locationInfoRt.Pivot == Pivot.TopLeft ? Pivot.TopRight : Pivot.BottomRight;
+                }
+                locationInfoOverlay?.AddToGUIUpdateList(order: 1);
+            }
 
             float closestDist = 0.0f;
             HighlightedLocation = null;
-            if (GUI.MouseOn == null || GUI.MouseOn == mapContainer)
+            if ((GUI.MouseOn == null || GUI.MouseOn == mapContainer))
             {
                 for (int i = 0; i < Locations.Count; i++)
                 {
@@ -374,7 +609,7 @@ namespace Barotrauma
                     if (HighlightedLocation == null || dist < closestDist)
                     {
                         closestDist = dist;
-                        HighlightedLocation = location;
+                        HighlightedLocation = location; 
                     }
                 }
             }
@@ -453,12 +688,13 @@ namespace Barotrauma
                         Level.Loaded.DebugSetEndLocation(null);
 
                         Discover(CurrentLocation);
+                        Visit(CurrentLocation);
                         OnLocationChanged?.Invoke(new LocationChangeInfo(prevLocation, CurrentLocation));
                         SelectLocation(-1);
                         if (GameMain.Client == null)
                         {
                             CurrentLocation.CreateStores();
-                            ProgressWorld();
+                            ProgressWorld(campaign);
                             Radiation?.OnStep(1);
                         }
                         else
@@ -467,12 +703,6 @@ namespace Barotrauma
                         }
                     }
 
-                    if (PlayerInput.KeyDown(Microsoft.Xna.Framework.Input.Keys.LeftShift) && PlayerInput.PrimaryMouseButtonClicked() && HighlightedLocation != null)
-                    {
-                        int distance = DistanceToClosestLocationWithOutpost(HighlightedLocation, out Location foundLocation);
-                        DebugConsole.NewMessage($"Distance to closest outpost from {HighlightedLocation.Name} to {foundLocation?.Name} is {distance}");
-                    }
-
                     if (PlayerInput.PrimaryMouseButtonClicked() && HighlightedLocation == null)
                     {
                         SelectLocation(-1);
@@ -481,10 +711,10 @@ namespace Barotrauma
             }
         }
         
-        public void Draw(SpriteBatch spriteBatch, GUICustomComponent mapContainer)
+        public void Draw(CampaignMode campaign, SpriteBatch spriteBatch, GUICustomComponent mapContainer)
         {
             tooltip = null;
-            var currentDisplayLocation = GameMain.GameSession?.Campaign?.GetCurrentDisplayLocation();
+            var currentDisplayLocation = campaign?.GetCurrentDisplayLocation();
 
             Rectangle rect = mapContainer.Rect;
 
@@ -501,13 +731,15 @@ namespace Barotrauma
 
             Vector2 rectCenter = new Vector2(rect.Center.X, rect.Center.Y);
 
+            float missionIconScale = generationParams.MissionIcon != null ? 18.0f / generationParams.MissionIcon.SourceRect.Width : 1.0f;
+
             Rectangle prevScissorRect = GameMain.Instance.GraphicsDevice.ScissorRectangle;
             spriteBatch.End();
             spriteBatch.GraphicsDevice.ScissorRectangle = Rectangle.Intersect(prevScissorRect, rect);
             spriteBatch.Begin(SpriteSortMode.Deferred, samplerState: GUI.SamplerState, rasterizerState: GameMain.ScissorTestEnable);
 
-            Vector2 topLeft = rectCenter + viewOffset;
-            Vector2 bottomRight = rectCenter + (viewOffset + new Vector2(Width, Height));
+            Vector2 topLeft = rectCenter + viewOffset - rect.Location.ToVector2();
+            Vector2 bottomRight = topLeft + new Vector2(Width, Height);
             Vector2 mapTileSize = mapTiles[0, 0].size * generationParams.MapTileScale;
 
             int startX = (int)Math.Floor(-topLeft.X / mapTileSize.X) - 1;
@@ -568,7 +800,9 @@ namespace Barotrauma
                 for (int i = 0; i < Locations.Count; i++)
                 {
                     Location location = Locations[i];
-                    if (IsInFogOfWar(location)) { continue; }
+                    if (!location.Discovered && IsInFogOfWar(location)) { continue; }
+                    bool isEndLocation = endLocations.Contains(location);
+                    if (!GameMain.DebugDraw && isEndLocation && location != endLocations.First()) { continue; }
                     Vector2 pos = rectCenter + (location.MapPosition + viewOffset) * zoom;
 
                     Sprite locationSprite = location.IsCriticallyRadiated() ? location.Type.RadiationSprite ?? location.Type.Sprite : location.Type.Sprite;
@@ -577,24 +811,54 @@ namespace Barotrauma
                     drawRect.X = (int)pos.X - drawRect.Width / 2;
                     drawRect.Y = (int)pos.Y - drawRect.Width / 2;
 
+                    if (drawRect.X > rect.Right - GUI.IntScale(100) && generationParams.MissionIcon != null && location.AvailableMissions.Any())
+                    {
+                        Vector2 offScreenMissionIconPos = new Vector2(rect.Right - GUI.IntScale(50), drawRect.Center.Y);
+                        generationParams.MissionIcon.Draw(spriteBatch,
+                            offScreenMissionIconPos,
+                            generationParams.IndicatorColor, scale: missionIconScale * zoom);
+                        GUI.Arrow.Draw(spriteBatch,
+                            offScreenMissionIconPos + Vector2.UnitX * generationParams.MissionIcon.size.X * missionIconScale * zoom,
+                            generationParams.IndicatorColor, MathHelper.PiOver2, scale: 0.5f);
+                    }
+
+
                     if (!rect.Intersects(drawRect)) { continue; }
 
                     Color color = location.Type.SpriteColor;
-                    if (!location.Discovered) { color = Color.White; }
+                    if (!location.Visited) { color = Color.White; }
                     if (location.Connections.Find(c => c.Locations.Contains(currentDisplayLocation)) == null)
                     {
                         color *= 0.5f;
                     }
 
                     float iconScale = location == currentDisplayLocation ? 1.2f : 1.0f;
-                    if (location == HighlightedLocation)
+                    if (location == HighlightedLocation) { iconScale *= 1.2f; }
+                    if (isEndLocation) { iconScale *= 2.0f; }
+
+                    float notificationPulseAmount = 1.0f;
+                    float notificationColorLerp = 0.0f;
+                    if (mapNotifications.Any(n => n.RelatedLocation == location && n.IsCurrentlyVisible))
                     {
-                        iconScale *= 1.2f;
+                        float sin = MathF.Sin((float)Timing.TotalTime * 2.0f);
+                        notificationPulseAmount = Math.Max(sin + 0.5f, 1.0f);
+                        notificationColorLerp = (notificationPulseAmount - 1.0f) * 4.0f;
+                        color = Color.Lerp(color, GUIStyle.Yellow, notificationColorLerp);
+                        iconScale *= notificationPulseAmount;
                     }
 
-                    locationSprite.Draw(spriteBatch, pos, color, 
+                    locationSprite.Draw(spriteBatch, pos, color,
                         scale: generationParams.LocationIconSize / locationSprite.size.X * iconScale * zoom);
 
+                    if (location.Faction != null)
+                    {
+                        float factionIconScale = iconScale * 0.7f;
+                        Sprite factionIcon = location.Faction.Prefab.IconSmall ?? location.Faction.Prefab.Icon;
+                        Color factionIconColor = Color.Lerp(color, location.Faction.Prefab.IconColor, notificationColorLerp);
+                        factionIcon.Draw(spriteBatch, pos + new Vector2(-15, 15) * zoom, factionIconColor,
+                            scale: generationParams.LocationIconSize / factionIcon.size.X * factionIconScale * zoom);
+                    }
+
                     if (location == currentDisplayLocation)
                     {
                         if (SelectedLocation != null)
@@ -626,7 +890,10 @@ namespace Barotrauma
                     {
                         Vector2 typeChangeIconPos = pos + new Vector2(1.35f, -0.35f) * generationParams.LocationIconSize * 0.5f * zoom;
                         float typeChangeIconScale = 18.0f / generationParams.TypeChangeIcon.SourceRect.Width;
-                        generationParams.TypeChangeIcon.Draw(spriteBatch, typeChangeIconPos, GUIStyle.Red, scale: typeChangeIconScale * zoom);
+                        Color iconColor = GUIStyle.Red;
+                        color = Color.Lerp(color, GUIStyle.Yellow, notificationColorLerp);
+                        iconScale *= notificationPulseAmount;                        
+                        generationParams.TypeChangeIcon.Draw(spriteBatch, typeChangeIconPos, iconColor, scale: typeChangeIconScale * zoom);
                         if (Vector2.Distance(PlayerInput.MousePosition, typeChangeIconPos) < generationParams.TypeChangeIcon.SourceRect.Width * zoom &&
                             (tooltip == null || IsPreferredTooltip(typeChangeIconPos)))
                         {
@@ -635,14 +902,17 @@ namespace Barotrauma
                     }
                     if (location != CurrentLocation && generationParams.MissionIcon != null)
                     {
-                        if ((CurrentLocation == currentDisplayLocation && CurrentLocation.AvailableMissions.Any(m => m.Locations.Contains(location))) || location.AvailableMissions.Any(m => m.Prefab.Type == MissionType.GoTo))
+                        if ((CurrentLocation == currentDisplayLocation && CurrentLocation.AvailableMissions.Any(m => m.Locations.Contains(location))) || 
+                            location.AvailableMissions.Any(m => m.Locations[0] == m.Locations[1]))
                         {
                             Vector2 missionIconPos = pos + new Vector2(1.35f, 0.35f) * generationParams.LocationIconSize * 0.5f * zoom;
-                            float missionIconScale = 18.0f / generationParams.MissionIcon.SourceRect.Width;
                             generationParams.MissionIcon.Draw(spriteBatch, missionIconPos, generationParams.IndicatorColor, scale: missionIconScale * zoom);
                             if (Vector2.Distance(PlayerInput.MousePosition, missionIconPos) < generationParams.MissionIcon.SourceRect.Width * zoom && IsPreferredTooltip(missionIconPos))
                             {
-                                var availableMissions = CurrentLocation.AvailableMissions.Where(m => m.Locations.Contains(location)).Concat(location.AvailableMissions.Where(m => m.Prefab.Type == MissionType.GoTo)).Distinct();
+                                var availableMissions = CurrentLocation.AvailableMissions
+                                    .Where(m => m.Locations.Contains(location))
+                                    .Concat(location.AvailableMissions.Where(m => m.Locations[0] == m.Locations[1]))
+                                    .Distinct();
                                 tooltip = (new Rectangle(missionIconPos.ToPoint(), new Point(30)), TextManager.Get("mission") + '\n'+ string.Join('\n', availableMissions.Select(m => "- " + m.Name)));
                             }
                         }
@@ -651,23 +921,19 @@ namespace Barotrauma
                     if (GameMain.DebugDraw)
                     {
                         Vector2 dPos = pos;
-                        if (location == HighlightedLocation && (!location.Discovered || !location.HasOutpost()) && location.Reputation != null)
+                        if (location == HighlightedLocation)
                         {
+                            dPos.Y -= 80;
+                            GUI.DrawString(spriteBatch, dPos + new Vector2(15, 32), "Faction: " + (location.Faction?.Prefab.Name ?? "none"), Color.White, Color.Black, font: GUIStyle.SubHeadingFont);
+                            GUI.DrawString(spriteBatch, dPos + new Vector2(15, 50), "Secondary Faction: " + (location.SecondaryFaction?.Prefab.Name ?? "none"), Color.White, Color.Black, font: GUIStyle.SubHeadingFont);
                             dPos.Y += 48;
-                            string name = $"Reputation: {location.Name}";
-                            Vector2 nameSize = GUIStyle.SmallFont.MeasureString(name);
-                            GUI.DrawString(spriteBatch, dPos, name, Color.White, Color.Black * 0.8f, 4, font: GUIStyle.SmallFont);
-                            dPos.Y += nameSize.Y + 16;
 
-                            Rectangle bgRect = new Rectangle((int)dPos.X, (int)dPos.Y, 256, 32);
-                            bgRect.Inflate(8,8);
-                            Color barColor = ToolBox.GradientLerp(location.Reputation.NormalizedValue, Color.Red, Color.Yellow, Color.LightGreen);
-                            GUI.DrawRectangle(spriteBatch, bgRect, Color.Black * 0.8f, isFilled: true);
-                            GUI.DrawRectangle(spriteBatch, new Rectangle((int)dPos.X, (int)dPos.Y, (int)(location.Reputation.NormalizedValue * 255), 32), barColor, isFilled: true);
-                            string reputationValue = ((int)location.Reputation.Value).ToString();
-                            Vector2 repValueSize = GUIStyle.SubHeadingFont.MeasureString(reputationValue);
-                            GUI.DrawString(spriteBatch, dPos + (new Vector2(256, 32) / 2) - (repValueSize / 2), reputationValue, Color.White, Color.Black, font: GUIStyle.SubHeadingFont);
-                            GUI.DrawRectangle(spriteBatch, new Rectangle((int)dPos.X, (int)dPos.Y, 256, 32), Color.White);
+                            if (PlayerInput.KeyDown(Keys.LeftShift))
+                            {
+                                GUI.DrawString(spriteBatch, new Vector2(150,150), "Dist: " +
+                                    GetDistanceToClosestLocationOrConnection(CurrentLocation, int.MaxValue, loc => loc == location), Color.White, Color.Black, font: GUIStyle.SubHeadingFont);
+
+                            }
                         }
                         dPos.Y += 48;
                         GUI.DrawString(spriteBatch, dPos, $"Difficulty: {location.LevelData.Difficulty.FormatSingleDecimal()}", Color.White, Color.Black * 0.8f, 4, font: GUIStyle.SmallFont);
@@ -684,97 +950,6 @@ namespace Barotrauma
                 GUIComponent.DrawToolTip(spriteBatch, tooltip.Value.tip, tooltip.Value.targetArea);
                 drawRadiationTooltip = false;
             }
-            else if (HighlightedLocation != null)
-            {
-                drawRadiationTooltip = false;
-                Vector2 pos = rectCenter + (HighlightedLocation.MapPosition + viewOffset) * zoom;
-                pos.X += 50 * zoom;
-                pos.X = (int)pos.X;
-                pos.Y = (int)pos.Y;
-                Vector2 nameSize = GUIStyle.LargeFont.MeasureString(HighlightedLocation.Name);
-                Vector2 typeSize = HighlightedLocation.Type.Name.IsNullOrEmpty() ? Vector2.Zero : GUIStyle.Font.MeasureString(HighlightedLocation.Type.Name);
-                Vector2 descSize = HighlightedLocation.Type.Description.IsNullOrEmpty() ? Vector2.Zero : GUIStyle.SmallFont.MeasureString(HighlightedLocation.Type.Description);
-                Vector2 size = new Vector2(Math.Max(nameSize.X, Math.Max(typeSize.X, descSize.X)), nameSize.Y + typeSize.Y + descSize.Y);
-
-                int highestSubTier = HighlightedLocation.HighestSubmarineTierAvailable();
-                List<(SubmarineClass subClass, int tier)> overrideTiers = null;
-                if (HighlightedLocation.CanHaveSubsForSale())
-                {
-                    overrideTiers = new List<(SubmarineClass subClass, int tier)>();
-                    foreach (SubmarineClass subClass in Enum.GetValues(typeof(SubmarineClass)))
-                    {
-                        if (subClass == SubmarineClass.Undefined) { continue; }
-                        int highestClassTier = HighlightedLocation.HighestSubmarineTierAvailable(subClass);
-                        if (highestClassTier > 0 && highestClassTier > highestSubTier)
-                        {
-                            overrideTiers.Add((subClass, highestClassTier));
-                        }
-                    }
-                }
-                int subAvailabilityTextCount = (highestSubTier > 0 ? 1 : 0) + (overrideTiers?.Count ?? 0);
-                size.Y += subAvailabilityTextCount * GUIStyle.SmallFont.MeasureString(TextManager.Get("advancedsub.all")).Y;
-
-                bool showReputation = hudVisibility > 0.0f && HighlightedLocation.Discovered && HighlightedLocation.Type.HasOutpost && HighlightedLocation.Reputation != null;
-                LocalizedString repLabelText = null, repValueText = null;
-                Vector2 repLabelSize = Vector2.Zero, repBarSize = Vector2.Zero;
-                if (showReputation)
-                {
-                    repLabelText = TextManager.Get("reputation");
-                    repLabelSize = GUIStyle.Font.MeasureString(repLabelText);
-                    repBarSize = new Vector2(GUI.IntScale(200), repLabelSize.Y);
-                    size.Y += 2 * repLabelSize.Y + GUI.IntScale(5) + repBarSize.Y;
-                    repValueText = HighlightedLocation.Reputation.GetFormattedReputationText(addColorTags: false);
-                    size.X = Math.Max(size.X, repBarSize.X + GUIStyle.Font.MeasureString(repValueText).X + GUI.IntScale(10));
-                }
-
-                GUIStyle.GetComponentStyle("OuterGlow").Sprites[GUIComponent.ComponentState.None][0].Draw(
-                    spriteBatch,
-                    new Rectangle(
-                        (int)(pos.X - 60 * GUI.Scale),
-                        (int)(pos.Y - size.Y),
-                        (int)(size.X + 120 * GUI.Scale),
-                        (int)(size.Y * 2.2f)),
-                    Color.Black * hudVisibility);
-
-                var topLeftPos = pos - new Vector2(0.0f, size.Y / 2);
-                GUI.DrawString(spriteBatch, topLeftPos, HighlightedLocation.Name, GUIStyle.TextColorNormal * hudVisibility * 1.5f, font: GUIStyle.LargeFont);
-                topLeftPos += new Vector2(0.0f, nameSize.Y);
-                DrawText(HighlightedLocation.Type.Name);
-                if (!HighlightedLocation.Type.Description.IsNullOrEmpty())
-                {
-                    topLeftPos += new Vector2(0.0f, descSize.Y);
-                    DrawText(HighlightedLocation.Type.Description, font: GUIStyle.SmallFont);
-                }
-
-                if (highestSubTier > 0)
-                {
-                    DrawSubAvailabilityText("advancedsub.all", highestSubTier);
-                }
-                if (overrideTiers != null)
-                {
-                    foreach (var (subClass, tier) in overrideTiers)
-                    {
-                        DrawSubAvailabilityText($"advancedsub.{subClass}", tier);
-                    }
-                }
-                void DrawSubAvailabilityText(string tag, int tier)
-                {
-                    topLeftPos += new Vector2(0.0f, typeSize.Y);
-                    DrawText(TextManager.GetWithVariable(tag, "[tiernumber]", tier.ToString()), font: GUIStyle.SmallFont);
-                }
-
-                if (showReputation)
-                {
-                    topLeftPos += new Vector2(0.0f, typeSize.Y + repLabelSize.Y);
-                    DrawText(repLabelText.Value);
-                    topLeftPos += new Vector2(0.0f, repLabelSize.Y + GUI.IntScale(10));
-                    Rectangle repBarRect = new Rectangle(new Point((int)topLeftPos.X, (int)topLeftPos.Y), new Point((int)repBarSize.X, (int)repBarSize.Y));
-                    RoundSummary.DrawReputationBar(spriteBatch, repBarRect, HighlightedLocation.Reputation.NormalizedValue);
-                    GUI.DrawString(spriteBatch, new Vector2(repBarRect.Right + GUI.IntScale(5), repBarRect.Top), repValueText.Value, Reputation.GetReputationColor(HighlightedLocation.Reputation.NormalizedValue));
-                }
-
-                void DrawText(LocalizedString text, GUIFont font = null) => GUI.DrawString(spriteBatch, topLeftPos, text, GUIStyle.TextColorNormal * hudVisibility * 1.5f, font: font);
-            }
 
             if (drawRadiationTooltip)
             {
@@ -892,7 +1067,7 @@ namespace Barotrauma
                 }
 
                 float a = 1.0f;
-                if (!connection.Locations[0].Discovered && !connection.Locations[1].Discovered)
+                if (!connection.Locations[0].Visited && !connection.Locations[1].Visited)
                 {
                     if (IsInFogOfWar(connection.Locations[0]))
                     {
@@ -961,25 +1136,25 @@ namespace Barotrauma
                 if (connection.Locked)
                 {
                     var gateLocation = connection.Locations[0].IsGateBetweenBiomes ? connection.Locations[0] : connection.Locations[1];
-                    var unlockEvent =
-                        EventPrefab.Prefabs.FirstOrDefault(ep => ep.UnlockPathEvent && ep.BiomeIdentifier == gateLocation.LevelData.Biome.Identifier) ??
-                        EventPrefab.Prefabs.FirstOrDefault(ep => ep.UnlockPathEvent && ep.BiomeIdentifier == Identifier.Empty);
+                    var unlockEvent = EventPrefab.GetUnlockPathEvent(gateLocation.LevelData.Biome.Identifier, gateLocation.Faction);
 
                     if (unlockEvent != null)
                     {
                         Reputation unlockReputation = CurrentLocation.Reputation;
                         Faction unlockFaction = null;
-                        if (!string.IsNullOrEmpty(unlockEvent.UnlockPathFaction))
+                        if (!unlockEvent.Faction.IsEmpty)
                         {
-                            unlockFaction = GameMain.GameSession.Campaign.Factions.Find(f => f.Prefab.Identifier == unlockEvent.UnlockPathFaction);
+                            unlockFaction = GameMain.GameSession.Campaign.Factions.Find(f => f.Prefab.Identifier == unlockEvent.Faction);
                             unlockReputation = unlockFaction?.Reputation;
                         }
-
-                        DrawIcon(
-                            "LockedLocationConnection", (int)(28 * zoom),
-                            RichString.Rich(TextManager.GetWithVariables(unlockEvent.UnlockPathTooltip ?? "LockedPathTooltip",
-                              ("[requiredreputation]", Reputation.GetFormattedReputationText(MathUtils.InverseLerp(unlockReputation.MinReputation, unlockReputation.MaxReputation, unlockEvent.UnlockPathReputation), unlockEvent.UnlockPathReputation, addColorTags: true)),
-                              ("[currentreputation]", unlockReputation.GetFormattedReputationText(addColorTags: true)))));
+                        if (unlockReputation != null)
+                        {
+                            DrawIcon(
+                                "LockedLocationConnection", (int)(28 * zoom),
+                                RichString.Rich(TextManager.GetWithVariables(unlockEvent.UnlockPathTooltip ?? "LockedPathTooltip",
+                                  ("[requiredreputation]", Reputation.GetFormattedReputationText(MathUtils.InverseLerp(unlockReputation.MinReputation, unlockReputation.MaxReputation, unlockEvent.UnlockPathReputation), unlockEvent.UnlockPathReputation, addColorTags: true)),
+                                  ("[currentreputation]", unlockReputation.GetFormattedReputationText(addColorTags: true)))));
+                        }
                     }
                     else
                     {
@@ -1042,13 +1217,14 @@ namespace Barotrauma
         private void DrawDecorativeHUD(SpriteBatch spriteBatch, Rectangle rect)
         {
             generationParams.DecorativeGraphSprite.Draw(spriteBatch, (int)((Timing.TotalTime * 5.0f) % generationParams.DecorativeGraphSprite.FrameCount),
-                new Vector2(rect.Left, rect.Top), Color.White, Vector2.Zero, 0, Vector2.One * GUI.Scale);
+                new Vector2(rect.X, rect.Bottom - (generationParams.DecorativeGraphSprite.FrameSize.Y + 30) * GUI.Scale), 
+                Color.White, Vector2.Zero, 0, Vector2.One * GUI.Scale, SpriteEffects.FlipVertically);
 
             GUI.DrawString(spriteBatch,
                 new Vector2(rect.Right - GUI.IntScale(170), rect.Y + GUI.IntScale(5)),
                 "JOVIAN FLUX " + ((cameraNoiseStrength + Rand.Range(-0.02f, 0.02f)) * 500), generationParams.IndicatorColor * hudVisibility, font: GUIStyle.SmallFont);
             GUI.DrawString(spriteBatch,
-                new Vector2(rect.X + GUI.IntScale(15), rect.Bottom - GUI.IntScale(25)),
+                new Vector2(rect.X + GUI.IntScale(5), rect.Y + GUI.IntScale(5)),
                 "LAT " + (-DrawOffset.Y / 100.0f) + "   LON " + (-DrawOffset.X / 100.0f), generationParams.IndicatorColor * hudVisibility, font: GUIStyle.SmallFont);
         }
 

Barotrauma/BarotraumaClient/ClientSource/Map/MapEntity.cs

@@ -36,7 +36,7 @@ namespace Barotrauma
 
         public static List<MapEntity> CopiedList = new List<MapEntity>();
 
-        private static List<MapEntity> highlightedList = new List<MapEntity>();
+        private static List<MapEntity> highlightedInEditorList = new List<MapEntity>();
 
         private static float highlightTimer;
 
@@ -99,11 +99,24 @@ namespace Barotrauma
         {
             float depth = baseDepth
                 //take texture into account to get entities with (roughly) the same base depth and texture to render consecutively to minimize texture swaps
-                + (sprite?.Texture?.SortingKey ?? 0) % 100 * 0.00001f
-                + ID % 100 * 0.000001f;
+                + (sprite?.Texture?.SortingKey ?? 0) % 100 * 0.000001f
+                + ID % 100 * 0.0000001f;
             return Math.Min(depth, 1.0f);
         }
 
+        protected Vector2 GetCollapseEffectOffset()
+        {
+            if (Level.Loaded?.Renderer?.CollapseEffectStrength is float collapseEffectStrength and > 0.0f && Submarine is not { Info.Type: SubmarineType.Player })
+            {
+                   Vector2 noisePos = new Vector2(
+                    (float)PerlinNoise.GetPerlin((float)(Timing.TotalTime + ID) * 0.1f, (float)(Timing.TotalTime + ID) * 0.5f) - 0.5f,
+                    (float)PerlinNoise.GetPerlin((float)(Timing.TotalTime + ID) * 0.1f, (float)(Timing.TotalTime + ID) * 0.1f) - 0.5f);
+                Vector2 offsetFromOrigin = Level.Loaded.Renderer.CollapseEffectOrigin - DrawPosition;
+                return offsetFromOrigin * MathF.Pow(collapseEffectStrength, MathHelper.Lerp(1, 4, ID % 1000 / 1000.0f)) + (noisePos * 100.0f * collapseEffectStrength);                
+            }
+            return Vector2.Zero;
+        }
+
         /// <summary>
         /// Update the selection logic in submarine editor
         /// </summary>
@@ -118,10 +131,7 @@ namespace Barotrauma
                 return;
             }
 
-            foreach (MapEntity e in mapEntityList)
-            {
-                e.isHighlighted = false;
-            }
+            ClearHighlightedEntities();
 
             if (DisableSelect)
             {
@@ -249,11 +259,10 @@ namespace Barotrauma
                             if (i == 0) highLightedEntity = e;
                         }
                     }
-
                     UpdateHighlighting(highlightedEntities);
                 }
 
-                if (highLightedEntity != null) highLightedEntity.isHighlighted = true;
+                if (highLightedEntity != null) { highLightedEntity.IsHighlighted = true; }
             }
 
             if (GUI.KeyboardDispatcher.Subscriber == null)
@@ -275,7 +284,6 @@ namespace Barotrauma
             if (startMovingPos != Vector2.Zero)
             {
                 Item targetContainer = GetPotentialContainer(position, SelectedList);
-
                 if (targetContainer != null) { targetContainer.IsHighlighted = true; }
 
                 if (PlayerInput.PrimaryMouseButtonReleased())
@@ -597,10 +605,10 @@ namespace Barotrauma
             if (highlightedListBox != null)
             {
                 if (GUI.MouseOn == highlightedListBox || highlightedListBox.IsParentOf(GUI.MouseOn)) return;
-                if (highlightedEntities.SequenceEqual(highlightedList)) return;
+                if (highlightedEntities.SequenceEqual(highlightedInEditorList)) return;
             }
 
-            highlightedList = highlightedEntities;
+            highlightedInEditorList = highlightedEntities;
 
             highlightedListBox = new GUIListBox(new RectTransform(new Point(180, highlightedEntities.Count * 18 + 5), GUI.Canvas)
             {
@@ -1083,7 +1091,7 @@ namespace Barotrauma
 
         private void UpdateResizing(Camera cam)
         {
-            isHighlighted = true;
+            IsHighlighted = true;
 
             int startX = ResizeHorizontal ? -1 : 0;
             int StartY = ResizeVertical ? -1 : 0;
@@ -1184,7 +1192,7 @@ namespace Barotrauma
 
         private void DrawResizing(SpriteBatch spriteBatch, Camera cam)
         {
-            isHighlighted = true;
+            IsHighlighted = true;
 
             int startX = ResizeHorizontal ? -1 : 0;
             int StartY = ResizeVertical ? -1 : 0;

Barotrauma/BarotraumaClient/ClientSource/Map/Structure.cs

@@ -55,21 +55,14 @@ namespace Barotrauma
         {
             if (!CastShadow) { return; }
 
-            if (convexHulls == null)
+            convexHulls ??= new List<ConvexHull>();
+            var h = new ConvexHull(
+                new Rectangle((position - size / 2).ToPoint(), size.ToPoint()),
+                IsHorizontal,
+                this)
             {
-                convexHulls = new List<ConvexHull>();
-            }
-
-            Vector2 halfSize = size / 2;
-            Vector2[] verts = new Vector2[]
-            {
-                position + new Vector2(-halfSize.X, halfSize.Y),
-                position + new Vector2(halfSize.X, halfSize.Y),
-                position + new Vector2(halfSize.X, -halfSize.Y),
-                position + new Vector2(-halfSize.X, -halfSize.Y),
+                IsExteriorWall = IsExteriorWall
             };
-
-            var h = new ConvexHull(verts, Color.Black, this);
             if (Math.Abs(rotation) > 0.001f)
             {
                 h.Rotate(position, rotation);
@@ -226,6 +219,9 @@ namespace Barotrauma
                 min.Y = Math.Min(worldPos.Y - decorativeSprite.Sprite.size.Y * (1.0f - decorativeSprite.Sprite.RelativeOrigin.Y) * scale, min.Y);
                 max.Y = Math.Max(worldPos.Y + decorativeSprite.Sprite.size.Y * decorativeSprite.Sprite.RelativeOrigin.Y * scale, max.Y);
             }
+            Vector2 offset = GetCollapseEffectOffset();
+            min += offset;
+            max += offset;
 
             if (min.X > worldView.Right || max.X < worldView.X) { return false; }
             if (min.Y > worldView.Y || max.Y < worldView.Y - worldView.Height) { return false; }
@@ -295,6 +291,7 @@ namespace Barotrauma
             if (isWiringMode) { color *= 0.15f; }
 
             Vector2 drawOffset = Submarine == null ? Vector2.Zero : Submarine.DrawPosition;
+            drawOffset += GetCollapseEffectOffset();
 
             float depth = GetDrawDepth();
 
@@ -504,7 +501,7 @@ namespace Barotrauma
 
         private bool ConditionalMatches(PropertyConditional conditional)
         {
-            if (!string.IsNullOrEmpty(conditional.TargetItemComponentName))
+            if (!string.IsNullOrEmpty(conditional.TargetItemComponent))
             {
                 return false;
             }
@@ -533,7 +530,7 @@ namespace Barotrauma
                 float damage = msg.ReadRangedSingle(0.0f, 1.0f, 8) * MaxHealth;
                 if (!invalidMessage && i < Sections.Length)
                 {
-                    SetDamage(i, damage);
+                    SetDamage(i, damage, isNetworkEvent: true);
                 }
             }
         }

Barotrauma/BarotraumaClient/ClientSource/Map/Submarine.cs

@@ -35,6 +35,13 @@ namespace Barotrauma
             Rectangle camView = cam.WorldView;
             camView = new Rectangle(camView.X - CullMargin, camView.Y + CullMargin, camView.Width + CullMargin * 2, camView.Height + CullMargin * 2);
 
+            if (Level.Loaded?.Renderer?.CollapseEffectStrength is > 0.0f)
+            {
+                //force everything to be visible when the collapse effect (which moves everything to a single point) is active
+                camView = Rectangle.Union(AbsRect(camView.Location.ToVector2(), camView.Size.ToVector2()), new Rectangle(Point.Zero, Level.Loaded.Size));
+                camView.Y += camView.Height;
+            }
+
             if (Math.Abs(camView.X - prevCullArea.X) < CullMoveThreshold &&
                 Math.Abs(camView.Y - prevCullArea.Y) < CullMoveThreshold &&
                 Math.Abs(camView.Right - prevCullArea.Right) < CullMoveThreshold &&

Barotrauma/BarotraumaClient/ClientSource/Map/SubmarinePreview.cs

@@ -116,7 +116,7 @@ namespace Barotrauma
                     bool isMouseOnComponent = GUI.MouseOn == component;
                     camera.MoveCamera(deltaTime, allowZoom: isMouseOnComponent, followSub: false);
                     if (isMouseOnComponent &&
-                        (PlayerInput.MidButtonHeld() || PlayerInput.LeftButtonHeld()))
+                        (PlayerInput.MidButtonHeld() || PlayerInput.PrimaryMouseButtonHeld()))
                     {
                         Vector2 moveSpeed = PlayerInput.MouseSpeed * (float)deltaTime * 60.0f / camera.Zoom;
                         moveSpeed.X = -moveSpeed.X;

Barotrauma/BarotraumaClient/ClientSource/Map/WayPoint.cs

@@ -39,7 +39,7 @@ namespace Barotrauma
         {
             Color clr = CurrentHull == null ? Color.DodgerBlue : GUIStyle.Green;
             if (spawnType != SpawnType.Path) { clr = Color.Gray; }
-            if (isObstructed)
+            if (!IsTraversable)
             {
                 clr = Color.Black;
             }
@@ -84,7 +84,7 @@ namespace Barotrauma
                 GUI.DrawLine(spriteBatch,
                     drawPos,
                     new Vector2(e.DrawPosition.X, -e.DrawPosition.Y),
-                    (isObstructed ? Color.Gray : GUIStyle.Green) * 0.7f, width: 5, depth: 0.002f);
+                    (IsTraversable ? GUIStyle.Green : Color.Gray) * 0.7f, width: 5, depth: 0.002f);
             }
             if (ConnectedGap != null)
             {
@@ -123,6 +123,11 @@ namespace Barotrauma
                     }
                 }
             }
+            else if (spawnType == SpawnType.ExitPoint && ExitPointSize != Point.Zero)
+            {
+                GUI.DrawRectangle(spriteBatch, drawPos - ExitPointSize.ToVector2() / 2, ExitPointSize.ToVector2(), Color.Cyan, thickness: 5);
+            }
+
             GUIStyle.SmallFont.DrawString(spriteBatch,
                 ID.ToString(),
                 new Vector2(DrawPosition.X - 10, -DrawPosition.Y - 30),
@@ -170,9 +175,9 @@ namespace Barotrauma
 
                 if (PlayerInput.KeyDown(Keys.Space))
                 {
-                    foreach (MapEntity e in mapEntityList)
+                    foreach (MapEntity e in HighlightedEntities)
                     {
-                        if (!(e is WayPoint) || e == this || !e.IsHighlighted) { continue; }
+                        if (e is not WayPoint || e == this) { continue; }
 
                         if (linkedTo.Contains(e))
                         {
@@ -251,6 +256,7 @@ namespace Barotrauma
 
         private bool ChangeSpawnType(GUIButton button, object obj)
         {
+            var prevSpawnType = spawnType;
             GUITextBlock spawnTypeText = button.Parent.GetChildByUserData("spawntypetext") as GUITextBlock;
             var values = (SpawnType[])Enum.GetValues(typeof(SpawnType));
             int currIndex = values.IndexOf(spawnType);
@@ -267,6 +273,7 @@ namespace Barotrauma
             }
             spawnType = values[currIndex];
             spawnTypeText.Text = spawnType.ToString();
+            if (spawnType == SpawnType.ExitPoint || prevSpawnType == SpawnType.ExitPoint) { CreateEditingHUD(); } 
             return true;
         }
 
@@ -412,6 +419,28 @@ namespace Barotrauma
                     textBox.Text = string.Join(",", tags);
                     textBox.Flash(GUIStyle.Green);
                 };
+
+                if (SpawnType == SpawnType.ExitPoint)
+                {
+                    var sizeField = GUI.CreatePointField(ExitPointSize, GUI.IntScale(20), TextManager.Get("dimensions"), paddedFrame.RectTransform);
+                    GUINumberInput xField = null, yField = null;
+                    foreach (GUIComponent child in sizeField.GetAllChildren())
+                    {
+                        if (yField == null)
+                        {
+                            yField = child as GUINumberInput;
+                        }
+                        else
+                        {
+                            xField = child as GUINumberInput;
+                            if (xField != null) { break; }
+                        }
+                    }
+                    xField.MinValueInt = 0;
+                    xField.OnValueChanged = (numberInput) => { ExitPointSize = new Point(numberInput.IntValue, ExitPointSize.Y); };
+                    yField.MinValueInt = 0;
+                    yField.OnValueChanged = (numberInput) => { ExitPointSize = new Point(ExitPointSize.X, numberInput.IntValue); };
+                }
             }
 
             editingHUD.RectTransform.Resize(new Point(