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

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

Dessa variabler bestämmer vilken bild som kommer att animeras in i appletskärmen och vad dess nuvarande position är. Paint() metoden kommer då att se ut så här:

public synchronized void paint(Graphics g)
{
    g.drawImage(images[currentimage],0,0,this);

    //följande bild ritas ovanpå den gamla bilden
    g.drawImage(images[nextimage]
        ,nextimagexposition,nextimageyposition,this);
}

public void run()
{
    //vi tar reda på appletens dimension och
    //sparar det i variabeln d. Vi kan nu komma
    //åt appletens bredd och höjd genom att skriva
    //d.width resp. d.height
    Dimension d=size();

    //displacement variablerna specifierar
    //startkoordinaterna för bilden
    int displacementx=0;
    int displacementy=0;

    //pathsize kommer att användas för att veta
    //vilket avstånd som den nya bilden kommer
    //att flyttas
    int pathsize=0;

    //currentimage initieras så att den börjar med 
    //den första bilden, följt av nästa bild som blir
    //bild nummer två osv
    currentimage=0;
    nextimage=1;
    while (true)
    {
        //Vi räknar ut startpositionerna för bilderna, 
        //dvs varifrån bilderna ska komma från.
        int directionx=(int) (Math.random()*3.0)-1;
        int directiony=(int) (Math.random()*3.0)-1;

        //directionx och directiony kan komma
        //att få tre värden: -1, 0 och 1.
        //Det är inte kul om båda får värdet 0
        //samtidigt, så därför så ändrar vi på
        //directiony så att effekten blir lite
        //roligare
        if (directionx==0 && directiony==0) directiony=1;

        //variabeln pathsize sätts till bredden eller
        //höjden beroende på vilken som är lägst
        if (d.width<d.height) pathsize=d.width;
        else pathsize=d.height;

        //följande rad är skydd mot problemet
        //om användaren specifierar bara en enda
        //bild
        if (nextimage>maxitems-1) nextimage=0;

        //följande slinga tar hand om att uppdatera
        //skärmen under animeringen. Den kommer att
        //flytta bilden det antal ggr som specifieras
        //av pathsize, dvs kortsidan av appleten.
        for (int i=0; i<=pathsize; i++)
        {
            //bildpositionerna flyttas med
            //bråkdelen (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) {}
        }
        //när flyttningen är klar så sätts currentimage
        //till den nya bilden
        currentimage=nextimage;

        //Vi ökar nextimage så att den
        //pekar på nästa bild, samtidigt så ser vi till
        //att nextimage inte överstiger arrayens index
        //utan att den tvingas börja om från början
        nextimage++;
        if (nextimage>maxitems-1) nextimage=0;
}

Appleten börjar med att placera en bild utom synhåll för åskådaren, dvs utanför appletskärmen. Sakta så flyttar den in bilden mot centrum, en pixel i taget. Ett problem som kan uppkomma här är om appleten är en rektangel och inte en kvadrat. Då måste appleten flytta bilden med olika horisontella och vertikala steg. Därför hämtar vi kortsidan på appletskärmen och for-slingan får räkna upp till den här sidans pixelantal (variabeln "pathsize"). Vi räknar upp ett procentuellt värde på hur mycket bilden skall röra sig (i/pathsize) och multiplicerar sedan med d.width eller d.height för att få den totala horisontella resp. vertikala sträckan som den har rört sig.

Problemet här är att eftersom vi håller på med integers så måste vi utföra divisionen sist och därför skriver vi ((i*d.width)/pathsize) istället. Annars så skulle (i/pathsize) alltid ge värdet noll eftersom värdet på "pathsize" är större än "i". Detta är viktigt, dividerar man ett mindre heltal med ett större så blir resultatet alltid noll.

Slutligen måste vi också multiplicera den här termen med "directionx" eller "directiony" så att bilden rör sig åt rätt håll. Till slut så drar vi av den här termen från "displacementx" resp. "displacementy" som är bildens startkoordinater.