Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
ConcurrentPooledLinkedList extends PooledLinkedList<T> implements ConcurrentCollection { @Override public void remove() { lock.lockWrite(); super.remove(); lock.unlockWrite(); } ConcurrentPooledLinkedList(int maxPoolSize); @Override void add(T object); @Override void addFirst(T object); @Override int size(); @Override void iter(); @Override void iterReverse(); @Override T next(); @Override T previous(); @Override void remove(); @Override T removeLast(); @Override void clear(); @Override ReadWriteLock getLock(); }
@Test public void testRemove() { ConcurrentPooledLinkedList<Integer> l = new ConcurrentPooledLinkedList<>(10000); for (int i = 0; i < 10000; i++) { l.addFirst(i); } l.iter(); CountDownLatch latch = new CountDownLatch(1000); Thread[] removeThread = createAndStartThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 10; i++) { l.lock.lockWrite(); l.next(); l.remove(); l.lock.unlockWrite(); } } }, 500); Thread[] removeLastThread = createAndStartThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 10; i++) { l.removeLast(); } } }, 500); joinAll(removeThread, removeLastThread); assertEquals(0, l.size()); }
ConcurrentByteArray extends ByteArray implements ConcurrentCollection { @Override public void add(byte value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentByteArray(); ConcurrentByteArray(int capacity); ConcurrentByteArray(boolean ordered, int capacity); ConcurrentByteArray(ByteArray array); ConcurrentByteArray(byte[] array); ConcurrentByteArray(boolean ordered, byte[] array, int startIndex, int count); @Override void add(byte value); @Override void add(byte value1, byte value2); @Override void add(byte value1, byte value2, byte value3); @Override void add(byte value1, byte value2, byte value3, byte value4); @Override void addAll(byte[] array, int offset, int length); @Override byte get(int index); @Override void set(int index, byte value); @Override void insert(int index, byte value); @Override void swap(int first, int second); @Override void addAll(ByteArray array, int offset, int length); @Override int removeIndex(int index); @Override void removeRange(int start, int end); @Override byte pop(); @Override byte peek(); @Override byte first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override byte[] shrink(); @Override void incr(int index, byte value); @Override void mul(int index, byte value); @Override boolean contains(byte value); @Override int indexOf(byte value); @Override int lastIndexOf(byte value); @Override boolean removeValue(byte value); @Override boolean removeAll(ByteArray array); @Override void sort(); @Override byte[] ensureCapacity(int additionalCapacity); @Override byte[] setSize(int newSize); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override byte random(); @Override byte[] toArray(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
@Test public void testAddItems() { ConcurrentByteArray a = new ConcurrentByteArray(); CountDownLatch latch = new CountDownLatch(100); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 100; i++) { a.add((byte)(i % 256 - 128)); } } }, 100); assertEquals(a.size, 10*1000); }
ConcurrentObjectSet extends ObjectSet<T> implements ConcurrentCollection { @Override public boolean add(T key) { lock.lockWrite(); boolean b = super.add(key); lock.unlockWrite(); return b; } ConcurrentObjectSet(); ConcurrentObjectSet(int initialCapacity); ConcurrentObjectSet(int initialCapacity, float loadFactor); ConcurrentObjectSet(ObjectSet<? extends T> set); @Override boolean add(T key); @Override void addAll(Array<? extends T> array, int offset, int length); @Override void addAll(T[] array, int offset, int length); @Override void addAll(ObjectSet<T> set); @Override boolean remove(T key); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void shrink(int maximumCapacity); @Override void clear(int maximumCapacity); @Override void clear(); @Override boolean contains(T key); @Override T get(T key); @Override T first(); @Override void ensureCapacity(int additionalCapacity); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toString(String separator); @Override ObjectSetIterator<T> iterator(); @Override ReadWriteLock getLock(); }
@Test public void testAdd() { ConcurrentObjectSet<Integer> set = new ConcurrentObjectSet<>(); Random r = new Random(); CountDownLatch latch = new CountDownLatch(1000); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } while (!set.add(r.nextInt())){ } } }, 1000); assertEquals(1000, set.size); }
ConcurrentObjectSet extends ObjectSet<T> implements ConcurrentCollection { @Override public boolean remove(T key) { lock.lockWrite(); boolean b = super.remove(key); lock.unlockWrite(); return b; } ConcurrentObjectSet(); ConcurrentObjectSet(int initialCapacity); ConcurrentObjectSet(int initialCapacity, float loadFactor); ConcurrentObjectSet(ObjectSet<? extends T> set); @Override boolean add(T key); @Override void addAll(Array<? extends T> array, int offset, int length); @Override void addAll(T[] array, int offset, int length); @Override void addAll(ObjectSet<T> set); @Override boolean remove(T key); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void shrink(int maximumCapacity); @Override void clear(int maximumCapacity); @Override void clear(); @Override boolean contains(T key); @Override T get(T key); @Override T first(); @Override void ensureCapacity(int additionalCapacity); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toString(String separator); @Override ObjectSetIterator<T> iterator(); @Override ReadWriteLock getLock(); }
@Test public void testRemove(){ ConcurrentObjectSet<Integer> set = new ConcurrentObjectSet<>(); for (int i = 0; i < 10000; i++) { set.add(i); } CountDownLatch latch = new CountDownLatch(1000); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 10; i++) { set.lock.lockWrite(); int key = set.first(); assertTrue(set.contains(key)); set.remove(key); assertFalse(set.contains(key)); set.lock.unlockWrite(); } } }, 1000); assertEquals(0, set.size); }
Tileset implements Disposable { public int getWidthInTiles() { return tilesetSource.getWidthInTiles(); } Tileset(int firstGid, TilesetSource tilesetSource); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); ObjectMap<String, String> getProperties(); void drawTile(Graphics g, int tileId, int renderX, int renderY); void drawTileset(Graphics g, int renderX, int renderY); Tile getTile(int tileId); Tile getTile(int x, int y); Array<AssetDescriptor> getDependencies(FileHandle tmxPath); boolean isTextureLoaded(); void loadTexture(FileHandle tmxPath); void loadTexture(AssetManager assetManager, FileHandle tmxPath); void loadTexture(TextureAtlas textureAtlas); @Override void dispose(); boolean contains(int tileId); int getTileId(int x, int y); int getTileX(int tileId); int getTileY(int tileId); int getWidthInTiles(); int getHeightInTiles(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getSpacing(); int getMargin(); int getFirstGid(); String getSourceInternalUuid(); }
@Test public void testGetWidthInTilesWithSpacing() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(3, tileset.getWidthInTiles()); tileset = new Tileset(1, new ImageTilesetSource(96, 128, 32, 32, 4, 0)); Assert.assertEquals(2, tileset.getWidthInTiles()); tileset = new Tileset(1, new ImageTilesetSource(1936, 1052, 32, 32, 2, 0)); Assert.assertEquals(57, tileset.getWidthInTiles()); } @Test public void testGetWidthInTilesWithMargin() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 4)); Assert.assertEquals(3, tileset.getWidthInTiles()); tileset = new Tileset(1, new ImageTilesetSource(96, 128, 32, 32, 0, 4)); Assert.assertEquals(2, tileset.getWidthInTiles()); } @Test public void testGetWidthInTiles() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(4, tileset.getWidthInTiles()); tileset = new Tileset(1, new ImageTilesetSource(96, 128, 32, 32, 0, 0)); Assert.assertEquals(3, tileset.getWidthInTiles()); }
ConcurrentIntArray extends IntArray implements ConcurrentCollection { @Override public void add(int value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentIntArray(); ConcurrentIntArray(int capacity); ConcurrentIntArray(boolean ordered, int capacity); ConcurrentIntArray(IntArray array); ConcurrentIntArray(int[] array); ConcurrentIntArray(boolean ordered, int[] array, int startIndex, int count); @Override void add(int value); @Override void add(int value1, int value2); @Override void add(int value1, int value2, int value3); @Override void add(int value1, int value2, int value3, int value4); @Override void addAll(IntArray array, int offset, int length); @Override void addAll(int[] array, int offset, int length); @Override int get(int index); @Override void set(int index, int value); @Override void incr(int index, int value); @Override void mul(int index, int value); @Override void insert(int index, int value); @Override void swap(int first, int second); @Override boolean contains(int value); @Override int indexOf(int value); @Override int lastIndexOf(int value); @Override boolean removeValue(int value); @Override int removeIndex(int index); @Override void removeRange(int start, int end); @Override boolean removeAll(IntArray array); @Override int pop(); @Override int peek(); @Override int first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override int[] shrink(); @Override int[] ensureCapacity(int additionalCapacity); @Override int[] setSize(int newSize); @Override void sort(); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override int random(); @Override int[] toArray(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
@Test public void testAddItems() { ConcurrentIntArray a = new ConcurrentIntArray(); CountDownLatch latch = new CountDownLatch(100); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 100; i++) { a.add(i); } } }, 100); assertEquals(a.size, 10*1000); }
ConcurrentArray extends Array<T> implements ConcurrentCollection { @Override public void add(T value) { lock.lockWrite(); super.add(value); lock.unlockWrite(); } ConcurrentArray(); ConcurrentArray(int capacity); ConcurrentArray(boolean ordered, int capacity); ConcurrentArray(boolean ordered, int capacity, Class arrayType); ConcurrentArray(Class arrayType); ConcurrentArray(Array<? extends T> array); ConcurrentArray(T[] array); ConcurrentArray(boolean ordered, T[] array, int start, int count); @Override void add(T value); @Override void add(T value1, T value2); @Override void add(T value1, T value2, T value3); @Override void add(T value1, T value2, T value3, T value4); @Override void addAll(Array<? extends T> array, int start, int count); @Override void addAll(T[] array, int start, int count); @Override T get(int index); @Override void set(int index, T value); @Override void insert(int index, T value); @Override void swap(int first, int second); @Override boolean contains(T value, boolean identity); @Override boolean containsAll(Array<? extends T> values, boolean identity); @Override boolean containsAny(Array<? extends T> values, boolean identity); @Override boolean removeValue(T value, boolean identity); @Override boolean removeAll(Array<? extends T> array, boolean identity); @Override T selectRanked(Comparator<T> comparator, int kthLowest); @Override int selectRankedIndex(Comparator<T> comparator, int kthLowest); @Override Iterable<T> select(Predicate<T> predicate); @Override int indexOf(T value, boolean identity); @Override int lastIndexOf(T value, boolean identity); @Override T removeIndex(int index); @Override void removeRange(int start, int end); @Override T pop(); @Override T peek(); @Override T first(); @Override boolean notEmpty(); @Override boolean isEmpty(); @Override void clear(); @Override Iterator<T> iterator(); @Override T[] shrink(); @Override T[] ensureCapacity(int additionalCapacity); @Override T[] setSize(int newSize); @Override void reverse(); @Override void shuffle(); @Override void truncate(int newSize); @Override T random(); @Override T[] toArray(); @Override V[] toArray(Class<V> type); @Override int hashCode(); @Override boolean equals(Object object); @Override boolean equalsIdentity(Object object); @Override String toString(); @Override String toString(String separator); @Override ReadWriteLock getLock(); }
@Test public void testAddItems() { ConcurrentArray<Integer> a = new ConcurrentArray<>(); CountDownLatch latch = new CountDownLatch(10); createStartAndJoinThreads(new Runnable() { @Override public void run() { latch.countDown(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } for (int i = 0; i < 1000; i++) { a.add(i); } } }, 10); assertEquals(a.size, 10*1000); }
LruObjectMap extends ObjectMap<K, V> { @Override public V put(K key, V value) { while(super.size >= maxCapacity) { purge(); } final V result = super.put(key, value); accessCounter.getAndIncrement(key, -1, 1); return result; } LruObjectMap(); LruObjectMap(int initialCapacity); LruObjectMap(int initialCapacity, float loadFactor); LruObjectMap(ObjectMap<? extends K, ? extends V> map); LruObjectMap(int initialCapacity, int maxCapacity); LruObjectMap(int initialCapacity, int maxCapacity, float loadFactor); LruObjectMap(ObjectMap<? extends K, ? extends V> map, int maxCapacity); @Override V put(K key, V value); @Override void putAll(ObjectMap<? extends K, ? extends V> map); @Override V get(K key); @Override V get(K key, V defaultValue); @Override V remove(K key); @Override void clear(); int getMaxCapacity(); static final int DEFAULT_MAX_CAPACITY; }
@Test public void testImmediatePurge() { for(int i = 0; i < MAX_CAPACITY; i++) { map.put("key" + i, "value" + i); } Assert.assertEquals(MAX_CAPACITY, map.size); for(int i = MAX_CAPACITY; i < MAX_CAPACITY * 2; i++) { map.put("key" + i, "value" + i); Assert.assertEquals(MAX_CAPACITY, map.size); } }
FloatQueue { public float removeLast () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final float[] values = this.values; int tail = this.tail; tail--; if (tail == -1) { tail = values.length - 1; } final float result = values[tail]; this.tail = tail; size--; return result; } FloatQueue(); FloatQueue(int initialSize); void addLast(float object); void addFirst(float object); void ensureCapacity(int additional); float removeFirst(); float removeLast(); int indexOf(float value); boolean removeValue(float value); float removeIndex(int index); boolean notEmpty(); boolean isEmpty(); float first(); float last(); float get(int index); void clear(); Iterator<Float> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeLastTest() { FloatQueue queue = new FloatQueue(); queue.addLast((float) 1); queue.addLast((float) 2); queue.addLast((float) 3); queue.addLast((float) 4); assertEquals(4, queue.size); assertEquals(3, queue.indexOf((float) 4)); assertEquals(4, queue.removeLast(), 0.01); assertEquals(3, queue.size); assertEquals(2, queue.indexOf((float) 3)); assertEquals(3, queue.removeLast(), 0.01); assertEquals(2, queue.size); assertEquals(1, queue.indexOf((float) 2)); assertEquals(2, queue.removeLast(), 0.01); assertEquals(1, queue.size); assertEquals(0, queue.indexOf((float) 1)); assertEquals(1, queue.removeLast(), 0.01); assertEquals(0, queue.size); }
FloatQueue { public float removeFirst () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final float[] values = this.values; final float result = values[head]; head++; if (head == values.length) { head = 0; } size--; return result; } FloatQueue(); FloatQueue(int initialSize); void addLast(float object); void addFirst(float object); void ensureCapacity(int additional); float removeFirst(); float removeLast(); int indexOf(float value); boolean removeValue(float value); float removeIndex(int index); boolean notEmpty(); boolean isEmpty(); float first(); float last(); float get(int index); void clear(); Iterator<Float> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeFirstTest() { FloatQueue queue = new FloatQueue(); queue.addLast((float) 1); queue.addLast((float) 2); queue.addLast((float) 3); queue.addLast((float) 4); assertEquals(4, queue.size); assertEquals(0, queue.indexOf((float) 1), 0.01); assertEquals(1, queue.removeFirst(), 0.01); assertEquals(3, queue.size); assertEquals(0, queue.indexOf((float) 2), 0.01); assertEquals(2, queue.removeFirst(), 0.01); assertEquals(2, queue.size); assertEquals(0, queue.indexOf((float) 3), 0.01); assertEquals(3, queue.removeFirst(), 0.01); assertEquals(1, queue.size); assertEquals(0, queue.indexOf((float) 4), 0.01); assertEquals(4, queue.removeFirst(), 0.01); assertEquals(0, queue.size); }
FloatQueue { public float get (int index) { if (index < 0) throw new IndexOutOfBoundsException("index can't be < 0: " + index); if (index >= size) throw new IndexOutOfBoundsException("index can't be >= size: " + index + " >= " + size); final float[] values = this.values; int i = head + index; if (i >= values.length) { i -= values.length; } return values[i]; } FloatQueue(); FloatQueue(int initialSize); void addLast(float object); void addFirst(float object); void ensureCapacity(int additional); float removeFirst(); float removeLast(); int indexOf(float value); boolean removeValue(float value); float removeIndex(int index); boolean notEmpty(); boolean isEmpty(); float first(); float last(); float get(int index); void clear(); Iterator<Float> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void getTest () { final FloatQueue q = new FloatQueue(7); for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { q.addLast((float) j); } assertEquals("get(0) is not equal to peek (" + i + ")", q.get(0), q.first(), 0.01); assertEquals("get(size-1) is not equal to peekLast (" + i + ")", q.get(q.size - 1), q.last(), 0.01); for (int j = 0; j < 4; j++) { assertEquals(q.get(j), j, 0.0); } for (int j = 0; j < 4 - 1; j++) { q.removeFirst(); assertEquals("get(0) is not equal to peek (" + i + ")", q.get(0), q.first(), 0.01); } q.removeFirst(); assert q.size == 0; try { q.get(0); fail("get() on empty queue did not throw"); } catch (IndexOutOfBoundsException ignore) { } } }
FloatQueue { public int indexOf (float value) { if (size == 0) return -1; float[] values = this.values; final int head = this.head, tail = this.tail; if (head < tail) { for (int i = head; i < tail; i++) if (values[i] == value) return i - head; } else { for (int i = head, n = values.length; i < n; i++) if (values[i] == value) return i - head; for (int i = 0; i < tail; i++) if (values[i] == value) return i + values.length - head; } return -1; } FloatQueue(); FloatQueue(int initialSize); void addLast(float object); void addFirst(float object); void ensureCapacity(int additional); float removeFirst(); float removeLast(); int indexOf(float value); boolean removeValue(float value); float removeIndex(int index); boolean notEmpty(); boolean isEmpty(); float first(); float last(); float get(int index); void clear(); Iterator<Float> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void indexOfTest () { final FloatQueue q = new FloatQueue(); for (int j = 0; j <= 6; j++) q.addLast((float) j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf((float) j), j); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst((float) j); for (int j = 3; j <= 6; j++) q.addLast((float) j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf((float) j), j); }
FloatQueue { public Iterator<Float> iterator () { if (iterable == null) iterable = new FloatQueueIterable(this); return iterable.iterator(); } FloatQueue(); FloatQueue(int initialSize); void addLast(float object); void addFirst(float object); void ensureCapacity(int additional); float removeFirst(); float removeLast(); int indexOf(float value); boolean removeValue(float value); float removeIndex(int index); boolean notEmpty(); boolean isEmpty(); float first(); float last(); float get(int index); void clear(); Iterator<Float> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void iteratorTest () { final FloatQueue q = new FloatQueue(); for (int j = 0; j <= 6; j++) q.addLast((float) j); Iterator<Float> iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next().intValue(), j); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, 1, 2, 3, 4, 5, 6); iter.next(); iter.remove(); assertValues(q, 2, 3, 4, 5, 6); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5, 6); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst((float) j); for (int j = 3; j <= 6; j++) q.addLast((float) j); iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next().intValue(), j); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, 1, 2, 3, 4, 5, 6); iter.next(); iter.remove(); assertValues(q, 2, 3, 4, 5, 6); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5, 6); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5); }
FloatQueue { public String toString () { if (size == 0) { return "[]"; } final float[] values = this.values; final int head = this.head; final int tail = this.tail; StringBuilder sb = new StringBuilder(64); sb.append('['); sb.append(values[head]); for (int i = (head + 1) % values.length; i != tail; i = (i + 1) % values.length) { sb.append(", ").append(values[i]); } sb.append(']'); return sb.toString(); } FloatQueue(); FloatQueue(int initialSize); void addLast(float object); void addFirst(float object); void ensureCapacity(int additional); float removeFirst(); float removeLast(); int indexOf(float value); boolean removeValue(float value); float removeIndex(int index); boolean notEmpty(); boolean isEmpty(); float first(); float last(); float get(int index); void clear(); Iterator<Float> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void toStringTest () { FloatQueue q = new FloatQueue(1); assertEquals("[]", q.toString()); q.addLast((float) 4); assertEquals("[4.0]", q.toString()); q.addLast((float) 5); q.addLast((float) 6); q.addLast((float) 7); assertEquals("[4.0, 5.0, 6.0, 7.0]", q.toString()); }
CharQueue { public char removeLast () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final char[] values = this.values; int tail = this.tail; tail--; if (tail == -1) { tail = values.length - 1; } final char result = values[tail]; this.tail = tail; size--; return result; } CharQueue(); CharQueue(int initialSize); void addLast(char object); void addFirst(char object); void ensureCapacity(int additional); char removeFirst(); char removeLast(); int indexOf(char value); boolean removeValue(char value); char removeIndex(int index); boolean notEmpty(); boolean isEmpty(); char first(); char last(); char get(int index); void clear(); Iterator<Character> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeLastTest() { CharQueue queue = new CharQueue(); queue.addLast((char) 1); queue.addLast((char) 2); queue.addLast((char) 3); queue.addLast((char) 4); assertEquals(4, queue.size); assertEquals(3, queue.indexOf((char) 4)); assertEquals((char) 4, queue.removeLast()); assertEquals(3, queue.size); assertEquals(2, queue.indexOf((char) 3)); assertEquals((char) 3, queue.removeLast()); assertEquals(2, queue.size); assertEquals(1, queue.indexOf((char) 2)); assertEquals((char) 2, queue.removeLast()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf((char) 1)); assertEquals((char) 1, queue.removeLast()); assertEquals(0, queue.size); }
CharQueue { public char removeFirst () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final char[] values = this.values; final char result = values[head]; head++; if (head == values.length) { head = 0; } size--; return result; } CharQueue(); CharQueue(int initialSize); void addLast(char object); void addFirst(char object); void ensureCapacity(int additional); char removeFirst(); char removeLast(); int indexOf(char value); boolean removeValue(char value); char removeIndex(int index); boolean notEmpty(); boolean isEmpty(); char first(); char last(); char get(int index); void clear(); Iterator<Character> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeFirstTest() { CharQueue queue = new CharQueue(); queue.addLast((char) 1); queue.addLast((char) 2); queue.addLast((char) 3); queue.addLast((char) 4); assertEquals(4, queue.size); assertEquals(0, queue.indexOf((char) 1)); assertEquals((char) 1, queue.removeFirst()); assertEquals(3, queue.size); assertEquals(0, queue.indexOf((char) 2)); assertEquals((char) 2, queue.removeFirst()); assertEquals(2, queue.size); assertEquals(0, queue.indexOf((char) 3)); assertEquals((char) 3, queue.removeFirst()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf((char) 4)); assertEquals((char) 4, queue.removeFirst()); assertEquals(0, queue.size); }
CharQueue { public char get (int index) { if (index < 0) throw new IndexOutOfBoundsException("index can't be < 0: " + index); if (index >= size) throw new IndexOutOfBoundsException("index can't be >= size: " + index + " >= " + size); final char[] values = this.values; int i = head + index; if (i >= values.length) { i -= values.length; } return values[i]; } CharQueue(); CharQueue(int initialSize); void addLast(char object); void addFirst(char object); void ensureCapacity(int additional); char removeFirst(); char removeLast(); int indexOf(char value); boolean removeValue(char value); char removeIndex(int index); boolean notEmpty(); boolean isEmpty(); char first(); char last(); char get(int index); void clear(); Iterator<Character> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void getTest () { final CharQueue q = new CharQueue(7); for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { q.addLast((char) j); } assertEquals("get(0) is not equal to peek (" + i + ")", q.get(0), q.first()); assertEquals("get(size-1) is not equal to peekLast (" + i + ")", q.get(q.size - 1), q.last()); for (int j = 0; j < 4; j++) { assertEquals(q.get(j), j); } for (int j = 0; j < 4 - 1; j++) { q.removeFirst(); assertEquals("get(0) is not equal to peek (" + i + ")", q.get(0), q.first()); } q.removeFirst(); assert q.size == 0; try { q.get(0); fail("get() on empty queue did not throw"); } catch (IndexOutOfBoundsException ignore) { } } }
CharQueue { public int indexOf (char value) { if (size == 0) return -1; char[] values = this.values; final int head = this.head, tail = this.tail; if (head < tail) { for (int i = head; i < tail; i++) if (values[i] == value) return i - head; } else { for (int i = head, n = values.length; i < n; i++) if (values[i] == value) return i - head; for (int i = 0; i < tail; i++) if (values[i] == value) return i + values.length - head; } return -1; } CharQueue(); CharQueue(int initialSize); void addLast(char object); void addFirst(char object); void ensureCapacity(int additional); char removeFirst(); char removeLast(); int indexOf(char value); boolean removeValue(char value); char removeIndex(int index); boolean notEmpty(); boolean isEmpty(); char first(); char last(); char get(int index); void clear(); Iterator<Character> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void indexOfTest () { final CharQueue q = new CharQueue(); for (int j = 0; j <= 6; j++) q.addLast((char) j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf((char) j), j); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst((char) j); for (int j = 3; j <= 6; j++) q.addLast((char) j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf((char) j), j); }
CharQueue { public Iterator<Character> iterator () { if (iterable == null) iterable = new CharQueueIterable(this); return iterable.iterator(); } CharQueue(); CharQueue(int initialSize); void addLast(char object); void addFirst(char object); void ensureCapacity(int additional); char removeFirst(); char removeLast(); int indexOf(char value); boolean removeValue(char value); char removeIndex(int index); boolean notEmpty(); boolean isEmpty(); char first(); char last(); char get(int index); void clear(); Iterator<Character> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void iteratorTest () { final CharQueue q = new CharQueue(); for (int j = 0; j <= 6; j++) q.addLast((char) j); Iterator<Character> iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next().charValue(), j); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, 1, 2, 3, 4, 5, 6); iter.next(); iter.remove(); assertValues(q, 2, 3, 4, 5, 6); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5, 6); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst((char) j); for (int j = 3; j <= 6; j++) q.addLast((char) j); iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next().charValue(), j); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, 1, 2, 3, 4, 5, 6); iter.next(); iter.remove(); assertValues(q, 2, 3, 4, 5, 6); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5, 6); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, 2, 4, 5); }
CharQueue { public String toString () { if (size == 0) { return "[]"; } final char[] values = this.values; final int head = this.head; final int tail = this.tail; StringBuilder sb = new StringBuilder(64); sb.append('['); sb.append(values[head]); for (int i = (head + 1) % values.length; i != tail; i = (i + 1) % values.length) { sb.append(", ").append(values[i]); } sb.append(']'); return sb.toString(); } CharQueue(); CharQueue(int initialSize); void addLast(char object); void addFirst(char object); void ensureCapacity(int additional); char removeFirst(); char removeLast(); int indexOf(char value); boolean removeValue(char value); char removeIndex(int index); boolean notEmpty(); boolean isEmpty(); char first(); char last(); char get(int index); void clear(); Iterator<Character> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void toStringTest () { CharQueue q = new CharQueue(1); assertEquals("[]", q.toString()); q.addLast((char) 4); assertEquals(q.toString(), "[" + '\4' + "]"); q.addLast((char) 5); q.addLast((char) 6); q.addLast((char) 7); assertEquals(q.toString(), "[" + '\4' + ", " + '\5' + ", " + '\6' + ", " + '\7' + "]"); }
RenderPipeline { public void update(GameContainer gc, float delta) { for(RenderOperation stage : operations) { stage.update(gc, delta); } } RenderPipeline(); void update(GameContainer gc, float delta); void interpolate(GameContainer gc, float alpha); void render(GameContainer gc, Graphics g); void add(RenderOperation operation); void remove(RenderOperation operation); boolean isOneWay(); void setOneWay(boolean oneWay); }
@Test public void testPipelineUpdate() { final float delta = 1.0f; mockery.checking(new Expectations() { { oneOf(operation1).update(gc, delta); oneOf(operation2).update(gc, delta); } }); pipeline.update(gc, delta); }
RenderPipeline { public void interpolate(GameContainer gc, float alpha) { for(RenderOperation stage : operations) { stage.interpolate(gc, alpha); } } RenderPipeline(); void update(GameContainer gc, float delta); void interpolate(GameContainer gc, float alpha); void render(GameContainer gc, Graphics g); void add(RenderOperation operation); void remove(RenderOperation operation); boolean isOneWay(); void setOneWay(boolean oneWay); }
@Test public void testPipelineInterpolate() { final float alpha = 1.0f; mockery.checking(new Expectations() { { oneOf(operation1).interpolate(gc, alpha); oneOf(operation2).interpolate(gc, alpha); } }); pipeline.interpolate(gc, alpha); }
RenderPipeline { public void render(GameContainer gc, Graphics g) { for(RenderOperation stage : operations) { stage.apply(gc, g); } if(oneWay) { return; } for(int i = operations.size - 1; i >= 0; i--) { operations.get(i).unapply(gc, g); } } RenderPipeline(); void update(GameContainer gc, float delta); void interpolate(GameContainer gc, float alpha); void render(GameContainer gc, Graphics g); void add(RenderOperation operation); void remove(RenderOperation operation); boolean isOneWay(); void setOneWay(boolean oneWay); }
@Test public void testDefaultPipeline() { final Sequence invokeSequence = mockery.sequence("sequence-name"); mockery.checking(new Expectations() { { oneOf(operation1).apply(gc, g); inSequence(invokeSequence); oneOf(operation2).apply(gc, g); inSequence(invokeSequence); oneOf(operation2).unapply(gc, g); inSequence(invokeSequence); oneOf(operation1).unapply(gc, g); inSequence(invokeSequence); } }); pipeline.render(gc, g); }
ScreenViewport extends Viewport { @Override public void onResize(int width, int height) { setBounds(0, 0, width, height, 1f, 1f); } @Override void onResize(int width, int height); }
@Test public void testOnResize() { viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT, viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); viewport.onResize(MathUtils.round(VIEWPORT_WIDTH * 1.5f), MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(MathUtils.round(VIEWPORT_WIDTH * 1.5f), viewport.getWidth()); Assert.assertEquals(MathUtils.round(VIEWPORT_HEIGHT * 1.5f), viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT * 2); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH * 2, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT * 2, viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); } @Test public void testToScreenCoordinates() { final Vector2 coordinates = new Vector2(); viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(MathUtils.round(VIEWPORT_WIDTH * 1.5f), MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT * 2); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); } @Test public void testToWorldCoordinates() { final Vector2 coordinates = new Vector2(); viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT); coordinates.set(1f, 1f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(MathUtils.round(VIEWPORT_WIDTH * 1.5f), MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); coordinates.set(1f, 1f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT * 2); coordinates.set(1f, 1f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); }
Tileset implements Disposable { public int getHeightInTiles() { return tilesetSource.getHeightInTiles(); } Tileset(int firstGid, TilesetSource tilesetSource); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); ObjectMap<String, String> getProperties(); void drawTile(Graphics g, int tileId, int renderX, int renderY); void drawTileset(Graphics g, int renderX, int renderY); Tile getTile(int tileId); Tile getTile(int x, int y); Array<AssetDescriptor> getDependencies(FileHandle tmxPath); boolean isTextureLoaded(); void loadTexture(FileHandle tmxPath); void loadTexture(AssetManager assetManager, FileHandle tmxPath); void loadTexture(TextureAtlas textureAtlas); @Override void dispose(); boolean contains(int tileId); int getTileId(int x, int y); int getTileX(int tileId); int getTileY(int tileId); int getWidthInTiles(); int getHeightInTiles(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getSpacing(); int getMargin(); int getFirstGid(); String getSourceInternalUuid(); }
@Test public void testGetHeightInTiles() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(4, tileset.getHeightInTiles()); tileset = new Tileset(1, new ImageTilesetSource(128, 96, 32, 32, 0, 0)); Assert.assertEquals(3, tileset.getHeightInTiles()); } @Test public void testGetHeightInTilesWithSpacing() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(3, tileset.getHeightInTiles()); tileset = new Tileset(1, new ImageTilesetSource(128, 96, 32, 32, 4, 0)); Assert.assertEquals(2, tileset.getHeightInTiles()); tileset = new Tileset(1, new ImageTilesetSource(1936, 1052, 32, 32, 2, 0)); Assert.assertEquals(31, tileset.getHeightInTiles()); } @Test public void testGetHeightInTilesWithMargin() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 4)); Assert.assertEquals(3, tileset.getHeightInTiles()); tileset = new Tileset(1, new ImageTilesetSource(128, 96, 32, 32, 0, 4)); Assert.assertEquals(2, tileset.getHeightInTiles()); }
ExtendViewport extends Viewport { @Override public void onResize(int width, int height) { float worldWidth = minWorldWidth; float worldHeight = minWorldHeight; Scaling.FIT.apply(size, scale, powerOfTwo, worldWidth, worldHeight, width, height); int viewportWidth = Math.round(size.x); int viewportHeight = Math.round(size.y); if (viewportWidth < width) { float toViewportSpace = viewportHeight / worldHeight; float toWorldSpace = worldHeight / viewportHeight; float lengthen = (width - viewportWidth) * toWorldSpace; if (maxWorldWidth > 0) lengthen = Math.min(lengthen, maxWorldWidth - minWorldWidth); worldWidth += lengthen; viewportWidth += Math.round(lengthen * toViewportSpace); } if (viewportHeight < height) { float toViewportSpace = viewportWidth / worldWidth; float toWorldSpace = worldWidth / viewportWidth; float lengthen = (height - viewportHeight) * toWorldSpace; if (maxWorldHeight > 0) lengthen = Math.min(lengthen, maxWorldHeight - minWorldHeight); worldHeight += lengthen; viewportHeight += Math.round(lengthen * toViewportSpace); } setBounds((width - viewportWidth) / MathUtils.round(2 * scale.x), (height - viewportHeight) / MathUtils.round(2 * scale.y), MathUtils.round(worldWidth), MathUtils.round(worldHeight), scale.x, scale.y); } ExtendViewport(float minWorldWidth, float minWorldHeight); ExtendViewport(float minWorldWidth, float minWorldHeight, float maxWorldWidth, float maxWorldHeight); ExtendViewport(boolean powerOfTwo, float minWorldWidth, float minWorldHeight); ExtendViewport(boolean powerOfTwo, float minWorldWidth, float minWorldHeight, float maxWorldWidth, float maxWorldHeight); @Override void onResize(int width, int height); float getMinWorldWidth(); void setMinWorldWidth(float minWorldWidth); float getMinWorldHeight(); void setMinWorldHeight(float minWorldHeight); float getMaxWorldWidth(); void setMaxWorldWidth(float maxWorldWidth); float getMaxWorldHeight(); void setMaxWorldHeight(float maxWorldHeight); boolean isPowerOfTwo(); void setPowerOfTwo(boolean powerOfTwo); }
@Test public void testOnResize() { viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT, viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); viewport.onResize(MathUtils.round(VIEWPORT_WIDTH * 1.5f), MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT, viewport.getHeight()); Assert.assertEquals(1.5f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1.5f, viewport.getScaleY(), 0.01f); viewport.onResize(VIEWPORT_WIDTH, MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH, viewport.getWidth()); Assert.assertEquals(MathUtils.round(VIEWPORT_HEIGHT * 1.5f), viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT * 2); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT, viewport.getHeight()); Assert.assertEquals(2f, viewport.getScaleX(), 0.01f); Assert.assertEquals(2f, viewport.getScaleY(), 0.01f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH * 2, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT, viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT * 2); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(VIEWPORT_WIDTH, viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT * 2, viewport.getHeight()); Assert.assertEquals(1f, viewport.getScaleX(), 0.01f); Assert.assertEquals(1f, viewport.getScaleY(), 0.01f); viewport.onResize(VIEWPORT_WIDTH * 3, MathUtils.round(VIEWPORT_HEIGHT * 2f)); Assert.assertEquals(0, viewport.getX()); Assert.assertEquals(0, viewport.getY()); Assert.assertEquals(MathUtils.round(VIEWPORT_WIDTH * 1.5f), viewport.getWidth()); Assert.assertEquals(VIEWPORT_HEIGHT, viewport.getHeight()); Assert.assertEquals(2f, viewport.getScaleX(), 0.01f); Assert.assertEquals(2f, viewport.getScaleY(), 0.01f); } @Test public void testToScreenCoordinates() { viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT); final Vector2 coordinates = new Vector2(); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(MathUtils.round(VIEWPORT_WIDTH * 1.5f), MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1.5f, coordinates.x, 0.001f); Assert.assertEquals(1.5f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT * 2); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(2f, coordinates.x, 0.001f); Assert.assertEquals(2f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT * 2); coordinates.set(1f, 1f); viewport.toScreenCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); } @Test public void testToWorldCoordinates() { final Vector2 coordinates = new Vector2(); viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT); coordinates.set(1f, 1f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(MathUtils.round(VIEWPORT_WIDTH * 1.5f), MathUtils.round(VIEWPORT_HEIGHT * 1.5f)); coordinates.set(1.5f, 1.5f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT * 2); coordinates.set(2f, 2f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH * 2, VIEWPORT_HEIGHT); coordinates.set(1f, 1f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); viewport.onResize(VIEWPORT_WIDTH, VIEWPORT_HEIGHT * 2); coordinates.set(1f, 1f); viewport.toWorldCoordinates(coordinates); Assert.assertEquals(1f, coordinates.x, 0.001f); Assert.assertEquals(1f, coordinates.y, 0.001f); }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public boolean add(T element) { if (element == null) return false; if (!this.contains(element.getX(), element.getY())) { return false; } clearTotalElementsCache(); return addElement(element); } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testAdd() { Random random = new Random(); for (int i = 0; i < 100; i++) { rootQuad.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); Assert.assertEquals(i + 1, rootQuad.getElements().size); } }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public void addAll(Array<T> elementsToAdd) { if (elementsToAdd == null || elementsToAdd.size == 0) return; clearTotalElementsCache(); Array<T> elementsWithinQuad = new Array<T>(); for (T element : elementsToAdd) { if (this.contains(element.getX(), element.getY())) { elementsWithinQuad.add(element); } } lock.lockWrite(); if (topLeft != null) { lock.lockRead(); lock.unlockWrite(); for (T element : elementsWithinQuad) { if (topLeft.add(element)) { continue; } if (topRight.add(element)) { continue; } if (bottomLeft.add(element)) { continue; } if (bottomRight.add(element)) { continue; } } lock.unlockRead(); return; } this.elements.addAll(elementsWithinQuad); for (T element : elementsWithinQuad) { element.addPostionChangeListener(this); } int totalElements = this.elements.size; lock.unlockWrite(); if (totalElements > elementLimitPerQuad && (getWidth() * 0.5f) >= minimumQuadWidth && (getHeight() * 0.5f) >= minimumQuadHeight) { subdivide(); } } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testAddAll() { Random random = new Random(); Array<CollisionPoint> points = new Array<CollisionPoint>(); for (int i = 0; i < 100; i++) { points.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } rootQuad.addAll(points); Assert.assertEquals(points.size, rootQuad.getTotalElements()); }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public boolean remove(T element) { if (element == null) return false; if (!this.contains(element.getX(), element.getY())) { return false; } clearTotalElementsCache(); lock.lockRead(); if (topLeft != null) { return removeElementFromChild(element); } lock.unlockRead(); return removeElement(element, true); } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testRemove() { Random random = new Random(); Array<CollisionPoint> collisionPoints = new Array<CollisionPoint>(); for (int i = 0; i < 1000; i++) { collisionPoints.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } for (int i = 0; i < collisionPoints.size; i++) { Assert.assertEquals(true, rootQuad.add(collisionPoints.get(i))); Assert.assertEquals(i + 1, rootQuad.getElements().size); } for (int i = collisionPoints.size - 1; i >= 0; i--) { Assert.assertEquals(i + 1, rootQuad.getElements().size); rootQuad.remove(collisionPoints.get(i)); Assert.assertEquals(i, rootQuad.getElements().size); } }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public void removeAll(Array<T> elementsToRemove) { if (elementsToRemove == null || elementsToRemove.size == 0) { return; } clearTotalElementsCache(); Array<T> elementsWithinQuad = new Array<T>(); for (T element : elementsToRemove) { if (this.contains(element.getX(), element.getY())) { elementsWithinQuad.add(element); } } lock.lockRead(); if (topLeft != null) { for (int i = elementsWithinQuad.size - 1; i >= 0; i--) { T element = elementsWithinQuad.get(i); if (topLeft.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } if (topRight.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } if (bottomLeft.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } if (bottomRight.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } } } lock.unlockRead(); lock.lockWrite(); elements.removeAll(elementsWithinQuad, false); lock.unlockWrite(); for (T element : elementsWithinQuad) { element.removePositionChangeListener(this); } if (parent == null) { return; } if (parent.isMergable()) { parent.merge(); } } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testRemoveAll() { Random random = new Random(); Array<CollisionPoint> points = new Array<CollisionPoint>(); for (int i = 0; i < 100; i++) { points.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } rootQuad.addAll(points); Assert.assertEquals(points.size, rootQuad.getTotalElements()); rootQuad.removeAll(points); Assert.assertEquals(0, rootQuad.getTotalElements()); }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { protected void subdivide() { lock.lockRead(); if (topLeft != null) { lock.unlockRead(); return; } lock.unlockRead(); lock.lockWrite(); if (topLeft != null) { lock.unlockWrite(); return; } float halfWidth = getWidth() / 2f; float halfHeight = getHeight() / 2f; topLeft = new ConcurrentPointQuadTree<T>(this, getX(), getY(), halfWidth, halfHeight); topRight = new ConcurrentPointQuadTree<T>(this, getX() + halfWidth, getY(), halfWidth, halfHeight); bottomLeft = new ConcurrentPointQuadTree<T>(this, getX(), getY() + halfHeight, halfWidth, halfHeight); bottomRight = new ConcurrentPointQuadTree<T>(this, getX() + halfWidth, getY() + halfHeight, halfWidth, halfHeight); for (int i = elements.size - 1; i >= 0; i--) { T element = elements.removeIndex(i); element.removePositionChangeListener(this); lock.lockRead(); addElementToChild(element); } lock.unlockWrite(); } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testSubdivide() { rootQuad.add(point1); Assert.assertEquals(1, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(point2); Assert.assertEquals(2, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(point3); Assert.assertEquals(3, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(point4); Assert.assertEquals(4, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionPoint(32, 32)); Assert.assertEquals(5, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionPoint(48, 48)); Assert.assertEquals(6, rootQuad.getElements().size); Assert.assertEquals(7, rootQuad.getTotalQuads()); }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public int getTotalElements() { if (totalElementsCache >= 0) { return totalElementsCache; } lock.lockRead(); if (topLeft != null) { totalElementsCache = topLeft.getTotalElements(); totalElementsCache += topRight.getTotalElements(); totalElementsCache += bottomLeft.getTotalElements(); totalElementsCache += bottomRight.getTotalElements(); } else { totalElementsCache = elements.size; } lock.unlockRead(); return totalElementsCache; } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testGetTotalElements() { rootQuad.add(point1); Assert.assertEquals(1, rootQuad.getTotalElements()); rootQuad.add(point2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(point3); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.remove(point2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(point4); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.add(point2); Assert.assertEquals(4, rootQuad.getTotalElements()); rootQuad.add(new CollisionPoint(32, 32)); Assert.assertEquals(5, rootQuad.getTotalElements()); rootQuad.add(new CollisionPoint(48, 48)); Assert.assertEquals(6, rootQuad.getTotalElements()); }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment) { Array<T> result = new Array<T>(); getElementsIntersectingLineSegment(result, lineSegment); return result; } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testGetElementsIntersectingLineSegment() { rootQuad.add(point1); rootQuad.add(point2); rootQuad.add(point3); rootQuad.add(point4); Array<CollisionPoint> collisionPoints = rootQuad .getElementsIntersectingLineSegment(new LineSegment(0, 0, 128, 128)); Assert.assertEquals(true, collisionPoints.contains(point1, false)); Assert.assertEquals(false, collisionPoints.contains(point2, false)); Assert.assertEquals(false, collisionPoints.contains(point3, false)); Assert.assertEquals(true, collisionPoints.contains(point4, false)); }
ConcurrentPointQuadTree extends Rectangle implements QuadTree<T> { public int getTotalMergeOperations() { lock.lockRead(); int result = totalMerges; if(topLeft != null) { result += topLeft.getTotalMergeOperations(); result += topRight.getTotalMergeOperations(); result += bottomLeft.getTotalMergeOperations(); result += bottomRight.getTotalMergeOperations(); } lock.unlockRead(); return result; } ConcurrentPointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); ConcurrentPointQuadTree(ConcurrentPointQuadTree<T> parent, float x, float y, float width, float height); ConcurrentPointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); ConcurrentPointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); @Override void clear(); boolean remove(T element); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getTotalMergeOperations(); int getElementLimitPerQuad(); int getMergeWatermark(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testMergingConcurrency() throws TimeoutException { rootQuad = new ConcurrentPointQuadTree<CollisionPoint>(CONCURRENCY_TEST_WATERMARK * 2, CONCURRENCY_TEST_WATERMARK, 0, 0, TREE_WIDTH, TREE_HEIGHT); for (int i = 0; i < MathUtils.round(TREE_WIDTH); i++) { createNextCollision(); } int totalThreads = Runtime.getRuntime().availableProcessors(); if (totalThreads % 2 == 1) { totalThreads++; } for (int i = 0; i < totalThreads; i++) { new Thread(this).start(); } waiter.await(CONCURRENCY_TEST_TIMEOUT); System.out.println(rootQuad.getTotalMergeOperations() + " total merge operations, " + collisionsFound.getAndIncrement() + " collisions found concurrently"); Assert.assertEquals(true, rootQuad.getTotalMergeOperations() > 0); Assert.assertEquals(true, collisionsFound.get() > 0); Assert.assertEquals(false, concurrencyExceptionOccurred.get()); }
RegionQuadTree extends PointQuadTree<T> { @Override public boolean add(T element) { if (element == null) return false; if (!this.intersects(element) && !this.contains(element)) { return false; } clearTotalElementsCache(); if (topLeft == null) { return addElement(element); } if (addElementToChild(element)) { return true; } return addElement(element); } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testAdd() { int totalElements = 100; Random random = new Random(); long startTime = System.nanoTime(); for(int i = 0; i < totalElements; i++) { CollisionBox rect = new CollisionBox(random.nextInt(96), random.nextInt(96), 32f, 32f); Assert.assertEquals(true, rootQuad.add(rect)); Assert.assertEquals(i + 1, rootQuad.getTotalElements()); } long duration = System.nanoTime() - startTime; System.out.println("Took " + duration + "ns to add " + totalElements + " elements individually to " + RegionQuadTree.class.getSimpleName()); }
RegionQuadTree extends PointQuadTree<T> { @Override public void addAll(Array<T> elementsToAdd) { if (elementsToAdd == null || elementsToAdd.size == 0) { return; } clearTotalElementsCache(); Array<T> elementsWithinQuad = new Array<T>(); for (T element : elementsToAdd) { if (this.contains(element) || this.intersects(element)) { elementsWithinQuad.add(element); } } for (T element : elementsWithinQuad) { if (topLeft == null) { addElement(element); continue; } if (addElementToChild(element)) { continue; } addElement(element); } } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testAddAll() { int totalElements = 100; Random random = new Random(); Array<CollisionBox> rects = new Array<CollisionBox>(); long startTime = System.nanoTime(); for(int i = 0; i < totalElements; i++) { rects.add(new CollisionBox(random.nextInt(96), random.nextInt(96), 32f, 32f)); } rects.add(new CollisionBox(-4f, -4f, 32f, 32f)); rootQuad.addAll(rects); long duration = System.nanoTime() - startTime; System.out.println("Took " + duration + "ns to add " + totalElements + " elements in bulk to " + RegionQuadTree.class.getSimpleName()); Assert.assertEquals(rects.size, rootQuad.getTotalElements()); }
RegionQuadTree extends PointQuadTree<T> { @Override public boolean remove(T element) { if (element == null) return false; if (!this.intersects(element) && !this.contains(element)) { return false; } clearTotalElementsCache(); if (removeElement(element)) { return true; } if (topLeft == null) { return false; } return removeElementFromChild(element); } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testRemove() { Random random = new Random(); Array<CollisionBox> collisionBoxs = new Array<CollisionBox>(); for(int i = 0; i < 1000; i++) { collisionBoxs.add(new CollisionBox(random.nextInt(96), random.nextInt(96), random.nextInt(32), random.nextInt(32))); } for(int i = 0; i < collisionBoxs.size; i++) { rootQuad.add(collisionBoxs.get(i)); Assert.assertEquals(i + 1, rootQuad.getElements().size); } for(int i = collisionBoxs.size - 1; i >= 0 ; i--) { Assert.assertEquals(i + 1, rootQuad.getElements().size); rootQuad.remove(collisionBoxs.get(i)); Assert.assertEquals(i, rootQuad.getElements().size); } }
RegionQuadTree extends PointQuadTree<T> { @Override public void clear() { if (topLeft != null) { topLeft.clear(); topRight.clear(); bottomLeft.clear(); bottomRight.clear(); topLeft = null; topRight = null; bottomLeft = null; bottomRight = null; } elements.clear(); clearTotalElementsCache(); } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testClear() { Random random = new Random(); Array<CollisionBox> rects = new Array<CollisionBox>(); for(int i = 0; i < 100; i++) { rects.add(new CollisionBox(random.nextInt(96), random.nextInt(96), random.nextInt(32), random.nextInt(32))); } rootQuad.addAll(rects); Assert.assertEquals(rects.size, rootQuad.getTotalElements()); rootQuad.clear(); Assert.assertEquals(0, rootQuad.getTotalElements()); }
RegionQuadTree extends PointQuadTree<T> { @Override protected void subdivide() { if (topLeft != null) return; float halfWidth = getWidth() / 2f; float halfHeight = getHeight() / 2f; topLeft = new RegionQuadTree<T>(this, getX(), getY(), halfWidth, halfHeight); topRight = new RegionQuadTree<T>(this, getX() + halfWidth, getY(), halfWidth, halfHeight); bottomLeft = new RegionQuadTree<T>(this, getX(), getY() + halfHeight, halfWidth, halfHeight); bottomRight = new RegionQuadTree<T>(this, getX() + halfWidth, getY() + halfHeight, halfWidth, halfHeight); for (int i = elements.size - 1; i >= 0; i--) { if (addElementToChild(elements.get(i))) { removeElement(elements.get(i)); } } } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testSubdivide() { rootQuad.add(box1); Assert.assertEquals(1, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(box2); Assert.assertEquals(2, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(box3); Assert.assertEquals(3, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(box4); Assert.assertEquals(4, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionBox(24, 24, 2, 2)); Assert.assertEquals(5, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionBox(48, 48, 32, 32)); Assert.assertEquals(6, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionBox(12, 48, 8, 8)); Assert.assertEquals(7, rootQuad.getElements().size); Assert.assertEquals(7, rootQuad.getTotalQuads()); }
RegionQuadTree extends PointQuadTree<T> { @Override public int getTotalElements() { if (totalElementsCache >= 0) { return totalElementsCache; } totalElementsCache = 0; if (topLeft != null) { totalElementsCache = topLeft.getTotalElements(); totalElementsCache += topRight.getTotalElements(); totalElementsCache += bottomLeft.getTotalElements(); totalElementsCache += bottomRight.getTotalElements(); } totalElementsCache += elements.size; return totalElementsCache; } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetTotalElements() { rootQuad.add(box1); Assert.assertEquals(1, rootQuad.getTotalElements()); rootQuad.add(box2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(box3); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.remove(box2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(box4); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.add(box2); Assert.assertEquals(4, rootQuad.getTotalElements()); rootQuad.add(new CollisionBox(48, 48, 32, 32)); Assert.assertEquals(5, rootQuad.getTotalElements()); rootQuad.add(new CollisionBox(12, 48, 8, 8)); Assert.assertEquals(6, rootQuad.getTotalElements()); }
RegionQuadTree extends PointQuadTree<T> { @Override public void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment) { if (topLeft != null) { if (intersects(topLeft, lineSegment)) { topLeft.getElementsIntersectingLineSegment(result, lineSegment); } if (intersects(topRight, lineSegment)) { topRight.getElementsIntersectingLineSegment(result, lineSegment); } if (intersects(bottomLeft, lineSegment)) { bottomLeft.getElementsIntersectingLineSegment(result, lineSegment); } if (intersects(bottomRight, lineSegment)) { bottomRight.getElementsIntersectingLineSegment(result, lineSegment); } } addElementsIntersectingLineSegment(result, lineSegment); } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsIntersectingLineSegment() { rootQuad.add(box1); rootQuad.add(box2); rootQuad.add(box3); rootQuad.add(box4); Array<CollisionBox> collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(0, 0, 128, 128)); Assert.assertEquals(2, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); Assert.assertEquals(true, collisionBoxs.contains(box4, false)); CollisionBox collisionBox5 = new CollisionBox(24, 24, 2, 2); CollisionBox collisionBox6 = new CollisionBox(48, 48, 32, 32); CollisionBox collisionBox7 = new CollisionBox(12, 48, 8, 8); rootQuad.add(collisionBox5); rootQuad.add(collisionBox6); rootQuad.add(collisionBox7); collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(0, 0, 128, 128)); Assert.assertEquals(4, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); Assert.assertEquals(true, collisionBoxs.contains(box4, false)); Assert.assertEquals(true, collisionBoxs.contains(collisionBox5, false)); Assert.assertEquals(true, collisionBoxs.contains(collisionBox6, false)); }
RegionQuadTree extends PointQuadTree<T> { @Override public void getElementsContainingPoint(Array<T> result, Point point) { if (topLeft != null) { if (topLeft.contains(point)) topLeft.getElementsContainingPoint(result, point); if (topRight.contains(point)) topRight.getElementsContainingPoint(result, point); if (bottomLeft.contains(point)) bottomLeft.getElementsContainingPoint(result, point); if (bottomRight.contains(point)) bottomRight.getElementsContainingPoint(result, point); } for (int i = elements.size - 1; i >= 0; i--) { T element = elements.get(i); if (element != null && element.contains(point)) { result.add(element); } } } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingPoint() { rootQuad.add(box1); rootQuad.add(box2); rootQuad.add(box3); rootQuad.add(box4); Array<CollisionBox> collisionBoxs = rootQuad.getElementsContainingPoint(new Point(16, 16)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingPoint(new Point(112, 16)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box2, false)); collisionBoxs = rootQuad.getElementsContainingPoint(new Point(16, 112)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box3, false)); collisionBoxs = rootQuad.getElementsContainingPoint(new Point(112, 112)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box4, false)); }
RegionQuadTree extends PointQuadTree<T> { private void getElementsContainingPointUpwards(Array<T> result, Point point, boolean firstInvocation) { if (elements != null){ addElementsContainingPoint(result, point); } if (firstInvocation && topLeft != null){ if (topLeft.contains(point)){ topLeft.getElementsContainingPoint(result, point); } if (topRight.contains(point)){ topRight.getElementsContainingPoint(result, point); } if (bottomLeft.contains(point)){ bottomLeft.getElementsContainingPoint(result, point); } if (bottomRight.contains(point)){ bottomRight.getElementsContainingPoint(result, point); } } if (parent != null){ if (parent.topLeft != this && (parent.topLeft.contains(point) || parent.topLeft.contains(point))) { parent.topLeft.getElementsContainingPoint(result, point); } if (parent.topRight != this && (parent.topRight.contains(point) || parent.topRight.contains(point))) { parent.topRight.getElementsContainingPoint(result, point); } if (parent.bottomLeft != this && (parent.bottomLeft.contains(point) || parent.bottomLeft.contains(point))) { parent.bottomLeft.getElementsContainingPoint(result, point); } if (parent.bottomRight != this && (parent.bottomRight.contains(point) || parent.bottomRight.contains(point))) { parent.bottomRight.getElementsContainingPoint(result, point); } ((RegionQuadTree<T>)parent).getElementsContainingPointUpwards(result, point, false); } } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingPointUpwards() { rootQuad.add(qABox1); rootQuad.add(qABox2); rootQuad.add(qABox3); rootQuad.add(qABox4); Array<CollisionBox> collisionBoxs = qABox1.getQuad().getElementsContainingPoint(new Point(16, 16), QuadTreeSearchDirection.UPWARDS); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingPoint(new Point(112, 16)); Assert.assertEquals(0, collisionBoxs.size); collisionBoxs = qABox1.getQuad().getElementsContainingPoint(new Point(112, 16), QuadTreeSearchDirection.UPWARDS); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox2, false)); collisionBoxs = qABox3.getQuad().getElementsContainingPoint(new Point(16, 112), QuadTreeSearchDirection.UPWARDS); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox3, false)); collisionBoxs = qABox4.getQuad().getElementsContainingPoint(new Point(112, 112), QuadTreeSearchDirection.UPWARDS); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox4, false)); }
RegionQuadTree extends PointQuadTree<T> { @Override public Array<T> getElementsContainingArea(Shape area, boolean entirelyContained) { Array<T> result = new Array<T>(); getElementsContainingArea(result, area, entirelyContained); return result; } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingArea() { rootQuad.add(box1); Array<CollisionBox> collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(2, 2, 10, 10), false); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(2, 2, 10, 10), true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(40, 40, 10, 10), false); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(40, 40, 10, 10), true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(25, 25, 10, 10), false); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(25, 25, 10, 10), true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(0.5f, 0.5f, 64, 64), false); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(0.5f, 0.5f, 64, 64), true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); }
RegionQuadTree extends PointQuadTree<T> { protected void getElementsContainingAreaUpwards(Array<T> result, Shape area, boolean firstInvocation, boolean entirelyContained) { if (elements != null) { addElementsContainingArea(result, area, entirelyContained); } if (firstInvocation && topLeft != null){ if (area.contains(topLeft) || area.intersects(topLeft)){ topLeft.getElementsContainingArea(result, area, entirelyContained); } if (area.contains(topRight) || area.intersects(topRight)){ topRight.getElementsContainingArea(result, area, entirelyContained); } if (area.contains(bottomLeft) || area.intersects(bottomLeft)){ bottomLeft.getElementsContainingArea(result, area, entirelyContained); } if (area.contains(bottomRight) || area.intersects(bottomRight)){ bottomRight.getElementsContainingArea(result, area, entirelyContained); } } if (parent != null) { if (parent.topLeft != this && (area.contains(parent.topLeft) || area.intersects(parent.topLeft))) { parent.topLeft.getElementsContainingArea(result, area, entirelyContained); } if (parent.topRight != this && (area.contains(parent.topRight) || area.intersects(parent.topRight))) { parent.topRight.getElementsContainingArea(result, area, entirelyContained); } if (parent.bottomLeft != this && (area.contains(parent.bottomLeft) || area.intersects(parent.bottomLeft))) { parent.bottomLeft.getElementsContainingArea(result, area, entirelyContained); } if (parent.bottomRight != this && (area.contains(parent.bottomRight) || area.intersects(parent.bottomRight))) { parent.bottomRight.getElementsContainingArea(result, area, entirelyContained); } ((RegionQuadTree<T>)parent).getElementsContainingAreaUpwards(result, area, false, entirelyContained); } } RegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); RegionQuadTree(int elementLimit, float x, float y, float width, float height); RegionQuadTree(RegionQuadTree<T> parent, float x, float y, float width, float height); RegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elementsToAdd); @Override boolean add(T element); @Override boolean remove(T element); @Override void clear(); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingAreaUpwards() { rootQuad.add(qABox1); rootQuad.add(qABox2); rootQuad.add(qABox3); rootQuad.add(qABox4); Array<CollisionBox> collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(16, 16, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea(new CollisionBox(112, 16, 1, 1), true); Assert.assertEquals(0, collisionBoxs.size); collisionBoxs = qABox1.getQuad().getElementsContainingArea(new CollisionBox(112, 16, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox2, false)); collisionBoxs = qABox3.getQuad().getElementsContainingArea(new CollisionBox(16, 112, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox3, false)); collisionBoxs = qABox4.getQuad().getElementsContainingArea(new CollisionBox(112, 112, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox4, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(16, 16, 20, 10), QuadTreeSearchDirection.UPWARDS, false); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(16, 16, 20, 10), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(0.5f, 0.5f, 40, 40), QuadTreeSearchDirection.UPWARDS, false); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(0.5f, 0.5f, 40, 40), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(qABox1, false)); }
CollisionPolygon extends Polygon implements CollisionArea, PositionChangeListener<CollisionPolygon>, SizeChangeListener<CollisionPolygon> { @Override public <T extends Positionable> void addPostionChangeListener( PositionChangeListener<T> listener) { positionChangeListenerLock.lockWrite(); if (positionChangeListeners == null) { positionChangeListeners = new Array<PositionChangeListener>(true, 1); } positionChangeListeners.add(listener); positionChangeListenerLock.unlockWrite(); } CollisionPolygon(float [] vertices); CollisionPolygon(Vector2[] vectors); CollisionPolygon(int id, float[] vertices); CollisionPolygon(int id, Vector2[] vectors); CollisionPolygon(int id, Collisions collisions, float [] vertices); CollisionPolygon(int id, Collisions collisions, Vector2[] vectors); @Override void dispose(); @Override void preUpdate(); @Override void interpolate(float alpha); @Override void forceTo(float x, float y); @Override CollisionArea setTo(float x, float y, float width, float height); @Override void forceTo(float x, float y, float width, float height); @Override void forceToWidth(float width); @Override void forceToHeight(float height); void forceTo(float [] vertices); @Override int getId(); @Override int getRenderX(); @Override int getRenderY(); @Override float getRawRenderX(); @Override float getRawRenderY(); @Override int getRenderWidth(); @Override int getRenderHeight(); @Override float getRawRenderWidth(); @Override float getRawRenderHeight(); int getRenderX(int index); int getRenderY(int index); @Override void positionChanged(CollisionPolygon moved); @Override void sizeChanged(CollisionPolygon changed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); @Override void addSizeChangeListener(SizeChangeListener<T> listener); @Override void removeSizeChangeListener(SizeChangeListener<T> listener); @Override RenderCoordMode getRenderCoordMode(); @Override void setRenderCoordMode(RenderCoordMode mode); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testSet() { polygon1.addPostionChangeListener(this); polygon1.setXY(10f, 10f); Assert.assertEquals(1, positionNotificationReceived); } @Test public void testAddPoint() { polygon1.addPostionChangeListener(this); polygon1.addPoint(new Vector2(-5f, 5f)); Assert.assertEquals(1, positionNotificationReceived); }
PointQuadTree extends Rectangle implements QuadTree<T> { public boolean add(T element) { if (element == null) return false; if (!this.contains(element.getX(), element.getY())) { return false; } clearTotalElementsCache(); if (topLeft != null) { return addElementToChild(element); } return addElement(element); } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testAdd() { Random random = new Random(); for(int i = 0; i < 100; i++) { rootQuad.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); Assert.assertEquals(i + 1, rootQuad.getElements().size); } }
PointQuadTree extends Rectangle implements QuadTree<T> { public void addAll(Array<T> elementsToAdd) { if (elementsToAdd == null || elementsToAdd.size == 0) { return; } Array<T> elementsWithinQuad = new Array<T>(); for (T element : elementsToAdd) { if (this.contains(element.getX(), element.getY())) { elementsWithinQuad.add(element); } } clearTotalElementsCache(); if (topLeft != null) { for (T element : elementsWithinQuad) { addElementToChild(element); } return; } for (T element : elementsWithinQuad) { elements.add(element); element.addPostionChangeListener(this); } if (elements.size > elementLimitPerQuad && (getWidth() * 0.5f) >= minimumQuadWidth && (getHeight() * 0.5f) >= minimumQuadHeight) { subdivide(); } } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testAddAll() { Random random = new Random(); Array<CollisionPoint> points = new Array<CollisionPoint>(); for(int i = 0; i < 100; i++) { points.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } rootQuad.addAll(points); Assert.assertEquals(points.size, rootQuad.getTotalElements()); }
PointQuadTree extends Rectangle implements QuadTree<T> { public boolean remove(T element) { if (element == null) return false; if (!this.contains(element.getX(), element.getY())) { return false; } clearTotalElementsCache(); if (topLeft != null) { return removeElementFromChild(element); } return removeElement(element); } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testRemove() { Random random = new Random(); Array<CollisionPoint> collisionPoints = new Array<CollisionPoint>(); for(int i = 0; i < 1000; i++) { collisionPoints.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } for(int i = 0; i < collisionPoints.size; i++) { Assert.assertEquals(true, rootQuad.add(collisionPoints.get(i))); Assert.assertEquals(i + 1, rootQuad.getElements().size); } for(int i = collisionPoints.size - 1; i >= 0 ; i--) { Assert.assertEquals(i + 1, rootQuad.getElements().size); rootQuad.remove(collisionPoints.get(i)); Assert.assertEquals(i, rootQuad.getElements().size); } }
PointQuadTree extends Rectangle implements QuadTree<T> { public void removeAll(Array<T> elementsToRemove) { if (elementsToRemove == null || elementsToRemove.size == 0) { return; } Array<T> elementsWithinQuad = new Array<T>(); for (T element : elementsToRemove) { if (this.contains(element.getX(), element.getY())) { elementsWithinQuad.add(element); } } clearTotalElementsCache(); if (topLeft != null) { for (T element : elementsWithinQuad) { removeElementFromChild(element); } } if (elements == null) { return; } elements.removeAll(elementsWithinQuad, false); for (T element : elementsWithinQuad) { element.removePositionChangeListener(this); } if (parent == null) { return; } if (parent.isMergable()) { parent.merge(); } } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testRemoveAll() { Random random = new Random(); Array<CollisionPoint> points = new Array<CollisionPoint>(); for(int i = 0; i < 100; i++) { points.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } rootQuad.addAll(points); Assert.assertEquals(points.size, rootQuad.getTotalElements()); rootQuad.removeAll(points); Assert.assertEquals(0, rootQuad.getTotalElements()); }
PointQuadTree extends Rectangle implements QuadTree<T> { public void clear() { if (topLeft != null) { topLeft.clear(); topRight.clear(); bottomLeft.clear(); bottomRight.clear(); topLeft = null; topRight = null; bottomLeft = null; bottomRight = null; elements = new Array<T>(true, elementLimitPerQuad); } else { elements.clear(); } clearTotalElementsCache(); } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testClear() { Random random = new Random(); Array<CollisionPoint> points = new Array<CollisionPoint>(); for(int i = 0; i < 100; i++) { points.add(new CollisionPoint(random.nextInt(128), random.nextInt(128))); } rootQuad.addAll(points); Assert.assertEquals(points.size, rootQuad.getTotalElements()); rootQuad.clear(); Assert.assertEquals(0, rootQuad.getTotalElements()); }
TiledObjectTemplate { public TiledObjectTemplate(String path, Tileset tileset, TiledObject tiledObject) { super(); this.path = path; this.tileset = tileset; this.tiledObject = tiledObject; } TiledObjectTemplate(String path, Tileset tileset, TiledObject tiledObject); String getPath(); Tileset getTileset(); TiledObject getTiledObject(); }
@Test public void testTiledObjectTemplate() throws TiledException { final String objectGroupName = "Objects"; final String propertyName = "testProperty"; Assert.assertEquals(1, tiledMap.getTilesets().size); final TiledObject templateObject = tiledMap.getObjectGroup(objectGroupName).getObjectById(3); Assert.assertEquals("SUCCESS", templateObject.getProperty(propertyName)); final TiledObject overrideTemplateObject = tiledMap.getObjectGroup(objectGroupName).getObjectById(4); Assert.assertEquals("FAILED", overrideTemplateObject.getProperty(propertyName)); Assert.assertEquals(1, TiledMapData.OBJECT_TEMPLATE_TILESET_SOURCES.size); }
PointQuadTree extends Rectangle implements QuadTree<T> { protected void subdivide() { if (topLeft != null) { return; } float halfWidth = getWidth() * 0.5f; float halfHeight = getHeight() * 0.5f; topLeft = new PointQuadTree<T>(this, getX(), getY(), halfWidth, halfHeight); topRight = new PointQuadTree<T>(this, getX() + halfWidth, getY(), halfWidth, halfHeight); bottomLeft = new PointQuadTree<T>(this, getX(), getY() + halfHeight, halfWidth, halfHeight); bottomRight = new PointQuadTree<T>(this, getX() + halfWidth, getY() + halfHeight, halfWidth, halfHeight); for (int i = elements.size - 1; i >= 0; i--) { T element = elements.removeIndex(i); element.removePositionChangeListener(this); addElementToChild(element); } elements = null; } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testSubdivide() { rootQuad.add(point1); Assert.assertEquals(1, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(point2); Assert.assertEquals(2, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(point3); Assert.assertEquals(3, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(point4); Assert.assertEquals(4, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionPoint(32, 32)); Assert.assertEquals(5, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionPoint(48, 48)); Assert.assertEquals(6, rootQuad.getElements().size); Assert.assertEquals(7, rootQuad.getTotalQuads()); }
PointQuadTree extends Rectangle implements QuadTree<T> { protected void merge() { if (topLeft == null) { return; } elements = new Array<>(true, elementLimitPerQuad); topLeft.getElements(elements); topRight.getElements(elements); bottomLeft.getElements(elements); bottomRight.getElements(elements); for (T element : elements) { topLeft.elements.removeValue(element, false); element.removePositionChangeListener(topLeft); topRight.elements.removeValue(element, false); element.removePositionChangeListener(topRight); bottomLeft.elements.removeValue(element, false); element.removePositionChangeListener(bottomLeft); bottomRight.elements.removeValue(element, false); element.removePositionChangeListener(bottomRight); element.addPostionChangeListener(this); } topLeft = null; topRight = null; bottomLeft = null; bottomRight = null; } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testMerge() { rootQuad = new PointQuadTree<CollisionPoint>(4, 3, 0, 0, 128, 128); rootQuad.add(point1); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(point2); rootQuad.add(point3); rootQuad.add(point4); rootQuad.add(new CollisionPoint(32, 32)); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.remove(point4); rootQuad.remove(point3); rootQuad.remove(point2); Assert.assertEquals(1, rootQuad.getTotalQuads()); Assert.assertEquals(2, rootQuad.getTotalElements()); Assert.assertEquals(true, rootQuad.getElements().contains(point1, false)); }
PointQuadTree extends Rectangle implements QuadTree<T> { public int getTotalElements() { if (totalElementsCache >= 0) { return totalElementsCache; } if (topLeft != null) { totalElementsCache = topLeft.getTotalElements(); totalElementsCache += topRight.getTotalElements(); totalElementsCache += bottomLeft.getTotalElements(); totalElementsCache += bottomRight.getTotalElements(); } else { totalElementsCache = elements.size; } return totalElementsCache; } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testGetTotalElements() { rootQuad.add(point1); Assert.assertEquals(1, rootQuad.getTotalElements()); rootQuad.add(point2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(point3); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.remove(point2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(point4); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.add(point2); Assert.assertEquals(4, rootQuad.getTotalElements()); rootQuad.add(new CollisionPoint(32, 32)); Assert.assertEquals(5, rootQuad.getTotalElements()); rootQuad.add(new CollisionPoint(48, 48)); Assert.assertEquals(6, rootQuad.getTotalElements()); }
PointQuadTree extends Rectangle implements QuadTree<T> { public Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment) { Array<T> result = new Array<T>(); getElementsIntersectingLineSegment(result, lineSegment); return result; } PointQuadTree(int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); PointQuadTree(int elementLimitPerQuad, float x, float y, float width, float height); PointQuadTree(PointQuadTree<T> parent, float x, float y, float width, float height); PointQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); void debugRender(Graphics g); void addAll(Array<T> elementsToAdd); boolean add(T element); void removeAll(Array<T> elementsToRemove); boolean remove(T element); void clear(); @Override Array<T> getElementsWithinArea(Shape area); @Override Array<T> getElementsWithinArea(Shape area, QuadTreeSearchDirection searchDirection); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override Array<T> getElementsContainingPoint(Point point); @Override Array<T> getElementsContainingPoint(Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment); @Override Array<T> getElementsIntersectingLineSegment(LineSegment lineSegment, QuadTreeSearchDirection searchDirection); void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); Array<T> getElements(); void getElements(Array<T> result); int getTotalQuads(); int getTotalElements(); @Override void positionChanged(T moved); QuadTree<T> getParent(); int getElementLimitPerQuad(); int getMergeWatermark(); boolean hasChildQuads(); @Override float getMinimumQuadWidth(); @Override float getMinimumQuadHeight(); static final float DEFAULT_MINIMUM_QUAD_SIZE; static Color QUAD_COLOR; static Color ELEMENT_COLOR; }
@Test public void testGetElementsIntersectingLineSegment() { rootQuad.add(point1); rootQuad.add(point2); rootQuad.add(point3); rootQuad.add(point4); Array<CollisionPoint> CollisionPoints = rootQuad.getElementsIntersectingLineSegment(new LineSegment(0, 0, 128, 128)); Assert.assertEquals(true, CollisionPoints.contains(point1, false)); Assert.assertEquals(false, CollisionPoints.contains(point2, false)); Assert.assertEquals(false, CollisionPoints.contains(point3, false)); Assert.assertEquals(true, CollisionPoints.contains(point4, false)); }
CollisionCircle extends Circle implements CollisionArea, PositionChangeListener<CollisionCircle>, SizeChangeListener<CollisionCircle> { @Override public int getId() { return id; } CollisionCircle(float radius); CollisionCircle(int id, float radius); CollisionCircle(float centerX, float centerY, float radius); CollisionCircle(int id, float centerX, float centerY, float radius); CollisionCircle(int id, Collisions collisions); @Override void dispose(); @Override void preUpdate(); @Override void interpolate(float alpha); @Override CollisionArea setTo(float x, float y, float width, float height); @Override void forceTo(float x, float y, float width, float height); @Override void forceToWidth(float width); @Override void forceToHeight(float height); @Override void forceTo(float x, float y); @Override int getId(); @Override int getRenderX(); @Override int getRenderY(); @Override float getRawRenderX(); @Override float getRawRenderY(); @Override RenderCoordMode getRenderCoordMode(); @Override void setRenderCoordMode(RenderCoordMode mode); @Override int getRenderWidth(); @Override int getRenderHeight(); @Override float getRawRenderWidth(); @Override float getRawRenderHeight(); int getRenderRadius(); float getRawRenderRadius(); @Override void positionChanged(CollisionCircle moved); @Override void sizeChanged(CollisionCircle changed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); @Override void addSizeChangeListener(SizeChangeListener<T> listener); @Override void removeSizeChangeListener(SizeChangeListener<T> listener); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testIdGeneration() { CollisionCircle circle2 = new CollisionCircle(20f, 20f, 4); Assert.assertEquals(true, circle.getId() != circle2.getId()); }
CollisionPoint extends Point implements CollisionObject, PositionChangeListener<CollisionPoint> { @Override public int getId() { return id; } CollisionPoint(); CollisionPoint(int id); CollisionPoint(float x, float y); CollisionPoint(int id, float x, float y); CollisionPoint(int id, Collisions collisions); @Override void dispose(); @Override void preUpdate(); @Override void interpolate(float alpha); @Override void forceTo(float x, float y); @Override int getRenderX(); @Override int getRenderY(); @Override float getRawRenderX(); @Override float getRawRenderY(); @Override RenderCoordMode getRenderCoordMode(); @Override void setRenderCoordMode(RenderCoordMode mode); @Override int getId(); @Override void positionChanged(CollisionPoint moved); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testIdGeneration() { Assert.assertEquals(true, point1.getId() != point2.getId()); Assert.assertEquals(true, point1.getId() != point3.getId()); Assert.assertEquals(true, point2.getId() != point3.getId()); }
CollisionPoint extends Point implements CollisionObject, PositionChangeListener<CollisionPoint> { @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof CollisionPoint)) return false; if (!super.equals(o)) return false; CollisionPoint that = (CollisionPoint) o; return id == that.id; } CollisionPoint(); CollisionPoint(int id); CollisionPoint(float x, float y); CollisionPoint(int id, float x, float y); CollisionPoint(int id, Collisions collisions); @Override void dispose(); @Override void preUpdate(); @Override void interpolate(float alpha); @Override void forceTo(float x, float y); @Override int getRenderX(); @Override int getRenderY(); @Override float getRawRenderX(); @Override float getRawRenderY(); @Override RenderCoordMode getRenderCoordMode(); @Override void setRenderCoordMode(RenderCoordMode mode); @Override int getId(); @Override void positionChanged(CollisionPoint moved); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testEquals() { point1.set(0f, 0f); point2.set(0f, 0f); Assert.assertEquals(true, point1.equals(point2)); point2.set(0.1f, 0f); Assert.assertEquals(false, point1.equals(point2)); point2.set(0f, 0.1f); Assert.assertEquals(false, point1.equals(point2)); point2.set(0.1f, 0.1f); Assert.assertEquals(false, point1.equals(point2)); point2.set(1f, 1f); Assert.assertEquals(false, point1.equals(point2)); } @Test public void testEqualsWithDelta() { point1.set(0f, 0f); point2.set(0f, 0f); Assert.assertEquals(true, point1.equals(point2, 0.1f)); point2.set(0.1f, 0f); Assert.assertEquals(true, point1.equals(point2, 0.1f)); point2.set(0.11f, 0f); Assert.assertEquals(false, point1.equals(point2, 0.1f)); point2.set(0f, 0.1f); Assert.assertEquals(true, point1.equals(point2, 0.1f)); point2.set(0f, 0.11f); Assert.assertEquals(false, point1.equals(point2, 0.1f)); point2.set(0.1f, 0.1f); Assert.assertEquals(true, point1.equals(point2, 0.1f)); point2.set(0.11f, 0.11f); Assert.assertEquals(false, point1.equals(point2, 0.1f)); point2.set(1f, 1f); Assert.assertEquals(false, point1.equals(point2, 0.1f)); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public boolean add(T element) { if (element == null) { return false; } if (!this.intersects(element) && !this.contains(element)) { return false; } clearTotalElementsCache(); if (!addElement(element)) { return false; } return true; } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testAdd() { int totalElements = 100; Random random = new Random(); long startTime = System.nanoTime(); for (int i = 0; i < totalElements; i++) { CollisionBox rect = new CollisionBox(random.nextInt(96), random.nextInt(96), 32f, 32f); Assert.assertEquals(true, rootQuad.add(rect)); Assert.assertEquals(i + 1, rootQuad.getElements().size); } long duration = System.nanoTime() - startTime; System.out.println("Took " + duration + "ns to add " + totalElements + " elements individually to " + ConcurrentRegionQuadTree.class.getSimpleName()); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public void addAll(Array<T> elements) { if (elements == null || elements.size == 0) return; Array<T> elementsWithinQuad = new Array<T>(); for(T element : elements) { if (this.contains(element) || this.intersects(element)) { elementsWithinQuad.add(element); } } clearTotalElementsCache(); lock.lockWrite(); if(topLeft != null) { lock.lockRead(); lock.unlockWrite(); for(int i = elementsWithinQuad.size - 1; i >= 0; i--) { T element = elementsWithinQuad.get(i); if (topLeft.add(element)) { elementsWithinQuad.removeIndex(i); continue; } if (topRight.add(element)) { elementsWithinQuad.removeIndex(i); continue; } if (bottomLeft.add(element)) { elementsWithinQuad.removeIndex(i); continue; } if (bottomRight.add(element)) { elementsWithinQuad.removeIndex(i); continue; } } lock.unlockRead(); if(elementsWithinQuad.size == 0) { return; } lock.lockWrite(); } this.elements.addAll(elementsWithinQuad); for(T element : elementsWithinQuad) { element.addPostionChangeListener(this); } int totalElements = this.elements.size; lock.unlockWrite(); if (totalElements > elementLimitPerQuad && getWidth() >= 2f && getHeight() >= 2f) { subdivide(); } } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testAddAll() { int totalElements = 100; Random random = new Random(); Array<CollisionBox> rects = new Array<CollisionBox>(); long startTime = System.nanoTime(); for (int i = 0; i < totalElements; i++) { rects.add(new CollisionBox(random.nextInt(96), random.nextInt(96), 32f, 32f)); } rects.add(new CollisionBox(-4f, -4f, 32f, 32f)); rootQuad.addAll(rects); long duration = System.nanoTime() - startTime; System.out.println("Took " + duration + "ns to add " + totalElements + " elements in bulk to " + ConcurrentRegionQuadTree.class.getSimpleName()); Assert.assertEquals(rects.size, rootQuad.getTotalElements()); } @Test public void testMergingConcurrency() throws TimeoutException { rootQuad = new ConcurrentRegionQuadTree<CollisionBox>(CONCURRENCY_TEST_ELEMENT_LIMIT, CONCURRENCY_TEST_WATERMARK, 0, 0, CONCURRENCY_TREE_WIDTH, CONCURRENCY_TREE_HEIGHT); List<CollisionBox> initialCollisions = new ArrayList<CollisionBox>(); for (int i = 0; i < MathUtils.round(CONCURRENCY_TREE_WIDTH / CONCURRENCY_TEST_ELEMENT_LIMIT); i++) { createNextConcurrencyCollision(initialCollisions); createRandomConcurrencyCollision(initialCollisions); } Collections.shuffle(initialCollisions); threadCollisions.addAll(initialCollisions); int totalThreads = Runtime.getRuntime().availableProcessors(); while (totalThreads % 3 != 0) { totalThreads++; } for (int i = 0; i < totalThreads; i++) { new Thread(this).start(); } concurrentTestStartLatch.countDown(); waiter.await(CONCURRENCY_TEST_TIMEOUT); System.out.println(rootQuad.getTotalMergeOperations() + " total merge operations."); System.out.println(collisionsFound.get() + " collisions found concurrently."); System.out.println(collisionsMoved.get() + " collisions moved concurrently."); Assert.assertEquals(true, rootQuad.getTotalMergeOperations() > 0); Assert.assertEquals(true, collisionsFound.get() > 0); Assert.assertEquals(true, collisionsMoved.get() > 0); Assert.assertEquals(false, concurrencyExceptionOccurred.get()); }
TiledMap { public Color getBackgroundColor() { return tiledMapData.getBackgroundColor(); } TiledMap(FileHandle fileHandle); TiledMap(FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledParser parser, FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledMapData tiledMapData, boolean loadTilesetTextures); boolean isTilesetTexturesLoaded(); boolean isTilesetTexturesLoaded(boolean ignoreObjectTemplateTilesets); boolean loadTilesetTextures(); boolean loadTilesetTextures(AssetManager assetManager); boolean loadTilesetTextures(TextureAtlas textureAtlas); boolean loadTilesetTextures(boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(AssetManager assetManager, boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(TextureAtlas textureAtlas, boolean loadObjectTemplateTilesets); void update(float delta); void draw(Graphics g, int x, int y); void draw(Graphics g, int x, int y, int layer); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles, int layer); void drawTileLayer(Graphics g, TileLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void drawGroupLayer(Graphics g, GroupLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); TileLayer getTileLayer(String name); TileLayer getTileLayer(String name, boolean recursive); TileLayer getTileLayer(int index); GroupLayer getGroupLayer(String name); GroupLayer getGroupLayer(String name, boolean recursive); GroupLayer getGroupLayer(int index); TiledObjectGroup getObjectGroup(String name); TiledObjectGroup getObjectGroup(String name, boolean recursive); Iterable<TiledObjectGroup> getObjectGroups(); int getLayerIndex(String name); int getLayerIndexIgnoreCase(String name); Tile getTile(int tileId); Tile getTile(int x, int y, int layer); void dispose(); void dispose(boolean disposeTilesets); Orientation getOrientation(); StaggerAxis getStaggerAxis(); StaggerIndex getStaggerIndex(); int getSideLength(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getPixelWidth(); int getPixelHeight(); Array<Tileset> getTilesets(); Array<Layer> getLayers(); int getTotalObjectGroups(); Color getBackgroundColor(); void setTileLayerRenderer(TileLayerRenderer tileLayerRenderer); void setTiledObjectGroupRenderer(TiledObjectGroupRenderer tiledObjectGroupRenderer); boolean containsAnimatedTiles(); static boolean STRICT_LAYER_VISIBILITY; static boolean FAST_RENDER_EMPTY_LAYERS; static boolean CLIP_TILES_OUTSIDE_GRAPHICS_VIEWPORT; }
@Test public void testGetBackgroundColor() { Assert.assertNotNull(tiledMap.getBackgroundColor()); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public boolean remove(T element) { if (element == null) return false; if (!this.intersects(element) && !this.contains(element)) { return false; } clearTotalElementsCache(); return removeElement(element, true); } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testRemove() { Random random = new Random(); Array<CollisionBox> collisionBoxs = new Array<CollisionBox>(); for (int i = 0; i < 1000; i++) { collisionBoxs.add( new CollisionBox(random.nextInt(96), random.nextInt(96), random.nextInt(32), random.nextInt(32))); } for (int i = 0; i < collisionBoxs.size; i++) { rootQuad.add(collisionBoxs.get(i)); Assert.assertEquals(i + 1, rootQuad.getElements().size); } for (int i = collisionBoxs.size - 1; i >= 0; i--) { Assert.assertEquals(i + 1, rootQuad.getElements().size); rootQuad.remove(collisionBoxs.get(i)); Assert.assertEquals(i, rootQuad.getElements().size); } }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public void removeAll(Array<T> elementsToRemove) { if(elementsToRemove == null || elementsToRemove.size == 0) { return; } clearTotalElementsCache(); Array<T> elementsWithinQuad = new Array<T>(); for(T element : elementsToRemove) { if(this.contains(element) || this.intersects(element)) { elementsWithinQuad.add(element); } } lock.lockRead(); if(topLeft != null) { for(int i = elementsWithinQuad.size - 1; i >= 0; i--) { T element = elementsWithinQuad.get(i); if (topLeft.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } if (topRight.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } if (bottomLeft.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } if (bottomRight.remove(element)) { elementsWithinQuad.removeIndex(i); continue; } } } lock.unlockRead(); lock.lockWrite(); elements.removeAll(elementsWithinQuad, false); lock.unlockWrite(); for(T element : elementsWithinQuad) { element.removePositionChangeListener(this); } if (parent == null) { return; } if (parent.isMergable()) { parent.merge(); } } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testRemoveAll() { Random random = new Random(); Array<CollisionBox> rects = new Array<CollisionBox>(); for (int i = 0; i < 100; i++) { rects.add(new CollisionBox(random.nextInt(96), random.nextInt(96), random.nextInt(32), random.nextInt(32))); } rootQuad.addAll(rects); Assert.assertEquals(rects.size, rootQuad.getTotalElements()); rootQuad.removeAll(rects); Assert.assertEquals(0, rootQuad.getTotalElements()); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override protected void subdivide() { lock.lockRead(); if (topLeft != null) { lock.unlockRead(); return; } lock.unlockRead(); lock.lockWrite(); if (topLeft != null) { lock.unlockWrite(); return; } float halfWidth = getWidth() / 2f; float halfHeight = getHeight() / 2f; topLeft = new ConcurrentRegionQuadTree<T>(this, getX(), getY(), halfWidth, halfHeight); topRight = new ConcurrentRegionQuadTree<T>(this, getX() + halfWidth, getY(), halfWidth, halfHeight); bottomLeft = new ConcurrentRegionQuadTree<T>(this, getX(), getY() + halfHeight, halfWidth, halfHeight); bottomRight = new ConcurrentRegionQuadTree<T>(this, getX() + halfWidth, getY() + halfHeight, halfWidth, halfHeight); for (int i = elements.size - 1; i >= 0; i--) { lock.lockRead(); T element = elements.get(i); if (addElementToChild(element)) { elements.removeValue(element, false); element.removePositionChangeListener(this); } } lock.unlockWrite(); } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testSubdivide() { rootQuad.add(box1); Assert.assertEquals(1, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(box2); Assert.assertEquals(2, rootQuad.getElements().size); Assert.assertEquals(1, rootQuad.getTotalQuads()); rootQuad.add(box3); Assert.assertEquals(3, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(box4); Assert.assertEquals(4, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionBox(24, 24, 2, 2)); Assert.assertEquals(5, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionBox(48, 48, 32, 32)); Assert.assertEquals(6, rootQuad.getElements().size); Assert.assertEquals(4, rootQuad.getTotalQuads()); rootQuad.add(new CollisionBox(12, 48, 8, 8)); Assert.assertEquals(7, rootQuad.getElements().size); Assert.assertEquals(7, rootQuad.getTotalQuads()); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public int getTotalElements() { if (totalElementsCache >= 0) { return totalElementsCache; } totalElementsCache = 0; lock.lockRead(); if (topLeft != null) { totalElementsCache = topLeft.getTotalElements(); totalElementsCache += topRight.getTotalElements(); totalElementsCache += bottomLeft.getTotalElements(); totalElementsCache += bottomRight.getTotalElements(); } totalElementsCache += elements.size; lock.unlockRead(); return totalElementsCache; } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetTotalElements() { rootQuad.add(box1); Assert.assertEquals(1, rootQuad.getTotalElements()); rootQuad.add(box2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(box3); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.remove(box2); Assert.assertEquals(2, rootQuad.getTotalElements()); rootQuad.add(box4); Assert.assertEquals(3, rootQuad.getTotalElements()); rootQuad.add(box2); Assert.assertEquals(4, rootQuad.getTotalElements()); rootQuad.add(new CollisionBox(48, 48, 32, 32)); Assert.assertEquals(5, rootQuad.getTotalElements()); rootQuad.add(new CollisionBox(12, 48, 8, 8)); Assert.assertEquals(6, rootQuad.getTotalElements()); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment) { lock.lockRead(); if (topLeft != null) { if (intersects(topLeft, lineSegment)) { topLeft.getElementsIntersectingLineSegment(result, lineSegment); } if (intersects(topRight, lineSegment)) { topRight.getElementsIntersectingLineSegment(result, lineSegment); } if (intersects(bottomLeft, lineSegment)) { bottomLeft.getElementsIntersectingLineSegment(result, lineSegment); } if (intersects(bottomRight, lineSegment)) { bottomRight.getElementsIntersectingLineSegment(result, lineSegment); } } addElementsIntersectingLineSegment(result, lineSegment); lock.unlockRead(); } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsIntersectingLineSegment() { rootQuad.add(box1); rootQuad.add(box2); rootQuad.add(box3); rootQuad.add(box4); Array<CollisionBox> collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(0, 0, 128, 128)); Assert.assertEquals(2, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); Assert.assertEquals(true, collisionBoxs.contains(box4, false)); CollisionBox collisionBox5 = new CollisionBox(24, 24, 2, 2); CollisionBox collisionBox6 = new CollisionBox(48, 48, 32, 32); CollisionBox collisionBox7 = new CollisionBox(12, 48, 8, 8); rootQuad.add(collisionBox5); rootQuad.add(collisionBox6); rootQuad.add(collisionBox7); collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(0, 0, 128, 128)); Assert.assertEquals(4, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); Assert.assertEquals(true, collisionBoxs.contains(box4, false)); Assert.assertEquals(true, collisionBoxs.contains(collisionBox5, false)); Assert.assertEquals(true, collisionBoxs.contains(collisionBox6, false)); collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(0, 0, 1, 1)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(-1, -1, 0, 0)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(31f, 31f, 32f, 32f)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsIntersectingLineSegment(new LineSegment(33f, 33f, 32f, 32f)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public void getElementsContainingPoint(Array<T> result, Point point) { lock.lockRead(); if (topLeft != null) { if (topLeft.contains(point)) { topLeft.getElementsContainingPoint(result, point); } if (topRight.contains(point)) { topRight.getElementsContainingPoint(result, point); } if (bottomLeft.contains(point)) { bottomLeft.getElementsContainingPoint(result, point); } if (bottomRight.contains(point)) { bottomRight.getElementsContainingPoint(result, point); } } addElementsContainingPoint(result, point); lock.unlockRead(); } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingPoint() { rootQuad.add(box1); rootQuad.add(box2); rootQuad.add(box3); rootQuad.add(box4); Array<CollisionBox> collisionBoxs = rootQuad.getElementsContainingPoint(new Point(16, 16)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingPoint(new Point(112, 16)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box2, false)); collisionBoxs = rootQuad.getElementsContainingPoint(new Point(16, 112)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box3, false)); collisionBoxs = rootQuad.getElementsContainingPoint(new Point(112, 112)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box4, false)); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { private void getElementsContainingPointUpwards(Array<T> result, Point point, boolean firstInvocation) { lock.lockRead(); if (elements != null){ addElementsContainingPoint(result, point); } if (firstInvocation && topLeft != null){ if (topLeft.contains(point)){ topLeft.getElementsContainingPoint(result, point); } if (topRight.contains(point)){ topRight.getElementsContainingPoint(result, point); } if (bottomLeft.contains(point)){ bottomLeft.getElementsContainingPoint(result, point); } if (bottomRight.contains(point)){ bottomRight.getElementsContainingPoint(result, point); } } if (parent != null){ if (parent.topLeft != this && (parent.topLeft.contains(point) || parent.topLeft.contains(point))) { parent.topLeft.getElementsContainingPoint(result, point); } if (parent.topRight != this && (parent.topRight.contains(point) || parent.topRight.contains(point))) { parent.topRight.getElementsContainingPoint(result, point); } if (parent.bottomLeft != this && (parent.bottomLeft.contains(point) || parent.bottomLeft.contains(point))) { parent.bottomLeft.getElementsContainingPoint(result, point); } if (parent.bottomRight != this && (parent.bottomRight.contains(point) || parent.bottomRight.contains(point))) { parent.bottomRight.getElementsContainingPoint(result, point); } ((ConcurrentRegionQuadTree<T>)parent).getElementsContainingPointUpwards(result, point, false); } lock.unlockRead(); } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingPointUpwards() { rootQuad.add(qABox1); rootQuad.add(qABox2); rootQuad.add(qABox3); rootQuad.add(qABox4); Array<CollisionBox> collisionBoxs = qABox1.getQuad().getElementsContainingPoint(new Point(16, 16), QuadTreeSearchDirection.UPWARDS); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingPoint(new Point(112, 16)); Assert.assertEquals(0, collisionBoxs.size); collisionBoxs = qABox1.getQuad().getElementsContainingPoint(new Point(112, 16), QuadTreeSearchDirection.UPWARDS); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox2, false)); collisionBoxs = qABox3.getQuad().getElementsContainingPoint(new Point(16, 112)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox3, false)); collisionBoxs = qABox4.getQuad().getElementsContainingPoint(new Point(112, 112)); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox4, false)); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { @Override public Array<T> getElementsContainingArea(Shape area, boolean entirelyContained) { Array<T> result = new Array<T>(); getElementsContainingArea(result, area, entirelyContained); return result; } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingArea() { rootQuad.add(box1); Array<CollisionBox> collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(2, 2, 10, 10), false); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(2, 2, 10, 10), true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(40, 40, 10, 10), false); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(40, 40, 10, 10), true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(25, 25, 10, 10), false); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(25, 25, 10, 10), true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(0.5f, 0.5f, 64, 64), false); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); collisionBoxs = rootQuad.getElementsContainingArea(new CollisionBox(0.5f, 0.5f, 64, 64), true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(box1, false)); }
ConcurrentRegionQuadTree extends ConcurrentPointQuadTree<T> { protected void getElementsContainingAreaUpwards(Array<T> result, Shape area, boolean firstInvocation, boolean entirelyContained) { lock.lockRead(); if (elements != null) { addElementsContainingArea(result, area, entirelyContained); } if (firstInvocation && topLeft != null){ if (area.contains(topLeft) || area.intersects(topLeft)){ topLeft.getElementsContainingArea(result, area, entirelyContained); } if (area.contains(topRight) || area.intersects(topRight)){ topRight.getElementsContainingArea(result, area, entirelyContained); } if (area.contains(bottomLeft) || area.intersects(bottomLeft)){ bottomLeft.getElementsContainingArea(result, area, entirelyContained); } if (area.contains(bottomRight) || area.intersects(bottomRight)){ bottomRight.getElementsContainingArea(result, area, entirelyContained); } } if (parent != null) { if (parent.topLeft != this && (area.contains(parent.topLeft) || area.intersects(parent.topLeft))) { parent.topLeft.getElementsContainingArea(result, area, entirelyContained); } if (parent.topRight != this && (area.contains(parent.topRight) || area.intersects(parent.topRight))) { parent.topRight.getElementsContainingArea(result, area, entirelyContained); } if (parent.bottomLeft != this && (area.contains(parent.bottomLeft) || area.intersects(parent.bottomLeft))) { parent.bottomLeft.getElementsContainingArea(result, area, entirelyContained); } if (parent.bottomRight != this && (area.contains(parent.bottomRight) || area.intersects(parent.bottomRight))) { parent.bottomRight.getElementsContainingArea(result, area, entirelyContained); } ((ConcurrentRegionQuadTree<T>)parent).getElementsContainingAreaUpwards(result, area, false, entirelyContained); } lock.unlockRead(); } ConcurrentRegionQuadTree(int elementLimit, int mergeWatermark, float x, float y, float width, float height); ConcurrentRegionQuadTree(int elementLimit, float x, float y, float width, float height); ConcurrentRegionQuadTree(ConcurrentRegionQuadTree<T> parent, float x, float y, float width, float height); ConcurrentRegionQuadTree(float minimumQuadWidth, float minimumQuadHeight, int elementLimitPerQuad, int mergeWatermark, float x, float y, float width, float height); @Override void debugRender(Graphics g); @Override void addAll(Array<T> elements); @Override boolean add(T element); @Override void removeAll(Array<T> elementsToRemove); @Override boolean remove(T element); @Override void getElementsWithinArea(Array<T> result, Shape area); @Override void getElementsWithinArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection); @Override Array<T> getElementsContainingArea(Shape area, boolean entirelyContained); @Override Array<T> getElementsContainingArea(Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, boolean entirelyContained); @Override void getElementsContainingArea(Array<T> result, Shape area, QuadTreeSearchDirection searchDirection, boolean entirelyContained); @Override void getElementsContainingPoint(Array<T> result, Point point); @Override void getElementsContainingPoint(Array<T> result, Point point, QuadTreeSearchDirection searchDirection); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment); @Override void getElementsIntersectingLineSegment(Array<T> result, LineSegment lineSegment, QuadTreeSearchDirection searchDirection); @Override Array<T> getElements(); @Override void getElements(Array<T> result); @Override int getTotalElements(); @Override void positionChanged(T moved); }
@Test public void testGetElementsContainingAreaUpwards() { rootQuad.add(qABox1); rootQuad.add(qABox2); rootQuad.add(qABox3); rootQuad.add(qABox4); Array<CollisionBox> collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(16, 16, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea(new CollisionBox(112, 16, 1, 1), true); Assert.assertEquals(0, collisionBoxs.size); collisionBoxs = qABox1.getQuad().getElementsContainingArea(new CollisionBox(112, 16, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox2, false)); collisionBoxs = qABox3.getQuad().getElementsContainingArea(new CollisionBox(16, 112, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox3, false)); collisionBoxs = qABox4.getQuad().getElementsContainingArea(new CollisionBox(112, 112, 1, 1), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox4, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(16, 16, 20, 10), QuadTreeSearchDirection.UPWARDS, false); Assert.assertEquals(1, collisionBoxs.size); Assert.assertEquals(true, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(16, 16, 20, 10), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(0.5f, 0.5f, 40, 40), QuadTreeSearchDirection.UPWARDS, false); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(qABox1, false)); collisionBoxs = qABox1.getQuad().getElementsContainingArea( new CollisionBox(0.5f, 0.5f, 40, 40), QuadTreeSearchDirection.UPWARDS, true); Assert.assertEquals(0, collisionBoxs.size); Assert.assertEquals(false, collisionBoxs.contains(qABox1, false)); }
TiledMap { public String getProperty(String propertyName) { return tiledMapData.getProperty(propertyName); } TiledMap(FileHandle fileHandle); TiledMap(FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledParser parser, FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledMapData tiledMapData, boolean loadTilesetTextures); boolean isTilesetTexturesLoaded(); boolean isTilesetTexturesLoaded(boolean ignoreObjectTemplateTilesets); boolean loadTilesetTextures(); boolean loadTilesetTextures(AssetManager assetManager); boolean loadTilesetTextures(TextureAtlas textureAtlas); boolean loadTilesetTextures(boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(AssetManager assetManager, boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(TextureAtlas textureAtlas, boolean loadObjectTemplateTilesets); void update(float delta); void draw(Graphics g, int x, int y); void draw(Graphics g, int x, int y, int layer); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles, int layer); void drawTileLayer(Graphics g, TileLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void drawGroupLayer(Graphics g, GroupLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); TileLayer getTileLayer(String name); TileLayer getTileLayer(String name, boolean recursive); TileLayer getTileLayer(int index); GroupLayer getGroupLayer(String name); GroupLayer getGroupLayer(String name, boolean recursive); GroupLayer getGroupLayer(int index); TiledObjectGroup getObjectGroup(String name); TiledObjectGroup getObjectGroup(String name, boolean recursive); Iterable<TiledObjectGroup> getObjectGroups(); int getLayerIndex(String name); int getLayerIndexIgnoreCase(String name); Tile getTile(int tileId); Tile getTile(int x, int y, int layer); void dispose(); void dispose(boolean disposeTilesets); Orientation getOrientation(); StaggerAxis getStaggerAxis(); StaggerIndex getStaggerIndex(); int getSideLength(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getPixelWidth(); int getPixelHeight(); Array<Tileset> getTilesets(); Array<Layer> getLayers(); int getTotalObjectGroups(); Color getBackgroundColor(); void setTileLayerRenderer(TileLayerRenderer tileLayerRenderer); void setTiledObjectGroupRenderer(TiledObjectGroupRenderer tiledObjectGroupRenderer); boolean containsAnimatedTiles(); static boolean STRICT_LAYER_VISIBILITY; static boolean FAST_RENDER_EMPTY_LAYERS; static boolean CLIP_TILES_OUTSIDE_GRAPHICS_VIEWPORT; }
@Test public void testGetMapProperty() { Assert.assertEquals("SUCCESS", tiledMap.getProperty("testMapProperty")); }
Collisions { public CollisionBox collisionBox() { return collisionBox(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testCollisionBox() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); for(int i = 0; i < 10; i++) { final int id = 7 + i; final float x = 9.0f * i; final float y = 11.0f * i; final float width = 123f * i; final float height = 132f * i; final CollisionBox collisionBox = collisions.collisionBox(id, x, y, width, height); Assert.assertEquals(0, collisions.getTotalCollisionBoxesAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionBox.getId()); Assert.assertEquals(x, collisionBox.getX(), 0f); Assert.assertEquals(y, collisionBox.getY(), 0f); Assert.assertEquals(width, collisionBox.getWidth(), 0f); Assert.assertEquals(height, collisionBox.getHeight(), 0f); Assert.assertEquals(x, collisionBox.getRenderX(), 0f); Assert.assertEquals(y, collisionBox.getRenderY(), 0f); Assert.assertEquals(width, collisionBox.getRenderWidth(), 0f); Assert.assertEquals(height, collisionBox.getRenderHeight(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionBox.setXY(x + offsetX, y + offsetY); collisionBox.interpolate(1f); Assert.assertEquals(x + offsetX, collisionBox.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionBox.getRenderY(), 0f); } } collisionBox.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionBox.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public CollisionCircle collisionCircle() { return collisionCircle(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testCollisionCircle() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionCirclesAvailable()); for(int i = 0; i < 10; i++) { final int id = 45 + i; final float x = 53f * i; final float y = 11f * i; final float radius = 46f * i; final CollisionCircle collisionCircle = collisions.collisionCircle(id, x, y, radius); Assert.assertEquals(0, collisions.getTotalCollisionCirclesAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionCircle.getId()); Assert.assertEquals(x, collisionCircle.getX(), 0f); Assert.assertEquals(y, collisionCircle.getY(), 0f); Assert.assertEquals(radius, collisionCircle.getRadius(), 0f); Assert.assertEquals(x, collisionCircle.getRenderX(), 0f); Assert.assertEquals(y, collisionCircle.getRenderY(), 0f); Assert.assertEquals(radius, collisionCircle.getRenderRadius(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionCircle.setXY(x + offsetX, y + offsetY); collisionCircle.interpolate(1f); Assert.assertEquals(x + offsetX, collisionCircle.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionCircle.getRenderY(), 0f); } } collisionCircle.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionCircle.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public CollisionPoint collisionPoint() { return collisionPoint(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testCollisionPoint() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); for(int i = 0; i < 10; i++) { final int id = 103 + i; final float x = 77f * i; final float y = 3f * i; final CollisionPoint collisionPoint = collisions.collisionPoint(id, x, y); Assert.assertEquals(0, collisions.getTotalCollisionPointsAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionPoint.getId()); Assert.assertEquals(x, collisionPoint.getX(), 0f); Assert.assertEquals(y, collisionPoint.getY(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionPoint.setXY(x + offsetX, y + offsetY); collisionPoint.interpolate(1f); Assert.assertEquals(x + offsetX, collisionPoint.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionPoint.getRenderY(), 0f); } } collisionPoint.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionPoint.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public CollisionPolygon collisionPolygon(float [] vertices) { return collisionPolygon(CollisionIdSequence.nextId(), vertices); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testCollisionPolygon() { Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); for(int i = 0; i < 10; i++) { final int id = 97 + i; final Vector2 [] vectors = new Vector2[] { new Vector2(10f * i, 10f * i), new Vector2(20f * i, 20f * i), new Vector2(i, 20f * i) }; final CollisionPolygon collisionPolygon = collisions.collisionPolygon(id, vectors); Assert.assertEquals(0, collisions.getTotalCollisionPolygonsAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionPolygon.getId()); Assert.assertEquals(vectors[0].x, collisionPolygon.getX(), 0f); Assert.assertEquals(vectors[0].y, collisionPolygon.getY(), 0f); Assert.assertEquals(vectors[1].x, collisionPolygon.getX(1), 0f); Assert.assertEquals(vectors[1].y, collisionPolygon.getY(1), 0f); Assert.assertEquals(vectors[2].x, collisionPolygon.getX(2), 0f); Assert.assertEquals(vectors[2].y, collisionPolygon.getY(2), 0f); collisionPolygon.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionPolygon.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public QuadTreeAwareCollisionBox quadTreeAwareCollisionBox() { return quadTreeAwareCollisionBox(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testQuadTreeAwareCollisionBox() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionBoxesAvailable()); for(int i = 0; i < 10; i++) { final int id = 7 + i; final float x = 9.0f * i; final float y = 11.0f * i; final float width = 123f * i; final float height = 132f * i; final QuadTreeAwareCollisionBox collisionBox = collisions.quadTreeAwareCollisionBox(id, x, y, width, height); Assert.assertEquals(0, collisions.getTotalQuadTreeAwareCollisionBoxesAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionBox.getId()); Assert.assertEquals(x, collisionBox.getX(), 0f); Assert.assertEquals(y, collisionBox.getY(), 0f); Assert.assertEquals(width, collisionBox.getWidth(), 0f); Assert.assertEquals(height, collisionBox.getHeight(), 0f); Assert.assertEquals(x, collisionBox.getRenderX(), 0f); Assert.assertEquals(y, collisionBox.getRenderY(), 0f); Assert.assertEquals(width, collisionBox.getRenderWidth(), 0f); Assert.assertEquals(height, collisionBox.getRenderHeight(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionBox.setXY(x + offsetX, y + offsetY); collisionBox.interpolate(1f); Assert.assertEquals(x + offsetX, collisionBox.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionBox.getRenderY(), 0f); } } collisionBox.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionBox.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle() { return quadTreeAwareCollisionCircle(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testQuadTreeAwareCollisionCircle() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionCirclesAvailable()); for(int i = 0; i < 10; i++) { final int id = 45 + i; final float x = 53f * i; final float y = 11f * i; final float radius = 46f * i; final QuadTreeAwareCollisionCircle collisionCircle = collisions.quadTreeAwareCollisionCircle(id, x, y, radius); Assert.assertEquals(0, collisions.getTotalQuadTreeAwareCollisionCirclesAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionCircle.getId()); Assert.assertEquals(x, collisionCircle.getX(), 0f); Assert.assertEquals(y, collisionCircle.getY(), 0f); Assert.assertEquals(radius, collisionCircle.getRadius(), 0f); Assert.assertEquals(x, collisionCircle.getRenderX(), 0f); Assert.assertEquals(y, collisionCircle.getRenderY(), 0f); Assert.assertEquals(radius, collisionCircle.getRenderRadius(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionCircle.setXY(x + offsetX, y + offsetY); collisionCircle.interpolate(1f); Assert.assertEquals(x + offsetX, collisionCircle.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionCircle.getRenderY(), 0f); } } collisionCircle.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionCircle.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint() { return quadTreeAwareCollisionPoint(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testQuadTreeAwareCollisionPoint() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionPointsAvailable()); for(int i = 0; i < 10; i++) { final int id = 103 + i; final float x = 77f * i; final float y = 3f * i; final CollisionPoint collisionPoint = collisions.quadTreeAwareCollisionPoint(id, x, y); Assert.assertEquals(0, collisions.getTotalQuadTreeAwareCollisionPointsAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionPoint.getId()); Assert.assertEquals(x, collisionPoint.getX(), 0f); Assert.assertEquals(y, collisionPoint.getY(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionPoint.setXY(x + offsetX, y + offsetY); collisionPoint.interpolate(1f); Assert.assertEquals(x + offsetX, collisionPoint.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionPoint.getRenderY(), 0f); } } collisionPoint.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionPoint.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices) { return quadTreeAwareCollisionPolygon(CollisionIdSequence.nextId(), vertices); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testQuadTreeAwareCollisionPolygon() { for(int i = 0; i < 10; i++) { final int id = 97 + i; final Vector2 [] vectors = new Vector2[] { new Vector2(10f * i, 10f * i), new Vector2(20f * i, 20f * i), new Vector2(i, 20f * i) }; final CollisionPolygon collisionPolygon = collisions.quadTreeAwareCollisionPolygon(id, vectors); Assert.assertEquals(0, collisions.getTotalQuadTreeAwareCollisionPolygonsAvailable()); Assert.assertEquals(1, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionPolygon.getId()); Assert.assertEquals(vectors[0].x, collisionPolygon.getX(), 0f); Assert.assertEquals(vectors[0].y, collisionPolygon.getY(), 0f); Assert.assertEquals(vectors[1].x, collisionPolygon.getX(1), 0f); Assert.assertEquals(vectors[1].y, collisionPolygon.getY(1), 0f); Assert.assertEquals(vectors[2].x, collisionPolygon.getX(2), 0f); Assert.assertEquals(vectors[2].y, collisionPolygon.getY(2), 0f); collisionPolygon.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionPolygon.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalQuadTreeAwareCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public StaticCollisionBox staticCollisionBox() { return staticCollisionBox(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testStaticCollisionBox() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionBoxesAvailable()); for(int i = 0; i < 10; i++) { final int id = 7 + i; final float x = 9.0f * i; final float y = 11.0f * i; final float width = 123f * i; final float height = 132f * i; final StaticCollisionBox collisionBox = collisions.staticCollisionBox(id, x, y, width, height); Assert.assertEquals(0, collisions.getTotalStaticCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionBox.getId()); Assert.assertEquals(x, collisionBox.getX(), 0f); Assert.assertEquals(y, collisionBox.getY(), 0f); Assert.assertEquals(width, collisionBox.getWidth(), 0f); Assert.assertEquals(height, collisionBox.getHeight(), 0f); Assert.assertEquals(x, collisionBox.getRenderX(), 0f); Assert.assertEquals(y, collisionBox.getRenderY(), 0f); Assert.assertEquals(width, collisionBox.getRenderWidth(), 0f); Assert.assertEquals(height, collisionBox.getRenderHeight(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionBox.setXY(x + offsetX, y + offsetY); collisionBox.interpolate(1f); Assert.assertEquals(x + offsetX, collisionBox.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionBox.getRenderY(), 0f); } } collisionBox.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionBox.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionBoxesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public StaticCollisionCircle staticCollisionCircle() { return staticCollisionCircle(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testStaticCollisionCircle() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionCirclesAvailable()); for(int i = 0; i < 10; i++) { final int id = 45 + i; final float x = 53f * i; final float y = 11f * i; final float radius = 46f * i; final StaticCollisionCircle collisionCircle = collisions.staticCollisionCircle(id, x, y, radius); Assert.assertEquals(0, collisions.getTotalStaticCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionCircle.getId()); Assert.assertEquals(x, collisionCircle.getX(), 0f); Assert.assertEquals(y, collisionCircle.getY(), 0f); Assert.assertEquals(radius, collisionCircle.getRadius(), 0f); Assert.assertEquals(x, collisionCircle.getRenderX(), 0f); Assert.assertEquals(y, collisionCircle.getRenderY(), 0f); Assert.assertEquals(radius, collisionCircle.getRenderRadius(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionCircle.setXY(x + offsetX, y + offsetY); collisionCircle.interpolate(1f); Assert.assertEquals(x + offsetX, collisionCircle.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionCircle.getRenderY(), 0f); } } collisionCircle.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionCircle.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionCirclesAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
TiledMap { public Orientation getOrientation() { return tiledMapData.getOrientation(); } TiledMap(FileHandle fileHandle); TiledMap(FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledParser parser, FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledMapData tiledMapData, boolean loadTilesetTextures); boolean isTilesetTexturesLoaded(); boolean isTilesetTexturesLoaded(boolean ignoreObjectTemplateTilesets); boolean loadTilesetTextures(); boolean loadTilesetTextures(AssetManager assetManager); boolean loadTilesetTextures(TextureAtlas textureAtlas); boolean loadTilesetTextures(boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(AssetManager assetManager, boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(TextureAtlas textureAtlas, boolean loadObjectTemplateTilesets); void update(float delta); void draw(Graphics g, int x, int y); void draw(Graphics g, int x, int y, int layer); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles, int layer); void drawTileLayer(Graphics g, TileLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void drawGroupLayer(Graphics g, GroupLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); TileLayer getTileLayer(String name); TileLayer getTileLayer(String name, boolean recursive); TileLayer getTileLayer(int index); GroupLayer getGroupLayer(String name); GroupLayer getGroupLayer(String name, boolean recursive); GroupLayer getGroupLayer(int index); TiledObjectGroup getObjectGroup(String name); TiledObjectGroup getObjectGroup(String name, boolean recursive); Iterable<TiledObjectGroup> getObjectGroups(); int getLayerIndex(String name); int getLayerIndexIgnoreCase(String name); Tile getTile(int tileId); Tile getTile(int x, int y, int layer); void dispose(); void dispose(boolean disposeTilesets); Orientation getOrientation(); StaggerAxis getStaggerAxis(); StaggerIndex getStaggerIndex(); int getSideLength(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getPixelWidth(); int getPixelHeight(); Array<Tileset> getTilesets(); Array<Layer> getLayers(); int getTotalObjectGroups(); Color getBackgroundColor(); void setTileLayerRenderer(TileLayerRenderer tileLayerRenderer); void setTiledObjectGroupRenderer(TiledObjectGroupRenderer tiledObjectGroupRenderer); boolean containsAnimatedTiles(); static boolean STRICT_LAYER_VISIBILITY; static boolean FAST_RENDER_EMPTY_LAYERS; static boolean CLIP_TILES_OUTSIDE_GRAPHICS_VIEWPORT; }
@Test public void testGetOrientation() { Assert.assertEquals(Orientation.ORTHOGONAL, tiledMap.getOrientation()); }
Collisions { public StaticCollisionPoint staticCollisionPoint() { return staticCollisionPoint(CollisionIdSequence.nextId()); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testStaticCollisionPoint() { Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionPointsAvailable()); for(int i = 0; i < 10; i++) { final int id = 103 + i; final float x = 77f * i; final float y = 3f * i; final StaticCollisionPoint collisionPoint = collisions.staticCollisionPoint(id, x, y); Assert.assertEquals(0, collisions.getTotalStaticCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionPoint.getId()); Assert.assertEquals(x, collisionPoint.getX(), 0f); Assert.assertEquals(y, collisionPoint.getY(), 0f); for(int offsetX = 1; offsetX < 10; offsetX++) { for(int offsetY = 1; offsetY < 10; offsetY++) { collisionPoint.setXY(x + offsetX, y + offsetY); collisionPoint.interpolate(1f); Assert.assertEquals(x + offsetX, collisionPoint.getRenderX(), 0f); Assert.assertEquals(y + offsetY, collisionPoint.getRenderY(), 0f); } } collisionPoint.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionPoint.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionPointsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
Collisions { public StaticCollisionPolygon staticCollisionPolygon(float [] vertices) { return staticCollisionPolygon(CollisionIdSequence.nextId(), vertices); } Collisions(); synchronized void init(); CollisionBox collisionBox(); CollisionBox collisionBox(int id); CollisionBox collisionBox(int id, float x, float y, float width, float height); CollisionCircle collisionCircle(); CollisionCircle collisionCircle(int id); CollisionCircle collisionCircle(int id, float x, float y, float radius); CollisionPoint collisionPoint(); CollisionPoint collisionPoint(int id); CollisionPoint collisionPoint(int id, float x, float y); CollisionPolygon collisionPolygon(float [] vertices); CollisionPolygon collisionPolygon(int id, float [] vertices); CollisionPolygon collisionPolygon(Vector2[] vectors); CollisionPolygon collisionPolygon(int id, Vector2[] vectors); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id); QuadTreeAwareCollisionBox quadTreeAwareCollisionBox(int id, float x, float y, float width, float height); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id); QuadTreeAwareCollisionCircle quadTreeAwareCollisionCircle(int id, float x, float y, float radius); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id); QuadTreeAwareCollisionPoint quadTreeAwareCollisionPoint(int id, float x, float y); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, float [] vertices); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(Vector2[] vectors); QuadTreeAwareCollisionPolygon quadTreeAwareCollisionPolygon(int id, Vector2[] vectors); StaticCollisionBox staticCollisionBox(); StaticCollisionBox staticCollisionBox(int id); StaticCollisionBox staticCollisionBox(int id, float x, float y, float width, float height); StaticCollisionCircle staticCollisionCircle(); StaticCollisionCircle staticCollisionCircle(int id); StaticCollisionCircle staticCollisionCircle(int id, float centerX, float centerY, float radius); StaticCollisionPoint staticCollisionPoint(); StaticCollisionPoint staticCollisionPoint(int id); StaticCollisionPoint staticCollisionPoint(int id, float x, float y); StaticCollisionPolygon staticCollisionPolygon(float [] vertices); StaticCollisionPolygon staticCollisionPolygon(int id, float [] vertices); StaticCollisionPolygon staticCollisionPolygon(Vector2[] vectors); StaticCollisionPolygon staticCollisionPolygon(int id, Vector2[] vectors); void release(CollisionBox collisionBox); void release(CollisionCircle collisionCircle); void release(CollisionPoint collisionPoint); void release(CollisionPolygon collisionPolygon); void release(QuadTreeAwareCollisionBox collisionBox); void release(QuadTreeAwareCollisionCircle collisionCircle); void release(QuadTreeAwareCollisionPoint collisionPoint); void release(QuadTreeAwareCollisionPolygon collisionPolygon); void release(StaticCollisionBox collisionBox); void release(StaticCollisionCircle collisionCircle); void release(StaticCollisionPoint collisionPoint); void release(StaticCollisionPolygon collisionPolygon); int getTotalCollisionBoxesAvailable(); int getTotalCollisionCirclesAvailable(); int getTotalCollisionPointsAvailable(); int getTotalCollisionPolygonsAvailable(); int getTotalQuadTreeAwareCollisionBoxesAvailable(); int getTotalQuadTreeAwareCollisionCirclesAvailable(); int getTotalQuadTreeAwareCollisionPointsAvailable(); int getTotalQuadTreeAwareCollisionPolygonsAvailable(); int getTotalStaticCollisionBoxesAvailable(); int getTotalStaticCollisionCirclesAvailable(); int getTotalStaticCollisionPointsAvailable(); int getTotalStaticCollisionPolygonsAvailable(); static int DEFAULT_POOL_SIZE; }
@Test public void testStaticCollisionPolygon() { for(int i = 0; i < 10; i++) { final int id = 97 + i; final Vector2 [] vectors = new Vector2[] { new Vector2(10f * i, 10f * i), new Vector2(20f * i, 20f * i), new Vector2(i, 20f * i) }; final StaticCollisionPolygon collisionPolygon = collisions.staticCollisionPolygon(id, vectors); Assert.assertEquals(0, collisions.getTotalStaticCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); Assert.assertEquals(id, collisionPolygon.getId()); Assert.assertEquals(vectors[0].x, collisionPolygon.getX(), 0f); Assert.assertEquals(vectors[0].y, collisionPolygon.getY(), 0f); Assert.assertEquals(vectors[1].x, collisionPolygon.getX(1), 0f); Assert.assertEquals(vectors[1].y, collisionPolygon.getY(1), 0f); Assert.assertEquals(vectors[2].x, collisionPolygon.getX(2), 0f); Assert.assertEquals(vectors[2].y, collisionPolygon.getY(2), 0f); collisionPolygon.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); collisionPolygon.dispose(); Assert.assertEquals(DEFAULT_POOL_SIZE, collisions.getTotalStaticCollisionPolygonsAvailable()); Assert.assertEquals(0, InterpolationTracker.getTotalObjects()); } }
CollisionBox extends Rectangle implements CollisionArea, PositionChangeListener<CollisionBox>, SizeChangeListener<CollisionBox> { @Override public int getId() { return id; } CollisionBox(); CollisionBox(int id); CollisionBox(float x, float y, float width, float height); CollisionBox(int id, float x, float y, float width, float height); CollisionBox(int id, Collisions collisions); @Override void dispose(); @Override void forceTo(float x, float y); @Override CollisionArea setTo(float x, float y, float width, float height); @Override void forceTo(float x, float y, float width, float height); void forceToWidth(float width); void forceToHeight(float height); @Override int getRenderWidth(); @Override int getRenderHeight(); @Override float getRawRenderWidth(); @Override float getRawRenderHeight(); @Override void preUpdate(); @Override void interpolate(float alpha); @Override int getRenderX(); @Override int getRenderY(); @Override float getRawRenderX(); @Override float getRawRenderY(); @Override RenderCoordMode getRenderCoordMode(); @Override void setRenderCoordMode(RenderCoordMode mode); @Override int getId(); @Override void positionChanged(CollisionBox moved); @Override void sizeChanged(CollisionBox changed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); @Override void addSizeChangeListener(SizeChangeListener<T> listener); @Override void removeSizeChangeListener(SizeChangeListener<T> listener); boolean isInterpolateRequired(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testIdGeneration() { rectangle1 = new CollisionBox(); rectangle2 = new CollisionBox(); Assert.assertEquals(true, rectangle1.getId() != rectangle2.getId()); }
CollisionBox extends Rectangle implements CollisionArea, PositionChangeListener<CollisionBox>, SizeChangeListener<CollisionBox> { @Override public <T extends Positionable> void addPostionChangeListener( PositionChangeListener<T> listener) { positionChangeListenerLock.lockWrite(); if (positionChangeListeners == null) { positionChangeListeners = new Array<PositionChangeListener>(true,1); } positionChangeListeners.add(listener); positionChangeListenerLock.unlockWrite(); } CollisionBox(); CollisionBox(int id); CollisionBox(float x, float y, float width, float height); CollisionBox(int id, float x, float y, float width, float height); CollisionBox(int id, Collisions collisions); @Override void dispose(); @Override void forceTo(float x, float y); @Override CollisionArea setTo(float x, float y, float width, float height); @Override void forceTo(float x, float y, float width, float height); void forceToWidth(float width); void forceToHeight(float height); @Override int getRenderWidth(); @Override int getRenderHeight(); @Override float getRawRenderWidth(); @Override float getRawRenderHeight(); @Override void preUpdate(); @Override void interpolate(float alpha); @Override int getRenderX(); @Override int getRenderY(); @Override float getRawRenderX(); @Override float getRawRenderY(); @Override RenderCoordMode getRenderCoordMode(); @Override void setRenderCoordMode(RenderCoordMode mode); @Override int getId(); @Override void positionChanged(CollisionBox moved); @Override void sizeChanged(CollisionBox changed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); @Override void addSizeChangeListener(SizeChangeListener<T> listener); @Override void removeSizeChangeListener(SizeChangeListener<T> listener); boolean isInterpolateRequired(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }
@Test public void testRectangleDefaultConstructor() { rectangle1 = new CollisionBox(); rectangle1.addPostionChangeListener(this); Assert.assertEquals(0f, rectangle1.getX()); Assert.assertEquals(0f, rectangle1.getY()); Assert.assertEquals(1f, rectangle1.getWidth()); Assert.assertEquals(1f, rectangle1.getHeight()); Assert.assertEquals(0, positionNotificationReceived); } @Test public void testRectangle() { rectangle1 = new CollisionBox(100f, 100f, 50f, 50f); rectangle1.addPostionChangeListener(this); Assert.assertEquals(100f, rectangle1.getX()); Assert.assertEquals(100f, rectangle1.getY()); Assert.assertEquals(50f, rectangle1.getWidth()); Assert.assertEquals(50f, rectangle1.getHeight()); Assert.assertEquals(0, positionNotificationReceived); }
MonospaceFontGlyphLayout implements FontGlyphLayout { public int calculateMaxCharactersBeforeWrap(CharSequence str, int from, int estimate, float targetWidth) { float x = 0f; for(int i = from; i < str.length(); i++) { final char c = str.charAt(i); switch(c) { case '\r': case '\n': return i - from; } if(x + fontParameters.characterWidth > targetWidth) { if(Character.isWhitespace(c)) { return i - from; } if(c == '\n' || c == '\r') { return i - from; } for(int j = i - 1; j >= from; j--) { final char previousChar = str.charAt(j); if(Character.isWhitespace(previousChar)) { return j - from; } } return i - from; } x += fontParameters.characterWidth + fontParameters.spacing; } return Math.min(estimate, str.length() - from); } MonospaceFontGlyphLayout(MonospaceGameFont monospaceFont); @Override void setText(CharSequence str); @Override void setText(CharSequence str, Color color, float targetWidth, int halign, boolean wrap); int calculateMaxCharactersBeforeWrap(CharSequence str, int from, int estimate, float targetWidth); @Override void reset(); @Override void dispose(); @Override float getWidth(); @Override float getHeight(); @Override GameFont getFont(); void transferGlyphsTo(Array<MonospaceGlyph> result, float x, float y); Array<MonospaceGlyph> getGlyphs(); }
@Test public void testCalculateMaxCharactersBeforeWrap() { final int estimate = 5; final float targetWidth = (5 * FONT_CHARACTER_WIDTH) + (4 * FONT_SPACING); Assert.assertEquals(3, glyphLayout.calculateMaxCharactersBeforeWrap("abc\ndef", 0, estimate, targetWidth)); Assert.assertEquals(3, glyphLayout.calculateMaxCharactersBeforeWrap("abc def", 0, estimate, targetWidth)); Assert.assertEquals(3, glyphLayout.calculateMaxCharactersBeforeWrap("abc def ghi", 4, estimate, targetWidth)); Assert.assertEquals(5, glyphLayout.calculateMaxCharactersBeforeWrap("abcdef", 0, estimate, targetWidth)); Assert.assertEquals(2, glyphLayout.calculateMaxCharactersBeforeWrap("ab\ncdef", 0, estimate, targetWidth)); Assert.assertEquals(2, glyphLayout.calculateMaxCharactersBeforeWrap("abc def", 5, estimate, targetWidth)); Assert.assertEquals(0, glyphLayout.calculateMaxCharactersBeforeWrap("\n", 0, estimate, targetWidth)); Assert.assertEquals(0, glyphLayout.calculateMaxCharactersBeforeWrap("", 0, estimate, targetWidth)); Assert.assertEquals(0, glyphLayout.calculateMaxCharactersBeforeWrap("a", 0, estimate, FONT_CHARACTER_WIDTH - 1f)); }
Rectangle extends Shape { public Rectangle() { this(0, 0, 1, 1); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testRectangle() { rectangle1 = new Rectangle(100f, 100f, 50f, 50f); Assert.assertEquals(100f, rectangle1.getX(), 0); Assert.assertEquals(100f, rectangle1.getY(), 0); Assert.assertEquals(50f, rectangle1.getWidth(), 0); Assert.assertEquals(50f, rectangle1.getHeight(), 0); Assert.assertEquals(150f, rectangle1.getMaxX(), 0); Assert.assertEquals(150f, rectangle1.getMaxY(), 0); Assert.assertEquals(125f, rectangle1.getCenterX(), MathUtils.FLOAT_ROUNDING_ERROR); Assert.assertEquals(125f, rectangle1.getCenterY(), MathUtils.FLOAT_ROUNDING_ERROR); }
Rectangle extends Shape { public void setX(float x) { polygon.setX(x); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetX() { rectangle1 = new Rectangle(100f, 100f, 50f, 50f); rectangle1.setX(200f); Assert.assertEquals(200f, rectangle1.getX(), 0); Assert.assertEquals(100f, rectangle1.getY(), 0); Assert.assertEquals(50f, rectangle1.getWidth(), 0); Assert.assertEquals(50f, rectangle1.getHeight(), 0); Assert.assertEquals(225f, rectangle1.getCenterX(), MathUtils.FLOAT_ROUNDING_ERROR); Assert.assertEquals(125f, rectangle1.getCenterY(), MathUtils.FLOAT_ROUNDING_ERROR); }
Rectangle extends Shape { public void setY(float y) { polygon.setY(y); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetY() { rectangle1 = new Rectangle(100f, 100f, 50f, 50f); rectangle1.setY(200f); Assert.assertEquals(100f, rectangle1.getX(), 0); Assert.assertEquals(200f, rectangle1.getY(), 0); Assert.assertEquals(50f, rectangle1.getWidth(), 0); Assert.assertEquals(50f, rectangle1.getHeight(), 0); Assert.assertEquals(125f, rectangle1.getCenterX(), MathUtils.FLOAT_ROUNDING_ERROR); Assert.assertEquals(225f, rectangle1.getCenterY(), MathUtils.FLOAT_ROUNDING_ERROR); }
Rectangle extends Shape { public Rectangle setWidth(float width) { float rotation = polygon.getRotation(); polygon.setRotation(-rotation); polygon.setVertices(determineVertices(getX(), getY(), width, getHeight())); polygon.setRotation(rotation); this.width = width; return this; } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetWidth() { rectangle1 = new Rectangle(100f, 100f, 50f, 50f); rectangle1.setWidth(100f); Assert.assertEquals(100f, rectangle1.getX(), 0); Assert.assertEquals(100f, rectangle1.getY(), 0); Assert.assertEquals(100f, rectangle1.getWidth(), 0); Assert.assertEquals(50f, rectangle1.getHeight(), 0); }
TiledMap { public int getWidth() { return tiledMapData.getWidth(); } TiledMap(FileHandle fileHandle); TiledMap(FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledParser parser, FileHandle fileHandle, boolean loadTilesetTextures); TiledMap(TiledMapData tiledMapData, boolean loadTilesetTextures); boolean isTilesetTexturesLoaded(); boolean isTilesetTexturesLoaded(boolean ignoreObjectTemplateTilesets); boolean loadTilesetTextures(); boolean loadTilesetTextures(AssetManager assetManager); boolean loadTilesetTextures(TextureAtlas textureAtlas); boolean loadTilesetTextures(boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(AssetManager assetManager, boolean loadObjectTemplateTilesets); boolean loadTilesetTextures(TextureAtlas textureAtlas, boolean loadObjectTemplateTilesets); void update(float delta); void draw(Graphics g, int x, int y); void draw(Graphics g, int x, int y, int layer); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void draw(Graphics g, int x, int y, int startTileX, int startTileY, int widthInTiles, int heightInTiles, int layer); void drawTileLayer(Graphics g, TileLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); void drawGroupLayer(Graphics g, GroupLayer layer, int renderX, int renderY, int startTileX, int startTileY, int widthInTiles, int heightInTiles); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); TileLayer getTileLayer(String name); TileLayer getTileLayer(String name, boolean recursive); TileLayer getTileLayer(int index); GroupLayer getGroupLayer(String name); GroupLayer getGroupLayer(String name, boolean recursive); GroupLayer getGroupLayer(int index); TiledObjectGroup getObjectGroup(String name); TiledObjectGroup getObjectGroup(String name, boolean recursive); Iterable<TiledObjectGroup> getObjectGroups(); int getLayerIndex(String name); int getLayerIndexIgnoreCase(String name); Tile getTile(int tileId); Tile getTile(int x, int y, int layer); void dispose(); void dispose(boolean disposeTilesets); Orientation getOrientation(); StaggerAxis getStaggerAxis(); StaggerIndex getStaggerIndex(); int getSideLength(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getPixelWidth(); int getPixelHeight(); Array<Tileset> getTilesets(); Array<Layer> getLayers(); int getTotalObjectGroups(); Color getBackgroundColor(); void setTileLayerRenderer(TileLayerRenderer tileLayerRenderer); void setTiledObjectGroupRenderer(TiledObjectGroupRenderer tiledObjectGroupRenderer); boolean containsAnimatedTiles(); static boolean STRICT_LAYER_VISIBILITY; static boolean FAST_RENDER_EMPTY_LAYERS; static boolean CLIP_TILES_OUTSIDE_GRAPHICS_VIEWPORT; }
@Test public void testGetWidth() { Assert.assertEquals(10, tiledMap.getWidth()); }
Tileset implements Disposable { public boolean contains(int tileId) { return tilesetSource.contains(tileId, firstGid, lastGid); } Tileset(int firstGid, TilesetSource tilesetSource); boolean containsProperty(String propertyName); String getProperty(String propertyName); void setProperty(String propertyName, String value); ObjectMap<String, String> getProperties(); void drawTile(Graphics g, int tileId, int renderX, int renderY); void drawTileset(Graphics g, int renderX, int renderY); Tile getTile(int tileId); Tile getTile(int x, int y); Array<AssetDescriptor> getDependencies(FileHandle tmxPath); boolean isTextureLoaded(); void loadTexture(FileHandle tmxPath); void loadTexture(AssetManager assetManager, FileHandle tmxPath); void loadTexture(TextureAtlas textureAtlas); @Override void dispose(); boolean contains(int tileId); int getTileId(int x, int y); int getTileX(int tileId); int getTileY(int tileId); int getWidthInTiles(); int getHeightInTiles(); int getWidth(); int getHeight(); int getTileWidth(); int getTileHeight(); int getSpacing(); int getMargin(); int getFirstGid(); String getSourceInternalUuid(); }
@Test public void testLastGidWithoutSpacing() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(true, tileset.contains(16)); Assert.assertEquals(false, tileset.contains(17)); } @Test public void testLastGidWithSpacing() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(true, tileset.contains(9)); Assert.assertEquals(false, tileset.contains(10)); }
Rectangle extends Shape { public Rectangle setHeight(float height) { float rotation = polygon.getRotation(); polygon.setRotation(-rotation); polygon.setVertices(determineVertices(getX(), getY(), getWidth(), height)); polygon.setRotation(rotation); this.height = height; return this; } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetHeight() { rectangle1 = new Rectangle(100f, 100f, 50f, 50f); rectangle1.setHeight(100f); Assert.assertEquals(100f, rectangle1.getX(), 0); Assert.assertEquals(100f, rectangle1.getY(), 0); Assert.assertEquals(50f, rectangle1.getWidth(), 0); Assert.assertEquals(100f, rectangle1.getHeight(), 0); }
Rectangle extends Shape { @Override public void rotateAround(float centerX, float centerY, float degrees) { polygon.rotateAround(centerX, centerY, degrees); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testRotateAround() { rectangle1 = new Rectangle(0f, 0f, 10f, 10f); rectangle1.rotateAround(0f, 0f, 90f); Assert.assertEquals(0f, rectangle1.getVertices()[0], 0); Assert.assertEquals(0f, rectangle1.getVertices()[1], 0); Assert.assertEquals(0, MathUtils.round(rectangle1.getVertices()[2])); Assert.assertEquals(10, MathUtils.round(rectangle1.getVertices()[3])); Assert.assertEquals(-10, MathUtils.round(rectangle1.getVertices()[4])); Assert.assertEquals(10, MathUtils.round(rectangle1.getVertices()[5])); Assert.assertEquals(-10, MathUtils.round(rectangle1.getVertices()[6])); Assert.assertEquals(0, MathUtils.round(rectangle1.getVertices()[7])); }
Rectangle extends Shape { @Override public boolean contains(float x, float y) { return polygon.contains(x, y); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testContainsRectangle() { rectangle1 = new Rectangle(0, 0, 50, 50); rectangle2 = new Rectangle(50, 50, 50, 50); Assert.assertFalse(rectangle1.contains(rectangle2)); Assert.assertFalse(rectangle2.contains(rectangle1)); rectangle2 = new Rectangle(25, 25, 50, 50); Assert.assertFalse(rectangle1.contains(rectangle2)); Assert.assertFalse(rectangle2.contains(rectangle1)); rectangle2 = new Rectangle(0, 0, 25, 25); Assert.assertTrue(rectangle1.contains(rectangle2)); Assert.assertFalse(rectangle2.contains(rectangle1)); rectangle2 = new Rectangle(15, 15, 25, 25); Assert.assertTrue(rectangle1.contains(rectangle2)); Assert.assertFalse(rectangle2.contains(rectangle1)); rectangle2 = new Rectangle(48, 48, 25, 25); Assert.assertFalse(rectangle1.contains(rectangle2)); Assert.assertFalse(rectangle2.contains(rectangle1)); rectangle1 = new Rectangle(0, 0, 128, 128); rectangle2 = new Rectangle(42, 72, 32, 32); Assert.assertTrue(rectangle1.contains(rectangle2)); Assert.assertFalse(rectangle2.contains(rectangle1)); } @Test public void testContainsZeroSizeRectangle() { rectangle1 = new Rectangle(0, 0, 10, 10); rectangle2 = new Rectangle(50, 50, 0, 0); Assert.assertFalse(rectangle2.contains(rectangle1)); }
Rectangle extends Shape { @Override public boolean intersects(Sizeable shape) { return polygon.intersects(shape); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testIntersectsCircle() { rectangle1 = new Rectangle(0f, 0f, 50f, 50f); Circle intersectingCircle = new Circle(75f, 75f, 50f); Circle nonIntersectingCircle = new Circle(500f, 500f, 50f); Assert.assertTrue(rectangle1.intersects(intersectingCircle)); Assert.assertFalse(rectangle1.intersects(nonIntersectingCircle)); } @Test public void testIntersectsRectangle() { rectangle1 = new Rectangle(100f, 100f, 75f, 75f); rectangle2 = new Rectangle(50f, 50f, 100f, 100f); Assert.assertTrue(rectangle1.intersects(rectangle2)); Assert.assertTrue(rectangle2.intersects(rectangle1)); rectangle2 = new Rectangle(0f, 0f, 50f, 50f); Assert.assertFalse(rectangle1.intersects(rectangle2)); Assert.assertFalse(rectangle2.intersects(rectangle1)); } @Test public void testIntersectsSameRectangle() { rectangle1 = new Rectangle(0f, 0f, 32f, 32f); rectangle2 = new Rectangle(0f, 0f, 32f, 32f); Assert.assertTrue(rectangle1.intersects(rectangle2)); Assert.assertTrue(rectangle2.intersects(rectangle1)); } @Test public void testIntersectsXYWidthHeight() { rectangle1 = new Rectangle(100f, 100f, 75f, 75f); Assert.assertTrue(rectangle1.intersects(50f, 50f, 100f, 100f)); Assert.assertFalse(rectangle1.intersects(0f, 0f, 50f, 50f)); }
Rectangle extends Shape { public Rectangle lerp(Rectangle target, float alpha) { lerp(this, this, target, alpha); return this; } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testLerp() { rectangle1 = new Rectangle(0, 0, 50, 50); rectangle2 = new Rectangle(50, 50, 100f, 100f); rectangle1.lerp(rectangle2, 0.5f); Assert.assertEquals(25f, rectangle1.getX(), 0); Assert.assertEquals(25f, rectangle1.getY(), 0); Assert.assertEquals(75f, rectangle1.getWidth(), 0); Assert.assertEquals(75f, rectangle1.getHeight(), 0); Assert.assertEquals(0f, rectangle1.getRotation(), 0); }
Rectangle extends Shape { public Rectangle intersection(Rectangle rect) { if (polygon.getRotation() != 0f || rect.getRotation() != 0f) throw new UnsupportedOperationException( "Rectangle.intersection is not implemented to handle rotated rectangles"); float newX = Math.max(getX(), rect.getX()); float newY = Math.max(getY(), rect.getY()); float newWidth = Math.min(getMaxX(), rect.getMaxX()) - newX; float newHeight = Math.min(getMaxY(), rect.getMaxY()) - newY; return new Rectangle(newX, newY, newWidth, newHeight); } Rectangle(); Rectangle(Geometry geometry); Rectangle(float x, float y, float width, float height); Rectangle(Rectangle rectangle); @Override void dispose(); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 point); @Override boolean contains(Sizeable shape); boolean contains(Rectangle rectangle); boolean contains(Circle circle); @Override boolean intersects(Sizeable shape); boolean intersects(Circle circle); boolean intersects(Rectangle rectangle); boolean intersects(float x, float y, float width, float height); boolean intersects(Triangle triangle); boolean intersects(Polygon polygon); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); Rectangle intersection(Rectangle rect); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); Rectangle lerp(Rectangle target, float alpha); Rectangle lerp(Rectangle result, Rectangle target, float alpha); static void lerp(Rectangle result, Rectangle from, Rectangle target, float alpha); float getDistanceTo(float x, float y); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); Rectangle set(float x, float y, float width, float height); void set(Rectangle rectangle); void setXY(float x, float y); void setXY(Vector2 position); @Override float getX(); void setX(float x); @Override float getY(); void setY(float y); float getWidth(); Rectangle setWidth(float width); float getHeight(); Rectangle setHeight(float height); Rectangle setSize(float width, float height); Rectangle setSize(float sizeXY); @Override void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); float getCenterX(); float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float [] getVertices(); @Override String toString(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testIntersection() { rectangle1 = new Rectangle(0, 0, 50f, 50f); rectangle2 = new Rectangle(25, 25, 100f, 100f); Rectangle rectangle3 = rectangle1.intersection(rectangle2); Assert.assertEquals(rectangle2.getX(), rectangle3.getX(), 0); Assert.assertEquals(rectangle2.getY(), rectangle3.getY(), 0); Assert.assertEquals(25f, rectangle3.getWidth(), 0); Assert.assertEquals(25f, rectangle3.getHeight(), 0); }