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
Rectangle extends Shape { @Override public String toString() { return "Rectangle [rotation=" + polygon.getRotation() + ", x=" + getX() + ", y=" + getY() + ", width=" + getWidth() + ", height=" + getHeight() + "]"; } 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 testToString() { rectangle1 = new Rectangle(0, 0, 40f, 60f); String rectangle = rectangle1.toString(); String expected = "Rectangle [rotation=0.0, x=0.0, y=0.0, width=40.0, height=60.0]"; Assert.assertEquals(expected, rectangle); }
TiledMap { public int getHeight() { return tiledMapData.getHeight(); } 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 testGetHeight() { Assert.assertEquals(8, tiledMap.getHeight()); }
Rectangle extends Shape { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Rectangle other = (Rectangle) obj; if (Float.floatToIntBits(getX()) != Float.floatToIntBits(other.getX())) return false; if (Float.floatToIntBits(getY()) != Float.floatToIntBits(other.getY())) return false; if (Float.floatToIntBits(height) != Float.floatToIntBits(other.height)) return false; if (Float.floatToIntBits(width) != Float.floatToIntBits(other.width)) return false; if (Float.floatToIntBits(getRotation()) != Float.floatToIntBits(other.getRotation())) return false; return true; } 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 testEquals() { rectangle1 = new Rectangle(0, 0, 50, 50); rectangle2 = new Rectangle(0, 0, 50, 50); Assert.assertEquals(rectangle1, rectangle2); rectangle2.rotate(1f); Assert.assertFalse(rectangle1.equals(rectangle2)); rectangle2 = new Rectangle(0.001f, 0, 50, 50); Assert.assertFalse(rectangle1.equals(rectangle2)); }
Rectangle extends Shape { @Override public void dispose() { if(disposed) { return; } disposed = true; clearPositionChangeListeners(); clearSizeChangeListeners(); if(geometry == null) { return; } geometry.release(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 testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); Assert.assertEquals(1, geometry.getTotalRectanglesAvailable()); rectangle1 = geometry.rectangle(); Assert.assertEquals(0, geometry.getTotalRectanglesAvailable()); rectangle1.dispose(); Assert.assertEquals(1, geometry.getTotalRectanglesAvailable()); rectangle1.dispose(); Assert.assertEquals(1, geometry.getTotalRectanglesAvailable()); rectangle1 = geometry.rectangle(); Assert.assertEquals(0, geometry.getTotalRectanglesAvailable()); rectangle1.dispose(); Assert.assertEquals(1, geometry.getTotalRectanglesAvailable()); }
RegularHexagon extends RegularPolygon { @Override public void dispose() { if(disposed) { return; } disposed = true; clearPositionChangeListeners(); clearSizeChangeListeners(); if(geometry == null) { return; } geometry.release(this); } RegularHexagon(float centerX, float centerY, float radius); RegularHexagon(Geometry geometry); @Override void dispose(); static final float ROTATION_SYMMETRY; }
@Test public void testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularHexagonsAvailable()); RegularHexagon hexagon = geometry.regularHexagon(); org.junit.Assert.assertEquals(0, geometry.getTotalRegularHexagonsAvailable()); hexagon.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularHexagonsAvailable()); hexagon.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularHexagonsAvailable()); hexagon = geometry.regularHexagon(); org.junit.Assert.assertEquals(0, geometry.getTotalRegularHexagonsAvailable()); hexagon.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularHexagonsAvailable()); }
Intersector { public static boolean intersectLines(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 intersection) { float x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y, x3 = p3.x, y3 = p3.y, x4 = p4.x, y4 = p4.y; float det3 = det(x1 - x2, y1 - y2, x3 - x4, y3 - y4); if (det3 == 0) return false; float det1 = det(x1, y1, x2, y2); float det2 = det(x3, y3, x4, y4); float x = det(det1, x1 - x2, det2, x3 - x4) / det3; float y = det(det1, y1 - y2, det2, y3 - y4) / det3; intersection.x = x; intersection.y = y; return true; } static boolean intersectLines(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 intersection); static boolean intersectLineSegments(float segAX1, float segAY1, float segAX2, float segAY2, float segBX1, float segBY1, float segBX2, float segBY2); static boolean intersects(Rectangle rectangle, Circle circle); static boolean containsPolygon(Polygon p1, Polygon p2); static boolean intersectSegmentPolygon(Vector2 p1, Vector2 p2, float[] vertices); }
@Test public void testIntersectLinesWithNonIntersectingLines() { Vector2 line1Start = new Vector2(0, 0); Vector2 line1End = new Vector2(0, 32); Vector2 line2Start = new Vector2(32, 0); Vector2 line2End = new Vector2(32, 32); Assert.assertEquals(false, Intersector.intersectLines(line1Start, line1End, line2Start, line2End, new Vector2())); } @Test public void testIntersectLinesWithIntersectingLines() { Vector2 line1Start = new Vector2(0, 0); Vector2 line1End = new Vector2(0, 32); Vector2 line2Start = new Vector2(-32, 16); Vector2 line2End = new Vector2(32, 16); Assert.assertEquals(true, Intersector.intersectLines(line1Start, line1End, line2Start, line2End, new Vector2())); line1Start = new Vector2(100, 100); line1End = new Vector2(150, 100); line2Start = new Vector2(50, 100); line2End = new Vector2(50, 200); Assert.assertEquals(true, Intersector.intersectLines(line1Start, line1End, line2Start, line2End, new Vector2())); }
LineSegment implements Disposable { public void set(float x1, float y1, float x2, float y2) { pointA.set(x1, y1); pointB.set(x2, y2); } LineSegment(Geometry geometry); LineSegment(float x1, float y1, float x2, float y2); LineSegment(Point pA, Point pB); void dispose(); void setDisposed(boolean disposed); void set(float x1, float y1, float x2, float y2); boolean contains(float x, float y); boolean intersectsLineSegment(float segmentX1, float segmentY1, float segmentX2, float segmentY2); boolean intersects(LineSegment lineSegment); @Deprecated Point getIntersection(LineSegment lineSegment); boolean getIntersection(LineSegment lineSegment, Point result); boolean intersects(Rectangle rectangle); Point getPointA(); void setPointA(Point pointA); Point getPointB(); void setPointB(Point pointB); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float getLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSet() { segment1 = new LineSegment(0, 0, 10, 10); segment1.set(15, 17, 25, 27); Assert.assertEquals(15f, segment1.getPointA().x, 0f); Assert.assertEquals(17f, segment1.getPointA().y, 0f); Assert.assertEquals(25f, segment1.getPointB().x, 0f); Assert.assertEquals(27f, segment1.getPointB().y, 0f); }
LineSegment implements Disposable { public boolean contains(float x, float y) { if (pointA.getX() == x && pointA.getY() == y) return true; if (pointB.getX() == x && pointB.getY() == y) return true; Point p3 = new Point(x, y); return p3.isOnLineBetween(pointA, pointB); } LineSegment(Geometry geometry); LineSegment(float x1, float y1, float x2, float y2); LineSegment(Point pA, Point pB); void dispose(); void setDisposed(boolean disposed); void set(float x1, float y1, float x2, float y2); boolean contains(float x, float y); boolean intersectsLineSegment(float segmentX1, float segmentY1, float segmentX2, float segmentY2); boolean intersects(LineSegment lineSegment); @Deprecated Point getIntersection(LineSegment lineSegment); boolean getIntersection(LineSegment lineSegment, Point result); boolean intersects(Rectangle rectangle); Point getPointA(); void setPointA(Point pointA); Point getPointB(); void setPointB(Point pointB); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float getLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testContains() { segment1 = new LineSegment(0, 0, 10, 0); Assert.assertEquals(true, segment1.contains(0, 0)); Assert.assertEquals(true, segment1.contains(10, 0)); Assert.assertEquals(true, segment1.contains(5, 0)); Assert.assertEquals(false, segment1.contains(5, -5)); Assert.assertEquals(false, segment1.contains(5, 5)); Assert.assertEquals(false, segment1.contains(-5, -5)); Assert.assertEquals(false, segment1.contains(15, -5)); Assert.assertEquals(false, segment1.contains(-5, 5)); Assert.assertEquals(false, segment1.contains(15, 5)); }
LineSegment implements Disposable { public boolean intersectsLineSegment(float segmentX1, float segmentY1, float segmentX2, float segmentY2) { return Intersector.intersectLineSegments(pointA.x, pointA.y, pointB.x, pointB.y, segmentX1, segmentY1, segmentX2, segmentY2); } LineSegment(Geometry geometry); LineSegment(float x1, float y1, float x2, float y2); LineSegment(Point pA, Point pB); void dispose(); void setDisposed(boolean disposed); void set(float x1, float y1, float x2, float y2); boolean contains(float x, float y); boolean intersectsLineSegment(float segmentX1, float segmentY1, float segmentX2, float segmentY2); boolean intersects(LineSegment lineSegment); @Deprecated Point getIntersection(LineSegment lineSegment); boolean getIntersection(LineSegment lineSegment, Point result); boolean intersects(Rectangle rectangle); Point getPointA(); void setPointA(Point pointA); Point getPointB(); void setPointB(Point pointB); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float getLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testIntersectsLineSegment() { segment1 = new LineSegment(0, 0, 10, 0); segment2 = new LineSegment(5, -5, 5, 5); Assert.assertEquals(true, segment1.intersects(segment2)); Assert.assertEquals(true, segment2.intersects(segment1)); segment2 = new LineSegment(15, -5, 15, 5); Assert.assertEquals(false, segment1.intersects(segment2)); Assert.assertEquals(false, segment2.intersects(segment1)); }
LineSegment implements Disposable { public void dispose() { if(disposed) { return; } disposed = true; if(geometry == null) { return; } geometry.release(this); } LineSegment(Geometry geometry); LineSegment(float x1, float y1, float x2, float y2); LineSegment(Point pA, Point pB); void dispose(); void setDisposed(boolean disposed); void set(float x1, float y1, float x2, float y2); boolean contains(float x, float y); boolean intersectsLineSegment(float segmentX1, float segmentY1, float segmentX2, float segmentY2); boolean intersects(LineSegment lineSegment); @Deprecated Point getIntersection(LineSegment lineSegment); boolean getIntersection(LineSegment lineSegment, Point result); boolean intersects(Rectangle rectangle); Point getPointA(); void setPointA(Point pointA); Point getPointB(); void setPointB(Point pointB); float getMinX(); float getMinY(); float getMaxX(); float getMaxY(); float getLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); org.junit.Assert.assertEquals(1, geometry.getTotalLineSegmentsAvailable()); segment1 = geometry.lineSegment(); org.junit.Assert.assertEquals(0, geometry.getTotalLineSegmentsAvailable()); segment1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalLineSegmentsAvailable()); segment1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalLineSegmentsAvailable()); segment1 = geometry.lineSegment(); org.junit.Assert.assertEquals(0, geometry.getTotalLineSegmentsAvailable()); segment1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalLineSegmentsAvailable()); }
TiledMap { public int getTileWidth() { return tiledMapData.getTileWidth(); } 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 testGetTileWidth() { Assert.assertEquals(32, tiledMap.getTileWidth()); for (int i = 0; i < tiledMap.getTilesets().size; i++) { Assert.assertEquals(32, tiledMap.getTilesets().get(i).getTileWidth()); } }
Polygon extends Shape { public void addPoint(float x, float y) { float[] existingVertices = vertices; float[] newVertices = new float[existingVertices.length + 2]; if (existingVertices.length > 0) { System.arraycopy(existingVertices, 0, newVertices, 0, existingVertices.length); } newVertices[existingVertices.length] = x; newVertices[existingVertices.length + 1] = y; this.vertices = newVertices; clearTotalSidesCache(); setDirty(); notifyPositionChangeListeners(); notifySizeChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testAddPoint() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(5f, 5f), new Point(2.5f, 10f) }); polygon.addPoint(new Point(-2.5f, 10f)); polygon.addPoint(new Point(-5f, 5f)); Assert.assertEquals(0f, polygon.getX(), 0.01f); Assert.assertEquals(0f, polygon.getY(), 0.01f); Assert.assertEquals(5f, polygon.getMaxX(), 0.01f); Assert.assertEquals(10f, polygon.getMaxY(), 0.01f); }
Polygon extends Shape { private void removePoint(int i) { float[] existingVertices = vertices; float[] newVertices = new float[existingVertices.length - 2]; if (i > 0) { System.arraycopy(existingVertices, 0, newVertices, 0, i); } if (i < existingVertices.length - 2) { System.arraycopy(existingVertices, i + 2, newVertices, i, existingVertices.length - i - 2); } this.vertices = newVertices; setDirty(); clearTotalSidesCache(); notifyPositionChangeListeners(); notifySizeChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testRemovePoint() { Point maxX = new Point(5f, 5f); Point maxY1 = new Point(2.5f, 10f); Point maxY2 = new Point(-2.5f, 10f); Polygon polygon = new Polygon(new Point[] { new Point(0f, 0f), maxX, maxY1, maxY2, new Point(-5f, 5f) }); Assert.assertEquals(5f, polygon.getMaxX(), 0.01f); Assert.assertEquals(10f, polygon.getMaxY(), 0.01f); polygon.removePoint(maxX); Assert.assertEquals(2.5f, polygon.getMaxX(), 0.01f); Assert.assertEquals(10f, polygon.getMaxY(), 0.01f); polygon.addPoint(maxX); polygon.removePoint(maxY1); polygon.removePoint(maxY2); Assert.assertEquals(5f, polygon.getMaxX(), 0.01f); Assert.assertEquals(5f, polygon.getMaxY(), 0.01f); }
Polygon extends Shape { public Polygon lerp(Polygon target, float alpha) { lerp(this, target, alpha); return this; } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testLerp() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f), }); Polygon target = new Polygon(new Point [] { new Point(10f, 10f), new Point(20f, 10f), new Point(20f, 20f), new Point(10f, 20f), }); polygon.lerp(target, 0.5f); Assert.assertEquals(5, MathUtils.round(polygon.getX(0))); Assert.assertEquals(5, MathUtils.round(polygon.getY(0))); Assert.assertEquals(15, MathUtils.round(polygon.getX(1))); Assert.assertEquals(5, MathUtils.round(polygon.getY(1))); Assert.assertEquals(15, MathUtils.round(polygon.getX(2))); Assert.assertEquals(15, MathUtils.round(polygon.getY(2))); Assert.assertEquals(5, MathUtils.round(polygon.getX(3))); Assert.assertEquals(15, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { @Override public void rotate(float degrees) { rotateAround(vertices[0], vertices[1], degrees); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testRotate() { Polygon polygon = new Polygon(new Point [] { new Point(10f, 0f), new Point(20f, 0f), new Point(20f, 10f), new Point(10f, 10f), }); polygon.rotate(90f); Assert.assertEquals(10, MathUtils.round(polygon.getX(0))); Assert.assertEquals(0, MathUtils.round(polygon.getY(0))); Assert.assertEquals(10, MathUtils.round(polygon.getX(1))); Assert.assertEquals(10, MathUtils.round(polygon.getY(1))); Assert.assertEquals(0, MathUtils.round(polygon.getX(2))); Assert.assertEquals(10, MathUtils.round(polygon.getY(2))); Assert.assertEquals(0, MathUtils.round(polygon.getX(3))); Assert.assertEquals(0, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { @Override public void rotateAround(float centerX, float centerY, float degrees) { if (degrees == 0f) { return; } rotation += degrees; final float cos = MathUtils.cos(degrees * MathUtils.degreesToRadians); final float sin = MathUtils.sin(degrees * MathUtils.degreesToRadians); for (int i = 0; i < vertices.length; i += 2) { float x = vertices[i]; float y = vertices[i + 1]; vertices[i] = (cos * (x - centerX) - sin * (y - centerY) + centerX); vertices[i + 1] = (sin * (x - centerX) + cos * (y - centerY) + centerY); } setDirty(); notifyPositionChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testRotateAround() { Polygon polygon = new Polygon(new Point [] { new Point(10f, 0f), new Point(20f, 0f), new Point(20f, 10f), new Point(10f, 10f), }); polygon.rotateAround(0f, 0f, -90f); Assert.assertEquals(-90f, polygon.getRotation(), 0.01f); Assert.assertEquals(0, MathUtils.round(polygon.getX(0))); Assert.assertEquals(-10, MathUtils.round(polygon.getY(0))); Assert.assertEquals(0, MathUtils.round(polygon.getX(1))); Assert.assertEquals(-20, MathUtils.round(polygon.getY(1))); Assert.assertEquals(10, MathUtils.round(polygon.getX(2))); Assert.assertEquals(-20, MathUtils.round(polygon.getY(2))); Assert.assertEquals(10, MathUtils.round(polygon.getX(3))); Assert.assertEquals(-10, MathUtils.round(polygon.getY(3))); polygon.rotate(90f); Assert.assertEquals(0f, polygon.getRotation(), 0.01f); Assert.assertEquals(0, MathUtils.round(polygon.getX(0))); Assert.assertEquals(-10, MathUtils.round(polygon.getY(0))); Assert.assertEquals(10, MathUtils.round(polygon.getX(1))); Assert.assertEquals(-10, MathUtils.round(polygon.getY(1))); Assert.assertEquals(10, MathUtils.round(polygon.getX(2))); Assert.assertEquals(0, MathUtils.round(polygon.getY(2))); Assert.assertEquals(0, MathUtils.round(polygon.getX(3))); Assert.assertEquals(0, MathUtils.round(polygon.getY(3))); polygon.rotateAround(0f, 0f, 90f); Assert.assertEquals(90f, polygon.getRotation(), 0.01f); Assert.assertEquals(10, MathUtils.round(polygon.getX(0))); Assert.assertEquals(0, MathUtils.round(polygon.getY(0))); Assert.assertEquals(10, MathUtils.round(polygon.getX(1))); Assert.assertEquals(10, MathUtils.round(polygon.getY(1))); Assert.assertEquals(0, MathUtils.round(polygon.getX(2))); Assert.assertEquals(10, MathUtils.round(polygon.getY(2))); Assert.assertEquals(0, MathUtils.round(polygon.getX(3))); Assert.assertEquals(0, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { @Override public void setRotation(float degrees) { setRotationAround(vertices[0], vertices[1], degrees); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSetRotation() { Polygon polygon = new Polygon(new Point [] { new Point(10f, 0f), new Point(20f, 0f), new Point(20f, 10f), new Point(10f, 10f), }); polygon.rotate(90f); Assert.assertEquals(90f, polygon.getRotation(), 0.01f); polygon.setRotation(0f); Assert.assertEquals(0f, polygon.getRotation(), 0.01f); Assert.assertEquals(10, MathUtils.round(polygon.getX(0))); Assert.assertEquals(0, MathUtils.round(polygon.getY(0))); Assert.assertEquals(20, MathUtils.round(polygon.getX(1))); Assert.assertEquals(0, MathUtils.round(polygon.getY(1))); Assert.assertEquals(20, MathUtils.round(polygon.getX(2))); Assert.assertEquals(10, MathUtils.round(polygon.getY(2))); Assert.assertEquals(10, MathUtils.round(polygon.getX(3))); Assert.assertEquals(10, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { @Override public void setRotationAround(float centerX, float centerY, float degrees) { if (rotation == degrees && centerX == getX() && centerY == getY()) { return; } rotateAround(centerX, centerY, degrees - rotation); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSetRotationAround() { Polygon polygon = new Polygon(new Point [] { new Point(10f, 0f), new Point(20f, 0f), new Point(20f, 10f), new Point(10f, 10f), }); polygon.setRotationAround(0f, 0f, -90f); Assert.assertEquals(0, MathUtils.round(polygon.getX(0))); Assert.assertEquals(-10, MathUtils.round(polygon.getY(0))); Assert.assertEquals(0, MathUtils.round(polygon.getX(1))); Assert.assertEquals(-20, MathUtils.round(polygon.getY(1))); Assert.assertEquals(10, MathUtils.round(polygon.getX(2))); Assert.assertEquals(-20, MathUtils.round(polygon.getY(2))); Assert.assertEquals(10, MathUtils.round(polygon.getX(3))); Assert.assertEquals(-10, MathUtils.round(polygon.getY(3))); polygon.setRotationAround(0f, 10f, 180f); Assert.assertEquals(-20, MathUtils.round(polygon.getX(0))); Assert.assertEquals(10, MathUtils.round(polygon.getY(0))); Assert.assertEquals(-30, MathUtils.round(polygon.getX(1))); Assert.assertEquals(10, MathUtils.round(polygon.getY(1))); Assert.assertEquals(-30, MathUtils.round(polygon.getX(2))); Assert.assertEquals(0, MathUtils.round(polygon.getY(2))); Assert.assertEquals(-20, MathUtils.round(polygon.getX(3))); Assert.assertEquals(0, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { public void set(Polygon polygon) { this.vertices = polygon.vertices; this.rotation = polygon.rotation; clearTotalSidesCache(); setDirty(); notifyPositionChangeListeners(); notifySizeChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSet() { Polygon polygon = new Polygon(new Point [] { new Point(10f, 10f), new Point(20f, 10f), new Point(20f, 20f), new Point(10f, 20f) }); polygon.setXY(100f, 100f); Assert.assertEquals(100, MathUtils.round(polygon.getX(0))); Assert.assertEquals(100, MathUtils.round(polygon.getY(0))); Assert.assertEquals(110, MathUtils.round(polygon.getX(1))); Assert.assertEquals(100, MathUtils.round(polygon.getY(1))); Assert.assertEquals(110, MathUtils.round(polygon.getX(2))); Assert.assertEquals(110, MathUtils.round(polygon.getY(2))); Assert.assertEquals(100, MathUtils.round(polygon.getX(3))); Assert.assertEquals(110, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { @Override public void setX(float x) { if (MathUtils.isEqual(x, getX())) { return; } float xDiff = x - getX(); for (int i = 0; i < vertices.length; i += 2) { vertices[i] += xDiff; } setDirty(); notifyPositionChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSetX() { Polygon polygon = new Polygon(new Point [] { new Point(10f, 0f), new Point(20f, 0f), new Point(20f, 10f), new Point(10f, 10f) }); polygon.setX(100f); Assert.assertEquals(100f, polygon.getX(), 0.01f); Assert.assertEquals(110f, polygon.getMaxX(), 0.01f); Assert.assertEquals(100, MathUtils.round(polygon.getX(0))); Assert.assertEquals(0, MathUtils.round(polygon.getY(0))); Assert.assertEquals(110, MathUtils.round(polygon.getX(1))); Assert.assertEquals(0, MathUtils.round(polygon.getY(1))); Assert.assertEquals(110, MathUtils.round(polygon.getX(2))); Assert.assertEquals(10, MathUtils.round(polygon.getY(2))); Assert.assertEquals(100, MathUtils.round(polygon.getX(3))); Assert.assertEquals(10, MathUtils.round(polygon.getY(3))); }
Polygon extends Shape { @Override public void setY(float y) { if (MathUtils.isEqual(y, getY())) { return; } float yDiff = y - getY(); for (int i = 1; i < vertices.length; i += 2) { vertices[i] += yDiff; } setDirty(); notifyPositionChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSetY() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 10f), new Point(10f, 10f), new Point(10f, 20f), new Point(0f, 20f) }); polygon.setY(200f); Assert.assertEquals(200f, polygon.getY(), 0.01f); Assert.assertEquals(210f, polygon.getMaxY(), 0.01f); Assert.assertEquals(0, MathUtils.round(polygon.getX(0))); Assert.assertEquals(200, MathUtils.round(polygon.getY(0))); Assert.assertEquals(10, MathUtils.round(polygon.getX(1))); Assert.assertEquals(200, MathUtils.round(polygon.getY(1))); Assert.assertEquals(10, MathUtils.round(polygon.getX(2))); Assert.assertEquals(210, MathUtils.round(polygon.getY(2))); Assert.assertEquals(0, MathUtils.round(polygon.getX(3))); Assert.assertEquals(210, MathUtils.round(polygon.getY(3))); }
TiledMap { public int getTileHeight() { return tiledMapData.getTileHeight(); } 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 testGetTileHeight() { Assert.assertEquals(32, tiledMap.getTileHeight()); for (int i = 0; i < tiledMap.getTilesets().size; i++) { Assert.assertEquals(32, tiledMap.getTilesets().get(i).getTileHeight()); } }
Polygon extends Shape { @Override public void setCenter(float x, float y) { float centerX = getCenterX(); float centerY = getCenterY(); if(x == centerX && y == centerY) { return; } translate(x - centerX, y - centerY); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSetCenter() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 10f), new Point(10f, 10f), new Point(10f, 20f), new Point(0f, 20f) }); Assert.assertEquals(5f, polygon.getCenterX(), 0.01f); Assert.assertEquals(15f, polygon.getCenterY(), 0.01f); polygon.setCenter(10f, 20f); Assert.assertEquals(10f, polygon.getCenterX(), 0.01f); Assert.assertEquals(20f, polygon.getCenterY(), 0.01f); }
Polygon extends Shape { @Override public void translate(float translateX, float translateY) { if(MathUtils.isZero(translateX) && MathUtils.isZero(translateY)) { return; } for (int i = 0; i < vertices.length; i += 2) { vertices[i] += translateX; vertices[i + 1] += translateY; } setDirty(); notifyPositionChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testTranslate() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); polygon.translate(10f, 0f); Assert.assertEquals(10f, polygon.getX(0), 0.01f); Assert.assertEquals(0f, polygon.getY(0), 0.01f); Assert.assertEquals(20f, polygon.getX(1), 0.01f); Assert.assertEquals(0f, polygon.getY(1), 0.01f); Assert.assertEquals(20f, polygon.getX(2), 0.01f); Assert.assertEquals(10f, polygon.getY(2), 0.01f); Assert.assertEquals(10f, polygon.getX(3), 0.01f); Assert.assertEquals(10f, polygon.getY(3), 0.01f); Assert.assertEquals(20f, polygon.getMaxX(), 0.01f); Assert.assertEquals(10f, polygon.getMaxY(), 0.01f); }
Polygon extends Shape { @Override public boolean contains(float x, float y) { if (isRectangle) { return triangleContains(x, y, vertices[0], vertices[1], vertices[2], vertices[3], vertices[6], vertices[7]) || triangleContains(x, y, vertices[6], vertices[7], vertices[2], vertices[3], vertices[4], vertices[5]); } int intersects = 0; for (int i = 0; i < vertices.length; i += 2) { float x1 = vertices[i]; float y1 = vertices[i + 1]; float x2 = vertices[(i + 2) % vertices.length]; float y2 = vertices[(i + 3) % vertices.length]; if (((y1 <= y && y < y2) || (y2 <= y && y < y1)) && x < ((x2 - x1) / (y2 - y1) * (y - y1) + x1)) intersects++; } return (intersects & 1) == 1; } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testContainsPoint() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 5f), new Point(5f, 10f), new Point(-10f, 5f), new Point(-5f, 10f) }); Assert.assertEquals(true, polygon.contains(0f, 5f)); Assert.assertEquals(false, polygon.contains(15f, 5f)); Assert.assertEquals(true, polygon.contains(new Vector2(0f, 5f))); Assert.assertEquals(false, polygon.contains(new Vector2(15f, 5f))); polygon = new Polygon(new Point [] { new Point(100f, 100f), new Point(150f, 100f), new Point(150f, 150f), new Point(100f, 150f) }); Assert.assertEquals(true, polygon.contains(125f, 125f)); } @Test public void testContainsPolygon() { Polygon polygon = new Polygon(new Point [] { new Point(100f, 100f), new Point(150f, 100f), new Point(150f, 150f), new Point(100f, 150f) }); Polygon containedPolygon = new Polygon(new Point [] { new Point(125f, 125f), new Point(130f, 125f), new Point(130f, 130f), new Point(125f, 130f) }); Polygon nonContainedPolygon = new Polygon(new Point [] { new Point(200f, 200f), new Point(250f, 200f), new Point(250f, 250f), new Point(200f, 250f) }); Assert.assertEquals(true, polygon.contains(containedPolygon)); Assert.assertEquals(false, polygon.contains(nonContainedPolygon)); }
Polygon extends Shape { @Override public void setRadius(float radius) { final Vector2 tmpVector1 = TMP_VECTOR1.get(); tmpVector1.set(vertices[0], vertices[1]); scale(radius / tmpVector1.dst(getCenterX(), getCenterY())); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testSetRadius() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); polygon.setRadius(10f); Assert.assertEquals(-7.07f, polygon.getX(), 0.1f); Assert.assertEquals(-7.07f, polygon.getY(), 0.1f); Assert.assertEquals(17.07f, polygon.getMaxX(), 0.1f); Assert.assertEquals(17.07f, polygon.getMaxY(), 0.1f); }
Polygon extends Shape { @Override public void scale(float scale) { if(!isEquilateral()) { Mdx.log.error(LOGGING_TAG, "Cannot set radius on non-equilateral Polygon"); return; } for(int i = 0; i < vertices.length; i += 2) { final Vector2 tmpVector1 = TMP_VECTOR1.get(); tmpVector1.set(vertices[i], vertices[i + 1]); tmpVector1.sub(getCenterX(), getCenterY()); tmpVector1.scl(scale); tmpVector1.add(vertices[i], vertices[i + 1]); vertices[i] = tmpVector1.x; vertices[i + 1] = tmpVector1.y; } setDirty(); notifySizeChangeListeners(); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testScale() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); polygon.scale(2f); Assert.assertEquals(-10f, polygon.getX(), 0.1f); Assert.assertEquals(-10f, polygon.getY(), 0.1f); Assert.assertEquals(20f, polygon.getMaxX(), 0.1f); Assert.assertEquals(20f, polygon.getMaxY(), 0.1f); }
Polygon extends Shape { @Override public boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB) { return Intersector.intersectSegmentPolygon(pointA, pointB, vertices); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testIntersectsLineSegment() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); LineSegment intersectingLineSegment = new LineSegment(5f, -5f, 5f, 15f); LineSegment nonIntersectingLineSegment = new LineSegment(100f, 100f, 200f, 200f); Assert.assertEquals(true, polygon.intersects(intersectingLineSegment)); Assert.assertEquals(false, polygon.intersects(nonIntersectingLineSegment)); }
Polygon extends Shape { @Override public boolean intersects(Sizeable shape) { if (shape.isCircle()) { return intersects((Circle) shape); } return intersects(shape.getPolygon()); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testIntersectsRectangle() { Polygon polygon = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); Rectangle intersectingRectangle = new Rectangle(-5f, -5f, 10f, 10f); Rectangle onLineIntersectingRectangle = new Rectangle(-5f, -5f, 10f, 5f); Rectangle nonIntersectingRectangle = new Rectangle(100f, 100f, 10f, 10f); Assert.assertEquals(true, polygon.intersects(intersectingRectangle)); Assert.assertEquals(true, polygon.intersects(onLineIntersectingRectangle)); Assert.assertEquals(false, polygon.intersects(nonIntersectingRectangle)); }
Polygon extends Shape { @Override public EdgeIterator edgeIterator() { return edgeIterator; } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testEdgeIterator() { Point [] points = new Point [] { new Point(0f, 0f), new Point(10f, 5f), new Point(5f, 10f), new Point(-10f, 5f), new Point(-5f, 10f), }; Polygon polygon = new Polygon(points); EdgeIterator iterator = polygon.edgeIterator(); iterator.begin(); for(int i = 0; i < points.length; i++) { iterator.next(); if(i < points.length - 1) { Assert.assertEquals(points[i].x, iterator.getPointAX(), 0.01f); Assert.assertEquals(points[i].y, iterator.getPointAY(), 0.01f); Assert.assertEquals(points[i + 1].x, iterator.getPointBX(), 0.01f); Assert.assertEquals(points[i + 1].y, iterator.getPointBY(), 0.01f); } else { Assert.assertEquals(points[i].x, iterator.getPointAX(), 0.01f); Assert.assertEquals(points[i].y, iterator.getPointAY(), 0.01f); Assert.assertEquals(points[0].x, iterator.getPointBX(), 0.01f); Assert.assertEquals(points[0].y, iterator.getPointBY(), 0.01f); } } iterator.end(); }
Polygon extends Shape { @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; if (getClass() != obj.getClass()) return false; Polygon other = (Polygon) obj; if (!Arrays.equals(vertices, other.vertices)) return false; return true; } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testEquals() { Polygon polygon1 = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); Polygon polygon2 = new Polygon(new Point [] { new Point(0f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); Assert.assertEquals(true, polygon1.equals(polygon2)); polygon2 = new Polygon(new Point [] { new Point(0.00001f, 0f), new Point(10f, 0f), new Point(10f, 10f), new Point(0f, 10f) }); Assert.assertEquals(false, polygon1.equals(polygon2)); }
TiledMap { public Array<Tileset> getTilesets() { return tiledMapData.getTilesets(); } 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 testGetTilesets() { Assert.assertEquals(1, tiledMap.getTilesets().size); }
Polygon extends Shape { @Override public void dispose() { if(disposed) { return; } disposed = true; clearPositionChangeListeners(); clearSizeChangeListeners(); if(geometry == null) { vertices = null; triangles = null; return; } geometry.release(this); } Polygon(Geometry geometry, float[] vertices); Polygon(float[] vertices); Polygon(Vector2[] points); @Override void dispose(); boolean isSameAs(Polygon polygon); Polygon lerp(Polygon target, float alpha); void lerp(Polygon result, Polygon target, float alpha); static void lerp(Polygon result, Polygon from, Polygon target, float alpha); @Override Shape copy(); @Override boolean contains(float x, float y); @Override boolean contains(Vector2 vector2); @Override boolean contains(Sizeable shape); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); boolean intersects(Polygon polygon); boolean intersects(Triangle triangle); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); @Override boolean intersects(LineSegment lineSegment); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); @Override float getDistanceTo(float x, float y); void addPoint(float x, float y); void addPoint(Vector2 point); void removePoint(float x, float y); void removePoint(Vector2 point); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); float[] getVertices(); void setVertices(float[] vertices); void setVertices(Vector2[] vertices); @Override float getRotation(); @Override void setRotation(float degrees); @Override void rotate(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override float getX(); @Override float getY(); float getX(int index); float getY(int index); @Override float getCenterX(); @Override 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(); ShortArray getTriangles(); @Override void setX(float x); @Override void setY(float y); @Override void setXY(float x, float y); @Override void setRadius(float radius); @Override void scale(float scale); void set(Polygon polygon); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); boolean isEquilateral(); boolean isEquilateral(float tolerance); boolean isRectangle(); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }
@Test public void testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); Polygon polygon1 = geometry.polygon(); org.junit.Assert.assertEquals(0, geometry.getTotalPolygonsAvailable()); polygon1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalPolygonsAvailable()); polygon1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalPolygonsAvailable()); polygon1 = geometry.polygon(); org.junit.Assert.assertEquals(0, geometry.getTotalPolygonsAvailable()); polygon1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalPolygonsAvailable()); }
RegularPentagon extends RegularPolygon { @Override public void dispose() { if(disposed) { return; } disposed = true; clearPositionChangeListeners(); clearSizeChangeListeners(); if(geometry == null) { return; } geometry.release(this); } RegularPentagon(float centerX, float centerY, float radius); RegularPentagon(Geometry geometry); @Override void dispose(); static final float ROTATION_SYMMETRY; }
@Test public void testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularPentagonsAvailable()); RegularPentagon pentagon = geometry.regularPentagon(); org.junit.Assert.assertEquals(0, geometry.getTotalRegularPentagonsAvailable()); pentagon.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularPentagonsAvailable()); pentagon.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularPentagonsAvailable()); pentagon = geometry.regularPentagon(); org.junit.Assert.assertEquals(0, geometry.getTotalRegularPentagonsAvailable()); pentagon.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalRegularPentagonsAvailable()); }
Point extends Vector2 implements Positionable, Disposable { public boolean equals(Vector2 v) { return x == v.x && y == v.y; } Point(Geometry geometry); Point(); Point(float x, float y); Point(Point point); void dispose(); void setDisposed(boolean disposed); float getDistanceTo(float x, float y); @Override float getDistanceTo(Positionable positionable); @Override void moveTowards(float x, float y, float speed); @Override void moveTowards(Positionable positionable, float speed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); void rotateAround(Point center, float degrees); void rotateAround(float centerX, float centerY, float degrees); boolean isOnLineBetween(Point a, Point b); boolean equals(Vector2 v); boolean equals(Vector2 v, float delta); boolean equals(float x, float y, float delta); float getX(); float getY(); void setX(float x); void setY(float y); @Override void setXY(float x, float y); @Override Vector2 set(float x, float y); @Override Vector2 add(float x, float y); @Override Vector2 sub(float x, float y); @Override Vector2 mul(Matrix3 mat); @Override Vector2 mulAdd(Vector2 vec, float scalar); @Override Vector2 mulAdd(Vector2 vec, Vector2 mulVec); @Override Vector2 scl(Vector2 v); @Override Vector2 scl(float scalar); @Override Vector2 scl(float x, float y); @Override Vector2 set(Vector2 v); @Override Vector2 add(Vector2 v); @Override Vector2 sub(Vector2 v); Point copy(); }
@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)); }
Point extends Vector2 implements Positionable, Disposable { public void rotateAround(Point center, float degrees) { rotateAround(center.x, center.y, degrees); } Point(Geometry geometry); Point(); Point(float x, float y); Point(Point point); void dispose(); void setDisposed(boolean disposed); float getDistanceTo(float x, float y); @Override float getDistanceTo(Positionable positionable); @Override void moveTowards(float x, float y, float speed); @Override void moveTowards(Positionable positionable, float speed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); void rotateAround(Point center, float degrees); void rotateAround(float centerX, float centerY, float degrees); boolean isOnLineBetween(Point a, Point b); boolean equals(Vector2 v); boolean equals(Vector2 v, float delta); boolean equals(float x, float y, float delta); float getX(); float getY(); void setX(float x); void setY(float y); @Override void setXY(float x, float y); @Override Vector2 set(float x, float y); @Override Vector2 add(float x, float y); @Override Vector2 sub(float x, float y); @Override Vector2 mul(Matrix3 mat); @Override Vector2 mulAdd(Vector2 vec, float scalar); @Override Vector2 mulAdd(Vector2 vec, Vector2 mulVec); @Override Vector2 scl(Vector2 v); @Override Vector2 scl(float scalar); @Override Vector2 scl(float x, float y); @Override Vector2 set(Vector2 v); @Override Vector2 add(Vector2 v); @Override Vector2 sub(Vector2 v); Point copy(); }
@Test public void testRotateAround() { point1.set(0, 0); point2.set(10, 0); point2.rotateAround(point1, 90f); Assert.assertEquals(10f, point2.getY(), 0.001f); point1.set(10, 0); point2.set(20, 0); point2.rotateAround(point1, 90f); Assert.assertEquals(10f, point2.getY(), 0.001f); }
Point extends Vector2 implements Positionable, Disposable { public void dispose() { if(disposed) { return; } disposed = true; clearPositionChangeListeners(); if(geometry == null) { return; } geometry.release(this); } Point(Geometry geometry); Point(); Point(float x, float y); Point(Point point); void dispose(); void setDisposed(boolean disposed); float getDistanceTo(float x, float y); @Override float getDistanceTo(Positionable positionable); @Override void moveTowards(float x, float y, float speed); @Override void moveTowards(Positionable positionable, float speed); @Override void addPostionChangeListener( PositionChangeListener<T> listener); @Override void removePositionChangeListener( PositionChangeListener<T> listener); void rotateAround(Point center, float degrees); void rotateAround(float centerX, float centerY, float degrees); boolean isOnLineBetween(Point a, Point b); boolean equals(Vector2 v); boolean equals(Vector2 v, float delta); boolean equals(float x, float y, float delta); float getX(); float getY(); void setX(float x); void setY(float y); @Override void setXY(float x, float y); @Override Vector2 set(float x, float y); @Override Vector2 add(float x, float y); @Override Vector2 sub(float x, float y); @Override Vector2 mul(Matrix3 mat); @Override Vector2 mulAdd(Vector2 vec, float scalar); @Override Vector2 mulAdd(Vector2 vec, Vector2 mulVec); @Override Vector2 scl(Vector2 v); @Override Vector2 scl(float scalar); @Override Vector2 scl(float x, float y); @Override Vector2 set(Vector2 v); @Override Vector2 add(Vector2 v); @Override Vector2 sub(Vector2 v); Point copy(); }
@Test public void testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); org.junit.Assert.assertEquals(1, geometry.getTotalPointsAvailable()); point1 = geometry.point(); org.junit.Assert.assertEquals(0, geometry.getTotalPointsAvailable()); point1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalPointsAvailable()); point1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalPointsAvailable()); point1 = geometry.point(); org.junit.Assert.assertEquals(0, geometry.getTotalPointsAvailable()); point1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalPointsAvailable()); }
Circle extends Shape { @Override public boolean contains(Vector2 point) { return contains(point.x, point.y); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testContains() { for (float x = -5f; x <= 5f; x += 0.1f) { for (float y = -5f; y <= 5f; y += 0.1f) { Assert.assertEquals(circle1.getDistanceFromCenter(x, y) <= circle1.getRadius(), circle1.contains(x, y)); } } } @Test public void testContainsShape() { Shape shape = new Circle(2f); Assert.assertEquals(true, circle1.contains(shape)); shape = new Rectangle(0f,0f,1f,1f); Assert.assertEquals(true, circle1.contains(shape)); shape = new Rectangle(0f,0f,3f,3f); Assert.assertEquals(false, circle1.contains(shape)); shape = new Triangle(new Vector2(0f, 4f), new Vector2(-4f,0f), new Vector2(4f,0f)); Assert.assertEquals(true,circle1.contains(shape)); shape = new Triangle(new Vector2(0f, 5f), new Vector2(-4f,0f), new Vector2(4f,0f)); Assert.assertEquals(false,circle1.contains(shape)); } @Test public void testContainsRectangle() { Rectangle rectangle = new Rectangle(0f,0f,1f,1f); Assert.assertEquals(true, circle1.contains(rectangle)); rectangle = new Rectangle(0f,0f,3f,3f); Assert.assertEquals(false, circle1.contains(rectangle)); }
Circle extends Shape { @Override public void setCenter(float x, float y) { setXY(x, y); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetCenter() { circle1.setXY(20f, 25f); Assert.assertEquals(20f, circle1.getX(), 0f); Assert.assertEquals(25f, circle1.getY(), 0f); }
Circle extends Shape { @Override public void setX(float x) { setCenterX(x); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetX() { circle1.setX(25f); Assert.assertEquals(25f, circle1.getX(), 0f); Assert.assertEquals(0f, circle1.getY(), 0f); }
Circle extends Shape { @Override public void setY(float y) { setCenterY(y); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testSetY() { circle1.setY(25f); Assert.assertEquals(0f, circle1.getX(), 0f); Assert.assertEquals(25f, circle1.getY(), 0f); }
TiledMap { public TileLayer getTileLayer(String name) { return tiledMapData.getTileLayer(name); } 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 testGetTileLayers() { Assert.assertEquals(true, tiledMap.getTileLayer("Ground") != null); Assert.assertEquals(0, tiledMap.getTileLayer("Ground").getIndex()); Assert.assertEquals(true, tiledMap.getTileLayer("Collisions") != null); Assert.assertEquals(1, tiledMap.getTileLayer("Collisions").getIndex()); Assert.assertEquals(true, tiledMap.getTileLayer("Higher") != null); Assert.assertEquals(4, tiledMap.getTileLayer("Higher").getIndex()); }
Circle extends Shape { @Override public boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB) { final Vector2 centerTmp = CENTER_TMP.get(); centerTmp.set(circle.x, circle.y); return org.mini2Dx.gdx.math.Intersector.intersectSegmentCircle(pointA, pointB, centerTmp, circle.radius * circle.radius); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testIntersectLineSegmentsXY() { Assert.assertEquals(true, circle1.intersectsLineSegment(0f,0f,5f,5f)); Assert.assertEquals(false, circle1.intersectsLineSegment(-5f,5f,5f,5f)); } @Test public void testIntersectLineSegmentsVectors() { Vector2 point1 = new Vector2(0f, 0f); Vector2 point2 = new Vector2(5f, 5f); Assert.assertEquals(true, circle1.intersectsLineSegment(point1, point2)); point1 = new Vector2(-5f,5f); point2 = new Vector2(5f, 5f); Assert.assertEquals(false, circle1.intersectsLineSegment(point1, point2)); }
Circle extends Shape { public Rectangle getBoundingBox() { computeBoundingBox(); return boundingBox; } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testGetBoundingBox() { Rectangle boundingBox = circle1.getBoundingBox(); Assert.assertEquals(-4f, boundingBox.getX(), 0f); Assert.assertEquals(-4f, boundingBox.getY(), 0f); Assert.assertEquals(8f, boundingBox.getWidth(), 0f); Assert.assertEquals(8f, boundingBox.getHeight(), 0f); }
Circle extends Shape { @Override public void translate(float translateX, float translateY) { if(MathUtils.isZero(translateX) && MathUtils.isZero(translateY)) { return; } circle.x += translateX; circle.y += translateY; setDirty(); notifyPositionChangeListeners(); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testTranslate() { circle1.translate(1f,-1f); Assert.assertEquals(1f,circle1.getCenterX(), 0f); Assert.assertEquals(-1f,circle1.getCenterY(), 0f); }
Circle extends Shape { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Circle other = (Circle) obj; if (Float.floatToIntBits(getX()) != Float.floatToIntBits(other.getX())) return false; if (Float.floatToIntBits(getY()) != Float.floatToIntBits(other.getY())) return false; if (Float.floatToIntBits(getRadius()) != Float.floatToIntBits(other.getRadius())) return false; return true; } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testEquals() { circle1 = new Circle(4); circle2 = new Circle(4); Assert.assertEquals(true, circle1.equals(circle2)); circle1 = new Circle(1, 1, 4); circle2 = new Circle(1, 1, 4); Assert.assertEquals(true, circle1.equals(circle2)); circle1 = new Circle(4); circle2 = new Circle(4.00001f); Assert.assertEquals(false, circle1.equals(circle2)); }
Circle extends Shape { @Override public void dispose() { if(disposed) { return; } disposed = true; clearPositionChangeListeners(); clearSizeChangeListeners(); if(geometry == null) { return; } geometry.release(this); } Circle(Geometry geometry); Circle(float radius); Circle(float centerX, float centerY, float radius); Circle(Circle circle); @Override void dispose(); @Override Shape copy(); Circle lerp(Circle target, float alpha); void lerp(Circle result, Circle target, float alpha); static void lerp(Circle result, Circle from, Circle target, float alpha); @Override boolean contains(Vector2 point); @Override boolean contains(float x, float y); @Override boolean contains(Sizeable shape); boolean contains(Circle circle); boolean contains(Rectangle rectangle); boolean contains(Polygon polygon); @Override boolean intersects(Sizeable shape); @Override boolean intersectsLineSegment(Vector2 pointA, Vector2 pointB); @Override boolean intersectsLineSegment(float x1, float y1, float x2, float y2); @Override float getWidth(); @Override float getHeight(); boolean intersects(Rectangle rectangle); boolean intersects(Circle circle); float getDistanceTo(float x, float y); float getDistanceFromCenter(Vector2 point); float getDistanceFromCenter(float x, float y); @Override int getNumberOfSides(); @Override void draw(Graphics g); @Override void fill(Graphics g); void set(Circle circle); @Override float getX(); @Override float getY(); @Override void setX(float x); @Override void setY(float y); @Override float getCenterX(); @Override float getCenterY(); @Override void setCenter(float x, float y); @Override void setCenterX(float x); @Override void setCenterY(float y); @Override void setXY(float x, float y); @Override float getMinX(); @Override float getMinY(); @Override float getMaxX(); @Override float getMaxY(); float getRadius(); void setRadius(float radius); @Override void scale(float scale); @Override void translate(float translateX, float translateY); @Override EdgeIterator edgeIterator(); Rectangle getBoundingBox(); @Override float getRotation(); @Override void setRotation(float degrees); @Override void setRotationAround(float centerX, float centerY, float degrees); @Override void rotate(float degrees); @Override void rotateAround(float centerX, float centerY, float degrees); @Override boolean isCircle(); @Override Polygon getPolygon(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void testDispose() { Geometry.DEFAULT_POOL_SIZE = 1; Geometry geometry = new Geometry(); org.junit.Assert.assertEquals(1, geometry.getTotalCirclesAvailable()); circle1 = geometry.circle(); org.junit.Assert.assertEquals(0, geometry.getTotalCirclesAvailable()); circle1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalCirclesAvailable()); circle1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalCirclesAvailable()); circle1 = geometry.circle(); org.junit.Assert.assertEquals(0, geometry.getTotalCirclesAvailable()); circle1.dispose(); org.junit.Assert.assertEquals(1, geometry.getTotalCirclesAvailable()); }
RenderingEntitySystem extends EntitySystem implements RenderingSystem { protected abstract void render(int entityId, Graphics g); RenderingEntitySystem(Builder aspect); @Override void renderSystem(Graphics g); @Override void setWorld(World world); }
@Test public void testRenderMatchesEntities() { Entity entityWithComponent = world.createEntity(); entityWithComponent.edit().add(new DummyComponent()); Entity entityWithoutComponent = world.createEntity(); world.process(); world.render(graphics); Assert.assertEquals(true, renderedIds.contains(entityWithComponent.getId())); Assert.assertEquals(false, renderedIds.contains(entityWithoutComponent.getId())); } @Test public void testRenderPassesGraphicsInstance() { Entity entityWithComponent = world.createEntity(); entityWithComponent.edit().add(new DummyComponent()); world.process(); world.render(graphics); } @Test public void testRenderDoesNothingIfCalledBeforeFirstProcess() { Entity entityWithComponent = world.createEntity(); entityWithComponent.edit().add(new DummyComponent()); world.render(graphics); }
TiledMap { public Iterable<TiledObjectGroup> getObjectGroups() { return tiledMapData.getObjectGroups(); } 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 testGetObjectGroups() { Assert.assertEquals(2, tiledMap.getTotalObjectGroups()); TiledObjectGroup group = tiledMap.getObjectGroup("Objects"); Assert.assertEquals("Objects", group.getName()); Assert.assertEquals(3, group.getObjects().size); for (int i = 0; i < group.getObjects().size; i++) { TiledObject obj = group.getObjects().get(i); switch (obj.getName()) { case "test1": Assert.assertEquals(true, obj.containsProperty("testProperty")); Assert.assertEquals("SUCCESS", obj.getProperty("testProperty")); Assert.assertEquals(32f, obj.getX(), 0f); Assert.assertEquals(64f, obj.getY(), 0f); Assert.assertEquals(16f, obj.getWidth(), 0f); Assert.assertEquals(24f, obj.getHeight(), 0f); break; case "test2": Assert.assertEquals(true, obj.containsProperty("testProperty")); Assert.assertEquals("SUCCESS2", obj.getProperty("testProperty")); Assert.assertEquals(260f, obj.getX(), 0f); Assert.assertEquals(192f, obj.getY(), 0f); Assert.assertEquals(24f, obj.getWidth(), 0f); Assert.assertEquals(16f, obj.getHeight(), 0f); break; case "flipped_tile_object": Assert.assertEquals(288f, obj.getX(), 0f); Assert.assertEquals(96f, obj.getY(), 0f); Assert.assertEquals(32f, obj.getWidth(), 0f); Assert.assertEquals(32f, obj.getHeight(), 0f); Assert.assertEquals(156, obj.getGid()); Assert.assertEquals(false, obj.isGidFlipDiagonally()); Assert.assertEquals(true, obj.isGidFlipHorizontally()); Assert.assertEquals(true, obj.isGidFlipVertically()); break; } } }
TiledCollisionMapper { public static byte[][] mapCollisionsByLayer(TiledMap tiledMap, String layerName) { return mapCollisionsByLayer(tiledMap, tiledMap.getLayerIndex(layerName)); } TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger, TileMergeMode mergeMode); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, String layerName); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, int layerIndex); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, TileLayer layer); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, String layerName); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName, String objectType); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName, String objectType); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); }
@Test public void testMapCollisionsByLayer() { int collisionLayerIndex = tiledMap.getLayerIndex("Collisions"); QuadTree<CollisionBox> quadTree = new PointQuadTree<CollisionBox>(8, 0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); Rectangle area = new Rectangle(0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); collisionBoxMapper.mapCollisionsByLayer(quadTree, tiledMap, collisionLayerIndex); Array<CollisionBox> collisions = quadTree.getElementsWithinArea(area); Assert.assertEquals(7, collisions.size); assertCollisionAt(6, 3, quadTree, tiledMap); assertCollisionAt(5, 4, quadTree, tiledMap); assertCollisionAt(6, 4, quadTree, tiledMap); assertCollisionAt(1, 5, quadTree, tiledMap); assertCollisionAt(2, 5, quadTree, tiledMap); assertCollisionAt(1, 6, quadTree, tiledMap); assertCollisionAt(2, 6, quadTree, tiledMap); } @Test public void testMapCollisionsByNonExistingLayer() { Array<CollisionBox> result = new Array<CollisionBox>(); collisionBoxMapper.mapCollisionsByLayer(result, tiledMap, "NonExistingLayer"); Assert.assertEquals(0, result.size); } @Test public void testMapCollisionsByLayerIndexToByteArray() { int collisionLayerIndex = tiledMap.getLayerIndex("Collisions"); byte[][] result = TiledCollisionMapper.mapCollisionsByLayer(tiledMap, collisionLayerIndex); byte[][] expected = new byte[][] { new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0 }, new byte[] { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; for (int x = 0; x < tiledMap.getWidth(); x++) { for (int y = 0; y < tiledMap.getHeight(); y++) { if (expected[y][x] != result[x][y]) { Assert.fail(x + "," + y + " expected: " + expected[x][y] + ", actual: " + result[x][y]); } } } } @Test public void testMapCollisionsByLayerNameToByteArray() { int collisionLayerIndex = tiledMap.getLayerIndex("Collisions"); byte[][] result = TiledCollisionMapper.mapCollisionsByLayer(tiledMap, collisionLayerIndex); byte[][] expected = new byte[][] { new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0 }, new byte[] { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 }, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }; for (int x = 0; x < tiledMap.getWidth(); x++) { for (int y = 0; y < tiledMap.getHeight(); y++) { if (expected[y][x] != result[x][y]) { Assert.fail(x + "," + y + " expected: " + expected[x][y] + ", actual: " + result[x][y]); } } } }
TiledCollisionMapper { public void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName) { TiledObjectGroup objectGroup = tiledMap.getObjectGroup(groupName); if (objectGroup == null) { return; } for (TiledObject tiledObject : objectGroup.getObjects()) { T collision = collisionFactory.createCollision(tiledMap, tiledObject); if (collision == null) { continue; } quadTree.add(collision); } } TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger, TileMergeMode mergeMode); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, String layerName); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, int layerIndex); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, TileLayer layer); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, String layerName); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName, String objectType); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName, String objectType); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); }
@Test public void testMapCollisionsByNonExistantObjectGroup() { Array<CollisionBox> result = new Array<CollisionBox>(); collisionBoxMapper.mapCollisionsByObjectGroup(result, tiledMap, "NonExistingObjectGroup"); Assert.assertEquals(0, result.size); } @Test public void testMapCollisionsByObjectGroup() { QuadTree<CollisionBox> quadTree = new PointQuadTree<CollisionBox>(8, 0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); collisionBoxMapper.mapCollisionsByObjectGroup(quadTree, tiledMap, "Objects"); Rectangle area = new Rectangle(0f, 0f, tiledMap.getPixelWidth(), tiledMap.getPixelHeight()); Array<CollisionBox> collisions = quadTree.getElementsWithinArea(area); Assert.assertEquals(3, collisions.size); Assert.assertEquals(288f, collisions.get(0).getX()); Assert.assertEquals(96f, collisions.get(0).getY()); Assert.assertEquals(32f, collisions.get(0).getWidth()); Assert.assertEquals(32f, collisions.get(0).getHeight()); } @Test public void testMapCollisionsByObjectGroupAndType() { QuadTree<CollisionBox> quadTree = new PointQuadTree<CollisionBox>(8, 0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); collisionBoxMapper.mapCollisionsByObjectGroup(quadTree, tiledMap, "Objects", "expected"); Rectangle area = new Rectangle(0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); Array<CollisionBox> collisions = quadTree.getElementsWithinArea(area); Assert.assertEquals(1, collisions.size); Assert.assertEquals(32f, collisions.get(0).getX()); Assert.assertEquals(64f, collisions.get(0).getY()); Assert.assertEquals(16f, collisions.get(0).getWidth()); Assert.assertEquals(24f, collisions.get(0).getHeight()); }
TiledCollisionMapper { public void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName) { mapAndMergeCollisionsByLayer(quadTree, tiledMap, tiledMap.getLayerIndex(layerName)); } TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger, TileMergeMode mergeMode); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, String layerName); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, int layerIndex); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, TileLayer layer); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, String layerName); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName, String objectType); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName, String objectType); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); }
@Test public void testMapAndMergeCollisionsByLayer() { int collisionLayerIndex = tiledMap.getLayerIndex("Collisions"); RegionQuadTree<CollisionBox> quadTree = new RegionQuadTree<CollisionBox>(8, 0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); collisionBoxMapper.mapAndMergeCollisionsByLayer(quadTree, tiledMap, collisionLayerIndex); Array<CollisionBox> collisions = quadTree.getElementsWithinArea(quadTree); Assert.assertEquals(4, collisions.size); CollisionBox collision = getCollisionAt(1, 5, quadTree, tiledMap); Assert.assertEquals(tiledMap.getTileWidth() * 2f, collision.getWidth()); Assert.assertEquals(tiledMap.getTileHeight() * 2f, collision.getHeight()); collision = getCollisionAt(5, 4, quadTree, tiledMap); Assert.assertEquals(tiledMap.getTileWidth() * 1f, collision.getWidth()); Assert.assertEquals(tiledMap.getTileHeight() * 1f, collision.getHeight()); collision = getCollisionAt(6, 3, quadTree, tiledMap); Assert.assertEquals(tiledMap.getTileWidth() * 1f, collision.getWidth()); Assert.assertEquals(tiledMap.getTileHeight() * 1f, collision.getHeight()); }
TiledCollisionMapper { public static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, String layerName) { return mapEmptySpacesByLayer(tiledMap, tiledMap.getLayerIndex(layerName)); } TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger, TileMergeMode mergeMode); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, String layerName); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, int layerIndex); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, TileLayer layer); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, String layerName); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName, String objectType); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName, String objectType); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); }
@Test public void testMapEmptySpacesByLayerIndexToByteArray() { int collisionLayerIndex = tiledMap.getLayerIndex("Collisions"); byte[][] result = TiledCollisionMapper.mapEmptySpacesByLayer(tiledMap, collisionLayerIndex); byte[][] expected = new byte[][] { new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, new byte[] { 1, 1, 1, 1, 1, 1, 0, 1, 1, 1 }, new byte[] { 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 }, new byte[] { 1, 0, 0, 1, 1, 1, 1, 1, 1, 1 }, new byte[] { 1, 0, 0, 1, 1, 1, 1, 1, 1, 1 }, new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } }; for (int x = 0; x < tiledMap.getWidth(); x++) { for (int y = 0; y < tiledMap.getHeight(); y++) { if (expected[y][x] != result[x][y]) { Assert.fail(x + "," + y + " expected: " + expected[x][y] + ", actual: " + result[x][y]); } } } }
TiledCollisionMapper { public void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName) { mapAndMergeEmptySpacesByLayer(quadTree, tiledMap, tiledMap.getLayerIndex(layerName)); } TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger); TiledCollisionMapper(TiledCollisionFactory<T> collisionFactory, TiledCollisionMerger collisionMerger, TileMergeMode mergeMode); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, String layerName); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, int layerIndex); static byte[][] mapCollisionsByLayer(TiledMap tiledMap, TileLayer layer); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, String layerName); static byte[][] mapEmptySpacesByLayer(TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(QuadTree<T> quadTree, TiledMap tiledMap, String groupName, String objectType); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName); void mapCollisionsByObjectGroup(Array<T> results, TiledMap tiledMap, String groupName, String objectType); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(QuadTree<T> quadTree, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeCollisionsByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, String layerName); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, int layerIndex); void mapAndMergeEmptySpacesByLayer(Array<T> results, TiledMap tiledMap, final int layerIndex, final int maxColumns, final int maxRows); }
@Test public void testMapAndMergeEmptySpacesByLayer() { int collisionLayerIndex = tiledMap.getLayerIndex("Collisions"); RegionQuadTree<CollisionBox> quadTree = new RegionQuadTree<CollisionBox>(8, 0f, 0f, tiledMap.getWidth() * tiledMap.getTileWidth(), tiledMap.getHeight() * tiledMap.getTileHeight()); collisionBoxMapper = new TiledCollisionMapper<>(new TiledCollisionBoxFactory(), new AllCollisionMerger()); collisionBoxMapper.mapAndMergeEmptySpacesByLayer(quadTree, tiledMap, collisionLayerIndex); Array<CollisionBox> collisions = quadTree.getElementsWithinArea(quadTree); Assert.assertEquals(19, collisions.size); }
UiXmlLoader { public <T extends UiElement> T load(String filename) { try { Reader reader = fileHandleResolver.resolve(filename).reader(); XmlReader xmlReader = new XmlReader(); XmlReader.Element root = xmlReader.parse(reader); return (T) processXmlTag(root); } catch (Exception e) { throw new MdxException("Failed to load UI file: " + filename, e); } } UiXmlLoader(FileHandleResolver fileHandleResolver); void addTagHandler(String tagName, UiElementFactory factory, UiElementPopulator... populators); T load(String filename); T load(String filename, Class<T> model); T load(String filename, T model); }
@Test public void fail_to_parse_file_contents() { String badFileFormat = "{\"hello\": \"world\"}"; FileHandle fileHandle = mockery.mock(FileHandle.class); mockery.checking(new Expectations() { { oneOf(fileHandleResolver).resolve(filename); try { oneOf(fileHandle).reader(); will(returnValue(new StringReader(badFileFormat))); } catch (IOException e) { throw new RuntimeException(e); } } }); try { loader.load(filename); fail(); } catch (Exception e) { assertEquals("Failed to load UI file: " + filename, e.getMessage()); assertNotNull(e.getCause()); } } @Test public void fail_to_resolve_file() { RuntimeException realError = new RuntimeException("BOOM"); mockery.checking(new Expectations() { { oneOf(fileHandleResolver).resolve(filename); will(throwException(realError)); } }); try { loader.load(filename); fail(); } catch (Exception e) { assertEquals("Failed to load UI file: " + filename, e.getMessage()); assertSame(e.getCause(), realError); } }
XmlTagUtil { public static String getTagNameWithoutPrefix(XmlReader.Element element) { return element.getName().replaceAll("(.*?:)?(.+?)", "$2"); } static String getTagNameWithoutPrefix(XmlReader.Element element); }
@Test public void with_prefix() { XmlReader.Element element = new XmlReader.Element("ui:text", null); assertEquals("text", getTagNameWithoutPrefix(element)); } @Test public void no_prefix() { XmlReader.Element element = new XmlReader.Element("text", null); assertEquals("text", getTagNameWithoutPrefix(element)); }
Tileset implements Disposable { public int getTileX(int tileId) { return tilesetSource.getTileX(tileId, firstGid); } 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 testGetTileX() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(0, tileset.getTileX(1)); Assert.assertEquals(0, tileset.getTileX(5)); tileset = new Tileset(28, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(0, tileset.getTileX(28)); Assert.assertEquals(0, tileset.getTileX(32)); } @Test public void testGetTileXWithSpacing() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(0, tileset.getTileX(1)); Assert.assertEquals(0, tileset.getTileX(4)); Assert.assertEquals(1, tileset.getTileX(5)); tileset = new Tileset(28, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(0, tileset.getTileX(28)); Assert.assertEquals(0, tileset.getTileX(31)); Assert.assertEquals(1, tileset.getTileX(32)); tileset = new Tileset(1, new ImageTilesetSource(1936, 1052, 32, 32, 2, 0)); Assert.assertEquals(0, tileset.getTileX(343)); Assert.assertEquals(2, tileset.getTileX(345)); Assert.assertEquals(5, tileset.getTileX(234)); } @Test public void testGetTileXWithMargin() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 4)); Assert.assertEquals(0, tileset.getTileX(1)); Assert.assertEquals(0, tileset.getTileX(4)); Assert.assertEquals(1, tileset.getTileX(5)); tileset = new Tileset(28, new ImageTilesetSource(128, 128, 32, 32, 0, 4)); Assert.assertEquals(0, tileset.getTileX(28)); Assert.assertEquals(0, tileset.getTileX(31)); Assert.assertEquals(1, tileset.getTileX(32)); }
XmlAttributeMapper { public static Visibility mapToVisibility(XmlReader.Element element, String attributeName) { String providedValue = element.getAttribute(attributeName, "VISIBLE"); try { return Visibility.valueOf(providedValue.toUpperCase()); } catch (IllegalArgumentException e) { throw new InvalidVisibilityException(element, providedValue); } } static FlexDirection mapToFlexDirection(XmlReader.Element element); static Visibility mapToVisibility(XmlReader.Element element, String attributeName); }
@Test public void mapToVisibility_unknown_visibility() { tag.setAttribute("visibility", "does-not-exist"); try { XmlAttributeMapper.mapToVisibility(tag, "visibility"); fail(); } catch (InvalidVisibilityException e) { assertTrue(e.getMessage().startsWith("tag-name has an invalid value: does-not-exist")); } }
XmlAttributeMapper { public static FlexDirection mapToFlexDirection(XmlReader.Element element) { String value = element.getAttribute("flex-direction"); try { return FlexDirection.valueOf(value.toUpperCase()); } catch (IllegalArgumentException e) { throw new InvalidFlexDirectionException(element, value); } } static FlexDirection mapToFlexDirection(XmlReader.Element element); static Visibility mapToVisibility(XmlReader.Element element, String attributeName); }
@Test public void mapToFlexDirection_unsupported_flex_direction() { tag.setAttribute("flex-direction", "does-not-exist"); try { mapToFlexDirection(tag); fail(); } catch (InvalidFlexDirectionException e) { assertTrue(e.getMessage().startsWith("tag-name has an invalid value: does-not-exist")); } } @Test public void mapToFlexDirection_flex_directions_case_insensitive() { tag.setAttribute("flex-direction", "ColUmn"); assertEquals(COLUMN, mapToFlexDirection(tag)); } @Test public void mapToFlexDirection_all_directions() { for (FlexDirection value : values()) { tag.setAttribute("flex-direction", value.name()); assertEquals(value, mapToFlexDirection(tag)); } }
LabelPopulator implements UiElementPopulator<Label> { @Override public boolean populate(XmlReader.Element xmlTag, Label uiElement) { if (xmlTag.hasAttribute("text")) { uiElement.setText(xmlTag.getAttribute("text")); } uiElement.setResponsive(xmlTag.getBoolean("responsive", false)); String providedHorizontalAlignment = xmlTag.get("horizontal-alignment", "LEFT").toUpperCase(); uiElement.setHorizontalAlignment(HorizontalAlignment.valueOf(providedHorizontalAlignment)); return false; } @Override boolean populate(XmlReader.Element xmlTag, Label uiElement); }
@Test public void responsive_is_provided() { xmlTag.setAttribute("responsive", "true"); populator.populate(xmlTag, label); assertTrue(label.isResponsive()); } @Test public void responsive_is_defaulted_to_false() { populator.populate(xmlTag, label); assertFalse(label.isResponsive()); } @Test public void horizontal_alignment_case_does_not_matter() { xmlTag.setAttribute("horizontal-alignment", "center"); populator.populate(xmlTag, label); assertEquals(CENTER, label.getHorizontalAlignment()); } @Test public void horizontal_alignment_CENTER() { xmlTag.setAttribute("horizontal-alignment", "CENTER"); populator.populate(xmlTag, label); assertEquals(CENTER, label.getHorizontalAlignment()); } @Test public void horizontal_alignment_RIGHT() { xmlTag.setAttribute("horizontal-alignment", "RIGHT"); populator.populate(xmlTag, label); assertEquals(RIGHT, label.getHorizontalAlignment()); } @Test public void default_horizontal_alignment() { populator.populate(xmlTag, label); assertEquals(LEFT, label.getHorizontalAlignment()); } @Test public void text_provided() { xmlTag.setAttribute("text", "hello"); populator.populate(xmlTag, label); assertEquals("hello", label.getText()); } @Test public void no_text_provided() { populator.populate(xmlTag, label); assertEquals("", label.getText()); }
GridUiNavigation implements UiNavigation { public Actionable get(int x, int y) { return navigation.get(getIndex(x, y)); } GridUiNavigation(int xsColumns); @Override void layout(ScreenSize screenSize); @Override void add(Actionable actionable); @Override void remove(Actionable actionable); @Override void removeAll(); @Override void set(int index, Actionable actionable); Actionable get(int x, int y); void set(int x, int y, Actionable actionable); @Override Actionable navigate(int keycode); @Override Actionable getCursor(); @Override Actionable resetCursor(); @Override Actionable resetCursor(boolean triggerHoverEvent); void setWidth(ScreenSize screenSize, int columns); int getTotalColumns(); int getTotalRows(); @Override String toString(); @Override void onHoverBegin(Hoverable source); @Override void onHoverEnd(Hoverable source); }
@Test public void testSetXY() { addElementsToGrid(); for(int x = 0; x < COLUMNS; x++) { for(int y = 0; y < ROWS; y++) { Assert.assertEquals(elements[x][y], navigation.get(x, y)); } } }
GridUiNavigation implements UiNavigation { @Override public Actionable navigate(int keycode) { if (navigation.size == 0) { return null; } switch (keycode) { case Keys.W: case Keys.UP: if (cursorY > 0) { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); cursorY--; } break; case Keys.S: case Keys.DOWN: if (getIndex(cursorX, cursorY + 1) >= navigation.size){ navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); }else if (cursorY < getTotalRows() - 1) { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); cursorY++; } else { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); cursorY = getTotalRows() - 1; } break; case Keys.A: case Keys.LEFT: if (cursorX > 0) { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); cursorX--; } break; case Keys.D: case Keys.RIGHT: if (getIndex(cursorX + 1, cursorY) >= navigation.size) { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); }else if (cursorX < columns - 1) { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); cursorX++; } else { navigation.get(getIndex(cursorX, cursorY)).invokeEndHover(); cursorX = columns - 1; } break; } return navigation.get(getIndex(cursorX, cursorY)); } GridUiNavigation(int xsColumns); @Override void layout(ScreenSize screenSize); @Override void add(Actionable actionable); @Override void remove(Actionable actionable); @Override void removeAll(); @Override void set(int index, Actionable actionable); Actionable get(int x, int y); void set(int x, int y, Actionable actionable); @Override Actionable navigate(int keycode); @Override Actionable getCursor(); @Override Actionable resetCursor(); @Override Actionable resetCursor(boolean triggerHoverEvent); void setWidth(ScreenSize screenSize, int columns); int getTotalColumns(); int getTotalRows(); @Override String toString(); @Override void onHoverBegin(Hoverable source); @Override void onHoverEnd(Hoverable source); }
@Test public void testNavigate() { addElementsToGrid(); Actionable lastActionable = null; for(int x = 0; x <= COLUMNS; x++) { lastActionable = navigation.navigate(Keys.RIGHT); } Assert.assertEquals(elements[2][0], lastActionable); for(int y = 0; y <= ROWS; y++) { lastActionable = navigation.navigate(Keys.DOWN); } Assert.assertEquals(elements[2][2], lastActionable); for(int x = 0; x <= COLUMNS; x++) { lastActionable = navigation.navigate(Keys.LEFT); } Assert.assertEquals(elements[0][2], lastActionable); for(int y = 0; y <= ROWS; y++) { lastActionable = navigation.navigate(Keys.UP); } Assert.assertEquals(elements[0][0], lastActionable); }
PowerOfTwo { public static int nextPowerOfTwo(int value) { return MathUtils.nextPowerOfTwo(value); } static int nextPowerOfTwo(int value); static int previousPowerOfTwo(int value); }
@Test public void testNextPowerOfTwo() { for(int power = 1; power < 16; power++) { for(int i = (int) Math.pow(2, power) + 1; i <= (int) Math.pow(2, power); i++) { Assert.assertEquals((int) Math.pow(2, power), PowerOfTwo.nextPowerOfTwo(i)); } } }
PowerOfTwo { public static int previousPowerOfTwo(int value) { final int power = (int)(Math.log(value) / Math.log(2)); return (int) Math.pow(2, power); } static int nextPowerOfTwo(int value); static int previousPowerOfTwo(int value); }
@Test public void testPreviousPowerOfTwo() { for(int power = 16; power > 0; power--) { for(int i = (int) Math.pow(2, power) - 1; i >= (int) Math.pow(2, power - 1); i--) { Assert.assertEquals((int) Math.pow(2, power - 1), PowerOfTwo.previousPowerOfTwo(i)); } } Assert.assertEquals(1, PowerOfTwo.previousPowerOfTwo(1)); }
BooleanQueue { public boolean removeLast () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final boolean[] values = this.values; int tail = this.tail; tail--; if (tail == -1) { tail = values.length - 1; } final boolean result = values[tail]; this.tail = tail; size--; return result; } BooleanQueue(); BooleanQueue(int initialSize); void addLast(boolean object); void addFirst(boolean object); void ensureCapacity(int additional); boolean removeFirst(); boolean removeLast(); int indexOf(boolean value); boolean removeValue(boolean value); boolean removeIndex(int index); boolean notEmpty(); boolean isEmpty(); boolean first(); boolean last(); boolean get(int index); void clear(); Iterator<Boolean> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeLastTest() { BooleanQueue queue = new BooleanQueue(); queue.addLast(true); queue.addLast(false); queue.addLast(true); queue.addLast(false); assertEquals(4, queue.size); assertFalse(queue.removeLast()); assertEquals(3, queue.size); assertTrue(queue.removeLast()); assertEquals(2, queue.size); assertFalse(queue.removeLast()); assertEquals(1, queue.size); assertTrue(queue.removeLast()); assertEquals(0, queue.size); }
BooleanQueue { public boolean removeFirst () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final boolean[] values = this.values; final boolean result = values[head]; head++; if (head == values.length) { head = 0; } size--; return result; } BooleanQueue(); BooleanQueue(int initialSize); void addLast(boolean object); void addFirst(boolean object); void ensureCapacity(int additional); boolean removeFirst(); boolean removeLast(); int indexOf(boolean value); boolean removeValue(boolean value); boolean removeIndex(int index); boolean notEmpty(); boolean isEmpty(); boolean first(); boolean last(); boolean get(int index); void clear(); Iterator<Boolean> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeFirstTest() { BooleanQueue queue = new BooleanQueue(); queue.addLast(false); queue.addLast(true); queue.addLast(false); queue.addLast(true); assertEquals(4, queue.size); assertFalse(queue.removeFirst()); assertEquals(3, queue.size); assertTrue(queue.removeFirst()); assertEquals(2, queue.size); assertFalse(queue.removeFirst()); assertEquals(1, queue.size); assertTrue(queue.removeFirst()); assertEquals(0, queue.size); }
BooleanQueue { public boolean 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 boolean[] values = this.values; int i = head + index; if (i >= values.length) { i -= values.length; } return values[i]; } BooleanQueue(); BooleanQueue(int initialSize); void addLast(boolean object); void addFirst(boolean object); void ensureCapacity(int additional); boolean removeFirst(); boolean removeLast(); int indexOf(boolean value); boolean removeValue(boolean value); boolean removeIndex(int index); boolean notEmpty(); boolean isEmpty(); boolean first(); boolean last(); boolean get(int index); void clear(); Iterator<Boolean> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void getTest () { final BooleanQueue q = new BooleanQueue(7); for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { q.addLast(j % 2 == 0); } 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 % 2 == 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()); } q.removeFirst(); assert q.size == 0; try { q.get(0); fail("get() on empty queue did not throw"); } catch (IndexOutOfBoundsException ignore) { } } }
BooleanQueue { public int indexOf (boolean value) { if (size == 0) return -1; boolean[] 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; } BooleanQueue(); BooleanQueue(int initialSize); void addLast(boolean object); void addFirst(boolean object); void ensureCapacity(int additional); boolean removeFirst(); boolean removeLast(); int indexOf(boolean value); boolean removeValue(boolean value); boolean removeIndex(int index); boolean notEmpty(); boolean isEmpty(); boolean first(); boolean last(); boolean get(int index); void clear(); Iterator<Boolean> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void indexOfTest () { final BooleanQueue q = new BooleanQueue(); for (int j = 0; j <= 6; j++) q.addLast(j % 2 == 0); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf(j % 2 == 0), j % 2); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst(j % 2 == 0); for (int j = 3; j <= 6; j++) q.addLast(j % 2 == 0); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf(j % 2 == 0), j % 2); }
BooleanQueue { public Iterator<Boolean> iterator () { if (iterable == null) iterable = new BooleanQueueIterable(this); return iterable.iterator(); } BooleanQueue(); BooleanQueue(int initialSize); void addLast(boolean object); void addFirst(boolean object); void ensureCapacity(int additional); boolean removeFirst(); boolean removeLast(); int indexOf(boolean value); boolean removeValue(boolean value); boolean removeIndex(int index); boolean notEmpty(); boolean isEmpty(); boolean first(); boolean last(); boolean get(int index); void clear(); Iterator<Boolean> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void iteratorTest () { final BooleanQueue q = new BooleanQueue(); for (int j = 0; j <= 6; j++) q.addLast(j % 2 == 0); Iterator<Boolean> iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next(), j % 2 == 0); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, false, true, false, true, false, true); iter.next(); iter.remove(); assertValues(q, true, false, true, false, true); iter.next(); iter.next(); iter.remove(); assertValues(q, true, true, false, true); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, true, true, false); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst(j % 2 == 0); for (int j = 3; j <= 6; j++) q.addLast(j % 2 == 0); iter = q.iterator(); for (int j = 0; j <= 6; j++) assertEquals(iter.next(), j % 2 == 0); iter = q.iterator(); iter.next(); iter.remove(); assertValues(q, false, true, false, true, false, true); iter.next(); iter.remove(); assertValues(q, true, false, true, false, true); iter.next(); iter.next(); iter.remove(); assertValues(q, true, true, false, true); iter.next(); iter.next(); iter.next(); iter.remove(); assertValues(q, true, true, false); }
BooleanQueue { public String toString () { if (size == 0) { return "[]"; } final boolean[] 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(); } BooleanQueue(); BooleanQueue(int initialSize); void addLast(boolean object); void addFirst(boolean object); void ensureCapacity(int additional); boolean removeFirst(); boolean removeLast(); int indexOf(boolean value); boolean removeValue(boolean value); boolean removeIndex(int index); boolean notEmpty(); boolean isEmpty(); boolean first(); boolean last(); boolean get(int index); void clear(); Iterator<Boolean> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void toStringTest () { BooleanQueue q = new BooleanQueue(1); assertEquals("[]", q.toString()); q.addLast(true); assertEquals("[true]", q.toString()); q.addLast(false); q.addLast(false); q.addLast(true); assertEquals("[true, false, false, true]", q.toString()); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public V put (byte key, V value) { if (key == 0) { V oldValue = zeroValue; zeroValue = value; if (!hasZeroValue) { hasZeroValue = true; size++; } return oldValue; } byte[] keyTable = this.keyTable; int index1 = (int)(key & mask); byte key1 = keyTable[index1]; if (key1 == key) { V oldValue = valueTable[index1]; valueTable[index1] = value; return oldValue; } int index2 = hash2(key); byte key2 = keyTable[index2]; if (key2 == key) { V oldValue = valueTable[index2]; valueTable[index2] = value; return oldValue; } int index3 = hash3(key); byte key3 = keyTable[index3]; if (key3 == key) { V oldValue = valueTable[index3]; valueTable[index3] = value; return oldValue; } for (int i = capacity, n = i + stashSize; i < n; i++) { if (keyTable[i] == key) { V oldValue = valueTable[i]; valueTable[i] = value; return oldValue; } } if (key1 == EMPTY) { keyTable[index1] = key; valueTable[index1] = value; if (size++ >= threshold) resize(capacity << 1); return null; } if (key2 == EMPTY) { keyTable[index2] = key; valueTable[index2] = value; if (size++ >= threshold) resize(capacity << 1); return null; } if (key3 == EMPTY) { keyTable[index3] = key; valueTable[index3] = value; if (size++ >= threshold) resize(capacity << 1); return null; } push(key, value, index1, key1, index2, key2, index3, key3); return null; } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testAdd(){ Assert.assertEquals(0, byteMap.size); byteMap.put((byte) 123, "Example123"); Assert.assertEquals(1, byteMap.size); byteMap.put((byte) 34, "Example34"); Assert.assertEquals(2, byteMap.size); byteMap.put((byte) 0, "Example0"); Assert.assertEquals(3, byteMap.size); Assert.assertEquals("Example123", byteMap.put((byte) 123, "NewExample123")); Assert.assertEquals(3, byteMap.size); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public V get (byte key) { return get(key, null); } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testGet(){ testAdd(); Assert.assertNull(byteMap.get((byte) 100)); Assert.assertEquals("Example0", byteMap.get((byte) 0)); Assert.assertEquals("NewExample123", byteMap.get((byte) 123)); Assert.assertEquals("Example34", byteMap.get((byte) 34)); Assert.assertEquals("Example34", byteMap.get((byte) 34, "DefaultValue")); Assert.assertEquals("DefaultValue", byteMap.get((byte) 56, "DefaultValue")); Assert.assertEquals(3, byteMap.size); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public V remove (byte key) { if (key == 0) { if (!hasZeroValue) return null; V oldValue = zeroValue; zeroValue = null; hasZeroValue = false; size--; return oldValue; } int index = (int)(key & mask); if (keyTable[index] == key) { keyTable[index] = EMPTY; V oldValue = valueTable[index]; valueTable[index] = null; size--; return oldValue; } index = hash2(key); if (keyTable[index] == key) { keyTable[index] = EMPTY; V oldValue = valueTable[index]; valueTable[index] = null; size--; return oldValue; } index = hash3(key); if (keyTable[index] == key) { keyTable[index] = EMPTY; V oldValue = valueTable[index]; valueTable[index] = null; size--; return oldValue; } return removeStash(key); } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testRemove(){ testAdd(); Assert.assertNull(byteMap.remove((byte) 100)); Assert.assertEquals("NewExample123", byteMap.remove((byte) 123)); Assert.assertEquals(2, byteMap.size); Assert.assertEquals("Example34", byteMap.remove((byte) 34)); Assert.assertEquals(1, byteMap.size); Assert.assertEquals("Example0", byteMap.remove((byte) 0)); Assert.assertEquals(0, byteMap.size); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public void clear (int maximumCapacity) { if (capacity <= maximumCapacity) { clear(); return; } zeroValue = null; hasZeroValue = false; size = 0; resize(maximumCapacity); } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testClear(){ testAdd(); byteMap.clear(); Assert.assertEquals(0, byteMap.size); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public boolean containsKey (byte key) { if (key == 0) return hasZeroValue; int index = (int)(key & mask); if (keyTable[index] != key) { index = hash2(key); if (keyTable[index] != key) { index = hash3(key); if (keyTable[index] != key) return containsKeyStash(key); } } return true; } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testContainsKey(){ Assert.assertFalse(byteMap.containsKey((byte) 0)); Assert.assertFalse(byteMap.containsKey((byte) 34)); Assert.assertFalse(byteMap.containsKey((byte) 123)); Assert.assertFalse(byteMap.containsKey((byte) 127)); testAdd(); Assert.assertTrue(byteMap.containsKey((byte) 0)); Assert.assertTrue(byteMap.containsKey((byte) 34)); Assert.assertTrue(byteMap.containsKey((byte) 123)); Assert.assertFalse(byteMap.containsKey((byte) 127)); byteMap.clear(); Assert.assertFalse(byteMap.containsKey((byte) 0)); Assert.assertFalse(byteMap.containsKey((byte) 34)); Assert.assertFalse(byteMap.containsKey((byte) 123)); Assert.assertFalse(byteMap.containsKey((byte) 127)); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public boolean containsValue (Object value, boolean identity) { V[] valueTable = this.valueTable; if (value == null) { if (hasZeroValue && zeroValue == null) return true; byte[] keyTable = this.keyTable; for (int i = capacity + stashSize; i-- > 0;) if (keyTable[i] != EMPTY && valueTable[i] == null) return true; } else if (identity) { if (value == zeroValue) return true; for (int i = capacity + stashSize; i-- > 0;) if (valueTable[i] == value) return true; } else { if (hasZeroValue && value.equals(zeroValue)) return true; for (int i = capacity + stashSize; i-- > 0;) if (value.equals(valueTable[i])) return true; } return false; } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testContainsValue(){ Assert.assertFalse(byteMap.containsValue("Example0", false)); Assert.assertFalse(byteMap.containsValue("Example34", false)); Assert.assertFalse(byteMap.containsValue("NewExample123", false)); Assert.assertFalse(byteMap.containsValue("ThisValueShouldNotBePresent", false)); testAdd(); Assert.assertTrue(byteMap.containsValue("Example0", false)); Assert.assertTrue(byteMap.containsValue("Example34", false)); Assert.assertTrue(byteMap.containsValue("NewExample123", false)); Assert.assertFalse(byteMap.containsValue("ThisValueShouldNotBePresent", false)); byteMap.clear(); Assert.assertFalse(byteMap.containsValue("Example0", false)); Assert.assertFalse(byteMap.containsValue("Example34", false)); Assert.assertFalse(byteMap.containsValue("NewExample123", false)); Assert.assertFalse(byteMap.containsValue("ThisValueShouldNotBePresent", false)); }
ByteMap implements Iterable<ByteMap.Entry<V>> { public byte findKey (Object value, boolean identity, byte notFound) { V[] valueTable = this.valueTable; if (value == null) { if (hasZeroValue && zeroValue == null) return 0; byte[] keyTable = this.keyTable; for (int i = capacity + stashSize; i-- > 0;) if (keyTable[i] != EMPTY && valueTable[i] == null) return keyTable[i]; } else if (identity) { if (value == zeroValue) return 0; for (int i = capacity + stashSize; i-- > 0;) if (valueTable[i] == value) return keyTable[i]; } else { if (hasZeroValue && value.equals(zeroValue)) return 0; for (int i = capacity + stashSize; i-- > 0;) if (value.equals(valueTable[i])) return keyTable[i]; } return notFound; } ByteMap(); ByteMap(int initialCapacity); ByteMap(int initialCapacity, float loadFactor); ByteMap(ByteMap<? extends V> map); V put(byte key, V value); void putAll(ByteMap<V> map); V get(byte key); V get(byte key, V defaultValue); V remove(byte key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(byte key); byte findKey(Object value, boolean identity, byte notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testFindKey(){ Assert.assertEquals(127, byteMap.findKey("Example0", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("Example34", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("NewExample123", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("ThisValueShouldNotBePresent", false, (byte) 127)); testAdd(); Assert.assertEquals(0, byteMap.findKey("Example0", false, (byte) 127)); Assert.assertEquals(34, byteMap.findKey("Example34", false, (byte) 127)); Assert.assertEquals(123, byteMap.findKey("NewExample123", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("ThisValueShouldNotBePresent", false, (byte) 127)); byteMap.clear(); Assert.assertEquals(127, byteMap.findKey("Example0", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("Example34", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("NewExample123", false, (byte) 127)); Assert.assertEquals(127, byteMap.findKey("ThisValueShouldNotBePresent", false, (byte) 127)); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public V put (short key, V value) { if (key == 0) { V oldValue = zeroValue; zeroValue = value; if (!hasZeroValue) { hasZeroValue = true; size++; } return oldValue; } short[] keyTable = this.keyTable; int index1 = (int)(key & mask); short key1 = keyTable[index1]; if (key1 == key) { V oldValue = valueTable[index1]; valueTable[index1] = value; return oldValue; } int index2 = hash2(key); short key2 = keyTable[index2]; if (key2 == key) { V oldValue = valueTable[index2]; valueTable[index2] = value; return oldValue; } int index3 = hash3(key); short key3 = keyTable[index3]; if (key3 == key) { V oldValue = valueTable[index3]; valueTable[index3] = value; return oldValue; } for (int i = capacity, n = i + stashSize; i < n; i++) { if (keyTable[i] == key) { V oldValue = valueTable[i]; valueTable[i] = value; return oldValue; } } if (key1 == EMPTY) { keyTable[index1] = key; valueTable[index1] = value; if (size++ >= threshold) resize(capacity << 1); return null; } if (key2 == EMPTY) { keyTable[index2] = key; valueTable[index2] = value; if (size++ >= threshold) resize(capacity << 1); return null; } if (key3 == EMPTY) { keyTable[index3] = key; valueTable[index3] = value; if (size++ >= threshold) resize(capacity << 1); return null; } push(key, value, index1, key1, index2, key2, index3, key3); return null; } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testAdd(){ Assert.assertEquals(0, shortMap.size); shortMap.put((short) 123, "Example123"); Assert.assertEquals(1, shortMap.size); shortMap.put((short) 34, "Example34"); Assert.assertEquals(2, shortMap.size); shortMap.put((short) 0, "Example0"); Assert.assertEquals(3, shortMap.size); Assert.assertEquals("Example123", shortMap.put((short) 123, "NewExample123")); Assert.assertEquals(3, shortMap.size); }
Tileset implements Disposable { public int getTileY(int tileId) { return tilesetSource.getTileY(tileId, firstGid); } 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 testGetTileY() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(0, tileset.getTileY(1)); Assert.assertEquals(1, tileset.getTileY(5)); tileset = new Tileset(28, new ImageTilesetSource(128, 128, 32, 32, 0, 0)); Assert.assertEquals(0, tileset.getTileY(28)); Assert.assertEquals(1, tileset.getTileY(32)); } @Test public void testGetTileYWithSpacing() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(0, tileset.getTileY(1)); Assert.assertEquals(1, tileset.getTileY(5)); tileset = new Tileset(28, new ImageTilesetSource(128, 128, 32, 32, 4, 0)); Assert.assertEquals(0, tileset.getTileY(28)); Assert.assertEquals(1, tileset.getTileY(32)); tileset = new Tileset(1, new ImageTilesetSource(1936, 1052, 32, 32, 2, 0)); Assert.assertEquals(6, tileset.getTileY(345)); Assert.assertEquals(4, tileset.getTileY(234)); } @Test public void testGetTileYWithMargin() { tileset = new Tileset(1, new ImageTilesetSource(128, 128, 32, 32, 0, 4)); Assert.assertEquals(0, tileset.getTileY(1)); Assert.assertEquals(1, tileset.getTileY(5)); tileset = new Tileset(28, new ImageTilesetSource(128, 128, 32, 32, 0, 4)); Assert.assertEquals(0, tileset.getTileY(28)); Assert.assertEquals(1, tileset.getTileY(32)); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public V get (short key) { return get(key, null); } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testGet(){ testAdd(); Assert.assertNull(shortMap.get((short) 100)); Assert.assertEquals("Example0", shortMap.get((short) 0)); Assert.assertEquals("NewExample123", shortMap.get((short) 123)); Assert.assertEquals("Example34", shortMap.get((short) 34)); Assert.assertEquals("Example34", shortMap.get((short) 34, "DefaultValue")); Assert.assertEquals("DefaultValue", shortMap.get((short) 56, "DefaultValue")); Assert.assertEquals(3, shortMap.size); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public V remove (short key) { if (key == 0) { if (!hasZeroValue) return null; V oldValue = zeroValue; zeroValue = null; hasZeroValue = false; size--; return oldValue; } int index = (int)(key & mask); if (keyTable[index] == key) { keyTable[index] = EMPTY; V oldValue = valueTable[index]; valueTable[index] = null; size--; return oldValue; } index = hash2(key); if (keyTable[index] == key) { keyTable[index] = EMPTY; V oldValue = valueTable[index]; valueTable[index] = null; size--; return oldValue; } index = hash3(key); if (keyTable[index] == key) { keyTable[index] = EMPTY; V oldValue = valueTable[index]; valueTable[index] = null; size--; return oldValue; } return removeStash(key); } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testRemove(){ testAdd(); Assert.assertNull(shortMap.remove((short) 100)); Assert.assertEquals("NewExample123", shortMap.remove((short) 123)); Assert.assertEquals(2, shortMap.size); Assert.assertEquals("Example34", shortMap.remove((short) 34)); Assert.assertEquals(1, shortMap.size); Assert.assertEquals("Example0", shortMap.remove((short) 0)); Assert.assertEquals(0, shortMap.size); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public void clear (int maximumCapacity) { if (capacity <= maximumCapacity) { clear(); return; } zeroValue = null; hasZeroValue = false; size = 0; resize(maximumCapacity); } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testClear(){ testAdd(); shortMap.clear(); Assert.assertEquals(0, shortMap.size); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public boolean containsKey (short key) { if (key == 0) return hasZeroValue; int index = (int)(key & mask); if (keyTable[index] != key) { index = hash2(key); if (keyTable[index] != key) { index = hash3(key); if (keyTable[index] != key) return containsKeyStash(key); } } return true; } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testContainsKey(){ Assert.assertFalse(shortMap.containsKey((short) 0)); Assert.assertFalse(shortMap.containsKey((short) 34)); Assert.assertFalse(shortMap.containsKey((short) 123)); Assert.assertFalse(shortMap.containsKey((short) 200)); testAdd(); Assert.assertTrue(shortMap.containsKey((short) 0)); Assert.assertTrue(shortMap.containsKey((short) 34)); Assert.assertTrue(shortMap.containsKey((short) 123)); Assert.assertFalse(shortMap.containsKey((short) 200)); shortMap.clear(); Assert.assertFalse(shortMap.containsKey((short) 0)); Assert.assertFalse(shortMap.containsKey((short) 34)); Assert.assertFalse(shortMap.containsKey((short) 123)); Assert.assertFalse(shortMap.containsKey((short) 200)); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public boolean containsValue (Object value, boolean identity) { V[] valueTable = this.valueTable; if (value == null) { if (hasZeroValue && zeroValue == null) return true; short[] keyTable = this.keyTable; for (int i = capacity + stashSize; i-- > 0;) if (keyTable[i] != EMPTY && valueTable[i] == null) return true; } else if (identity) { if (value == zeroValue) return true; for (int i = capacity + stashSize; i-- > 0;) if (valueTable[i] == value) return true; } else { if (hasZeroValue && value.equals(zeroValue)) return true; for (int i = capacity + stashSize; i-- > 0;) if (value.equals(valueTable[i])) return true; } return false; } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testContainsValue(){ Assert.assertFalse(shortMap.containsValue("Example0", false)); Assert.assertFalse(shortMap.containsValue("Example34", false)); Assert.assertFalse(shortMap.containsValue("NewExample123", false)); Assert.assertFalse(shortMap.containsValue("ThisValueShouldNotBePresent", false)); testAdd(); Assert.assertTrue(shortMap.containsValue("Example0", false)); Assert.assertTrue(shortMap.containsValue("Example34", false)); Assert.assertTrue(shortMap.containsValue("NewExample123", false)); Assert.assertFalse(shortMap.containsValue("ThisValueShouldNotBePresent", false)); shortMap.clear(); Assert.assertFalse(shortMap.containsKey((short) 0)); Assert.assertFalse(shortMap.containsKey((short) 34)); Assert.assertFalse(shortMap.containsKey((short) 123)); Assert.assertFalse(shortMap.containsKey((short) 200)); }
ShortMap implements Iterable<ShortMap.Entry<V>> { public short findKey (Object value, boolean identity, short notFound) { V[] valueTable = this.valueTable; if (value == null) { if (hasZeroValue && zeroValue == null) return 0; short[] keyTable = this.keyTable; for (int i = capacity + stashSize; i-- > 0;) if (keyTable[i] != EMPTY && valueTable[i] == null) return keyTable[i]; } else if (identity) { if (value == zeroValue) return 0; for (int i = capacity + stashSize; i-- > 0;) if (valueTable[i] == value) return keyTable[i]; } else { if (hasZeroValue && value.equals(zeroValue)) return 0; for (int i = capacity + stashSize; i-- > 0;) if (value.equals(valueTable[i])) return keyTable[i]; } return notFound; } ShortMap(); ShortMap(int initialCapacity); ShortMap(int initialCapacity, float loadFactor); ShortMap(ShortMap<? extends V> map); V put(short key, V value); void putAll(ShortMap<V> map); V get(short key); V get(short key, V defaultValue); V remove(short key); void shrink(int maximumCapacity); void clear(int maximumCapacity); void clear(); boolean containsValue(Object value, boolean identity); boolean containsKey(short key); short findKey(Object value, boolean identity, short notFound); void ensureCapacity(int additionalCapacity); int hashCode(); boolean equals(Object obj); String toString(); Iterator<Entry<V>> iterator(); Entries<V> entries(); Values<V> values(); Keys keys(); public int size; }
@Test public void testFindKey(){ Assert.assertEquals(256, shortMap.findKey("Example0", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("Example34", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("NewExample123", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("ThisValueShouldNotBePresent", false, (short) 256)); testAdd(); Assert.assertEquals(0, shortMap.findKey("Example0", false, (short) 256)); Assert.assertEquals(34, shortMap.findKey("Example34", false, (short) 256)); Assert.assertEquals(123, shortMap.findKey("NewExample123", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("ThisValueShouldNotBePresent", false, (short) 256)); shortMap.clear(); Assert.assertEquals(256, shortMap.findKey("Example0", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("Example34", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("NewExample123", false, (short) 256)); Assert.assertEquals(256, shortMap.findKey("ThisValueShouldNotBePresent", false, (short) 256)); }
LongQueue { public long removeLast () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final long[] values = this.values; int tail = this.tail; tail--; if (tail == -1) { tail = values.length - 1; } final long result = values[tail]; this.tail = tail; size--; return result; } LongQueue(); LongQueue(int initialSize); void addLast(long object); void addFirst(long object); void ensureCapacity(int additional); long removeFirst(); long removeLast(); int indexOf(long value); boolean removeValue(long value); long removeIndex(int index); boolean notEmpty(); boolean isEmpty(); long first(); long last(); long get(int index); void clear(); Iterator<Long> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeLastTest() { LongQueue queue = new LongQueue(); queue.addLast(1); queue.addLast(2); queue.addLast(3); queue.addLast(4); assertEquals(4, queue.size); assertEquals(3, queue.indexOf(4)); assertEquals(4, queue.removeLast()); assertEquals(3, queue.size); assertEquals(2, queue.indexOf(3)); assertEquals(3, queue.removeLast()); assertEquals(2, queue.size); assertEquals(1, queue.indexOf(2)); assertEquals(2, queue.removeLast()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf(1)); assertEquals(1, queue.removeLast()); assertEquals(0, queue.size); }
LongQueue { public long removeFirst () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final long[] values = this.values; final long result = values[head]; head++; if (head == values.length) { head = 0; } size--; return result; } LongQueue(); LongQueue(int initialSize); void addLast(long object); void addFirst(long object); void ensureCapacity(int additional); long removeFirst(); long removeLast(); int indexOf(long value); boolean removeValue(long value); long removeIndex(int index); boolean notEmpty(); boolean isEmpty(); long first(); long last(); long get(int index); void clear(); Iterator<Long> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeFirstTest() { LongQueue queue = new LongQueue(); queue.addLast(1); queue.addLast(2); queue.addLast(3); queue.addLast(4); assertEquals(4, queue.size); assertEquals(0, queue.indexOf(1)); assertEquals(1, queue.removeFirst()); assertEquals(3, queue.size); assertEquals(0, queue.indexOf(2)); assertEquals(2, queue.removeFirst()); assertEquals(2, queue.size); assertEquals(0, queue.indexOf(3)); assertEquals(3, queue.removeFirst()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf(4)); assertEquals(4, queue.removeFirst()); assertEquals(0, queue.size); }
LongQueue { public long 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 long[] values = this.values; int i = head + index; if (i >= values.length) { i -= values.length; } return values[i]; } LongQueue(); LongQueue(int initialSize); void addLast(long object); void addFirst(long object); void ensureCapacity(int additional); long removeFirst(); long removeLast(); int indexOf(long value); boolean removeValue(long value); long removeIndex(int index); boolean notEmpty(); boolean isEmpty(); long first(); long last(); long get(int index); void clear(); Iterator<Long> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void getTest () { final LongQueue q = new LongQueue(7); for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { q.addLast(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) { } } }
LongQueue { public int indexOf (long value) { if (size == 0) return -1; long[] 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; } LongQueue(); LongQueue(int initialSize); void addLast(long object); void addFirst(long object); void ensureCapacity(int additional); long removeFirst(); long removeLast(); int indexOf(long value); boolean removeValue(long value); long removeIndex(int index); boolean notEmpty(); boolean isEmpty(); long first(); long last(); long get(int index); void clear(); Iterator<Long> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void indexOfTest () { final LongQueue q = new LongQueue(); for (int j = 0; j <= 6; j++) q.addLast(j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf(j), j); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst(j); for (int j = 3; j <= 6; j++) q.addLast(j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf(j), j); }
LongQueue { public Iterator<Long> iterator () { if (iterable == null) iterable = new LongQueueIterable(this); return iterable.iterator(); } LongQueue(); LongQueue(int initialSize); void addLast(long object); void addFirst(long object); void ensureCapacity(int additional); long removeFirst(); long removeLast(); int indexOf(long value); boolean removeValue(long value); long removeIndex(int index); boolean notEmpty(); boolean isEmpty(); long first(); long last(); long get(int index); void clear(); Iterator<Long> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void iteratorTest () { final LongQueue q = new LongQueue(); for (int j = 0; j <= 6; j++) q.addLast(j); Iterator<Long> 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(j); for (int j = 3; j <= 6; j++) q.addLast(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); }
LongQueue { public String toString () { if (size == 0) { return "[]"; } final long[] 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(); } LongQueue(); LongQueue(int initialSize); void addLast(long object); void addFirst(long object); void ensureCapacity(int additional); long removeFirst(); long removeLast(); int indexOf(long value); boolean removeValue(long value); long removeIndex(int index); boolean notEmpty(); boolean isEmpty(); long first(); long last(); long get(int index); void clear(); Iterator<Long> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void toStringTest () { LongQueue q = new LongQueue(1); assertEquals("[]", q.toString()); q.addLast(4); assertEquals("[4]", q.toString()); q.addLast(5); q.addLast(6); q.addLast(7); assertEquals("[4, 5, 6, 7]", q.toString()); }
ShortQueue { public short removeLast () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final short[] values = this.values; int tail = this.tail; tail--; if (tail == -1) { tail = values.length - 1; } final short result = values[tail]; this.tail = tail; size--; return result; } ShortQueue(); ShortQueue(int initialSize); void addLast(short object); void addFirst(short object); void ensureCapacity(int additional); short removeFirst(); short removeLast(); int indexOf(short value); boolean removeValue(short value); short removeIndex(int index); boolean notEmpty(); boolean isEmpty(); short first(); short last(); short get(int index); void clear(); Iterator<Short> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeLastTest() { ShortQueue queue = new ShortQueue(); queue.addLast((short) 1); queue.addLast((short) 2); queue.addLast((short) 3); queue.addLast((short) 4); assertEquals(4, queue.size); assertEquals(3, queue.indexOf((short) 4)); assertEquals(4, queue.removeLast()); assertEquals(3, queue.size); assertEquals(2, queue.indexOf((short) 3)); assertEquals(3, queue.removeLast()); assertEquals(2, queue.size); assertEquals(1, queue.indexOf((short) 2)); assertEquals(2, queue.removeLast()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf((short) 1)); assertEquals(1, queue.removeLast()); assertEquals(0, queue.size); }
ShortQueue { public short removeFirst () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final short[] values = this.values; final short result = values[head]; head++; if (head == values.length) { head = 0; } size--; return result; } ShortQueue(); ShortQueue(int initialSize); void addLast(short object); void addFirst(short object); void ensureCapacity(int additional); short removeFirst(); short removeLast(); int indexOf(short value); boolean removeValue(short value); short removeIndex(int index); boolean notEmpty(); boolean isEmpty(); short first(); short last(); short get(int index); void clear(); Iterator<Short> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeFirstTest() { ShortQueue queue = new ShortQueue(); queue.addLast((short) 1); queue.addLast((short) 2); queue.addLast((short) 3); queue.addLast((short) 4); assertEquals(4, queue.size); assertEquals(0, queue.indexOf((short) 1)); assertEquals(1, queue.removeFirst()); assertEquals(3, queue.size); assertEquals(0, queue.indexOf((short) 2)); assertEquals(2, queue.removeFirst()); assertEquals(2, queue.size); assertEquals(0, queue.indexOf((short) 3)); assertEquals(3, queue.removeFirst()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf((short) 4)); assertEquals(4, queue.removeFirst()); assertEquals(0, queue.size); }
ShortQueue { public short 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 short[] values = this.values; int i = head + index; if (i >= values.length) { i -= values.length; } return values[i]; } ShortQueue(); ShortQueue(int initialSize); void addLast(short object); void addFirst(short object); void ensureCapacity(int additional); short removeFirst(); short removeLast(); int indexOf(short value); boolean removeValue(short value); short removeIndex(int index); boolean notEmpty(); boolean isEmpty(); short first(); short last(); short get(int index); void clear(); Iterator<Short> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void getTest () { final ShortQueue q = new ShortQueue(7); for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { q.addLast((short) 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) { } } }
ShortQueue { public int indexOf (short value) { if (size == 0) return -1; short[] 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; } ShortQueue(); ShortQueue(int initialSize); void addLast(short object); void addFirst(short object); void ensureCapacity(int additional); short removeFirst(); short removeLast(); int indexOf(short value); boolean removeValue(short value); short removeIndex(int index); boolean notEmpty(); boolean isEmpty(); short first(); short last(); short get(int index); void clear(); Iterator<Short> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void indexOfTest () { final ShortQueue q = new ShortQueue(); for (int j = 0; j <= 6; j++) q.addLast((short) j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf((short) j), j); q.clear(); for (int j = 2; j >= 0; j--) q.addFirst((short) j); for (int j = 3; j <= 6; j++) q.addLast((short) j); for (int j = 0; j <= 6; j++) assertEquals(q.indexOf((short) j), j); }
ShortQueue { public Iterator<Short> iterator () { if (iterable == null) iterable = new ShortQueueIterable(this); return iterable.iterator(); } ShortQueue(); ShortQueue(int initialSize); void addLast(short object); void addFirst(short object); void ensureCapacity(int additional); short removeFirst(); short removeLast(); int indexOf(short value); boolean removeValue(short value); short removeIndex(int index); boolean notEmpty(); boolean isEmpty(); short first(); short last(); short get(int index); void clear(); Iterator<Short> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void iteratorTest () { final ShortQueue q = new ShortQueue(); for (int j = 0; j <= 6; j++) q.addLast((short) j); Iterator<Short> 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((short) j); for (int j = 3; j <= 6; j++) q.addLast((short) 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); }
ShortQueue { public String toString () { if (size == 0) { return "[]"; } final short[] 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(); } ShortQueue(); ShortQueue(int initialSize); void addLast(short object); void addFirst(short object); void ensureCapacity(int additional); short removeFirst(); short removeLast(); int indexOf(short value); boolean removeValue(short value); short removeIndex(int index); boolean notEmpty(); boolean isEmpty(); short first(); short last(); short get(int index); void clear(); Iterator<Short> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void toStringTest () { ShortQueue q = new ShortQueue(1); assertEquals("[]", q.toString()); q.addLast((short) 4); assertEquals("[4]", q.toString()); q.addLast((short) 5); q.addLast((short) 6); q.addLast((short) 7); assertEquals("[4, 5, 6, 7]", q.toString()); }
IntQueue { public int removeLast () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final int[] values = this.values; int tail = this.tail; tail--; if (tail == -1) { tail = values.length - 1; } final int result = values[tail]; this.tail = tail; size--; return result; } IntQueue(); IntQueue(int initialSize); void addLast(int object); void addFirst(int object); void ensureCapacity(int additional); int removeFirst(); int removeLast(); int indexOf(int value); boolean removeValue(int value); int removeIndex(int index); boolean notEmpty(); boolean isEmpty(); int first(); int last(); int get(int index); void clear(); Iterator<Integer> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeLastTest() { IntQueue queue = new IntQueue(); queue.addLast(1); queue.addLast(2); queue.addLast(3); queue.addLast(4); assertEquals(4, queue.size); assertEquals(3, queue.indexOf(4)); assertEquals(4, queue.removeLast()); assertEquals(3, queue.size); assertEquals(2, queue.indexOf(3)); assertEquals(3, queue.removeLast()); assertEquals(2, queue.size); assertEquals(1, queue.indexOf(2)); assertEquals(2, queue.removeLast()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf(1)); assertEquals(1, queue.removeLast()); assertEquals(0, queue.size); }
IntQueue { public int removeFirst () { if (size == 0) { throw new NoSuchElementException("Queue is empty."); } final int[] values = this.values; final int result = values[head]; head++; if (head == values.length) { head = 0; } size--; return result; } IntQueue(); IntQueue(int initialSize); void addLast(int object); void addFirst(int object); void ensureCapacity(int additional); int removeFirst(); int removeLast(); int indexOf(int value); boolean removeValue(int value); int removeIndex(int index); boolean notEmpty(); boolean isEmpty(); int first(); int last(); int get(int index); void clear(); Iterator<Integer> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void removeFirstTest() { IntQueue queue = new IntQueue(); queue.addLast(1); queue.addLast(2); queue.addLast(3); queue.addLast(4); assertEquals(4, queue.size); assertEquals(0, queue.indexOf(1)); assertEquals(1, queue.removeFirst()); assertEquals(3, queue.size); assertEquals(0, queue.indexOf(2)); assertEquals(2, queue.removeFirst()); assertEquals(2, queue.size); assertEquals(0, queue.indexOf(3)); assertEquals(3, queue.removeFirst()); assertEquals(1, queue.size); assertEquals(0, queue.indexOf(4)); assertEquals(4, queue.removeFirst()); assertEquals(0, queue.size); }
IntQueue { public int 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 int[] values = this.values; int i = head + index; if (i >= values.length) { i -= values.length; } return values[i]; } IntQueue(); IntQueue(int initialSize); void addLast(int object); void addFirst(int object); void ensureCapacity(int additional); int removeFirst(); int removeLast(); int indexOf(int value); boolean removeValue(int value); int removeIndex(int index); boolean notEmpty(); boolean isEmpty(); int first(); int last(); int get(int index); void clear(); Iterator<Integer> iterator(); String toString(); String toString(String separator); int hashCode(); boolean equals(Object o); public int size; }
@Test public void getTest () { final IntQueue q = new IntQueue(7); for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { q.addLast(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) { } } }