Example usage for com.badlogic.gdx.utils Array reverse

List of usage examples for com.badlogic.gdx.utils Array reverse

  1. HOME
  2. Java
  3. com.badlogic.gdx
  4. com.badlogic.gdx.utils.*
  5. Array
  6. reverse

Introduction

In this page you can find the example usage for com.badlogic.gdx.utils Array reverse.

Prototype

public void reverse()

Source Link

Usage

From source file:com.agateau.pixelwheels.GameWorld.java

License:Open Source License

private void setupRacers(Array<GameInfo.Entrant> entrants) {
    VehicleCreator creator = new VehicleCreator(mGame.getAssets(), this);
    Assets assets = mGame.getAssets();//from w w w .  j av a  2s.c  om

    final float startAngle = 90;
    Array<Vector2> positions = mTrack.findStartTilePositions();
    positions.reverse();

    AudioManager audioManager = mGame.getAudioManager();
    for (int idx = 0; idx < entrants.size; ++idx) {
        Assert.check(idx < positions.size, "Too many entrants");
        GameInfo.Entrant entrant = entrants.get(idx);
        VehicleDef vehicleDef = assets.findVehicleDefById(entrant.getVehicleId());
        Vehicle vehicle = creator.create(vehicleDef, positions.get(idx), startAngle);
        Racer racer = new Racer(assets, audioManager, this, vehicle, entrant);
        if (entrant.isPlayer()) {
            GameInfo.Player player = (GameInfo.Player) entrant;
            PlayerPilot pilot = new PlayerPilot(assets, this, racer, mGame.getConfig(), player.getIndex());
            racer.setPilot(pilot);
            mPlayerRacers.add(racer);
        } else {
            racer.setPilot(new AIPilot(this, mTrack, racer));
        }
        addGameObject(racer);
        mRacers.add(racer);
    }
}

From source file:com.arkanoid.Actors.ActorFactory.java

License:Open Source License

/**
 * Create a player using the default texture.
 * @param world     world where the player will have to live in.
 * @param position  initial position ofr the player in the world (meters,meters).
 * @return          a player.//from   www .  ja  va 2 s . c om
 */
public PlayerActor createPlayer(World world, Vector2 position) {
    //Texture playerTexture = manager.get("player.png");
    TextureAtlas atlas = manager.get("sprites_player.txt", TextureAtlas.class);
    HashMap<PlayerActor.PlayerAnimations, Animation> animations = new HashMap<PlayerActor.PlayerAnimations, Animation>();

    Array<TextureAtlas.AtlasRegion> playerRegions = atlas.findRegions("red_medium");
    Array<TextureAtlas.AtlasRegion> playerRegionsReverse = atlas.findRegions("red_medium");
    playerRegionsReverse.reverse();
    playerRegions.addAll(playerRegionsReverse);
    animations.put(PlayerActor.PlayerAnimations.RED_MEDIUM,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("red_large");
    playerRegionsReverse = atlas.findRegions("red_large");
    playerRegionsReverse.reverse();
    playerRegions.addAll(playerRegionsReverse);
    animations.put(PlayerActor.PlayerAnimations.RED_LARGE,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("red_medium_create");
    animations.put(PlayerActor.PlayerAnimations.RED_MEDIUM_CREATE,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("red_medium_destoy");
    animations.put(PlayerActor.PlayerAnimations.RED_MEDIUM_DESTROY,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("blue_medium");
    playerRegionsReverse = atlas.findRegions("blue_medium");
    playerRegionsReverse.reverse();
    playerRegions.addAll(playerRegionsReverse);
    animations.put(PlayerActor.PlayerAnimations.BLUE_MEDIUM,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("blue_large");
    playerRegionsReverse = atlas.findRegions("blue_large");
    playerRegionsReverse.reverse();
    playerRegions.addAll(playerRegionsReverse);
    animations.put(PlayerActor.PlayerAnimations.BLUE_LARGE,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("blue_medium_create");
    animations.put(PlayerActor.PlayerAnimations.BLUE_MEDIUM_CREATE,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    playerRegions = atlas.findRegions("blue_medium_destoy");
    animations.put(PlayerActor.PlayerAnimations.BLUE_MEDIUM_DESTROY,
            new Animation(1f / (float) playerRegions.size, playerRegions));

    return new PlayerActor(world, animations, position);
}

From source file:com.indignado.games.smariano.utils.dermetfan.box2d.Box2DMapObjectParser.java

License:Apache License

/**
 * creates {@link com.badlogic.gdx.physics.box2d.Fixture Fixtures} from a {@link com.badlogic.gdx.maps.MapObject}
 *
 * @param mapObject the {@link com.badlogic.gdx.maps.MapObject} to parse
 * @return an array of parsed {@link com.badlogic.gdx.physics.box2d.Fixture Fixtures}
 */// ww w .ja v a  2s  .c o  m
public Fixture[] createFixtures(MapObject mapObject) {
    Polygon polygon;

    if (!(mapObject instanceof PolygonMapObject)
            || isConvex(polygon = ((PolygonMapObject) mapObject).getPolygon()))
        return new Fixture[] { createFixture(mapObject) };

    Polygon[] convexPolygons;
    if (triangulate) {
        if (areVerticesClockwise(polygon)) { // ensure the vertices are in counterclockwise order (not really necessary according to EarClippingTriangulator's javadoc, but sometimes better)
            Array<Vector2> vertices = new Array<Vector2>(toVector2Array(polygon.getVertices()));
            Vector2 first = vertices.removeIndex(0);
            vertices.reverse();
            vertices.insert(0, first);
            polygon.setVertices(toFloatArray(vertices.items));
        }
        convexPolygons = toPolygonArray(toVector2Array(
                new EarClippingTriangulator().computeTriangles(polygon.getTransformedVertices()).toArray()), 3);
    } else {
        Array<Array<Vector2>> convexPolys = BayazitDecomposer
                .convexPartition(new Array<Vector2>(toVector2Array(polygon.getTransformedVertices())));
        convexPolygons = new Polygon[convexPolys.size];
        for (int i = 0; i < convexPolygons.length; i++)
            convexPolygons[i] = new Polygon(
                    toFloatArray((Vector2[]) convexPolys.get(i).toArray(Vector2.class)));
    }

    // create the fixtures using the convex polygons
    Fixture[] fixtures = new Fixture[convexPolygons.length];
    for (int i = 0; i < fixtures.length; i++) {
        PolygonMapObject convexObject = new PolygonMapObject(convexPolygons[i]);
        convexObject.setColor(mapObject.getColor());
        convexObject.setName(mapObject.getName());
        convexObject.setOpacity(mapObject.getOpacity());
        convexObject.setVisible(mapObject.isVisible());
        convexObject.getProperties().putAll(mapObject.getProperties());
        fixtures[i] = createFixture(convexObject);
    }

    return fixtures;
}

From source file:com.kotcrab.vis.editor.module.physicseditor.util.earclipping.bayazit.BayazitDecomposer.java

License:Apache License

public static Array<Array<Vector2>> ConvexPartition(Array<Vector2> vertices) {
    // We force it to CCW as it is a precondition in this algorithm.
    // vertices.ForceCounterClockWise();
    if (!IsCounterClockWise(vertices)) {
        // Collections.reverse(vertices);
        vertices.reverse();
        // Array<Vector2> reversed = new Array<Vector2>(vertices.size);
        // for (int i = vertices.size - 1; i <= 0; i--) {
        // reversed.add(vertices.get(i));
        // }/*from  w  w  w  .  j a  v a 2  s .c om*/
        // vertices = reversed;
    }
    Array<Array<Vector2>> list = new Array<Array<Vector2>>();
    float d, lowerDist, upperDist;
    Vector2 p;
    Vector2 lowerInt = new Vector2();
    Vector2 upperInt = new Vector2(); // intersection points
    int lowerIndex = 0, upperIndex = 0;
    Array<Vector2> lowerPoly, upperPoly;
    for (int i = 0; i < vertices.size; ++i) {
        if (Reflex(i, vertices)) {
            lowerDist = upperDist = Float.MAX_VALUE; // std::numeric_limits<qreal>::max();
            for (int j = 0; j < vertices.size; ++j) {
                // if line intersects with an edge
                if (Left(At(i - 1, vertices), At(i, vertices), At(j, vertices))
                        && RightOn(At(i - 1, vertices), At(i, vertices), At(j - 1, vertices))) {
                    // find the point of intersection
                    p = LineIntersect(At(i - 1, vertices), At(i, vertices), At(j, vertices),
                            At(j - 1, vertices));
                    if (Right(At(i + 1, vertices), At(i, vertices), p)) {
                        // make sure it's inside the poly
                        d = SquareDist(At(i, vertices), p);
                        if (d < lowerDist) {
                            // keep only the closest intersection
                            lowerDist = d;
                            lowerInt = p;
                            lowerIndex = j;
                        }
                    }
                }
                if (Left(At(i + 1, vertices), At(i, vertices), At(j + 1, vertices))
                        && RightOn(At(i + 1, vertices), At(i, vertices), At(j, vertices))) {
                    p = LineIntersect(At(i + 1, vertices), At(i, vertices), At(j, vertices),
                            At(j + 1, vertices));
                    if (Left(At(i - 1, vertices), At(i, vertices), p)) {
                        d = SquareDist(At(i, vertices), p);
                        if (d < upperDist) {
                            upperDist = d;
                            upperIndex = j;
                            upperInt = p;
                        }
                    }
                }
            }
            // if there are no vertices to connect to, choose a point in the
            // middle
            if (lowerIndex == (upperIndex + 1) % vertices.size) {
                Vector2 sp = new Vector2((lowerInt.x + upperInt.x) / 2, (lowerInt.y + upperInt.y) / 2);
                lowerPoly = Copy(i, upperIndex, vertices);
                lowerPoly.add(sp);
                upperPoly = Copy(lowerIndex, i, vertices);
                upperPoly.add(sp);
            } else {
                double highestScore = 0, bestIndex = lowerIndex;
                while (upperIndex < lowerIndex)
                    upperIndex += vertices.size;
                for (int j = lowerIndex; j <= upperIndex; ++j) {
                    if (CanSee(i, j, vertices)) {
                        double score = 1 / (SquareDist(At(i, vertices), At(j, vertices)) + 1);
                        if (Reflex(j, vertices)) {
                            if (RightOn(At(j - 1, vertices), At(j, vertices), At(i, vertices))
                                    && LeftOn(At(j + 1, vertices), At(j, vertices), At(i, vertices))) {
                                score += 3;
                            } else {
                                score += 2;
                            }
                        } else {
                            score += 1;
                        }
                        if (score > highestScore) {
                            bestIndex = j;
                            highestScore = score;
                        }
                    }
                }
                lowerPoly = Copy(i, (int) bestIndex, vertices);
                upperPoly = Copy((int) bestIndex, i, vertices);
            }
            list.addAll(ConvexPartition(lowerPoly));
            list.addAll(ConvexPartition(upperPoly));
            return list;
        }
    }
    // polygon is already convex
    if (vertices.size > MaxPolygonVertices) {
        lowerPoly = Copy(0, vertices.size / 2, vertices);
        upperPoly = Copy(vertices.size / 2, 0, vertices);
        list.addAll(ConvexPartition(lowerPoly));
        list.addAll(ConvexPartition(upperPoly));
    } else
        list.add(vertices);
    // The polygons are not guaranteed to be with collinear points. We
    // remove
    // them to be sure.
    for (int i = 0; i < list.size; i++) {
        list.set(i, SimplifyTools.CollinearSimplify(list.get(i), 0));
    }
    // Remove empty vertice collections
    for (int i = list.size - 1; i >= 0; i--) {
        if (list.get(i).size == 0)
            list.removeIndex(i);
    }
    return list;
}

From source file:com.kotcrab.vis.editor.util.CrashReporter.java

License:Apache License

private void printLog() throws IOException {
    println("--- Log file (last 200 lines) ---");

    ReversedLinesFileReader reader = new ReversedLinesFileReader(logFile);
    Array<String> logLines = new Array<>();

    for (int i = 0; i < 200; i++) {
        String line = reader.readLine();
        if (line == null)
            break;
        logLines.add(line);//  w  w w .ja  va  2  s.  co  m
    }

    logLines.reverse();

    for (String s : logLines)
        println(s);

    println("---------------------------------");
    println();
}

From source file:com.kotcrab.vis.editor.util.vis.CrashReporter.java

License:Apache License

private void printLog() throws IOException {
    println("--- Log file (last 200 lines) ---");

    ReversedLinesFileReader reader = new ReversedLinesFileReader(logFile);
    Array<String> logLines = new Array<>();

    for (int i = 0; i < 200; i++) {
        String line = reader.readLine();
        if (line == null)
            break;
        logLines.add(line);//from w  w w  . j a v a  2  s.c o m
    }

    logLines.reverse();

    for (String s : logLines)
        println(s);

    println("---------------------------------");
    println();
    IOUtils.closeQuietly(reader);
}

From source file:com.kotcrab.vis.ui.widget.file.FileUtils.java

License:Apache License

/**
 * Sorts file list, using this rules: directories first, sorted using provided comparator, then files sorted using provided comparator.
 * @param files list to sort/*from w  w w .j  a v a2  s .c  o m*/
 * @param comparator comparator used to sort files list
 * @param descending if true then sorted list will be in reversed order
 * @return sorted file list
 */
public static Array<FileHandle> sortFiles(FileHandle[] files, Comparator<FileHandle> comparator,
        boolean descending) {
    Array<FileHandle> directoriesList = new Array<FileHandle>();
    Array<FileHandle> filesList = new Array<FileHandle>();

    for (FileHandle f : files) {
        if (f.isDirectory()) {
            directoriesList.add(f);
        } else {
            filesList.add(f);
        }
    }

    directoriesList.sort(comparator);
    filesList.sort(comparator);

    if (descending) {
        directoriesList.reverse();
        filesList.reverse();
    }

    directoriesList.addAll(filesList); // combine lists
    return directoriesList;
}

From source file:com.theosirian.ppioo.controllers.PlayerSelectionController.java

License:Open Source License

protected void buildPlayerPane(Array<Player> players) {
    playersTable.clear();//w  ww .  j  av a2 s  .c om
    Drawable odd = game.skin.newDrawable("white", Color.valueOf("C0C0C0FF"));
    Drawable even = game.skin.newDrawable("white", Color.valueOf("E0E0E0FF"));
    Drawable[] turn = new Drawable[] { odd, even };
    players.sort(playerPlayerComp.getComparator());
    if (playerPlayerComp.isReverse()) {
        players.reverse();
    }
    int counter = 0;
    for (final Player player : players) {
        playersTable.add(buildPlayerListItem(player, turn[counter % 2])).expand().fill();
        counter++;
        playersTable.row();
    }
    playersPane.setWidget(playersTable);
}

From source file:com.theosirian.ppioo.controllers.PlayerSelectionController.java

License:Open Source License

protected void buildPlayerSetupList(Array<Player> players) {
    positionsTable.clear();//from w w w  .ja v a  2s  .  co  m
    Drawable odd = game.skin.newDrawable("white", Color.valueOf("C0C0C0FF"));
    Drawable even = game.skin.newDrawable("white", Color.valueOf("E0E0E0FF"));
    Drawable[] turn = new Drawable[] { odd, even };
    if (positionPlayerComp != null) {
        players.sort(positionPlayerComp.getComparator());
        if (positionPlayerComp.isReverse()) {
            players.reverse();
        }
        positionPlayerComp = null;
    }
    int counter = 0;
    for (final Player player : players) {
        positionsTable.add(buildPlayerSetupListItem(player, turn[counter % 2])).expand().fill();
        counter++;
        positionsTable.row();
    }
    positionsPane.setWidget(positionsTable);
}

From source file:com.theosirian.ppioo.controllers.ShopController.java

License:Open Source License

private void buildFanList(Array<Fan> fans) {
    fansTable.clear();//  w  w w  .  jav  a  2 s  .  c o m
    Drawable odd = game.skin.newDrawable("white", Color.valueOf("C0C0C0FF"));
    Drawable even = game.skin.newDrawable("white", Color.valueOf("E0E0E0FF"));
    Drawable[] turn = new Drawable[] { odd, even };
    fans.sort(fanComp.comparator);
    if (fanComp.isReverse) {
        fans.reverse();
    }
    int counter = 0;
    for (Fan fan : fans) {
        fansTable.add(buildFanListItem(fan, turn[counter % 2])).expand().fill();
        counter++;
        fansTable.row();
    }
    fansPane.setWidget(fansTable);
}