public void AddTest()
{
Quadtree <Q> quadtree = new Quadtree <Q>(2, Vector2Int.Zero);
Q[] qs = new Q[]
{
new Q(0, 0),
new Q(1, 0),
new Q(0, 1),
new Q(1, 1)
};
quadtree.Add(qs[0]);
quadtree.Add(qs[1]);
quadtree.Add(qs[2]);
quadtree.Add(qs[3]);
int j = 0;
for (int i = 0; i < quadtree.Area; i++)
{
if (quadtree[i].Data != null)
{
Assert.AreEqual(quadtree[i].Data.Position, qs[j].Position);
j++;
}
}
}
public void CheckSplit()
{
var _NumberOfSplits = 0L;
var _Quadtree = new Quadtree <Double>(0, 0, 10, 10, MaxNumberOfEmbeddedPixels: 4);
_Quadtree.OnTreeSplit += (Quadtree, Pixel) =>
{
Interlocked.Increment(ref _NumberOfSplits);
};
_Quadtree.Add(new Pixel <Double>(1, 1));
Assert.AreEqual(1UL, _Quadtree.EmbeddedCount);
Assert.AreEqual(1UL, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(9, 1));
Assert.AreEqual(2, _Quadtree.EmbeddedCount);
Assert.AreEqual(2, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(1, 9));
Assert.AreEqual(3, _Quadtree.EmbeddedCount);
Assert.AreEqual(3, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(9, 9));
Assert.AreEqual(4, _Quadtree.EmbeddedCount);
Assert.AreEqual(4, _Quadtree.Count);
// Add the fifth pixel -> Should cause a split!
_Quadtree.Add(new Pixel <Double>(4, 4));
Assert.AreEqual(1L, _NumberOfSplits);
Assert.AreEqual(0, _Quadtree.EmbeddedCount);
// Assert.AreEqual(5, _Quadtree.Count);
}
public void AddWhenTimoutAndMultipleObjectsTest()
{
var _objects = new Quadtree<object>();
var _newObject = new object();
var _newObject2 = new object();
var _envelope = new Envelope(new Coordinate(1, 1));
var _envelope2 = new Envelope(new Coordinate(2, 2));
Parallel.Invoke(
() =>
{
_objects.Add(_envelope, _newObject, 100, () => _objects.Remove(_envelope, _newObject));
_objects.Add(_envelope2, _newObject2, 500, () => _objects.Remove(_envelope2, _newObject2));
},
() =>
{
Thread.Sleep(10);
Assert.IsTrue(_objects.Contains(_envelope));
Assert.IsTrue(_objects.Contains(_envelope2));
Thread.Sleep(250);
}
);
Assert.IsFalse(_objects.Contains(_envelope));
Assert.IsTrue(_objects.Contains(_envelope2));
}
public void MoveTest()
{
Quadtree <Q> quadtree = new Quadtree <Q>(2, Vector2Int.Zero);
Q q = new Q(0, 0);
quadtree.Add(q);
quadtree.Center = new Vector2Int(1, 1);
Assert.AreEqual(new Vector2Int(0, 0), quadtree.GetData(new Vector2Int(1, 1)).Position);
quadtree.Clear();
quadtree.Add(q);
Assert.AreEqual(new Vector2Int(0, 0), quadtree.GetData(new Vector2Int(0, 0)).Position);
}
public void QueryQuadtreeWithThreeDummiesAndObtainAll()
{
var qtree = new Quadtree<BoundableDummy>();
var dummy1 = new BoundableDummy(
new AxisAlignedBoundingBox2D(10.0f, 10.0f, 20.0f)
);
var dummy2 = new BoundableDummy(
new AxisAlignedBoundingBox2D(100.0f, 100.0f, 20.0f)
);
var dummy3 = new BoundableDummy(
new AxisAlignedBoundingBox2D(10.0f, 60.0f, 20.0f)
);
qtree.Add(dummy1);
qtree.Add(dummy2);
qtree.Add(dummy3);
var hitDummies = new List<BoundableDummy>();
Action<BoundableDummy> hitAction = (bd) => hitDummies.Add(bd);
qtree.Query(hitAction);
Assert.AreEqual(3, hitDummies.Count);
}
public void DataIsQueriableAsDesired()
{
var qtree = new Quadtree<BoundableDummy>();
var dummy = new BoundableDummy(
new AxisAlignedBoundingBox2D(10.0f, 10.0f, 20.0f)
);
qtree.Add(dummy);
var searchBox = new AxisAlignedBoundingBox2D(0, 0, 50.0f);
var hitCount = 0;
Action<BoundableDummy> hitAction = (BoundableDummy) => hitCount++;
qtree.Query(searchBox, hitAction);
Assert.AreEqual(1, hitCount);
}
public void Add(ICollidable collidable)
{
if (collidable == null)
{
throw new ArgumentNullException(nameof(collidable));
}
// also keep them in a list for easier collision checks
// static collidables don't move, so they can't "run into" other collidables
if (!collidable.IsStatic)
{
_collidables.Add(collidable);
}
else
{
_tree.Add(collidable);
}
}
public void AddWhenTimoutNotElapsedTest()
{
var _objects = new Quadtree<object>();
var _newObject = new object();
var _envelope = new Envelope(new Coordinate(1, 1));
Parallel.Invoke(
() => _objects.Add(_envelope, _newObject, 100, () => _objects.Remove(_envelope, _newObject)),
() =>
{
Thread.Sleep(10);
Assert.IsTrue(_objects.Contains(_envelope));
}
);
Assert.IsTrue(_objects.Contains(_envelope));
}
private void ProcessRectangleObject(Quadtree <GameObject> hash, RectangleObject obj,
Action <GameObject, BaseObject> func)
{
var entity = new GameObject();
var bounds = CCollisionBound.Rectangle(new Vector2(obj.Width, obj.Height));
var position = new CPosition(new Vector2(obj.X, obj.Y));
entity.Components.Add(bounds);
entity.Components.Add(position);
func(entity, obj);
hash.Add(entity, new RectangleF(
position.Position.X,
position.Position.Y,
bounds.Bounds.Width,
bounds.Bounds.Height
));
}
private void ProcessPolygonObject(Quadtree <GameObject> hash, PolygonObject obj,
Action <GameObject, BaseObject> func)
{
var entity = new GameObject();
var bounds = new CCollisionBound(obj.Polygon.Select(point => new Vector2(point.X, point.Y)).ToList());
var position = new CPosition(new Vector2(obj.X, obj.Y));
entity.Components.Add(bounds);
entity.Components.Add(position);
func(entity, obj);
hash.Add(entity, new RectangleF(
position.Position.X,
position.Position.Y,
bounds.Bounds.Width,
bounds.Bounds.Height
));
}
public Foregrounds(GraphicsDevice g)
{
int mapLength = 20000;
_s = new SpriteBatch(g);
var maxDepth = 0;
var items = new List <(Texture2D Texture, Core.AnimationStyle Style)> {
(Assets.Shrub1, Core.AnimationStyle.Tree),
(Assets.Shrub2, Core.AnimationStyle.Tree),
(Assets.Shrub3, Core.AnimationStyle.Tree),
};
for (int i = 0; i < 100; i++)
{
var scale = (float)(Core.R.NextDouble() * 0.4 + 0.6) * 0.7f;
var type = items[Core.R.Next(0, items.Count)];
var z = Core.R.Next(0, 4) / 10f + 0.2f;
Quadtree <ForegroundObjects> .Add(new ForegroundObjects(Core.R.Next(0, mapLength), -(int)(type.Texture.Height *scale) + 300, z, scale, type.Texture, type.Style, maxDepth + (int)((1 - scale) * 100)));
}
}
public ChunkManager(IRenderContext renderContext, DebugMessageBuilder messageBuilder, CollisionEngine collisionEngine, int width, int height)
{
_messageBuilder = messageBuilder;
var start = new Cell(0, 0).GetBoundingBox();
var end = new Cell(width - 1, height - 1).GetBoundingBox();
var fullGrid = BoundingBox.CreateMerged(start, end);
_quadtree = new Quadtree <MazeChunk>(fullGrid);
var cells = GenerateNewMaze(width, height);
var chunks = GenerateChunks(renderContext, cells, collisionEngine);
_totalVertices = chunks.Sum(c => c.Vertices);
_totalChunks = chunks.Count;
foreach (var c in chunks)
{
_quadtree.Add(c);
}
}
public Backgrounds(GraphicsDevice g)
{
int mapLength = 20000;
_s = new SpriteBatch(g);
_infiniteObjects.Add(new InfiniteObjects(Assets.Sky, _furthest - 10, 100, Vector2.Zero));
_infiniteObjects.Add(new InfiniteObjects(Assets.Mountains, _furthest, 2, new Vector2(0, 450), -260));
var maxDepth = 0;
for (int i = _furthest + 1; i <= 0; i++)
{
_infiniteObjects.Add(new InfiniteObjects(Assets.Ground, i, 1, new Vector2(0, 0), 1));
}
var items = new List <(Texture2D Texture, Core.AnimationStyle Style)> {
(Assets.Tree, Core.AnimationStyle.Tree),
(Assets.Shrub1, Core.AnimationStyle.Tree),
(Assets.Shrub2, Core.AnimationStyle.Tree),
(Assets.Shrub3, Core.AnimationStyle.Tree),
(Assets.Shrub4, Core.AnimationStyle.Tree),
};
for (int i = 0; i < 130; i++)
{
var scale = (float)(Core.R.NextDouble() * 0.4 + 0.6);
var type = items[Core.R.Next(0, items.Count)];
Quadtree <BackgroundObjects> .Add(new BackgroundObjects(Core.R.Next(0, mapLength), -(int)(type.Texture.Height *scale) + 250, Core.R.Next(_furthest + 1, 1), scale, type.Texture, type.Style, maxDepth + (int)((1 - scale) * 100)));
}
for (int i = 0; i < 100; i++)
{
var scale = (float)(Core.R.NextDouble() * 0.4 + 0.6);
Quadtree <BackgroundObjects> .Add(new BackgroundObjects(Core.R.Next(0, mapLength), -700, Core.R.Next(_furthest + 1, 0), scale, Assets.Clouds, Core.AnimationStyle.Cloud, maxDepth + (int)((1 - scale) * 200)));
}
}
public WorldScene(IRenderContext renderContext, DebugMessageBuilder messageBuilder)
{
_messageBuilder = messageBuilder;
var width = 250;
var height = 250;
var start = new Cell(0, 0).GetBoundingBox();
var end = new Cell(width - 1, height - 1).GetBoundingBox();
var fullGrid = BoundingBox.CreateMerged(start, end);
_quadtree = new Quadtree <MazeChunk>(fullGrid);
var cells = GenerateNewMaze(width, height);
var chunks = GenerateChunks(renderContext, cells);
_totalVertices = chunks.Sum(c => c.Vertices);
_totalChunks = chunks.Count;
foreach (var c in chunks)
{
_quadtree.Add(c);
}
}
public void CheckSplit2()
{
var _NumberOfSplits = 0L;
var _Quadtree = new Quadtree <Double, String>(0, 0, 10, 10, MaxNumberOfEmbeddedPixels: 4);
_Quadtree.OnTreeSplit += (Quadtree, Pixel) =>
{
Interlocked.Increment(ref _NumberOfSplits);
};
_Quadtree.Add(new Pixel <Double>(1, 1), "a");
Assert.AreEqual(1UL, _Quadtree.EmbeddedCount);
Assert.AreEqual(1UL, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(9, 1), "b");
Assert.AreEqual(2, _Quadtree.EmbeddedCount);
Assert.AreEqual(2, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(1, 9), "c");
Assert.AreEqual(3, _Quadtree.EmbeddedCount);
Assert.AreEqual(3, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(9, 9), "d");
Assert.AreEqual(4, _Quadtree.EmbeddedCount);
Assert.AreEqual(4, _Quadtree.Count);
// Add the fifth pixel -> Should cause a split!
_Quadtree.Add(new Pixel <Double>(4, 4), "e");
Assert.AreEqual(1L, _NumberOfSplits);
Assert.AreEqual(0, _Quadtree.EmbeddedCount);
// Assert.AreEqual(5, _Quadtree.Count);
_Quadtree.Add(new Pixel <Double>(5, 5), "f");
var a = _Quadtree.Get(new Rectangle <Double>(3, 3, 6, 6)).ToArray();
Assert.AreEqual(2, a.Count());
Assert.IsTrue(a[0].Value == "e" || a[1].Value == "f");
}
public void ContainsTest()
{
var _objects = new Quadtree<object>();
var _newObject = new object();
var _envelope = new Envelope(new Coordinate(1, 1));
_objects.Add(_envelope, _newObject);
Assert.IsTrue(_objects.Contains(_envelope));
}
public void VerifyOutOfBoundsException()
{
var _Quadtree = new Quadtree <Double>(1, 2, 3, 5);
_Quadtree.Add(new Pixel <Double>(10, 10));
}
public void VerifyOutOfBoundsException()
{
var _Quadtree = new Quadtree<Double>(1, 2, 3, 5);
_Quadtree.Add(new Pixel<Double>(10, 10));
}
public void CheckRecursiveSplits()
{
var _NumberOfSplits = 0L;
var _Quadtree = new Quadtree<Double>(0, 0, 100, 100, MaxNumberOfEmbeddedPixels: 4);
_Quadtree.OnTreeSplit += (Quadtree, Pixel) =>
{
Interlocked.Increment(ref _NumberOfSplits);
};
_Quadtree.Add(new Pixel<Double>(1, 1));
_Quadtree.Add(new Pixel<Double>(9, 1));
_Quadtree.Add(new Pixel<Double>(1, 9));
_Quadtree.Add(new Pixel<Double>(9, 9));
_Quadtree.Add(new Pixel<Double>(4, 4));
_Quadtree.Add(new Pixel<Double>(5, 5));
_Quadtree.Add(new Pixel<Double>(50, 5));
_Quadtree.Add(new Pixel<Double>(51, 5));
_Quadtree.Add(new Pixel<Double>(52, 5));
_Quadtree.Add(new Pixel<Double>(53, 5));
_Quadtree.Add(new Pixel<Double>(54, 5));
_Quadtree.Add(new Pixel<Double>(55, 5));
_Quadtree.Add(new Pixel<Double>(56, 5));
_Quadtree.Add(new Pixel<Double>(57, 5));
_Quadtree.Add(new Pixel<Double>(58, 5));
_Quadtree.Add(new Pixel<Double>(59, 5));
_Quadtree.Add(new Pixel<Double>(60, 5));
Assert.AreEqual(8L, _NumberOfSplits);
}
private void ParseTiles(Map map)
{
var isMask = true;
var tilesetCache = new Dictionary <int, ITileset>();
map.Layers
.OfType <TileLayer>()
.ForEach(layer =>
{
if (layer.Name.Equals("FringeStart"))
{
isMask = false;
}
for (int y = 0, i = 0; y < layer.Height; y++)
{
for (var x = 0; x < layer.Width; x++, i++)
{
var gid = layer.Data[i];
if (gid == 0)
{
continue;
}
if (!tilesetCache.TryGetValue(gid, out var tileset))
{
tileset = map.Tilesets.Single(ts =>
gid >= ts.FirstGid && ts.FirstGid + ts.TileCount > gid);
tilesetCache.Add(gid, tileset);
}
var tile = tileset[gid];
var posX = map.XOffset + x * map.CellWidth + layer.X;
var posY = map.YOffset + y * map.CellHeight + layer.Y;
var relativeId = gid - tileset.FirstGid;
if (tileset.TileProperties.TryGetValue(relativeId, out var item))
{
var values = item.Values.Select(i => i);
foreach (var value in values)
{
var split = value.Split('|');
switch (split[0])
{
case "emitter":
var px = (int)float.Parse(split[2]);
var py = (int)float.Parse(split[3]);
var width = (int)float.Parse(split[4]);
var height = (int)float.Parse(split[5]);
var bounds = new Rectangle(tile.Left + px, tile.Top + py, width, height);
if (!new Rectangle(tile.Left, tile.Top, tile.Width, tile.Height)
.Contains(bounds))
{
continue;
}
var ty = posY - (tile.Height) + 16 + py;
var boundsT = new Rectangle(posX + px, ty, width, height);
var boundsF = new RectangleF(posX + px, ty, width, height);
switch (split[1])
{
case "leaf":
// todo: use isMask to determine
_maskEmitters.Add(new Emitter <Leaf>(_random, 2,
_assetLoader.Get <Texture2D>("particles/leaf.png"),
boundsT), boundsF);
_fringeEmitters.Add(new Emitter <Leaf>(_random, 1,
_assetLoader.Get <Texture2D>("particles/leaf.png"),
boundsT), boundsF);
break;
default:
break;
}
break;
default:
break;
}
}
}
}
}
});
}
public void CheckSplit2()
{
var _NumberOfSplits = 0L;
var _Quadtree = new Quadtree<Double, String>(0, 0, 10, 10, MaxNumberOfEmbeddedPixels: 4);
_Quadtree.OnTreeSplit += (Quadtree, Pixel) =>
{
Interlocked.Increment(ref _NumberOfSplits);
};
_Quadtree.Add(new Pixel<Double>(1, 1), "a");
Assert.AreEqual(1UL, _Quadtree.EmbeddedCount);
Assert.AreEqual(1UL, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(9, 1), "b");
Assert.AreEqual(2, _Quadtree.EmbeddedCount);
Assert.AreEqual(2, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(1, 9), "c");
Assert.AreEqual(3, _Quadtree.EmbeddedCount);
Assert.AreEqual(3, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(9, 9), "d");
Assert.AreEqual(4, _Quadtree.EmbeddedCount);
Assert.AreEqual(4, _Quadtree.Count);
// Add the fifth pixel -> Should cause a split!
_Quadtree.Add(new Pixel<Double>(4, 4), "e");
Assert.AreEqual(1L, _NumberOfSplits);
Assert.AreEqual(0, _Quadtree.EmbeddedCount);
// Assert.AreEqual(5, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(5, 5), "f");
var a = _Quadtree.Get(new Rectangle<Double>(3, 3, 6, 6)).ToArray();
Assert.AreEqual(2, a.Count());
Assert.IsTrue(a[0].Value == "e" || a[1].Value == "f");
}
public void QueryQuadtreeWithTwoDummiesAndObtainNone()
{
var qtree = new Quadtree<BoundableDummy>();
var dummy1 = new BoundableDummy(
new AxisAlignedBoundingBox2D(10.0f, 10.0f, 20.0f)
);
var dummy2 = new BoundableDummy(
new AxisAlignedBoundingBox2D(100.0f, 100.0f, 20.0f)
);
qtree.Add(dummy1);
qtree.Add(dummy2);
var searchBox = new AxisAlignedBoundingBox2D(50.0f, 50.0f, 5.0f);
var hitDummies = new List<BoundableDummy>();
Action<BoundableDummy> hitAction = (bd) => hitDummies.Add(bd);
qtree.Query(searchBox, hitAction);
Assert.AreEqual(0, hitDummies.Count);
}
public void CheckSplit()
{
var _NumberOfSplits = 0L;
var _Quadtree = new Quadtree<Double>(0, 0, 10, 10, MaxNumberOfEmbeddedPixels: 4);
_Quadtree.OnTreeSplit += (Quadtree, Pixel) =>
{
Interlocked.Increment(ref _NumberOfSplits);
};
_Quadtree.Add(new Pixel<Double>(1, 1));
Assert.AreEqual(1UL, _Quadtree.EmbeddedCount);
Assert.AreEqual(1UL, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(9, 1));
Assert.AreEqual(2, _Quadtree.EmbeddedCount);
Assert.AreEqual(2, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(1, 9));
Assert.AreEqual(3, _Quadtree.EmbeddedCount);
Assert.AreEqual(3, _Quadtree.Count);
_Quadtree.Add(new Pixel<Double>(9, 9));
Assert.AreEqual(4, _Quadtree.EmbeddedCount);
Assert.AreEqual(4, _Quadtree.Count);
// Add the fifth pixel -> Should cause a split!
_Quadtree.Add(new Pixel<Double>(4, 4));
Assert.AreEqual(1L, _NumberOfSplits);
Assert.AreEqual(0, _Quadtree.EmbeddedCount);
// Assert.AreEqual(5, _Quadtree.Count);
}
public void CheckRecursiveSplits()
{
var _NumberOfSplits = 0L;
var _Quadtree = new Quadtree <Double>(0, 0, 100, 100, MaxNumberOfEmbeddedPixels: 4);
_Quadtree.OnTreeSplit += (Quadtree, Pixel) =>
{
Interlocked.Increment(ref _NumberOfSplits);
};
_Quadtree.Add(new Pixel <Double>(1, 1));
_Quadtree.Add(new Pixel <Double>(9, 1));
_Quadtree.Add(new Pixel <Double>(1, 9));
_Quadtree.Add(new Pixel <Double>(9, 9));
_Quadtree.Add(new Pixel <Double>(4, 4));
_Quadtree.Add(new Pixel <Double>(5, 5));
_Quadtree.Add(new Pixel <Double>(50, 5));
_Quadtree.Add(new Pixel <Double>(51, 5));
_Quadtree.Add(new Pixel <Double>(52, 5));
_Quadtree.Add(new Pixel <Double>(53, 5));
_Quadtree.Add(new Pixel <Double>(54, 5));
_Quadtree.Add(new Pixel <Double>(55, 5));
_Quadtree.Add(new Pixel <Double>(56, 5));
_Quadtree.Add(new Pixel <Double>(57, 5));
_Quadtree.Add(new Pixel <Double>(58, 5));
_Quadtree.Add(new Pixel <Double>(59, 5));
_Quadtree.Add(new Pixel <Double>(60, 5));
Assert.AreEqual(8L, _NumberOfSplits);
}
