让我的圈子随机消失，并在随机秒后再次出现

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;
}
}

如果您需要其他课程，请告诉我，我将其发布。

Answer 1

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

因此，如果您给定了宝石数（5），请使用此数字创建一个常数字段。 然后创建一个###布尔值数组，您将在其中保存每个宝石的状态。 然后，在石头将改变其可见性时创建一个“时间”数组。

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
   }
}

最后将条件添加到render方法：

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);
    }
}

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

还要注意，一些石头会在很短的时间内消失（并再次出现）-您可以在更新方法中的changeTimes [i]中添加几秒钟，以确保至少在此数量的石头上（看不见）每块石头时间。