Specialeffekter och spelutveckling i Java(TM) - Appleten NotePad

import java.applet.*;
import java.awt.*;

public class notepad extends Applet {

//Variabeln "backgroundimage" pekar på
//bakgrundsbilden (bilden som man ritar på).
Image backgroundimage;
Graphics backgroundg;

//Image-arrayen "blockimages" innehåller
//de nödvändiga bilderna för ritblockets
//animation.
Image blockimages[];

Image penimage;
Image bufferimage;
Graphics bufferg;

//För att inte pennan skall skriva "hackigt"
//så måste vi lagra de gamla värderna för
//pennans position. Vi lägger därför till variablerna
//"oldpenx" och "oldpeny".
int penx,oldpenx;
int peny,oldpeny;

public void init()
{
    Dimension d=size();
    bufferimage=createImage(d.width,d.height);
    bufferg=bufferimage.getGraphics();

    //Vi måste ladda in 7 bilder på blocket
    //för animationens skull. Vi använder oss
    //därför av en for-slinga.
    blockimages=new Image[7];
    MediaTracker tracker=new MediaTracker(this);
    for (int i=0; i < 7; i++)
    {
        //"block0.jpg","block1.jpg" osv kommer att laddas
        //in och lagras i arrayen "blockimages" samtidigt
        //som de lagras hos spåraren (i ordning).
        blockimages[i]=getImage(getDocumentBase(),"block"+i+".jpg");
        tracker.addImage(blockimages[i],i);
    }
    penimage=getImage(getDocumentBase(),"pen.gif");

    //Pennbilden läggs in sist i spåraren.
    tracker.addImage(penimage,7);

    try {tracker.waitForAll();}
    catch(InterruptedException e)
    {
        System.out.println("Någonting stoppade inladdningen...");
    }

    //Vi måste ha en kopia av block0.jpg bilden
    //eftersom den skall vi använda för att rita på.
    //Samtidigt vill vi inte förstöra bilden eftersom
    //den behövs när vi skall rensa skärmen.
    backgroundimage=createCopy(blockimages[0]);

    //Vi behöver en Graphics-objekt för
    //för senare operationer.
    backgroundg=backgroundimage.getGraphics();

    //Pennfärgen får vara svart.
    backgroundg.setColor(Color.black);
}

public Image createCopy(Image img)
{
    //createCopy() metoden skapar en likadan
    //bild som den som specifieras.
    //Först tar man reda på bredden och höjden för bilden
    int width=img.getWidth(this);
    int height=img.getHeight(this);

    //Först skapar vi en tom bild med samma dimensioner
    //som bilden som vi skall ha en kopia av.
    Image result=createImage(width,height);

    //Slutligen skapar vi en Graphics-objekt som pekar
    //på den tomma bilden och ritar ut bilden som
    //vi vill kopiera.
    Graphics resultg=result.getGraphics();
    resultg.drawImage(img,0,0,this);
    return result;
}

public void paint(Graphics g)
{
    if (bufferg!=null)
    {
        bufferg.drawImage(backgroundimage,0,0,this);
        bufferg.drawImage(penimage,penx-6,peny-6,this);
        g.drawImage(bufferimage,0,0,this);
    }
}

public void update(Graphics g)
{
    paint(g);
}

public boolean mouseMove(Event e, int x, int y)
{
    penx=x; peny=y;
    repaint(70);
    return true;
}

public boolean mouseDrag(Event e, int x, int y)
{
    //När användaren draggar så uppdateras "penx"
    //och "peny" som vanligt men innan dess uppdateras
    //"oldpenx" och "oldpeny". Dessa kommer nu att innehålla
    //det gamla värdet.
    oldpenx=penx;
    oldpeny=peny;
    penx=x;
    peny=y;

    //Nu ritar vi en streck mellan punkterna
    //(oldpenx,oldpeny) och (penx,peny).
    //Detta gör vi med Graphics-metoden drawline.
    backgroundg.drawLine(oldpenx,oldpeny,penx,peny);

    //Skärmen måste nu uppdateras så att bilden syns.
    repaint(70);
    return true;
}

public boolean mouseDown(Event e, int x, int y)
{
    //När användaren klickar på musknappen måste
    //"oldpenx" och "oldpeny" peka på det nya x och
    //y värdena.
    penx=x;
    peny=y;
    oldpenx=x;
    oldpeny=y;

    //Om användaren klickar på kanten av skärmen
    //där så skall sidan bytas och
    //skärmen rensas.
    if (penx < 18)
    {
        //Vi använder oss av en for-slinga
        //för att rita ut de sju bilderna.
        for (int i=0; i < 7; i++)
        {
            //Vi använder paint() metoden för att
            //rita ut bilderna så därför sätter
            //vi backgroundimage att peka
            //på de animerade bilderna och anropar paint()
            //för varje bild med en 70ms tidsfördröjning.
            backgroundimage=blockimages[i];
            update(getGraphics());
            try {Thread.sleep(70);}
            catch(InterruptedException ex) {}
        }
        //Nu initierar vi "backgroundimage" igen
        //som vi gjorde på init() metoden
        //Så att vi kan rita på skärmen.
        backgroundimage=createCopy(blockimages[0]);
        backgroundg=backgroundimage.getGraphics();
        backgroundg.setColor(Color.black);

        //Skärmen måste till slut uppdateras
        //med den första bilden.
        update(getGraphics());
    }
    return true;
}

public boolean mouseUp(Event e, int x, int y)
{
    //När användaren släpper på musknappen så
    //nollställ "oldpen" variablerna.
    oldpenx=0;
    oldpeny=0;
    return true;
}

}