Java 我如何在游戏中显示时间

我现在正在做一个下降方块游戏。我需要一个记分系统，但我不知道如何将它集成到游戏框架中并显示出来

我的问题是如何制作一个向上计数的计时器，并将其实时显示在游戏画面上

我的代码：

package GamePackage;


import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.audio.AudioPlayer;
import sun.audio.AudioStream;
import javax.swing.ImageIcon;

public class Game extends JPanel { 

    //changing these values will change the size of the game, while still remaining functional
    //within the size limit specified.
    public static final int WINDOW_WIDTH = 875;
    public static final int WINDOW_HEIGHT = 720;
    private Timer countdownTimer;

    private javax.swing.JLabel lblTimer;
    private String Highscore = "";

    private int count;
    int Health  = 1;

    //Creates a Square object Array
    Square[] squareArray = new Square[20];
    //Triangle[] TriangleArray = new Triangle[10];

   Player thePlayer = new Player();


    public Game() {

        //initializes square objects

        for (int i = 0; i < squareArray.length; i++)
            squareArray[i] = new Square();


    }

     public static void music(){
        try{
            AudioStream Music = new AudioStream (new FileInputStream("/SplashDemoPackage/URF.wav"));
            AudioPlayer.player.start(Music);
        }catch (IOException error){}
    }

   private void StartGame(){
               count = 14;
         countdownTimer = new Timer(1000,new ActionListener() {
             public void actionPerformed(ActionEvent e) {
               lblTimer.setText(Integer.toString(count));
               count = count -1;
               if(count<0){
               lblTimer.setText("0");
               }
         }
    });
    countdownTimer.start();
   }


    public void paint(Graphics graphics) {


        graphics.setColor(Color.WHITE); 
        graphics.fillRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);

        //paints square objects to the screen


        for (Square aSquareArray : squareArray) {
            aSquareArray.paint(graphics);    
        }

      //   for (Triangle aTriangleArray : TriangleArray) {
      //      aTriangleArray.paint(graphics);    
       // }

        thePlayer.paint(graphics); 

  //      if(Highscore.equals("")){
//            Highscore = this.GetHighScore();
   //     }

    }

  //  public void DrawScore(Graphics g){
   //     g.drawString("Score: " + score, 0, B);
  //      g.drawString("HighScore: " + HighScore, 0,);
  //  }

    public void update() {

       // calls the Square class update method on the square objects
         if(Health > 0){

         for (Square aSquareArray : squareArray) aSquareArray.update();
         }

            // if(Health > 0){

        // for (Triangle aTriangleArray : TriangleArray) aTriangleArray.update();
        // }

    }



      private void mouseMove(MouseEvent evt) {
          if(Health > 0){
          thePlayer.PlayerMove(evt);  
         }
    } 


   public void collision(){
     Rectangle rectangle1 = thePlayer.bounds();//player rectangle 
     for (Square square: squareArray) { 
        if(square.GetBounds().intersects(rectangle1)){//testing all squares vs player
            Health = Health - 1;
           System.out.println("HIT");

             if (Health == 0){
                    System.out.println("LOST");

             }
        }  
    } 

      //    for (Triangle triangle: TriangleArray) { 
    //   if(triangle.GetBounds().intersects(rectangle1)){//testing all triangles vs player
     //       Health = Health - 1;
      //     System.out.println("HIT");

       //      if (Health == 0){
        //            System.out.println("LOST");

       //      }
      //  }  
   // } 

 }

 private static void GUI() throws InterruptedException {

        Game game = new Game();
        Player thePlayer = new Player();

        JLabel lblStart = new JLabel();
        JFrame frame = new JFrame();
        frame.add(game); 
        frame.setVisible(true);
        frame.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setTitle("Dodge The Squares");
        frame.setResizable(false);
        frame.setLocationRelativeTo(null);





         BufferedImage cursorImg = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);

// Create a new blank cursor.
Cursor blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(
    cursorImg, new Point(0, 0), "blank cursor");

// Set the blank cursor to the JFrame.
frame.getContentPane().setCursor(blankCursor);



              frame.addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
            public void mouseMoved(java.awt.event.MouseEvent evt) {
                mouseMove(evt); 
            } 

            private void mouseMove(MouseEvent evt){
                game.mouseMove(evt); 
            }
        });


        while (true) {
            game.update();
            game.repaint();  
            game.collision();


            Thread.sleep(10);
        }

 }

  public void DrawScore(Graphics g) throws InterruptedException{

        while (true) {
            int time = 0; 
           time = time + 1;
            g.drawString("Score: " + time, 0, WINDOW_WIDTH * WINDOW_HEIGHT + 10); 

            Thread.sleep(1000);
        }

  }

    public static void main(String[] args) throws InterruptedException {
         new Scoreboards().setVisible(true); 
        music(); 
            GUI();

    }       
}

package；
导入javax.swing.*；
导入java.awt.*；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.KeyEvent；
导入java.awt.event.MouseEvent；
导入java.awt.image.buffereImage；
导入java.io.BufferedReader；
导入java.io.FileInputStream；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.logging.Level；
导入java.util.logging.Logger；
导入sun.audio.AudioPlayer；
导入sun.audio.AudioStream；
导入javax.swing.ImageIcon；
公共类游戏扩展了JPanel{
//更改这些值将改变游戏的大小，同时仍然保持功能
//在指定的大小限制内。
公共静态最终整数窗口_宽度=875；
公共静态最终int窗口_高度=720；
私人定时器倒计时；
私有javax.swing.JLabel lblTimer；
私有字符串Highscore=“”；
私人整数计数；
int-Health=1；
//创建方形对象数组
Square[]squareArray=新的Square[20]；
//三角形[]三角形光线=新三角形[10]；
Player thePlayer=新玩家（）；
公共游戏（）{
//初始化方形对象
for（int i=0；i0）{
//对于（Triangle aTriangleArray:TriangleArray）aTriangleArray.update（）；
// }
}
私有无效mouseMove（MouseEvent evt）{
如果（运行状况>0）{
玩家移动（evt）；
}
} 
公众利益冲突（）{
矩形矩形1=thePlayer.bounds（）；//播放器矩形
对于（平方：平方数组）{
如果（square.GetBounds（）与（rectangle1）相交，{//测试所有方块对玩家
健康=健康-1；
System.out.println（“命中”）；
如果（运行状况==0）{
系统输出打印项次（“丢失”）；
}
}  
} 
//对于（三角形：三角形光线）{
//如果（triangle.GetBounds（）.intersects（rectangle1））{//测试所有三角形与播放器
//健康=健康-1；
//System.out.println（“命中”）；
//如果（运行状况==0）{
//系统输出打印项次（“丢失”）；
//      }
//  }  
// } 
}
私有静态void GUI（）引发InterruptedException{
游戏=新游戏（）；
Player thePlayer=新玩家（）；
JLabel lblStart=新的JLabel（）；
JFrame=新JFrame（）；
frame.add（游戏）；
frame.setVisible（true）；
框架设置尺寸（窗宽、窗高）；
frame.setDefaultCloseOperation（WindowConstants.EXIT_ON_CLOSE）；
frame.setTitle（“避开方块”）；
frame.setresizeable（false）；
frame.setLocationRelativeTo（空）；
BuffereImage cursorImg=新的BuffereImage（16,16，BuffereImage.TYPE_INT_ARGB）；
//创建一个新的空白光标。
Cursor blankCursor=Toolkit.getDefaultToolkit（）.createCustomCursor(
光标，新点（0,0），“空白光标”）；
/将空白光标设置为JFrror。
frame.getContentPane（）.setCursor（blankCursor）；
frame.addMouseMotionListener（新java.awt.event.MouseMotionAdapter（）{
public void mouseMoved（java.awt.event.MouseEvent evt）{
mouseMove（evt）；
} 
私有无效mouseMove（MouseEvent evt）{
game.mouseMove（evt）；
}
});
while（true）{
game.update（）；
游戏。重绘（）；
游戏。碰撞（）；
睡眠（10）；
}
}
public void DrawScore（图g）抛出InterruptedException{
while（true）{
整数时间=0；
时间=时间+1；
g、 抽绳（“分数：+时间，0，窗宽*窗高+10）；
睡眠（1000）；
}
}
公共静态void main（字符串[]args）引发InterruptedException{
新记分板（）.setVisible（true）；
音乐（）；
GUI（）；
}       
}

对于游戏用法，我建议使用System.currentTimeMillis（），因为它比System.nanoTime（）性能更好。关于如何在游戏中跟踪时间的示例：

public class Stopwatch {
    private long startTime;

    public void start() {
        startTime = System.currentTimeMillis();
    }

    public float getElapsedTimeSeconds() {
        return (System.currentTimeMillis() - startTime) / 1000f;
    }
}

用法：

Stopwatch stopwatch = new Stopwatch();
stopwatch.start();
Thread.sleep(5000);
System.out.println("Time elapsed in seconds: " + stopwatch.getElapsedTimeSeconds());

---

System.currentTimeMillis（）

和

System.nanoTime（）

将是您今后最好的朋友；）

Thread.sleep（5000）；

如果不小心使用，将冻结GUI。最好使用基于Swing的

计时器来定期更新GUI。我同意您不需要或不想要睡眠（5000），但我认为您不需要单独的计时器，因为程序已经每隔10毫秒左右更新一次GUI。很抱歉，Thread.sleep调用只是为了演示秒表功能。