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

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

Introduction

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

Prototype

public void insert(int index, T value) 

Source Link

Usage

From source file:cocos2d.touch_dispatcher.CCTouchDispatcher.java

License:Open Source License

protected void forceAddHandler(CCTouchHandler pHandler, Array<CCTouchHandler> pArray) {
    int u = 0;/* w w  w  . ja  v  a 2  s .c  om*/
    for (int i = 0; i < pArray.size; i++) {
        CCTouchHandler h = pArray.get(i);

        if (h != null) {
            if (h.getPriority() < pHandler.getPriority()) {
                ++u;
            }

            if (h.getDelegate() == pHandler.getDelegate()) {
                return;
            }
        }
    }

    pArray.insert(u, pHandler);
}

From source file:com.bladecoder.engineeditor.ui.LayerList.java

License:Apache License

private void up() {
    int pos = list.getSelectedIndex();

    if (pos == -1 || pos == 0)
        return;/* w w w .j a  va2 s . co  m*/

    Array<SceneLayer> items = list.getItems();
    SceneLayer e = items.get(pos);
    SceneLayer e2 = items.get(pos - 1);

    parent.getLayers().set(pos, e2);
    parent.getLayers().set(pos - 1, e);

    items.removeIndex(pos);
    items.insert(pos - 1, e);
    list.setSelectedIndex(pos - 1);
    upBtn.setDisabled(list.getSelectedIndex() == 0);
    downBtn.setDisabled(list.getSelectedIndex() == list.getItems().size - 1);

    Ctx.project.setModified();
}

From source file:com.bladecoder.engineeditor.ui.LayerList.java

License:Apache License

private void down() {
    int pos = list.getSelectedIndex();
    Array<SceneLayer> items = list.getItems();

    if (pos == -1 || pos == items.size - 1)
        return;/*  w w w. j av  a2 s . c o  m*/

    SceneLayer e = items.get(pos);
    SceneLayer e2 = pos + 1 < items.size ? items.get(pos + 1) : null;

    parent.getLayers().set(pos, e2);
    parent.getLayers().set(pos + 1, e);

    items.removeIndex(pos);
    items.insert(pos + 1, e);
    list.setSelectedIndex(pos + 1);
    upBtn.setDisabled(list.getSelectedIndex() == 0);
    downBtn.setDisabled(list.getSelectedIndex() == list.getItems().size - 1);

    Ctx.project.setModified();
}

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}
 *//*from w  w w  .  j a  v a 2  s . c om*/
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.PRigidBodiesScreen.java

License:Apache License

public void insertPointsBetweenSelected() {
    if (!isInsertEnabled())
        return;//from   w w  w .  j a v a 2  s .c o  m

    List<Vector2> toAdd = new ArrayList<Vector2>();

    for (ShapeModel shape : selectedModel.getShapes()) {
        if (shape.getType() != ShapeModel.Type.POLYGON)
            continue;

        Array<Vector2> vs = shape.getVertices();

        for (int i = 0; i < vs.size; i++) {
            Vector2 p1 = vs.get(i);
            Vector2 p2 = i != vs.size - 1 ? vs.get(i + 1) : vs.get(0);

            if (selectedPoints.contains(p1) && selectedPoints.contains(p2)) {
                Vector2 p = new Vector2((p1.x + p2.x) / 2, (p1.y + p2.y) / 2);
                vs.insert(i + 1, p);
                toAdd.add(p);
            }
        }
    }

    selectedPoints.addAll(toAdd);
    selectedModel.computePhysics(settings.polygonizer);
}

From source file:com.kotcrab.vis.editor.module.physicseditor.util.trace.TextureConverter.java

License:Apache License

private static Array<Array<Vector2>> createPolygon(PolygonCreationAssistance pca) throws Exception {
    Array<Array<Vector2>> polygons = new Array<Array<Vector2>>();
    Array<Vector2> polygon;
    Array<Vector2> holePolygon;
    Vector2 holeEntrance = null;/* w  w w  .ja v a  2  s.c  o  m*/
    Vector2 polygonEntrance = null;
    Array<Vector2> blackList = new Array<Vector2>();
    // First of all: Check the array you just got.
    if (pca.IsValid()) {
        boolean searchOn;
        do {
            if (polygons.size == 0) {
                polygon = CreateSimplePolygon(pca, new Vector2(), new Vector2());
                if (polygon != null && polygon.size > 2) {
                    polygonEntrance = GetTopMostVertex(polygon);
                }
            } else if (polygonEntrance != null) {
                polygon = CreateSimplePolygon(pca, polygonEntrance,
                        new Vector2(polygonEntrance.x - 1f, polygonEntrance.y));
            } else {
                break;
            }
            searchOn = false;
            if (polygon != null && polygon.size > 2) {
                if (pca.HoleDetection) {
                    do {
                        holeEntrance = GetHoleHullEntrance(pca, polygon, holeEntrance);
                        if (holeEntrance != null) {
                            if (!vectorListContains(blackList, holeEntrance)) {
                                blackList.add(holeEntrance);
                                holePolygon = CreateSimplePolygon(pca, holeEntrance,
                                        new Vector2(holeEntrance.x + 1, holeEntrance.y));
                                if (holePolygon != null && holePolygon.size > 2) {
                                    holePolygon.add(holePolygon.get(0));
                                    Reference<Integer> vertex2IndexRef = new Reference<Integer>(0);
                                    Reference<Integer> vertex1IndexRef = new Reference<Integer>(0);
                                    if (SplitPolygonEdge(polygon, EdgeAlignment.Vertical, holeEntrance,
                                            vertex1IndexRef, vertex2IndexRef)) {

                                        polygon.ensureCapacity(holePolygon.size);
                                        for (int i = holePolygon.size - 1; i <= 0; i--) {
                                            polygon.insert(vertex2IndexRef.v, holePolygon.get(i));
                                        }
                                    }
                                }
                            } else {
                                break;
                            }
                        } else {
                            break;
                        }
                    } while (true);
                }
                polygons.add(polygon);
                if (pca.MultipartDetection) {
                    // 1: 95 / 151
                    // 2: 232 / 252
                    //
                    polygonEntrance = new Vector2();
                    while (GetNextHullEntrance(pca, polygonEntrance, polygonEntrance)) {
                        boolean inPolygon = false;
                        for (int i = 0; i < polygons.size; i++) {
                            polygon = polygons.get(i);
                            if (InPolygon(pca, polygon, polygonEntrance)) {
                                inPolygon = true;
                                break;
                            }
                        }
                        if (!inPolygon) {
                            searchOn = true;
                            break;
                        }
                    }
                }
            }
        } while (searchOn);
    } else {
        throw new Exception(
                "Sizes don't match: Color array must contain texture width * texture height elements.");
    }
    return polygons;
}

From source file:com.kotcrab.vis.editor.module.physicseditor.util.trace.TextureConverter.java

License:Apache License

private static boolean SplitPolygonEdge(Array<Vector2> polygon, EdgeAlignment edgeAlign,
        Vector2 coordInsideThePolygon, Reference<Integer> vertex1IndexRef, Reference<Integer> vertex2IndexRef)
        throws Exception {
    Array<CrossingEdgeInfo> edges;
    Vector2 slope = new Vector2();
    int nearestEdgeVertex1Index = 0;
    int nearestEdgeVertex2Index = 0;
    boolean edgeFound = false;
    float shortestDistance = Float.MAX_VALUE;
    boolean edgeCoordFound = false;
    Vector2 foundEdgeCoord = new Vector2();
    vertex1IndexRef.v = 0;/*from   ww w. j a v a 2 s . com*/
    vertex2IndexRef.v = 0;
    switch (edgeAlign) {
    case Vertical:
        edges = GetCrossingEdges(polygon, EdgeAlignment.Vertical, (int) coordInsideThePolygon.y);
        foundEdgeCoord.y = coordInsideThePolygon.y;
        if (edges != null && edges.size > 1 && edges.size % 2 == 0) {
            float distance;
            for (int i = 0; i < edges.size; i++) {
                if (edges.get(i).CrossingPoint.x < coordInsideThePolygon.x) {
                    distance = coordInsideThePolygon.x - edges.get(i).CrossingPoint.x;
                    if (distance < shortestDistance) {
                        shortestDistance = distance;
                        foundEdgeCoord.x = edges.get(i).CrossingPoint.x;
                        edgeCoordFound = true;
                    }
                }
            }
            if (edgeCoordFound) {
                shortestDistance = Float.MAX_VALUE;
                int edgeVertex2Index = polygon.size - 1;
                int edgeVertex1Index;
                for (edgeVertex1Index = 0; edgeVertex1Index < polygon.size; edgeVertex1Index++) {
                    Vector2 tempVector1 = polygon.get(edgeVertex1Index).cpy();
                    Vector2 tempVector2 = polygon.get(edgeVertex2Index).cpy();
                    distance = LineTools.DistanceBetweenPointAndLineSegment(foundEdgeCoord, tempVector1,
                            tempVector2);
                    if (distance < shortestDistance) {
                        shortestDistance = distance;
                        nearestEdgeVertex1Index = edgeVertex1Index;
                        nearestEdgeVertex2Index = edgeVertex2Index;
                        edgeFound = true;
                    }
                    edgeVertex2Index = edgeVertex1Index;
                }
                if (edgeFound) {
                    slope.set(vectorSub(polygon.get(nearestEdgeVertex2Index),
                            polygon.get(nearestEdgeVertex1Index)));
                    slope.nor();
                    Vector2 tempVector = polygon.get(nearestEdgeVertex1Index).cpy();
                    distance = LineTools.DistanceBetweenPointAndPoint(tempVector, foundEdgeCoord);
                    vertex1IndexRef.v = nearestEdgeVertex1Index;
                    vertex2IndexRef.v = nearestEdgeVertex1Index + 1;
                    // distance * slope + polygon[vertex1Index]
                    polygon.insert(nearestEdgeVertex1Index,
                            vectorAdd(vectorMul(slope, distance), polygon.get(vertex1IndexRef.v)));
                    polygon.insert(nearestEdgeVertex1Index,
                            vectorAdd(vectorMul(slope, distance), polygon.get(vertex2IndexRef.v)));
                    return true;
                }
            }
        }
        break;
    case Horizontal:
        throw new Exception("EdgeAlignment.Horizontal isn't implemented yet. Sorry.");
    }
    return false;
}

From source file:com.lynk.gdx.tool.particleeditor.EffectPanel.java

License:Apache License

void move(int direction) {
    if (direction < 0 && editIndex == 0)
        return;//from w  w  w.ja  va 2  s. c o m
    Array<ParticleEmitter> emitters = editor.effect.getEmitters();
    if (direction > 0 && editIndex == emitters.size - 1)
        return;
    int insertIndex = editIndex + direction;
    Object name = emitterTableModel.getValueAt(editIndex, 0);
    emitterTableModel.removeRow(editIndex);
    ParticleEmitter emitter = emitters.removeIndex(editIndex);
    emitterTableModel.insertRow(insertIndex, new Object[] { name });
    emitters.insert(insertIndex, emitter);
    editIndex = insertIndex;
    emitterTable.getSelectionModel().setSelectionInterval(editIndex, editIndex);
}

From source file:com.ridiculousRPG.GameServiceProvider.java

License:Apache License

private <T> void shiftPos(Array<T> array, T service, T ref, int offset) {
    array.removeValue(service, true);/*from   w w  w  .  ja v  a 2  s  .  co  m*/
    array.insert(array.indexOf(ref, true) + offset, service);
}

From source file:de.thomas.pure_tetris.screens.GameOverScreen.java

License:Open Source License

@Override
public void input(String text) {
    text = text.substring(0, Math.min(text.length(), 10));

    FileHandle file = Gdx.files.local("scores.txt");

    Array<Score> scores = readScores(file);

    if (scores.size > 0) {
        boolean isLast = true;

        for (int x = 0; x < scores.size && x < 10; x++) {
            if (score > scores.get(x).y) {
                scores.insert(x, new Score(text, score));
                isLast = false;//from www. j  a v a2s .c  o  m
                break;
            }
        }

        if (isLast)
            scores.add(new Score(text, score));

        try {
            file.writer(false).write("");
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }

        file = Gdx.files.local("scores.txt");

        int amount = 0;
        for (Score s : scores) {
            if (amount++ >= 10)
                break;

            file.writeString(s.x + " " + s.y + "\n", true);
        }
    } else {
        file.writeString(text + " " + score + "\n", true);
    }

    game.setScreen(new HighScoreScreen(game));
    dispose();
}