java - 让我的圆圈随机消失，并在随机几秒后再次出现

Question

所以我正在制作非常简单的游戏。游戏是关于一些人在岩石(圆圈)上跳跃，岩石有时会被水覆盖，当它们被水覆盖时，你不能站在它们上面，否则你会掉进水里淹死。我被困在需要让那些岩石消失(被水覆盖)的地方。所以我需要在随机的时间让它们消失，随机的几秒(不要太长)让它们“隐形”，然后它们再次需要出现。我还是个初学者，我会很感激任何类型的答案，但如果你能向我解释它，我会很兴奋。这是我的代码:我的主课

package com.pitcher654.main;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyListener;
import java.awt.image.BufferStrategy;
import java.util.Random;

import com.pitcher654.main.Game.STATE;

public class Game extends Canvas implements Runnable{

private static final long serialVersionUID = -7800496711589684767L;

public static final int WIDTH = 640, HEIGHT = WIDTH / 12 * 9;

private Thread thread;
private boolean running = false;

private Random r;
private Handler handler;
//private HUD hud;
private Menu menu;

public enum STATE {
    Menu,
    Help,
    Game
};

public STATE gameState = STATE.Menu;

public Game() {
    handler = new Handler();
    menu = new Menu(this, handler);
    this.addKeyListener(new KeyInput(handler));
    this.addMouseListener(menu);
    new Window(WIDTH, HEIGHT, "My game", this);

    //hud = new HUD();
    r = new Random();

    if(gameState == STATE.Game) {
        //handler.addObject(new Player(100, 200, ID.Player));
    }

    //handler.addObject(new Player(100, 200, ID.Player));
    //handler.addObject(new BasicEnemy(100, 200, ID.BasicEnemy));

}

public synchronized void start() {
    thread = new Thread(this);
    thread.start();
    running = true;
}

public synchronized void stop() {
    try {
        thread.join();
        running = false;
    }catch(Exception ex) { ex.printStackTrace(); }
}

public void run()
{
    this.requestFocus();
    long lastTime = System.nanoTime();
    double amountOfTicks = 60.0;
    double ns = 1000000000 / amountOfTicks;
    double delta = 0;
    long timer = System.currentTimeMillis();
    int frames = 0;
    while(running)
    {
                long now = System.nanoTime();
                delta += (now - lastTime) / ns;
                lastTime = now;
                while(delta >=1)
                        {
                            tick();
                            delta--;
                        }
                        if(running)
                            render();
                        frames++;

                        if(System.currentTimeMillis() - timer > 1000)
                        {
                            timer += 1000;
                            //System.out.println("FPS: "+ frames);
                            frames = 0;
                        }
    }
            stop();
 }  

private void tick() {
    handler.tick();
    //hud.tick();
    if(gameState == STATE.Game) {

    }else if(gameState == STATE.Menu) {
        menu.tick();
    }
}

private void render() {
    BufferStrategy bs = this.getBufferStrategy();
    if(bs == null) {
        this.createBufferStrategy(3);
        return;
    }

    Graphics g = bs.getDrawGraphics();

    g.setColor(new Color(87, 124, 212));
    g.fillRect(0, 0, WIDTH, HEIGHT);
    if(gameState == STATE.Game) {
        g.setColor(new Color(209, 155, 29));
        for(int i = 0; i < 5; i++) {
            g.fillOval(80 + (100 * i), 325, 70, 20);
        }
    }else if(gameState == STATE.Menu || gameState == STATE.Help){
        menu.render(g);
    }

    handler.render(g);

    if(gameState == STATE.Game) {

    }
    //hud.render(g);

    g.dispose();
    bs.show();
}

public static int clamp(int var, int min, int max) {
    if(var >= max)
        return var = max;
    else if(var <= max)
        return var = min;
    else 
        return var;
}

public static void main(String[] args) {
    new Game();
}
}

我在其中创建播放器的播放器类:

package com.pitcher654.main;

import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;

import com.pitcher654.main.Game.STATE;

public class Player extends GameObject {

    Random r = new Random();

public Player(int x, int y, ID id) {
    super(x, y, id);
    //velX = r.nextInt(5) + 1;
    //velY = r.nextInt(5);
}

public void tick() {
    x += velX;
    y += velY;
    //System.out.println(x);
    if(x == 500) x = 500;
}

public void render(Graphics g) {
    if(id == ID.Player) g.setColor(Color.white);
    if(id == ID.Player2) g.setColor(Color.blue);
    g.fillRect(x, y, 32, 32);
    g.drawLine(x + 15, y, x + 15, y + 100);
    g.drawLine(x + 15, y + 100, x, y + 135);
    g.drawLine(x + 15, y + 100, x + 33, y + 135);
    g.drawLine(x + 15, y + 70, x - 35, y + 30);
    g.drawLine(x + 15, y + 70, x + 65, y + 30);
    /*if(game.gameState == STATE.Menu) {
        g.setColor(new Color(87, 124, 212));
        g.fillRect(0, 0, Game.WIDTH, Game.HEIGHT);
    }*/
}


}

还有我的游戏对象类:

package com.pitcher654.main;

import java.awt.Graphics;

public abstract class GameObject {

protected static int x, y;
protected ID id;
protected int velX, velY;

public GameObject(int x, int y, ID id) {
    this.x = x;
    this.y = y;
    this.id = id;
}

public abstract void tick();
public abstract void render(Graphics g);

public void setX(int x) {
    this.x = x;
}
public void setY(int y) {
    this.y = y;
}
public int getX() {
    return x;
}
public int getY() {
    return y;
}
public void setID(ID id) {
    this.id = id;
}
public ID getID() {
    return id;
}
public void setVelX(int velX) {
    this.velX = velX;
}
public void setVelY(int velY) {
    this.velY = velY;
}
public int getVelX() {
    return velX;
}
public int getVelY() {
    return velY;
}
}

如果您需要任何其他类(class)，请告诉我，我会将其发布。

Answer 1

您应该存储游戏中每个石头的状态。

因此，如果您给定了石头数量 (5)，请使用该数量创建一个常量字段。然后创建一个 ### boolean 值数组，您将在其中保存每 block 石头的状态。然后创建一个“时间”数组，当石头改变它们的可见性时。

private static final int NUM_STONES = 5; // you can change the # of the stones here
private boolean[] visible = new int[NUM_STONES];
private long[] changeTimes = new long[NUM_STONES];

在游戏的 init 方法中初始化值。

for(int i=0; i<NUM_STONES; i++){
    visible[i] = true; // each stone will be visible
    changeTimes[i] = System.currentTimeMillis() + r.nextInt(10000); // every stone will disappear in less than 10 seconds
}

在您的更新方法(我想是 tick() )中更新可见性状态。

long now = System.currentTimeMillis();
for(int i=0; i<NUM_STONES; i++){
    if(now < changeTimes[i]){ // if the time has come
        if(visible[i]) changeTimes[i] = now + r.nextInt(5000); // every stone will be invisible up to five seconds
        else changeTimes[i] = now + r.nextInt(10000); // every stone will be visible again up to 10 seconds
        visible[i] = !visible[i]; // switch the visibility state
   }
}

最后将条件添加到渲染方法中:

if(gameState == STATE.Game) {

    for(int i = 0; i < NUM_STONES; i++) {
        if(visible[i] g.setColor(new Color(209, 155, 29));
        else g.setColor(new Color(107, 155, 170));
        g.fillOval(80 + (100 * i), 325, 70, 20);
    }
}

应该是这样。接下来您应该做的是将魔数(Magic Number)提取到常量中，就像我向您展示的 NUM_STONES 一样。并且不要像我之前写的那样每次渲染石头并创建颜色实例时都创建 Color 类的新实例。

另请注意，有些石头会在很短的时间内消失(并再次出现) - 您可以在更新方法中的changeTimes[i]中添加几秒钟，以确保每个石头至少在一段时间内可见(不可见)这么多时间。