BarotraumaServer compiles

Cleanup + fixes coming up next

BarotraumaClient/Source/Map/Levels/Ruins/RuinGenerator.cs

@@ -0,0 +1,30 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Voronoi2;
+
+namespace Barotrauma.RuinGeneration
+{
+    partial class Ruin
+    {
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            //foreach (BTRoom room in leaves)
+            //{
+            //    GUI.DrawRectangle(spriteBatch, room.Rect, Color.White);
+            //}
+
+            //foreach (Corridor corr in corridors)
+            //{
+            //    GUI.DrawRectangle(spriteBatch, corr.Rect, Color.Blue);
+            //}
+
+            foreach (Line line in walls)
+            {
+                GUI.DrawLine(spriteBatch, new Vector2(line.A.X, -line.A.Y), new Vector2(line.B.X, -line.B.Y), Color.Red, 0.0f, 10);
+            }
+        }
+    }
+}

BarotraumaClient/Source/Map/Levels/WrappingWall.cs

@@ -0,0 +1,39 @@
+using FarseerPhysics;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    partial class WrappingWall : IDisposable
+    {
+        private VertexBuffer wallVertices, bodyVertices;
+
+        public VertexBuffer WallVertices
+        {
+            get { return wallVertices; }
+        }
+
+        public VertexBuffer BodyVertices
+        {
+            get { return bodyVertices; }
+        }
+
+        public void SetWallVertices(VertexPositionTexture[] vertices)
+        {
+            wallVertices = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionTexture.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
+            wallVertices.SetData(vertices);
+        }
+
+        public void SetBodyVertices(VertexPositionColor[] vertices)
+        {
+            bodyVertices = new VertexBuffer(GameMain.Instance.GraphicsDevice, VertexPositionColor.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
+            bodyVertices.SetData(vertices);
+        }
+    }
+}

BarotraumaClient/Source/Map/Map.cs

@@ -0,0 +1,210 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    partial class Map
+    {
+        private static Sprite iceTexture;
+        private static Texture2D iceCraters;
+        private static Texture2D iceCrack;
+
+        public void Update(float deltaTime, Rectangle rect, float scale = 1.0f)
+        {
+            Vector2 rectCenter = new Vector2(rect.Center.X, rect.Center.Y);
+            Vector2 offset = -currentLocation.MapPosition;
+
+            float maxDist = 20.0f;
+            float closestDist = 0.0f;
+            highlightedLocation = null;
+            for (int i = 0; i < locations.Count; i++)
+            {
+                Location location = locations[i];
+                Vector2 pos = rectCenter + (location.MapPosition + offset) * scale;
+
+                if (!rect.Contains(pos)) continue;
+
+                float dist = Vector2.Distance(PlayerInput.MousePosition, pos);
+                if (dist < maxDist && (highlightedLocation == null || dist < closestDist))
+                {
+                    closestDist = dist;
+                    highlightedLocation = location;
+                }
+            }
+
+            foreach (LocationConnection connection in connections)
+            {
+                if (highlightedLocation != currentLocation &&
+                    connection.Locations.Contains(highlightedLocation) && connection.Locations.Contains(currentLocation))
+                {
+                    if (PlayerInput.LeftButtonClicked() &&
+                        selectedLocation != highlightedLocation && highlightedLocation != null)
+                    {
+                        selectedConnection = connection;
+                        selectedLocation = highlightedLocation;
+                        GameMain.LobbyScreen.SelectLocation(highlightedLocation, connection);
+                    }
+                }
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch, Rectangle rect, float scale = 1.0f)
+        {
+            Vector2 rectCenter = new Vector2(rect.Center.X, rect.Center.Y);
+            Vector2 offset = -currentLocation.MapPosition;
+
+            iceTexture.DrawTiled(spriteBatch, new Vector2(rect.X, rect.Y), new Vector2(rect.Width, rect.Height), Vector2.Zero, Color.White * 0.8f);
+
+            foreach (LocationConnection connection in connections)
+            {
+                Color crackColor = Color.White * Math.Max(connection.Difficulty / 100.0f, 1.5f);
+
+                if (selectedLocation != currentLocation &&
+                    (connection.Locations.Contains(selectedLocation) && connection.Locations.Contains(currentLocation)))
+                {
+                    crackColor = Color.Red;
+                }
+                else if (highlightedLocation != currentLocation &&
+                (connection.Locations.Contains(highlightedLocation) && connection.Locations.Contains(currentLocation)))
+                {
+                    crackColor = Color.Red * 0.5f;
+                }
+                else if (!connection.Passed)
+                {
+                    crackColor *= 0.2f;
+                }
+
+                for (int i = 0; i < connection.CrackSegments.Count; i++)
+                {
+                    var segment = connection.CrackSegments[i];
+
+                    Vector2 start = rectCenter + (segment[0] + offset) * scale;
+                    Vector2 end = rectCenter + (segment[1] + offset) * scale;
+
+                    if (!rect.Contains(start) && !rect.Contains(end))
+                    {
+                        continue;
+                    }
+                    else
+                    {
+                        Vector2? intersection = MathUtils.GetLineRectangleIntersection(start, end, new Rectangle(rect.X, rect.Y + rect.Height, rect.Width, rect.Height));
+                        if (intersection != null)
+                        {
+                            if (!rect.Contains(start))
+                            {
+                                start = (Vector2)intersection;
+                            }
+                            else
+                            {
+                                end = (Vector2)intersection;
+                            }
+                        }
+                    }
+
+                    float dist = Vector2.Distance(start, end);
+
+                    int width = (int)(MathHelper.Clamp(connection.Difficulty, 2.0f, 20.0f) * scale);
+
+                    spriteBatch.Draw(iceCrack,
+                        new Rectangle((int)start.X, (int)start.Y, (int)dist + 2, width),
+                        new Rectangle(0, 0, iceCrack.Width, 60), crackColor, MathUtils.VectorToAngle(end - start),
+                        new Vector2(0, 30), SpriteEffects.None, 0.01f);
+                }
+            }
+
+            rect.Inflate(8, 8);
+            GUI.DrawRectangle(spriteBatch, rect, Color.Black, false, 0.0f, 8);
+            GUI.DrawRectangle(spriteBatch, rect, Color.LightGray);
+
+            for (int i = 0; i < locations.Count; i++)
+            {
+                Location location = locations[i];
+                Vector2 pos = rectCenter + (location.MapPosition + offset) * scale;
+
+                Rectangle drawRect = location.Type.Sprite.SourceRect;
+                Rectangle sourceRect = drawRect;
+                drawRect.X = (int)pos.X - drawRect.Width / 2;
+                drawRect.Y = (int)pos.Y - drawRect.Width / 2;
+
+                if (!rect.Intersects(drawRect)) continue;
+
+                Color color = location.Connections.Find(c => c.Locations.Contains(currentLocation)) == null ? Color.White : Color.Green;
+
+                color *= (location.Discovered) ? 0.8f : 0.2f;
+
+                if (location == currentLocation) color = Color.Orange;
+
+                if (drawRect.X < rect.X)
+                {
+                    sourceRect.X += rect.X - drawRect.X;
+                    sourceRect.Width -= sourceRect.X;
+                    drawRect.X = rect.X;
+                }
+                else if (drawRect.Right > rect.Right)
+                {
+                    sourceRect.Width -= (drawRect.Right - rect.Right);
+                }
+
+                if (drawRect.Y < rect.Y)
+                {
+                    sourceRect.Y += rect.Y - drawRect.Y;
+                    sourceRect.Height -= sourceRect.Y;
+                    drawRect.Y = rect.Y;
+                }
+                else if (drawRect.Bottom > rect.Bottom)
+                {
+                    sourceRect.Height -= drawRect.Bottom - rect.Bottom;
+                }
+
+                drawRect.Width = sourceRect.Width;
+                drawRect.Height = sourceRect.Height;
+
+                spriteBatch.Draw(location.Type.Sprite.Texture, drawRect, sourceRect, color);
+            }
+
+            for (int i = 0; i < 3; i++)
+            {
+                Location location = (i == 0) ? highlightedLocation : selectedLocation;
+                if (i == 2) location = currentLocation;
+
+                if (location == null) continue;
+
+                Vector2 pos = rectCenter + (location.MapPosition + offset) * scale;
+                pos.X = (int)(pos.X + location.Type.Sprite.SourceRect.Width * 0.6f);
+                pos.Y = (int)(pos.Y - 10);
+                GUI.DrawString(spriteBatch, pos, location.Name, Color.White, Color.Black * 0.8f, 3);
+            }
+
+        }
+
+        public void Save(XElement element)
+        {
+            XElement mapElement = new XElement("map");
+
+            mapElement.Add(new XAttribute("currentlocation", CurrentLocationIndex));
+            mapElement.Add(new XAttribute("seed", Seed));
+            mapElement.Add(new XAttribute("size", size));
+
+            List<int> discoveredLocations = new List<int>();
+            for (int i = 0; i < locations.Count; i++)
+            {
+                if (locations[i].Discovered) discoveredLocations.Add(i);
+            }
+            mapElement.Add(new XAttribute("discovered", string.Join(",", discoveredLocations)));
+
+            List<int> passedConnections = new List<int>();
+            for (int i = 0; i < connections.Count; i++)
+            {
+                if (connections[i].Passed) passedConnections.Add(i);
+            }
+            mapElement.Add(new XAttribute("passed", string.Join(",", passedConnections)));
+
+            element.Add(mapElement);
+        }
+    }
+}

BarotraumaClient/Source/Map/Submarine.cs

@@ -0,0 +1,228 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using FarseerPhysics.Common;
+using FarseerPhysics.Dynamics;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Xml.Linq;
+using Voronoi2;
+
+namespace Barotrauma
+{
+    partial class Submarine : Entity, IServerSerializable
+    {
+        public static void Draw(SpriteBatch spriteBatch, bool editing = false)
+        {
+            var entitiesToRender = !editing && visibleEntities != null ? visibleEntities : MapEntity.mapEntityList;
+
+            foreach (MapEntity e in entitiesToRender)
+            {
+                e.Draw(spriteBatch, editing);
+            }
+        }
+
+        public static void DrawFront(SpriteBatch spriteBatch, bool editing = false, Predicate<MapEntity> predicate = null)
+        {
+            var entitiesToRender = !editing && visibleEntities != null ? visibleEntities : MapEntity.mapEntityList;
+
+            foreach (MapEntity e in entitiesToRender)
+            {
+                if (!e.DrawOverWater) continue;
+
+                if (predicate != null)
+                {
+                    if (!predicate(e)) continue;
+                }
+
+                e.Draw(spriteBatch, editing, false);
+            }
+
+            if (GameMain.DebugDraw)
+            {
+                foreach (Submarine sub in Submarine.Loaded)
+                {
+                    Rectangle worldBorders = sub.Borders;
+                    worldBorders.Location += sub.WorldPosition.ToPoint();
+                    worldBorders.Y = -worldBorders.Y;
+
+                    GUI.DrawRectangle(spriteBatch, worldBorders, Color.White, false, 0, 5);
+
+                    if (sub.subBody.MemPos.Count < 2) continue;
+
+                    Vector2 prevPos = ConvertUnits.ToDisplayUnits(sub.subBody.MemPos[0].Position);
+                    prevPos.Y = -prevPos.Y;
+
+                    for (int i = 1; i < sub.subBody.MemPos.Count; i++)
+                    {
+                        Vector2 currPos = ConvertUnits.ToDisplayUnits(sub.subBody.MemPos[i].Position);
+                        currPos.Y = -currPos.Y;
+
+                        GUI.DrawRectangle(spriteBatch, new Rectangle((int)currPos.X - 10, (int)currPos.Y - 10, 20, 20), Color.Blue * 0.6f, true, 0.01f);
+                        GUI.DrawLine(spriteBatch, prevPos, currPos, Color.Cyan * 0.5f, 0, 5);
+
+                        prevPos = currPos;
+                    }
+                }
+            }
+        }
+
+        public static float DamageEffectCutoff;
+
+        public static void DrawDamageable(SpriteBatch spriteBatch, Effect damageEffect, bool editing = false)
+        {
+            var entitiesToRender = !editing && visibleEntities != null ? visibleEntities : MapEntity.mapEntityList;
+
+            foreach (MapEntity e in entitiesToRender)
+            {
+                if (e.DrawDamageEffect)
+                    e.DrawDamage(spriteBatch, damageEffect);
+            }
+            if (damageEffect != null)
+            {
+                damageEffect.Parameters["aCutoff"].SetValue(0.0f);
+                damageEffect.Parameters["cCutoff"].SetValue(0.0f);
+
+                DamageEffectCutoff = 0.0f;
+            }
+        }
+
+        public static void DrawBack(SpriteBatch spriteBatch, bool editing = false, Predicate<MapEntity> predicate = null)
+        {
+            var entitiesToRender = !editing && visibleEntities != null ? visibleEntities : MapEntity.mapEntityList;
+
+            foreach (MapEntity e in entitiesToRender)
+            {
+                if (!e.DrawBelowWater) continue;
+
+                if (predicate != null)
+                {
+                    if (!predicate(e)) continue;
+                }
+
+                e.Draw(spriteBatch, editing, true);
+            }
+        }
+
+        public bool Save()
+        {
+            return SaveAs(filePath);
+        }
+
+        public bool SaveAs(string filePath)
+        {
+            name = System.IO.Path.GetFileNameWithoutExtension(filePath);
+
+            XDocument doc = new XDocument(new XElement("Submarine"));
+            SaveToXElement(doc.Root);
+
+            hash = new Md5Hash(doc);
+            doc.Root.Add(new XAttribute("md5hash", hash.Hash));
+
+            try
+            {
+                SaveUtil.CompressStringToFile(filePath, doc.ToString());
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError("Saving submarine \"" + filePath + "\" failed!", e);
+                return false;
+            }
+
+            return true;
+        }
+
+        public void SaveToXElement(XElement element)
+        {
+            element.Add(new XAttribute("name", name));
+            element.Add(new XAttribute("description", Description == null ? "" : Description));
+
+            element.Add(new XAttribute("tags", tags.ToString()));
+
+            foreach (MapEntity e in MapEntity.mapEntityList)
+            {
+                if (e.MoveWithLevel || e.Submarine != this) continue;
+                e.Save(element);
+            }
+        }
+
+        public static bool SaveCurrent(string filePath)
+        {
+            if (Submarine.MainSub == null)
+            {
+                Submarine.MainSub = new Submarine(filePath);
+                // return;
+            }
+
+            Submarine.MainSub.filePath = filePath;
+
+            return Submarine.MainSub.SaveAs(filePath);
+        }
+
+        public void CheckForErrors()
+        {
+            List<string> errorMsgs = new List<string>();
+
+            if (!Hull.hullList.Any())
+            {
+                errorMsgs.Add("No hulls found in the submarine. Hulls determine the \"borders\" of an individual room and are required for water and air distribution to work correctly.");
+            }
+
+            foreach (Item item in Item.ItemList)
+            {
+                if (item.GetComponent<Items.Components.Vent>() == null) continue;
+
+                if (!item.linkedTo.Any())
+                {
+                    errorMsgs.Add("The submarine contains vents which haven't been linked to an oxygen generator. Select a vent and click an oxygen generator while holding space to link them.");
+                    break;
+                }
+            }
+
+            if (WayPoint.WayPointList.Find(wp => !wp.MoveWithLevel && wp.SpawnType == SpawnType.Path) == null)
+            {
+                errorMsgs.Add("No waypoints found in the submarine. AI controlled crew members won't be able to navigate without waypoints.");
+            }
+
+            if (WayPoint.WayPointList.Find(wp => wp.SpawnType == SpawnType.Cargo) == null)
+            {
+                errorMsgs.Add("The submarine doesn't have spawnpoints for cargo (which are used for determining where to place bought items). "
+                     + "To fix this, create a new spawnpoint and change its \"spawn type\" parameter to \"cargo\".");
+            }
+
+            if (errorMsgs.Any())
+            {
+                new GUIMessageBox("Warning", string.Join("\n\n", errorMsgs), 400, 0);
+            }
+
+            foreach (MapEntity e in MapEntity.mapEntityList)
+            {
+                if (Vector2.Distance(e.Position, HiddenSubPosition) > 20000)
+                {
+                    var msgBox = new GUIMessageBox(
+                        "Warning",
+                        "One or more structures have been placed very far from the submarine. Show the structures?",
+                        new string[] { "Yes", "No" });
+
+                    msgBox.Buttons[0].OnClicked += (btn, obj) =>
+                    {
+                        GameMain.EditMapScreen.Cam.Position = e.WorldPosition;
+                        return true;
+                    };
+                    msgBox.Buttons[0].OnClicked += msgBox.Close;
+                    msgBox.Buttons[1].OnClicked += msgBox.Close;
+
+                    break;
+
+                }
+            }
+        }
+
+    }
+}