v0.11.0.9

Barotrauma/BarotraumaClient/ClientSource/Map/Levels/BackgroundCreatures/BackgroundCreature.cs

@@ -1,30 +1,38 @@
-using Microsoft.Xna.Framework;
+using Barotrauma.SpriteDeformations;
+using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using System;
 using System.Collections.Generic;
+using System.Xml.Linq;
 
 namespace Barotrauma
 {
 
     class BackgroundCreature : ISteerable
     {
-        const float MaxDepth = 100.0f;
+        const float MaxDepth = 10000.0f;
 
         const float CheckWallsInterval = 5.0f;
 
-        public bool Enabled;
+        public bool Visible;
 
-        private BackgroundCreaturePrefab prefab;
+        public readonly BackgroundCreaturePrefab Prefab;
 
+        private readonly List<SpriteDeformation> uniqueSpriteDeformations = new List<SpriteDeformation>();
+        private readonly List<SpriteDeformation> spriteDeformations = new List<SpriteDeformation>();
+        private readonly List<SpriteDeformation> lightSpriteDeformations = new List<SpriteDeformation>();
+        
         private Vector2 position;
 
         private Vector3 velocity;
 
         private float depth;
-        
-        private SteeringManager steeringManager;
 
-        private float checkWallsTimer;
+        private float alpha = 1.0f;
+        
+        private readonly SteeringManager steeringManager;
+
+        private float checkWallsTimer, flashTimer;
 
         private float wanderZPhase;
         private Vector2 obstacleDiff;
@@ -33,9 +41,16 @@ namespace Barotrauma
         public Swarm Swarm;
 
         Vector2 drawPosition;
-        public Vector2 TransformedPosition
+
+        public Vector2[,] CurrentSpriteDeformation
         {
-            get { return drawPosition; }
+            get;
+            private set;
+        }
+        public Vector2[,] CurrentLightSpriteDeformation
+        {
+            get;
+            private set;
         }
 
         public Vector2 SimPosition
@@ -58,11 +73,10 @@ namespace Barotrauma
             get;
             set;
         }
-        
+
         public BackgroundCreature(BackgroundCreaturePrefab prefab, Vector2 position)
         {
-            this.prefab = prefab;
-
+            this.Prefab = prefab;
             this.position = position;
 
             drawPosition = position;
@@ -70,18 +84,73 @@ namespace Barotrauma
             steeringManager = new SteeringManager(this);
 
             velocity = new Vector3(
-                Rand.Range(-prefab.Speed, prefab.Speed),
-                Rand.Range(-prefab.Speed, prefab.Speed),
-                Rand.Range(0.0f, prefab.WanderZAmount));
+                Rand.Range(-prefab.Speed, prefab.Speed, Rand.RandSync.ClientOnly),
+                Rand.Range(-prefab.Speed, prefab.Speed, Rand.RandSync.ClientOnly),
+                Rand.Range(0.0f, prefab.WanderZAmount, Rand.RandSync.ClientOnly));
 
-            checkWallsTimer = Rand.Range(0.0f, CheckWallsInterval);
+            checkWallsTimer = Rand.Range(0.0f, CheckWallsInterval, Rand.RandSync.ClientOnly);
 
+            foreach (XElement subElement in prefab.Config.Elements())
+            {
+                List<SpriteDeformation> deformationList = null;
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "deformablesprite":
+                        deformationList = spriteDeformations;
+                        break;
+                    case "deformablelightsprite":
+                        deformationList = lightSpriteDeformations;
+                        break;
+                    default:
+                        continue;
+                }
+                foreach (XElement animationElement in subElement.Elements())
+                {
+                    SpriteDeformation deformation = null;
+                    int sync = animationElement.GetAttributeInt("sync", -1);
+                    if (sync > -1)
+                    {
+                        string typeName = animationElement.GetAttributeString("type", "").ToLowerInvariant();
+                        deformation = uniqueSpriteDeformations.Find(d => d.TypeName == typeName && d.Sync == sync);
+                    }
+                    if (deformation == null)
+                    {
+                        deformation = SpriteDeformation.Load(animationElement, prefab.Name);
+                        if (deformation != null)
+                        {
+                            uniqueSpriteDeformations.Add(deformation);
+                        }
+                    }
+                    if (deformation != null)
+                    {
+                        deformationList.Add(deformation);
+                    }
+                }
+            }
         }
         
         public void Update(float deltaTime)
         {
             position += new Vector2(velocity.X, velocity.Y) * deltaTime;
-            depth = MathHelper.Clamp(depth + velocity.Z * deltaTime, 0.0f, MaxDepth);
+            depth = MathHelper.Clamp(depth + velocity.Z * deltaTime, Prefab.MinDepth, Prefab.MaxDepth * 10);
+
+            if (Prefab.FlashInterval > 0.0f)
+            {
+                flashTimer -= deltaTime;
+                if (flashTimer > 0.0f)
+                {
+                    alpha = 0.0f;
+                }
+                else
+                {
+                    //value goes from 0 to 1 and back to 0 during the flash
+                    alpha = (float)Math.Sin(-flashTimer / Prefab.FlashDuration * MathHelper.Pi) * PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.1f, (float)Timing.TotalTime * 0.2f);
+                    if (flashTimer < -Prefab.FlashDuration)
+                    {
+                        flashTimer = Prefab.FlashInterval;
+                    }
+                }
+            }
 
             checkWallsTimer -= deltaTime;
             if (checkWallsTimer <= 0.0f && Level.Loaded != null)
@@ -134,54 +203,145 @@ namespace Barotrauma
                 float midPointDist = Vector2.Distance(SimPosition, midPoint) * 100.0f;
                 if (midPointDist > Swarm.MaxDistance)
                 {
-                    steeringManager.SteeringSeek(midPoint, ((midPointDist / Swarm.MaxDistance) - 1.0f) * prefab.Speed);
+                    steeringManager.SteeringSeek(midPoint, ((midPointDist / Swarm.MaxDistance) - 1.0f) * Prefab.Speed);
                 }
                 steeringManager.SteeringManual(deltaTime, Swarm.AvgVelocity() * Swarm.Cohesion);
             }
 
-            if (prefab.WanderAmount > 0.0f)
+            if (Prefab.WanderAmount > 0.0f)
             {
-                steeringManager.SteeringWander(prefab.Speed);
+                steeringManager.SteeringWander(Prefab.Speed);
             }
 
             if (obstacleDiff != Vector2.Zero)
             {
-                steeringManager.SteeringManual(deltaTime, -obstacleDiff * (1.0f - obstacleDist / 5000.0f) * prefab.Speed);
+                steeringManager.SteeringManual(deltaTime, -obstacleDiff * (1.0f - obstacleDist / 5000.0f) * Prefab.Speed);
             }
 
-            steeringManager.Update(prefab.Speed);
+            steeringManager.Update(Prefab.Speed);
 
-            if (prefab.WanderZAmount > 0.0f)
+            if (Prefab.WanderZAmount > 0.0f)
             {
-                wanderZPhase += Rand.Range(-prefab.WanderZAmount, prefab.WanderZAmount);
-                velocity.Z = (float)Math.Sin(wanderZPhase) * prefab.Speed;
+                wanderZPhase += Rand.Range(-Prefab.WanderZAmount, Prefab.WanderZAmount);
+                velocity.Z = (float)Math.Sin(wanderZPhase) * Prefab.Speed;
             }
 
             velocity = Vector3.Lerp(velocity, new Vector3(Steering.X, Steering.Y, velocity.Z), deltaTime);
+
+            UpdateDeformations(deltaTime);            
+        }
+
+        public void DrawLightSprite(SpriteBatch spriteBatch, Camera cam)
+        {
+            Draw(spriteBatch, cam, Prefab.LightSprite, Prefab.DeformableLightSprite, CurrentLightSpriteDeformation, Color.White * alpha);
         }
 
         public void Draw(SpriteBatch spriteBatch, Camera cam)
         {
+            Draw(spriteBatch, 
+                cam, 
+                Prefab.Sprite, 
+                Prefab.DeformableSprite, 
+                CurrentSpriteDeformation,
+                Color.Lerp(Color.White, Level.Loaded.BackgroundColor, depth / Math.Max(MaxDepth, Prefab.MaxDepth)) * alpha);
+        }
+
+        private void Draw(SpriteBatch spriteBatch, Camera cam, Sprite sprite, DeformableSprite deformableSprite, Vector2[,] currentSpriteDeformation, Color color)
+        {
+            if (sprite == null && deformableSprite == null) { return; }
+            if (color.A == 0) { return; }
+
             float rotation = 0.0f;
-            if (!prefab.DisableRotation)
+            if (!Prefab.DisableRotation)
             {
                 rotation = MathUtils.VectorToAngle(new Vector2(velocity.X, -velocity.Y));
-                if (velocity.X < 0.0f) rotation -= MathHelper.Pi;
+                if (velocity.X < 0.0f) { rotation -= MathHelper.Pi; }
             }
 
-            drawPosition = position;
-            if (depth > 0.0f)
+            drawPosition = GetDrawPosition(cam);
+
+            float scale = GetScale();
+            sprite?.Draw(spriteBatch,
+                new Vector2(drawPosition.X, -drawPosition.Y),
+                color,
+                rotation, 
+                scale,
+                Prefab.DisableFlipping || velocity.X > 0.0f ? SpriteEffects.None : SpriteEffects.FlipHorizontally,
+                Math.Min(depth / MaxDepth, 1.0f));
+
+            if (deformableSprite != null)
+            {
+                if (currentSpriteDeformation != null)
+                {
+                    deformableSprite.Deform(currentSpriteDeformation);
+                }
+                else
+                {
+                    deformableSprite.Reset();
+                }
+                deformableSprite?.Draw(cam,
+                    new Vector3(drawPosition.X, drawPosition.Y, Math.Min(depth / 10000.0f, 1.0f)),
+                    deformableSprite.Origin,
+                    rotation,
+                    Vector2.One * scale,
+                    color,
+                    mirror: Prefab.DisableFlipping || velocity.X <= 0.0f);
+            }
+        }
+
+        public Vector2 GetDrawPosition(Camera cam)
+        {
+            Vector2 drawPosition = WorldPosition;
+            if (depth >= 0)
             {
                 Vector2 camOffset = drawPosition - cam.WorldViewCenter;
-                drawPosition -= camOffset * (depth / MaxDepth) * 0.05f;
+                drawPosition -= camOffset * depth / MaxDepth;
             }
+            return drawPosition;
+        }
 
-            prefab.Sprite.Draw(spriteBatch,
-                new Vector2(drawPosition.X, -drawPosition.Y),
-                Color.Lerp(Color.White, Level.Loaded.BackgroundColor, (depth / MaxDepth) * 0.2f),
-                rotation, (1.0f - (depth / MaxDepth) * 0.2f) * prefab.Scale,
-                velocity.X > 0.0f ? SpriteEffects.None : SpriteEffects.FlipHorizontally,
-                (depth / MaxDepth));
+        public float GetScale()
+        {
+            return Math.Max(1.0f - depth / MaxDepth, 0.05f) * Prefab.Scale;
+        }
+
+        public Rectangle GetExtents(Camera cam)
+        {
+            Vector2 min = GetDrawPosition(cam);
+            Vector2 max = min;
+
+            float scale = GetScale();
+            GetSpriteExtents(Prefab.Sprite, ref min, ref max);
+            GetSpriteExtents(Prefab.LightSprite, ref min, ref max);
+            GetSpriteExtents(Prefab.DeformableSprite?.Sprite, ref min, ref max);
+            GetSpriteExtents(Prefab.DeformableLightSprite?.Sprite, ref min, ref max);
+
+            return new Rectangle(min.ToPoint(), (max - min).ToPoint());
+
+            void GetSpriteExtents(Sprite sprite, ref Vector2 min, ref Vector2 max)
+            {
+                if (sprite == null) { return; }
+                min.X = Math.Min(min.X, min.X - sprite.size.X * sprite.RelativeOrigin.X * scale);
+                min.Y = Math.Min(min.Y, min.Y - sprite.size.Y * sprite.RelativeOrigin.Y * scale);
+                max.X = Math.Max(max.X, max.X + sprite.size.X * (1.0f - sprite.RelativeOrigin.X) * scale);
+                max.Y = Math.Max(max.Y, max.Y + sprite.size.Y * (1.0f - sprite.RelativeOrigin.Y) * scale);
+            }
+        }
+
+        private void UpdateDeformations(float deltaTime)
+        {
+            foreach (SpriteDeformation deformation in uniqueSpriteDeformations)
+            {
+                deformation.Update(deltaTime);
+            }
+            if (spriteDeformations.Count > 0)
+            {
+                CurrentSpriteDeformation = SpriteDeformation.GetDeformation(spriteDeformations, Prefab.DeformableSprite.Size);
+            }
+            if (lightSpriteDeformations.Count > 0)
+            {
+                CurrentLightSpriteDeformation = SpriteDeformation.GetDeformation(lightSpriteDeformations, Prefab.DeformableLightSprite.Size);
+            }
         }
     }
 

Barotrauma/BarotraumaClient/ClientSource/Map/Levels/BackgroundCreatures/BackgroundCreatureManager.cs

@@ -9,14 +9,14 @@ namespace Barotrauma
 {
     class BackgroundCreatureManager
     {
-        const int MaxSprites = 100;
+        const int MaxCreatures = 100;
 
-        const float CheckActiveInterval = 1.0f;
+        const float VisibilityCheckInterval = 1.0f;
 
-        private float checkActiveTimer;
+        private float checkVisibleTimer;
 
-        private List<BackgroundCreaturePrefab> prefabs = new List<BackgroundCreaturePrefab>();
-        private List<BackgroundCreature> activeSprites = new List<BackgroundCreature>();
+        private readonly List<BackgroundCreaturePrefab> prefabs = new List<BackgroundCreaturePrefab>();
+        private readonly List<BackgroundCreature> creatures = new List<BackgroundCreature>();
 
         public BackgroundCreatureManager(string configPath)
         {
@@ -60,92 +60,111 @@ namespace Barotrauma
             }
         }
 
-        public void SpawnSprites(int count, Vector2? position = null)
+        public void SpawnCreatures(Level level, int count, Vector2? position = null)
         {
-            activeSprites.Clear();
+            creatures.Clear();
 
-            if (prefabs.Count == 0) return;
+            if (prefabs.Count == 0) { return; }
 
-            count = Math.Min(count, MaxSprites);
+            count = Math.Min(count, MaxCreatures);
 
-            for (int i = 0; i < count; i++ )
+            List<BackgroundCreaturePrefab> availablePrefabs = new List<BackgroundCreaturePrefab>(prefabs);
+
+            for (int i = 0; i < count; i++)
             {
                 Vector2 pos = Vector2.Zero;
-
                 if (position == null)
                 {
-                    var wayPoints = WayPoint.WayPointList.FindAll(wp => wp.Submarine==null);
+                    var wayPoints = WayPoint.WayPointList.FindAll(wp => wp.Submarine == null);
                     if (wayPoints.Any())
                     {
                         WayPoint wp = wayPoints[Rand.Int(wayPoints.Count, Rand.RandSync.ClientOnly)];
-
                         pos = new Vector2(wp.Rect.X, wp.Rect.Y);
                         pos += Rand.Vector(200.0f, Rand.RandSync.ClientOnly);
                     }
                     else
                     {
                         pos = Rand.Vector(2000.0f, Rand.RandSync.ClientOnly);
-                    } 
+                    }
                 }
                 else
                 {
                     pos = (Vector2)position;
                 }
 
-
-                var prefab = prefabs[Rand.Int(prefabs.Count, Rand.RandSync.ClientOnly)];
+                var prefab = ToolBox.SelectWeightedRandom(availablePrefabs, availablePrefabs.Select(p => p.GetCommonness(level.GenerationParams)).ToList(), Rand.RandSync.ClientOnly);
+                if (prefab == null) { break; }
 
                 int amount = Rand.Range(prefab.SwarmMin, prefab.SwarmMax, Rand.RandSync.ClientOnly);
                 List<BackgroundCreature> swarmMembers = new List<BackgroundCreature>();
-
                 for (int n = 0; n < amount; n++)
                 {
-                    var newSprite = new BackgroundCreature(prefab, pos);
-                    activeSprites.Add(newSprite);
-                    swarmMembers.Add(newSprite);
+                    var creature = new BackgroundCreature(prefab, pos + Rand.Vector(Rand.Range(0.0f, prefab.SwarmRadius, Rand.RandSync.ClientOnly), Rand.RandSync.ClientOnly));
+                    creatures.Add(creature);
+                    swarmMembers.Add(creature);
                 }
-                if (amount > 0)
+                if (amount > 1)
                 {
                     new Swarm(swarmMembers, prefab.SwarmRadius, prefab.SwarmCohesion);
                 }
+                if (creatures.Count(c => c.Prefab == prefab) > prefab.MaxCount)
+                {
+                    availablePrefabs.Remove(prefab);
+                    if (availablePrefabs.Count <= 0) { break; }
+                }
             }
         }
 
-        public void ClearSprites()
+        public void Clear()
         {
-            activeSprites.Clear();
+            creatures.Clear();
         }
 
         public void Update(float deltaTime, Camera cam)
         {
-            if (checkActiveTimer < 0.0f)
+            if (checkVisibleTimer < 0.0f)
             {
-                foreach (BackgroundCreature sprite in activeSprites)
+                int margin = 500;
+                foreach (BackgroundCreature creature in creatures)
                 {
-                    sprite.Enabled = Math.Abs(sprite.TransformedPosition.X - cam.WorldViewCenter.X) < cam.WorldView.Width &&
-                                     Math.Abs(sprite.TransformedPosition.Y - cam.WorldViewCenter.Y) < cam.WorldView.Height;
+                    Rectangle extents = creature.GetExtents(cam);
+                    bool wasVisible = creature.Visible;
+                    creature.Visible =
+                        extents.Right >= cam.WorldView.X - margin &&
+                        extents.X <= cam.WorldView.Right + margin &&
+                        extents.Bottom >= cam.WorldView.Y - cam.WorldView.Height - margin &&
+                        extents.Y <= cam.WorldView.Y + margin;
                 }
 
-                checkActiveTimer = CheckActiveInterval;
+                checkVisibleTimer = VisibilityCheckInterval;
             }
             else
             {
-                checkActiveTimer -= deltaTime;
+                checkVisibleTimer -= deltaTime;
             }
 
-            foreach (BackgroundCreature sprite in activeSprites)
+            foreach (BackgroundCreature creature in creatures)
             {
-                if (!sprite.Enabled) continue;
-                sprite.Update(deltaTime);
+                if (!creature.Visible) { continue; }
+                creature.Update(deltaTime);
             }
         }
 
         public void Draw(SpriteBatch spriteBatch, Camera cam)
         {
-            foreach (BackgroundCreature sprite in activeSprites)
+            foreach (BackgroundCreature creature in creatures)
             {
-                if (!sprite.Enabled) continue;
-                sprite.Draw(spriteBatch, cam);
+                if (!creature.Visible) { continue; }
+                creature.Draw(spriteBatch, cam);
+            }
+        }
+
+        public void DrawLights(SpriteBatch spriteBatch, Camera cam)
+        {
+            foreach (BackgroundCreature creature in creatures)
+            {
+                if (!creature.Visible) { continue; }
+                creature.DrawLightSprite(spriteBatch, cam);
             }
         }
     }

Barotrauma/BarotraumaClient/ClientSource/Map/Levels/BackgroundCreatures/BackgroundCreaturePrefab.cs

@@ -1,50 +1,117 @@
-using System.Xml.Linq;
+using System.Collections.Generic;
+using System.Xml.Linq;
 
 namespace Barotrauma
 {
     class BackgroundCreaturePrefab
     {
-        public readonly Sprite Sprite;
+        public readonly Sprite Sprite, LightSprite;
+        public readonly DeformableSprite DeformableSprite, DeformableLightSprite;
 
-        public readonly float Speed;
+        public readonly string Name;
 
-        public readonly float WanderAmount;
+        public readonly XElement Config;
 
-        public readonly float WanderZAmount;
+        [Serialize(1.0f, true)]
+        public float Speed { get; private set; }
 
-        public readonly int SwarmMin, SwarmMax;
-        public readonly float SwarmRadius, SwarmCohesion;
+        [Serialize(0.0f, true)]
+        public float WanderAmount { get; private set; }
 
-        public readonly bool DisableRotation;
+        [Serialize(0.0f, true)]
+        public float WanderZAmount { get; private set; }
+
+        [Serialize(1, true)]
+        public int SwarmMin { get; private set; }
+
+        [Serialize(1, true)]
+        public int SwarmMax { get; private set; }
+
+        [Serialize(200.0f, true)]
+        public float SwarmRadius { get; private set; }
+
+        [Serialize(0.2f, true)]
+        public float SwarmCohesion { get; private set; }
+
+        [Serialize(10.0f, true)]
+        public float MinDepth { get; private set; }
+
+        [Serialize(1000.0f, true)]
+        public float MaxDepth { get; private set; }
+
+        [Serialize(false, true)]
+        public bool DisableRotation { get; private set; }
+
+        [Serialize(false, true)]
+        public bool DisableFlipping { get; private set; }
+
+        [Serialize(1.0f, true)]
+        public float Scale { get; private set; }
+
+        [Serialize(1.0f, true)]
+        public float Commonness { get; private set; }
+
+        [Serialize(1000, true)]
+        public int MaxCount { get; private set; }
+
+        [Serialize(0.0f, true)]
+        public float FlashInterval { get; private set; }
+
+        [Serialize(0.0f, true)]
+        public float FlashDuration { get; private set; }
+
+
+        /// <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 = new Dictionary<string, float>();
 
-        public readonly float Scale;
-        
         public BackgroundCreaturePrefab(XElement element)
         {
-            Speed = element.GetAttributeFloat("speed", 1.0f);
+            Name = element.Name.ToString();
 
-            WanderAmount = element.GetAttributeFloat("wanderamount", 0.0f);
+            Config = element;
 
-            WanderZAmount = element.GetAttributeFloat("wanderzamount", 0.0f);
-            
-            SwarmMin = element.GetAttributeInt("swarmmin", 1);
-            SwarmMax = element.GetAttributeInt("swarmmax", 1);
-
-            SwarmRadius = element.GetAttributeFloat("swarmradius", 200.0f);
-            SwarmCohesion = element.GetAttributeFloat("swarmcohesion", 0.2f);
-
-            DisableRotation = element.GetAttributeBool("disablerotation", false);
-
-            Scale = element.GetAttributeFloat("scale", 1.0f);
+            SerializableProperty.DeserializeProperties(this, element);
 
             foreach (XElement subElement in element.Elements())
             {
-                if (!subElement.Name.ToString().Equals("sprite", System.StringComparison.OrdinalIgnoreCase)) { continue; }
-
-                Sprite = new Sprite(subElement, lazyLoad: true);
-                break;
+                switch (subElement.Name.ToString().ToLowerInvariant())
+                {
+                    case "sprite":
+                        Sprite = new Sprite(subElement, lazyLoad: true);
+                        break;
+                    case "deformablesprite":
+                        DeformableSprite = new DeformableSprite(subElement, lazyLoad: true);
+                        break;
+                    case "lightsprite":
+                        LightSprite = new Sprite(subElement, lazyLoad: true);
+                        break;
+                    case "deformablelightsprite":
+                        DeformableLightSprite = new DeformableSprite(subElement, lazyLoad: true);
+                        break;
+                    case "overridecommonness":
+                        string levelType = subElement.GetAttributeString("leveltype", "").ToLowerInvariant();
+                        if (!OverrideCommonness.ContainsKey(levelType))
+                        {
+                            OverrideCommonness.Add(levelType, subElement.GetAttributeFloat("commonness", 1.0f));
+                        }
+                        break;
+                }
             }
         }
+
+        public float GetCommonness(LevelGenerationParams generationParams)
+        {
+            if (generationParams?.Identifier != null &&
+                (OverrideCommonness.TryGetValue(generationParams.Identifier, out float commonness) ||
+                (generationParams.OldIdentifier != null && OverrideCommonness.TryGetValue(generationParams.OldIdentifier, out commonness))))
+            {
+                return commonness;
+            }
+            return Commonness;
+        }
     }
 
 }