(77d1794a) Tester's build January 10th, 2020

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/CaveGenerator.cs

@@ -0,0 +1,436 @@
+using FarseerPhysics;
+using FarseerPhysics.Common;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    static partial class CaveGenerator
+    {
+        public static List<VoronoiCell> GraphEdgesToCells(List<GraphEdge> graphEdges, Rectangle borders, float gridCellSize, out List<VoronoiCell>[,] cellGrid)
+        {
+            List<VoronoiCell> cells = new List<VoronoiCell>();
+
+            cellGrid = new List<VoronoiCell>[(int)Math.Ceiling(borders.Width / gridCellSize), (int)Math.Ceiling(borders.Height / gridCellSize)];
+            for (int x = 0; x < borders.Width / gridCellSize; x++)
+            {
+                for (int y = 0; y < borders.Height / gridCellSize; y++)
+                {
+                    cellGrid[x, y] = new List<VoronoiCell>();
+                }
+            }
+
+            foreach (GraphEdge ge in graphEdges)
+            {
+                if (Vector2.DistanceSquared(ge.Point1, ge.Point2) < 0.001f) continue;
+
+                for (int i = 0; i < 2; i++)
+                {
+                    Site site = (i == 0) ? ge.Site1 : ge.Site2;
+
+                    int x = (int)(Math.Floor((site.Coord.X-borders.X) / gridCellSize));
+                    int y = (int)(Math.Floor((site.Coord.Y-borders.Y) / gridCellSize));
+
+                    x = MathHelper.Clamp(x, 0, cellGrid.GetLength(0)-1);
+                    y = MathHelper.Clamp(y, 0, cellGrid.GetLength(1)-1);
+                        
+                    VoronoiCell cell = cellGrid[x,y].Find(c => c.Site == site);
+
+                    if (cell == null)
+                    {
+                        cell = new VoronoiCell(site);
+                        cellGrid[x, y].Add(cell);
+                        cells.Add(cell);
+                    }
+
+                    if (ge.Cell1 == null)
+                    {
+                        ge.Cell1 = cell;
+                    }
+                    else
+                    {
+                        ge.Cell2 = cell;
+                    }
+                    cell.Edges.Add(ge);
+                }
+            }
+
+            return cells;
+        }
+
+
+        private static Vector2 GetEdgeNormal(GraphEdge edge, VoronoiCell cell = null)
+        {
+            if (cell == null) cell = edge.AdjacentCell(null);
+            if (cell == null) return Vector2.UnitX;
+
+            CompareCCW compare = new CompareCCW(cell.Center);
+            if (compare.Compare(edge.Point1, edge.Point2) == -1)
+            {
+                var temp = edge.Point1;
+                edge.Point1 = edge.Point2;
+                edge.Point2 = temp;
+            }
+
+            Vector2 normal = Vector2.Zero;
+
+            normal = Vector2.Normalize(edge.Point2 - edge.Point1);
+            Vector2 diffToCell = Vector2.Normalize(cell.Center - edge.Point2);
+
+            normal = new Vector2(-normal.Y, normal.X);
+            if (Vector2.Dot(normal, diffToCell) < 0)
+            {
+                normal = -normal;
+            }
+
+            return normal;
+        }
+
+        public static List<VoronoiCell> GeneratePath(
+            List<Point> pathNodes, List<VoronoiCell> cells, List<VoronoiCell>[,] cellGrid,
+            int gridCellSize, Rectangle limits, float wanderAmount = 0.3f, bool mirror = false)
+        {
+            var targetCells = new List<VoronoiCell>();
+            for (int i = 0; i < pathNodes.Count; i++)
+            {
+                //a search depth of 2 is large enough to find a cell in almost all maps, but in case it fails, we increase the depth
+                int searchDepth = 2;
+                while (searchDepth < 5)
+                {
+                    int cellIndex = FindCellIndex(pathNodes[i], cells, cellGrid, gridCellSize, searchDepth);
+                    if (cellIndex > -1)
+                    {
+                        targetCells.Add(cells[cellIndex]);
+                        break;
+                    }
+
+                    searchDepth++;
+                }
+
+            }
+
+            return GeneratePath(targetCells, cells, cellGrid, gridCellSize, limits, wanderAmount, mirror);
+        }
+
+
+        public static List<VoronoiCell> GeneratePath(
+            List<VoronoiCell> targetCells, List<VoronoiCell> cells, List<VoronoiCell>[,] cellGrid, 
+            int gridCellSize, Rectangle limits, float wanderAmount = 0.3f, bool mirror = false)
+        {
+            Stopwatch sw2 = new Stopwatch();
+            sw2.Start();
+
+            //how heavily the path "steers" towards the endpoint
+            //lower values will cause the path to "wander" more, higher will make it head straight to the end
+            wanderAmount = MathHelper.Clamp(wanderAmount, 0.0f, 1.0f);
+
+            List<GraphEdge> allowedEdges = new List<GraphEdge>();
+            List<VoronoiCell> pathCells = new List<VoronoiCell>();
+            
+            VoronoiCell currentCell = targetCells[0];
+            currentCell.CellType = CellType.Path;
+            pathCells.Add(currentCell);
+
+            int currentTargetIndex = 1;
+
+            int iterationsLeft = cells.Count;
+
+            do
+            {
+                int edgeIndex = 0;
+
+                allowedEdges.Clear();
+                foreach (GraphEdge edge in currentCell.Edges)
+                {
+                    var adjacentCell = edge.AdjacentCell(currentCell);
+                    if (limits.Contains(adjacentCell.Site.Coord.X, adjacentCell.Site.Coord.Y))
+                    {
+                        allowedEdges.Add(edge);
+                    }
+                }
+
+                //steer towards target
+                if (Rand.Range(0.0f, 1.0f, Rand.RandSync.Server) > wanderAmount || allowedEdges.Count == 0)
+                {
+                    double smallestDist = double.PositiveInfinity;
+                    for (int i = 0; i < currentCell.Edges.Count; i++)
+                    {
+                        var adjacentCell = currentCell.Edges[i].AdjacentCell(currentCell);
+                        double dist = MathUtils.Distance(
+                            adjacentCell.Site.Coord.X, adjacentCell.Site.Coord.Y,
+                            targetCells[currentTargetIndex].Site.Coord.X, targetCells[currentTargetIndex].Site.Coord.Y);
+                        if (dist < smallestDist)
+                        {
+                            edgeIndex = i;
+                            smallestDist = dist;
+                        }
+                    }
+                }
+                //choose random edge (ignoring ones where the adjacent cell is outside limits)
+                else
+                {
+                    edgeIndex = Rand.Int(allowedEdges.Count, Rand.RandSync.Server);
+                    if (mirror && edgeIndex > 0) edgeIndex = allowedEdges.Count - edgeIndex;
+                    edgeIndex = currentCell.Edges.IndexOf(allowedEdges[edgeIndex]);
+                }
+
+                currentCell = currentCell.Edges[edgeIndex].AdjacentCell(currentCell);
+                currentCell.CellType = CellType.Path;
+                pathCells.Add(currentCell);
+
+                iterationsLeft--;
+
+                if (currentCell == targetCells[currentTargetIndex])
+                {
+                    currentTargetIndex += 1;
+                    if (currentTargetIndex >= targetCells.Count) break;
+                }
+
+            } while (currentCell != targetCells[targetCells.Count - 1] && iterationsLeft > 0);
+
+
+            Debug.WriteLine("gettooclose: " + sw2.ElapsedMilliseconds + " ms");
+            sw2.Restart();
+
+            return pathCells;
+        }
+
+        /// <summary>
+        /// Makes the cell rounder by subdividing the edges and offsetting them at the middle
+        /// </summary>
+        /// <param name="minEdgeLength">How small the individual subdivided edges can be (smaller values produce rounder shapes, but require more geometry)</param>
+        public static void RoundCell(VoronoiCell cell, float minEdgeLength = 500.0f, float roundingAmount = 0.5f, float irregularity = 0.1f)
+        {
+            List<GraphEdge> tempEdges = new List<GraphEdge>();
+            foreach (GraphEdge edge in cell.Edges)
+            {
+                if (!edge.IsSolid)
+                {
+                    tempEdges.Add(edge);
+                    continue;
+                }
+
+                List<Vector2> edgePoints = new List<Vector2>();
+                Vector2 edgeNormal = GetEdgeNormal(edge, cell);
+                float edgeLength = Vector2.Distance(edge.Point1, edge.Point2);
+                int pointCount = (int)Math.Max(Math.Ceiling(edgeLength / minEdgeLength), 1);
+                Vector2 edgeDir = (edge.Point2 - edge.Point1);
+                for (int i = 0; i <= pointCount; i++)
+                {
+                    if (i == 0)
+                    {
+                        edgePoints.Add(edge.Point1);
+                    }
+                    else if (i == pointCount)
+                    {
+                        edgePoints.Add(edge.Point2);
+                    }
+                    else
+                    {
+                        float centerF = 0.5f - Math.Abs(0.5f - (i / (float)pointCount));
+                        float randomVariance = Rand.Range(0, irregularity, Rand.RandSync.Server);
+                        edgePoints.Add(
+                            edge.Point1 +
+                            edgeDir * (i / (float)pointCount) -
+                            edgeNormal * edgeLength * (roundingAmount + randomVariance) * centerF);
+                    }
+                }
+
+                for (int i = 0; i < pointCount; i++)
+                {
+                    tempEdges.Add(new GraphEdge(edgePoints[i], edgePoints[i + 1])
+                    {
+                        Cell1 = edge.Cell1,
+                        Cell2 = edge.Cell2,
+                        IsSolid = edge.IsSolid,
+                        Site1 = edge.Site1,
+                        Site2 = edge.Site2,
+                        OutsideLevel = edge.OutsideLevel
+                    });
+                }
+            }
+
+            cell.Edges = tempEdges;
+        }
+
+        public static Body GeneratePolygons(List<VoronoiCell> cells, Level level, out List<Vector2[]> renderTriangles)
+        {
+            renderTriangles = new List<Vector2[]>();
+
+            List<Vector2> tempVertices = new List<Vector2>();
+            List<Vector2> bodyPoints = new List<Vector2>();
+
+            Body cellBody = new Body()
+            {
+                SleepingAllowed = false,
+                BodyType = BodyType.Static,
+                CollisionCategories = Physics.CollisionLevel
+            };
+            GameMain.World.Add(cellBody);
+
+            for (int n = cells.Count - 1; n >= 0; n-- )
+            {
+                VoronoiCell cell = cells[n];
+                
+                bodyPoints.Clear();
+                tempVertices.Clear();
+                foreach (GraphEdge ge in cell.Edges)
+                {
+                    if (Vector2.DistanceSquared(ge.Point1, ge.Point2) < 0.01f) continue;
+                    if (!tempVertices.Any(v => Vector2.DistanceSquared(ge.Point1, v) < 1.0f))
+                    {
+                        tempVertices.Add(ge.Point1);
+                        bodyPoints.Add(ge.Point1);
+                    }
+                    if (!tempVertices.Any(v => Vector2.DistanceSquared(ge.Point2, v) < 1.0f))
+                    {
+                        tempVertices.Add(ge.Point2);
+                        bodyPoints.Add(ge.Point2);
+                    }
+                }
+
+                if (tempVertices.Count < 3 || bodyPoints.Count < 2)
+                {
+                    cells.RemoveAt(n);
+                    continue;
+                }
+
+                renderTriangles.AddRange(MathUtils.TriangulateConvexHull(tempVertices, cell.Center));
+                
+                if (bodyPoints.Count < 2) continue;
+
+                if (bodyPoints.Count < 3)
+                {
+                    foreach (Vector2 vertex in tempVertices)
+                    {
+                        if (bodyPoints.Contains(vertex)) continue;
+                        bodyPoints.Add(vertex);
+                        break;
+                    }
+                }
+
+                for (int i = 0; i < bodyPoints.Count; i++)
+                {
+                    cell.BodyVertices.Add(bodyPoints[i]);
+                    bodyPoints[i] = ConvertUnits.ToSimUnits(bodyPoints[i]);
+                }
+                
+                if (cell.CellType == CellType.Empty) continue;
+
+                cellBody.UserData = cell;
+                var triangles = MathUtils.TriangulateConvexHull(bodyPoints, ConvertUnits.ToSimUnits(cell.Center));
+                
+                for (int i = 0; i < triangles.Count; i++)
+                {
+                    //don't create a triangle if the area of the triangle is too small
+                    //(apparently Farseer doesn't like polygons with a very small area, see Shape.ComputeProperties)
+                    Vector2 a = triangles[i][0];
+                    Vector2 b = triangles[i][1];
+                    Vector2 c = triangles[i][2];
+                    float area = Math.Abs(a.X * (b.Y - c.Y) + b.X * (c.Y - a.Y) + c.X * (a.Y - b.Y)) / 2.0f;
+                    if (area < 1.0f) continue;
+
+                    Vertices bodyVertices = new Vertices(triangles[i]);
+                    var newFixture = cellBody.CreatePolygon(bodyVertices, 5.0f);
+                    newFixture.UserData = cell;
+
+                    if (newFixture.Shape.MassData.Area < FarseerPhysics.Settings.Epsilon)
+                    {
+                        DebugConsole.ThrowError("Invalid triangle created by CaveGenerator (" + triangles[i][0] + ", " + triangles[i][1] + ", " + triangles[i][2] + ")");
+                        GameAnalyticsManager.AddErrorEventOnce(
+                            "CaveGenerator.GeneratePolygons:InvalidTriangle",
+                            GameAnalyticsSDK.Net.EGAErrorSeverity.Warning,
+                            "Invalid triangle created by CaveGenerator (" + triangles[i][0] + ", " + triangles[i][1] + ", " + triangles[i][2] + "). Seed: " + level.Seed);
+                    }
+                }
+                
+                cell.Body = cellBody;
+            }
+
+            return cellBody;
+        }
+        
+        public static List<Vector2> CreateRandomChunk(float radius, int vertexCount, float radiusVariance)
+        {
+            Debug.Assert(radiusVariance < radius);
+            Debug.Assert(vertexCount >= 3);
+
+            List<Vector2> verts = new List<Vector2>();
+            float angleStep = MathHelper.TwoPi / vertexCount;
+            float angle = 0.0f;
+            for (int i = 0; i < vertexCount; i++)
+            {
+                verts.Add(new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)) *
+                    (radius + Rand.Range(-radiusVariance, radiusVariance, Rand.RandSync.Server)));
+                angle += angleStep;
+            }
+            return verts;
+        }
+
+        /// <summary>
+        /// find the index of the cell which the point is inside
+        /// (actually finds the cell whose center is closest, but it's always the correct cell assuming the point is inside the borders of the diagram)
+        /// </summary>
+        public static int FindCellIndex(Vector2 position,List<VoronoiCell> cells, List<VoronoiCell>[,] cellGrid, int gridCellSize, int searchDepth = 1, Vector2? offset = null)
+        {
+            float closestDist = float.PositiveInfinity;
+            VoronoiCell closestCell = null;
+
+            Vector2 gridOffset = offset == null ? Vector2.Zero : (Vector2)offset;
+            position -= gridOffset;
+
+            int gridPosX = (int)Math.Floor(position.X / gridCellSize);
+            int gridPosY = (int)Math.Floor(position.Y / gridCellSize);
+
+            for (int x = Math.Max(gridPosX - searchDepth, 0); x <= Math.Min(gridPosX + searchDepth, cellGrid.GetLength(0) - 1); x++)
+            {
+                for (int y = Math.Max(gridPosY - searchDepth, 0); y <= Math.Min(gridPosY + searchDepth, cellGrid.GetLength(1) - 1); y++)
+                {
+                    for (int i = 0; i < cellGrid[x, y].Count; i++)
+                    {
+                        float dist = Vector2.DistanceSquared(cellGrid[x, y][i].Center, position);
+                        if (dist > closestDist) continue;
+
+                        closestDist = dist;
+                        closestCell = cellGrid[x, y][i];
+                    }
+                }
+            }
+
+            return cells.IndexOf(closestCell);
+        }
+
+        public static int FindCellIndex(Point position, List<VoronoiCell> cells, List<VoronoiCell>[,] cellGrid, int gridCellSize, int searchDepth = 1)
+        {
+            int closestDist = int.MaxValue;
+            VoronoiCell closestCell = null;
+            
+            int gridPosX = position.X / gridCellSize;
+            int gridPosY = position.Y / gridCellSize;
+
+            for (int x = Math.Max(gridPosX - searchDepth, 0); x <= Math.Min(gridPosX + searchDepth, cellGrid.GetLength(0) - 1); x++)
+            {
+                for (int y = Math.Max(gridPosY - searchDepth, 0); y <= Math.Min(gridPosY + searchDepth, cellGrid.GetLength(1) - 1); y++)
+                {
+                    for (int i = 0; i < cellGrid[x, y].Count; i++)
+                    {
+                        int dist = MathUtils.DistanceSquared(
+                            (int)cellGrid[x, y][i].Site.Coord.X, (int)cellGrid[x, y][i].Site.Coord.Y, 
+                            position.X, position.Y);
+                        if (dist > closestDist) continue;
+
+                        closestDist = dist;
+                        closestCell = cellGrid[x, y][i];
+                    }
+                }
+            }
+
+            return cells.IndexOf(closestCell);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/LevelGenerationParams.cs

@@ -0,0 +1,522 @@
+using Barotrauma.Extensions;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    class Biome
+    {
+
+        public readonly string Identifier;
+        public readonly string DisplayName;
+        public readonly string Description;
+
+        public readonly List<int> AllowedZones = new List<int>();
+
+        public Biome(string name, string description)
+        {
+            Identifier = name;
+            Description = description;
+        }
+
+        public Biome(XElement element)
+        {
+            Identifier = element.GetAttributeString("identifier", "");
+            if (string.IsNullOrEmpty(Identifier))
+            {
+                Identifier = element.GetAttributeString("name", "");
+                DebugConsole.ThrowError("Error in biome \"" + Identifier + "\": identifier missing, using name as the identifier.");
+            }
+
+            DisplayName =
+                TextManager.Get("biomename." + Identifier, returnNull: true) ??
+                element.GetAttributeString("name", "Biome") ??
+                TextManager.Get("biomename." + Identifier);
+
+            Description =
+                TextManager.Get("biomedescription." + Identifier, returnNull: true) ??
+                element.GetAttributeString("description", "") ??
+                TextManager.Get("biomedescription." + Identifier);
+
+            string allowedZonesStr = element.GetAttributeString("AllowedZones", "1,2,3,4,5,6,7,8,9");
+            string[] zoneIndices = allowedZonesStr.Split(',');
+            for (int i = 0; i < zoneIndices.Length; i++)
+            {
+                int zoneIndex = -1;
+                if (!int.TryParse(zoneIndices[i].Trim(), out zoneIndex))
+                {
+                    DebugConsole.ThrowError("Error in biome config \"" + Identifier + "\" - \"" + zoneIndices[i] + "\" is not a valid zone index.");
+                    continue;
+                }
+                AllowedZones.Add(zoneIndex);
+            }
+        }
+    }
+
+    class LevelGenerationParams : ISerializableEntity
+    {
+        public static List<LevelGenerationParams> LevelParams
+        {
+            get { return levelParams; }
+        }
+
+        private static List<LevelGenerationParams> levelParams;
+        private static List<Biome> biomes;
+
+        public string Name
+        {
+            get;
+            private set;
+        }
+
+        private int minWidth, maxWidth, height;
+
+        private Point voronoiSiteInterval;
+        //how much the sites are "scattered" on x- and y-axis
+        //if Vector2.Zero, the sites will just be placed in a regular grid pattern
+        private Point voronoiSiteVariance;
+
+        //how far apart the nodes of the main path can be
+        //x = min interval, y = max interval
+        private Point mainPathNodeIntervalRange;
+
+        private int smallTunnelCount;
+        //x = min length, y = max length
+        private Point smallTunnelLengthRange;
+
+        //how large portion of the bottom of the level should be "carved out"
+        //if 0.0f, the bottom will be completely solid (making the abyss unreachable)
+        //if 1.0f, the bottom will be completely open
+        private float bottomHoleProbability;
+
+        //the y-position of the ocean floor (= the position from which the bottom formations extend upwards)
+        private int seaFloorBaseDepth;
+        //how much random variance there can be in the height of the formations
+        private int seaFloorVariance;
+
+        private int cellSubdivisionLength;
+        private float cellRoundingAmount;
+        private float cellIrregularity;
+
+        private int mountainCountMin, mountainCountMax;
+
+        private int mountainHeightMin, mountainHeightMax;
+
+        private int ruinCount;
+
+        private float waterParticleScale;
+
+        //which biomes can this type of level appear in
+        private List<Biome> allowedBiomes = new List<Biome>();
+
+        public IEnumerable<Biome> AllowedBiomes
+        {
+            get { return allowedBiomes; }
+        }
+
+        public Dictionary<string, SerializableProperty> SerializableProperties
+        {
+            get;
+            set;
+        }
+
+        [Serialize("27,30,36", true), Editable]
+        public Color AmbientLightColor
+        {
+            get;
+            set;
+        }
+
+        [Serialize("20,40,50", true), Editable()]
+        public Color BackgroundTextureColor
+        {
+            get;
+            set;
+        }
+
+        [Serialize("20,40,50", true), Editable]
+        public Color BackgroundColor
+        {
+            get;
+            set;
+        }
+
+        [Serialize("255,255,255", true), Editable]
+        public Color WallColor
+        {
+            get;
+            set;
+        }
+
+        [Serialize(1000, true, description: "The total number of level objects (vegetation, vents, etc) in the level."), Editable(MinValueInt = 0, MaxValueInt = 100000)]
+        public int LevelObjectAmount
+        {
+            get;
+            set;
+        }
+
+        [Serialize(100000, true), Editable(MinValueInt = 10000, MaxValueInt = 1000000)]
+        public int MinWidth
+        {
+            get { return minWidth; }
+            set { minWidth = Math.Max(value, 2000); }
+        }
+
+        [Serialize(100000, true), Editable(MinValueInt = 10000, MaxValueInt = 1000000)]
+        public int MaxWidth
+        {
+            get { return maxWidth; }
+            set { maxWidth = Math.Max(value, 2000); }
+        }
+
+        [Serialize(50000, true), Editable(MinValueInt = 10000, MaxValueInt = 1000000)]
+        public int Height
+        {
+            get { return height; }
+            set { height = Math.Max(value, 2000); }
+        }
+
+        [Editable, Serialize("3000, 3000", true, description: "How far from each other voronoi sites are placed. " +
+            "Sites determine shape of the voronoi graph which the level walls are generated from. " +
+            "(Decreasing this value causes the number of sites, and the complexity of the level, to increase exponentially - be careful when adjusting)")]
+        public Point VoronoiSiteInterval
+        {
+            get { return voronoiSiteInterval; }
+            set
+            {
+                voronoiSiteInterval.X = MathHelper.Clamp(value.X, 100, MinWidth / 2);
+                voronoiSiteInterval.Y = MathHelper.Clamp(value.Y, 100, height / 2);
+            }
+        }
+
+        [Editable, Serialize("700,700", true, description: "How much random variation to apply to the positions of the voronoi sites on each axis. " +
+            "Small values produce roughly rectangular level walls. The larger the values are, the less uniform the shapes get.")]
+        public Point VoronoiSiteVariance
+        {
+            get { return voronoiSiteVariance; }
+            set
+            {
+                voronoiSiteVariance = new Point(
+                    MathHelper.Clamp(value.X, 0, voronoiSiteInterval.X),
+                    MathHelper.Clamp(value.Y, 0, voronoiSiteInterval.Y));
+            }
+        }
+
+        [Editable(MinValueInt = 100, MaxValueInt = 10000), Serialize(1000, true, description: "The edges of the individual wall cells are subdivided into edges of this size. "
+            + "Can be used in conjunction with the rounding values to make the cells rounder. Smaller values will make the cells look smoother, " +
+            "but make the level more performance-intensive as the number of polygons used in rendering and physics calculations increases.")]
+        public int CellSubdivisionLength
+        {
+            get { return cellSubdivisionLength; }
+            set
+            {
+                cellSubdivisionLength = Math.Max(value, 10);
+            }
+        }
+
+
+        [Editable(MinValueFloat = 0.0f, MaxValueFloat = 1.0f), Serialize(0.5f, true, description: "How much the individual wall cells are rounded. "
+            + "Note that the final shape of the cells is also affected by the CellSubdivisionLength parameter.")]
+        public float CellRoundingAmount
+        {
+            get { return cellRoundingAmount; }
+            set
+            {
+                cellRoundingAmount = MathHelper.Clamp(value, 0.0f, 1.0f);
+            }
+        }
+
+        [Editable(MinValueFloat = 0.0f, MaxValueFloat = 1.0f), Serialize(0.1f, true, description: "How much random variance is applied to the edges of the cells. "
+            + "Note that the final shape of the cells is also affected by the CellSubdivisionLength parameter.")]
+        public float CellIrregularity
+        {
+            get { return cellIrregularity; }
+            set
+            {
+                cellIrregularity = MathHelper.Clamp(value, 0.0f, 1.0f);
+            }
+        }
+
+
+        [Editable, Serialize("5000, 10000", true, description: "The distance between the nodes that are used to generate the main path through the level (min, max). Larger values produce a straighter path.")]
+        public Point MainPathNodeIntervalRange
+        {
+            get { return mainPathNodeIntervalRange; }
+            set
+            {
+                mainPathNodeIntervalRange.X = MathHelper.Clamp(value.X, 100, MinWidth / 2);
+                mainPathNodeIntervalRange.Y = MathHelper.Clamp(value.Y, mainPathNodeIntervalRange.X, MinWidth / 2);
+            }
+        }
+
+        [Editable, Serialize(5, true, description: "The number of small tunnels placed along the main path.")]
+        public int SmallTunnelCount
+        {
+            get { return smallTunnelCount; }
+            set { smallTunnelCount = MathHelper.Clamp(value, 0, 100); }
+        }
+
+        [Editable, Serialize("5000, 10000", true, description: "The minimum and maximum length of small tunnels placed along the main path.")]
+        public Point SmallTunnelLengthRange
+        {
+            get { return smallTunnelLengthRange; }
+            set
+            {
+                smallTunnelLengthRange.X = MathHelper.Clamp(value.X, 100, MinWidth);
+                smallTunnelLengthRange.Y = MathHelper.Clamp(value.Y, smallTunnelLengthRange.X, MinWidth);
+            }
+        }
+
+        [Serialize(100, true), Editable(MinValueInt = 0, MaxValueInt = 10000)]
+        public int ItemCount
+        {
+            get;
+            set;
+        }
+
+        [Serialize(0, true), Editable(MinValueInt = 0, MaxValueInt = 20)]
+        public int FloatingIceChunkCount
+        {
+            get;
+            set;
+        }
+
+        [Serialize(300000, true, description: "How far below the level the sea floor is placed."), Editable(MinValueFloat = Level.MaxEntityDepth, MaxValueFloat = 0.0f)]
+        public int SeaFloorDepth
+        {
+            get { return seaFloorBaseDepth; }
+            set { seaFloorBaseDepth = MathHelper.Clamp(value, Level.MaxEntityDepth, 0); }
+        }
+
+        [Serialize(1000, true, description: "Variance of the depth of the sea floor. Smaller values produce a smoother sea floor."), Editable(MinValueFloat = 0.0f, MaxValueFloat = 100000.0f)]
+        public int SeaFloorVariance
+        {
+            get { return seaFloorVariance; }
+            set { seaFloorVariance = value; }
+        }
+
+        [Serialize(0, true, description: "The minimum number of mountains on the sea floor."), Editable(MinValueInt = 0, MaxValueInt = 20)]
+        public int MountainCountMin
+        {
+            get { return mountainCountMin; }
+            set
+            {
+                mountainCountMin = Math.Max(value, 0);
+            }
+        }
+
+        [Serialize(0, true, description: "The maximum number of mountains on the sea floor."), Editable(MinValueInt = 0, MaxValueInt = 20)]
+        public int MountainCountMax
+        {
+            get { return mountainCountMax; }
+            set
+            {
+                mountainCountMax = Math.Max(value, 0);
+            }
+        }
+
+        [Serialize(1000, true, description: "The minimum height of the mountains on the sea floor."), Editable(MinValueInt = 0, MaxValueInt = 1000000)]
+        public int MountainHeightMin
+        {
+            get { return mountainHeightMin; }
+            set
+            {
+                mountainHeightMin = Math.Max(value, 0);
+            }
+        }
+
+        [Serialize(5000, true, description: "The maximum height of the mountains on the sea floor."), Editable(MinValueInt = 0, MaxValueInt = 1000000)]
+        public int MountainHeightMax
+        {
+            get { return mountainHeightMax; }
+            set
+            {
+                mountainHeightMax = Math.Max(value, 0);
+            }
+        }
+
+        [Serialize(1, true, description: "The number of alien ruins in the level."), Editable(MinValueInt = 0, MaxValueInt = 50)]
+        public int RuinCount
+        {
+            get { return ruinCount; }
+            set { ruinCount = MathHelper.Clamp(value, 0, 10); }
+        }
+
+        [Serialize(0.4f, true, description: "The probability for wall cells to be removed from the bottom of the map. A value of 0 will produce a completely enclosed tunnel and 1 will make the entire bottom of the level completely open."), Editable()]
+        public float BottomHoleProbability
+        {
+            get { return bottomHoleProbability; }
+            set { bottomHoleProbability = MathHelper.Clamp(value, 0.0f, 1.0f); }
+        }
+
+        [Serialize(1.0f, true, description: "Scale of the water particle texture."), Editable]
+        public float WaterParticleScale
+        {
+            get { return waterParticleScale; }
+            private set { waterParticleScale = Math.Max(value, 0.01f); }
+        }
+
+        public Sprite BackgroundSprite { get; private set; }
+        public Sprite BackgroundTopSprite { get; private set; }
+        public Sprite WallSprite { get; private set; }
+        public Sprite WallSpriteSpecular { get; private set; }
+        public Sprite WallEdgeSprite { get; private set; }
+        public Sprite WallEdgeSpriteSpecular { get; private set; }
+        public Sprite WaterParticles { get; private set; }
+
+        public static List<Biome> GetBiomes()
+        {
+            return biomes;
+        }
+
+        public static LevelGenerationParams GetRandom(string seed, Biome biome = null)
+        {
+            Rand.SetSyncedSeed(ToolBox.StringToInt(seed));
+
+            if (levelParams == null || !levelParams.Any())
+            {
+                DebugConsole.ThrowError("Level generation presets not found - using default presets");
+                return new LevelGenerationParams(null);
+            }
+
+            if (biome == null)
+            {
+                return levelParams.GetRandom(lp => lp.allowedBiomes.Count > 0, Rand.RandSync.Server);
+            }
+
+            var matchingLevelParams = levelParams.FindAll(lp => lp.allowedBiomes.Contains(biome));
+            if (matchingLevelParams.Count == 0)
+            {
+                DebugConsole.ThrowError("Level generation presets not found for the biome \"" + biome.Identifier + "\"!");
+                return new LevelGenerationParams(null);
+            }
+
+            return matchingLevelParams[Rand.Range(0, matchingLevelParams.Count, Rand.RandSync.Server)];
+        }
+
+        private LevelGenerationParams(XElement element)
+        {
+            Name = element == null ? "default" : element.Name.ToString();
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+
+            string biomeStr = element.GetAttributeString("biomes", "");
+            if (string.IsNullOrWhiteSpace(biomeStr))
+            {
+                allowedBiomes = new List<Biome>(biomes);
+            }
+            else
+            {
+                string[] biomeNames = biomeStr.Split(',');
+                for (int i = 0; i < biomeNames.Length; i++)
+                {
+                    string biomeName = biomeNames[i].Trim().ToLowerInvariant();
+                    if (biomeName == "none") { continue; }
+
+                    Biome matchingBiome = biomes.Find(b => b.Identifier.ToLowerInvariant() == biomeName);
+                    if (matchingBiome == null)
+                    {
+                        matchingBiome = biomes.Find(b => b.DisplayName.ToLowerInvariant() == biomeName);
+                        if (matchingBiome == null)
+                        {
+                            DebugConsole.ThrowError("Error in level generation parameters: biome \"" + biomeName + "\" not found.");
+                            continue;
+                        }
+                        else
+                        {
+                            DebugConsole.NewMessage("Please use biome identifiers instead of names in level generation parameter \"" + Name + "\".", Color.Orange);
+                        }
+                    }
+
+                    allowedBiomes.Add(matchingBiome);
+                }
+            }
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "background":
+                        BackgroundSprite = new Sprite(subElement);
+                        break;
+                    case "backgroundtop":
+                        BackgroundTopSprite = new Sprite(subElement);
+                        break;
+                    case "wall":
+                        WallSprite = new Sprite(subElement);
+                        break;
+                    case "wallspecular":
+                        WallSpriteSpecular = new Sprite(subElement);
+                        break;
+                    case "walledge":
+                        WallEdgeSprite = new Sprite(subElement);
+                        break;
+                    case "walledgespecular":
+                        WallEdgeSpriteSpecular = new Sprite(subElement);
+                        break;
+                    case "waterparticles":
+                        WaterParticles = new Sprite(subElement);
+                        break;
+                }
+            }
+        }
+
+        public static void LoadPresets()
+        {
+            levelParams = new List<LevelGenerationParams>();
+            biomes = new List<Biome>();
+
+            var files = GameMain.Instance.GetFilesOfType(ContentType.LevelGenerationParameters);
+            if (!files.Any())
+            {
+                files = new List<ContentFile>() { new ContentFile("Content/Map/LevelGenerationParameters.xml", ContentType.LevelGenerationParameters) };
+            }
+
+            List<XElement> biomeElements = new List<XElement>();
+            List<XElement> levelParamElements = new List<XElement>();
+
+            foreach (ContentFile file in files)
+            {
+                XDocument doc = XMLExtensions.TryLoadXml(file.Path);
+                if (doc == null) { continue; }
+                var mainElement = doc.Root;
+                if (doc.Root.IsOverride())
+                {
+                    mainElement = doc.Root.FirstElement();
+                    biomeElements.Clear();
+                    levelParamElements.Clear();
+                    DebugConsole.NewMessage($"Overriding the level generation parameters with '{file.Path}'", Color.Yellow);
+                }
+                else if (biomeElements.Any() || levelParamElements.Any())
+                {
+                    DebugConsole.ThrowError($"Error in '{file.Path}': Another level generation parameter file already loaded! Use <override></override> tags to override it.");
+                    break;
+                }
+
+                foreach (XElement element in mainElement.Elements())
+                {
+                    if (element.Name.ToString().ToLowerInvariant() == "biomes")
+                    {
+                        biomeElements.AddRange(element.Elements());
+                    }
+                    else
+                    {
+                        levelParamElements.Add(element);
+                    }
+                }
+            }
+
+            foreach (XElement biomeElement in biomeElements)
+            {
+                biomes.Add(new Biome(biomeElement));
+            }
+
+            foreach (XElement levelParamElement in levelParamElements)
+            {
+                levelParams.Add(new LevelGenerationParams(levelParamElement));
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/LevelObjects/LevelObject.cs

@@ -0,0 +1,133 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class LevelObject
+    {
+        public readonly LevelObjectPrefab Prefab;
+        public Vector3 Position;
+
+        public float NetworkUpdateTimer;
+
+        public float Scale;
+
+        public float Rotation;
+
+        private int spriteIndex;
+
+        public LevelObjectPrefab ActivePrefab;
+
+        public PhysicsBody PhysicsBody
+        {
+            get;
+            private set;
+        }
+
+        public List<LevelTrigger> Triggers
+        {
+            get;
+            private set;
+        }
+
+        public bool NeedsNetworkSyncing
+        {
+            get { return Triggers.Any(t => t.NeedsNetworkSyncing); }
+            set { Triggers.ForEach(t => t.NeedsNetworkSyncing = false); }
+        }
+
+        public Sprite Sprite
+        {
+            get { return spriteIndex < 0 || Prefab.Sprites.Count == 0 ? null : Prefab.Sprites[spriteIndex % Prefab.Sprites.Count]; }
+        }
+        public Sprite SpecularSprite
+        {
+            get { return spriteIndex < 0 || Prefab.SpecularSprites.Count == 0 ? null : Prefab.SpecularSprites[spriteIndex % Prefab.SpecularSprites.Count]; }
+        }
+
+        public LevelObject(LevelObjectPrefab prefab, Vector3 position, float scale, float rotation = 0.0f)
+        {
+            Triggers = new List<LevelTrigger>();
+
+            ActivePrefab = Prefab = prefab;
+            Position = position;
+            Scale = scale;
+            Rotation = rotation;
+
+            spriteIndex = ActivePrefab.Sprites.Any() ? Rand.Int(ActivePrefab.Sprites.Count, Rand.RandSync.Server) : -1;
+
+            if (prefab.PhysicsBodyElement != null)
+            {
+                PhysicsBody = new PhysicsBody(prefab.PhysicsBodyElement, ConvertUnits.ToSimUnits(new Vector2(position.X, position.Y)), Scale);
+            }
+
+            foreach (XElement triggerElement in prefab.LevelTriggerElements)
+            {
+                Vector2 triggerPosition = triggerElement.GetAttributeVector2("position", Vector2.Zero) * scale;
+
+                if (rotation != 0.0f)
+                {
+                    var ca = (float)Math.Cos(rotation);
+                    var sa = (float)Math.Sin(rotation);
+
+                    triggerPosition = new Vector2(
+                        ca * triggerPosition.X + sa * triggerPosition.Y,
+                        -sa * triggerPosition.X + ca * triggerPosition.Y);
+                }
+
+                var newTrigger = new LevelTrigger(triggerElement, new Vector2(position.X, position.Y) + triggerPosition, -rotation, scale, prefab.Name);
+                int parentTriggerIndex = prefab.LevelTriggerElements.IndexOf(triggerElement.Parent);
+                if (parentTriggerIndex > -1) newTrigger.ParentTrigger = Triggers[parentTriggerIndex];
+                Triggers.Add(newTrigger);
+            }
+
+            InitProjSpecific();
+        }
+        
+        partial void InitProjSpecific();
+        
+        public Vector2 LocalToWorld(Vector2 localPosition, float swingState = 0.0f)
+        {
+            Vector2 emitterPos = localPosition * Scale;
+
+            if (Rotation != 0.0f || Prefab.SwingAmountRad != 0.0f)
+            {
+                float rot = Rotation + swingState * Prefab.SwingAmountRad;
+
+                var ca = (float)Math.Cos(rot);
+                var sa = (float)Math.Sin(rot);
+
+                emitterPos = new Vector2(
+                    ca * emitterPos.X + sa * emitterPos.Y,
+                    -sa * emitterPos.X + ca * emitterPos.Y);
+            }
+            return new Vector2(Position.X, Position.Y) + emitterPos;
+        }
+
+        public void Remove()
+        {
+            RemoveProjSpecific();
+        }
+
+        partial void RemoveProjSpecific();
+
+        public override string ToString()
+        {
+            return "LevelObject (" + ActivePrefab.Name + ")";
+        }
+
+        public void ServerWrite(IWriteMessage msg, Client c)
+        {
+            for (int j = 0; j < Triggers.Count; j++)
+            {
+                if (!Triggers[j].UseNetworkSyncing) continue;
+                Triggers[j].ServerWrite(msg, c);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/LevelObjects/LevelObjectManager.cs

@@ -0,0 +1,416 @@
+#if CLIENT
+using Barotrauma.Particles;
+#endif
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    partial class LevelObjectManager : Entity, IServerSerializable
+    {
+        const int GridSize = 2000;
+
+        private List<LevelObject> objects;
+        private List<LevelObject>[,] objectGrid;
+
+        public LevelObjectManager() : base(null)
+        {
+        }
+
+        class SpawnPosition
+        {
+            public readonly GraphEdge GraphEdge;
+            public readonly Vector2 Normal;
+            public readonly LevelObjectPrefab.SpawnPosType SpawnPosType;
+            public readonly Alignment Alignment;
+            public readonly float Length;
+
+            public SpawnPosition(GraphEdge graphEdge, Vector2 normal, LevelObjectPrefab.SpawnPosType spawnPosType, Alignment alignment)
+            {
+                GraphEdge = graphEdge;
+                Normal = normal;
+                SpawnPosType = spawnPosType;
+                Alignment = alignment;
+                
+                Length = Vector2.Distance(graphEdge.Point1, graphEdge.Point2);
+            }
+
+            public float GetSpawnProbability(LevelObjectPrefab prefab)
+            {
+                if (prefab.ClusteringAmount <= 0.0f) return Length;
+
+                float noise = (float)(
+                    PerlinNoise.CalculatePerlin(GraphEdge.Point1.X / 10000.0f, GraphEdge.Point1.Y / 10000.0f, prefab.ClusteringGroup) +
+                    PerlinNoise.CalculatePerlin(GraphEdge.Point1.X / 20000.0f, GraphEdge.Point1.Y / 20000.0f, prefab.ClusteringGroup));
+
+                return Length * (float)Math.Pow(noise, prefab.ClusteringAmount);
+            }
+        }
+
+        public void PlaceObjects(Level level, int amount)
+        {
+            objectGrid = new List<LevelObject>[
+                level.Size.X / GridSize,
+                (level.Size.Y - level.BottomPos) / GridSize];
+            
+            List<SpawnPosition> availableSpawnPositions = new List<SpawnPosition>();
+            var levelCells = level.GetAllCells();
+            availableSpawnPositions.AddRange(GetAvailableSpawnPositions(levelCells, LevelObjectPrefab.SpawnPosType.Wall));            
+            availableSpawnPositions.AddRange(GetAvailableSpawnPositions(level.SeaFloor.Cells, LevelObjectPrefab.SpawnPosType.SeaFloor));
+            
+            foreach (RuinGeneration.Ruin ruin in level.Ruins)
+            {
+                foreach (var ruinShape in ruin.RuinShapes)
+                {
+                    foreach (var wall in ruinShape.Walls)
+                    {
+                        availableSpawnPositions.Add(new SpawnPosition(
+                            new GraphEdge(wall.A, wall.B),
+                            (wall.A + wall.B) / 2.0f - ruinShape.Center,
+                            LevelObjectPrefab.SpawnPosType.RuinWall,
+                            ruinShape.GetLineAlignment(wall)));
+                    }
+                }            
+            }
+
+            foreach (var posOfInterest in level.PositionsOfInterest)
+            {
+                if (posOfInterest.PositionType != Level.PositionType.MainPath) continue;
+
+                availableSpawnPositions.Add(new SpawnPosition(
+                    new GraphEdge(posOfInterest.Position.ToVector2(), posOfInterest.Position.ToVector2() + Vector2.UnitX), 
+                    Vector2.UnitY, 
+                    LevelObjectPrefab.SpawnPosType.MainPath, 
+                    Alignment.Top));
+            }
+
+            objects = new List<LevelObject>();
+            for (int i = 0; i < amount; i++)
+            {
+                //get a random prefab and find a place to spawn it
+                LevelObjectPrefab prefab = GetRandomPrefab(level.GenerationParams.Name);
+                
+                SpawnPosition spawnPosition = FindObjectPosition(availableSpawnPositions, level, prefab);
+
+                if (spawnPosition == null && prefab.SpawnPos != LevelObjectPrefab.SpawnPosType.None) continue;
+
+                float rotation = 0.0f;
+                if (prefab.AlignWithSurface && spawnPosition != null)
+                {
+                    rotation = MathUtils.VectorToAngle(new Vector2(spawnPosition.Normal.Y, spawnPosition.Normal.X));
+                }
+                rotation += Rand.Range(prefab.RandomRotationRad.X, prefab.RandomRotationRad.Y, Rand.RandSync.Server);
+
+                Vector2 position = Vector2.Zero;
+                Vector2 edgeDir = Vector2.UnitX;
+                if (spawnPosition == null)
+                {
+                    position = new Vector2(
+                        Rand.Range(0.0f, level.Size.X, Rand.RandSync.Server),
+                        Rand.Range(0.0f, level.Size.Y, Rand.RandSync.Server));
+                }
+                else
+                {
+                    edgeDir = (spawnPosition.GraphEdge.Point1 - spawnPosition.GraphEdge.Point2) / spawnPosition.Length;
+                    position = spawnPosition.GraphEdge.Point2 + edgeDir * Rand.Range(prefab.MinSurfaceWidth / 2.0f, spawnPosition.Length - prefab.MinSurfaceWidth / 2.0f, Rand.RandSync.Server);
+                }
+
+                var newObject = new LevelObject(prefab,
+                    new Vector3(position, Rand.Range(prefab.DepthRange.X, prefab.DepthRange.Y, Rand.RandSync.Server)), Rand.Range(prefab.MinSize, prefab.MaxSize, Rand.RandSync.Server), rotation);
+                AddObject(newObject, level);
+
+                foreach (LevelObjectPrefab.ChildObject child in prefab.ChildObjects)
+                {
+                    int childCount = Rand.Range(child.MinCount, child.MaxCount, Rand.RandSync.Server);
+                    for (int j = 0; j < childCount; j++)
+                    {
+                        var matchingPrefabs = LevelObjectPrefab.List.Where(p => child.AllowedNames.Contains(p.Name));
+                        int prefabCount = matchingPrefabs.Count();
+                        var childPrefab = prefabCount == 0 ? null : matchingPrefabs.ElementAt(Rand.Range(0, prefabCount, Rand.RandSync.Server));
+                        if (childPrefab == null) continue;
+
+                        Vector2 childPos = position + edgeDir * Rand.Range(-0.5f, 0.5f, Rand.RandSync.Server) * prefab.MinSurfaceWidth;
+
+                        var childObject = new LevelObject(childPrefab,
+                            new Vector3(childPos, Rand.Range(childPrefab.DepthRange.X, childPrefab.DepthRange.Y, Rand.RandSync.Server)),
+                            Rand.Range(childPrefab.MinSize, childPrefab.MaxSize, Rand.RandSync.Server),
+                            rotation + Rand.Range(childPrefab.RandomRotationRad.X, childPrefab.RandomRotationRad.Y, Rand.RandSync.Server));
+
+                        AddObject(childObject, level);
+                    }
+                }
+
+            }
+                
+        }
+
+        private void AddObject(LevelObject newObject, Level level)
+        {
+            foreach (LevelTrigger trigger in newObject.Triggers)
+            {
+                trigger.OnTriggered += (levelTrigger, obj) =>
+                {
+                    OnObjectTriggered(newObject, levelTrigger, obj);
+                };
+            }
+            
+            var spriteCorners = new List<Vector2>
+            {
+                Vector2.Zero, Vector2.Zero, Vector2.Zero, Vector2.Zero
+            };
+
+            Sprite sprite = newObject.Sprite ?? newObject.Prefab.DeformableSprite?.Sprite;
+
+            //calculate the positions of the corners of the rotated sprite
+            if (sprite != null)
+            {
+                Vector2 halfSize = sprite.size * newObject.Scale / 2;
+                spriteCorners[0] = -halfSize;
+                spriteCorners[1] = new Vector2(-halfSize.X, halfSize.Y);
+                spriteCorners[2] = halfSize;
+                spriteCorners[3] = new Vector2(halfSize.X, -halfSize.Y);
+
+                Vector2 pivotOffset = sprite.Origin * newObject.Scale - halfSize;
+                pivotOffset.X = -pivotOffset.X;
+                pivotOffset = new Vector2(
+                    (float)(pivotOffset.X * Math.Cos(-newObject.Rotation) - pivotOffset.Y * Math.Sin(-newObject.Rotation)),
+                    (float)(pivotOffset.X * Math.Sin(-newObject.Rotation) + pivotOffset.Y * Math.Cos(-newObject.Rotation)));
+
+                for (int j = 0; j < 4; j++)
+                {
+                    spriteCorners[j] = new Vector2(
+                        (float)(spriteCorners[j].X * Math.Cos(-newObject.Rotation) - spriteCorners[j].Y * Math.Sin(-newObject.Rotation)),
+                        (float)(spriteCorners[j].X * Math.Sin(-newObject.Rotation) + spriteCorners[j].Y * Math.Cos(-newObject.Rotation)));
+
+                    spriteCorners[j] += new Vector2(newObject.Position.X, newObject.Position.Y) + pivotOffset;
+                }
+            }
+
+            float minX = spriteCorners.Min(c => c.X) - newObject.Position.Z;
+            float maxX = spriteCorners.Max(c => c.X) + newObject.Position.Z;
+
+            float minY = spriteCorners.Min(c => c.Y) - newObject.Position.Z - level.BottomPos;
+            float maxY = spriteCorners.Max(c => c.Y) + newObject.Position.Z - level.BottomPos;
+
+            foreach (LevelTrigger trigger in newObject.Triggers)
+            {
+                if (trigger.PhysicsBody == null) continue;
+                for (int i = 0; i < trigger.PhysicsBody.FarseerBody.FixtureList.Count; i++)
+                {
+                    trigger.PhysicsBody.FarseerBody.GetTransform(out FarseerPhysics.Common.Transform transform);
+                    trigger.PhysicsBody.FarseerBody.FixtureList[i].Shape.ComputeAABB(out FarseerPhysics.Collision.AABB aabb, ref transform, i);
+
+                    minX = Math.Min(minX, ConvertUnits.ToDisplayUnits(aabb.LowerBound.X));
+                    maxX = Math.Max(maxX, ConvertUnits.ToDisplayUnits(aabb.UpperBound.X));
+                    minY = Math.Min(minY, ConvertUnits.ToDisplayUnits(aabb.LowerBound.Y) - level.BottomPos);
+                    maxY = Math.Max(maxY, ConvertUnits.ToDisplayUnits(aabb.UpperBound.Y) - level.BottomPos);
+                }
+            }
+
+
+#if CLIENT
+            if (newObject.ParticleEmitters != null)
+            {
+                foreach (ParticleEmitter emitter in newObject.ParticleEmitters)
+                {
+                    Rectangle particleBounds = emitter.CalculateParticleBounds(new Vector2(newObject.Position.X, newObject.Position.Y));
+                    minX = Math.Min(minX, particleBounds.X);
+                    maxX = Math.Max(maxX, particleBounds.Right);
+                    minY = Math.Min(minY, particleBounds.Y - level.BottomPos);
+                    maxY = Math.Max(maxY, particleBounds.Bottom - level.BottomPos);
+                }
+            }
+#endif
+            objects.Add(newObject);
+            newObject.Position.Z += (minX + minY) % 100.0f * 0.00001f;
+
+            int xStart = (int)Math.Floor(minX / GridSize);
+            int xEnd = (int)Math.Floor(maxX / GridSize);
+            if (xEnd < 0 || xStart >= objectGrid.GetLength(0)) return;
+
+            int yStart = (int)Math.Floor(minY / GridSize);
+            int yEnd = (int)Math.Floor(maxY / GridSize);
+            if (yEnd < 0 || yStart >= objectGrid.GetLength(1)) return;
+
+            xStart = Math.Max(xStart, 0);
+            xEnd = Math.Min(xEnd, objectGrid.GetLength(0) - 1);
+            yStart = Math.Max(yStart, 0);
+            yEnd = Math.Min(yEnd, objectGrid.GetLength(1) - 1);
+
+            for (int x = xStart; x <= xEnd; x++)
+            {
+                for (int y = yStart; y <= yEnd; y++)
+                {
+                    if (objectGrid[x, y] == null) objectGrid[x, y] = new List<LevelObject>();
+                    objectGrid[x, y].Add(newObject);
+                }
+            }            
+        }
+
+        public Microsoft.Xna.Framework.Point GetGridIndices(Vector2 worldPosition)        
+        {
+            return new Microsoft.Xna.Framework.Point(
+                (int)Math.Floor(worldPosition.X / GridSize),
+                (int)Math.Floor((worldPosition.Y - Level.Loaded.BottomPos) / GridSize));
+        }
+
+        public IEnumerable<LevelObject> GetAllObjects()
+        {
+            return objects;
+        }
+
+        private readonly static List<LevelObject> objectsInRange = new List<LevelObject>();
+        public IEnumerable<LevelObject> GetAllObjects(Vector2 worldPosition, float radius)
+        {
+            var minIndices = GetGridIndices(worldPosition - Vector2.One * radius);
+            if (minIndices.X >= objectGrid.GetLength(0) || minIndices.Y >= objectGrid.GetLength(1)) return Enumerable.Empty<LevelObject>();
+
+            var maxIndices = GetGridIndices(worldPosition + Vector2.One * radius);
+            if (maxIndices.X < 0 || maxIndices.Y < 0) return Enumerable.Empty<LevelObject>();
+
+            minIndices.X = Math.Max(0, minIndices.X);
+            minIndices.Y = Math.Max(0, minIndices.Y);
+            maxIndices.X = Math.Min(objectGrid.GetLength(0) - 1, maxIndices.X);
+            maxIndices.Y = Math.Min(objectGrid.GetLength(1) - 1, maxIndices.Y);
+
+            objectsInRange.Clear();
+            for (int x = minIndices.X; x <= maxIndices.X; x++)
+            {
+                for (int y = minIndices.Y; y <= maxIndices.Y; y++)
+                {
+                    if (objectGrid[x, y] == null) continue;
+                    foreach (LevelObject obj in objectGrid[x, y])
+                    {
+                        if (!objectsInRange.Contains(obj)) objectsInRange.Add(obj);
+                    }
+                }
+            }
+
+            return objectsInRange;
+        }
+
+        private List<SpawnPosition> GetAvailableSpawnPositions(IEnumerable<VoronoiCell> cells, LevelObjectPrefab.SpawnPosType spawnPosType)
+        {
+            List<SpawnPosition> availableSpawnPositions = new List<SpawnPosition>();
+            foreach (var cell in cells)
+            {
+                foreach (var edge in cell.Edges)
+                {
+                    if (!edge.IsSolid || edge.OutsideLevel) continue;
+                    Vector2 normal = edge.GetNormal(cell);
+
+                    Alignment edgeAlignment = 0;
+                    if (normal.Y < -0.5f)
+                        edgeAlignment |= Alignment.Bottom;
+                    else if (normal.Y > 0.5f)
+                        edgeAlignment |= Alignment.Top;
+                    else if (normal.X < -0.5f)
+                        edgeAlignment |= Alignment.Left;
+                    else if(normal.X > 0.5f)
+                        edgeAlignment |= Alignment.Right;
+
+                    availableSpawnPositions.Add(new SpawnPosition(edge, normal, spawnPosType, edgeAlignment));
+                }
+            }
+            return availableSpawnPositions;
+        }
+
+        private SpawnPosition FindObjectPosition(List<SpawnPosition> availableSpawnPositions, Level level, LevelObjectPrefab prefab)
+        {
+            if (prefab.SpawnPos == LevelObjectPrefab.SpawnPosType.None) return null;
+
+            var suitableSpawnPositions = availableSpawnPositions.Where(sp => 
+                prefab.SpawnPos.HasFlag(sp.SpawnPosType) && sp.Length >= prefab.MinSurfaceWidth && prefab.Alignment.HasFlag(sp.Alignment)).ToList();
+
+            return ToolBox.SelectWeightedRandom(suitableSpawnPositions, suitableSpawnPositions.Select(sp => sp.GetSpawnProbability(prefab)).ToList(), Rand.RandSync.Server);
+        }
+        
+        public void Update(float deltaTime)
+        {
+            foreach (LevelObject obj in objects)
+            {
+                if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsServer)
+                {
+                    obj.NetworkUpdateTimer -= deltaTime;
+                    if (obj.NeedsNetworkSyncing && obj.NetworkUpdateTimer <= 0.0f)
+                    {
+                        GameMain.NetworkMember.CreateEntityEvent(this, new object[] { obj });
+                        obj.NeedsNetworkSyncing = false;
+                        obj.NetworkUpdateTimer = NetConfig.LevelObjectUpdateInterval;
+                    }
+                }
+
+                obj.ActivePrefab = obj.Prefab;
+                for (int i = 0; i < obj.Triggers.Count; i++)
+                {
+                    obj.Triggers[i].Update(deltaTime);
+                    if (obj.Triggers[i].IsTriggered && obj.Prefab.OverrideProperties[i] != null)
+                    {
+                        obj.ActivePrefab = obj.Prefab.OverrideProperties[i];
+                    }
+                }
+
+                if (obj.PhysicsBody != null)
+                {
+                    if (obj.Prefab.PhysicsBodyTriggerIndex > -1) obj.PhysicsBody.Enabled = obj.Triggers[obj.Prefab.PhysicsBodyTriggerIndex].IsTriggered;
+                    obj.Position = new Vector3(obj.PhysicsBody.Position, obj.Position.Z);
+                    obj.Rotation = obj.PhysicsBody.Rotation;
+                }
+            }
+
+            UpdateProjSpecific(deltaTime);            
+        }
+
+        partial void UpdateProjSpecific(float deltaTime);
+
+        private void OnObjectTriggered(LevelObject triggeredObject, LevelTrigger trigger, Entity triggerer)
+        {
+            if (trigger.TriggerOthersDistance <= 0.0f) return;
+            foreach (LevelObject obj in objects)
+            {
+                if (obj == triggeredObject) continue;
+                foreach (LevelTrigger otherTrigger in obj.Triggers)
+                {
+                    otherTrigger.OtherTriggered(triggeredObject, trigger);
+                }
+            }
+        }
+
+        private LevelObjectPrefab GetRandomPrefab(string levelType)
+        {
+            return ToolBox.SelectWeightedRandom(
+                LevelObjectPrefab.List, 
+                LevelObjectPrefab.List.Select(p => p.GetCommonness(levelType)).ToList(), Rand.RandSync.Server);
+        }
+
+        public override void Remove()
+        {
+            if (objects != null)
+            {
+                foreach (LevelObject obj in objects)
+                {
+                    obj.Remove();
+                }
+                objects.Clear();
+            }
+            RemoveProjSpecific();
+
+            base.Remove();
+        }
+
+        partial void RemoveProjSpecific();
+
+        public void ServerWrite(IWriteMessage msg, Client c, object[] extraData = null)
+        {
+            LevelObject obj = extraData[0] as LevelObject;
+            msg.WriteRangedInteger(objects.IndexOf(obj), 0, objects.Count);
+            obj.ServerWrite(msg, c);
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/LevelObjects/LevelObjectPrefab.cs

@@ -0,0 +1,397 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class LevelObjectPrefab : ISerializableEntity
+    {
+        private static List<LevelObjectPrefab> list = new List<LevelObjectPrefab>();
+        public static List<LevelObjectPrefab> List
+        {
+            get { return list; }
+        }
+
+        public class ChildObject
+        {
+            public List<string> AllowedNames;
+            public int MinCount, MaxCount;
+
+            public ChildObject()
+            {
+                AllowedNames = new List<string>();
+                MinCount = 1;
+                MaxCount = 1;
+            }
+
+            public ChildObject(XElement element)
+            {
+                AllowedNames = element.GetAttributeStringArray("names", new string[0]).ToList();
+                MinCount = element.GetAttributeInt("mincount", 1);
+                MaxCount = Math.Max(element.GetAttributeInt("maxcount", 1), MinCount);
+            }
+        }
+
+        [Flags]
+        public enum SpawnPosType
+        {
+            None = 0,
+            Wall = 1,
+            RuinWall = 2,
+            SeaFloor = 4,
+            MainPath = 8
+        }
+
+        public List<Sprite> Sprites
+        {
+            get;
+            private set;
+        } = new List<Sprite>();
+
+        public List<Sprite> SpecularSprites
+        {
+            get;
+            private set;
+        } = new List<Sprite>();
+
+        public DeformableSprite DeformableSprite
+        {
+            get;
+            private set;
+        }
+
+        [Serialize(1.0f, false), Editable(MinValueFloat = 0.01f, MaxValueFloat = 10.0f)]
+        public float MinSize
+        {
+            get;
+            private set;
+        }
+        [Serialize(1.0f, false), Editable(MinValueFloat = 0.01f, MaxValueFloat = 10.0f)]
+        public float MaxSize
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Which sides of a wall the object can appear on.
+        /// </summary>
+        [Serialize((Alignment.Top | Alignment.Bottom | Alignment.Left | Alignment.Right), true, description: "Which sides of a wall the object can spawn on."), Editable]
+        public Alignment Alignment
+        {
+            get;
+            private set;
+        }
+
+        [Serialize(SpawnPosType.Wall, false), Editable()]
+        public SpawnPosType SpawnPos
+        {
+            get;
+            private set;
+        }
+
+        public XElement Config
+        {
+            get;
+            private set;
+        }
+
+        public readonly List<XElement> LevelTriggerElements;
+        
+        /// <summary>
+        /// Overrides the commonness of the object in a specific level type. 
+        /// Key = name of the level type, value = commonness in that level type.
+        /// </summary>
+        public Dictionary<string, float> OverrideCommonness;
+
+        public XElement PhysicsBodyElement
+        {
+            get;
+            private set;
+        }
+        public int PhysicsBodyTriggerIndex
+        {
+            get;
+            private set;
+        }
+
+        [Serialize("0.0,1.0", true), Editable]
+        public Vector2 DepthRange
+        {
+            get;
+            private set;
+        }
+
+        [Editable(MinValueFloat = 0.0f, MaxValueFloat = 10.0f),
+        Serialize(0.0f, true, description: "The tendency for the prefab to form clusters. Used as an exponent for perlin noise values that are used to determine the probability for an object to spawn at a specific position.")]
+        /// <summary>
+        /// The tendency for the prefab to form clusters. Used as an exponent for perlin noise values 
+        /// that are used to determine the probability for an object to spawn at a specific position.
+        /// </summary>
+        public float ClusteringAmount
+        {
+            get;
+            private set;
+        }
+
+        [Editable(MinValueFloat = 0.0f, MaxValueFloat = 1.0f),
+            Serialize(0.0f, true, description: "A value between 0-1 that determines the z-coordinate to sample perlin noise from when determining the probability " +
+            " for an object to spawn at a specific position. Using the same (or close) value for different objects means the objects tend " +
+            "to form clusters in the same areas.")]
+        /// <summary>
+        /// A value between 0-1 that determines the z-coordinate to sample perlin noise from when
+        /// determining the probability  for an object to spawn at a specific position.
+        /// Using the same (or close) value for different objects means the objects tend to form clusters
+        /// in the same areas.
+        /// </summary>
+        public float ClusteringGroup
+        {
+            get;
+            private set;
+        }
+
+        [Editable, Serialize(false, true, description: "Should the object be rotated to align it with the wall surface it spawns on.")]
+        public bool AlignWithSurface
+        {
+            get;
+            private set;
+        }
+
+        [Serialize(0.0f, true, description: "Minimum length of a graph edge the object can spawn on."), Editable(MinValueFloat = 0.0f, MaxValueFloat = 1000.0f)]
+        /// <summary>
+        /// Minimum length of a graph edge the object can spawn on.
+        /// </summary>
+        public float MinSurfaceWidth
+        {
+            get;
+            private set;
+        }
+
+        private Vector2 randomRotation;
+        [Editable, Serialize("0.0,0.0", true, description: "How much the rotation of the object can vary (min and max values in degrees).")]
+        public Vector2 RandomRotation
+        {
+            get { return new Vector2(MathHelper.ToDegrees(randomRotation.X), MathHelper.ToDegrees(randomRotation.Y)); }
+            private set
+            {
+                randomRotation = new Vector2(MathHelper.ToRadians(value.X), MathHelper.ToRadians(value.Y));
+            }
+        }
+
+        public Vector2 RandomRotationRad => randomRotation;
+
+        private float swingAmount;
+        [Serialize(0.0f, true, description: "How much the object swings (in degrees)."), Editable(MinValueFloat = 0.0f, MaxValueFloat = 360.0f)]
+        public float SwingAmount
+        {
+            get { return MathHelper.ToDegrees(swingAmount); }
+            private set
+            {
+                swingAmount = MathHelper.ToRadians(value);
+            }
+        }
+
+        public float SwingAmountRad => swingAmount;
+
+        [Serialize(0.0f, true, description: "How fast the object swings."), Editable(MinValueFloat = 0.0f, MaxValueFloat = 10.0f)]
+        public float SwingFrequency
+        {
+            get;
+            private set;
+        }
+
+        [Editable, Serialize("0.0,0.0", true, description: "How much the scale of the object oscillates on each axis. A value of 0.5,0.5 would make the object's scale oscillate from 100% to 150%.")]
+        public Vector2 ScaleOscillation
+        {
+            get;
+            private set;
+        }
+
+        [Serialize(0.0f, true, description: "How fast the object's scale oscillates."), Editable(MinValueFloat = 0.0f, MaxValueFloat = 10.0f)]
+        public float ScaleOscillationFrequency
+        {
+            get;
+            private set;
+        }
+
+        [Editable, Serialize(1.0f, true, description: "How likely it is for the object to spawn in a level. " +
+            "This is relative to the commonness of the other objects - for example, having an object with " +
+            "a commonness of 1 and another with a commonness of 10 would mean the latter appears in levels 10 times as frequently as the former. " +
+            "The commonness value can be overridden on specific level types.")]
+        public float Commonness
+        {
+            get;
+            private set;
+        }
+
+        [Serialize(0.0f, true, description: "How much the object disrupts submarine's sonar."), Editable(MinValueFloat = 0.0f, MaxValueFloat = 10.0f)]
+        public float SonarDisruption
+        {
+            get;
+            private set;
+        }
+
+        public string Name
+        {
+            get;
+            set;
+        }
+
+        public List<ChildObject> ChildObjects
+        {
+            get;
+            private set;
+        }
+        
+        public Dictionary<string, SerializableProperty> SerializableProperties
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// A list of prefabs whose properties override this one's properties when a trigger is active.
+        /// E.g. if a trigger in the index 1 of the trigger list is active, the properties in index 1 in this list are used (unless it's null)
+        /// </summary>
+        public List<LevelObjectPrefab> OverrideProperties
+        {
+            get;
+            private set;
+        }
+
+        public override string ToString()
+        {
+            return "LevelObjectPrefab (" + Name + ")";
+        }
+
+        public static void LoadAll()
+        {
+            list.Clear();
+            var files = GameMain.Instance.GetFilesOfType(ContentType.LevelObjectPrefabs);
+            if (files.Count() > 0)
+            {
+                foreach (var file in files)
+                {
+                    LoadConfig(file.Path);
+                }
+            }
+            else
+            {
+                LoadConfig("Content/LevelObjects/LevelObject/Prefabs.xml");
+            }
+        }
+
+        private static void LoadConfig(string configPath)
+        {
+            try
+            {
+                XDocument doc = XMLExtensions.TryLoadXml(configPath);
+                if (doc == null) { return; }
+                var mainElement = doc.Root;
+                if (doc.Root.IsOverride())
+                {
+                    mainElement = doc.Root.FirstElement();
+                    DebugConsole.NewMessage($"Overriding all level object prefabs with '{configPath}'", Color.Yellow);
+                    list.Clear();
+                }
+                else if (list.Any())
+                {
+                    DebugConsole.NewMessage($"Loading additional level object prefabs from file '{configPath}'");
+                }
+                foreach (XElement element in mainElement.Elements())
+                {
+                    list.Add(new LevelObjectPrefab(element));
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError(String.Format("Failed to load LevelObject prefabs from {0}", configPath), e);
+            }
+        }
+        
+        public LevelObjectPrefab(XElement element)
+        {
+            ChildObjects = new List<ChildObject>();
+            LevelTriggerElements = new List<XElement>();
+            OverrideProperties = new List<LevelObjectPrefab>();
+            OverrideCommonness = new Dictionary<string, float>();
+
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+            if (element != null)
+            {
+                Config = element;
+                Name = element.Name.ToString();
+                LoadElements(element, -1);
+                InitProjSpecific(element);
+            }
+
+            //use the maximum width of the sprite as the minimum surface width if no value is given
+            if (element != null && !element.Attributes("minsurfacewidth").Any())
+            {
+                if (Sprites.Any()) MinSurfaceWidth = Sprites[0].size.X * MaxSize;
+                if (DeformableSprite != null) MinSurfaceWidth = Math.Max(MinSurfaceWidth, DeformableSprite.Size.X * MaxSize);
+            }
+        }
+
+        private void LoadElements(XElement element, int parentTriggerIndex)
+        {
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        Sprites.Add( new Sprite(subElement, lazyLoad: true));
+                        break;
+                    case "specularsprite":
+                        SpecularSprites.Add(new Sprite(subElement, lazyLoad: true));
+                        break;
+                    case "deformablesprite":
+                        DeformableSprite = new DeformableSprite(subElement, lazyLoad: true);
+                        break;
+                    case "overridecommonness":
+                        string levelType = subElement.GetAttributeString("leveltype", "");
+                        if (!OverrideCommonness.ContainsKey(levelType))
+                        {
+                            OverrideCommonness.Add(levelType, subElement.GetAttributeFloat("commonness", 1.0f));
+                        }
+                        break;
+                    case "leveltrigger":
+                    case "trigger":
+                        OverrideProperties.Add(null);
+                        LevelTriggerElements.Add(subElement);
+                        LoadElements(subElement, LevelTriggerElements.Count - 1);
+                        break;
+                    case "childobject":
+                        ChildObjects.Add(new ChildObject(subElement));
+                        break;
+                    case "overrideproperties":
+                        var propertyOverride = new LevelObjectPrefab(subElement);
+                        OverrideProperties[OverrideProperties.Count - 1] = propertyOverride;
+                        if (!propertyOverride.Sprites.Any() && propertyOverride.DeformableSprite == null)
+                        {
+                            propertyOverride.Sprites = Sprites;
+                            propertyOverride.DeformableSprite = DeformableSprite;
+                        }
+                        break;
+                    case "body":
+                    case "physicsbody":
+                        PhysicsBodyElement = subElement;
+                        PhysicsBodyTriggerIndex = parentTriggerIndex;
+                        break;
+                }
+            }
+        }
+        
+        partial void InitProjSpecific(XElement element);
+
+        public float GetCommonness(string levelType)
+        {
+            if (!OverrideCommonness.TryGetValue(levelType, out float commonness))
+            {
+                return Commonness;
+            }
+            return commonness;
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/LevelObjects/LevelTrigger.cs

@@ -0,0 +1,612 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using FarseerPhysics.Dynamics.Contacts;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class LevelTrigger
+    {
+        [Flags]
+        enum TriggererType
+        {
+            None = 0,
+            Human = 1,
+            Creature = 2,
+            Character = Human | Creature,
+            Submarine = 4,
+            Item = 8,
+            OtherTrigger = 16
+        }
+
+        public enum TriggerForceMode
+        {
+            Force, //default, apply a force to the object over time
+            Acceleration, //apply an acceleration to the object, ignoring it's mass
+            Impulse, //apply an instant force, ignoring deltaTime
+            LimitVelocity //clamp the velocity of the triggerer to some value
+        }
+
+        public Action<LevelTrigger, Entity> OnTriggered;
+
+        private PhysicsBody physicsBody;
+
+        /// <summary>
+        /// Effects applied to entities that are inside the trigger
+        /// </summary>
+        private List<StatusEffect> statusEffects = new List<StatusEffect>();
+
+        /// <summary>
+        /// Attacks applied to entities that are inside the trigger
+        /// </summary>
+        private List<Attack> attacks = new List<Attack>();
+
+        private float cameraShake;
+        private Vector2 unrotatedForce;
+        private float forceFluctuationTimer, currentForceFluctuation = 1.0f;
+
+        private HashSet<Entity> triggerers = new HashSet<Entity>();
+
+        private TriggererType triggeredBy;
+        
+        private float randomTriggerInterval;
+        private float randomTriggerProbability;
+        private float randomTriggerTimer;
+
+        private float triggeredTimer;
+
+        //how far away this trigger can activate other triggers from
+        private float triggerOthersDistance;
+
+        private HashSet<string> tags = new HashSet<string>();
+
+        //other triggers have to have at least one of these tags to trigger this one
+        private HashSet<string> allowedOtherTriggerTags = new HashSet<string>();
+
+        /// <summary>
+        /// How long the trigger stays in the triggered state after triggerers have left
+        /// </summary>
+        private float stayTriggeredDelay;
+
+        public LevelTrigger ParentTrigger;
+
+        public Dictionary<Entity, Vector2> TriggererPosition
+        {
+            get;
+            private set;
+        }
+
+        private Vector2 worldPosition;        
+        public Vector2 WorldPosition
+        {
+            get { return worldPosition; }
+            set
+            {
+                worldPosition = value;
+                physicsBody?.SetTransform(ConvertUnits.ToSimUnits(value), physicsBody.Rotation);
+            }
+        }
+
+        public float Rotation
+        {
+            get { return physicsBody == null ? 0.0f : physicsBody.Rotation; }
+            set
+            {
+                if (physicsBody == null) return;
+                physicsBody.SetTransform(physicsBody.Position, value);
+                CalculateDirectionalForce();
+            }
+        }
+
+        public PhysicsBody PhysicsBody
+        {
+            get { return physicsBody; }
+        }
+
+        public float TriggerOthersDistance
+        {
+            get { return triggerOthersDistance; }
+        }
+
+        public IEnumerable<Entity> Triggerers
+        {
+            get { return triggerers.AsEnumerable(); }
+        }
+
+        public bool IsTriggered
+        {
+            get
+            {
+                return (triggerers.Count > 0 || triggeredTimer > 0.0f) &&
+                    (ParentTrigger == null || ParentTrigger.IsTriggered);
+            }
+        }
+
+        public Vector2 Force
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// does the force diminish by distance
+        /// </summary>
+        public bool ForceFalloff
+        {
+            get;
+            private set;
+        }
+        
+        public float ForceFluctuationInterval
+        {
+            get;
+            private set;
+        }
+        public float ForceFluctuationStrength
+        {
+            get;
+            private set;
+        }
+
+        private TriggerForceMode forceMode;
+        public TriggerForceMode ForceMode
+        {
+            get { return forceMode; }
+        }
+
+        /// <summary>
+        /// Stop applying forces to objects if they're moving faster than this
+        /// </summary>
+        public float ForceVelocityLimit
+        {
+            get;
+            private set;
+        }
+
+        public float ColliderRadius
+        {
+            get;
+            private set;
+        }
+
+
+        public bool UseNetworkSyncing
+        {
+            get;
+            private set;
+        }
+
+        public bool NeedsNetworkSyncing
+        {
+            get;
+            set;
+        }
+                
+        public LevelTrigger(XElement element, Vector2 position, float rotation, float scale = 1.0f, string parentDebugName = "")
+        {
+            TriggererPosition = new Dictionary<Entity, Vector2>();
+
+            worldPosition = position;
+            if (element.Attributes("radius").Any() || element.Attributes("width").Any() || element.Attributes("height").Any())
+            {
+                physicsBody = new PhysicsBody(element, scale)
+                {
+                    CollisionCategories = Physics.CollisionLevel,
+                    CollidesWith = Physics.CollisionCharacter | Physics.CollisionItem | Physics.CollisionProjectile | Physics.CollisionWall
+                };
+                physicsBody.FarseerBody.OnCollision += PhysicsBody_OnCollision;
+                physicsBody.FarseerBody.OnSeparation += PhysicsBody_OnSeparation;
+                physicsBody.FarseerBody.SetIsSensor(true);
+                physicsBody.FarseerBody.BodyType = BodyType.Static;
+                physicsBody.FarseerBody.BodyType = BodyType.Kinematic;
+
+                ColliderRadius = ConvertUnits.ToDisplayUnits(Math.Max(Math.Max(PhysicsBody.radius, PhysicsBody.width / 2.0f), PhysicsBody.height / 2.0f));
+
+                physicsBody.SetTransform(ConvertUnits.ToSimUnits(position), rotation);
+            }
+
+            cameraShake = element.GetAttributeFloat("camerashake", 0.0f);
+
+            stayTriggeredDelay = element.GetAttributeFloat("staytriggereddelay", 0.0f);
+            randomTriggerInterval = element.GetAttributeFloat("randomtriggerinterval", 0.0f);
+            randomTriggerProbability = element.GetAttributeFloat("randomtriggerprobability", 0.0f);
+
+            UseNetworkSyncing = element.GetAttributeBool("networksyncing", false);
+
+            unrotatedForce = 
+                element.Attribute("force") != null && element.Attribute("force").Value.Contains(',') ?
+                element.GetAttributeVector2("force", Vector2.Zero) :
+                new Vector2(element.GetAttributeFloat("force", 0.0f), 0.0f);
+
+            ForceFluctuationInterval = element.GetAttributeFloat("forcefluctuationinterval", 0.01f);
+            ForceFluctuationStrength = Math.Max(element.GetAttributeFloat("forcefluctuationstrength", 0.0f), 0.0f);
+            ForceFalloff = element.GetAttributeBool("forcefalloff", true);
+
+            ForceVelocityLimit = ConvertUnits.ToSimUnits(element.GetAttributeFloat("forcevelocitylimit", float.MaxValue));
+            string forceModeStr = element.GetAttributeString("forcemode", "Force");
+            if (!Enum.TryParse(forceModeStr, out forceMode))
+            {
+                DebugConsole.ThrowError("Error in LevelTrigger config: \"" + forceModeStr + "\" is not a valid force mode.");
+            }
+            CalculateDirectionalForce();
+
+            string triggeredByStr = element.GetAttributeString("triggeredby", "Character");
+            if (!Enum.TryParse(triggeredByStr, out triggeredBy))
+            {
+                DebugConsole.ThrowError("Error in LevelTrigger config: \"" + triggeredByStr + "\" is not a valid triggerer type.");
+            }
+            UpdateCollisionCategories();
+            triggerOthersDistance = element.GetAttributeFloat("triggerothersdistance", 0.0f);
+
+            var tagsArray = element.GetAttributeStringArray("tags", new string[0]);
+            foreach (string tag in tagsArray)
+            {
+                tags.Add(tag.ToLower());
+            }
+
+            if (triggeredBy.HasFlag(TriggererType.OtherTrigger))
+            {
+                var otherTagsArray = element.GetAttributeStringArray("allowedothertriggertags", new string[0]);
+                foreach (string tag in otherTagsArray)
+                {
+                    allowedOtherTriggerTags.Add(tag.ToLower());
+                }
+            }
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "statuseffect":
+                        statusEffects.Add(StatusEffect.Load(subElement, string.IsNullOrEmpty(parentDebugName) ? "LevelTrigger" : "LevelTrigger in "+ parentDebugName));
+                        break;
+                    case "attack":
+                    case "damage":
+                        var attack = new Attack(subElement, string.IsNullOrEmpty(parentDebugName) ? "LevelTrigger" : "LevelTrigger in " + parentDebugName);
+                        var multipliedAfflictions = attack.GetMultipliedAfflictions((float)Timing.Step);
+                        attack.Afflictions.Clear();
+                        foreach (Affliction affliction in multipliedAfflictions)
+                        {
+                            attack.Afflictions.Add(affliction, null);
+                        }
+                        attacks.Add(attack);
+                        break;
+                }
+            }
+
+            forceFluctuationTimer = Rand.Range(0.0f, ForceFluctuationInterval);
+            randomTriggerTimer = Rand.Range(0.0f, randomTriggerInterval);
+        }
+
+        private void UpdateCollisionCategories()
+        {
+            if (physicsBody == null) return;
+
+            var collidesWith = Physics.CollisionNone;
+            if (triggeredBy.HasFlag(TriggererType.Character) || triggeredBy.HasFlag(TriggererType.Creature)) collidesWith |= Physics.CollisionCharacter;
+            if (triggeredBy.HasFlag(TriggererType.Item)) collidesWith |= Physics.CollisionItem | Physics.CollisionProjectile;
+            if (triggeredBy.HasFlag(TriggererType.Submarine)) collidesWith |= Physics.CollisionWall;
+
+            physicsBody.CollidesWith = collidesWith;
+        }
+
+        private void CalculateDirectionalForce()
+        {
+            var ca = (float)Math.Cos(-Rotation);
+            var sa = (float)Math.Sin(-Rotation);
+
+            Force = new Vector2(
+                ca * unrotatedForce.X + sa * unrotatedForce.Y,
+                -sa * unrotatedForce.X + ca * unrotatedForce.Y);      
+        }
+
+        private bool PhysicsBody_OnCollision(Fixture fixtureA, Fixture fixtureB, FarseerPhysics.Dynamics.Contacts.Contact contact)
+        {
+            Entity entity = GetEntity(fixtureB);
+            if (entity == null) return false;
+
+            if (entity is Character character)
+            {
+                if (character.CurrentHull != null) return false;
+                if (character.IsHuman)
+                {
+                    if (!triggeredBy.HasFlag(TriggererType.Human)) return false;
+                }
+                else
+                {
+                    if (!triggeredBy.HasFlag(TriggererType.Creature)) return false;
+                }
+            }
+            else if (entity is Item item)
+            {
+                if (item.CurrentHull != null) return false;
+                if (!triggeredBy.HasFlag(TriggererType.Item)) return false;
+            }
+            else if (entity is Submarine)
+            {
+                if (!triggeredBy.HasFlag(TriggererType.Submarine)) return false;
+            }
+
+            if (!triggerers.Contains(entity))
+            {
+                if (!IsTriggered)
+                {
+                    OnTriggered?.Invoke(this, entity);
+                }
+                TriggererPosition[entity] = entity.WorldPosition;
+                triggerers.Add(entity);
+            }
+            return true;
+        }
+
+        private void PhysicsBody_OnSeparation(Fixture fixtureA, Fixture fixtureB, Contact contact)
+        {
+            Entity entity = GetEntity(fixtureB);
+            if (entity == null) return;
+
+            if (entity is Character character && 
+                (!character.Enabled || character.Removed) &&
+                triggerers.Contains(entity))
+            {
+                TriggererPosition.Remove(entity);
+                triggerers.Remove(entity);
+                return;
+            }
+
+            //check if there are any other contacts with the entity
+            //(the OnSeparation callback happens when two fixtures separate, 
+            //e.g. if a body stops touching the circular fixture at the end of a capsule-shaped body)
+            ContactEdge contactEdge = fixtureA.Body.ContactList;
+            while (contactEdge != null)
+            {
+                if (contactEdge.Contact != null &&
+                    contactEdge.Contact.IsTouching)
+                {
+                    var otherEntity = GetEntity(contactEdge.Contact.FixtureB == fixtureB ? 
+                        contactEdge.Contact.FixtureB : 
+                        contactEdge.Contact.FixtureA);
+                    if (otherEntity == entity) return;
+                }
+                contactEdge = contactEdge.Next;
+            }
+
+            if (triggerers.Contains(entity))
+            {
+                TriggererPosition.Remove(entity);
+                triggerers.Remove(entity);
+            }
+        }
+
+        private Entity GetEntity(Fixture fixture)
+        {
+            if (fixture.Body == null || fixture.Body.UserData == null) return null;
+            if (fixture.Body.UserData is Entity entity) return entity;
+            if (fixture.Body.UserData is Limb limb) return limb.character;
+            if (fixture.Body.UserData is SubmarineBody subBody) return subBody.Submarine;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Another trigger was triggered, check if this one should react to it
+        /// </summary>
+        public void OtherTriggered(LevelObject levelObject, LevelTrigger otherTrigger)
+        {
+            if (!triggeredBy.HasFlag(TriggererType.OtherTrigger) || stayTriggeredDelay <= 0.0f) return;
+
+            //check if the other trigger has appropriate tags
+            if (allowedOtherTriggerTags.Count > 0)
+            {
+                if (!allowedOtherTriggerTags.Any(t => otherTrigger.tags.Contains(t))) return;
+            }
+
+            if (Vector2.DistanceSquared(WorldPosition, otherTrigger.WorldPosition) <= otherTrigger.triggerOthersDistance * otherTrigger.triggerOthersDistance)
+            {
+                bool wasAlreadyTriggered = IsTriggered;
+                triggeredTimer = stayTriggeredDelay;
+                if (!wasAlreadyTriggered)
+                {
+                    OnTriggered?.Invoke(this, null);
+                }
+            }
+        }
+
+        public void Update(float deltaTime)
+        {
+            if (ParentTrigger != null && !ParentTrigger.IsTriggered) return;
+
+            triggerers.RemoveWhere(t => t.Removed);
+
+            bool isNotClient = true;
+#if CLIENT
+            isNotClient = GameMain.Client == null;
+#endif
+
+            if (!UseNetworkSyncing || isNotClient)
+            {
+                if (ForceFluctuationStrength > 0.0f)
+                {
+                    //no need for force fluctuation (or network updates) if the trigger limits velocity and there are no triggerers
+                    if (forceMode != TriggerForceMode.LimitVelocity || triggerers.Any())
+                    {
+                        forceFluctuationTimer += deltaTime;
+                        if (forceFluctuationTimer > ForceFluctuationInterval)
+                        {
+                            NeedsNetworkSyncing = true;
+                            currentForceFluctuation = Rand.Range(1.0f - ForceFluctuationStrength, 1.0f);
+                            forceFluctuationTimer = 0.0f;
+                        }
+                    }
+                }
+
+                if (randomTriggerProbability > 0.0f)
+                {
+                    randomTriggerTimer += deltaTime;
+                    if (randomTriggerTimer > randomTriggerInterval)
+                    {
+                        if (Rand.Range(0.0f, 1.0f) < randomTriggerProbability)
+                        {
+                            NeedsNetworkSyncing = true;
+                            triggeredTimer = stayTriggeredDelay;
+                        }
+                        randomTriggerTimer = 0.0f;
+                    }
+                }
+            }
+            
+            if (stayTriggeredDelay > 0.0f)
+            {
+                if (triggerers.Count == 0)
+                {
+                    triggeredTimer -= deltaTime;
+                }
+                else
+                {
+                    triggeredTimer = stayTriggeredDelay;
+                }
+            }
+
+            foreach (Entity triggerer in triggerers)
+            {
+                foreach (StatusEffect effect in statusEffects)
+                {
+                    if (triggerer is Character)
+                    {
+                        effect.Apply(effect.type, deltaTime, triggerer, (Character)triggerer);
+                    }
+                    else if (triggerer is Item)
+                    {
+                        effect.Apply(effect.type, deltaTime, triggerer, ((Item)triggerer).AllPropertyObjects);
+                    }
+                }
+
+                if (triggerer is IDamageable damageable)
+                {
+                    foreach (Attack attack in attacks)
+                    {
+                        attack.DoDamage(null, damageable, WorldPosition, deltaTime, false);
+                    }
+                }
+                else if (triggerer is Submarine submarine)
+                {
+                    foreach (Attack attack in attacks)
+                    {
+                        float structureDamage = attack.GetStructureDamage(deltaTime);
+                        if (structureDamage > 0.0f)
+                        {
+                            Explosion.RangedStructureDamage(worldPosition, attack.DamageRange, structureDamage);
+                        }
+                    }
+                }
+
+                if (Force.LengthSquared() > 0.01f)
+                {
+                    if (triggerer is Character character)
+                    {
+                        ApplyForce(character.AnimController.Collider, deltaTime);
+                        foreach (Limb limb in character.AnimController.Limbs)
+                        {
+                            ApplyForce(limb.body, deltaTime);
+                        }
+                    }
+                    else if (triggerer is Submarine submarine)
+                    {
+                        ApplyForce(submarine.SubBody.Body, deltaTime);
+                    }
+                }
+
+                if (triggerer == Character.Controlled || triggerer == Character.Controlled?.Submarine)
+                {
+                    GameMain.GameScreen.Cam.Shake = Math.Max(GameMain.GameScreen.Cam.Shake, cameraShake);
+                }
+            }
+        }
+
+        private void ApplyForce(PhysicsBody body, float deltaTime)
+        {
+            float distFactor = 1.0f;
+            if (ForceFalloff)
+            {
+                distFactor = 1.0f - ConvertUnits.ToDisplayUnits(Vector2.Distance(body.SimPosition, PhysicsBody.SimPosition)) / ColliderRadius;
+                if (distFactor < 0.0f) return;
+            }
+
+            switch (ForceMode)
+            {
+                case TriggerForceMode.Force:
+                    if (ForceVelocityLimit < 1000.0f)
+                        body.ApplyForce(Force * currentForceFluctuation * distFactor, ForceVelocityLimit);
+                    else
+                        body.ApplyForce(Force * currentForceFluctuation * distFactor, maxVelocity: NetConfig.MaxPhysicsBodyVelocity);
+                    break;
+                case TriggerForceMode.Acceleration:
+                    if (ForceVelocityLimit < 1000.0f)
+                        body.ApplyForce(Force * body.Mass * currentForceFluctuation * distFactor, ForceVelocityLimit);
+                    else
+                        body.ApplyForce(Force * body.Mass * currentForceFluctuation * distFactor, maxVelocity: NetConfig.MaxPhysicsBodyVelocity);
+                    break;
+                case TriggerForceMode.Impulse:
+                    if (ForceVelocityLimit < 1000.0f)
+                        body.ApplyLinearImpulse(Force * currentForceFluctuation * distFactor, maxVelocity: ForceVelocityLimit);
+                    else
+                        body.ApplyLinearImpulse(Force * currentForceFluctuation * distFactor, maxVelocity: NetConfig.MaxPhysicsBodyVelocity);
+                    break;
+                case TriggerForceMode.LimitVelocity:
+                    float maxVel = ForceVelocityLimit * currentForceFluctuation * distFactor;
+                    if (body.LinearVelocity.LengthSquared() > maxVel * maxVel)
+                    {
+                        body.ApplyForce(
+                            Vector2.Normalize(-body.LinearVelocity) * 
+                            Force.Length() * body.Mass * currentForceFluctuation * distFactor, 
+                            maxVelocity: NetConfig.MaxPhysicsBodyVelocity);
+                    }
+                    break;
+            }
+        }
+
+        public Vector2 GetWaterFlowVelocity(Vector2 viewPosition)
+        {
+            Vector2 baseVel = GetWaterFlowVelocity();
+            if (baseVel.LengthSquared() < 0.1f) return Vector2.Zero;
+
+            float triggerSize = ConvertUnits.ToDisplayUnits(Math.Max(Math.Max(PhysicsBody.radius, PhysicsBody.width / 2.0f), PhysicsBody.height / 2.0f));
+            float dist = Vector2.Distance(viewPosition, WorldPosition);
+            if (dist > triggerSize) return Vector2.Zero;
+
+            return baseVel * (1.0f - dist / triggerSize);
+        }
+
+        public Vector2 GetWaterFlowVelocity()
+        {
+            if (Force == Vector2.Zero) return Vector2.Zero;
+            
+            Vector2 vel = Force;
+            if (ForceMode == TriggerForceMode.Acceleration)
+            {
+                vel *= 1000.0f;
+            }
+            else if (ForceMode == TriggerForceMode.Impulse)
+            {
+                vel /= (float)Timing.Step;
+            }
+            return vel.ClampLength(ConvertUnits.ToDisplayUnits(ForceVelocityLimit)) * currentForceFluctuation;            
+        }
+
+        public void ServerWrite(IWriteMessage msg, Client c)
+        {
+            if (ForceFluctuationStrength > 0.0f)
+            {
+                msg.WriteRangedSingle(MathHelper.Clamp(currentForceFluctuation, 0.0f, 1.0f), 0.0f, 1.0f, 8);
+            }
+            if (stayTriggeredDelay > 0.0f)
+            {
+                msg.WriteRangedSingle(MathHelper.Clamp(triggeredTimer, 0.0f, stayTriggeredDelay), 0.0f, stayTriggeredDelay, 16);
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/LevelWall.cs

@@ -0,0 +1,153 @@
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using Voronoi2;
+#if CLIENT
+using Microsoft.Xna.Framework.Graphics;
+#endif
+
+namespace Barotrauma
+{
+    partial class LevelWall : IDisposable
+    {        
+        private List<VoronoiCell> cells;                
+        public List<VoronoiCell> Cells
+        {
+            get { return cells; }
+        }
+
+        private Body body;
+        public Body Body
+        {
+            get { return body; }
+        }
+
+        private float moveState;
+        private float moveLength;
+
+        private Vector2 moveAmount;
+        public Vector2 MoveAmount
+        {
+            get { return moveAmount; }
+            set
+            {
+                moveAmount = value;
+                moveLength = moveAmount.Length();
+            }
+        }
+
+        public float MoveSpeed;
+
+        private Vector2? originalPos;
+
+        public float MoveState
+        {
+            get { return moveState; }
+            set { moveState = MathHelper.Clamp(value, 0.0f, MathHelper.TwoPi); }
+        }
+
+        public LevelWall(List<Vector2> vertices, Color color, Level level, bool giftWrap = false)
+        {
+            if (giftWrap)
+            {
+                vertices = MathUtils.GiftWrap(vertices);
+            }
+
+            VoronoiCell wallCell = new VoronoiCell(vertices.ToArray());
+            for (int i = 0; i < wallCell.Edges.Count; i++)
+            {
+                wallCell.Edges[i].Cell1 = wallCell;
+                wallCell.Edges[i].IsSolid = true;
+            }
+            cells = new List<VoronoiCell>() { wallCell };
+
+            body = CaveGenerator.GeneratePolygons(cells, level, out List<Vector2[]> triangles);
+#if CLIENT
+            List<VertexPositionTexture> bodyVertices = CaveGenerator.GenerateRenderVerticeList(triangles);
+            SetBodyVertices(bodyVertices.ToArray(), color);
+            SetWallVertices(CaveGenerator.GenerateWallShapes(cells, level), color);
+#endif
+        }
+
+        public LevelWall(List<Vector2> edgePositions, Vector2 extendAmount, Color color, Level level)
+        {
+            cells = new List<VoronoiCell>();
+            for (int i = 0; i < edgePositions.Count - 1; i++)
+            {
+                Vector2[] vertices = new Vector2[4];
+                vertices[0] = edgePositions[i];
+                vertices[1] = edgePositions[i + 1];
+                vertices[2] = vertices[0] + extendAmount;
+                vertices[3] = vertices[1] + extendAmount;
+
+                VoronoiCell wallCell = new VoronoiCell(vertices);
+                wallCell.CellType = CellType.Edge;
+                wallCell.Edges[0].Cell1 = wallCell;
+                wallCell.Edges[1].Cell1 = wallCell;
+                wallCell.Edges[2].Cell1 = wallCell;
+                wallCell.Edges[3].Cell1 = wallCell;
+                wallCell.Edges[0].IsSolid = true;
+
+                if (i > 1)
+                {
+                    wallCell.Edges[3].Cell2 = cells[i - 1];
+                    cells[i - 1].Edges[1].Cell2 = wallCell;
+                }
+
+                cells.Add(wallCell);
+            }
+            
+            body = CaveGenerator.GeneratePolygons(cells, level, out List<Vector2[]> triangles);
+            body.CollisionCategories = Physics.CollisionLevel;
+
+#if CLIENT
+            List<VertexPositionTexture> bodyVertices = CaveGenerator.GenerateRenderVerticeList(triangles);
+            SetBodyVertices(bodyVertices.ToArray(), color);
+            SetWallVertices(CaveGenerator.GenerateWallShapes(cells, level), color);
+#endif
+        }
+
+        public void Update(float deltaTime)
+        {
+            if (body.BodyType == BodyType.Static) return;
+
+            Vector2 bodyPos = ConvertUnits.ToDisplayUnits(body.Position);
+            Cells.ForEach(c => c.Translation = bodyPos);
+
+            if (!originalPos.HasValue) originalPos = bodyPos;
+
+            if (moveLength > 0.0f && MoveSpeed > 0.0f)
+            {
+                moveState += MoveSpeed / moveLength * deltaTime;
+                moveState %= MathHelper.TwoPi;
+
+                Vector2 targetPos = ConvertUnits.ToSimUnits(originalPos.Value + moveAmount * (float)Math.Sin(moveState));            
+                body.ApplyForce((targetPos - body.Position).ClampLength(1.0f) * body.Mass);
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+#if CLIENT
+            if (wallVertices != null)
+            {
+                wallVertices.Dispose();
+                wallVertices = null;
+            }
+            if (bodyVertices != null)
+            {
+                BodyVertices.Dispose();
+                bodyVertices = null;
+            }
+#endif
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/Ruins/BTRoom.cs

@@ -0,0 +1,190 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Barotrauma.RuinGeneration
+{
+    /// <summary>
+    /// nodes of a binary tree used for generating underwater "dungeons"
+    /// </summary>
+    class BTRoom : RuinShape
+    {
+        private BTRoom[] subRooms;
+
+        public BTRoom Parent
+        {
+            get;
+            private set;
+        }
+
+        public Corridor Corridor
+        {
+            get;
+            set;
+        }
+
+        public BTRoom[] SubRooms
+        {
+            get { return subRooms; }
+        }
+
+        public BTRoom Adjacent
+        {
+            get;
+            private set;
+        }
+
+        public BTRoom(Rectangle rect)
+        {
+            this.rect = rect;
+        }
+
+        public void Split(float minDivRatio, float verticalProbability = 0.5f, int minWidth = 200, int minHeight = 200)
+        {
+            bool verticalSplit = Rand.Range(0.0f, rect.Height / (float)rect.Width, Rand.RandSync.Server) < verticalProbability;
+            if (rect.Width * minDivRatio < minWidth && rect.Height * minDivRatio < minHeight)
+            {
+                minDivRatio = 0.5f;
+            }
+            else if (rect.Width * minDivRatio < minWidth)
+            {
+                verticalSplit = false;
+            }
+            else if (rect.Height * minDivRatio < minHeight)
+            {
+                verticalSplit = true;
+            }
+
+            subRooms = new BTRoom[2];
+            if (verticalSplit)
+            {
+                SplitVertical(minDivRatio);
+            }
+            else
+            {
+                SplitHorizontal(minDivRatio);
+            }
+
+            subRooms[0].Parent = this;
+            subRooms[1].Parent = this;
+
+            subRooms[0].Adjacent = subRooms[1];
+            subRooms[1].Adjacent = subRooms[0];
+        }
+
+        private void SplitHorizontal(float minDivRatio)
+        {
+            float div = Rand.Range(minDivRatio, 1.0f - minDivRatio, Rand.RandSync.Server);
+            subRooms[0] = new BTRoom(new Rectangle(rect.X, rect.Y, rect.Width, (int)(rect.Height * div)));
+            subRooms[1] = new BTRoom(new Rectangle(rect.X, rect.Y + subRooms[0].rect.Height, rect.Width, rect.Height - subRooms[0].rect.Height));
+
+        }
+
+        private void SplitVertical(float minDivRatio)
+        {
+            float div = Rand.Range(minDivRatio, 1.0f - minDivRatio, Rand.RandSync.Server);
+            subRooms[0] = new BTRoom(new Rectangle(rect.X, rect.Y, (int)(rect.Width * div), rect.Height));
+            subRooms[1] = new BTRoom(new Rectangle(rect.X + subRooms[0].rect.Width, rect.Y, rect.Width - subRooms[0].rect.Width, rect.Height));
+        }
+
+        public override void CreateWalls()
+        {
+            Walls = new List<Line>
+            {
+                new Line(new Vector2(Rect.X, Rect.Y), new Vector2(Rect.Right, Rect.Y)),
+                new Line(new Vector2(Rect.X, Rect.Bottom), new Vector2(Rect.Right, Rect.Bottom)),
+                new Line(new Vector2(Rect.X, Rect.Y), new Vector2(Rect.X, Rect.Bottom)),
+                new Line(new Vector2(Rect.Right, Rect.Y), new Vector2(Rect.Right, Rect.Bottom))
+            };
+        }
+
+        public void Scale(Vector2 scale)
+        {
+            rect.Inflate((scale.X - 1.0f) * 0.5f * rect.Width, (scale.Y - 1.0f) * 0.5f * rect.Height);
+        }
+
+        public List<BTRoom> GetLeaves()
+        {
+            return GetLeaves(new List<BTRoom>());
+        }
+
+        private List<BTRoom> GetLeaves(List<BTRoom> leaves)
+        {
+            if (subRooms == null)
+            {
+                leaves.Add(this);
+            }
+            else
+            {
+                subRooms[0].GetLeaves(leaves);
+                subRooms[1].GetLeaves(leaves);
+            }
+
+            return leaves;
+        }
+
+        public void GenerateCorridors(int minWidth, int maxWidth, List<Corridor> corridors)
+        {
+            if (Adjacent != null && Corridor == null)
+            {
+                Corridor = new Corridor(this, Rand.Range(minWidth, maxWidth, Rand.RandSync.Server), corridors);
+            }
+
+            if (subRooms != null)
+            {
+                subRooms[0].GenerateCorridors(minWidth, maxWidth, corridors);
+                subRooms[1].GenerateCorridors(minWidth, maxWidth, corridors);
+            }
+        }
+
+        public static void CalculateDistancesFromEntrance(BTRoom entrance, List<BTRoom> rooms, List<Corridor> corridors)
+        {
+            entrance.CalculateDistanceFromEntrance(0, rooms, new List<Corridor>(corridors));
+        }
+
+        private void CalculateDistanceFromEntrance(int currentDist, List<BTRoom> rooms, List<Corridor> corridors)
+        {
+            DistanceFromEntrance = DistanceFromEntrance == 0 ? currentDist : Math.Min(currentDist, DistanceFromEntrance);
+
+            currentDist++;
+
+            var roomRect = Rect;
+            roomRect.Inflate(5, 5);
+            foreach (var corridor in corridors)
+            {
+                var corridorRect = corridor.Rect;
+                corridorRect.Inflate(5, 5);
+                if (!corridorRect.Intersects(roomRect)) continue;
+
+                corridor.DistanceFromEntrance = corridor.DistanceFromEntrance == 0 ?
+                    DistanceFromEntrance + 1 :
+                    Math.Min(corridor.DistanceFromEntrance, DistanceFromEntrance + 1);
+
+                
+                List<BTRoom> connectedRooms = new List<BTRoom>();
+                foreach (var otherRoom in rooms)
+                {
+                    if (otherRoom == this) continue;
+                    if (otherRoom.DistanceFromEntrance > 0 && otherRoom.DistanceFromEntrance < currentDist) continue;
+
+                    var otherRoomRect = otherRoom.Rect;
+                    otherRoomRect.Inflate(5, 5);
+                    if (corridorRect.Intersects(otherRoomRect)) { connectedRooms.Add(otherRoom); }
+                }
+
+                connectedRooms.Sort((r1, r2) =>
+                {
+                    return
+                        (Math.Abs(r1.Rect.Center.X - Rect.Center.X) + Math.Abs(r1.Rect.Center.Y - Rect.Center.Y)) -
+                        (Math.Abs(r2.Rect.Center.X - Rect.Center.X) + Math.Abs(r2.Rect.Center.Y - Rect.Center.Y));
+                });
+
+                for (int i = 0; i < connectedRooms.Count; i++)
+                {
+                    connectedRooms[i].CalculateDistanceFromEntrance(currentDist + 1 + i, rooms, corridors);
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/Ruins/Corridor.cs

@@ -0,0 +1,210 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Barotrauma.RuinGeneration
+{
+
+    class Corridor : RuinShape
+    {
+        private readonly bool isHorizontal;
+        
+        public bool IsHorizontal
+        {
+            get { return isHorizontal; }
+        }
+
+        public BTRoom[] ConnectedRooms
+        {
+            get;
+            private set;
+        }
+            
+        public Corridor(Rectangle rect)
+        {
+            this.rect = rect;
+
+            isHorizontal = rect.Width > rect.Height;
+        }
+
+        public Corridor(BTRoom room, int width, List<Corridor> corridors)
+        {
+            System.Diagnostics.Debug.Assert(room.Adjacent != null);
+
+            ConnectedRooms = new BTRoom[2];
+            ConnectedRooms[0] = room;
+            ConnectedRooms[1] = room.Adjacent;
+
+            Rectangle room1, room2;
+
+            room1 = room.Rect;
+            room2 = room.Adjacent.Rect;
+
+            isHorizontal = (room1.Right <= room2.X || room2.Right <= room1.X);
+
+            //use the leaves as starting points for the corridor
+            if (room.SubRooms != null)
+            {
+                var leaves1 = room.GetLeaves();
+                var leaves2 = room.Adjacent.GetLeaves();
+
+                var suitableLeaves = GetSuitableLeafRooms(leaves1, leaves2, width, isHorizontal);
+                if (suitableLeaves == null || suitableLeaves.Length < 2)
+                {
+                    // No suitable leaves found due to intersections
+                    //DebugConsole.ThrowError("Error while generating ruins. Could not find a suitable position for a corridor. The width of the corridors may be too large compared to the sizes of the rooms.");
+                    return;
+                }
+                else
+                {
+                    ConnectedRooms[0] = suitableLeaves[0];
+                    ConnectedRooms[1] = suitableLeaves[1];
+                }
+            }
+            else
+            {
+                rect = CalculateRectangle(room1, room2, width, isHorizontal);
+                if (rect.Width <= 0 || rect.Height <= 0)
+                {
+                    DebugConsole.ThrowError("Error while generating ruins. Attempted to create a corridor with a width or height of <= 0");
+                    return;
+                }
+            }
+
+            room.Corridor = this;
+            room.Adjacent.Corridor = this;
+
+            for (int i = corridors.Count - 1; i >= 0; i--)
+            {
+                var corridor = corridors[i];
+
+                if (corridor.rect.Intersects(this.rect))
+                {
+                    if (isHorizontal && corridor.isHorizontal)
+                    {
+                        if (this.rect.Width < corridor.rect.Width)
+                            return;
+                        else
+                            corridors.RemoveAt(i);
+                    }
+                    else if (!isHorizontal && !corridor.isHorizontal)
+                    {
+                        if (this.rect.Height < corridor.rect.Height)
+                            return;
+                        else
+                            corridors.RemoveAt(i);
+                    }
+                }
+            }
+
+            corridors.Add(this);
+        }
+
+        public override void CreateWalls()
+        {
+            Walls = new List<Line>();
+            if (IsHorizontal)
+            {
+                Walls.Add(new Line(new Vector2(Rect.X, Rect.Y), new Vector2(Rect.Right, Rect.Y)));
+                Walls.Add(new Line(new Vector2(Rect.X, Rect.Bottom), new Vector2(Rect.Right, Rect.Bottom)));
+            }
+            else
+            {
+                Walls.Add(new Line(new Vector2(Rect.X, Rect.Y), new Vector2(Rect.X, Rect.Bottom)));
+                Walls.Add(new Line(new Vector2(Rect.Right, Rect.Y), new Vector2(Rect.Right, Rect.Bottom)));
+            }
+        }
+
+        /// <summary>
+        /// Find two rooms which have two face-two-face walls that we can place a corridor in between
+        /// </summary>
+        /// <returns></returns>
+        private BTRoom[] GetSuitableLeafRooms(List<BTRoom> leaves1, List<BTRoom> leaves2, int width, bool isHorizontal)
+        {
+            int iOffset = Rand.Int(leaves1.Count, Rand.RandSync.Server);
+            int jOffset = Rand.Int(leaves2.Count, Rand.RandSync.Server);
+
+            for (int iCount = 0; iCount < leaves1.Count; iCount++)
+            {
+                int i = (iCount + iOffset) % leaves1.Count;
+
+                for (int jCount = 0; jCount < leaves2.Count; jCount++)
+                {
+                    int j = (jCount + jOffset) % leaves2.Count;
+
+                    if (isHorizontal)
+                    {
+                        if (leaves1[i].Rect.Y > leaves2[j].Rect.Bottom - width) continue;
+                        if (leaves1[i].Rect.Bottom < leaves2[j].Rect.Y + width) continue;
+                    }
+                    else
+                    {
+                        if (leaves1[i].Rect.X > leaves2[j].Rect.Right - width) continue;
+                        if (leaves1[i].Rect.Right < leaves2[j].Rect.X + width) continue;
+                    }
+
+                    // Check if the given corridor rect would intersect over a third room
+                    if (CheckForIntersection(leaves1[i], leaves2[j], leaves1, leaves2, width, isHorizontal)) continue;
+
+                    return new BTRoom[] { leaves1[i], leaves2[j] };
+                }
+            }
+
+            return null;
+        }
+
+        private bool CheckForIntersection(BTRoom potential1, BTRoom potential2, List<BTRoom> leaves1, List<BTRoom> leaves2, int width, bool isHorizontal)
+        {
+            Rectangle potentialCorridorRectangle = CalculateRectangle(potential1.Rect, potential2.Rect, width, isHorizontal);
+
+            if (potentialCorridorRectangle.Width <= 0 || potentialCorridorRectangle.Height <= 0) return true; // Invalid rectangle
+
+            for (int i = 0; i < leaves1.Count; i++)
+            {
+                if (leaves1[i] == potential1) continue;
+                if (potentialCorridorRectangle.Intersects(leaves1[i].Rect)) return true;
+            }
+
+            for (int i = 0; i < leaves2.Count; i++)
+            {
+                if (leaves2[i] == potential2) continue;
+                if (potentialCorridorRectangle.Intersects(leaves2[i].Rect)) return true;
+            }
+
+            rect = potentialCorridorRectangle; // Save the rectangle that passes the test
+            return false;
+        }
+
+        private Rectangle CalculateRectangle(Rectangle rect1, Rectangle rect2, int width, bool isHorizontal)
+        {
+            if (isHorizontal)
+            {
+                int left = Math.Min(rect1.Right, rect2.Right);
+                int right = Math.Max(rect1.X, rect2.X);
+
+                int top = Math.Max(rect1.Y, rect2.Y);
+                //int bottom = Math.Min(room1.Bottom, room2.Bottom);
+                int yPos = top;//Rand.Range(top, bottom - width, Rand.RandSync.Server);
+
+                return new Rectangle(left, yPos, right - left, width);
+            }
+            else if (rect1.Y > rect2.Bottom || rect2.Y > rect1.Bottom)
+            {
+                int left = Math.Max(rect1.X, rect2.X);
+                int right = Math.Min(rect1.Right, rect2.Right);
+
+                int top = Math.Min(rect1.Bottom, rect2.Bottom);
+                int bottom = Math.Max(rect1.Y, rect2.Y);
+
+                int xPos = Rand.Range(left, right - width, Rand.RandSync.Server);
+
+                return new Rectangle(xPos, top, width, bottom - top);
+            }
+            else
+            {
+                DebugConsole.ThrowError("wat");
+                return new Rectangle();
+            }
+        }
+    }
+}

Barotrauma/BarotraumaShared/SharedSource/Map/Levels/Ruins/RuinGenerationParams.cs

@@ -0,0 +1,497 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace Barotrauma.RuinGeneration
+{
+    [Flags]
+    enum RuinEntityType
+    {
+        Wall, Back, Door, Hatch, Prop
+    }
+
+    class RuinGenerationParams : ISerializableEntity
+    {
+        public static List<RuinGenerationParams> List
+        {
+            get
+            {
+                if (paramsList == null)
+                {
+                    LoadAll();
+                }
+                return paramsList;
+            }
+        }
+
+        private static List<RuinGenerationParams> paramsList;
+
+        private string filePath;
+
+        private List<RuinRoom> roomTypeList;
+                
+        public string Name => "RuinGenerationParams";
+        
+        [Serialize("5000,5000", false), Editable]
+        public Point SizeMin
+        {
+            get;
+            set;
+        }
+        [Serialize("8000,8000", false), Editable]
+        public Point SizeMax
+        {
+            get;
+            set;
+        }
+
+        [Serialize(3, false, description: "The ruin generation algorithm \"splits\" the ruin area into two, splits these areas again, repeats this for some number of times and creates a room at each of the final split areas. This is value determines the minimum number of times the split is done."), Editable(MinValueInt = 1, MaxValueInt = 10)]
+        public int RoomDivisionIterationsMin
+        {
+            get;
+            set;
+        }
+
+        [Serialize(4, false, description: "The ruin generation algorithm \"splits\" the ruin area into two, splits these areas again, repeats this for some number of times and creates a room at each of the final split areas. This is value determines the maximum number of times the split is done."), Editable(MinValueInt = 1, MaxValueInt = 10)]
+        public int RoomDivisionIterationsMax
+        {
+            get;
+            set;
+        }
+
+        [Serialize(0.5f, false, description: "The probability for the split algorithm to split the area vertically. High values tend to create tall, vertical rooms, and low values wide, horizontal rooms."), Editable(MinValueFloat = 0.1f, MaxValueFloat = 0.9f)]
+        public float VerticalSplitProbability
+        {
+            get;
+            set;
+        }
+
+        [Serialize(400, false, description: "The splitting algorithm attempts to keep the width of the split areas larger than this. If the width of the split areas would be smaller than this after a vertical split, the algorithm would do a horizontal split."), Editable]
+        public int MinSplitWidth
+        {
+            get;
+            set;
+        }
+        [Serialize(400, false, description: "The splitting algorithm attempts to keep the height of the split areas larger than this. If the height of the split areas would be smaller than this after a vertical split, the algorithm would do a horizontal split."), Editable]
+        public int MinSplitHeight
+        {
+            get;
+            set;
+        }
+
+        [Serialize("0.5,0.9", false, description: "The minimum and maximum width of a room relative to the areas created by the split algorithm."), Editable]
+        public Vector2 RoomWidthRange
+        {
+            get;
+            set;
+        }
+        [Serialize("0.5,0.9", false, description: "The minimum and maximum height of a room relative to the areas created by the split algorithm."), Editable]
+        public Vector2 RoomHeightRange
+        {
+            get;
+            set;
+        }
+
+        [Serialize("200,256", false, description: "The minimum and maximum width of the corridors between rooms."), Editable]
+        public Point CorridorWidthRange
+        {
+            get;
+            set;
+        }
+
+        public Dictionary<string, SerializableProperty> SerializableProperties
+        {
+            get;
+            private set;
+        } = new Dictionary<string, SerializableProperty>();
+
+        public IEnumerable<RuinRoom> RoomTypeList
+        {
+            get { return roomTypeList; }
+        }
+
+        private RuinGenerationParams(XElement element)
+        {
+            roomTypeList = new List<RuinRoom>();
+
+            if (element != null)
+            {                
+                foreach (XElement subElement in element.Elements())
+                {
+                    roomTypeList.Add(new RuinRoom(subElement));
+                }
+            }
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+        }
+
+        public static RuinGenerationParams GetRandom()
+        {
+            if (paramsList == null) { LoadAll(); }
+
+            if (paramsList.Count == 0)
+            {
+                DebugConsole.ThrowError("No ruin configuration files found in any content package.");
+                return new RuinGenerationParams(null);
+            }
+
+            return paramsList[Rand.Int(paramsList.Count, Rand.RandSync.Server)];
+        }
+
+        private static void LoadAll()
+        {
+            paramsList = new List<RuinGenerationParams>();
+            foreach (ContentFile configFile in GameMain.Instance.GetFilesOfType(ContentType.RuinConfig))
+            {
+                XDocument doc = XMLExtensions.TryLoadXml(configFile.Path);
+                if (doc == null) { continue; }
+                var mainElement = doc.Root;
+                if (doc.Root.IsOverride())
+                {
+                    mainElement = doc.Root.FirstElement();
+                    paramsList.Clear();
+                    DebugConsole.NewMessage($"Overriding all ruin configuration parameters using the file {configFile.Path}.", Color.Yellow);
+                }
+                else if (paramsList.Any())
+                {
+                    DebugConsole.NewMessage($"Adding additional ruin configuration parameters from file '{configFile.Path}'");
+                }
+                var newParams = new RuinGenerationParams(mainElement)
+                {
+                    filePath = configFile.Path
+                };
+                paramsList.Add(newParams);
+            }
+        }
+
+        public static void ClearAll()
+        {
+            paramsList?.Clear();
+            paramsList = null;
+        }
+
+        public static void SaveAll()
+        {
+            XmlWriterSettings settings = new XmlWriterSettings
+            {
+                Indent = true,
+                NewLineOnAttributes = true
+            };
+
+            foreach (RuinGenerationParams generationParams in List)
+            {
+                foreach (ContentFile configFile in GameMain.Instance.GetFilesOfType(ContentType.RuinConfig))
+                {
+                    if (configFile.Path != generationParams.filePath) continue;
+
+                    XDocument doc = XMLExtensions.TryLoadXml(configFile.Path);
+                    if (doc == null) { continue; }
+
+                    SerializableProperty.SerializeProperties(generationParams, doc.Root);
+
+                    using (var writer = XmlWriter.Create(configFile.Path, settings))
+                    {
+                        doc.WriteTo(writer);
+                        writer.Flush();
+                    }
+                }
+            }
+        }
+    }
+
+    class RuinRoom : ISerializableEntity
+    {
+        public enum RoomPlacement
+        {
+            Any,
+            First,
+            Last
+        }
+
+        public string Name
+        {
+            get;
+            private set;
+        }
+
+        [Serialize(1.0f, false), Editable(MinValueFloat = 0.0f, MaxValueFloat = 10.0f)]
+        public float Commonness { get; private set; }
+
+        public Dictionary<string, SerializableProperty> SerializableProperties
+        {
+            get;
+            private set;
+        } = new Dictionary<string, SerializableProperty>();
+        
+        [Serialize(RoomPlacement.Any, false), Editable]
+        public RoomPlacement Placement
+        {
+            get;
+            set;
+        }
+
+        [Serialize(0, false), Editable]
+        public int PlacementOffset
+        {
+            get;
+            set;
+        }
+
+        [Serialize(false, false), Editable]
+        public bool IsCorridor
+        {
+            get;
+            set;
+        }
+        
+        [Serialize(1.0f, false), Editable]
+        public float MinWaterAmount
+        {
+            get;
+            set;
+        }
+        [Serialize(1.0f, false), Editable]
+        public float MaxWaterAmount
+        {
+            get;
+            set;
+        }
+
+        private List<RuinEntityConfig> entityList = new List<RuinEntityConfig>();
+
+        public RuinRoom(XElement element)
+        {
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+
+            Name = element.GetAttributeString("name", "");
+
+            if (element != null)
+            {
+                int groupIndex = 0;
+                LoadEntities(element, ref groupIndex);
+            }
+
+            void LoadEntities(XElement element2, ref int groupIndex)
+            {
+                foreach (XElement subElement in element2.Elements())
+                {
+                    if (subElement.Name.ToString().ToLowerInvariant() == "chooseone")
+                    {
+                        groupIndex++;
+                        LoadEntities(subElement, ref groupIndex);
+                    }
+                    else
+                    {
+                        entityList.Add(new RuinEntityConfig(subElement) { SingleGroupIndex = groupIndex });
+                    }
+                }
+            }
+        }
+
+        public RuinEntityConfig GetRandomEntity(RuinEntityType type, Alignment alignment)
+        {
+            var matchingEntities = entityList.FindAll(rs =>
+                rs.Type == type &&
+                rs.Alignment.HasFlag(alignment));
+
+            if (!matchingEntities.Any()) return null;
+
+            return ToolBox.SelectWeightedRandom(
+                matchingEntities,
+                matchingEntities.Select(s => s.Commonness).ToList(),
+                Rand.RandSync.Server);
+        }
+
+        public List<RuinEntityConfig> GetPropList(RuinShape room, Rand.RandSync randSync)
+        {
+            Dictionary<int, List<RuinEntityConfig>> propGroups = new Dictionary<int, List<RuinEntityConfig>>();
+            foreach (RuinEntityConfig entityConfig in entityList)
+            {
+                if (entityConfig.Type != RuinEntityType.Prop) { continue; }
+                if (room.Rect.Width < entityConfig.MinRoomSize.X || room.Rect.Height < entityConfig.MinRoomSize.Y) { continue; }
+                if (room.Rect.Width > entityConfig.MaxRoomSize.X || room.Rect.Height > entityConfig.MaxRoomSize.Y) { continue; }
+                if (!propGroups.ContainsKey(entityConfig.SingleGroupIndex))
+                {
+                    propGroups[entityConfig.SingleGroupIndex] = new List<RuinEntityConfig>();
+                }
+                propGroups[entityConfig.SingleGroupIndex].Add(entityConfig);
+            }
+
+            List<RuinEntityConfig> props = new List<RuinEntityConfig>();
+            foreach (KeyValuePair<int, List<RuinEntityConfig>> propGroup in propGroups)
+            {
+                if (propGroup.Key == 0)
+                {
+                    props.AddRange(propGroup.Value);
+                }
+                else
+                {
+                    props.Add(propGroup.Value[Rand.Int(propGroup.Value.Count, randSync)]);
+                }
+            }
+            return props;
+        }
+    }
+
+    class RuinEntityConfig : ISerializableEntity
+    {
+        public readonly MapEntityPrefab Prefab;
+
+        public enum RelativePlacement
+        {
+            SameRoom,
+            NextRoom,
+            NextCorridor,
+            PreviousRoom,
+            PreviousCorridor,
+            FirstRoom,
+            FirstCorridor,
+            LastRoom,
+            LastCorridor
+        }
+
+        public class EntityConnection
+        {
+            //which type of room to search for the item to connect to
+            //sameroom, nextroom, previousroom, firstroom and lastroom are also valid
+            public string RoomName
+            {
+                get;
+                private set;
+            }
+
+            public string TargetEntityIdentifier
+            {
+                get;
+                private set;
+            }
+
+            //Identifier of the item to run the wire from. Only needed in item assemblies to determine which item in the assembly to use.
+            public string SourceEntityIdentifier
+            {
+                get;
+                private set;
+            }
+
+            //if set, the connection is done by running a wire from 
+            //(Pair.First = the name of the connection in this item) to (Pair.Second = the name of the connection in the target item)
+            public Pair<string, string> WireConnection
+            {
+                get;
+                private set;
+            }
+
+            public EntityConnection(XElement element)
+            {
+                RoomName = element.GetAttributeString("roomname", "");
+                TargetEntityIdentifier = element.GetAttributeString("targetentity", "");
+                SourceEntityIdentifier = element.GetAttributeString("sourceentity", "");
+                foreach (XElement subElement in element.Elements())
+                {
+                    if (subElement.Name.ToString().ToLowerInvariant() == "wire")
+                    {
+                        WireConnection = new Pair<string, string>(
+                            subElement.GetAttributeString("from", ""),
+                            subElement.GetAttributeString("to", ""));
+                    }
+                }
+            }
+        }
+
+        [Serialize(Alignment.Bottom, false), Editable]
+        public Alignment Alignment { get; private set; }
+
+        [Serialize("0,0", false, description: "Minimum offset from the anchor position, relative to the size of the room." +
+            " For example, a value of { -0.5,0 } with a Bottom alignment would mean the entity can be placed anywhere between the bottom-left corner of the room and bottom-center."), Editable]
+        public Vector2 MinOffset { get; private set; }
+        [Serialize("0,0", false, description: "Maximum offset from the anchor position, relative to the size of the room." +
+            " For example, a value of { 0.5,0 } with a Bottom alignment would mean the entity can be placed anywhere between the bottom-right corner of the room and bottom-center."), Editable]
+        public Vector2 MaxOffset { get; private set; }
+
+        [Serialize(RuinEntityType.Prop, false), Editable]
+        public RuinEntityType Type { get; private set; }
+
+        [Serialize(false, false), Editable]
+        public bool Expand { get; private set; }
+
+        [Serialize(RelativePlacement.SameRoom, false), Editable]
+        public RelativePlacement PlacementRelativeToParent { get; private set; }
+
+        [Serialize(1.0f, false), Editable(MinValueFloat = 0.0f, MaxValueFloat = 10.0f)]
+        public float Commonness { get; private set; }
+
+        [Serialize(1, false)]
+        public int MinAmount { get; private set; }
+        [Serialize(1, false)]
+        public int MaxAmount { get; private set; }
+
+        [Serialize("0,0", false)]
+        public Point MinRoomSize { get; private set; }
+
+        [Serialize("100000,100000", false)]
+        public Point MaxRoomSize { get; private set; }
+
+        [Serialize("", false)]
+        public string TargetContainer { get; private set; }
+
+        public List<EntityConnection> EntityConnections { get; private set; } = new List<EntityConnection>();
+
+
+        public int SingleGroupIndex;
+
+        private readonly List<RuinEntityConfig> childEntities = new List<RuinEntityConfig>();        
+
+        public IEnumerable<RuinEntityConfig> ChildEntities
+        {
+            get { return childEntities; }
+        }
+
+        public string Name => Prefab == null ? "null" : Prefab.Name;
+
+        public Dictionary<string, SerializableProperty> SerializableProperties
+        {
+            get;
+            private set;
+        } = new Dictionary<string, SerializableProperty>();
+
+        public RuinEntityConfig(XElement element)
+        {
+            string name = element.GetAttributeString("prefab", "");
+            Prefab = MapEntityPrefab.Find(name: null, identifier: name);
+
+            if (Prefab == null)
+            {
+                DebugConsole.ThrowError("Loading ruin entity config failed - map entity prefab \"" + name + "\" not found.");
+                return;
+            }
+
+            SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
+            
+            int gIndex = 0;
+            LoadChildren(element, ref gIndex);
+
+            void LoadChildren(XElement element2, ref int groupIndex)
+            {
+                foreach (XElement subElement in element2.Elements())
+                {
+                    switch (subElement.Name.ToString().ToLowerInvariant())
+                    {
+                        case "connection":
+                        case "entityconnection":
+                            EntityConnections.Add(new EntityConnection(subElement));
+                            break;
+                        case "chooseone":
+                            groupIndex++;
+                            LoadChildren(subElement, ref groupIndex);
+                            break;
+                        default:
+                            childEntities.Add(new RuinEntityConfig(subElement) { SingleGroupIndex = groupIndex });
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}