unflüssiges Zeichnen

[Guest]

Hallo allerseits.

Ich bin grad ein wenig Swing am ausprobieren und habe ein kleines Programm geschrieben.
Ich weiss nun leider einfach nicht wieso das ganze Teils nicht flüssig läuft, sondern wie so
kleine Sprünge nimmt. Es geht dabei um einen Punkt der von unten nach oben läuft.
Vielleicht kann mir von euch jemand einen Tip geben.
danke schonmal fürs anschauen.

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;

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

public class Main {

	private static final int HEIGHT = 500;
	private static final int WIDTH = 200;

	public Main() {
		init();
	}

	private void init() {
		final JFrame frame = new JFrame("The bouncing Point");
		frame.setSize(WIDTH, HEIGHT);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		PointPanel pp = new PointPanel(WIDTH, HEIGHT);
		frame.getContentPane().add(pp);

		Thread thread = new Thread(new PointThread(pp));
		thread.start();
		frame.setVisible(true);
	}

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

	public static class PointThread implements Runnable {

		private PointPanel pointPanel;

		private int speed = 4;
		private boolean upwards;

		public PointThread(PointPanel panel) {
			this.pointPanel = panel;
		}

		@Override
		public void run() {
			while (true) {
				int height = pointPanel.getHeight();

				Rectangle oldRect = pointPanel.getRectabgle();
				// change up/down
				if (oldRect.getCenterY() < (height / 4)) {
					upwards = false;
				} else if (!upwards && oldRect.getCenterY() > height - 20) {
					upwards = true;
				}
				Point oldLocation = oldRect.getLocation();

				Point newLocation;
				if (upwards) {
					newLocation = new Point(oldLocation.x, oldLocation.y - speed);
				} else {
					newLocation = new Point(oldLocation.x, oldLocation.y + speed);
				}
				Rectangle newrect = new Rectangle(newLocation, oldRect.getSize());

				pointPanel.updatePoint(newrect);
				try {
					// 50 Hz
					Thread.sleep(20);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	@SuppressWarnings("serial")
	public static class PointPanel extends JPanel {

		final Dimension POINT_SIZE = new Dimension(20, 20);

		// actual point
		Rectangle rect = new Rectangle(new Point(250, 400), new Dimension(20, 20));

		public PointPanel(int width, int height) {
			super();
			// start point (middle of frame bottom)
			rect = new Rectangle(new Point(width / 2 - POINT_SIZE.width / 2, height - POINT_SIZE.height), POINT_SIZE);
		}

		@Override
		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			g.setColor(Color.RED);
			g.fillOval(rect.x, rect.y, rect.width, rect.height);
		}

		public void updatePoint(Rectangle newRect) {
			Rectangle updateArea = newRect.union(rect);
			rect = newRect;
			// repaint the specific area
			repaint(updateArea.x, updateArea.y, updateArea.width + 1, updateArea.height + 1);
		}

		public Rectangle getRectabgle() {
			return this.rect;
		}
	}
}

 

[André Uhres]

Allgemein hängt das von Geschwindigkeit (sleep) und Y-Schrittweite ab.
Bei grösserer Geschwindigkeit (=weniger sleep) kann man sich grössere Schrittweite erlauben,
ohne den Eindruck zu haben, daß es ruckt.

 

[Gast]

ok. danke erstmal. vielleicht liegts an meinem verwöhnten Auge.
Ich dachte da hätte ich was komplett falsch gemacht, oder
Linux will net richtig oder sonst irgendwas. Werde es morgen
mal auf einem anderen Rechner anschauen, vielleicht siehts dann
schon anders aus

 

[Quaxli]

Für ruckelfreie Bewegungen empfiehlt es sich, die Zeit zu messen, die ein Schleifendurchlauf benötigt und die Bewegung in Abhängigkeit dieser Zeit durchzuführen:

   public static class PointThread implements Runnable {

  	  long diff = 0;
  	  long time = 0;
      private PointPanel pointPanel;

      private int speed = 100;
      private boolean upwards;

      public PointThread(PointPanel panel) {
         this.pointPanel = panel;
         time = System.nanoTime();
      }

      public void run() {
         while (true) {
        	  diff = System.nanoTime() - time;
        	  time = System.nanoTime();
        	  
            int height = pointPanel.getHeight();

            Rectangle oldRect = pointPanel.getRectabgle();
            // change up/down
            if (oldRect.getCenterY() < (height / 4)) {
               upwards = false;
            } else if (!upwards && oldRect.getCenterY() > height - 20) {
               upwards = true;
            }
            Point oldLocation = oldRect.getLocation();

            Point newLocation;
            if (upwards) {
               newLocation = new Point(oldLocation.x, oldLocation.y - (int)(speed*diff/1e9));
            } else {
               newLocation = new Point(oldLocation.x, oldLocation.y + (int)(speed*diff/1e9));
            }
            Rectangle newrect = new Rectangle(newLocation, oldRect.getSize());

            pointPanel.updatePoint(newrect);
            try {
               // 50 Hz
               Thread.sleep(10);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }//while
      }//run
   }

Und mit der folgenden Änderung, sieht Deine Kugel noch etwas schöner aus :

      public void paintComponent(Graphics g) {
         super.paintComponent(g);
         Graphics2D g2 = (Graphics2D)g;
         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON );
         g2.setColor(Color.RED);
         g2.fillOval(rect.x, rect.y, rect.width, rect.height);
      }