int randomnumber = (int)(Math.random()*2.0);

int nextimage = 0;
int nextimagexposition = 0;
int nextimageyposition = 0;

These variables indicates what image will be animated into the applet screen and what its current position is. The paint() method will then look like this:

public synchronized void paint(Graphics g)
{
    g.drawImage(images[currentimage],0,0,this);
    //The following image is drawn on top of the last
    //image.
    g.drawImage(images[nextimage]
        ,nextimagexposition,nextimageyposition,this);
}

public void run()
{
    //We must find out the applet's dimension and save it
    //in the "d" variable. We can now get the applet
    //width and height by writing d.width and d.height.
    Dimension d=size();
    //The "displacement" variables specify the
    //starting coordinates for the image.
    int displacementx=0;
    int displacementy=0;
    //"pathsize" will be used to know what distance
    //that the new image will be moved.
    int pathsize=0;
    //"currentimage" is initialized to the first image,
    //followed by the next image, who becomes image
    //number 2, and so on.
    currentimage=0;
    nextimage=1;
    while (true)
    {
        //We calculate from which direction that
        //the new image should be moved from.
        int directionx=(int) (Math.random()*3.0)-1;
        int directiony=(int) (Math.random()*3.0)-1;
        //"directionx" and "directiony" may have
        //three values: -1, 0 and 1. It is not
        //interesting if both variables get the value 0
        //at the same time so therefore we change
        //"directiony" so that the effect becomes
        //more interesting.
        if (directionx==0 && directiony==0) directiony=1;
        //The variable "pathsize" is set to the applet
        //width or height depending on what side is the
        //shortest.
        if (d.width<d.height) pathsize=d.width;
        else pathsize=d.height;
        //The following line is the protection to the
        //problem if the user should only specify one
        //image.
        if (nextimage>maxitems-1) nextimage=0;
        //The following loop handles the screen update
        //during the animation. It will move the image
        //the number of times specifies by "pathsize",
        //which is the short side of the applet screen.
        for (int i=0; i<=pathsize; i++)
        {
         //The image positions are moved
            //with the fraction (i/pathsize).
            nextimagexposition=displacementx
                -directionx*(i*d.width)/pathsize;
            nextimageyposition=displacementy
                -directiony*(i*d.height)/pathsize;
            update(getGraphics());
           try {Thread.sleep(sleeptime);}
           catch(InterruptedException e) {}
        }
        //When the translation is finished,
        //then "currentimage" is set to the new
        //image.
        currentimage=nextimage;
        //We increase "nextimage" so that it points to the
        //next image. At the same time we make sure that
        //"nextimage" extends above the array index but
        //that it is forced to start over from 0 if it does.
        nextimage++;
        if (nextimage>maxitems-1) nextimage=0;
}

The applet begins by placing an image out of visual range of the spectator, that is outside the applet screen. Slowly the image is translated to the center, one pixel at the time. A problem that can appear here, is the case when the applet is a rectangle and not a quadrate. Because then the applet must move the image with different horizontal and vertical steps. Therefore we use the short side of the applet screen and use it in the for loop to count to the number of pixels (the variable "pathsize"). We calculate a percent of how much the image must move (i/pathsize) and multiplicate this with d.width or d.height to get the total horizontal and vertical distance that it has translated and the new x and y position for the image.

The problem here is, because we are working with integers, we must make the division last. Therefore we write ((i*d.width)/pathsize) instead. Or else (i/pathsize) will always give the result zero because the value of "pathsize" is larger than "i". This is important, if you divide a smaller integer with a larger integer, then the result is always zero.

Finally we must also multiply this expression with "directionx" or "directiony", so that the image moves in the right direction and deduce this expression from "displacementx" and "displacementy" respectively, which are the images start coordinates.