Boucle de jeu principale de Java

Je suis en train d'écrire une boucle de jeu, j'ai trouvé le code dans l'exemple ci-dessous ici. J'ai aussi regardé d'autres manières de faire une boucle de jeu, comme de cet article. Je ne pouvais pas obtenir un de ceux ceux qui travaillent bien. J'ai donc continué avec celui du premier lien.

Ce que je voudrais savoir:

  • Est la façon dont j'ai écrit ma boucle de jeu une bonne façon de le faire?
    • Des suggestions?
  • Dois-je utiliser Thread.sleep(); dans ma boucle de jeu?

Voici mon code actuel:

public void run(){
    long lastLoopTime = System.nanoTime();
    final int TARGET_FPS = 60;
    final long OPTIMAL_TIME = 1000000000 / TARGET_FPS;
    long lastFpsTime = 0;
    while(true){
        long now = System.nanoTime();
        long updateLength = now - lastLoopTime;
        lastLoopTime = now;
        double delta = updateLength / ((double)OPTIMAL_TIME);

        lastFpsTime += updateLength;
        if(lastFpsTime >= 1000000000){
            lastFpsTime = 0;
        }

        this.updateGame(delta);

        this.repaint();

        try{
            Room.gameTime = (lastLoopTime - System.nanoTime() + OPTIMAL_TIME) / 1000000;
            System.out.println(Room.gameTime);
            Thread.sleep(Room.gameTime);
        }catch(Exception e){
        }
    }

source d'informationauteur Get Off My Lawn

  1. 11

    Finalement, vous aurez envie de passer à quelque chose comme LWJGLmais permettez-moi de souligner, continuer à faire ce que vous êtes en train de faire ici pour l'instant. Il vous apprendra les fondamentaux.

    Bon travail sur votre boucle. A l'air sympa, laissez-moi vous donner quelques conseils:

    • Repeindre ne sera pas rendu à l'écran immédiatement. Il raconte l' RepaintManager à rendre lors de son prêt. Utiliser invalide paintImmediately à la place. paintImmediately va bloquer l'exécution jusqu'à ce que le composant a été redessiné pour vous permettre de mesurer les temps de rendu.

    • Thread.sleep typiquement de quelques millisecondes dérive. Vous devriez l'utiliser pour garder votre boucle d'utiliser trop de CPU, mais assurez-vous de comprendre si vous dormez 10 millisecondes vous pourriez dormir 5 millisecondes ou vous pourriez dormir 20.

    • Enfin:

      double delta = updateLength / ((double)OPTIMAL_TIME);

      Si updateLength est à moins de OPTIMAL_TIME, n'appelez pas de mise à jour. En d'autres termes, si le delta est inférieur à un, ne pas mettre à jour. Ce tutoriel explique pourquoi la meilleure que j'ai jamais pu.

  2. 4

    Dans l'ensemble, c'est une bonne boucle, mais il y a un manque que quelques aspects de ce que j'ai trouvé dans l'expérience d'être le meilleur de la boucle.

    Vous souhaitez éventuellement passer à LWJGL ou certains autres jeu java API, mais pour l'instant, d'apprendre les rudiments de la façon de jeu des boucles de travail, et ce qui convient le mieux à vos besoins.

    • Tout d'abord, en réponse à l'un de vos points, aucun. Vous ferez mieux de rester loin de

      Fil.sleep()

      cela peut s'écarter de la vraie quantité de temps que vous définissez à dormir.

      par exemple, si vous choisissez de dormir pendant 10 millisecondes, il pouvait dormir le programme de 5 à 20 millisecondes.

    • Le deuxième problème que j'ai cam immédiatement voir, c'est que vous n'avez aucun moyen d'arrêter le jeu en boucle personnalisé à la méthode stop (). Essayez

      boolean running = true;

      while (running) {

      //Votre Code Ici //

      }

    • Troisièmement, vous souhaitez peut-être envisager de changer la façon dont vous utilisez votre delta variable. Le chemin dans le code ci-dessous peut être une meilleure utilisation et de la construction pour vous.

      Ceci est un exemple de mon jeu en boucle que j'utilise dans mes programmes:

      @Override
public void run() {

long initialTime = System.nanoTime();
final double timeU = 1000000000 / UPS;
final double timeF = 1000000000 / FPS;
double deltaU = 0, deltaF = 0;
int frames = 0, ticks = 0;
long timer = System.currentTimeMillis();

    while (running) {

        long currentTime = System.nanoTime();
        deltaU += (currentTime - initialTime) / timeU;
        deltaF += (currentTime - initialTime) / timeF;
        initialTime = currentTime;

        if (deltaU >= 1) {
            getInput();
            update();
            ticks++;
            deltaU--;
        }

        if (deltaF >= 1) {
            render();
            frames++;
            deltaF--;
        }

        if (System.currentTimeMillis() - timer > 1000) {
            if (RENDER_TIME) {
                System.out.println(String.format("UPS: %s, FPS: %s", ticks, frames));
            }
            frames = 0;
            ticks = 0;
            timer += 1000;
        }
    }
}