tiled content pipeline bugfixes & new fields

src/cs/MonoGame.Extended.Collisions/CollisionComponent.cs

@@ -6,6 +6,7 @@
 using Microsoft.Xna.Framework;
 using MonoGame.Extended.Collisions.Layers;
 using MonoGame.Extended.Collisions.QuadTree;
+using Newtonsoft.Json.Linq;
 
 namespace MonoGame.Extended.Collisions
 {
@@ -97,6 +98,50 @@ public override void Update(GameTime gameTime)
             }
         }
 
+        /// <summary>
+        /// Cast an actor's colliders in a direction and check for collisions.
+        /// </summary>
+        /// <param name="actors">The list of actor colliders to cast.</param>
+        /// <param name="move">Normalized vector representing the direction to cast each shape.</param>
+        /// <param name="hitBuffer">Buffer to receive results.</param>
+        /// <param name="distance">Maximum distance over which to cast the Collider(s).</param>
+        public int Cast(IEnumerable<ICollisionActor> actors, Vector2 move, List<CollisionEventArgs> hitBuffer, float distance)
+        {
+            hitBuffer.Clear();
+            Vector2 offset = move.NormalizedCopy() * distance;
+            return Cast(actors, offset, hitBuffer);
+        }
+
+
+        /// <summary>
+        /// Cast an actor's colliders in a direction and check for collisions.
+        /// </summary>
+        /// <param name="actors">The list of actor colliders to cast.</param>
+        /// <param name="offset">Vector representing the translation to use for each cast.</param>
+        /// <param name="hitBuffer">Buffer to receive results.</param>
+        public int Cast(IEnumerable<ICollisionActor> actors, Vector2 offset, List<CollisionEventArgs> hitBuffer)
+        {
+            foreach (ICollisionActor actor in actors)
+            {
+                try
+                {
+                    actor.Bounds.Position += offset;
+                    foreach ((_, Layer secondLayer) in _layerCollision)
+                    {
+                        if (!secondLayer.Space.Contains(actor)) continue;
+                        foreach (ICollisionActor other in secondLayer.Space.Query(actor.Bounds.BoundingRectangle))
+                            if (actor != other && actor.Bounds.Intersects(other.Bounds))
+                            {
+                                CollisionEventArgs collisionInfo = new() { Other = other, PenetrationVector = CalculatePenetrationVector(actor.Bounds, other.Bounds) };
+                                hitBuffer.Add(collisionInfo);
+                            }
+                    }
+                }
+                finally { actor.Bounds.Position -= offset; }
+            }
+            return hitBuffer.Count;
+        }
+
         /// <summary>
         /// Inserts the target into the collision tree.
         /// The target will have its OnCollision called when collisions occur.

src/cs/MonoGame.Extended.Collisions/ISpaceAlgorithm.cs

@@ -21,10 +21,15 @@ public interface ISpaceAlgorithm
     bool Remove(ICollisionActor actor);
 
     /// <summary>
-    /// Removes the actor into the space.
-    /// The actor will have its OnCollision called when collisions occur.
+    /// Checks if an actor is within the space.
     /// </summary>
-    /// <param name="actor">Actor to remove.</param>
+    /// <param name="actor">Actor to check for.</param>
+    bool Contains(ICollisionActor actor);
+
+    /// <summary>
+    /// Queries the space for collisions within a bounding rectangle.
+    /// </summary>
+    /// <param name="boundsBoundingRectangle">Rectangle to check against.</param>
     IEnumerable<ICollisionActor> Query(RectangleF boundsBoundingRectangle);
 
     /// <summary>

src/cs/MonoGame.Extended.Collisions/QuadTree/QuadTreeSpace.cs

@@ -49,8 +49,15 @@ public bool Remove(ICollisionActor target)
         return false;
     }
 
+
+    /// <summary>
+    /// Checks if the target is within the space.
+    /// </summary>
+    /// <param name="target">Target to check for.</param>
+    public bool Contains(ICollisionActor target) => _actors.Contains(target);
+
     /// <summary>
-    /// Restructure a inner collection, if layer is dynamic, because actors can change own position
+    /// Restructure an inner collection, if layer is dynamic, because actors can change own position
     /// </summary>
     public void Reset()
     {

src/cs/MonoGame.Extended.Collisions/SpatialHash.cs

@@ -16,6 +16,8 @@ public SpatialHash(Size2 size)
         _size = size;
     }
 
+    public bool Contains(ICollisionActor actor) => _actors.Contains(actor);
+
     public void Insert(ICollisionActor actor)
     {
         InsertToHash(actor);

src/cs/MonoGame.Extended.Content.Pipeline/Tiled/ContentWriterExtensions.cs

@@ -19,6 +19,8 @@ public static void WriteTiledMapProperties(this ContentWriter writer, IReadOnlyC
             {
                 writer.Write(property.Name);
                 writer.Write(property.Value ?? string.Empty);
+                writer.Write(property.Type ?? string.Empty);
+                writer.Write(property.PropertyType ?? string.Empty);
                 WriteTiledMapProperties(writer, property.Properties);
             }
         }

src/cs/MonoGame.Extended.Content.Pipeline/Tiled/TiledMapWriter.cs

@@ -97,6 +97,8 @@ private void WriteLayer(ContentWriter writer, TiledMapLayerContent layer)
             switch (layer.LayerType)
             {
                 case TiledMapLayerType.ImageLayer:
+                    writer.Write(((TiledMapImageLayerContent)layer).RepeatX);
+                    writer.Write(((TiledMapImageLayerContent)layer).RepeatY);
                     WriteImageLayer(writer, (TiledMapImageLayerContent)layer);
                     break;
                 case TiledMapLayerType.TileLayer:

src/cs/MonoGame.Extended.Tiled/ContentReaderExtensions.cs

@@ -11,7 +11,10 @@ public static void ReadTiledMapProperties(this ContentReader reader, TiledMapPro
             for (var i = 0; i < count; i++)
             {
                 var key = reader.ReadString();
-                var value = new TiledMapPropertyValue(reader.ReadString());
+                var value = new TiledMapPropertyValue(
+                    reader.ReadString(),
+                    reader.ReadString(),
+                    reader.ReadString());
                 ReadTiledMapProperties(reader, value.Properties);
                 properties[key] = value;
             }

src/cs/MonoGame.Extended.Tiled/Serialization/TiledMapImageLayerContent.cs

@@ -14,10 +14,18 @@ public class TiledMapImageLayerContent : TiledMapLayerContent
         [XmlElement(ElementName = "image")]
         public TiledMapImageContent Image { get; set; }
 
+        [XmlAttribute(AttributeName = "repeatx")]
+        public bool RepeatX { get; set; }
+
+        [XmlAttribute(AttributeName = "repeaty")]
+        public bool RepeatY { get; set; }
+
         public TiledMapImageLayerContent()
             : base(TiledMapLayerType.ImageLayer)
         {
             Opacity = 1.0f;
+            RepeatX = false;
+            RepeatY = false;
             Visible = true;
             Properties = new List<TiledMapPropertyContent>();
         }

src/cs/MonoGame.Extended.Tiled/Serialization/TiledMapPropertyContent.cs

@@ -11,6 +11,12 @@ public class TiledMapPropertyContent
         [XmlAttribute(AttributeName = "value")]
         public string ValueAttribute { get; set; }
 
+        [XmlAttribute(AttributeName = "type")]
+        public string Type { get; set; }
+
+        [XmlAttribute(AttributeName = "propertytype")]
+        public string PropertyType { get; set; }
+
         [XmlText]
         public string ValueBody { get; set; }
 

src/cs/MonoGame.Extended.Tiled/TiledMapImageLayer.cs

@@ -5,14 +5,18 @@ namespace MonoGame.Extended.Tiled
 {
     public class TiledMapImageLayer : TiledMapLayer, IMovable
     {
-        public TiledMapImageLayer(string name, string type, Texture2D image, Vector2? position = null, Vector2? offset = null, Vector2? parallaxFactor = null, float opacity = 1.0f, bool isVisible = true)
+        public TiledMapImageLayer(string name, string type, Texture2D image, Vector2? position = null, Vector2? offset = null, Vector2? parallaxFactor = null, float opacity = 1.0f, bool repeatX = false, bool repeatY = false, bool isVisible = true)
             : base(name, type, offset, parallaxFactor, opacity, isVisible)
         {
             Image = image;
             Position = position ?? Vector2.Zero;
+            RepeatX = repeatX;
+            RepeatY = repeatY;
         }
 
         public Texture2D Image { get; }
         public Vector2 Position { get; set; }
+        public bool RepeatX { get; set; }
+        public bool RepeatY { get; set; }
     }
 }

src/cs/MonoGame.Extended.Tiled/TiledMapProperties.cs

@@ -7,7 +7,7 @@ public class TiledMapProperties : Dictionary<string, TiledMapPropertyValue>
         public bool TryGetValue(string key, out string value)
         {
             bool result = TryGetValue(key, out TiledMapPropertyValue tmpVal);
-            value = result ? null : tmpVal.Value;
+            value = result ? tmpVal.Value : null;
             return result;
         }
     }

src/cs/MonoGame.Extended.Tiled/TiledMapPropertyValue.cs

@@ -4,26 +4,20 @@ public class TiledMapPropertyValue
 {
     public string Value { get; }
 
-    public TiledMapProperties Properties;
+    public string Type { get; }
 
-    public TiledMapPropertyValue()
-    {
-        Value = string.Empty;
-        Properties = new();
-    }
+    public string PropertyType { get; }
 
-    public TiledMapPropertyValue(string value)
+    public TiledMapProperties Properties;
+
+    public TiledMapPropertyValue(string value, string type, string propertyType)
     {
         Value = value;
+        Type = type;
+        PropertyType = propertyType;
         Properties = new();
     }
 
-    public TiledMapPropertyValue(TiledMapProperties properties)
-    {
-        Value = string.Empty;
-        Properties = properties;
-    }
-
     public override string ToString() => Value;
 
     //public static implicit operator TiledMapPropertyValue(string value) => new(value);

src/cs/MonoGame.Extended.Tiled/TiledMapReader.cs

@@ -95,7 +95,9 @@ private static TiledMapLayer ReadLayer(ContentReader reader, TiledMap map)
             switch (layerType)
             {
                 case TiledMapLayerType.ImageLayer:
-                    layer = ReadImageLayer(reader, name, type, offset, parallaxFactor, opacity, isVisible);
+                    var repeatX = reader.ReadBoolean();
+                    var repeatY = reader.ReadBoolean();
+                    layer = ReadImageLayer(reader, name, type, offset, parallaxFactor, opacity, repeatX, repeatY, isVisible);
                     break;
                 case TiledMapLayerType.TileLayer:
                     layer = ReadTileLayer(reader, name, type, offset, parallaxFactor, opacity, isVisible, map);
@@ -195,13 +197,13 @@ private static Point2[] ReadPoints(ContentReader reader)
             return points;
         }
 
-        private static TiledMapImageLayer ReadImageLayer(ContentReader reader, string name, string type, Vector2 offset, Vector2 parallaxFactor, float opacity, bool isVisible)
+        private static TiledMapImageLayer ReadImageLayer(ContentReader reader, string name, string type, Vector2 offset, Vector2 parallaxFactor, float opacity, bool repeatX, bool repeatY, bool isVisible)
         {
             var texture = reader.ReadExternalReference<Texture2D>();
             var x = reader.ReadSingle();
             var y = reader.ReadSingle();
             var position = new Vector2(x, y);
-            return new TiledMapImageLayer(name, type, texture, position, offset, parallaxFactor, opacity, isVisible);
+            return new TiledMapImageLayer(name, type, texture, position, offset, parallaxFactor, opacity, repeatX, repeatY, isVisible);
         }
 
         private static TiledMapTileLayer ReadTileLayer(ContentReader reader, string name, string type, Vector2 offset, Vector2 parallaxFactor, float opacity, bool isVisible, TiledMap map)