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

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

Queste variabili indicano quale immagine sarà animata nello schermo della applet e quale sia la sua posizione attuale. Il metodo paint() apparirà quindi come segue:

public synchronized void paint(Graphics g)
{
    g.drawImage(images[currentimage],0,0,this);
    //L'immagine seguente viene tracciata sopra la
    //precedente.
    g.drawImage(images[nextimage]
        ,nextimagexposition,nextimageyposition,this);
}

public void run()
{
    //Dobbiamo trovare la dimensione della applet e salvarla
    //nella variabile "d". Possiamo ottenere ora larghezza e altezza 
    //della applet scrivendo d.width e d.height.
    Dimension d=size();
    //Le variabili "displacement" specificano le
    //coordinate iniziali della immagine.
    int displacementx=0;
    int displacementy=0;
    //"pathsize" la userete per conoscere a quale distanza
    //verrà spostata la nuova immagine.
    int pathsize=0;
    //"currentimage" viene inizializzata alla prima immagine,
    //seguita dall'immagine seguente, che diventa l'immagine
    //numero 2, e così via.
    currentimage=0;
    nextimage=1;
    while (true)
    {
        //Calcoliamo da quale direzione
        //debba arrivare la nuova immagine.
        int directionx=(int) (Math.random()*3.0)-1;
        int directiony=(int) (Math.random()*3.0)-1;
        //"directionx" e "directiony" possono avere
        //tre valori: -1, 0 e 1. Non vogliamo che
        //entrambe le variabili abbiano valore 0
        //contemporaneamente quindi cambiamo
        //"directiony" per rendere l'effetto
        //più interessante.
        if (directionx==0 && directiony==0) directiony=1;
        //La variabile "pathsize" contiene larghezza o altezza
        //della  applet a seconda di quale lato sia il più
        //corto.
        if (d.width<d.height) pathsize=d.width;
        else pathsize=d.height;
        //La riga seguente ci protegge dal problema
        //che sorgerebbe se l'utente dovesse specificare una sola
        //immagine.
        if (nextimage>maxitems-1) nextimage=0;
        //Il seguente ciclo gestisce l'aggiornamento dello schermo
        //durante l'animazione. Sposterà l'immagine
        //il numero di volte specificato da "pathsize",
        //che è il lato più corto dello schermo dell'applet.
        for (int i=0; i<=pathsize; i++)
        {
         //Le posizioni dell'immagine si spostano
            //della frazione (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) {}
        }
        //Quando la traslazione è finita,
        //"currentimage" viene impostato alla nuova
        //immagine.
        currentimage=nextimage;
        //Incrementiamo "nextimage" di modo che punti alla
        //immagine successiva. Allo stesso tempo ci assicuriamo che
        //"nextimage" si estenda oltre l'indice dell'array ma
        //che sia costretto a ricominciare da 0 se lo fa.
        nextimage++;
        if (nextimage>maxitems-1) nextimage=0;
}

L'applet parte col piazzare un'immagine fuori dal campo visivo dello spettatore, ovvero fuori dallo schermo della applet. Lentamente l'immagine viene traslata al centro, un pixel per volta. Un problema che si può presentare in questa situazione, è l'eventualità che l'applet sia un rettangolo e non un quadrato. Perché in quel caso l'applet dovrebbe muovere l'immagine con incrementi differenti tra lo spostamento orizzontale e quello verticale. Per questa ragione useremo il lato corto dello schermo della applet e l'useremo nel ciclo for per contare il numero di pixels (la variabile "pathsize"). Calcoliamo una percentuale di quanto si debba muovere l'immagine (i/pathsize) e moltiplichiamola per d.width o d.height per ottenere la distanza orizzontale e verticale totale di quanto sia stata traslata e le nuove posizioni x e y dell'immagine.

Il problema qua è che, dato che stiamo lavorando con gli interi, dobbiamo far continuare le divisioni. Quindi scriviamo piuttosto ((i*d.width)/pathsize). Altrimenti (i/pathsize) darebbe sempre come risultato zero perché il valore di "pathsize" è più grande di "i". Questo concetto è importante, se dividete un intero più piccolo per uno più grande, il risultato è sempre zero.

In ultimo dobbiamo anche moltiplicare questa espressione per "directionx" o "directiony", di modo che l'immagine si sposti nella direzione giusta e sottrarre questa espressione da "displacementx" e "displacementy" rispettivamente, queste due sono le coordinate di partenza delle immagini.