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

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

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

Introduction

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

Prototype

public T peek()

Source Link

Document

Returns the last item.

Usage

From source file:com.kotcrab.vis.editor.module.scene.entitymanipulator.tool.PolygonTool.java

License:Apache License

private boolean checkCurrentVertexIntersection() {
    Array<Vector2> vertices = component.vertices;
    int index = vertices.indexOf(overVertex, true);
    if (index == -1)
        return true;

    Edge firstEdge;/* w  ww .ja  v  a2  s . co  m*/
    Edge secondEdge;

    if (index == 0)
        firstEdge = new Edge(vertices.peek(), overVertex);
    else
        firstEdge = new Edge(vertices.get(index - 1), overVertex);

    if (index == vertices.size - 1)
        secondEdge = new Edge(vertices.first(), overVertex);
    else
        secondEdge = new Edge(vertices.get(index + 1), overVertex);

    Array<Edge> polygonEdges = new Array<>();

    for (int i = 0; i < vertices.size - 1; i++) {
        polygonEdges.add(new Edge(vertices.get(i), vertices.get(i + 1)));
    }

    polygonEdges.add(new Edge(vertices.peek(), vertices.first()));

    for (Edge edge : polygonEdges) {
        if (edge.epsilonEquals(firstEdge, 0) || edge.epsilonEquals(secondEdge, 0))
            continue;

        if (polygonLineIntersection(firstEdge.start, firstEdge.end, edge.start, edge.end))
            return true;

        if (polygonLineIntersection(secondEdge.start, secondEdge.end, edge.start, edge.end))
            return true;
    }

    return false;
}

From source file:com.stercore.code.net.dermetfan.utils.libgdx.box2d.Box2DUtils.java

License:Apache License

/** splits the given Shape using the segment described by the two given Vector2s
 *  @param shape the Shape to split/*w  ww. j ava 2  s.  c  o m*/
 *  @param a the first point of the segment
 *  @param b the second point of the segment
 *  @param store the {@link Pair} to store the split Shapes in
 *  @return if the given shape was split */
@SuppressWarnings("unchecked")
public static <T extends Shape> boolean split(T shape, Vector2 a, Vector2 b, Pair<T, T> store) {
    Type type = shape.getType();

    if (type == Type.Circle)
        throw new IllegalArgumentException("shapes of the type " + Type.Circle
                + " cannot be split since Box2D does not support curved shapes other than circles: " + shape);

    if (type == Type.Edge) {
        Vector2 vertex1 = Pools.obtain(Vector2.class), vertex2 = Pools.obtain(Vector2.class),
                intersection = Pools.obtain(Vector2.class);
        EdgeShape es = (EdgeShape) shape;
        es.getVertex1(vertex1);
        es.getVertex2(vertex2);
        if (!Intersector.intersectSegments(a, b, vertex1, vertex2, intersection)) {
            Pools.free(vertex1);
            Pools.free(vertex2);
            Pools.free(intersection);
            return false;
        }

        EdgeShape sa = new EdgeShape(), sb = new EdgeShape();
        sa.set(vertex1, intersection);
        sb.set(intersection, vertex2);
        store.set((T) sa, (T) sb);

        Pools.free(vertex1);
        Pools.free(vertex2);
        Pools.free(intersection);
        return true;
    }

    store.clear();

    Vector2 vertices[] = vertices(shape), aa = Pools.obtain(Vector2.class).set(a),
            bb = Pools.obtain(Vector2.class).set(b);
    Array<Vector2> aVertices = Pools.obtain(Array.class), bVertices = Pools.obtain(Array.class);
    aVertices.clear();
    bVertices.clear();

    if (type == Type.Polygon) {
        aVertices.add(aa);
        aVertices.add(bb);
        GeometryUtils.arrangeClockwise(aVertices);

        if (GeometryUtils.intersectSegments(a, b, GeometryUtils.toFloatArray(vertices), aVertices.first(),
                aVertices.peek()) < 2) {
            Pools.free(aa);
            Pools.free(bb);
            Pools.free(aVertices);
            Pools.free(bVertices);
            return false;
        }

        bVertices.add(aa);
        bVertices.add(bb);

        for (Vector2 vertice : vertices) {
            float det = MathUtils.det(aa.x, aa.y, vertice.x, vertice.y, bb.x, bb.y);
            if (det < 0)
                aVertices.add(vertice);
            else if (det > 0)
                bVertices.add(vertice);
            else {
                aVertices.add(vertice);
                bVertices.add(vertice);
            }
        }

        GeometryUtils.arrangeClockwise(aVertices);
        GeometryUtils.arrangeClockwise(bVertices);

        Vector2[] aVerticesArray = aVertices.toArray(Vector2.class),
                bVerticesArray = bVertices.toArray(Vector2.class);

        if (checkPreconditions) {
            if (aVertices.size >= 3 && aVertices.size <= maxPolygonVertices && bVertices.size >= 3
                    && bVertices.size <= maxPolygonVertices) {
                float[] aVerticesFloatArray = GeometryUtils.toFloatArray(aVerticesArray),
                        bVerticesFloatArray = GeometryUtils.toFloatArray(bVerticesArray);
                if (GeometryUtils.area(aVerticesFloatArray) > minExclusivePolygonArea
                        && GeometryUtils.area(bVerticesFloatArray) > minExclusivePolygonArea) {
                    PolygonShape sa = new PolygonShape(), sb = new PolygonShape();
                    sa.set(aVerticesFloatArray);
                    sb.set(bVerticesFloatArray);
                    store.set((T) sa, (T) sb);
                }
            }
        } else {
            PolygonShape sa = new PolygonShape(), sb = new PolygonShape();
            sa.set(aVerticesArray);
            sb.set(bVerticesArray);
            store.set((T) sa, (T) sb);
        }
    } else if (type == Type.Chain) {
        Vector2 tmp = Pools.obtain(Vector2.class);
        boolean intersected = false;
        for (int i = 0; i < vertices.length; i++) {
            if (!intersected)
                aVertices.add(vertices[i]);
            else
                bVertices.add(vertices[i]);
            if (!intersected && i + 1 < vertices.length
                    && Intersector.intersectSegments(vertices[i], vertices[i + 1], aa, bb, tmp)) {
                intersected = true;
                aVertices.add(tmp);
                bVertices.add(tmp);
            }
        }
        if (intersected)
            if (!checkPreconditions || aVertices.size >= 3 && bVertices.size >= 3) {
                ChainShape sa = new ChainShape(), sb = new ChainShape();
                sa.createChain((Vector2[]) aVertices.toArray(Vector2.class));
                sb.createChain((Vector2[]) bVertices.toArray(Vector2.class));
                store.set((T) sa, (T) sb);
            }
        Pools.free(tmp);
    }

    Pools.free(aa);
    Pools.free(bb);
    Pools.free(aVertices);
    Pools.free(bVertices);

    return store.isFull();
}

From source file:com.stercore.code.net.dermetfan.utils.libgdx.box2d.Box2DUtils.java

License:Apache License

/** {@link Body#destroyFixture(Fixture) destroys} all fixtures of the given body
 *  @param body the body which fixtures to destroy */
public static void destroyFixtures(Body body) {
    Array<Fixture> fixtures = body.getFixtureList();
    while (fixtures.size > 0)
        body.destroyFixture(fixtures.peek());
}

From source file:com.vlaaad.dice.game.actions.imp.ChainLightning.java

License:Open Source License

private IActionResult calcResult(Ability ability, Creature caster, Creature target, World world) {
    ObjectSet<Creature> affected = tmpSet;
    Array<Creature> chain = new Array<Creature>();
    chain.add(target);//from ww w .ja v  a2  s. c  om
    affected.add(target);

    // i == 1 because we already have initial target
    RandomController random = world.getController(RandomController.class);

    for (int i = 1; i < targets; i++) {
        Creature last = chain.peek();
        tmpArray2.clear();
        Array<Creature> neighbours = getNeighbourCreatures(world, last.getX(), last.getY(), tmpArray2);
        Iterator<Creature> it = neighbours.iterator();
        while (it.hasNext()) {
            Creature toCheck = it.next();
            if (affected.contains(toCheck))
                it.remove();
        }
        if (neighbours.size == 0) {
            break;
        } else if (neighbours.size == 1) {
            addToChain(affected, chain, neighbours.first());
        } else {
            Array<Creature> betterTargets = tmpArray3;
            betterTargets.clear();
            for (Creature toCheck : neighbours) {
                if (toCheck.get(Attribute.defenceFor(attackType)) < attackLevel) {
                    betterTargets.add(toCheck);
                }
            }
            if (betterTargets.size > 0) {
                addToChain(affected, chain, random.random(betterTargets));
            } else {
                addToChain(affected, chain, random.random(neighbours));
            }
        }
    }

    ObjectIntMap<Creature> expResults = new ObjectIntMap<Creature>();
    Array<Creature> killed = new Array<Creature>();

    for (Creature creature : chain) {
        if (creature.get(Attribute.defenceFor(attackType)) < attackLevel) { // killed
            if (creature.player != caster.player) {
                expResults.getAndIncrement(caster, 0, ExpHelper.expForKill(caster, creature));
            }
            killed.add(creature);
        } else { // survived
            expResults.put(creature, ExpHelper.expForDefence(caster, creature));
        }
    }

    tmpSet.clear();
    tmpArray2.clear();
    tmpArray3.clear();

    return new ChainLightningResult(caster, ability, chain, killed, expResults);
}

From source file:com.vlaaad.dice.game.world.view.visualizers.actions.ShamanDefenceVisualizer.java

License:Open Source License

@Override
public IFuture<Void> visualize(final ShamanDefenceResult result) {
    final Future<Void> future = Future.make();
    final WorldObjectView view = visualizer.viewController.getView(result.creatureToAddEffect);
    final AnimationSubView appear = new AnimationSubView(0.1f, Config.findRegions(ANIMATION_NAME),
            Animation.PlayMode.NORMAL);/*w  ww. ja  v a2  s  .  co  m*/
    init(appear);
    view.addSubView(appear);
    SoundManager.instance.playMusicAsSound("ability-" + result.ability.name);
    appear.getActor().addListener(new AnimationListener() {
        @Override
        protected void onAnimationEvent(AnimationEvent event) {
            view.removeSubView(appear);
            Array<TextureRegion> playRegions = Array.with(appear.animation.getKeyFrames());
            playRegions.removeIndex(0);
            playRegions.add(playRegions.peek());
            final AnimationSubView play = new AnimationSubView(0.5f, playRegions, Animation.PlayMode.LOOP);
            init(play);
            view.addSubView(play);
            result.creature.world.dispatcher.add(Creature.REMOVE_EFFECT, new EventListener<EffectEvent>() {
                @Override
                public void handle(EventType<EffectEvent> type, EffectEvent event) {
                    if (event.creature == result.creature && event.effect == result.effectToApply) {
                        result.creature.world.dispatcher.remove(Creature.REMOVE_EFFECT, this);
                        view.removeSubView(play);
                        if (result.creature.isKilled())
                            return;
                        SoundManager.instance.playMusicAsSound("ability-" + result.ability.name);
                        Array<TextureAtlas.AtlasRegion> disappearRegions = new Array<TextureAtlas.AtlasRegion>(
                                Config.findRegions(ANIMATION_NAME));
                        disappearRegions.pop();
                        final AnimationSubView disappear = new AnimationSubView(0.1f, disappearRegions,
                                Animation.PlayMode.REVERSED);
                        init(disappear);
                        view.addSubView(disappear);
                        disappear.getActor().addListener(new AnimationListener() {
                            @Override
                            protected void onAnimationEvent(AnimationEvent event) {
                                view.removeSubView(disappear);
                            }
                        });

                    }
                }
            });
            future.happen();

        }
    });
    return future;
}

From source file:com.vlaaad.dice.game.world.view.visualizers.DoubleDefensiveAttackVisualizer.java

License:Open Source License

@Override
public IFuture<Void> visualize(final AttackResult result) {
    final Future<Void> future = Future.make();
    final WorldObjectView actorView = visualizer.viewController.getView(result.creature);
    final Array<AtlasRegion> regions = Config.findRegions("animation/" + result.ability.name);
    final AnimationSubView appear = new AnimationSubView(0.05f, regions, Animation.PlayMode.NORMAL);
    actorView.addSubView(appear);/*from w w  w .  j ava  2 s.  c  o m*/
    visualizer.viewController.world.dispatcher.dispatch(ResultVisualizer.VISUALIZE_ATTACK, result.creature);
    actorView.addListener(new AnimationListener() {
        @Override
        protected void onAnimationEvent(AnimationEvent event) {
            actorView.removeListener(this);
            actorView.removeSubView(appear);
            final Image claw = new Image(regions.peek());
            actorView.addActor(claw);
            claw.setOrigin(Align.center);

            final int dx = result.target.getX() - result.creature.getX();
            final int dy = result.target.getY() - result.creature.getY();

            claw.addAction(rotateBy(360, ANIMATION_TIME));
            claw.addAction(sequence(moveBy(dx * 10, dy * 10, ANIMATION_TIME * 0.5f), run(new Runnable() {
                @Override
                public void run() {
                    String soundName = result.type.toString() + (result.success ? "-kill" : "-miss");
                    if (SoundManager.instance.soundExists(soundName)) {
                        SoundManager.instance.playSound(soundName);
                    }
                    if (result.success) {

                        visualizer.viewController.visualize(new Death(result.creature, result.target))
                                .addListener(future);
                    }
                }
            }), moveBy(-dx * 10, -dy * 10, ANIMATION_TIME * 0.5f), run(new Runnable() {
                @Override
                public void run() {
                    claw.remove();
                    Array<TextureAtlas.AtlasRegion> disappearRegions = new Array<TextureAtlas.AtlasRegion>(
                            regions);
                    disappearRegions.removeIndex(1);
                    disappearRegions.reverse();
                    final AnimationSubView disappear = new AnimationSubView(0.1f, disappearRegions,
                            Animation.PlayMode.NORMAL);
                    actorView.addSubView(disappear);
                    actorView.addListener(new AnimationListener() {
                        @Override
                        protected void onAnimationEvent(AnimationEvent event) {
                            actorView.removeSubView(disappear);
                            actorView.removeListener(this);
                            if (!result.success) {
                                future.happen();
                            }
                        }
                    });
                }
            })));
        }
    });
    return future;
}

From source file:org.ams.testapps.paintandphysics.physicspuzzle.PhysicsPuzzle.java

License:Open Source License

/**
 * Finds the vertices for the chain body that is the "ground" for the active blocks.
 * It forms an outline around the walls, floor and locked blocks.
 *//*www .j a v  a2  s  .c o m*/
private Vector2[] computeChainVertices() {

    Array<Vector2> platformVertices = new Array<Vector2>();

    platformVertices.addAll(wallVerticesForGroundBody);

    // first i find all the platforms that the locked blocks form
    Array<Array<Integer>> platforms = new Array<Array<Integer>>();
    {
        Array<Integer> platform = new Array<Integer>();
        platforms.add(platform);

        int row = platformLevels.get(0);
        int previousRow = row;
        platform.add(row);

        for (int i = 1; i < platformLevels.size; i++) {
            row = platformLevels.get(i);
            if (row != previousRow) {
                platform = new Array<Integer>();
                platforms.add(platform);
            }
            platform.add(row);

            previousRow = row;
        }
    }

    // for each platform 2 vertices is added
    // special treatment for platforms with index -1(a platform on the floor)
    // and for platforms touching the left or right wall
    int i = 0;
    int previousPlatformRow = -1;
    for (Array<Integer> platform : platforms) {
        int platformColumnBegin = i; // inclusive
        int platformColumnEnd = i + platform.size - 1; // not inclusive
        int platformRow = platform.first();

        Vector2 beginPos, endPos;

        if (platformRow >= 0) {
            PPPolygon platformBegin = getBlock(platformRow, platformColumnBegin);
            beginPos = new Vector2(platformBegin.getPhysicsThing().getBody().getPosition());
            beginPos.add(-physicsBlockDim * 0.5f, physicsBlockDim * 0.5f);

            PPPolygon platformEnd = getBlock(platformRow, platformColumnEnd);
            endPos = new Vector2(platformEnd.getPhysicsThing().getBody().getPosition());
            endPos.add(physicsBlockDim * 0.5f, physicsBlockDim * 0.5f);
        } else {
            // platform is on the floor
            // we get coordinates for an equally wide platform just
            // one row higher up, then lower height by one block height

            PPPolygon platformBegin = getBlock(0, platformColumnBegin);
            beginPos = new Vector2((Vector2) platformBegin.getUserData());
            beginPos.add(-physicsBlockDim * 0.5f, physicsBlockDim * 0.5f - blockDim);

            PPPolygon platformEnd = getBlock(0, platformColumnEnd);
            endPos = new Vector2((Vector2) platformEnd.getUserData());
            endPos.add(physicsBlockDim * 0.5f, physicsBlockDim * 0.5f - blockDim);

        }

        if (platformRow < previousPlatformRow) {
            beginPos.sub((blockDim - physicsBlockDim), 0);
        } else {
            if (platformVertices.size > 0 && platformColumnBegin != 0) {
                platformVertices.peek().add(blockDim - physicsBlockDim, 0);
            }
        }

        if (platformColumnEnd == columns - 1) {
            // platform touching right wall, adjust slightly
            endPos.add(blockDim - physicsBlockDim, 0);
        }
        if (platformColumnBegin == 0) {
            // platform touching left wall, adjust slightly
            beginPos.sub(blockDim - physicsBlockDim, 0);
        }

        // make sure i don't add vertices that are too close to the previous
        // (this is only an issue for the top row)

        boolean distanceOk = platformVertices.peek().dst(beginPos) > 0.001f;
        distanceOk &= platformVertices.first().dst(beginPos) > 0.001f;

        if (platformVertices.size == 0 || distanceOk)
            platformVertices.add(beginPos);

        distanceOk = platformVertices.peek().dst(endPos) > 0.001f;
        distanceOk &= platformVertices.first().dst(endPos) > 0.001f;

        if (platformVertices.size == 0 || distanceOk)
            platformVertices.add(endPos);

        i += platform.size;
        previousPlatformRow = platformRow;

    }

    return platformVertices.toArray(Vector2.class);
}

From source file:presentation.concretion.game.HUD.java

License:Open Source License

@Override
protected void registerListeners() {
    // PAUSE/*from www .j  a  v  a2s  .co  m*/
    this.buttonPause.addListener(new ChangeListener() {

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
            // Paused game.
            if (!isPasued) {
                processors.peek().touchDown(0, 0, 0, InputGame.Keys.PAUSE);
            }
            // Resume game.
            else {
                processors.peek().touchDown(0, 0, 0, InputGame.Keys.CONTINUE);
                buttonPause.setDisabled(true);
            }
        }
    });
    // HOME
    this.buttonHome.addListener(new ChangeListener() {

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            InputGame.getInputMultiplexer().clear();
            buttonAudio.setY(0);
            buttonAudio.setX(0);
            nextScreen = new LoadingScreen(false);
        }
    });
    // RETRY
    this.buttonRetry.addListener(new InputListener() {
        @Override
        public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
            InputGame.getInputMultiplexer().clear();
            nextScreen = new LoadingScreen(true);
            return true;
        }
    });
    // TUTORIALS
    this.buttonTutorials.addListener(new InputListener() {
        @Override
        public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
            if (!tTutorials.isVisible()) {
                tempNumberOfTutorial = -1;
                numberOfTutorial = 0;
                tTutorials.setVisible(true);
                tTutorials.toFront();
                tArrowLeft.toFront();
                tArrowRight.toFront();
            } else {
                tTutorials.setVisible(false);
                tTutorials.clear();
                tArrowRight.clear();
                tArrowLeft.clear();
                tempNumberOfTutorial = -1;
                numberOfTutorial = 0;
            }
            return true;
        }
    });
    this.nextTutorial.addListener(new ChangeListener() {

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            numberOfTutorial++;
        }
    });
    this.prevoiusTutorial.addListener(new ChangeListener() {

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            numberOfTutorial--;
        }
    });
}

From source file:presentation.concretion.game.HUD.java

License:Open Source License

private void updateSpButtons() {
    // Sp1/*  w w  w .ja  v  a2  s.  c  o m*/
    if (magic >= Hero.MAGIC_SPEND_SP1) {
        tSp1.clear();
        tSp1.center().right().padTop(-350).toFront();
        Drawable image = new TextureRegionDrawable(ResourcesHUD.buttonSp1Up);
        ImageButton sp1 = new ImageButton(image);
        tSp1.add(sp1);
        sp1.addListener(new InputListener() {
            @Override
            public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
                Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
                return processors.peek().touchDown(0, 0, 0, InputGame.Keys.SP1);
            }
        });
    } else if (magic < Hero.MAGIC_SPEND_SP1) {
        tSp1.clear();
        tSp1.center().right().padTop(-350).toFront();
        Drawable image = new TextureRegionDrawable(ResourcesHUD.buttonSp1Down);
        ImageButton sp1 = new ImageButton(image);
        tSp1.add(sp1);
    }
    // Sp2
    if (magic >= Hero.MAGIC_SPEND_SP2) {
        tSp2.clear();
        tSp2.center().right().padTop(-50).toFront();
        Drawable image = new TextureRegionDrawable(ResourcesHUD.buttonSp2Up);
        ImageButton sp2 = new ImageButton(image);
        tSp2.add(sp2);
        sp2.addListener(new InputListener() {
            @Override
            public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
                Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
                return processors.peek().touchDown(0, 0, 0, InputGame.Keys.SP2);
            }
        });
    } else if (magic < Hero.MAGIC_SPEND_SP2) {
        tSp2.clear();
        tSp2.center().right().padTop(-50).toFront();
        Drawable image = new TextureRegionDrawable(ResourcesHUD.buttonSp2Down);
        ImageButton sp2 = new ImageButton(image);
        tSp2.add(sp2);
    }
    // Sp3
    if (magic >= Hero.MAGIC_SPEND_SP3) {
        tSp3.clear();
        tSp3.center().right().padTop(250).toFront();
        Drawable image = new TextureRegionDrawable(ResourcesHUD.buttonSp3Up);
        ImageButton sp3 = new ImageButton(image);
        tSp3.add(sp3);
        sp3.addListener(new InputListener() {
            @Override
            public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
                Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
                return processors.peek().touchDown(0, 0, 0, InputGame.Keys.SP3);
            }
        });
    } else if (magic < Hero.MAGIC_SPEND_SP3) {
        tSp3.clear();
        tSp3.center().right().padTop(250).toFront();
        Drawable image = new TextureRegionDrawable(ResourcesHUD.buttonSp3Down);
        ImageButton sp3 = new ImageButton(image);
        tSp3.add(sp3);
    }
}

From source file:presentation.concretion.game.HUD.java

License:Open Source License

private void registerListenersMobilePhone() {
    // Control/*from  w w  w .j  ava2  s .c o  m*/
    this.control.addListener(new ChangeListener() {

        @Override
        public void changed(ChangeEvent event, Actor actor) {
            int x = Math.round(control.getKnobPercentX());
            Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
            processors.peek().touchDown(x, 0, 0, InputGame.Keys.PAD);
        }
    });

    // Attack
    this.buttonAttack.addListener(new InputListener() {
        @Override
        public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
            Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
            return processors.peek().touchDown(0, 0, 0, InputGame.Keys.ATTACK);
        }
    });

    // Jump
    this.buttonJump.addListener(new InputListener() {
        @Override
        public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
            Array<InputProcessor> processors = InputGame.getInputMultiplexer().getProcessors();
            return processors.peek().touchDown(0, 0, 0, InputGame.Keys.JUMP);
        }
    });
}