Juhitav animatsioon
Joonistuskäsud, lõimed, mälupilt, heli
Taustateave
Joonistamine 

	Javas on püütud joonistusvahendid teha sihtpinnast sõltumatuks, nii et sama programmilõigu abil võib joonistada nii ekraanile, mällu kui printerisse ning sobiva draiveri abil ka muude vahendite abil. Programmi poolt saadetakse joonistatavale pinnale teateid graafilise konteksti abil, milleks on enamasti klassi Graphics või Graphics2D oskustega isend. Kontekstile antakse üldisi käsklusi joone, ringi, teksti jm. joonistamise kohta, viimase ülesandeks on tulemus kanda üle sihtpinnale. Kas tegemist on mälupildi joonistamisel massiivi väärtuste arvutamisega või põletuspulga liigutamisel plotteris, sellele ei pea programm tähelepanu pöörama. Programmi kirjutaja isegi ei pea teadma, millise sihtseadmeni tema käskude mõju lõpuks ulatub. Et iga lõigu või punkti joonistamisel ei peaks eraldi kaasa lisama joonistamisel vajalikke parameetreid, hoitakse neid graafilise konteksti juures ning koos joonistuskäsklustega edastatakse sihtseadmele. Graphics hoiab eneses joonistusvärvi, -piirkonda ning nihet, Graphics2D  juures aga tulevad juurde joone laius, pildi keere, kalle, suurendus, joonte ühendus. Samuti võib joonistusvärviks valida mustri või värviülemineku.  Sellisel juhul arvutades mälus asuvale pildile joonistatavat ringi iga punkti puhul vaadatakse, milline koht mustrist vastab joone alla jäävale kohale sihtpinnal. 
	Välja paistva graafikakomponendi joonistuskäsud koondatakse üldiselt meetodisse nimega paint. Meetodile antakse parameetrina graafiline kontekst, mis oma väljundi suunab pinnale, kus kasutaja arvab komponenti asuvat, üldjuhul ekraanile. Nii õnnestub lihtsustada komponenti näitava kesta tööd. Igal korral kui  leitakse, et komponendi sisu on kaduma läinud või vajab lihtsalt uuendamist, kutsutakse taas välja paint, mis komponendi arvates sobiva oleku taastab. Kui komponendi omanik vaatab, et uuendamist vajab vaid osa komponendi pinnast, võidakse ressursside kokkuhoiu huvides saata paint-meetodisse pügatud (vähendatud, clip) joonistusalaga Graphics, mis kannab sihtpinnale edasi vaid nende joonistuskäskude tulemused, mis jäävad konteineri (komponendi omaniku) arvates uuendamist vajavasse piirkonda. Nõnda võib mõnikord veebilehe kerimisel avastada, et konteiner on uuendamist vajavat osa valesti hinnanud ning valgeks jäetakse ka osa komponendi pinnast, kus peaks midagi muud leiduma. Soovides kogu komponendi pinda uuendada, tuleb anda käsklus repaint(). See käsk käivitab pinnauuenduse eraldi lõimes. Ta ootab kõigepealt, et virtuaalmasinal jaguks piisavalt ressursse joonistamiseks. Edasi kutsutakse välja komponendi meetod update parameetrina graafiline kontekst komponendi asukohaseadme pinnale joonistamiseks, mis klassist java.awt.Component päritud vaikimisi oskuste alusel kõigepealt katab komponendi pinna taustavärviga ning seejärel kutsub välja meetodi paint, kus kirjeldatud käskude abil peaks kompomendi arvatav pinnavälimus kasutajani jõudma. Nõndamoodi saab hoolitseda, et vanast välimusest uude juhuslike jupikeste näol rudimente ei jääks, sest kui vana pind ühtlaselt taustavärvi plaadiga katta, siis ei tohi ju põhja midagi alla silma häirima jääda. Samas võib suurema pinna uuendamisel tekkida ekraanile vilgatus, kui platsi tühjendamise ning uue sisu joonistamise vahele piisavalt suur vahe jääb, et inimsilm seda märkab. Lahenduseks leitakse, et tuleb komponendi kohal näidatav pilt eelnevalt valmis arvutada ning siis ühekorraga või rida-realt ekraanile joonistada. Nõnda saab teha, kui pilt koostatakse mällu ning paint-meetodi sisuks oleks vaid selle pildi ekraanile manamine, update aga loobuks taustavärviga katmisest (taustavärv oleks ekraanile joonistatava pildi põhjaks) ning kutsuks kohe välja paint-i. update't annab muuta ülekatte abil: kui kirjutatada

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

siis jääbki taustaga katmine ära ning kogu töö usaldatakse paint'ile. Sellist joonistusviisi nimetatakse topeltpuhverduseks ning Swingi juures võib sama skeemi joonistamise juures ühe lisaparameetriga sisse lülitada.
	Ekraanile joonistada saab ka mujal kui paint-meetodis, kuid sellisel juhul konteineri poolt kutsutud pinnauuenduse korral läheb kõik muu kaduma, mis paint'is kirjas pole. Sellegipoolest on mõnikord mugav kohe hiirevajutuse peale küsida pinna graafiline kontekst ning sealtkaudu soovitud ringike ekraanile manada, mitte asuda andmeid muutujates säilitama ning paint'i kaudu ekraanile tooma. Tõsisemate programmide juures tuleks aga valida viimane tee ning pea alati on siiski vaja ka omal teada, mida ja kus peaks ekraanile ilmuma. Ka liikumise puhul on mõistlik jätta pinna uuendamine paint-meetodi hooleks, kuigi vahel on mugavam otse leitud uute andmete järgi ka pilt ekraanile joonistada. 

Taust liikumise ajal mälus.

	Järgnevas näites koos kasutaja hiire lohistamisega liigub ekraanil ring. Liikumise taustaks on eelnevalt hiire lahtilaskmise kohas taustapildile joonistatud ringid ning iga uue lahtilaskmisega tekib taustapildile üks ring juurde. Joonistusmeetod paint viib ekraanile vaid taustapildi, liikumismulje jätab mouseDragged, kus alla joonistatakse taust ning peale hiire parajatist asukohta tähistav ring. Et taustapilt oleks kõikjalt Liigu2 isendist kätte saadav, selleks on deklareeritud
Image pilt;
klassi algusse. Pilt saab enesele väärtuse ning võimaluse andmeid sisestada aga alles joonistusmeetodis
public void paint(Graphics g){
    if(pilt==null)looPilt();
    g.drawImage(pilt, 0, 0, this);
  }
, sest varem pole kindlustatud, et createImage suudaks Liigu2 komponendi omadustele vastava pildi luua. Koos pildi loomisega küsitakse ka selle graafiline kontekst, et edaspidi oleks hea lihtne mälupildi peale andmeid saata. 
void looPilt(){
    pilt=createImage(getSize().width, getSize().height);
    piltg=pilt.getGraphics();
  }
 Java uuemates versioonides on võimalik pilt ka varem luua BufferedImage abil. Hiire sündmustele reageerimiseks on rakendile külge pandud kuular nii hiirevajutuste (MouseListener) kui hiire liikumise (MouseMotionListener) tarvis.
  public Liigu2(){
    addMouseMotionListener(this);
    addMouseListener(new Liigu2kuular(this));
  }
Liikumise ja vedamise tarvis kaks meetodit on realiseeritud Liigu2 enese sees, vajutuste püüdmiseks on aga loodud eraldi adapterklass, kust hiirenupu lahtilaskmise peale mälupildile ring joonistatakse. 

import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
public class Liigu2 extends Applet 
           implements MouseMotionListener{
  Image pilt;
  Graphics piltg;
  public Liigu2(){
    addMouseMotionListener(this);
    addMouseListener(new Liigu2kuular(this));
  }
  public void paint(Graphics g){
    if(pilt==null)looPilt();
    g.drawImage(pilt, 0, 0, this);
  }
  void looPilt(){
    pilt=createImage(getSize().width, getSize().height);
    piltg=pilt.getGraphics();
  }
  public void mouseMoved(MouseEvent e){}
  public void mouseDragged(MouseEvent e){
    Graphics g=this.getGraphics();
    g.drawImage(pilt, 0, 0, this);
    g.drawOval(e.getX()-5, e.getY()-5, 10, 10);
  }
  public static void main(String argumendid[]){
    Frame f=new Frame();
    f.add(new Liigu2());
    f.setSize(200, 200);
    f.setVisible(true);
  }
}

Et hiire vajutamise teateid püüdev suudaks Liigu2 juurde kuuluvale pildile midagi joonistada, selleks peab siin olema ligipääs ekraanile joonistatava pildi graafilisele kontekstile. Üheks võimaluseks on lisada kuularile osuti, mille kaudu sihtisendile ligi pääseda. Selle muutuja nimeks on siin peremees. Objektorienteeritud programmeerimises on viisakas isendimuutujatele anda väärtusi meetodite kaudu, siin saadakse andmed kohale konstruktori kaudu. Kui üleval kirjutati kuulari lisamiseks

addMouseListener(new Liigu2kuular(this));

, siis see this Liigu2kuulari loomisel tähendabki osutit Liigu2 eksemplarile.



class Liigu2kuular extends MouseAdapter{
  Liigu2 peremees;
  public Liigu2kuular(Liigu2 l2){
    peremees=l2;
  }
  public void mouseReleased(MouseEvent e){
    peremees.piltg.drawOval(
                 e.getX()-5, e.getY()-5, 10, 10);
  }
}



Lõim liikumisel
	Järgnevas näites on lõime alamklass Pall2. Igal pallil on koordinaadid x ja y ning iga sammuga muutuvad need dx ja dy võrra. Iga pall liigub omaette lõimes, s.t. programmi muudest osadest sõltumatult. Pall alandab enese prioriteeti, s.t. et protsessori tööaja jagamisel loeb ta end keskmisest vähem tähtsamaks. Prioriteedi alandamine on vajalik selleks, et pallide liigutamine ei hakkaks märkimisväärselt aeglustama teisi lõimi, näiteks ekraanile joonistamist. Muidu võib juhtuda, et suure hulga pallide puhul jäävad ülejäänud tegevused suhteliselt unarusse.  Käsk yield tähendab, et lõim annab oma tööjärje üle järgmisele ning asub ise järjekorda uuesti protsessori aega ootama. 
Raami alamklass Loim2 loob enesele viis palli isendit ning laseb nad liikuma. Loim2 ise realiseerib liidest Runnable, s.t., et tema run-meetodit on samuti võimalik panna tööle eraldi lõimes. Selle lõime ülesandeks on joonistada iga natukese aja tagant uus ekraanipilt vastavalt pallide  uutele koordinaatidele. 

import java.awt.*;
public class Loim2 extends Frame implements Runnable{
 Pall2[] pallid;
 public Loim2(){
   pallid=new Pall2[5];
   for(int i=0; i<pallid.length; i++)
     pallid[i]=new Pall2();
   setSize(200, 200);
   setVisible(true);
   new Thread(this).start();
 }
 public void joonista(){
   Image pilt=createImage(200, 200);
   Graphics piltg=pilt.getGraphics();
   for(int i=0; i<pallid.length; i++){
     piltg.drawOval(pallid[i].x()-10, pallid[i].y()-10, 20, 20);
   }
   this.getGraphics().drawImage(pilt, 0, 0, this);
 }
 public void run(){
   while(true){
     joonista();
     Thread.yield();
     try{Thread.sleep(100);}catch(Exception e){}
   }
 }
 public static void main(String argumendid[]){
   new Loim2();
 }
}

class Pall2 extends Thread{
  double x=200, y=200, dx, dy;
  int vasak=20, ulal=50, parem=200, all=200;
  public Pall2(){
    dx=5*Math.random();
    dy=5*Math.random();
    start();
  }
  public int x(){
    return (int)x;
  }
  public int y(){
    return (int)y;
  }
  public void run(){
    setPriority(Thread.NORM_PRIORITY-2);
    while(true){
      if(x>parem)dx=-Math.abs(dx);
      if(y>all)dy=-Math.abs(dy);
      if(x<vasak)dx=Math.abs(dx);
      if(y<ulal)dy=Math.abs(dy);
      x+=dx;
      y+=dy;
      yield();
      try{Thread.sleep(100);}catch(Exception e){}
    }
  }
}


 


Sirelasemäng

Järgnevalt vaadeldalse näidete abil teekond, mida läheb tarvis enamiku liikumisega seotud rakenduste puhul. Alustatakse tausta liigutamisest ning ükshaaval lisatakse elemente. Kas tulemuseks on mäng või juhitav simulaator sõltub rohkem vaatenurgast. 

Liikuv taust

Küllalt mugav on tausta tekitada korduva pildiga, kuid see pole sugugi ainuke võimalus. Mustri võib ka pidevalt mõne kavala valemi abil välja arvutada.  Mugavaks ümberkäimiseks peaks taustapilt olema  nähtavast alast suurem, kuigi mälu kokkuhoiu huvides võib vajadusel proovida ka sama väiksemat pilti mitu korda üksteise kõrvale joonistada. Samuti on nõnda võimalik panna rakendus tausta joonistamisel ka nähtava ala suurust arvestama. Siin näites on taustapildi suuruseks 320x480 punkti, eeldatav vaatamissuurus aga 300x300 punkti. Tausta muster kordub iga 160 punkti tagant. Taustapilti joonistatakse iga kaadri haaval niikaua allapoole, kuni on läbitud kogu mustripikkus (siin 160 punkti). Siis alustatakse järgmisel korral jälle mustri joonistamist ülevalt. Nii tekibki pilt liikumisest, sest hüpe mustri kõrguse jagu üles ei ole kasutajale nähtav.
	Muudetavad parameetrid on koondatud programmi algusse, et neid saaks ka siis oma vajaduste järgi paika sättida, kui programmi sisust suuremat ülevaadet pole. Lähem seletus:
Taustapildimuutuja on toodud meetoditest välja, et selle abil oleks võimalik pidevalt pildi poole pöörduda ning ei peaks iga joonistamisvajaduse eel pilti asuma failist uuesti välja lugema.  
Mustripikkus on eraldi muutujas, sest taustapildi vahetamisel teistsuguse vastu on tarvis teada, kui pika hüppe peab üles tegema, et pilt kasutaja silmadele taas samasugune välja näeks.
Samm hoiab meeles, mitme ekraanipunkti jagu iga korraga pilti allapoole nihutatakse, paus teatab joonistamise vahel oodatavate millisekundite arvu. Sammu suurendamisel või ooteaja lühenemisel liikumiskiirus kasvab. Liialt suur samm muudab aga liikumise hüplikuks, liialt väike ooteaeg aga ei pruugi lasta masinal tulemust korralikult välja joonistada.

 Image taust;
  int mustripikkus=160;
  int samm=3;
  int paus=50;
  int nihe=0; 
  boolean veel=false;
Plinkimise vältimiseks on üle kaetud meetod update, paludes sel kohe paint välja kutsuda. Muul juhul tahetaks igal korral ekraan enne pildi joonistamist taustavärviga katta ning selle tulemusena hakkaks silmeesine virvendama. Kuna aga taustapilt nagunii kogu nähtava ala katab, siis ei jää vana pilt nagunii näha ning taustavärviga katmine oleks mõttetu. 
	Pildi laadimiseks on loodud eraldi alamprogramm, kuna rakend ja rakendus saavad pildi kätte erinevalt. See meetod proovib kõigepealt pilti saada rakendi moel. Kui nii ei õnnestu, siis üritatakse Toolkiti abil failist lugeda. Kui fail leidub ja formaadid sobivad, siis üks võimalus nendest võiks õnnestuda. 
	Pilt laetakse sisse, kui käivitusjärg jõuab esimest korda paint-alamprogammini. Loogiline võiks tunduda pildi laadimine otse muutujate deklareerimise ajal, aga rakendi getImage pole selleks ajaks veel töövõimeline. Nii ongi tehtud paint'i algusesse valik, kus muutuja taust null-väärtuse korral (mis tal algselt on) palutakse pilt sisse laadida. 
	Iga paint-meetodi väljakutse korral liigutatakse taustapilti sammu jagu allapoole. Nihe näitab, palju ollakse algsest asendist edasi liikunud. Kui pärast arvutust ületab nihe mustripikkust, siis hüpatakse mustri pikkuse jagu ülespoole, et oleks taas võimalik rahumeeles alla liikuda. 
	Joonistamiskäskluses on x-koordinaadiks 0, sest tausta joonistatakse alates vasakust servast. Y-koordinaadi väärtus nihe-mustripikkus näitab, et igal korral määrab pildi asukoha nihke suurenemine. Samas konstantne mustripikkuse muutuja väärtus hoiab pilti pidevalt niipalju kõrgel, et pildi ülaserv ei hakkaks kasutajale paistma. 
	Kui kood vaid sellega piirduks, siis püsiks pilt enamiku ajast paigal. Ning vaid juhul, kui mõnd teist akent me rakenduse peale ja sealt ära liigutada või natukese aja tagant meie akna suurust muuta võiksime märgata mingit liikumist. Et aga saaksime silme ees näha pidevalt liikuvat pilti, peaksid üksikud hüpped toimuma piisavalt sageli. 
	Sarnase ülejoonistuse nagu toimub akna suuruse muutuse juures, saab esile kutsuda ka käsu repaint() käivitamisega. Püsivat pilti joonistavates programmides paigutati see enamasti tekstivälja või hiiresündmuse töötlusossa. Siin aga soovime, et meetodit kutsutaks välja pidevalt iga natukese aja tagant. Leidub ka klass, mille abil peaks võimalik olema täpselt soovitud ajavahemike tagant etteantud meetodit käivitada, kuid lihtsamal juhul piisab lahendusest, kus pärast iga joonistust peetakse soovitud aja pikkune paus. Selline vaikselt põksuv süda on ka siia rakendusse sisse ehitatud ning võlusõnaks on lõim. 
	Kuigi traditsioonilise programmeerimise juures on programmi tööjärg kogu aeg kindlas kohas ning  ilma eelmist sammu lõpetamata edasi ei liiguta, siis pole see sugugi ainus tava rakendusi töös hoida. Näiteks liigutamise, ehk praegusel juhul repaint'i väljakutsumise saab jätta suhteliselt iseseisvalt töötava lõime hooleks. Selle käivitamise, tööshoidmise ja seiskamise tarvis on näha järgnevas koodis hulk sõnu. 
	Lõime abil omaette käivitatav kood paigutatakse meetodi run sisse. Selline nimi on määratud liideses Runnable ning selle järgi teab Thread-tüüpi objekt, mida käivitada. Meetodi run ülesandeks selles programmis on repaint-käsklust korduvalt välja kutsuda. Selleks on loodud tsükkel milles käsklus repaint() ning ootamiseks Thread.sleep(paus). Viimane on paigutatud try-catch katsendiplokki, kuna võib mõnes olukorras (lõimede omavahelise suhtlemise korral) heita erindeid. Siin koodis taolist võimalust pole, kuid sellest hoolimata nõuab Java kompilaator potentsiaalselt erindiohtliku käsu ümbritsemist vastava plokiga. Muutuja veel while-tsükli päises võimaldab lõimel oma töö lõpetada, kui too tõeväärtusmuutuja väärtuseks antakse false. See juhtub näiteks käsus stop, mis kutsutakse välja seilur lahkub rakendit sisaldavalt lehelt.
	Tööle lükatakse lõim meetodist start. Näites võib märgata kaht käsklust start, mis aga omavahel kuigivõrd seotud pole. Esimene kuulub klassi Pildike1 külge ning katab üle klassi Applet vastavat meetodit. Rakendikäitur (seilur) teatab selle kaudu Pildike1 eksemplarile, et isend on lehel avanenud. Siis on paras aeg liikumislõime käivitamiseks. Käsk new Thread(this).start() teatab, et loodagu uus klassi Thread  eksemplar, millele antakse ette this ehk klassi Pildike1 eksemplar. Ning et etteantud eksemplaris pandagu iseseisvana käima run-meetod. Et run just käivitada tuleb, seda teab juba Thread. Iseseisva programmina käsurealt käivitades on näha main-meetodis käsku ap.start() – see käivitab Pildike1 start-käsu samuti nagu rakendikäiturgi veebis. Ning tulemusena õnnestub liikuvat tausta vaadata. 

import java.applet.Applet;
import java.awt.*;
public class Pildike1 extends Applet implements Runnable{
  Image taust;
  int mustripikkus=160;
  int samm=3;
  int paus=50;
  int nihe=0; 
  boolean veel=false;
  
  public void paint(Graphics g){
    if(taust==null)taust=laePilt("rohetaust320x480.gif");
    nihe=nihe+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    g.drawImage(taust, 0, nihe-mustripikkus, this);
  }
  public void update(Graphics g){
    paint(g);
  }

  public void start(){
    veel=true;
    new Thread(this).start();
  }
  public void run(){
    while(veel){
        repaint();
      try{Thread.sleep(paus); }catch(Exception e){}
    }
  }
  public void stop(){
    veel=false;
  }
 

  Image laePilt(String failinimi){
     try{
      return getImage(getCodeBase(), failinimi);
     }catch(Exception e){}
      return Toolkit.getDefaultToolkit().
                            getImage(failinimi);
  }
  public static void main(String argumendid[]){
    Frame f=new Frame("Pildiraam");
    Pildike1 ap=new Pildike1();
    f.add(ap);
    f.setSize(300, 300);
    f.setVisible(true);
    ap.start();
  }
}






Taust koos lilledega

Nagu iga keerukama ülesande kallale tuleb asuda üksikute osade kaupa, nii ka siin on järgmiseks ette võetud lillede paigutamine taustale. Ning hoolitsetud, et lilled suhteliselt ühtlase tihedusega, kuid samas juhuslikult pinnale jaotuksid ning pinna suhtes paigal püsides inimese eest läbi liiguksid. Juurde on tulnud muutujad lilledega seotud andmete hoidmiseks. Lille kõrguse järgi saab arvestada millal ta ekraanile paistma hakkab, millal kaob ning hiljem ka leida, kas lill mõne muu alaga kattuma juhtub. Reaalarvuline lillelisamistõenäosus näitab, mitu lille luuakse keskmiselt iga sammu korral. Et väärtuseks on praegu 0.03*samm, tähendab, et iga kõrguse ekraanipunkti kohta tuleb keskmiselt 0.03 lille, ehk siis ligikaudu üks lill iga 33 punkti kohta. Lilli endeid hoitakse Vector'is; kollektsioonis, mille elemente võib vabalt lisada ja eemaldada ilma, et peaks ise muret tundma mälu eraldamise või vabastamise pärast. Aega arvutatakse ekraanipunktides. Et liikumine on ühtlase kiirusega, siis leidub ka kulunud ajaga võrdeline seos. Samahästi võiks muutujat nimetada kogunihkeks, ehk maapinna liikumise kogu punktide arvuks. 

Lillede haldamise tarbeks on loodud mitu alamprogrammi: lisamise, eemaldamise ja joonistamise tarbeks. 
	Lillelisamistõenäosus näitas, mitu lille tuleb ühe joonistustsükli eel lisada. Kui see väärtus on näiteks 2,7, siis kaks lille lisatakse kindlasti, kolmas aga tõenäosusega 0,7 ehk 70%. Muutuja lt liigub tõenäosuse algsest väärtusest kuni nullini. Kuni lt väärtus on suurem kui 1, lisatakse lill kindlasti, sest Math.random()-i väljastatu on vahemikus 0<=x<1. Jääb aga lt väärtus alla ühe, siis sõltub Math.random'i tegevusest, kas tuleb veel lill või mitte. Lill luuakse uue objektina, millele jäetakse meelde tema x-koordinaat (muutumatu) ning aeg ehk maapinna liikumise teepikkus ekraanipunktides lille lisamise ajaks. Selle järgi on võimalik pärast arvutada, kus lill ekraanil peaks asuma, sest kõik lilled luuakse vaikimisi ülaserva. X-koordinaat leitakse juhuslikult pea kogu nähtava laiuse ulatuses. Kümme punkti võetakse laiusest x-i leidmisel maha, et ei tekiks lille, mis ekraanil sugugi näha poleks. Meeldejäetud x tähistab lille vasakut serva. 

  void lisaUusiLilli(){
   for(double lt=lillelisamistoenaosus; lt>0; lt=lt-1){
    if(Math.random()<lt){
      lillekesed.addElement(new Lilleke2((int)((laius-10)*Math.random()), aeg));
    }
   }
  }

Lille klass näeb välja suhteliselt lihtne. Vaid kaks muutujat ning konstruktor algandmete sisestamiseks. Siin näites on ta paigutatud eraldi klassina samasse faili, kuid selle võiks paigutada ka sootuks omaette faili samasse kataloogi või siis hoopis sisemise klassina Pildike2 sisse. Eraldi failis saaks Lilleke2-te kasutada soovi korral otse ka teised klassid. Sisemise klassina paigutamise puhul aga pole muret et mõni muu samanimeline klass kusagil segadust tekitama hakkaks.

class Lilleke2{
  int x, algaeg;
  public Lilleke2(int x1, int algaeg1){
    x=x1; algaeg=algaeg1;
  }
}

Iga sammu juures kontrollitakse kõik lilled läbi ning eemaldatakse alt üle ääre sattunud. Käsuga elementAt küsitakse lillekeste vektorist välja  järjekorranumbrile vastav lill. Tüübimuundus on tarvilik, kuna Vector hoiab kõiki andmeid ülemklassina Object, meil on aga tarvis lillelt küsida vaid temale omase välja algaeg väärtust. 

  void eemaldaVanadLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke2 l=(Lilleke2)lillekesed.elementAt(i); 
      if(aeg-l.algaeg>korgus+lillekorgus){
        lillekesed.removeElementAt(i);
        i--;
      }    
    }
  }
  
Joonistamine läks pikemaks. Ehkki paint näeb välja ilus lühike, on tema ülesannet täitma tulnud hulk abilisi.

  public void paint(Graphics g){
    koostaPilt();
    g.drawImage(pilt, 0, 0, this);
  }

Lisaks taustale tuleb sisse lugeda ka lille pilt. Samuti ei joonistata tausta enam otse ekraanile, vaid pannakse mälus enne taust ja lilled uue pildi peale kokku ning alles seejärel näidatakse tulemus ekraanile. Mälupildi koostamiseks on createImage, mis jällegi rakendi puhul pole enne võimeline käivituma kui esimese paint-i ajal. Loodud pildi käest küsitud piltg jääb globaalsena üle kogu isendi kättesaadavaks, et ei pea muudele joonistavatele alamprogrammidele seda eraldi kätte jagama. Nagu näha, pärast iga sammu eemaldatakse vanad lilled, lisatakse uusi, joonistatakse taust mälupildi põhjaks ning lilled ükshaaval sellele.

  void koostaPilt(){
    if(taust==null)taust=laePilt("rohetaust320x480.gif");
    if(lill==null)lill=laePilt("lill1.gif");
    if(pilt==null){
      pilt=createImage(laius, korgus);    
      piltg=pilt.getGraphics();
    }
    nihe=nihe+samm;
    aeg=aeg+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    eemaldaVanadLilled();
    lisaUusiLilli();
    piltg.drawImage(taust, 0, nihe-mustripikkus, this);
    joonistaLilled();
  }

Lillede joonistamisel käiakse lihtsalt läbi kõik vektoris olevad lilled ning paigutatakse nende andmete järgi lillepilt taustapildile. Arvutus aeg-lille algaeg näitab lille asukoha ekraanil. Lisaks võetakse maha veel lillekõrgus, et lill asuks nähtavasse alasse sisenema oma alumise poolega ja mitte ei tekiks järsku tervikuna inimese vaatevälja.

  void joonistaLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke2 l=(Lilleke2)lillekesed.elementAt(i); 
      piltg.drawImage(lill, l.x, aeg-l.algaeg-lillekorgus, this);
    }
  }

Ja tervikuna liikuva tausta ja juhuslike lilledega rakenduse kood.

import java.applet.Applet;
import java.awt.*;
import java.util.Vector;

public class Pildike2 extends Applet implements Runnable{
  Image taust;
  Image pilt;
  Graphics piltg;
  Image lill;
  int lillekorgus=100;
  int mustripikkus=160;
  int samm=3;
  int paus=50;
  int nihe=0; 
  int aeg=0;
  int laius=300, korgus=300;
  Vector lillekesed=new Vector();
  double lillelisamistoenaosus=0.03*samm;
  boolean veel=false;
  
  public void paint(Graphics g){
    koostaPilt();
    g.drawImage(pilt, 0, 0, this);
  }
  public void update(Graphics g){
    paint(g);
  }

  void koostaPilt(){
    if(taust==null)taust=laePilt("rohetaust320x480.gif");
    if(lill==null)lill=laePilt("lill1.gif");
    if(pilt==null){
      pilt=createImage(laius, korgus);    
      piltg=pilt.getGraphics();
    }
    nihe=nihe+samm;
    aeg=aeg+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    eemaldaVanadLilled();
    lisaUusiLilli();
    piltg.drawImage(taust, 0, nihe-mustripikkus, this);
    joonistaLilled();
  }
  
  
  void lisaUusiLilli(){
   for(double lt=lillelisamistoenaosus; lt>0; lt=lt-1){
    if(Math.random()<lt){
      lillekesed.addElement(new Lilleke2((int)((laius-10)*Math.random()), aeg));
    }
   }
  }
  
  void eemaldaVanadLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke2 l=(Lilleke2)lillekesed.elementAt(i); 
      if(aeg-l.algaeg>korgus+lillekorgus){
        lillekesed.removeElementAt(i);
        i--;
      }    
    }
  }
  
  void joonistaLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke2 l=(Lilleke2)lillekesed.elementAt(i); 
      piltg.drawImage(lill, l.x, aeg-l.algaeg-lillekorgus, this);
    }
  }

  public void start(){
    veel=true;
    new Thread(this).start();
  }

  public void run(){
    while(veel){
        repaint();
      try{Thread.sleep(paus); }catch(Exception e){}
    }
  }
  public void stop(){
    veel=false;
  }

  Image laePilt(String failinimi){
     try{
      return getImage(getCodeBase(), failinimi);
     }catch(Exception e){}
      return Toolkit.getDefaultToolkit().getImage(failinimi);
  }

public static void main(String argumendid[]){
    Frame f=new Frame("Pildiraam");
    Pildike2 ap=new Pildike2();
    f.add(ap);
    f.setSize(300, 300);
    f.setVisible(true);
    ap.start();
  }
}

class Lilleke2{
  int x, algaeg;
  public Lilleke2(int x1, int algaeg1){
    x=x1; algaeg=algaeg1;
  }
}








Liigutatav putukas

Ehkki lõpupoole soovin näha nii lilli kui putukaid koos liiklemas, on hea väiksemaid osi alustuseks eraldi poovida. Järgnevalt saab putukat noolte abil liigutada omasoodu liikuva tausta kohal. Putuka tarvis on juurde tulnud muutujad tema asukoha kohta, samuti sammu pikkus, mõõtmed ja pilt. Joonistatakse sarnaselt lilledega, st., et kõigepealt koostatakse mälus pilt taustast ja putukast ning siis kantakse tulemus tervikuna ekraanile. 
Põhiline lisandus on putuka liigutamine klaviatuuri abil. Klahvisündmuste kuulamiseks on realiseeritavaks liideseks lisandunud KeyListener paketist java.awt.event. Liidesega koos kolm kohustuslikult realiseeritavat meetodit: keyPressed, keyReleased ja keyTyped. Et reageerida soovime vaid esimesele, on ülejäänute koodiosa tühi. 
	Klahvivajutusele reageerimisel küsitakse kõigepealt klahvi kood, et oleks võimalik asuda võrdlema, millisele klahvile vajutati. Vasaku noole puhul kontrollitakse kõigepealt, et putukas oleks vasakust äärest vähemalt oma sammupikkuse kaugusel ning sel puhul vähendatakse putuka x-koordinaadi väärtust sammu jagu. Nõnda võin vasakut noolt vajutades liikuda putukaga vasaku serva lähedale, kuid mitte kaugemale. Pole karta, et putukas ekraani pealt lahkuks. Sarnane kontroll on ka teiste külgede juures, kuid paremal ja all arvestatakse lisaks veel putuka mõõtmetega, et ka parem ega alumine külg üle piiri ei läheks. 

  public void keyPressed(KeyEvent e){
    int kood=e.getKeyCode();
    if((kood==KeyEvent.VK_LEFT) && (putukax>putukasamm))putukax-=putukasamm;
    if((kood==KeyEvent.VK_RIGHT) && (putukax<laius-putukasamm-putukalaius))
        putukax+=putukasamm;
    if(kood==KeyEvent.VK_UP && putukay>putukasamm)putukay-=putukasamm;
    if(kood==KeyEvent.VK_DOWN && putukay<korgus-putukasamm-putukakorgus)
        putukay+=putukasamm;
  }

Muu kood on küllalt sarnane tausta liikumise näitega. Lõim hoolitseb omasoodu sagedase pildiuuenduse eest, lisaks taustapildile on aga tarvis lisada ka putukas vastavalt oma koordinaatidele.


import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;

public class Pildike3 extends Applet implements Runnable, KeyListener{
  Image taust;
  Image pilt;
  Graphics piltg;
  Image putukas;
  int putukax=100, putukay=150;
  int putukalaius=30, putukakorgus=15;
  int putukasamm=4;
  int mustripikkus=160;
  int samm=3;
  int paus=50;
  int nihe=0; 
  int aeg=0;
  int laius=300, korgus=300;
  boolean veel=false;
  
  public Pildike3(){
    addKeyListener(this);
    requestFocus();
  }
  public void paint(Graphics g){
    koostaPilt();
    g.drawImage(pilt, 0, 0, this);
  }
  public void update(Graphics g){
    paint(g);
  }

  void koostaPilt(){
    if(taust==null)taust=laePilt("rohetaust320x480.gif");
    if(putukas==null)putukas=laePilt("sirelane.gif");
    if(pilt==null){
      pilt=createImage(laius, korgus);    
      piltg=pilt.getGraphics();
    }
    nihe=nihe+samm;
    aeg=aeg+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    piltg.drawImage(taust, 0, nihe-mustripikkus, this);
    piltg.drawImage(putukas, putukax, putukay, this);
  }
  
  
  public void start(){
    veel=true;
    new Thread(this).start();
  }

  public void run(){
    while(veel){
        repaint();
      try{Thread.sleep(paus); }catch(Exception e){}
    }
  }
  public void stop(){
    veel=false;
  }
  public void keyPressed(KeyEvent e){
    int kood=e.getKeyCode();
    if((kood==KeyEvent.VK_LEFT) && (putukax>putukasamm))putukax-=putukasamm;
    if((kood==KeyEvent.VK_RIGHT) && (putukax<laius-putukasamm-putukalaius))
        putukax+=putukasamm;
    if(kood==KeyEvent.VK_UP && putukay>putukasamm)putukay-=putukasamm;
    if(kood==KeyEvent.VK_DOWN && putukay<korgus-putukasamm-putukakorgus)
        putukay+=putukasamm;
  }

  public void keyReleased(KeyEvent e){}
  public void keyTyped(KeyEvent e){}
  Image laePilt(String failinimi){
     try{
      return getImage(getCodeBase(), failinimi);
     }catch(Exception e){}
      return Toolkit.getDefaultToolkit().
                          getImage(failinimi);
  }

  public static void main(String argumendid[]){
    Frame f=new Frame("Pildiraam");
    Pildike3 ap=new Pildike3();
    f.add(ap);
    f.setSize(300, 300);
    f.setVisible(true);
    ap.start();
  }
}








Nektarit imev putukas

Liikuvad lilled ja liigutatav putukas omaette läbi proovitud, nüüd kannatab nad ühte kesta kokku panna. Juures on omadus, kus putukas lilleni jõudmisel selle nektarist tühjaks imeb, nii et viimane pärast imemist seest tühjemana paistab. Ka lilleklassi sai veidi täiendatud: nüüd on sel lisaks oma x-koordinaadile ja algusajale meeles, kas on ta juba nektarist tühjaks imetud või veel mitte. Ning nii nagu objektorienteeritud programmile kohane, sai tühjuse määramiseks ja küsimiseks koostatud eraldi meetodid. Nii on näiteks võimalik oleku muutumisel kontrollida, kas uus väärtus sobib või soovi korral toimingud kuhugile testiks logida. Samuti võiks praeguse programmi korral olla lubatud tühi vaid tõeseks muuta, sest iseenesest juba tühjaks imetud õied siin enam mesimahla ei tekita.

class Lilleke4{
  int x, algaeg;
  boolean tyhi=false;
  public Lilleke4(int x1, int algaeg1){
    x=x1; algaeg=algaeg1;
  }
  void paneTyhi(boolean kasTyhi){
    tyhi=kasTyhi;
  }
  boolean kasTyhi(){
    return tyhi;
  }
}

Teadmaks, kas putukas mõne lille pihta satub, kontrollitakse läbi kõikide loetelus olevate lillede kaugused putukast. Kontrollimisel abiks põhikoolist tuttav Pythagorase teoreem, et täisnurkse kolmnurga külgede ruutude summa on võrdne pikima külje ruuduga. Imemiskaugus on paigutatud eraldi muutujasse, et oleks võimalik määrata, kui kaugelt suudab putukas nektari kätte saada. Esimene mõte imemisvõimaluse leidmisel tõenäoliselt tuleb, et peaks leidma putuka ja lille vahelise kauguse ning siis võrdlema, kas leitud suurus on imemiskaugusest väiksem. Et aga ruutjuure arvutamine nõuab arvutilt küllalt palju protsessoritehteid ning iga sammu ajal on tarvilik leida hulga lillede ja putuka vaheline kaugus, siis annab programmi sujuvamaks teha, kui vaid võrrelda külgede ruutude summat imemiskauguse ruuduga. Viimane ei muutu ning selle saab vähemasti enne sammu algust valmis arvutada.
Kui leitakse, et lill putukale piisavalt lähedale sattus, siis antakse lillele teada, et mingu ta tühjaks. Samuti palutakse Toolkit'il tekitada väikene kõll.

  void kontrolliImemisi(){
    int kauguseruut=imemiskaugus*imemiskaugus;
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i);
      int lilley=aeg-l.algaeg-lillekorgus/2;
      int xkaugus=putukax-l.x;
      int ykaugus=putukay-(lilley-lillekorgus/2);
      if(!l.kasTyhi() && (xkaugus*xkaugus+ykaugus*ykaugus)<kauguseruut){
        l.paneTyhi(true);
        Toolkit.getDefaultToolkit().beep();
      }
    }
  }


Joonistamise puhul tuleb siis iga lille puhul otsustada, milline pilt lillest välja näidata. Nektarit täis lille pilt on nime all lill, tühjaks imetu oma lill2. Avaldis  (l.kasTyhi())?lill2:lill väljastab sulgudes oleva tõese tingimuse puhul küsimärgile kohe järgneva väärtuse, ehk pildi lill2. Kui aga lill pole veel tühjaks imetud, võetakse tulemus pärast koolonit ehk pilt muutujast lill.

  void joonistaLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i); 
      Image lillepilt=(l.kasTyhi())?lill2:lill;
      piltg.drawImage(lillepilt, l.x, aeg-l.algaeg-lillekorgus, this);
    }
  }   

Ja taas kogu peaklassi kood tervikuna.

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;

public class Pildike4 extends Applet implements Runnable, KeyListener{
  Image taust;
  Image pilt;
  Graphics piltg;
  Image lill, lill2;
  int lillekorgus=100;
  Image putukas;
  int putukax=100, putukay=150;
  int putukalaius=30, putukakorgus=15;
  int putukasamm=4;
  int imemiskaugus=10;
  int mustripikkus=160;
  int samm=1;
  int paus=50;
  int nihe=0; 
  int aeg=0;
  int laius=300, korgus=300;
  Vector lillekesed=new Vector();
  double lillelisamistoenaosus=0.03*samm;

  boolean veel=false;
  
  public Pildike4(){
    addKeyListener(this);
  }
  public void paint(Graphics g){
    koostaPilt();
    g.drawImage(pilt, 0, 0, this);
  }
  public void update(Graphics g){
    paint(g);
  }

  void koostaPilt(){
    if(taust==null)taust=laePilt("rohetaust320x480.gif");
    if(putukas==null)putukas=laePilt("sirelane.gif");
    if(lill==null)lill=laePilt("lill1a.gif");
    if(lill2==null)lill2=laePilt("lill1.gif");
    if(pilt==null){
      pilt=createImage(laius, korgus);    
      piltg=pilt.getGraphics();
    }
    nihe=nihe+samm;
    aeg=aeg+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    eemaldaVanadLilled();
    lisaUusiLilli();
    kontrolliImemisi();
    piltg.drawImage(taust, 0, nihe-mustripikkus, this);
    joonistaLilled();
    piltg.drawImage(putukas, putukax, putukay, this);
  }
  
  void lisaUusiLilli(){
   for(double lt=lillelisamistoenaosus; lt>0; lt=lt-1){
    if(Math.random()<lt){
      lillekesed.addElement(new Lilleke4((int)((laius-10)*Math.random()), aeg));
    }
   }
  }
  
  void eemaldaVanadLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i); 
      if(aeg-l.algaeg>korgus+lillekorgus){
        lillekesed.removeElementAt(i);
        i--;
      }    
    }
  }
  
  void kontrolliImemisi(){
    int kauguseruut=imemiskaugus*imemiskaugus;
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i);
      int lilley=aeg-l.algaeg-lillekorgus/2;
      int xkaugus=putukax-l.x;
      int ykaugus=putukay-(lilley-lillekorgus/2);
      if(!l.kasTyhi() && (xkaugus*xkaugus+ykaugus*ykaugus)<kauguseruut){
        l.paneTyhi(true);
        Toolkit.getDefaultToolkit().beep();
      }
    }
  }
  
  void joonistaLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i); 
      Image lillepilt=(l.kasTyhi())?lill2:lill;
      piltg.drawImage(lillepilt, l.x, aeg-l.algaeg-lillekorgus, this);
    }
  }

  
  
  public void start(){
    veel=true;
    new Thread(this).start();
  }

  public void run(){
    while(veel){
        repaint();
      try{Thread.sleep(paus); }catch(Exception e){}
    }
  }
  public void stop(){
    veel=false;
  }
  public void keyPressed(KeyEvent e){
    int kood=e.getKeyCode();
    if((kood==KeyEvent.VK_LEFT) && (putukax>putukasamm))putukax-=putukasamm;
    if((kood==KeyEvent.VK_RIGHT) && (putukax<laius-putukasamm-putukalaius))
        putukax+=putukasamm;
    if(kood==KeyEvent.VK_UP && putukay>putukasamm)putukay-=putukasamm;
    if(kood==KeyEvent.VK_DOWN && putukay<korgus-putukasamm-putukakorgus)
        putukay+=putukasamm;
  }
  public void keyReleased(KeyEvent e){}
  public void keyTyped(KeyEvent e){}
  Image laePilt(String failinimi){
     try{
      return getImage(getCodeBase(), failinimi);
     }catch(Exception e){}
      return Toolkit.getDefaultToolkit().getImage(failinimi);
  }

  public static void main(String argumendid[]){
    Frame f=new Frame("Pildiraam");
    Pildike4 ap=new Pildike4();
    f.add(ap);
    f.setSize(300, 300);
    f.setVisible(true);
    ap.start();
  }
}

Sirelane mängu alguses

Esimesed lilled






Kaks tühjaks imetud lille



Püüdlus terviku poole

Nähtavalt on juurde tulnud kerimisribad putuka liikumistundlikkuse, maapinna liikumiskiiruse ja lillede tiheduse määramiseks. Näha veel väike statistika ning klahve vajutades tunda, et putukas mitte ei hüppa klahvivajutuse peale, vaid klahvidega saab pigem putuka suunda ja kiirust määrata. Ühes sellega on muutunud või lisandunud hulga koodi. 

Kõigepealt tuleb kerimisribad mälus valmis luua. Sulgude sees näha neil hulga parameetreid. Scrollbar.HORIZONTAL näitab, et riba on pikali. Sooviks püstist riba, oleks vastavaks konstandiks Scrollbar.VERTICAL. Järgnevad arvud: algne väärtus, nupu laius, vähim ja suurim võimalik väärtus. Nagu siit aimata võib, määratakse ja küsitakse kerimisriba väärtusi arvude abil.

  Scrollbar sbtaustasamm=new Scrollbar(Scrollbar.HORIZONTAL, 10, 5, 0, 100);

Et kerimisriba sündmustele annaks reageerida, selleks on klassi realiseeritavate liideste loendisse lisandunud AdjustmentListener

public class Pildike5 extends Applet implements Runnable, KeyListener, AdjustmentListener{

Liidesega käib koos meetod adjustmentValueChanged, mis on võimalik kerimisriba liigutamise peale käivitada. Iga käivituse puhul küsitakse kõigist kolmest kerimisribast väärtused ja paigutatakse vastavatesse muutujatesse. Iseenesest oleks võimalik küsida meetodi parameetriks tulnud AdjustmentEvent'i käest käsuga e.getSource(), et millist riba just liigutati. Kuna aga kerimisribast väärtuse küsimine ei nõua kuigivõrd ressurssse, siis pole eristust tehtud. Samuti oleks võimalik läbi ajada sootuks ilma sammupikkuse või mõne muu muutujata, küsides igal vajaminemiskorral väärtuse otse kerimisribast. 
	Kerimisribast saab väärtuse küsida vaid täisarvuna. Et aga liikumisel saaks asukohti sujuvamalt arvutada, on liikumisega seotud väärtused salvestatud reaalarvudena. Putuka ja maapinna liikumise puhul on kerimisribalt väärtus jagatud kümnega. Lillelisamistõenäosuse puhul aga, kus väärtused väiksemad ning kümnendkohtadel suurem tähtsus - tuhandega. Lõpuks on palutud lõuend fookusesse kutsuda, et kasutaja klahvivajutused taas lõuendilt kinni püütavad oleksid. Lõuendil asuvad taust, lilled ja putukas.

  public void adjustmentValueChanged(AdjustmentEvent e){
    samm=sbtaustasamm.getValue()/10.0;
    kiirusesamm=sbputukatundlikkus.getValue()/10.0;
    lillelisamistoenaosus=sblilletoenaosus.getValue()/1000.0*samm;
    louend.requestFocus();
  }
  
Graafikakomponendid paigutatakse konstruktoris. Kui eelmises näites joonistati rakendi enese pinnale, siis nüüd kasutatakse selleks eraldi lõuendit. Nõnda on kergem hoolitseda, et kerimisribad sisestusfookust enesele ei haarakse. Veel taseme jagu viisakam oleks kogu liikumine ja joonistamine jätta eraldi komponendi sisse ning komponendi külge ehitada meetodid, mille abil saab parameetreid muuta. Siis luua kestprogramm, mis paigutaks enese peale nii tolle joonistava komponendi kui kerimisribad ning kas vahendaks kerimisribade teated loodud komponendile või paluks ribadel otse oma teated sinna saata. 
	Pildike5 paigutushalduriks on valitud BorderLayout. Nii saab paigutada (alla) serva juhtribad ning joonistuskomponendi venitada üle muu pinna, nii et rakend oleks ühtlaselt kaetud.
	Alumised kerimisribad koos nende sisu selgitavate siltidega paigutati omaette paneeli. Nii saab valmis ehitatud ploki pärast tervikuna rakendi allserva paigutada. Paneeli paigutushalduriks määrati GridLayout kolme rea ja kahe veeruga. Ning edasi paigutati sinna järgemööda sisse nii kirjeldavad sildid kui ribad ise. 

  public Pildike5(){
    setLayout(new BorderLayout());
    Panel p1=new Panel(new GridLayout(3, 2));
    p1.add(new Label("Maapinna kiirus")); p1.add(sbtaustasamm);
    p1.add(new Label("Putuka liikumistundlikkus")); p1.add(sbputukatundlikkus);
    p1.add(new Label("Lillede sagedus")); p1.add(sblilletoenaosus);
    add(p1, BorderLayout.SOUTH);
    add(louend, BorderLayout.CENTER);
    louend.addKeyListener(this);
    sbtaustasamm.addAdjustmentListener(this);
    sbputukatundlikkus.addAdjustmentListener(this);
    sblilletoenaosus.addAdjustmentListener(this);
  }

	Asukohtade arvutamisel on juurde tulnud putuka liikumise arvutus. Nii nagu maapind, nii ka putukas liigub üldjuhul ühtlase kiirusega. Enne putuka sammu võrra liikumist kontrollitakse, kas uus soovitav asukoht asub liikumiseks sobiliku pinna sees. Meetodi esimesed kaks koordinaati tähistavad uuritavat kohta, viimased kaks lubatud ala laiust ja kõrgust. Eeldatakse, et ala vasak ja ülemine serv hakkavad nullist.

  boolean sees(double x, double y, double x2, double y2){
    if(x>=0 && x<x2 && y>=0 && y<y2) return true;
    return false;
  }
  
Kui aga juhtub, et putukas on sattunud lubatud ala serva lähedale ning edasi pole võimalik liikuda, siis seatakse ta liikumiskiirus (sammu pikkus ühe joonistuse jooksul) nulliks. 


  void arvutaAsukohad(){
    nihe=nihe+samm;
    aeg=aeg+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    if(sees(putukax+putukaxkiirus, putukay+putukaykiirus,
                 laius-putukalaius, korgus-putukakorgus)){
      putukax+=putukaxkiirus;
      putukay+=putukaykiirus;
    } else {
      putukaxkiirus=putukaykiirus=0;
    }
  }
  

Reageering klahvivajutusele on mõnevõrra muutunud. Kui ennist muutus vajutusel putuka asukoht, siis nüüd püütakse muuta ta liikumise kiirust. Näitena näha vasak nooleklahv. Kui putukas liikus ennist vasakule (st. putukaxkiirus oli nullist väiksem) sel juhul klahvile vajutades vasakule liikumise kiirus kasvab kiirusesammu võrra, ehk kiirusest lahutatakse kiirusesammu väärtus. Kui aga putukas juhtus enne paigal seisma või paremale liikuma, siis määratakse uueks kiiruseks -kiirusesamm, ehk sama palju, kui muidu iga vajutamisega kiirust juurde tuleb. Nõnda ei pea kiiruse suuna muutmisel liialt aega kulutama pidurdamisele, vaid võib küllalt järsku teises suunas liikuma hakata, nagu putuka lennu puhul ikka näha võib.


  public void keyPressed(KeyEvent e){
    int kood=e.getKeyCode();
    if(kood==KeyEvent.VK_LEFT){
      if(putukaxkiirus<0)putukaxkiirus-=kiirusesamm;
      else putukaxkiirus=-kiirusesamm;
    }
    //...
  }


Juurde tuli mõningane statistika, et kasutajal oleks näha, kaugele ta mänguga jõudnud on. Kulunud aja arvutamiseks küsitakse käivitamise ajal eraldi muutujasse alghetke väärtus. Tegemist küllalt suure ja väheütleva arvuga: millisekundeid alates aastast 1970. 

  long alghetk=new Date().getTime();

Kui nüüd aga millalgi uuesti süsteemi käest aeg küsida, siis nende kahe väärtuse vahe ütleb, palju mängu algusest aega kulunud on.

  void joonistaStatistika(){
    String st="Lilli: "+lilli+" Imetud: "+imetud+ 
         " Kadunud: "+kadunud+" Aeg: "+(new Date().getTime()-alghetk)/1000;
    piltg.setColor(Color.white);
    piltg.drawString(st, 30, korgus-10);
  }
  
Rakendusele pandi kaasa heli. Pidevalt korduv linnutaust, et veidigi tekiks mulje niidul lendavast putukast ning märku andev sahin, kui putukas lillest nektari kätte sai. Taustaga on lihtsam. Kui esimest korda joonistama asutakse, siis palutakse muutujasse laadida linnutaust ning käsu loop abil pannakse too korduvalt end ketrama. 

    if(linnutaust==null){
      linnutaust=laeKlipp("linnutaust.au");
      linnutaust.loop();
    }

Lille tabamise sahina saaks ka lihtsamal juhul laadida ning käsuga play mängima panna. Kui aga lilli palju ning sahinaheli vähegi pikem, siis kipuvad järjestikustel tabamustel helid kattuma ning üksikud tabamused ei eristu kõrvale ilusti ja loendatavalt. Sahinahelide eristamiseks loodi omaette klass. Lähem kirjeldus näha juba kommentaarides.


/**
* Lõimeklass, mille abil saab meloodiajuppe mängida. Sünkroniseerimise abil hoolitsetakse,
* et mängualguste vahel oleks vähemalt poolesekundiline paus. Luku
* (loa)ga sünkroniseeritud plokki pääseb korraga vaid üks lõim. Ülejäänud
* peavad selle ees ootama, kuni eelmine on plokist väljunud. 
*/
class Piiksuja extends Thread{
  static Object lukk=new Object();
  static java.applet.AudioClip sahin;
  public void run(){
   synchronized(lukk){
    sahin.play();
    try{Thread.sleep(500);}catch(Exception e){}
   }
  }
}

Nagu näha, on Piiksuja nii lukk kui sahin staatilised muutujad. See tähendab, et neile on võimalik ligi pääseda sõltumata klassi eksemplaride arvust. Lukuobjekt luuakse programmi käivitamisel ning sama isend on kättesaadav kõigile klassi isenditele - nõndamoodi saab selle järgi sünkroniseerimisel otsustada, et korraga ei juhtuks mitu sahinat mängima. Piiksuja sahin laetakse koos muude klippidega ja paigutatakse sinna staatilisse muutujasse. 

    if(Piiksuja.sahin==null) Piiksuja.sahin=laeKlipp("sahin.au");


Kui nüüd käivitamise juures jõutakse niikaugele, et on paras aeg sahistada, siis luuakse lõimeklassist Piiksuja uus eksemplar ning palutakse start abil eraldi lõimes ta run käivitada. 

      if(!l.kasTyhi() && (xkaugus*xkaugus+ykaugus*ykaugus)<kauguseruut){
        l.paneTyhi(true);
        imetud++;
        new Piiksuja().start();
      }

	Kui eelmist mängijat pooleli pole, siis asutakse pea kohe mängima. Kui aga eelmine lõime eksemplar peatub luku abil sünkroniseeritud ploki sees, siis jääb uus mängija järjekorda, kuni eelmine on oma töö lõpetanud ning plokist väljunud. Kui nüüd liikuda putukaga läbi tiheda lillesalu, võib järgemööda eristatult kuulda mitut sahinat - iga tabatud lille kohta üht. 

   synchronized(lukk){
    sahin.play();
    try{Thread.sleep(500);}catch(Exception e){}
   }

Nagu koodist näha, pole rakendiklassil Pildike5 enam main-meetodit. Lähem seletus klassi kommentaarides.

/**
* Alamklass liikuvate lilledega rakendile Pildike5. Meetod laeKlipp on siin üle kaetud, 
* sest rakendil saadakse heliklipi andmed käsust getAudioClip, rakendusel aga samaotstarbeliseks
* käsuks Applet.newAudioClip. Viimane kuulub aga JDK koosseisu alates versioonist 1.2 ning 
* varasema versiooni seilurid annavad neile tundmatu meetodi sisse lugemisel klassi kohta veateate
* ning keelduvad vastava klassiga edaspidi tegelemast kartes turvamuresid. Kui aga vastav meetod
* siin üle katta, siis ülemklass on sellest meetodist prii ja võib rahus rakendis töötada,
* käsurealt käivitades aga võetakse siinse alamklassi üle kaetud käsklus ning pannakse 
* tööle. 
*/
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.io.*;
class Pildike5Raam extends Pildike5{
  AudioClip laeKlipp(String failinimi){
    try{return Applet.newAudioClip(new File(failinimi).toURL());}catch(Exception e){}
    return null;
  }

  public static void main(String argumendid[]){
    Frame f=new Frame("Pildiraam");
    Pildike5Raam ap=new Pildike5Raam();
    f.add(ap);
    f.setSize(300, 400);
    f.setVisible(true);
    ap.start();
    f.addWindowListener(
      new WindowAdapter(){
        public void windowClosing(WindowEvent e){
          System.exit(0);
        }
      }
    );
  }
}


Nõnda on tehtud muudatused/täiendused üle vaadatud ning rakenduse terviku kood loodetavasti arusaadav.


import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Pildike5 extends Applet implements Runnable, KeyListener, AdjustmentListener{
  Image taust;
  Image pilt;
  AudioClip linnutaust;
  Graphics piltg;
  Image lill, lill2;
  int lillekorgus=100, lillelaius=50;
  Image putukas;
  double putukax=100, putukay=150;
  double putukaxkiirus=0, putukaykiirus=0;
  double kiirusesamm=0.2;
  int putukalaius=35, putukakorgus=35;
  int imemiskaugus=10;
  int mustripikkus=160;
  double samm=1;
  int paus=50;
  double nihe=0; 
  double aeg=0;
  int laius=300, korgus=300;
  int lilli=0, imetud=0, kadunud=0;
  long alghetk=new Date().getTime();
  Vector lillekesed=new Vector();
  double lillelisamistoenaosus=0.02*samm;
  Canvas louend=new Canvas(){
    public boolean isFocusTraversable(){
      return true;
    }
  };
  Scrollbar sbtaustasamm=new Scrollbar(Scrollbar.HORIZONTAL, 10, 5, 0, 100);
  Scrollbar sbputukatundlikkus=new Scrollbar(Scrollbar.HORIZONTAL, 2, 1, 1, 20);
  Scrollbar sblilletoenaosus=new Scrollbar(Scrollbar.HORIZONTAL, 20, 1, 0, 100);
  boolean veel=false;
  
  public Pildike5(){
    setLayout(new BorderLayout());
    Panel p1=new Panel(new GridLayout(3, 2));
    p1.add(new Label("Maapinna kiirus")); p1.add(sbtaustasamm);
    p1.add(new Label("Putuka liikumistundlikkus")); p1.add(sbputukatundlikkus);
    p1.add(new Label("Lillede sagedus")); p1.add(sblilletoenaosus);
    add(p1, BorderLayout.SOUTH);
    add(louend, BorderLayout.CENTER);
    louend.addKeyListener(this);
    sbtaustasamm.addAdjustmentListener(this);
    sbputukatundlikkus.addAdjustmentListener(this);
    sblilletoenaosus.addAdjustmentListener(this);
  }
  public void adjustmentValueChanged(AdjustmentEvent e){
    samm=sbtaustasamm.getValue()/10.0;
    kiirusesamm=sbputukatundlikkus.getValue()/10.0;
    lillelisamistoenaosus=sblilletoenaosus.getValue()/1000.0*samm;
    louend.requestFocus();
  }
  
  public void joonista(){
    koostaPilt();
    louend.getGraphics().drawImage(pilt, 0, 0, this);
  }

  void laeKlipid(){
    if(taust==null)taust=laePilt("rohetaust320x480.gif");
    if(putukas==null)putukas=laePilt("sirelane.gif");
    if(lill==null)lill=laePilt("lill1a.gif");
    if(lill2==null)lill2=laePilt("lill1.gif");
    if(pilt==null){
      pilt=createImage(laius, korgus);    
      piltg=pilt.getGraphics();
    }
    if(Piiksuja.sahin==null) Piiksuja.sahin=laeKlipp("sahin.au");
    if(linnutaust==null){
      linnutaust=laeKlipp("linnutaust.au");
      linnutaust.loop();
    }
    korgus=louend.getSize().height;
    laius=louend.getSize().width;
    louend.requestFocus();
  }
  
  void arvutaAsukohad(){
    nihe=nihe+samm;
    aeg=aeg+samm;
    if(nihe>mustripikkus)nihe=nihe-mustripikkus;
    if(sees(putukax+putukaxkiirus, putukay+putukaykiirus,
                 laius-putukalaius, korgus-putukakorgus)){
      putukax+=putukaxkiirus;
      putukay+=putukaykiirus;
    } else {
      putukaxkiirus=putukaykiirus=0;
    }
  }
  
  void koostaPilt(){
    if(taust==null)laeKlipid();
    arvutaAsukohad();
    eemaldaVanadLilled();
    lisaUusiLilli();
    kontrolliImemisi();
    piltg.drawImage(taust, 0, (int)nihe-mustripikkus, this);
    joonistaLilled();
    joonistaStatistika();
    piltg.drawImage(putukas, (int)putukax, (int)putukay, this);
  }
  
  
  
  void lisaUusiLilli(){
   for(double lt=lillelisamistoenaosus; lt>0; lt=lt-1){
    if(Math.random()<lt){
      lillekesed.addElement(new Lilleke4((int)((laius-lillelaius)*Math.random()), (int)aeg));
      lilli++;
    }
   }
  }
  
  void eemaldaVanadLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i); 
      if(aeg-l.algaeg>korgus+lillekorgus){
        if(!l.tyhi)kadunud++;
        lillekesed.removeElementAt(i);
        i--;
      }    
    }
  }
  
  void kontrolliImemisi(){
    int kauguseruut=imemiskaugus*imemiskaugus;
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i);
      int lilley=(int)aeg-l.algaeg-lillekorgus/2;
      int xkaugus=(int)putukax-l.x;
      int ykaugus=(int)putukay-(lilley-lillekorgus/2);
      if(!l.kasTyhi() && (xkaugus*xkaugus+ykaugus*ykaugus)<kauguseruut){
        l.paneTyhi(true);
        imetud++;
        new Piiksuja().start();
      }
    }
  }
  
  void joonistaLilled(){
    for(int i=0; i<lillekesed.size(); i++){
      Lilleke4 l=(Lilleke4)lillekesed.elementAt(i); 
      Image lillepilt=(l.kasTyhi())?lill2:lill;
      piltg.drawImage(lillepilt, l.x, (int)aeg-l.algaeg-lillekorgus, this);
    }
  }

  void joonistaStatistika(){
    String st="Lilli: "+lilli+" Imetud: "+imetud+ " Kadunud: "+kadunud+" Aeg: "+(new Date().getTime()-alghetk)/1000;
    piltg.setColor(Color.white);
    piltg.drawString(st, 30, korgus-10);
  }
  
  public void start(){
    veel=true;
    new Thread(this).start();
    if(linnutaust!=null)linnutaust.loop();
  }

  public void run(){
    while(veel){
        joonista();
      try{Thread.sleep(paus); }catch(Exception e){}
    }
  }
  public void stop(){
    veel=false;
    linnutaust.stop();
  }
  
  boolean sees(double x, double y, double x2, double y2){
    if(x>=0 && x<x2 && y>=0 && y<y2) return true;
    return false;
  }
  
  public void keyPressed(KeyEvent e){
    int kood=e.getKeyCode();
    if(kood==KeyEvent.VK_LEFT){
      if(putukaxkiirus<0)putukaxkiirus-=kiirusesamm;
      else putukaxkiirus=-kiirusesamm;
    }
    if(kood==KeyEvent.VK_RIGHT){
      if(putukaxkiirus>0)putukaxkiirus+=kiirusesamm;
      else putukaxkiirus=kiirusesamm;
    }
    if(kood==KeyEvent.VK_UP){
      if(putukaykiirus<0)putukaykiirus-=kiirusesamm;
      else putukaykiirus=-kiirusesamm;
    }
    if(kood==KeyEvent.VK_DOWN){
      if(putukaykiirus>0)putukaykiirus+=kiirusesamm;
      else putukaykiirus=kiirusesamm;
    }
  }
  
  public void keyReleased(KeyEvent e){}
  public void keyTyped(KeyEvent e){}

  Image laePilt(String failinimi){
     try{
      return getImage(getCodeBase(), failinimi);
     }catch(Exception e){}
      return Toolkit.getDefaultToolkit().getImage(failinimi);
  }

  AudioClip laeKlipp(String failinimi){
      return getAudioClip(getDocumentBase(), failinimi);
  }
}

Esimesed lilled

Kaks imetud, kaks silmist mööda läinud

 
Tihedaks määratud lilleväli
Edasiarendusvõimalused
Loodud rakendus küll töötab ning on mõningase näpuharjutusena mängitav, kuid pole ta veel ei terviklik mäng ega saa seda kuigivõrd asjalikult ka mõneks muuks otstarbeks kasutada. Olemasolevat koodi vähemalt osalt mõistes on võimalik küllalt vähese vaeva abil koodi toimimist ja rakenduse väljanägemist täiesti märkimisväärselt muuta. Lihtsaimaks asenduseks ehk pildid ja heliklipid. Kui joonistada või leida muru ja lillede abil miskit muud, siis annab kergesti kokku panna koristaja maanteel või elevandi portselanikaupluses. Üks üliõpilane aga kujundas piltide muutmise abil sellest samast näitest aga näiteks küllaltki verise sõjamängu.
	Kui näidet mänguks kujundada, siis tõenäoliselt tuleb üsna pea lisada punktidearvutus ja mängu lõpp, ehk ka tasemed. Punkte kannatab kuvada statistikafunktsiooni veidi muutes. Iseseisva rakenduse puhul annab vahetulemusi faili salvestada. Rakendi puhul on turvapiirangute tõttu see veidi keerulisem, kuid kel PHP või muu veebiserveripoolse programmeerimisvahendiga kokkupuuteid ja kasutusvõimalusi, siis on ka see täiesti tehtav. 
	Ilus võistlusmoment tekib, kui ühe putuka asemel lendleb kaks, kummagi juhtimiseks omaette klahvid. Ning samuti võib saabuvaid pilte olla mitut tüüpi. Nii magusaid mesikaid, õiteta okaspuid kui muude vahele ära eksinud kärbsepabereid.
	Näide ei pea aga mitte ainult mängu aluseks olema. Mõningase muutmise teel saab selle põhjal koostada katseseadme pidurdusteekonna pikkuse või molekulide kaootilise liikumise näitamiseks. Kõige rohkem läheb vaja pealehakkamist. 
Ülesandeid

Sirelasemäng
Alustuseks on kasutada mängu põhi
Tutvu mänguga
Lae lähtekood, pildid ja helilõigud oma arvutisse, kompileeri ja käivita.
Otsi Internetist pilte ning kujunda nende abil mäng oma silma järgi. 
Lisa punktidearvutus.
Loo mängule lõpp.
Luba samaaegselt liikuda kahel mängijal

Klahvidega liigutamine.
Nooleklahvidega saab liigutada ekraanil olevat ringi.
Ekraanil juhuslikus kohas paikneb rist. Jõudes ringiga selleni, hüppab rist uude juhuslikku kohta.
Liigutatavaid ringe on kaks, kummalgi oma klahvid.
Risti asemel on pisike pilt. All servas on kirjas, mitu korda kumbki  mängija on ristini jõudnud.

Tennis
Võrguga tenniseväljakul liigub pall (ring) vasakult paremale.
Samaaegselt ringi liikumisega saab ekraanil liigutada reketit. 
Kummalgi serval on liigutatav reket, mille tabamisel pall tagasi põrkab. Loetakse punkte. 


Ussimäng
10*10 ruudustikul asub vasakul ülaservas neljalüliline uss, keda saab  nooleklahviga paremale liigutada.
Uss liigub pidevalt, nooleklahvidega saab tema liikumise suunda määrata. Seinani jõudmisel uss seiskub. 
Ussiga püütakse juhuslikus kohas asuvat kuldmuna. Muna kättesaamisel uss pikeneb kahe lüli võrra ning muna tekib uude kohta. Seina või enese hammustamisel uss lüheneb nelja lüli võrra. 


Tilgapüüdja
All servas saab liigutada kaussi 
Ekraanil kukub tilk. Selle kaussi püüdmisel saab punkti. 
Tilku võib korraga kukkuda mitu. Mäng on meeldivalt kujundatud ning töötab märgatavate vigadeta. 

Nooltega ralli.
Noolte abil saab muuta ekraanil liikuva ringi kiirust. 
Külgmiste nooltega saab muuta liikumise suunda, teiste nooltega kiirust. 
Korraga võib üle võrgu sõita kaks kasutajat. Aetakse taga juhuslikus kohas paiknevat aaret, mis selleni jõudmisel hüppab uude kohta.