Running a "worm" around edge of JComponent.

Question

Hello all.
I am currently working on a little class that will draw a "worm" onto any JComponent and run it around the edge (clockwise, starting in upper left corner) of that JComponent. Currently the worm is just a simple Rectangle2D (a 10x10 square), but I want to extend it into an elongated rectangle with a gradiant tail. Baby steps though. :)
My worm is currently working, with 2 issues that I am hoping some folks could help me with. The current code is at the end of the message.
(1) My worm sometimes jumps beyond the boundries of the JComponent it belongs to. I have some math set up to avoid this, but I seem to be missing something obvious because it is still happening!
(2) There is a slightly flicker associated with the movement of the worm. I'm not sure if double buffering will really help in this case because the redraw is very simple. Perhaps I just haven't found the right mix of "speed" and "delay". If anyone has thoughts on this I woudl appreciate the input.
(3) Okay... 3 things. I'm just looking for tips on cleaning up the code. My hopes are to extend this to having a gradient tail and to actually crawl around corners too. General input on how I might change things now to make things easier in the future would be greatly appreciated!
Thanks much for any input! Code follows:
public class Worm implements Runnable {
     private JComponent world;
     private boolean isRunning = false;
     private Thread wormThread;
     private Rectangle2D worm;
     private int speed = 10;
     private int delay = 100;
     private int xVelocity = speed;
     private int yVelocity = 0;
     public Worm(JComponent widget) {
          this.world = widget;
          worm = new Rectangle2D.Double(0, 0, 10, 10);
          wormThread = new Thread(this);
     public void run() {
          while (isRunning) {
               /** calculate the worm's new location */
               double newX = worm.getX() + xVelocity;
               double newY = worm.getY() + yVelocity;
               /** make sure the worm does not run out of bounds */
               if (newX + worm.getWidth() > world.getWidth())
                    newX = world.getWidth() - worm.getWidth();
               if (newY + worm.getHeight() > world.getHeight())
                    newY = world.getHeight() - worm.getHeight();
               newX = (newX < 0) ? 0 : newX;
               newY = (newY < 0) ? 0 : newY;
               /** redraw the background, with a little buffer for safety */
               Rectangle prevBounds = new Rectangle((int)worm.getX()-1, (int)worm.getY()-1, (int)worm.getWidth()+2, (int)worm.getHeight()+2);
               world.repaint(prevBounds.getBounds());
               /** update the worm's location */
               worm.setRect(newX, newY, worm.getWidth(), worm.getHeight());
               repaint();
               /** change the worm's direction as needed */
               if (xVelocity > 0 && newX + worm.getWidth() >= world.getWidth()) {
                    xVelocity = 0;
                    yVelocity = speed;
               } else if (yVelocity > 0 && newY + worm.getHeight() >= world.getHeight()) {
                    xVelocity = -speed;
                    yVelocity = 0;
               } else if (xVelocity < 0 && newX <= 0) {
                    xVelocity = 0;
                    yVelocity = -speed;
               } else if (yVelocity < 0 && newY <= 0) {
                    stop();
               /** take a short nap */
               try {
                    Thread.sleep(delay);
               } catch (InterruptedException e) {
                    e.printStackTrace();
     private void repaint() {
          Graphics2D g2d = (Graphics2D)world.getGraphics();
          g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
          g2d.setPaint(Color.ORANGE);
          g2d.fill(worm);
          g2d.draw(worm);          
          g2d.dispose();
     public void start() {
          isRunning = true;
          wormThread.start();
     public void stop() {
          /** stop the worm */
          isRunning = false;
          /** redraw the world to clear up any remnants */
          world.repaint();
}

Answer 1

The worm flicker could be solved by double buffering, but it could also be down to the the actual frames per second which are being achived. 85 FPS would be ideal. The trouble is the call to repaint() and the call to Thread.sleep() both return when the JVM feels like it and this could vary depending on the load placed on your machine at the time.
So measuring how many loops are occuring in a second might be start.
To clean up the code it might be worh factoring the loop into:
public void run() {
          while (isRunning) {
                    updateGameState();
                    repaint();
                 }The worm would update its own state with worm.move() which would be called in updateGameState(); Therefore moving the move logic from run() to the worm, ofcourse the worm would have to have a reference to its world!