LibGDX在游戏中暂停图像

Question

i am new to libgdx and i have tried several ways to adding pause function and image. Can anyone correct my mistakes? i am stuck

package com.badlogic.drop;

import java.util.Iterator;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.audio.Music;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.TimeUtils;

public class GameScreen implements Screen {
final Drop game;

Texture dropImage;
Texture bucketImage;
Texture pauseImage;
Sound dropSound;
Music rainMusic;
OrthographicCamera camera;
Rectangle bucket;
Rectangle pause;
Array<Rectangle> raindrops;
long lastDropTime;
int dropsGathered;

public GameScreen(final Drop gam) {
    this.game = gam;

    // load the images for the droplet and the bucket, 64x64 pixels each
    dropImage = new Texture(Gdx.files.internal("droplet.png"));
    bucketImage = new Texture(Gdx.files.internal("bucket.png"));
    pauseImage = new Texture(Gdx.files.internal("pause.png"));
    // load the drop sound effect and the rain background "music"
    dropSound = Gdx.audio.newSound(Gdx.files.internal("drop.wav"));
    rainMusic = Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));
    rainMusic.setLooping(true);

    // create the camera and the SpriteBatch
    camera = new OrthographicCamera();
    camera.setToOrtho(false, 800, 480);

    // create a Rectangle to logically represent the bucket
    bucket = new Rectangle();
    bucket.x = 800 / 2 - 64 / 2; // center the bucket horizontally
    bucket.y = 20; // bottom left corner of the bucket is 20 pixels above
    // the bottom screen edge
    bucket.width = 64;
    bucket.height = 64;

    pause = new Rectangle();
    pause.x =700;
    pause.y =380;
    pause.width = 64;
    pause.height = 64;

    // create the raindrops array and spawn the first raindrop
    raindrops = new Array<Rectangle>();
    spawnRaindrop();
}

private void spawnRaindrop() {
    Rectangle raindrop = new Rectangle();
    raindrop.x = MathUtils.random(0, 800 - 64);
    raindrop.y = 480;
    raindrop.width = 64;
    raindrop.height = 64;
    raindrops.add(raindrop);
    lastDropTime = TimeUtils.nanoTime();
}

public enum State{Running,Paused}
State state = State.Running;
@Override
public void render(float delta) {
    switch(state) {
        case Running:
            update();
            break;
        case Paused:
            Gdx.graphics.setContinuousRendering(false);
            break;
    }
    draw();
}
public void update(){
    Gdx.graphics.requestRendering();
}
public void draw(){// clear the screen with a dark blue color. The
    // arguments to glClearColor are the red, green
    // blue and alpha component in the range [0,1]
    // of the color to be used to clear the screen.
    Gdx.gl.glClearColor(0, 0, 0.2f, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    // tell the camera to update its matrices.
    camera.update();

    // tell the SpriteBatch to render in the
    // coordinate system specified by the camera.
    game.batch.setProjectionMatrix(camera.combined);

    // begin a new batch and draw the bucket and
    // all drops
    game.batch.begin();
    game.font.draw(game.batch, "Drops Collected: " + dropsGathered, 0, 480);
    game.batch.draw(bucketImage, bucket.x, bucket.y);
    game.batch.draw(pauseImage, pause.x, pause.y);
    for (Rectangle raindrop : raindrops) {
        game.batch.draw(dropImage, raindrop.x, raindrop.y);
    }
    game.batch.end();

How to code the button into game`

    // process user input
    if (Gdx.input.isTouched()) {
        Vector3 touchPos = new Vector3();
        touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
        camera.unproject(touchPos);
        bucket.x = touchPos.x - 64 / 2;
    }
    if (Gdx.input.isKeyPressed(Keys.LEFT))
        bucket.x -= 200 * Gdx.graphics.getDeltaTime();
    if (Gdx.input.isKeyPressed(Keys.RIGHT))
        bucket.x += 200 * Gdx.graphics.getDeltaTime();

    // make sure the bucket stays within the screen bounds
    if (bucket.x < 0)
        bucket.x = 0;
    if (bucket.x > 800 - 64)
        bucket.x = 800 - 64;

    // check if we need to create a new raindrop
    if (TimeUtils.nanoTime() - lastDropTime > 1000000000)
        spawnRaindrop();

    // move the raindrops, remove any that are beneath the bottom edge of
    // the screen or that hit the bucket. In the later case we play back
    // a sound effect as well.
    Iterator<Rectangle> iter = raindrops.iterator();
    while (iter.hasNext()) {
        Rectangle raindrop = iter.next();
        raindrop.y -= 200 * Gdx.graphics.getDeltaTime();
        if (raindrop.y + 64 < 0)
            iter.remove();
        if (raindrop.overlaps(bucket)) {
            dropsGathered++;
            dropSound.play();
            iter.remove();
        }
    }}   

@Override
public void hide() {
}

@Override
public void pause() {
}

@Override
public void resume() {
}  

CRY

Answer 1

There are several improvements to be made.

Pausing the game

It is common practise to create a new method called update , where you can dump all logic inside of (like moving the textures). You call this method from your render loop. If you wouldn't call this method if the game is paused.

I see you've already done this. You do not need to call any of those setContinuousRendering methods. Your statemachine should work. You could also opt to just use a boolean ( isPaused for example).

I haven't seen a method to set the state to Paused, so I don't know how you want to test your pause system. You'll have to make a button or use console input or just pause immediately to test it.

Sprites

I recommend you use Sprites instead of manually creating rectangles with textures, it makes your life a lot easier. Sprites are basically textures + rectangles and some rendering code.

Performance

I would call Gdx.graphics.getDeltaTime() once, then save the return value inside a variable. This way the method doesn't get called for everything you need the value for.

You use TimeUtils.nanoTime() . I personally use Java's System.currentTimeMillis() , since it is a 100x higher value. This way you don't have to type all those zeroes.

The render method gets called automatically because you are using Scene2D. It has a parameter called delta. You can use this variable instead of manually making one. Just change your update() method to update(float delta) and pass the variable.

In your draw method, you update the camera. If you don't move the camera, this is redundant.

Good luck with your game!

Edit : I misread your question. You can use Scene2D to create a button. This button will fire an event you can use to set the Paused state. You are creating your game inside of a Screen, you should use a Stage instead. Look up some more about Scene2D.

Edit 2 : Formatting