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); }