- Added "LevelTriggers", areas that apply statuseffects and/or damage to entities. Atm can only be attached to background sprites.

- Moved background sprites to the shared project. - The debug textures of physics bodies have a maximum size of 128x128 pixels to prevent large bodies from taking up excessive amounts of memory. - Attacks can be set to only affect humans.
2017-08-23 20:37:30 +03:00
parent 2d1c00546f
commit c2da3a6af4
19 changed files with 467 additions and 225 deletions
@@ -0,0 +1,316 @@
+#if CLIENT
+using Barotrauma.Particles;
+#endif
+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 BackgroundSprite
+    {
+        public readonly BackgroundSpritePrefab Prefab;
+        public Vector3 Position;
+
+        public float Scale;
+
+        public float Rotation;
+
+        public LevelTrigger Trigger;
+        
+        public BackgroundSprite(BackgroundSpritePrefab prefab, Vector3 position, float scale, float rotation = 0.0f)
+        {
+            this.Prefab = prefab;
+            this.Position = position;
+
+            this.Scale = scale;
+
+            this.Rotation = rotation;
+
+            if (prefab.LevelTriggerElement != null)
+            {
+                Vector2 triggerPosition = ToolBox.GetAttributeVector2(prefab.LevelTriggerElement, "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);
+                }
+
+                this.Trigger = new LevelTrigger(prefab.LevelTriggerElement, new Vector2(position.X, position.Y) + triggerPosition, -rotation);
+            }
+
+#if CLIENT
+            if (prefab.ParticleEmitterPrefab != null)
+            {
+                this.ParticleEmitter = new ParticleEmitter(prefab.ParticleEmitterPrefab);
+            }
+#endif
+
+        }
+    }
+
+    partial class BackgroundSpriteManager
+    {
+        const int GridSize = 2000;
+
+        private List<BackgroundSpritePrefab> prefabs = new List<BackgroundSpritePrefab>();
+
+        private List<BackgroundSprite> sprites;
+        private List<BackgroundSprite>[,] spriteGrid;
+        
+        private float swingTimer, swingState;
+
+        public BackgroundSpriteManager(string configPath)
+        {
+            LoadConfig(configPath);
+        }
+        public BackgroundSpriteManager(List<string> files)
+        {
+            foreach (var file in files)
+            {
+                LoadConfig(file);
+            }
+        }
+        private void LoadConfig(string configPath)
+        {
+            try
+            {
+                XDocument doc = ToolBox.TryLoadXml(configPath);
+                if (doc == null || doc.Root == null) return;
+
+                foreach (XElement element in doc.Root.Elements())
+                {
+                    prefabs.Add(new BackgroundSpritePrefab(element));
+                }
+            }
+            catch (Exception e)
+            {
+                DebugConsole.ThrowError(String.Format("Failed to load BackgroundSprites from {0}", configPath), e);
+            }
+        }
+
+
+        public void PlaceSprites(Level level, int amount)
+        {
+            spriteGrid = new List<BackgroundSprite>[
+                (int)Math.Ceiling(level.Size.X / GridSize),
+                (int)Math.Ceiling((level.Size.Y - level.BottomPos) / GridSize)];
+
+            sprites = new List<BackgroundSprite>();
+            
+            for (int i = 0 ; i < amount; i++)
+            {
+                BackgroundSpritePrefab prefab = GetRandomPrefab(level.GenerationParams.Name);
+                GraphEdge selectedEdge = null;
+                Vector2 edgeNormal = Vector2.One;
+                Vector2? pos = FindSpritePosition(level, prefab, out selectedEdge, out edgeNormal);
+
+                if (pos == null) continue;
+
+                float rotation = 0.0f;
+                if (prefab.AlignWithSurface)
+                {
+                    rotation = MathUtils.VectorToAngle(new Vector2(edgeNormal.Y, edgeNormal.X));
+                }
+
+                rotation += Rand.Range(prefab.RandomRotation.X, prefab.RandomRotation.Y, Rand.RandSync.ClientOnly);
+
+                var newSprite = new BackgroundSprite(prefab,
+                    new Vector3((Vector2)pos, Rand.Range(prefab.DepthRange.X, prefab.DepthRange.Y, Rand.RandSync.ClientOnly)), Rand.Range(prefab.Scale.X, prefab.Scale.Y, Rand.RandSync.ClientOnly), rotation);
+                
+                //calculate the positions of the corners of the rotated sprite
+                Vector2 halfSize = newSprite.Prefab.Sprite.size * newSprite.Scale / 2;
+                var spriteCorners = new List<Vector2>
+                {
+                    -halfSize, new Vector2(-halfSize.X, halfSize.Y),
+                    halfSize, new Vector2(halfSize.X, -halfSize.Y)
+                };
+
+                Vector2 pivotOffset = newSprite.Prefab.Sprite.Origin * newSprite.Scale - halfSize;
+                pivotOffset.X = -pivotOffset.X;
+                pivotOffset = new Vector2(
+                    (float)(pivotOffset.X * Math.Cos(-rotation) - pivotOffset.Y * Math.Sin(-rotation)),
+                    (float)(pivotOffset.X * Math.Sin(-rotation) + pivotOffset.Y * Math.Cos(-rotation)));                
+
+                for (int j = 0; j < 4; j++)
+                {
+                    spriteCorners[j] = new Vector2(
+                        (float)(spriteCorners[j].X * Math.Cos(-rotation) - spriteCorners[j].Y * Math.Sin(-rotation)),
+                        (float)(spriteCorners[j].X * Math.Sin(-rotation) + spriteCorners[j].Y * Math.Cos(-rotation)));
+
+                    spriteCorners[j] += pos.Value + pivotOffset;
+                }
+
+#if CLIENT
+                if (newSprite.ParticleEmitter != null)
+                {
+                    Rectangle particleBounds = newSprite.ParticleEmitter.CalculateParticleBounds(pos.Value);
+                    spriteCorners.Add(particleBounds.Location.ToVector2());
+                    spriteCorners.Add(new Vector2(particleBounds.Right, particleBounds.Bottom));
+                }
+#endif
+
+                sprites.Add(newSprite);
+
+                int minX = (int)Math.Floor((spriteCorners.Min(c => c.X) - newSprite.Position.Z) / GridSize);
+                int maxX = (int)Math.Floor((spriteCorners.Max(c => c.X) + newSprite.Position.Z) / GridSize);
+
+                if (maxX < 0 || minX >= spriteGrid.GetLength(0)) continue;
+
+                int minY = (int)Math.Floor((spriteCorners.Min(c => c.Y) - newSprite.Position.Z - level.BottomPos) / GridSize);
+                int maxY = (int)Math.Floor((spriteCorners.Max(c => c.Y) + newSprite.Position.Z - level.BottomPos) / GridSize);
+                if (maxY < 0 || minY >= spriteGrid.GetLength(1)) continue;
+
+                minX = Math.Max(minX, 0);
+                maxX = Math.Min(maxX, spriteGrid.GetLength(0) - 1);
+                minY = Math.Max(minY, 0);
+                maxY = Math.Min(maxY, spriteGrid.GetLength(1) - 1);
+
+                for (int x = minX; x <= maxX; x++)
+                {
+                    for (int y = minY; y <= maxY; y++)
+                    {
+                        if (spriteGrid[x, y] == null) spriteGrid[x, y] = new List<BackgroundSprite>();
+                        spriteGrid[x, y].Add(newSprite);
+                    }
+                }
+            }
+        }
+
+        private Vector2? FindSpritePosition(Level level, BackgroundSpritePrefab prefab, out GraphEdge closestEdge, out Vector2 edgeNormal)
+        {
+            closestEdge = null;
+            edgeNormal = Vector2.One;
+
+            Vector2 randomPos = new Vector2(
+                Rand.Range(0.0f, level.Size.X, Rand.RandSync.ClientOnly), 
+                Rand.Range(0.0f, level.Size.Y, Rand.RandSync.ClientOnly));
+
+            if (prefab.SpawnPos == BackgroundSpritePrefab.SpawnPosType.None) return randomPos;
+
+            List<GraphEdge> edges = new List<GraphEdge>();
+            List<Vector2> normals = new List<Vector2>();
+
+            System.Diagnostics.Debug.Assert(level.ExtraWalls.Length == 1);
+            List<VoronoiCell> cells = new List<VoronoiCell>();
+
+            if (prefab.SpawnPos.HasFlag(BackgroundSpritePrefab.SpawnPosType.Wall)) cells.AddRange(level.GetCells(randomPos));
+            if (prefab.SpawnPos.HasFlag(BackgroundSpritePrefab.SpawnPosType.SeaFloor)) cells.AddRange(level.ExtraWalls[0].Cells);
+            
+            if (cells.Any())
+            {
+                VoronoiCell cell = cells[Rand.Int(cells.Count, Rand.RandSync.ClientOnly)];
+
+                foreach (GraphEdge edge in cell.edges)
+                {
+                    if (!edge.isSolid || edge.OutsideLevel) continue;
+
+                    Vector2 normal = edge.GetNormal(cell);
+                
+                    if (prefab.Alignment.HasFlag(Alignment.Bottom) && normal.Y < -0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else if (prefab.Alignment.HasFlag(Alignment.Top) && normal.Y > 0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else if (prefab.Alignment.HasFlag(Alignment.Left) && normal.X < -0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else if (prefab.Alignment.HasFlag(Alignment.Right) && normal.X > 0.5f)
+                    {
+                        edges.Add(edge);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    normals.Add(normal);
+                }
+            }
+            
+            if (prefab.SpawnPos.HasFlag(BackgroundSpritePrefab.SpawnPosType.RuinWall))
+            {
+                foreach (RuinGeneration.Ruin ruin in Level.Loaded.Ruins)
+                {
+                    Rectangle expandedArea = ruin.Area;
+                    expandedArea.Inflate(ruin.Area.Width, ruin.Area.Height);
+                    if (!expandedArea.Contains(randomPos)) continue;
+
+                    foreach (var ruinShape in ruin.RuinShapes)
+                    {
+                        foreach (var wall in ruinShape.Walls)
+                        {
+                            if (!prefab.Alignment.HasFlag(ruinShape.GetLineAlignment(wall))) continue;
+
+                            edges.Add(new GraphEdge(wall.A, wall.B));
+                            normals.Add((wall.A + wall.B) / 2.0f - ruinShape.Center);
+                        }
+                    }
+                }
+            }
+
+            if (!edges.Any()) return null;
+
+            int index = Rand.Int(edges.Count, Rand.RandSync.ClientOnly);
+            closestEdge = edges[index];
+            edgeNormal = normals[index];
+
+            float length = Vector2.Distance(closestEdge.point1, closestEdge.point2);
+            Vector2 dir = (closestEdge.point1 - closestEdge.point2) / length;
+            Vector2 pos = closestEdge.point2 + dir * Rand.Range(prefab.Sprite.size.X / 2.0f, length - prefab.Sprite.size.X / 2.0f, Rand.RandSync.ClientOnly);
+
+            return pos;
+        }
+
+        public void Update(float deltaTime)
+        {
+            swingTimer += deltaTime;
+            swingState = (float)Math.Sin(swingTimer * 0.1f);
+
+            foreach (BackgroundSprite sprite in sprites)
+            {
+                sprite.Trigger?.Update(deltaTime);
+            }
+            
+            UpdateProjSpecific(deltaTime);            
+        }
+
+        partial void UpdateProjSpecific(float deltaTime);
+
+        private BackgroundSpritePrefab GetRandomPrefab(string levelType)
+        {
+            int totalCommonness = 0;
+            foreach (BackgroundSpritePrefab prefab in prefabs)
+            {
+                totalCommonness += prefab.GetCommonness(levelType);
+            }
+
+            float randomNumber = Rand.Int(totalCommonness+1, Rand.RandSync.ClientOnly);
+
+            foreach (BackgroundSpritePrefab prefab in prefabs)
+            {
+                if (randomNumber <= prefab.GetCommonness(levelType))
+                {
+                    return prefab;
+                }
+
+                randomNumber -= prefab.GetCommonness(levelType);
+            }
+
+            return null;
+        }
+    }
+}
@@ -0,0 +1,117 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class BackgroundSpritePrefab
+    {
+        [Flags]
+        public enum SpawnPosType
+        {
+            None = 0,
+            Wall = 1,
+            RuinWall = 2,
+            SeaFloor = 4
+        }
+        
+        public readonly Alignment Alignment;
+
+        public readonly Vector2 DepthRange;
+
+        public readonly Sprite Sprite;
+
+        public readonly Vector2 Scale;
+
+        public SpawnPosType SpawnPos;
+
+        public readonly bool AlignWithSurface;
+        
+        public readonly Vector2 RandomRotation;
+        
+        public readonly float SwingAmount;
+
+        public readonly int Commonness;
+
+        public Dictionary<string, int> OverrideCommonness;
+
+        public readonly XElement LevelTriggerElement;
+
+        public BackgroundSpritePrefab(XElement element)
+        {
+            string alignmentStr = ToolBox.GetAttributeString(element, "alignment", "");
+
+            if (string.IsNullOrEmpty(alignmentStr) || !Enum.TryParse(alignmentStr, out Alignment))
+            {
+                Alignment = Alignment.Top | Alignment.Bottom | Alignment.Left | Alignment.Right;
+            }
+
+            Commonness = ToolBox.GetAttributeInt(element, "commonness", 1);
+            
+            string[] spawnPosStrs = ToolBox.GetAttributeString(element, "spawnpos", "Wall").Split(',');
+            foreach (string spawnPosStr in spawnPosStrs)
+            {
+                SpawnPosType parsedSpawnPos;
+                if (Enum.TryParse(spawnPosStr.Trim(), out parsedSpawnPos))
+                {
+                    SpawnPos |= parsedSpawnPos;
+                }
+            }
+
+            Scale.X = ToolBox.GetAttributeFloat(element, "minsize", 1.0f);
+            Scale.Y = ToolBox.GetAttributeFloat(element, "maxsize", 1.0f);
+
+            DepthRange = ToolBox.GetAttributeVector2(element, "depthrange", new Vector2(0.0f, 1.0f));
+
+            AlignWithSurface = ToolBox.GetAttributeBool(element, "alignwithsurface", false);
+
+            RandomRotation = ToolBox.GetAttributeVector2(element, "randomrotation", Vector2.Zero);
+            RandomRotation.X = MathHelper.ToRadians(RandomRotation.X);
+            RandomRotation.Y = MathHelper.ToRadians(RandomRotation.Y);
+
+            SwingAmount = MathHelper.ToRadians(ToolBox.GetAttributeFloat(element, "swingamount", 0.0f));
+
+            OverrideCommonness = new Dictionary<string, int>();
+
+            foreach (XElement subElement in element.Elements())
+            {
+                switch(subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        Sprite = new Sprite(subElement);
+                        break;
+                    case "overridecommonness":
+                        string levelType = ToolBox.GetAttributeString(subElement, "leveltype", "");
+                        if (!OverrideCommonness.ContainsKey(levelType))
+                        {
+                            OverrideCommonness.Add(levelType, ToolBox.GetAttributeInt(subElement, "commonness", 1));
+                        }
+                        break;
+                    case "leveltrigger":
+                    case "trigger":
+                        LevelTriggerElement = subElement;
+                        break;
+#if CLIENT
+                    case "particleemitter":
+                        ParticleEmitterPrefab = new Particles.ParticleEmitterPrefab(subElement);
+                        EmitterPosition = ToolBox.GetAttributeVector2(subElement, "position", Vector2.Zero);
+                        break;
+#endif
+                }
+            }
+        }
+
+        public int GetCommonness(string levelType)
+        {
+            int commonness = 0;
+            if (!OverrideCommonness.TryGetValue(levelType, out commonness))
+            {
+                return Commonness;
+            }
+
+            return commonness;
+        }
+
+    }
+}
@@ -15,7 +15,6 @@ namespace Barotrauma
    {
        //all entities are disabled after they reach this depth
        public const float MaxEntityDepth = -300000.0f;
-
        public const float ShaftHeight = 1000.0f;
        
        public static Level Loaded
@@ -75,6 +74,8 @@ namespace Barotrauma

        private LevelGenerationParams generationParams;

+        private static BackgroundSpriteManager backgroundSpriteManager;
+
        public Vector2 StartPosition
        {
            get { return startPosition; }
@@ -150,7 +151,7 @@ namespace Barotrauma
        {
            get { return wallColor; }
        }
-        
+
        public Level(string seed, float difficulty, LevelGenerationParams generationParams)
        {
            this.seed = seed;
@@ -183,6 +184,25 @@ namespace Barotrauma

        public void Generate(bool mirror = false)
        {
+            if (backgroundSpriteManager == null)
+            {
+                var files = GameMain.SelectedPackage.GetFilesOfType(ContentType.BackgroundSpritePrefabs);
+                if (files.Count > 0)
+                    backgroundSpriteManager = new BackgroundSpriteManager(files);
+                else
+                    backgroundSpriteManager = new BackgroundSpriteManager("Content/BackgroundSprites/BackgroundSpritePrefabs.xml");
+            }
+#if CLIENT
+            if (backgroundCreatureManager == null)
+            {
+                var files = GameMain.SelectedPackage.GetFilesOfType(ContentType.BackgroundCreaturePrefabs);
+                if (files.Count > 0)
+                    backgroundCreatureManager = new BackgroundCreatureManager(files);
+                else
+                    backgroundCreatureManager = new BackgroundCreatureManager("Content/BackgroundSprites/BackgroundCreaturePrefabs.xml");
+            }
+#endif
+
            Stopwatch sw = new Stopwatch();
            sw.Start();

@@ -485,8 +505,9 @@ namespace Barotrauma

            GenerateSeaFloor();

+            backgroundSpriteManager.PlaceSprites(this, generationParams.BackgroundSpriteAmount);
 #if CLIENT
-            renderer.PlaceSprites(generationParams.BackgroundSpriteAmount);
+            backgroundCreatureManager.SpawnSprites(80);
 #endif

            foreach (VoronoiCell cell in cells)
@@ -872,15 +893,13 @@ namespace Barotrauma
            return matchingPositions[Rand.Int(matchingPositions.Count, (useSyncedRand ? Rand.RandSync.Server : Rand.RandSync.Unsynced))].Position;
        }

-        public void Update(float deltaTime)
+        public void Update(float deltaTime, Camera cam)
        {
-            /*
-            if (Submarine.MainSub != null)
-            {
-                WrappingWall.UpdateWallShift(Submarine.MainSub.WorldPosition, wrappingWalls);
-            }*/
+            backgroundSpriteManager.Update(deltaTime);

 #if CLIENT
+            backgroundCreatureManager.Update(deltaTime, cam);
+
            if (Hull.renderer != null)
            {
                Hull.renderer.ScrollWater((float)deltaTime);
@@ -0,0 +1,134 @@
+using FarseerPhysics;
+using FarseerPhysics.Dynamics;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+
+namespace Barotrauma
+{
+    partial class LevelTrigger
+    {
+        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 List<Entity> triggerers = new List<Entity>();
+
+        public Vector2 WorldPosition
+        {
+            get { return ConvertUnits.ToDisplayUnits(physicsBody.Position); }
+            set { physicsBody.SetTransform(ConvertUnits.ToSimUnits(value), physicsBody.Rotation); }
+        }
+
+        public float Rotation
+        {
+            get { return physicsBody.Rotation; }
+            set { physicsBody.SetTransform(physicsBody.Position, value); }
+        }
+
+        public PhysicsBody PhysicsBody
+        {
+            get { return physicsBody; }
+        }
+
+        public LevelTrigger(XElement element, Vector2 position, float rotation, float scale = 1.0f)
+        {
+            physicsBody = new PhysicsBody(element, scale);
+            physicsBody.CollisionCategories = Physics.CollisionLevel;
+            physicsBody.CollidesWith = Physics.CollisionCharacter | Physics.CollisionItem | Physics.CollisionProjectile | Physics.CollisionWall;
+            physicsBody.FarseerBody.OnCollision += PhysicsBody_OnCollision;
+            physicsBody.FarseerBody.OnSeparation += PhysicsBody_OnSeparation;
+            physicsBody.FarseerBody.IsSensor = true;
+            physicsBody.FarseerBody.IsStatic = true;
+            physicsBody.FarseerBody.IsKinematic = true;
+
+            physicsBody.SetTransform(ConvertUnits.ToSimUnits(position), rotation);
+            
+            foreach (XElement subElement in element.Elements())
+            {
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "statuseffect":
+                        statusEffects.Add(StatusEffect.Load(subElement));
+                        break;
+                    case "attack":
+                    case "damage":
+                        attacks.Add(new Attack(subElement));
+                        break;
+                }
+            }
+        }
+
+        private bool PhysicsBody_OnCollision(Fixture fixtureA, Fixture fixtureB, FarseerPhysics.Dynamics.Contacts.Contact contact)
+        {
+            Entity entity = GetEntity(fixtureB);
+            if (entity == null) return false;
+
+            if (!triggerers.Contains(entity))
+            {
+                triggerers.Add(entity);
+            }
+            return true;
+        }
+
+        private void PhysicsBody_OnSeparation(Fixture fixtureA, Fixture fixtureB)
+        {
+            Entity entity = GetEntity(fixtureB);
+            if (entity == null) return;
+
+            if (triggerers.Contains(entity))
+            {
+                triggerers.Remove(entity);
+            }
+        }
+
+        private Entity GetEntity(Fixture fixture)
+        {
+            if (fixture.Body == null || fixture.Body.UserData == null) return null;
+
+            var entity = fixture.Body.UserData as Entity;
+            if (entity != null) return entity;
+            
+            var limb = fixture.Body.UserData as Limb;
+            if (limb != null) return limb.character;
+
+            return null;
+        }
+
+        public void Update(float deltaTime)
+        {
+            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);
+                    }
+                }
+
+                IDamageable damageable = triggerer as IDamageable;
+                if (damageable != null)
+                {
+                    foreach (Attack attack in attacks)
+                    {
+                        attack.DoDamage(null, damageable, WorldPosition, deltaTime, false);
+                    }
+                }
+            }
+        }
+    }
+}