java - 使用 MVC 布局实现游戏状态？

Question

您好，我正在创建一个基本游戏并尝试用我的代码实现 MVC 模式。我目前有:型号游戏对象、云、船水等。

世界这将所有模型联系在一起并定义对象

世界渲染器这会将所有纹理应用于对象

游戏画面这处理用户输入、触摸或键盘。

我的问题是如何以及在哪里实现游戏状态？我假设它会进入 GameScreen，但我已经实现了状态的基本布局，READY，RUNNING，PAUSED，NEXT_LVL，GAME_OVER，

但是我发现当出现“READY”状态时，游戏正在后台运行？

这是在世界渲染器中定义的，即水等级在背景中的屏幕上上升，但我希望这种情况仅在游戏状态切换到运行时发生。

当 Gamstate 切换到运行状态时，如何让 Gamestate 仅初始化 WorldRenderer。我已将语句 renderer.render(); 应用到 RUNNING 语句中，但它仍然在 READY 状态下运行。

对此的任何帮助将不胜感激。

干杯

丹尼尔。

我正在附加 WorldRenderer、World 和 GameScreen 类

GameScreen Class


    import com.badlogic.gdx.Gdx;

    import com.badlogic.gdx.Input.Keys;

    import com.badlogic.gdx.Screen;
    import com.badlogic.gdx.graphics.GL10;
    import com.badlogic.gdx.graphics.OrthographicCamera;
    import com.badlogic.gdx.graphics.Texture;
    import com.badlogic.gdx.graphics.Texture.TextureFilter;
    import com.badlogic.gdx.graphics.g2d.SpriteBatch;
    import com.badlogic.gdx.graphics.g2d.TextureRegion;

    import com.badlogic.gdx.math.Rectangle;
    import com.badlogic.gdx.math.Vector3;




    public class GameScreen implements Screen {

    enum State{
        READY,RUNNING,PAUSED,LEVEL_END,GAME_OVER
    }


    MainThing game;


    OrthographicCamera cam;
    SpriteBatch batch;

    Texture pauseMenu;
    TextureRegion pauseMenuR;

    Texture pauseBtn;

    Texture ready;
    TextureRegion readyR;

    private World world;
    private WorldRenderer renderer;

    public static State state = State.READY;


    public GameScreen(MainThing game){

        this.game = game;
        cam = new OrthographicCamera(800,480);
        cam.position.set(800/2, 480/2, 0);
        batch = new SpriteBatch();
        state = State.READY;

        loadingTexture();

    }





    private void loadingTexture() {

        pauseBtn = Assets.manager.get("pause.png", Texture.class);

        pauseMenu = Assets.manager.get("resume-quit.png", Texture.class);
        pauseMenu.setFilter(TextureFilter.Linear, TextureFilter.Linear);
        pauseMenuR = new TextureRegion(pauseMenu,0,0,375,256);

        ready = Assets.manager.get("ready.png",Texture.class);
        readyR = new TextureRegion(ready,0,0,256,105);
    }


    public static void setState(State newState){
        state = newState;
    }





    private void update(float delta) {

        switch (state) {
        case READY:
            updateReady();
            break;
        case RUNNING:
            updateRunning(delta);
            break;
        case PAUSED:
            updatePaused();
            break;
        case LEVEL_END:
            updateLevelEnd();
            break;
        case GAME_OVER:
            updateGameOver();
            break;
        }

    }



    private void updateReady() {
        if (Gdx.input.justTouched()) {
            state = State.RUNNING;
        }

    }

    private void updateRunning(float delta) {

        if(Gdx.input.isTouched()) {
             Vector3 touchPos = new Vector3();
             touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
             WorldRenderer.cam.unproject(touchPos);
             Boat.position.x = touchPos.x - 1f / 2;
          }



        if(Gdx.input.isKeyPressed(Keys.LEFT)) {

        Boat.velocity.x = -Boat.SPEED * delta;
        }


        else if(Gdx.input.isKeyPressed(Keys.RIGHT)) {

            Boat.velocity.x = Boat.SPEED * delta;
          }
        else if(!Gdx.input.isKeyPressed(Keys.LEFT) && !(Gdx.input.isKeyPressed(Keys.RIGHT)) || (Gdx.input.isKeyPressed(Keys.LEFT) && (Gdx.input.isKeyPressed(Keys.RIGHT)))) {

            Boat.velocity.x = 0;
            }

          Boat.update(delta);

          if(Boat.position.x < 0) Boat.position.x = 0;
          if(Boat.position.x > WorldRenderer.cam.viewportWidth - 1f) Boat.position.x = WorldRenderer.cam.viewportWidth - 1f;


    }




    private void updatePaused() {
        // TODO Auto-generated method stub

    }





    private void updateLevelEnd() {
        // TODO Auto-generated method stub

    }





    private void updateGameOver() {
        // TODO Auto-generated method stub

    }





    private void draw(float deltaTime) {

        Gdx.gl.glClearColor(1, 1, 1, 1);
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
        renderer.render(deltaTime);
        cam.update();
        batch.setProjectionMatrix(cam.combined);
        batch.begin();

        switch (state) {
        case READY:
            presentReady();
            break;
        case RUNNING:
            presentRunning(deltaTime);
            break;
        case PAUSED:
            presentPaused();
            break;
        case LEVEL_END:
            presentLevelEnd();
            break;
        case GAME_OVER:
            presentGameOver();
            break;
        }
        batch.end();
    }




    private void presentReady() {
        batch.draw(readyR, cam.viewportWidth /2 - 375 /2    , cam.viewportHeight /2 - 256 /2,375,256);

    }





    private void presentRunning(float delta) {
        // TODO Auto-generated method stub

    }





    private void presentPaused() {
        // TODO Auto-generated method stub

    }





    private void presentLevelEnd() {
        // TODO Auto-generated method stub

    }





    private void presentGameOver() {
        // TODO Auto-generated method stub

    }




    @Override
    public void render(float delta) {

        update(delta);
        draw(delta);



    }






    @Override
    public void resize(int width, int height) {
        renderer.setSize(width,height);

    }

    @Override
    public void show() {
        world = new World();
        renderer = new WorldRenderer(world, false);


    }

    @Override
    public void hide() {


    }

    @Override
    public void pause() {
        dispose();

    }

    @Override
    public void resume() {


    }

    @Override
    public void dispose() {
        Assets.unload();


        Boat.dispose();
        Cloud.dispose();
        WorldRenderer.dispose();


    }



}

世界级

  package com.inspirednotion.thing;

import com.badlogic.gdx.math.MathUtils;

import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.TimeUtils;



public class World {

Boat boat;
Water water;
Cloud cloud;
long lastDropTime;
Array<Rain> raindrops = new Array<Rain>();


public Array<Rain> getRain(){
     return raindrops;

}

 Boat getBoat(){
    return boat;
}
public Water getWater(){
    return water;
}

public Cloud getCloud(){
    return cloud;
}


public World(){

    createWorld();
    spawnRaindrop();
    lastDropTime = TimeUtils.nanoTime();
}

private void createWorld() {
    boat = new Boat(new Vector2(WorldRenderer.CAMERA_WIDTH / 2 - Boat.BOAT_WIDTH / 2, Water.position.y +11.3f ));
    cloud = new Cloud(new Vector2(WorldRenderer.CAMERA_WIDTH / 2 - Cloud.CLOUD_WIDTH /2, 8));
    water = new Water(new Vector2(WorldRenderer.CAMERA_WIDTH /2 - Water.WATER_WIDTH/2, -11.3f));




}
void spawnRaindrop(){
raindrops.add( new Rain(new Vector2(MathUtils.random(cloud.position.x, cloud.position.x + Cloud.CLOUD_WIDTH ),cloud.position.y)));
lastDropTime = TimeUtils.nanoTime();
}

public static void dispose() {


}
}

世界渲染器类

public class WorldRenderer {

    private static World world;
    public static OrthographicCamera cam;

    ShapeRenderer debugRenderer = new ShapeRenderer();

     static final float CAMERA_WIDTH = 20f;
    static final float CAMERA_HEIGHT = 12f;

    static Texture cloudTexture;
    private TextureRegion cR;
    static Texture boatAniTex;
    TextureRegion[]                 boatFrames;
    Animation                       boatAnimation;
    TextureRegion                   boatCurrentFrame;
    static TextureRegion                   currentFrameBoat;
    TextureRegion[][]               tmpBoat;

    static Texture cloudBg;
    private TextureRegion cloudBgR;


    static Texture rainDrop;
    long lastDropTime;
    float lastDropT;


    private static Texture water;
    TextureRegion[]                 waveFrames;
    Animation                       waveAnimation;
    TextureRegion                   currentFrame;
    TextureRegion                   currentFrameWav;
    TextureRegion[][]               tmp;

    float stateTime = 0f; 

    private static SpriteBatch batch;

    static int width;
     static int height;

    public void setSize(int w, int h){
        WorldRenderer.width= w;
        WorldRenderer.height = h;
    }



    public WorldRenderer(World world, boolean debug){

        WorldRenderer.world = world;
        WorldRenderer.cam = new OrthographicCamera(CAMERA_WIDTH ,CAMERA_HEIGHT);
        WorldRenderer.cam.position.set(CAMERA_WIDTH /2f, CAMERA_HEIGHT /2f, 0);
        WorldRenderer.cam.update();
        batch = new SpriteBatch();
        loadTextures();
        loadAnimations();




    }





    public void loadTextures(){
        boatAniTex = Assets.manager.get("bin.png", Texture.class);
        boatAniTex.setFilter(TextureFilter.Linear, TextureFilter.Linear);
        cloudTexture = Assets.manager.get("cloud.png", Texture.class);
        cloudTexture.setFilter(TextureFilter.Linear, TextureFilter.Linear);
        cR = new TextureRegion(cloudTexture,0,0,256,140);
        cloudBg = Assets.manager.get("cloudbg.png", Texture.class);
        cloudBg.setFilter(TextureFilter.Linear, TextureFilter.Linear);
        cloudBgR = new TextureRegion(cloudBg,0,0,800,480);
        water = Assets.manager.get("wavey.png", Texture.class);
        water.setFilter(TextureFilter.Linear, TextureFilter.Linear);
        rainDrop = new Texture(Gdx.files.internal("RainDrop_sml.png"));
    }


    private void loadAnimations() {

        water.setFilter(TextureFilter.Linear, TextureFilter.Linear);

        tmp = new TextureRegion(water).split(800,480);                                
        waveFrames = new TextureRegion[14];
        for (int x = 0, index = 0; x < 7; x++) {
            for (int y = 0; y < 2; y++, index++) {
               waveFrames[index] = tmp[x][y];
            }
         }

        waveAnimation = new Animation(0.14f, waveFrames); 

        //************************

boatAniTex.setFilter(TextureFilter.Linear, TextureFilter.Linear);

        tmpBoat = new TextureRegion(boatAniTex).split(64,64);                                
        boatFrames = new TextureRegion[7];
        for (int x = 0, indexed = 0; x < 1; x++) {
            for (int y = 0; y < 7; y++, indexed++) {
               boatFrames[indexed] = tmpBoat[x][y];
            }
         }

        boatAnimation = new Animation(0.2f, boatFrames); 

    }


    public void render(float delta){
        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
        batch.setProjectionMatrix(cam.combined);
        stateTime += Gdx.graphics.getDeltaTime();  
        currentFrameWav = waveAnimation.getKeyFrame(stateTime += delta, true);
        currentFrameBoat = boatAnimation.getKeyFrame(stateTime += delta, true);
        batch.begin();


        batch.disableBlending();
        drawBackGround();
        batch.enableBlending();
        drawBoat();

        drawWater(delta);
        drawCloud();


        batch.end();
        drawRain();
    }





    private void drawRain() {
        batch.begin();
        for(  Rain bounds: world.raindrops) {
             batch.draw(rainDrop, bounds.position.x ,  bounds.position.y,.2f,.2f);

        }
        batch.end();
        if(TimeUtils.nanoTime() - world.lastDropTime >  500000000) world.spawnRaindrop();




        Iterator<Rain> iter = world.raindrops.iterator();
          while(iter.hasNext()) {
             Rain raindrop = iter.next();
             raindrop.position.y -=2f * Gdx.graphics.getDeltaTime();
            if(raindrop.position.y < Water.position.y  ) {
                System.out.println("water is hit");
                iter.remove();
            }
          }
    }



    private void drawWater(float delta) {
        batch.draw(currentFrameWav, Water.position.x , Water.position.y ,Water.WATER_WIDTH , Water.WATER_HEIGHT );
        if (Water.position.y < -4f){
            Water.position.y += .1 * Gdx.graphics.getDeltaTime();
            Boat.position.y += .1 * Gdx.graphics.getDeltaTime();
        }
    }



    private void drawBackGround() {

        batch.draw(cloudBgR, 0,0,CAMERA_WIDTH,CAMERA_HEIGHT);

    }



    private void drawCloud(){
        Cloud cloud = world.getCloud();
         batch.draw(cR,cloud.position.x ,cloud.position.y ,Cloud.CLOUD_WIDTH , Cloud.CLOUD_HEIGHT );
    }


    private void drawBoat(){
        world.getBoat();
         batch.draw(currentFrameBoat, Boat.position.x , Water.position.y +11.3f,Boat.BOAT_WIDTH , Boat.BOAT_HEIGHT );
    }








    private void drawDebug(){
        debugRenderer.setProjectionMatrix(cam.combined);
        debugRenderer.begin(ShapeType.Rectangle);

        Cloud cloud = world.getCloud();
        Rectangle rect =  cloud.bounds;
        float x1 = cloud.position.x + rect.x;
        float y1 = cloud.position.y + rect.y;
        debugRenderer.setColor(new Color(1,0,0,1));
        debugRenderer.rect(x1, y1, rect.width, rect.height);

        Boat boat = world.getBoat();
        Rectangle rec =  boat.bounds;
        float xx1 = Boat.position.x + rec.x;
        float yx1 = Boat.position.y + rec.y;
        debugRenderer.setColor(new Color(1,1,0,1));
        debugRenderer.rect(xx1, yx1, rec.width, rec.height);

        debugRenderer.end();
    }




public static   void dispose(){
    cloudTexture.dispose();
    water.dispose();
    boatAniTex.dispose();
    rainDrop.dispose();
    cloudBg.dispose();
    batch.dispose();

}
}

请原谅困惑的代码..正在清理和调试问题..

Answer 1

底线:您的 GameScreen 处于 READY 状态，但您的 WorldRenderer 并不知道这一点，并继续其快乐的方式。您需要确保您的 WorldRenderer 具有映射到 GameScreen 状态的状态。

您在 GameScreen.draw() 中对 renderer.render(deltaTime) 的调用是罪魁祸首。无论 GameScreen 中的状态如何，它都会始终更新事物的位置。

假设所需的效果是在后台绘制游戏，但游戏尚未开始 -

1. 向 WorldRenderer 添加一个状态枚举，该状态枚举至少处于 WAITING 和 PLAYING 状态，并具有此枚举类型的字段。确保在 WorldRenderer 中创建了一个公共(public)方法，允许 GameScreen 设置此值。
2. 当GameScreen创建WorldRenderer时，请确保调用WorldRenderer状态并将其设置为WAITING。
3. 当GameScreen转换到播放状态时，调用WorldRenderer状态并将其设置为PLAYING。
4. 在 WorldRenderer 中，仔细定义在 WAITING 状态、PLAYING 状态以及这两种状态下需要执行的操作。在这种情况下，您不希望水位上升，因此如果您处于 WAITING 状态，请不要更改水位和船的高度。