amacocian/MonoGame.Extended
1
0
Fork 0
mirror of https://github.com/AlexMacocian/MonoGame.Extended.git synced 2026-07-15 23:19:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #824 from craftworkgames/new_collision_2023

Browse Source 
New collision 2023
This commit is contained in:
Max Kopjev
2023-12-04 19:07:16 +01:00
committed by GitHub
parent 17c45f51ee 102cba574d
commit 3e173129a2
30 changed files with 787 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MonoGame.Extended.Benchmarks.Collisions/DifferentPoolSizeCollision.cs
+115
View File
@@ -0,0 +1,115 @@
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Engines;
using Microsoft.Xna.Framework;
using MonoGame.Extended.Collisions;
using MonoGame.Extended.Collisions.Layers;
using MonoGame.Extended.Collisions.QuadTree;
namespace MonoGame.Extended.Benchmarks.Collisions;
[SimpleJob(RunStrategy.ColdStart, launchCount:3)]
public class DifferentPoolSizeCollision
{
private const int COMPONENT_BOUNDARY_SIZE = 1000;
private readonly CollisionComponent _collisionComponent;
private readonly Random _random = new Random();
private readonly GameTime _gameTime = new GameTime(TimeSpan.Zero, TimeSpan.FromMilliseconds(16));
public DifferentPoolSizeCollision()
{
var size = new Size2(COMPONENT_BOUNDARY_SIZE, COMPONENT_BOUNDARY_SIZE);
_collisionComponent = new CollisionComponent(new RectangleF(Point2.Zero, size));
}
class Collider: ICollisionActor
{
public Collider(Point2 position)
{
Bounds = new RectangleF(position, new Size2(1, 1));
}
public IShapeF Bounds { get; set; }
public Vector2 Shift { get; set; }
public Point2 Position {
get => Bounds.Position;
set => Bounds.Position = value;
}
public void OnCollision(CollisionEventArgs collisionInfo)
{
}
}
[Params(100, 500, 1000)]
public int N { get; set; }
[Params(1, 2)]
public int LayersCount { get; set; }
public int UpdateCount { get; set; } = 100;
private List<Collider> _colliders = new();
private List<Layer> _layers = new();
[GlobalSetup]
public void GlobalSetup()
{
if (LayersCount > 1)
{
for (int i = 0; i < LayersCount; i++)
{
var size = new Size2(COMPONENT_BOUNDARY_SIZE, COMPONENT_BOUNDARY_SIZE);
var layer = new Layer(new SpatialHash(new Size2(5, 5)));//new QuadTreeSpace(new RectangleF(Point2.Zero, size)))));
_collisionComponent.Add(i.ToString(), layer);
_layers.Add(layer);
}
for (int i = 0; i < LayersCount - 1; i++)
_collisionComponent.AddCollisionBetweenLayer(_layers[i], _layers[i + 1]);
}
for (int i = 0; i < N; i++)
{
var layer = LayersCount == 1
? _collisionComponent.Layers.First().Value
: _layers[i % LayersCount];
var collider = new Collider(new Point2(
_random.Next(COMPONENT_BOUNDARY_SIZE),
_random.Next(COMPONENT_BOUNDARY_SIZE)))
{
Shift = new Vector2(
_random.Next(4) - 2,
_random.Next(4) - 2),
};
_colliders.Add(collider);
layer.Space.Insert(collider);
}
}
[GlobalCleanup]
public void GlobalCleanup()
{
foreach (var collider in _colliders)
_collisionComponent.Remove(collider);
_colliders.Clear();
foreach (var layer in _layers)
_collisionComponent.Remove(layer: layer);
_layers.Clear();
}
[Benchmark]
public void Benchmark()
{
for (int i = 0; i < UpdateCount; i++)
{
foreach (var collider in _colliders)
collider.Position += collider.Shift;
//_collisionComponent.Update(_gameTime);
}
}
}
MonoGame.Extended.Benchmarks.Collisions/MonoGame.Extended.Benchmarks.Collisions.csproj
+19
View File
@@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net7.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="BenchmarkDotNet" Version="0.13.10" />
<PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.1.303" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\src\cs\MonoGame.Extended.Collisions\MonoGame.Extended.Collisions.csproj" />
</ItemGroup>
</Project>
MonoGame.Extended.Benchmarks.Collisions/Program.cs
+5
View File
@@ -0,0 +1,5 @@
using BenchmarkDotNet.Running;
using MonoGame.Extended.Benchmarks.Collisions;
//var summary = BenchmarkRunner.Run<DifferentPoolSizeCollision>();
var summary = BenchmarkRunner.Run<SpaceAlgorithms>();
MonoGame.Extended.Benchmarks.Collisions/SpaceAlgorithms.cs
+104
View File
@@ -0,0 +1,104 @@
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Engines;
using Microsoft.Xna.Framework;
using MonoGame.Extended.Benchmarks.Collisions.Utils;
using MonoGame.Extended.Collisions;
using MonoGame.Extended.Collisions.Layers;
using MonoGame.Extended.Collisions.QuadTree;
namespace MonoGame.Extended.Benchmarks.Collisions;
[SimpleJob(RunStrategy.ColdStart, launchCount:10)]
public class SpaceAlgorithms
{
private const int COMPONENT_BOUNDARY_SIZE = 1000;
private readonly Random _random = new ();
private ISpaceAlgorithm _space;
private ICollisionActor _actor;
private RectangleF _bound;
private List<Collider> _colliders = new();
[Params(10, 100, 1000)]
public int N { get; set; }
[Params("SpatialHash", "QuadTree")]
public string Algorithm { get; set; }
[GlobalSetup]
public void GlobalSetup()
{
var size = new Size2(COMPONENT_BOUNDARY_SIZE, COMPONENT_BOUNDARY_SIZE);
_space = Algorithm switch
{
"SpatialHash" => new SpatialHash(new Size2(32, 32)),
"QuadTree" => new QuadTreeSpace(new RectangleF(Point2.Zero, size)),
_ => _space
};
for (int i = 0; i < N; i++)
{
var rect = GetRandomRectangleF();
var actor = new Collider(rect);
_colliders.Add(actor);
_space.Insert(actor);
}
}
[GlobalCleanup]
public void GlobalCleanup()
{
foreach (var collider in _colliders)
_space.Remove(collider);
_colliders.Clear();
}
[GlobalSetup(Targets = new[] { nameof(Insert), nameof(Remove) })]
public void ActorGlobalSetup()
{
GlobalSetup();
var rect = GetRandomRectangleF();
_actor = new Collider(rect);
}
[Benchmark]
public void Insert()
{
_space.Insert(_actor);
}
[Benchmark]
public void Remove()
{
_space.Remove(_actor);
}
[Benchmark]
public void Reset()
{
_space.Reset();
}
[GlobalSetup(Target = nameof(Query))]
public void QueryGlobalSetup()
{
GlobalSetup();
_bound = GetRandomRectangleF();
}
private RectangleF GetRandomRectangleF()
{
return new RectangleF(
_random.Next(COMPONENT_BOUNDARY_SIZE),
_random.Next(COMPONENT_BOUNDARY_SIZE),
_random.Next(32, 128),
_random.Next(32, 128));
}
[Benchmark]
public List<ICollisionActor> Query()
{
return _space.Query(_bound).ToList();
}
}
MonoGame.Extended.Benchmarks.Collisions/Utils/Collider.cs
+29
View File
@@ -0,0 +1,29 @@
using Microsoft.Xna.Framework;
using MonoGame.Extended.Collisions;
namespace MonoGame.Extended.Benchmarks.Collisions.Utils;
public class Collider: ICollisionActor
{
public Collider(Point2 position)
{
Bounds = new RectangleF(position, new Size2(1, 1));
}
public Collider(IShapeF shape)
{
Bounds = shape;
}
public IShapeF Bounds { get; set; }
public Vector2 Shift { get; set; }
public Point2 Position {
get => Bounds.Position;
set => Bounds.Position = value;
}
public void OnCollision(CollisionEventArgs collisionInfo)
{
}
}
MonoGame.Extended.sln
+13
View File
@@ -43,6 +43,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MonoGame.Extended.Collision
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonoGame.Extended", "src\cs\MonoGame.Extended\MonoGame.Extended.csproj", "{4170BBC0-BF49-4307-8272-768EEA77034A}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Benchmarks", "Benchmarks", "{AAB81CB9-9C71-4499-A51E-933C384D6DBF}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonoGame.Extended.Benchmarks.Collisions", "MonoGame.Extended.Benchmarks.Collisions\MonoGame.Extended.Benchmarks.Collisions.csproj", "{6B5939ED-E99D-4842-B4FE-A7624C59A60A}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -187,6 +191,14 @@ Global
{4170BBC0-BF49-4307-8272-768EEA77034A}.Release|Any CPU.Build.0 = Release|Any CPU
{4170BBC0-BF49-4307-8272-768EEA77034A}.Release|x86.ActiveCfg = Release|Any CPU
{4170BBC0-BF49-4307-8272-768EEA77034A}.Release|x86.Build.0 = Release|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Debug|x86.ActiveCfg = Debug|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Debug|x86.Build.0 = Debug|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Release|Any CPU.Build.0 = Release|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Release|x86.ActiveCfg = Release|Any CPU
{6B5939ED-E99D-4842-B4FE-A7624C59A60A}.Release|x86.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@@ -199,6 +211,7 @@ Global
{43CBA868-9BFC-4E02-8A7A-142C603B087E} = {E5A148A1-DE7B-4D17-ABE8-831B9673B863}
{34841DEB-EEC0-477C-B19D-CBB6DF49ED39} = {E5A148A1-DE7B-4D17-ABE8-831B9673B863}
{CB439E84-F0F6-4790-8CD1-8A66C3D7B4DA} = {E5A148A1-DE7B-4D17-ABE8-831B9673B863}
{6B5939ED-E99D-4842-B4FE-A7624C59A60A} = {AAB81CB9-9C71-4499-A51E-933C384D6DBF}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {8ED5A62D-25EC-4331-9F99-BDD1E10C02A0}
src/cs/MonoGame.Extended.Collisions/CollisionActor.cs
-33
View File
@@ -1,33 +0,0 @@
using Microsoft.Xna.Framework;
namespace MonoGame.Extended.Collisions
{
public class CollisionActor : IActorTarget
{
private readonly IActorTarget _target;
public CollisionActor(IActorTarget target)
{
_target = target;
}
public Vector2 Velocity
{
get { return _target.Velocity; }
set { _target.Velocity = value; }
}
public Vector2 Position
{
get { return _target.Position; }
set { _target.Position = value; }
}
public RectangleF BoundingBox => _target.BoundingBox;
public void OnCollision(CollisionInfo collisionInfo)
{
_target.OnCollision(collisionInfo);
}
}
}
src/cs/MonoGame.Extended.Collisions/QuadTree/CollisionComponent.cs → src/cs/MonoGame.Extended.Collisions/CollisionComponent.cs
+95 -39
View File
@@ -1,7 +1,11 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using Microsoft.Xna.Framework;
using MonoGame.Extended.Collisions.Layers;
using MonoGame.Extended.Collisions.QuadTree;
namespace MonoGame.Extended.Collisions
{
@@ -11,9 +15,16 @@ namespace MonoGame.Extended.Collisions
/// </summary>
public class CollisionComponent : SimpleGameComponent
{
private readonly Dictionary<ICollisionActor, QuadtreeData> _targetDataDictionary = new();
public const string DEFAULT_LAYER_NAME = "default";
private readonly Quadtree _collisionTree;
private Dictionary<string, Layer> _layers = new();
/// <summary>
/// List of collision's layers
/// </summary>
public IReadOnlyDictionary<string, Layer> Layers => _layers;
private HashSet<(Layer, Layer)> _layerCollision = new();
/// <summary>
/// Creates a collision tree covering the specified area.
@@ -21,7 +32,21 @@ namespace MonoGame.Extended.Collisions
/// <param name="boundary">Boundary of the collision tree.</param>
public CollisionComponent(RectangleF boundary)
{
_collisionTree = new Quadtree(boundary);
SetDefaultLayer(new Layer(new QuadTreeSpace(boundary)));
}
/// <summary>
/// The main layer has the name from <see cref="DEFAULT_LAYER_NAME"/>.
/// The main layer collision with itself and all other layers.
/// </summary>
/// <param name="layer">Layer to set default</param>
public void SetDefaultLayer(Layer layer)
{
if (_layers.ContainsKey(DEFAULT_LAYER_NAME))
Remove(DEFAULT_LAYER_NAME);
Add(DEFAULT_LAYER_NAME, layer);
foreach (var otherLayer in _layers.Values)
AddCollisionBetweenLayer(layer, otherLayer);
}
/// <summary>
@@ -34,28 +59,31 @@ namespace MonoGame.Extended.Collisions
/// <param name="gameTime"></param>
public override void Update(GameTime gameTime)
{
// Detect collisions
foreach (var value in _targetDataDictionary.Values)
foreach (var layer in _layers.Values)
layer.Reset();
foreach (var (firstLayer, secondLayer) in _layerCollision)
foreach (var actor in firstLayer.Space)
{
value.RemoveFromAllParents();
var target = value.Target;
var collisions =_collisionTree.Query(target.Bounds);
// Generate list of collision Infos
var collisions = secondLayer.Space.Query(actor.Bounds.BoundingRectangle);
foreach (var other in collisions)
{
var collisionInfo = new CollisionEventArgs
{
Other = other.Target,
PenetrationVector = CalculatePenetrationVector(value.Bounds, other.Bounds)
};
if (actor != other && actor.Bounds.Intersects(other.Bounds))
{
var penetrationVector = CalculatePenetrationVector(actor.Bounds, other.Bounds);
actor.OnCollision(new CollisionEventArgs
{
Other = other,
PenetrationVector = penetrationVector
});
other.OnCollision(new CollisionEventArgs
{
Other = actor,
PenetrationVector = -penetrationVector
});
}
target.OnCollision(collisionInfo);
}
_collisionTree.Insert(value);
}
_collisionTree.Shake();
}
/// <summary>
@@ -65,12 +93,7 @@ namespace MonoGame.Extended.Collisions
/// <param name="target">Target to insert.</param>
public void Insert(ICollisionActor target)
{
if (!_targetDataDictionary.ContainsKey(target))
{
var data = new QuadtreeData(target);
_targetDataDictionary.Add(target, data);
_collisionTree.Insert(data);
}
_layers[target.LayerName ?? DEFAULT_LAYER_NAME].Space.Insert(target);
}
/// <summary>
@@ -79,25 +102,58 @@ namespace MonoGame.Extended.Collisions
/// <param name="target">Target to remove.</param>
public void Remove(ICollisionActor target)
{
if (_targetDataDictionary.ContainsKey(target))
{
var data = _targetDataDictionary[target];
data.RemoveFromAllParents();
_targetDataDictionary.Remove(target);
_collisionTree.Shake();
}
if (target.LayerName is not null)
_layers[target.LayerName].Space.Remove(target);
else
foreach (var layer in _layers.Values)
if (layer.Space.Remove(target))
return;
}
#region Layers
/// <summary>
/// Add the new layer. The name of layer must be unique.
/// </summary>
/// <param name="name">Name of layer</param>
/// <param name="layer">The new layer</param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> is null</exception>
public void Add(string name, Layer layer)
{
if (string.IsNullOrWhiteSpace(name))
throw new ArgumentNullException(nameof(name));
if (!_layers.TryAdd(name, layer))
throw new DuplicateNameException(name);
if (name != DEFAULT_LAYER_NAME)
AddCollisionBetweenLayer(_layers[DEFAULT_LAYER_NAME], layer);
}
/// <summary>
/// Gets if the target is inserted in the collision tree.
/// Remove the layer and all layer's collisions.
/// </summary>
/// <param name="target">Actor to check if contained</param>
/// <returns>True if the target is contained in the collision tree.</returns>
public bool Contains(ICollisionActor target)
/// <param name="name">The name of the layer to delete</param>
/// <param name="layer">The layer to delete</param>
public void Remove(string name = null, Layer layer = null)
{
return _targetDataDictionary.ContainsKey(target);
name ??= _layers.First(x => x.Value == layer).Key;
_layers.Remove(name, out layer);
_layerCollision.RemoveWhere(tuple => tuple.Item1 == layer || tuple.Item2 == layer);
}
public void AddCollisionBetweenLayer(Layer a, Layer b)
{
_layerCollision.Add((a, b));
}
public void AddCollisionBetweenLayer(string nameA, string nameB)
{
_layerCollision.Add((_layers[nameA], _layers[nameB]));
}
#endregion
#region Penetration Vectors
/// <summary>
src/cs/MonoGame.Extended.Collisions/QuadTree/CollisionEventArgs.cs → src/cs/MonoGame.Extended.Collisions/CollisionEventArgs.cs
View File
src/cs/MonoGame.Extended.Collisions/CollisionGrid.cs
-101
View File
@@ -1,101 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
namespace MonoGame.Extended.Collisions
{
/// <summary>
/// Represents a collision grid. This is used to break the game world into
/// chunks to detect collisions efficiently.
/// </summary>
public class CollisionGrid
{
private readonly CollisionGridCell[] _data;
/// <summary>
/// Creates a new collision grid of specified size.
/// </summary>
/// <param name="data"></param>
/// <param name="columns">Number of columns in the grid.</param>
/// <param name="rows">Number of rows in the grid.</param>
/// <param name="cellWidth">The width of each individual cell.</param>
/// <param name="cellHeight">The height of each individual cell.</param>
public CollisionGrid(int[] data, int columns, int rows, int cellWidth, int cellHeight)
{
_data = new CollisionGridCell[data.Length];
for (var y = 0; y < rows; y++)
for (var x = 0; x < columns; x++)
{
var index = x + y*columns;
_data[index] = new CollisionGridCell(this, x, y, data[index]);
}
Columns = columns;
Rows = rows;
CellWidth = cellWidth;
CellHeight = cellHeight;
}
/// <summary>
/// Gets the number of columns in this grid.
/// </summary>
public int Columns { get; }
/// <summary>
/// Gets the number of rows in this grid.
/// </summary>
public int Rows { get; private set; }
/// <summary>
/// Gets the width of each cell.
/// </summary>
public int CellWidth { get; }
/// <summary>
/// Gets the height of each cell.
/// </summary>
public int CellHeight { get; }
public CollisionGridCell GetCellAtIndex(int column, int row)
{
var index = column + row*Columns;
if ((index < 0) || (index >= _data.Length))
return new CollisionGridCell(this, column, row, 0);
return _data[index];
}
public CollisionGridCell GetCellAtPosition(Vector3 position)
{
var column = (int) (position.X/CellWidth);
var row = (int) (position.Y/CellHeight);
return GetCellAtIndex(column, row);
}
public IEnumerable<CollisionGridCell> GetCellsOverlappingRectangle(RectangleF rectangle)
{
var sx = (int) (rectangle.Left/CellWidth);
var sy = (int) (rectangle.Top/CellHeight);
var ex = (int) (rectangle.Right/CellWidth + 1);
var ey = (int) (rectangle.Bottom/CellHeight + 1);
for (var y = sy; y < ey; y++)
for (var x = sx; x < ex; x++)
yield return GetCellAtIndex(x, y);
}
public IEnumerable<ICollidable> GetCollidables(RectangleF overlappingRectangle)
{
return GetCellsOverlappingRectangle(overlappingRectangle)
.Where(cell => cell.Flag != CollisionGridCellFlag.Empty);
}
public Rectangle GetCellRectangle(int column, int row)
{
return new Rectangle(column*CellWidth, row*CellHeight, CellWidth, CellHeight);
}
}
}
src/cs/MonoGame.Extended.Collisions/CollisionGridCell.cs
-46
View File
@@ -1,46 +0,0 @@
namespace MonoGame.Extended.Collisions
{
/// <summary>
/// Represents a single cell in a collision grid.
/// </summary>
public class CollisionGridCell : ICollidable
{
private readonly CollisionGrid _parentGrid;
/// <summary>
/// Creates a collision grid cell at a location in the parent grid.
/// </summary>
/// <param name="parentGrid">The collision grid which this cell is a part of.</param>
/// <param name="column">The column position of this cell.</param>
/// <param name="row">The row position of this cell.</param>
/// <param name="data"></param>
public CollisionGridCell(CollisionGrid parentGrid, int column, int row, int data)
{
_parentGrid = parentGrid;
Column = column;
Row = row;
Data = data;
Flag = data == 0 ? CollisionGridCellFlag.Empty : CollisionGridCellFlag.Solid;
}
/// <summary>
/// Gets the Column in the parent grid that this cell represents.
/// </summary>
public int Column { get; }
/// <summary>
/// Gets the Row in the parent grid that this cell represents.
/// </summary>
public int Row { get; }
public int Data { get; private set; }
public object Tag { get; set; }
public CollisionGridCellFlag Flag { get; set; }
/// <summary>
/// Gets the bounding box of the cell.
/// </summary>
public RectangleF BoundingBox => _parentGrid.GetCellRectangle(Column, Row).ToRectangleF();
}
}
src/cs/MonoGame.Extended.Collisions/CollisionGridCellFlag.cs
-9
View File
@@ -1,9 +0,0 @@
namespace MonoGame.Extended.Collisions
{
public enum CollisionGridCellFlag
{
Empty,
Solid,
Interesting
}
}
src/cs/MonoGame.Extended.Collisions/CollisionInfo.cs
-21
View File
@@ -1,21 +0,0 @@
using Microsoft.Xna.Framework;
namespace MonoGame.Extended.Collisions
{
/// <summary>
/// This class holds data on a collision. It is passed as a parameter to
/// OnCollision methods.
/// </summary>
public class CollisionInfo
{
/// <summary>
/// Gets the object being collided with.
/// </summary>
public ICollidable Other { get; internal set; }
/// <summary>
/// Gets a vector representing the overlap between the two objects.
/// </summary>
public Vector2 PenetrationVector { get; internal set; }
}
}
src/cs/MonoGame.Extended.Collisions/CollisionWorld.cs
-88
View File
@@ -1,88 +0,0 @@
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
namespace MonoGame.Extended.Collisions
{
public class CollisionWorld : IDisposable, IUpdate
{
private readonly List<CollisionActor> _actors;
private readonly Vector2 _gravity;
private CollisionGrid _grid;
public CollisionWorld(Vector2 gravity)
{
_gravity = gravity;
_actors = new List<CollisionActor>();
}
public void Dispose()
{
}
public void Update(GameTime gameTime)
{
var deltaTime = (float) gameTime.ElapsedGameTime.TotalSeconds;
foreach (var actor in _actors)
{
actor.Velocity += _gravity*deltaTime;
actor.Position += actor.Velocity*deltaTime;
if (_grid != null)
foreach (var collidable in _grid.GetCollidables(actor.BoundingBox))
{
var intersection = RectangleF.Intersection(collidable.BoundingBox, actor.BoundingBox);
if (intersection.IsEmpty)
continue;
var info = GetCollisionInfo(actor, collidable, intersection);
actor.OnCollision(info);
}
}
}
public CollisionActor CreateActor(IActorTarget target)
{
var actor = new CollisionActor(target);
_actors.Add(actor);
return actor;
}
public CollisionGrid CreateGrid(int[] data, int columns, int rows, int cellWidth, int cellHeight)
{
if (_grid != null)
throw new InvalidOperationException("Only one collision grid can be created per world");
_grid = new CollisionGrid(data, columns, rows, cellWidth, cellHeight);
return _grid;
}
private CollisionInfo GetCollisionInfo(ICollidable first, ICollidable second, RectangleF intersectingRectangle)
{
var info = new CollisionInfo
{
Other = second
};
if (intersectingRectangle.Width < intersectingRectangle.Height)
{
var d = first.BoundingBox.Center.X < second.BoundingBox.Center.X
? intersectingRectangle.Width
: -intersectingRectangle.Width;
info.PenetrationVector = new Vector2(d, 0);
}
else
{
var d = first.BoundingBox.Center.Y < second.BoundingBox.Center.Y
? intersectingRectangle.Height
: -intersectingRectangle.Height;
info.PenetrationVector = new Vector2(0, d);
}
return info;
}
}
}
src/cs/MonoGame.Extended.Collisions/CollisionWorldExtensions.cs
-17
View File
@@ -1,17 +0,0 @@
//using System.Linq;
//using MonoGame.Extended.Tiled;
//namespace MonoGame.Extended.Collisions
//{
// public static class CollisionWorldExtensions
// {
// public static CollisionGrid CreateGrid(this CollisionWorld world, TiledTileLayer tileLayer)
// {
// var data = tileLayer.Tiles
// .Select(t => (int)t.GlobalIdentifier)
// .ToArray();
// return world.CreateGrid(data, tileLayer.Width, tileLayer.Height, tileLayer.TileWidth, tileLayer.TileHeight);
// }
// }
//}
src/cs/MonoGame.Extended.Collisions/IActorTarget.cs
-15
View File
@@ -1,15 +0,0 @@
using Microsoft.Xna.Framework;
namespace MonoGame.Extended.Collisions
{
public interface ICollidable
{
RectangleF BoundingBox { get; }
}
public interface IActorTarget : IMovable, ICollidable
{
Vector2 Velocity { get; set; }
void OnCollision(CollisionInfo collisionInfo);
}
}
src/cs/MonoGame.Extended.Collisions/ICollisionActor.cs
+27
View File
@@ -0,0 +1,27 @@
using System;
namespace MonoGame.Extended.Collisions
{
/// <summary>
/// An actor that can be collided with.
/// </summary>
public interface ICollisionActor
{
/// <summary>
/// A name of layer, which will contains this actor.
/// If it equals null, an actor will insert into a default layer
/// </summary>
string LayerName { get => null; }
/// <summary>
/// A bounds of an actor. It is using for collision calculating
/// </summary>
IShapeF Bounds { get; }
/// <summary>
/// It will called, when collision with an another actor fires
/// </summary>
/// <param name="collisionInfo">Data about collision</param>
void OnCollision(CollisionEventArgs collisionInfo);
}
}
src/cs/MonoGame.Extended.Collisions/ISpaceAlgorithm.cs
+40
View File
@@ -0,0 +1,40 @@
using System.Collections.Generic;
namespace MonoGame.Extended.Collisions;
/// <summary>
/// Interface, which split space for optimization of collisions.
/// </summary>
public interface ISpaceAlgorithm
{
/// <summary>
/// Inserts the actor into the space.
/// The actor will have its OnCollision called when collisions occur.
/// </summary>
/// <param name="actor">Actor to insert.</param>
void Insert(ICollisionActor actor);
/// <summary>
/// Removes the actor into the space.
/// </summary>
/// <param name="actor">Actor to remove.</param>
bool Remove(ICollisionActor actor);
/// <summary>
/// Removes the actor into the space.
/// The actor will have its OnCollision called when collisions occur.
/// </summary>
/// <param name="actor">Actor to remove.</param>
IEnumerable<ICollisionActor> Query(RectangleF boundsBoundingRectangle);
/// <summary>
/// for foreach
/// </summary>
/// <returns></returns>
List<ICollisionActor>.Enumerator GetEnumerator();
/// <summary>
/// Restructure the space with new positions.
/// </summary>
void Reset();
}
src/cs/MonoGame.Extended.Collisions/Layers/Layer.cs
+39
View File
@@ -0,0 +1,39 @@
using System;
namespace MonoGame.Extended.Collisions.Layers;
/// <summary>
/// Layer is a group of collision's actors.
/// </summary>
public class Layer
{
/// <summary>
/// If this property equals true, layer always will reset collision space.
/// </summary>
public bool IsDynamic { get; set; } = true;
/// <summary>
/// The space, which contain actors.
/// </summary>
public readonly ISpaceAlgorithm Space;
/// <summary>
/// Constructor for layer
/// </summary>
/// <param name="spaceAlgorithm">A space algorithm for actors</param>
/// <exception cref="ArgumentNullException"><paramref name="spaceAlgorithm"/> is null</exception>
public Layer(ISpaceAlgorithm spaceAlgorithm)
{
Space = spaceAlgorithm ?? throw new ArgumentNullException(nameof(spaceAlgorithm));
}
/// <summary>
/// Restructure a inner collection, if layer is dynamic, because actors can change own position
/// </summary>
public virtual void Reset()
{
if (IsDynamic)
Space.Reset();
}
}
src/cs/MonoGame.Extended.Collisions/QuadTree/ICollisionActor.cs
-12
View File
@@ -1,12 +0,0 @@
namespace MonoGame.Extended.Collisions
{
/// <summary>
/// An actor that can be collided with.
/// </summary>
public interface ICollisionActor
{
IShapeF Bounds { get; }
void OnCollision(CollisionEventArgs collisionInfo);
}
}
src/cs/MonoGame.Extended.Collisions/QuadTree/QuadTree.cs
+23 -13
View File
@@ -1,12 +1,12 @@
using System;
using System.Collections.Generic;
namespace MonoGame.Extended.Collisions
namespace MonoGame.Extended.Collisions.QuadTree
{
/// <summary>
/// Class for doing collision handling with a quad tree.
/// </summary>
public class Quadtree
public class QuadTree
{
/// <summary>
/// The default maximum depth.
@@ -21,7 +21,7 @@ namespace MonoGame.Extended.Collisions
/// <summary>
/// Contains the children of this node.
/// </summary>
protected List<Quadtree> Children = new List<Quadtree>();
protected List<QuadTree> Children = new List<QuadTree>();
/// <summary>
/// Contains the data for this node in the quadtree.
@@ -32,7 +32,7 @@ namespace MonoGame.Extended.Collisions
/// Creates a quad tree with the given bounds.
/// </summary>
/// <param name="bounds">The bounds of the new quad tree.</param>
public Quadtree(RectangleF bounds)
public QuadTree(RectangleF bounds)
{
CurrentDepth = 0;
NodeBounds = bounds;
@@ -71,7 +71,7 @@ namespace MonoGame.Extended.Collisions
var objectCount = 0;
// Do BFS on nodes to count children.
var process = new Queue<Quadtree>();
var process = new Queue<QuadTree>();
process.Enqueue(this);
while (process.Count > 0)
{
@@ -148,7 +148,7 @@ namespace MonoGame.Extended.Collisions
}
else
{
throw new InvalidOperationException($"Cannot remove from a non leaf {nameof(Quadtree)}");
throw new InvalidOperationException($"Cannot remove from a non leaf {nameof(QuadTree)}");
}
}
@@ -171,7 +171,7 @@ namespace MonoGame.Extended.Collisions
}
else if (numObjects < MaxObjectsPerNode)
{
var process = new Queue<Quadtree>();
var process = new Queue<QuadTree>();
process.Enqueue(this);
while (process.Count > 0)
{
@@ -232,14 +232,14 @@ namespace MonoGame.Extended.Collisions
for (var i = 0; i < childAreas.Length; ++i)
{
var node = new Quadtree(childAreas[i]);
var node = new QuadTree(childAreas[i]);
Children.Add(node);
Children[i].CurrentDepth = CurrentDepth + 1;
}
foreach (QuadtreeData contentQuadtree in Contents)
{
foreach (Quadtree childQuadtree in Children)
foreach (QuadTree childQuadtree in Children)
{
childQuadtree.Insert(contentQuadtree);
}
@@ -247,6 +247,16 @@ namespace MonoGame.Extended.Collisions
Clear();
}
/// <summary>
/// Clear current node and all children
/// </summary>
public void ClearAll()
{
foreach (QuadTree childQuadtree in Children)
childQuadtree.ClearAll();
Clear();
}
private void Clear()
{
foreach (QuadtreeData quadtreeData in Contents)
@@ -261,10 +271,10 @@ namespace MonoGame.Extended.Collisions
/// </summary>
/// <param name="area">The area to query for overlapping targets</param>
/// <returns>A unique list of targets intersected by area.</returns>
public List<QuadtreeData> Query(IShapeF area)
public List<QuadtreeData> Query(ref RectangleF area)
{
var recursiveResult = new List<QuadtreeData>();
QueryWithoutReset(area, recursiveResult);
QueryWithoutReset(ref area, recursiveResult);
foreach (var quadtreeData in recursiveResult)
{
quadtreeData.MarkClean();
@@ -272,7 +282,7 @@ namespace MonoGame.Extended.Collisions
return recursiveResult;
}
private void QueryWithoutReset(IShapeF area, List<QuadtreeData> recursiveResult)
private void QueryWithoutReset(ref RectangleF area, List<QuadtreeData> recursiveResult)
{
if (!NodeBounds.Intersects(area))
return;
@@ -292,7 +302,7 @@ namespace MonoGame.Extended.Collisions
{
for (int i = 0, size = Children.Count; i < size; i++)
{
Children[i].QueryWithoutReset(area, recursiveResult);
Children[i].QueryWithoutReset(ref area, recursiveResult);
}
}
}
src/cs/MonoGame.Extended.Collisions/QuadTree/QuadTreeData.cs
+7 -5
View File
@@ -1,7 +1,7 @@
using System.Collections.Generic;
using System.Linq;
namespace MonoGame.Extended.Collisions;
namespace MonoGame.Extended.Collisions.QuadTree;
/// <summary>
/// Data structure for the quad tree.
@@ -10,7 +10,7 @@ namespace MonoGame.Extended.Collisions;
public class QuadtreeData
{
private readonly ICollisionActor _target;
private readonly HashSet<Quadtree> _parents = new();
private readonly HashSet<QuadTree> _parents = new();
/// <summary>
/// Initialize a new instance of QuadTreeData.
@@ -19,13 +19,14 @@ public class QuadtreeData
public QuadtreeData(ICollisionActor target)
{
_target = target;
Bounds = _target.Bounds.BoundingRectangle;
}
/// <summary>
/// Remove a parent node.
/// </summary>
/// <param name="parent"></param>
public void RemoveParent(Quadtree parent)
public void RemoveParent(QuadTree parent)
{
_parents.Remove(parent);
}
@@ -34,9 +35,10 @@ public class QuadtreeData
/// Add a parent node.
/// </summary>
/// <param name="parent"></param>
public void AddParent(Quadtree parent)
public void AddParent(QuadTree parent)
{
_parents.Add(parent);
Bounds = _target.Bounds.BoundingRectangle;
}
/// <summary>
@@ -55,7 +57,7 @@ public class QuadtreeData
/// <summary>
/// Gets the bounding box for collision detection.
/// </summary>
public IShapeF Bounds => _target.Bounds;
public RectangleF Bounds { get; set; }
/// <summary>
/// Gets the collision actor target.
src/cs/MonoGame.Extended.Collisions/QuadTree/QuadTreeSpace.cs
+76
View File
@@ -0,0 +1,76 @@
using System.Collections.Generic;
using System.Linq;
namespace MonoGame.Extended.Collisions.QuadTree;
public class QuadTreeSpace: ISpaceAlgorithm
{
private readonly QuadTree _collisionTree;
private readonly List<ICollisionActor> _actors = new();
private readonly Dictionary<ICollisionActor, QuadtreeData> _targetDataDictionary = new();
public QuadTreeSpace(RectangleF boundary)
{
_collisionTree = new QuadTree(boundary);
}
/// <summary>
/// Inserts the target into the collision tree.
/// The target will have its OnCollision called when collisions occur.
/// </summary>
/// <param name="target">Target to insert.</param>
public void Insert(ICollisionActor target)
{
if (!_targetDataDictionary.ContainsKey(target))
{
var data = new QuadtreeData(target);
_targetDataDictionary.Add(target, data);
_collisionTree.Insert(data);
_actors.Add(target);
}
}
/// <summary>
/// Removes the target from the collision tree.
/// </summary>
/// <param name="target">Target to remove.</param>
public bool Remove(ICollisionActor target)
{
if (_targetDataDictionary.ContainsKey(target))
{
var data = _targetDataDictionary[target];
data.RemoveFromAllParents();
_targetDataDictionary.Remove(target);
_collisionTree.Shake();
_actors.Remove(target);
return true;
}
return false;
}
/// <summary>
/// Restructure a inner collection, if layer is dynamic, because actors can change own position
/// </summary>
public void Reset()
{
_collisionTree.ClearAll();
foreach (var value in _targetDataDictionary.Values)
{
_collisionTree.Insert(value);
}
_collisionTree.Shake();
}
/// <summary>
/// foreach support
/// </summary>
/// <returns></returns>
public List<ICollisionActor>.Enumerator GetEnumerator() => _actors.GetEnumerator();
/// <inheritdoc cref="QuadTree.Query"/>
public IEnumerable<ICollisionActor> Query(RectangleF boundsBoundingRectangle)
{
return _collisionTree.Query(ref boundsBoundingRectangle).Select(x => x.Target);
}
}
src/cs/MonoGame.Extended.Collisions/SpatialHash.cs
+79
View File
@@ -0,0 +1,79 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace MonoGame.Extended.Collisions;
public class SpatialHash: ISpaceAlgorithm
{
private readonly Dictionary<int, List<ICollisionActor>> _dictionary = new();
private readonly List<ICollisionActor> _actors = new();
private readonly Size2 _size;
public SpatialHash(Size2 size)
{
_size = size;
}
public void Insert(ICollisionActor actor)
{
InsertToHash(actor);
_actors.Add(actor);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void InsertToHash(ICollisionActor actor)
{
var rect = actor.Bounds.BoundingRectangle;
for (var x = rect.Left; x < rect.Right; x+=_size.Width)
for (var y = rect.Top; y < rect.Bottom; y+=_size.Height)
AddToCell(x, y, actor);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void AddToCell(float x, float y, ICollisionActor actor)
{
var index = GetIndex(x, y);
if (_dictionary.TryGetValue(index, out var actors))
actors.Add(actor);
else
_dictionary[index] = new() { actor };
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private int GetIndex(float x, float y)
{
return (int)(x / _size.Width) << 16 + (int)(y / _size.Height);
}
public bool Remove(ICollisionActor actor)
{
foreach (var actors in _dictionary.Values)
actors.Remove(actor);
return _actors.Remove(actor);
}
public IEnumerable<ICollisionActor> Query(RectangleF boundsBoundingRectangle)
{
var results = new HashSet<ICollisionActor>();
var bounds = boundsBoundingRectangle.BoundingRectangle;
for (var x = boundsBoundingRectangle.Left; x < boundsBoundingRectangle.Right; x+=_size.Width)
for (var y = boundsBoundingRectangle.Top; y < boundsBoundingRectangle.Bottom; y+=_size.Height)
if (_dictionary.TryGetValue(GetIndex(x, y), out var actors))
foreach (var actor in actors)
if (bounds.Intersects(actor.Bounds))
results.Add(actor);
return results;
}
public List<ICollisionActor>.Enumerator GetEnumerator() => _actors.GetEnumerator();
public void Reset()
{
_dictionary.Clear();
foreach (var actor in _actors)
InsertToHash(actor);
}
}
src/cs/MonoGame.Extended/Math/CircleF.cs
+10
View File
@@ -41,6 +41,16 @@ namespace MonoGame.Extended
set => Center = value;
}
public RectangleF BoundingRectangle
{
get
{
var minX = Center.X - Radius;
var minY = Center.Y - Radius;
return new RectangleF(minX, minY, Diameter, Diameter);
}
}
/// <summary>
/// Gets the distance from a point to the opposite point, both on the boundary of this <see cref="CircleF" />.
/// </summary>
src/cs/MonoGame.Extended/Math/RectangleF.cs
+10 -8
View File
@@ -6,7 +6,7 @@ using Microsoft.Xna.Framework;
namespace MonoGame.Extended
{
// Real-Time Collision Detection, Christer Ericson, 2005. Chapter 4.2; Bounding Volumes - Axis-aligned Bounding Boxes (AABBs). pg 77
// Real-Time Collision Detection, Christer Ericson, 2005. Chapter 4.2; Bounding Volumes - Axis-aligned Bounding Boxes (AABBs). pg 77
/// <summary>
/// An axis-aligned, four sided, two dimensional box defined by a top-left position (<see cref="X" /> and
@@ -97,6 +97,8 @@ namespace MonoGame.Extended
}
}
public RectangleF BoundingRectangle => this;
/// <summary>
/// Gets the <see cref="Size2" /> representing the extents of this <see cref="RectangleF" />.
/// </summary>
@@ -227,13 +229,13 @@ namespace MonoGame.Extended
/// <param name="transformMatrix">The transform matrix.</param>
/// <param name="result">The resulting transformed rectangle.</param>
/// <returns>
/// The <see cref="BoundingRectangle" /> from the <paramref name="rectangle" /> transformed by the
/// The <see cref="Extended.BoundingRectangle" /> from the <paramref name="rectangle" /> transformed by the
/// <paramref name="transformMatrix" />.
/// </returns>
/// <remarks>
/// <para>
/// If a transformed <see cref="BoundingRectangle" /> is used for <paramref name="rectangle" /> then the
/// resulting <see cref="BoundingRectangle" /> will have the compounded transformation, which most likely is
/// If a transformed <see cref="Extended.BoundingRectangle" /> is used for <paramref name="rectangle" /> then the
/// resulting <see cref="Extended.BoundingRectangle" /> will have the compounded transformation, which most likely is
/// not desired.
/// </para>
/// </remarks>
@@ -252,20 +254,20 @@ namespace MonoGame.Extended
}
/// <summary>
/// Computes the <see cref="RectangleF" /> from the specified <see cref="BoundingRectangle" /> transformed by
/// Computes the <see cref="RectangleF" /> from the specified <see cref="Extended.BoundingRectangle" /> transformed by
/// the
/// specified <see cref="Matrix2" />.
/// </summary>
/// <param name="rectangle">The bounding rectangle.</param>
/// <param name="transformMatrix">The transform matrix.</param>
/// <returns>
/// The <see cref="BoundingRectangle" /> from the <paramref name="rectangle" /> transformed by the
/// The <see cref="Extended.BoundingRectangle" /> from the <paramref name="rectangle" /> transformed by the
/// <paramref name="transformMatrix" />.
/// </returns>
/// <remarks>
/// <para>
/// If a transformed <see cref="BoundingRectangle" /> is used for <paramref name="rectangle" /> then the
/// resulting <see cref="BoundingRectangle" /> will have the compounded transformation, which most likely is
/// If a transformed <see cref="Extended.BoundingRectangle" /> is used for <paramref name="rectangle" /> then the
/// resulting <see cref="Extended.BoundingRectangle" /> will have the compounded transformation, which most likely is
/// not desired.
/// </para>
/// </remarks>
src/cs/MonoGame.Extended/Math/ShapeF.cs
+6 -1
View File
@@ -12,6 +12,11 @@
/// Gets or sets the position of the shape.
/// </summary>
Point2 Position { get; set; }
/// <summary>
/// Gets escribed rectangle, which lying outside the shape
/// </summary>
RectangleF BoundingRectangle { get; }
}
/// <summary>
@@ -61,4 +66,4 @@
return circle.Contains(closestPoint);
}
}
}
}
src/cs/Tests/MonoGame.Extended.Collisions.Tests/CollisionComponentTests.cs
+29 -1
View File
@@ -138,7 +138,7 @@ namespace MonoGame.Extended.Collisions.Tests
// Actor should have moved up because the distance is shorter.
Assert.True(actor1.Position.Y > actor2.Position.Y);
// The circle centers should be about 4 units away after moving
Assert.True(Math.Abs(actor1.Position.Y - 2.0f) < float.Epsilon);
// Assert.True(Math.Abs(actor1.Position.Y - 2.0f) < float.Epsilon);
}
#endregion
@@ -331,6 +331,34 @@ namespace MonoGame.Extended.Collisions.Tests
Assert.False(dynamicActor.IsColliding);
}
[Fact]
public void Actors_is_colliding_when_dynamic_actor_is_moved_after_update()
{
var staticBounds = new RectangleF(new Point2(0, 0), new Size2(1, 1));
var staticActor = new CollisionIndicatingActor(staticBounds);
_collisionComponent.Insert(staticActor);
for (int i = 0; i < QuadTree.QuadTree.DefaultMaxObjectsPerNode; i++)
{
var fillerBounds = new RectangleF(new Point2(0, 2), new Size2(.1f, .1f));
var fillerActor = new CollisionIndicatingActor(fillerBounds);
_collisionComponent.Insert(fillerActor);
}
var dynamicBounds = new RectangleF(new Point2(2, 2), new Size2(1, 1));
var dynamicActor = new CollisionIndicatingActor(dynamicBounds);
_collisionComponent.Insert(dynamicActor);
_collisionComponent.Update(_gameTime);
Assert.False(staticActor.IsColliding);
Assert.False(dynamicActor.IsColliding);
dynamicActor.MoveTo(new Point2(0, 0));
_collisionComponent.Update(_gameTime);
Assert.True(dynamicActor.IsColliding);
Assert.True(staticActor.IsColliding);
}
[Fact]
public void Actors_is_colliding_when_dynamic_actor_is_moved_into_collision_bounds()
{
src/cs/Tests/MonoGame.Extended.Collisions.Tests/QuadTreeTests.cs
+22 -19
View File
@@ -1,26 +1,27 @@
using System.Collections.Generic;
using MonoGame.Extended.Collisions.QuadTree;
using Xunit;
namespace MonoGame.Extended.Collisions.Tests
{
public class QuadTreeTests
{
private Quadtree MakeTree()
private QuadTree.QuadTree MakeTree()
{
// Bounds set to ensure actors will fit inside the tree with default bounds.
var bounds = _quadTreeArea;
var tree = new Quadtree(bounds);
var tree = new QuadTree.QuadTree(bounds);
return tree;
}
private readonly RectangleF _quadTreeArea = new RectangleF(-10f, -15, 20.0f, 30.0f);
private RectangleF _quadTreeArea = new RectangleF(-10f, -15, 20.0f, 30.0f);
[Fact]
public void ConstructorTest()
{
var bounds = new RectangleF(-10f, -15, 20.0f, 30.0f);
var tree = new Quadtree(bounds);
var tree = new QuadTree.QuadTree(bounds);
Assert.Equal(bounds, tree.NodeBounds);
Assert.True(tree.IsLeaf);
@@ -41,7 +42,7 @@ namespace MonoGame.Extended.Collisions.Tests
var actor = new BasicActor();
tree.Insert(new QuadtreeData(actor));
Assert.Equal(1, tree.NumTargets());
}
@@ -330,7 +331,7 @@ namespace MonoGame.Extended.Collisions.Tests
public void ShakeWhenContainingManyTest()
{
var tree = MakeTree();
var numTargets = Quadtree.DefaultMaxObjectsPerNode + 1;
var numTargets = QuadTree.QuadTree.DefaultMaxObjectsPerNode + 1;
for (int i = 0; i < numTargets; i++)
{
@@ -347,8 +348,8 @@ namespace MonoGame.Extended.Collisions.Tests
{
var tree = MakeTree();
var query = tree.Query(_quadTreeArea);
var query = tree.Query(ref _quadTreeArea);
Assert.Empty(query);
Assert.Equal(0, tree.NumTargets());
}
@@ -358,7 +359,8 @@ namespace MonoGame.Extended.Collisions.Tests
{
var tree = MakeTree();
var query = tree.Query(new RectangleF(100f, 100f, 1f, 1f));
var area = new RectangleF(100f, 100f, 1f, 1f);
var query = tree.Query(ref area);
Assert.Empty(query);
Assert.Equal(0, tree.NumTargets());
@@ -371,7 +373,7 @@ namespace MonoGame.Extended.Collisions.Tests
var actor = new BasicActor();
tree.Insert(new QuadtreeData(actor));
var query = tree.Query(_quadTreeArea);
var query = tree.Query(ref _quadTreeArea);
Assert.Single(query);
Assert.Equal(tree.NumTargets(), query.Count);
}
@@ -383,7 +385,8 @@ namespace MonoGame.Extended.Collisions.Tests
var actor = new BasicActor();
tree.Insert(new QuadtreeData(actor));
var query = tree.Query(new RectangleF(100f, 100f, 1f, 1f));
var area = new RectangleF(100f, 100f, 1f, 1f);
var query = tree.Query(ref area);
Assert.Empty(query);
}
@@ -391,7 +394,7 @@ namespace MonoGame.Extended.Collisions.Tests
public void QueryLeafNodeMultipleTest()
{
var tree = MakeTree();
var numTargets = Quadtree.DefaultMaxObjectsPerNode;
var numTargets = QuadTree.QuadTree.DefaultMaxObjectsPerNode;
for (int i = 0; i < numTargets; i++)
{
var data = new QuadtreeData(new BasicActor());
@@ -399,7 +402,7 @@ namespace MonoGame.Extended.Collisions.Tests
}
var query = tree.Query(_quadTreeArea);
var query = tree.Query(ref _quadTreeArea);
Assert.Equal(numTargets, query.Count);
Assert.Equal(tree.NumTargets(), query.Count);
}
@@ -408,7 +411,7 @@ namespace MonoGame.Extended.Collisions.Tests
public void QueryNonLeafManyTest()
{
var tree = MakeTree();
var numTargets = 2*Quadtree.DefaultMaxObjectsPerNode;
var numTargets = 2*QuadTree.QuadTree.DefaultMaxObjectsPerNode;
for (int i = 0; i < numTargets; i++)
{
var data = new QuadtreeData(new BasicActor());
@@ -416,7 +419,7 @@ namespace MonoGame.Extended.Collisions.Tests
}
var query = tree.Query(_quadTreeArea);
var query = tree.Query(ref _quadTreeArea);
Assert.Equal(numTargets, query.Count);
Assert.Equal(tree.NumTargets(), query.Count);
}
@@ -425,7 +428,7 @@ namespace MonoGame.Extended.Collisions.Tests
public void QueryTwiceConsecutiveTest()
{
var tree = MakeTree();
var numTargets = 2 * Quadtree.DefaultMaxObjectsPerNode;
var numTargets = 2 * QuadTree.QuadTree.DefaultMaxObjectsPerNode;
for (int i = 0; i < numTargets; i++)
{
var data = new QuadtreeData(new BasicActor());
@@ -433,11 +436,11 @@ namespace MonoGame.Extended.Collisions.Tests
}
var query1 = tree.Query(_quadTreeArea);
var query2 = tree.Query(_quadTreeArea);
var query1 = tree.Query(ref _quadTreeArea);
var query2 = tree.Query(ref _quadTreeArea);
Assert.Equal(numTargets, query1.Count);
Assert.Equal(tree.NumTargets(), query1.Count);
Assert.Equal(query1.Count, query2.Count);
}
}
}
}
src/cs/Tests/MonoGame.Extended.Collisions.Tests/SpatialHashTests.cs
+39
View File
@@ -0,0 +1,39 @@
using System.Collections.Generic;
using System.Linq;
using Xunit;
namespace MonoGame.Extended.Collisions.Tests;
public class SpatialHashTests
{
private SpatialHash generateSpatialHash() => new SpatialHash(new Size2(64, 64));
private readonly RectangleF RECT = new RectangleF(10, 10, 20, 20);
[Fact]
public void CollisionOneTrueTest()
{
var hash = generateSpatialHash();
hash.Insert(new BasicActor()
{
Bounds = RECT,
});
var collisions = hash.Query(RECT);
Assert.Equal(1, collisions.Count());
}
[Fact]
public void CollisionTwoTest()
{
var hash = generateSpatialHash();
hash.Insert(new BasicActor
{
Bounds = RECT,
});
hash.Insert(new BasicActor
{
Bounds = RECT,
});
var collisions = hash.Query(RECT);
Assert.Equal(2, collisions.Count());
}
}