2016-03-23 1 views
0

J'essaie d'utiliser delta pour déplacer un rectangle. Cependant, quand je le multiplie par la vitesse et l'ajoute à la position du rectangle x, le rectangle ne bouge pas. Je pensais que le problème pouvait résider dans la boucle du jeu, mais je ne pense pas que ce soit le cas. Voici le code:Le rectangle ne bouge pas lorsqu'il est multiplié par le temps delta

package Main; 

import java.awt.Canvas; 
import java.awt.Color; 
import java.awt.Graphics; 
import java.awt.Image; 
import java.awt.event.KeyEvent; 
import java.awt.event.KeyListener; 
import java.awt.event.MouseEvent; 
import java.awt.event.MouseListener; 
import java.awt.image.BufferStrategy; 

import javax.swing.JFrame; 
import javax.swing.JPanel; 

//do double buffering 

public class Game extends Canvas { 
    int x, y; 
    private static final long serialVersionUID = 1L; 

    public static final int height = 400; 
    public static final int width = height * 16/9; 

    JPanel p; 
    Game game; 

    Image buffer; 

    KeyListener kl; 
    MouseListener ml; 

    public boolean running = true; 

    public Game(){ 
     kl = new KeyListener(){ 

      public void keyPressed(KeyEvent e) { 

      } 

      public void keyReleased(KeyEvent e) { 

      } 

      public void keyTyped(KeyEvent e) { 

      } 
     }; 

     ml = new MouseListener(){ 

      public void mousePressed(MouseEvent e) { 

      } 

      public void mouseReleased(MouseEvent e) { 

      } 
      public void mouseClicked(MouseEvent e) { 

      } 

      public void mouseEntered(MouseEvent e) { 

      } 

      public void mouseExited(MouseEvent e) { 

      } 
     }; 
    } 

    public void update(double delta){ 
     x += 10/1000 * delta; 
    } 

    public void render(){ 
     BufferStrategy bs = getBufferStrategy(); 
     if(bs==null){ 
      createBufferStrategy(2); 
      return; 
     } 
     Graphics g = bs.getDrawGraphics(); 
     g.clearRect(0, 0, getWidth(), getHeight()); 
     g.setColor(Color.BLACK); 
     g.fillRect(x, y, 100, 100); 

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

    public void run(){ 

     //initialize time loop variables 
     long lastLoopTime = System.nanoTime(); 
     final int TARGET_FPS = 60; 
     final long OPTIMAL_TIME = 1000000000/TARGET_FPS; 
     double lastFpsTime = 0; 

     //Main game loop 
     while(running) 
     { 
      //Calculate since last update 
      long now = System.nanoTime(); 
      long updateLength = now - lastLoopTime; 
      lastLoopTime = now; 
      double delta = updateLength/((double)OPTIMAL_TIME); 

      //update frame counter 
      lastFpsTime += updateLength; 

      //update FPS counter 
      if(lastFpsTime >= 1000000000) 
      { 
       lastFpsTime = 0; 
      } 

      //game updates 
      game.update(delta); 

      //graphics (gameState) 
      game.render(); 

      try{ 
       Thread.sleep((Math.abs(lastLoopTime - System.nanoTime() + OPTIMAL_TIME)/1000000)); 
      }catch(Exception e){ 
       System.out.println("Error in sleep"); 
      } 
     } 
    } 

    public void start(){ 
     JFrame frame = new JFrame("Game"); 

     game = new Game(); 

     frame.add(game); 
     frame.pack(); 

     frame.setSize(width, height); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame.setLocationRelativeTo(null); 

     frame.addKeyListener(kl); 
     frame.addMouseListener(ml); 

     frame.setVisible(true); 

     run(); 
    } 

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

Répondre

0

x et y sont des nombres entiers et 10/1000 * delta est la plupart du temps inférieur à 1. Incremeting x avec une telle valeur ne changera pas du tout x.

Pour résoudre ce problème, essayez de changer le type de x à float ou double, et il suffit d'utiliser Math.floor() ou tout simplement jeter un int quand le dessiner:

g.fillRect((int) x, (int) y, 100, 100); 
0

Pour continuer sur la réponse précédente: 10/1000 vous donnera zéro tandis que 10./1000 vous donnera le nombre réel qu'il représente. Donc, vous devriez changer votre déclaration à

x + = (int) (10./1000 * delta);

et nous espérons que le delta est un nombre supérieur à 1000-1010 pour porter ce chiffre à un nombre entier supérieur à 0.

0

Vous devez changer vos variables x et y être flottant ou double.

double x, y; 

Et si vous souhaitez voir le mouvement, vous aurez besoin de changer quelque chose comme ça ...

x += 100d/1000d * delta; 

Que faisiez-vous avant divisait un entier 10 par un entier 1000 et obtenir 0 en conséquence.

Vous aurez également besoin de jeter les résultats ints lorsque vous dessinez le rect ...

g.fillRect((int)x, (int)y, 100, 100);