Beginselen van programmeren Practicum 1 (Doolhof) : Oplossing

Transcriptie

1 Beginselen van programmeren Practicum 1 (Doolhof) : Oplossing Introductie In dit document geven we een mogelijke oplossing voor het eerste practicum. Deze oplossing gebruikt verschillende klassen en overerving, en zal daarmee een beeld geven wat we voor het tweede practicum verwachten. We proberen in dit document niet alleen de oplossing te beschrijven, maar we proberen ook te schetsen hoe we tot die oplossing gekomen zijn. De code van deze oplossing vind je in de folder oplossing (in de zip model.zip ). Datavoorstelling Het eerste wat we doen is ons afvragen welke data we moeten voorstellen, en hoe we die gaan voorstellen. Het is duidelijk dat we op een of andere manier een 'wereld'(doolhof) moeten voorstellen. Een wereld bestaat uit allemaal tegels of 'vakken'. Elk vak zit op een bepaalde 'positie' in de wereld. Elk vak is ofwel een 'muur'ofwel een vrije tegel (een 'vloer'). Een vloer kan een 'schat'bevatten, en kan een 'persoon'bevatten. Als we even vooruit kijken, dan weten we dat in subdeel B, een tegel ook een 'kruimel'kan bevatten. We kunnen dus zeggen dat een tegel een 'Voorwerp'kan bevatten dat ofwel een schat, ofwel een kruimel is. Een 'Positie'object zal een x- en een y-coördinaat hebben als instantie variabelen. We maken deze private en voorzien een methode geefx en geefy om de coördinaten uit te lezen. Op deze manier is een positie onveranderbaar. public class Positie { private int x; private int y; public Positie (int x, int y) { this. x=x; this. y=y; public int geefx() { return x; public int geefy() { return y; 1

2 Een Wereld object zal als instantie variabele een tabel hebben van type Vak. Het is ook interessant om het mannetje (type Persoon ) bij te houden in een aparte variabele. Als we dit niet doen moeten we alle vakjes afgaan tot we het vakje vinden met het mannetje, wanneer we het mannetje nodig hebben. Interessante methodes voor Wereld zijn: public Persoon geefmannetje() public Vak geefvak (Positie positie) We hebben geen methode om een vakje te veranderen nodig omdat de wereld zelf niet meer verandert. Elk Vloer object heeft een variabele voorwerp en een variabele persoon om bij te houden welke persoon of welk voorwerp op dat vakje staat. We maken dus methodes: public boolean bevatvoorwerp() { return voorwerp!=null; public boolean bevatpersoon() public Voorwerp geefvoorwerp() public Persoon geefpersoon() public void verwijdervoorwerp() public void verwijderpersoon() public void plaatsvoorwerp(voorwerp voorwerp) public void plaatspersoon (Persoon persoon) Een Persoon object zal later acties moeten kunnen ondernemen in de wereld. Het is dus best als dat object bijhoud in welke wereld die persoon zit en welk zijn positie in die wereld is. We komen dus tot onderstaand (voorlopige) klassendiagramma. We zullen later extra methodes toevoegen wanneer we weten welke extra bewerkingen op de data moeten kunnen gebeuren. 2

3 We maken een constructor voor de klasse Wereld die als parameter een Scanner object meekrijgt. Deze constructor zal de data uit het Scanner object inlezen, en de tabel creëren en opvullen. Ons probleem kan op hoog niveau beschreven worden als: Zolang het einde van de invoer niet bereikt is blijven we een regel verwerken. public Wereld(Scanner scanner) { while (scanner.hasnextline()) { verwerkregel (scanner); We hoeven ons nu dus enkel nog te concentreren op het verwerken van een regel. We kunnen alle regels negeren, behalve die met DIM en WERELD. Voor de DIM-regel lezen we de dimensies in en creëren de tabel die de vakken bijhoud. Als we de WERELD regel tegenkomen moeten we wereld inlezen die daarachter komt. protected void verwerkregel (Scanner scanner) { String regel=scanner.nextline (); Scanner regelscanner=new Scanner (regel); //Als regel leeg is of alleen spaties bevat, //geeft de methode next() een fout. //Vandaar onderstaande test. Zo negeren we die //regels. if (regelscanner.hasnext()) { 3

4 String begin=regelscanner.next (); if (begin.equals("dim")) { int breedte=regelscanner.next Int (); int hoogte=regelscanner.nextint (); vakken=new Vak[hoogte] [breedte]; else if (begin.equals("wereld")) { leeswereld(scanner, vakken); //alle andere regels worden genegeerd. Het probleem is weer vereenvoudigd. We weten dat als de onderstaande methode opgeroepen wordt, de tabel gecreëerd is met de juiste dimensies (anders is er iets mis met de data, aangezien DIM altijd voor WERELD moet komen), en dat de er 'hoogte'regels in het Scanner object zitten die de wereld voorstellen. Normaal mogen we veronderstellen dat de invoer correct is. Aangezien dat de invoer soms met de hand gemaakt wordt kan het geen kwaad te zorgen dat we een paar fouten aankunnen. We gebruiken hasnextline om te testen of er inderdaad voldoende regels in de invoer zitten (indien niet gebruiken we een lege regel). Het kan ook zijn dat sommige regels kleiner zijn dan de breedte (een paar spaties te weinig gezet). In dat geval geven we de variabele 'soort'de waarde ''voor alle karakters na het einde van de regel. Elke positie in de tabel wordt opgevuld met het juiste subtype van Vak. We ontcijferen de karakter code in de methode decodeersoort. protected void leeswereld(scanner scanner, Vak[] [] vakken) { for (int y=0; y<vakken.length; y++) { String regel=""; if (scanner.hasnextline ()) regel=scanner.nextline (); for (int x=0; x<vakken[0].length; x++) { char soort= ; if (x<regel.length ()) soort=regel.charat (x); Vak vak=decodeersoort(soort, x, y); vakken [y] [x] =vak; Als we het mannetje tegenkomen, zetten we dat niet alleen op het vloer vakje, maar steken we dat ook in de instantievariabele 'mannetje'. protected Vak decodeersoort(char soort, int x, int y) { Vak resultaat; switch (soort) { case # : resultaat=new Muur (); 4

5 break; : resultaat=new Vloer (); mannetje=new Persoon(new Positie(x, y), this); ((Vloer)resultaat).plaatsPersoon (mannetje); break; case $ : resultaat=new Vloer (); ((Vloer) resultaat).plaatsvoorwerp(new Schat()); break; default: resultaat=new Vloer (); return resultaat; Tekenen van de wereld Het valt te verwachten dat er wel vaker objecten zijn die getekend moeten worden en waarvoor we niet gewoon een bestaande figuur kunnen gebruiken. Het is dus interessant om een algemene interface te maken om alle soorten objecten die tekenbaar zijn te behandelen. Hierin steken we een methode om op een bepaalde plaats op een canvas, dat object te tekenen. We geven de verzameling van figuren mee die door dat object gebruikt kunnen worden. Ook de breedte en de hoogte van een object kunnen afhangen van de gebruikte figuren. import bvp.*; public interface Tekenbaar { public void tekenop(figuur canvas, int x, int y, Figuren figuren); public int geefbreedte(figuren figuren); public int geefhoogte (Figuren figuren); We laten de abstracte klasse Vak, de interface Tekenbaar implementeren. public abstract class Vak implements Tekenbaar { public void tekenop (Figuur canvas, int x, int y, Figuren figuren) { tekenvak(canvas, x, y, figuren); protected abstract String geeffiguurnaam(); public void tekenvak(figuur canvas, int x, int y, Figuren figuren) { canvas.plaatsfiguur(figuren.getfiguur(geeffiguurnaam()), x, y); public int geefbreedte (Figuren figuren) { return figuren.getfiguur(geeffiguurnaam()).getbreedte (); public int geefhoogte (Figuren figuren) { return figuren.getfiguur(geeffiguurnaam()).gethoogte(); 5

6 De klasse Muur wordt dan eenvoudig: public class Muur extends Vak { protected String geeffiguurnaam() { return muur ; De klasse Vloer wordt dan: public class Vloer extends Vak { protected String geeffiguurnaam() { return "vloer"; public void tekenvak(figuur canvas, int x, int y, Figuren figuren) { super.tekenvak(canvas, x, y, figuren); if (bevatpersoon()) { geefpersoon().tekenop(canvas, x, y, figuren); else if (bevatvoorwerp()) { geefvoorwerp().tekenop(canvas, x, y, figuren);... We gaan dus ook Persoon en Voorwerp, de interface Tekenbaar laten implementeren. Als we de wereld willen tekenen, moeten we een tabel van tekenbare objecten tekenen. Ofwel tekenen we de hele tabel, ofwel slechts een klein venster (zie subopgave A). In dat laatste geval moeten natuurlijk ook de positie van dat venster in de tabel opgeven. Het lijkt interessant om een aparte klasse te maken, die al deze parameters bijhoudt. Op die manier kunnen we ook meerdere vensters op dezelfde wereld (met verschillende parameters maken). Bij voorbeeld een klein venster (met grote tegels) rond het mannetje, en daarnaast de hele wereld met kleine tegels. De klasse TabelVenster is een Tekenbaar object. We implementeren dus de methodes van deze interface. Daarnaast maken we nog een paar methodes om de instantievariabelen aan te passen. De variabele buitenfiguur bevat de naam van de figuur die gebruikt wordt als onze klasse cellen moet tekenen die buiten de tabel liggen. Als we de hele tabel willen tonen, moeten we bij oproep van de constructor, de rijen en kolommen van het venster even groot nemen als die van de tabel. De constructor verwacht een tabel van type Tekenbaar[][]. Aangezien Vak de interface Tekenbaar implementeert, kunnen we dus ook een tabel van type Vak[] [] meegeven. We kunnen deze klasse dus hergebruiken voor andere tabellen, zolang de elementen van die tabel maar de interface Tekenbaar implementeren. import bvp.*; public class TabelVenster implements Tekenbaar { 6

7 protected int rijen; protected int kolommen; protected Positie positie; protected Tekenbaar[] [] cellen; protected String buitenfiguur; public TabelVenster(int kolommen, int rijen, Tekenbaar[][] cellen) { this.kolommen=kolommen; this.rijen=rijen; this.cellen=cellen; positie=new Positie (0,0); public void tekenop (Figuur canvas, int x, int y, Figuren figuren) { int celbreedte=cellen[0][0].geefbreedte(figuren); int celhoogte=cellen[0][0].geefhoogte(figuren); int canvasx=x; int canvasy; for (int i=positie.geefx(); i<kolommen+positie.geefx(); i++) { canvasy=y; for (int j=positie.geefy(); j<rijen+positie.geefy(); j++) { if (i>=0 && j>=0 && i<cellen[0].length && j<cellen.length) { cellen[j][i].tekenop(canvas, canvasx, canvasy, figuren); else { canvas.plaatsfiguur(figuren.getfiguur(buitenfiguur), canvasx, canvasy); canvasy+=celhoogte; canvasx+=celbreedte; public int geefbreedte(figuren figuren) { int celbreedte=cellen[0][0].geefbreedte(figuren); return celbreedte*kolommen; public int geefhoogte(figuren figuren) { int celhoogte=cellen[0][0].geefhoogte(figuren); return celhoogte*rijen; public int geefaantalkolommen() { return kolommen; public int geefaantalrijen() { return rijen; public void zetvensterpositie(positie positie) { this.positie=positie; 7

8 public void zetbuitenfiguur(string figuur) { buitenfiguur=figuur; Het mannetje besturen en kruimels leggen Het is duidelijk dat we een lus zullen maken die de toetsen die de gebruiker intikt verwerkt, en het mannetje laat bewegen. We moeten echter nog beslissen waar die code gedefinieerd moet worden. In de klasse Wereld lijkt niet zo n goed idee, aangezien gebruikersinvoer inlezen niet zo veel met het voorstellen van een wereld te zien heeft. We kunnen het zoeken van de schat ook voorstellen met de klasse Zoektocht. Klassen zijn zeker niet altijd concrete objecten. Het kunnen ook begrippen zijn. We houden in deze klasse enerzijds de wereld bij waarin we aan het zoeken zijn, en anderzijds het bord en de figuren die we gebruiken om die zoektocht te visualiseren. We kunnen in deze klasse dan de methode zoek() definiëren, die de lus zal bevatten, op hoog niveau kunnen we zeggen dat we zolang de schat niet gevonden is, wachten op invoer van het toetsenbord, en dit commando dan verwerken. public class Zoektocht { Wereld doolhof; TabelVenster venster; Figuren figuren; Bord bord; Figuur basis; public static void main(string[] args) { Zoektocht tocht=new Zoektocht(); tocht.zoek(); public Zoektocht() { bord=new Bord("Doolhof"); figuren=new Figuren(); maakdoolhof(); venster=maakvenster(doolhof); basis=new Figuur(venster.getBreedte(figuren), venster.gethoogte(figuren)); public void zoek() { venster.tekenop(basis, 0, 0, figuren); bord.toon(basis); while (!schatgevonden()) { String line= bord.getscanner().nextline(); if (line.startswith("toetsenbord")) { Scanner linescan=new Scanner (line); linescan.next(); //"toetsenbord" overslaan String toets=linescan.next (); verwerkcommando (toets); 8

9 Het probleem is dus weer vereenvoudigd tot een methode die aangeeft of de schat gevonden is, en een methode om een commando te verwerken. We kunnen het mannetje 4 commando s geven. Ga naar links, naar rechts, naar boven en naar onder. Maar in de 4 gevallen gebeurt eigenlijk hetzelfde. We testen of het vakje in de opgegeven richting begaanbaar is. Als dat zo is dan laten we het mannetje in die richting stappen. De methode wordt dus: public void verwerkcommando(string toets) { Richting richting=vindrichting(toets); if (richting!=null) { Positie huidig=doolhof.geefmannetje().geefpositie(); Positie volgende=doolhof.volgrichting(huidig, richting); doolhof.geefmannetje().ganaar(volgende); //teken het veranderde bord rooster.tekenop(basis, 0,0, figuren); bord.toon(basis); Nu moeten we dus nog een methode vindrichting maken en een klasse Richting. In doolhof kunnen we dan een methode definiëren die de positie teruggeeft, waar je terechtkomt als je vanuit een gegeven positie een bepaalde richting uitstapt. En uiteindelijk moeten we in de klasse Persoon nog een methode ganaar maken. Deze methode moet eerst testen of het mogelijk is om naar die positie te gaan. We doen dit door aan het vakje te vragen of het de doorgang blokkeert of niet. Deze methode is gedefinieerd op Vak. De subklasse Muur zal hier natuurlijk 'true'op antwoorden, terwijl een Vloer hier 'false'op antwoord. public void ganaar(positie volgende) { Vak volgendvak=doolhof.getvak (volgende); if (!volgendvak.blokkeertdoorgang()) { ((Vloer)doolhof.getVak(positie)).verwijderPersoon(); positie=volgende; ((Vloer)volgendVak).plaatsPersoon (this); Kruimels strooien Een Kruimel is net zoals Schat een subklasse van Voorwerp. Een kruimel op een vakje zetten gebeurt dus op dezelfde manier als een schat op een vakje zetten. Het enige wat we moeten aanpassen is de methode verwerkcommando zodat die wanneer 'enter'gedrukt wordt, een kruimel legt op de positie waar het mannetje staat. public void verwerkcommando(string toets) { Richting richting=vindrichting(toets); if (richting!=null) { 9

10 ... else { if (toets.equals("!-enter")) { Positie huidig=doolhof.geefmannetje().geefpositie(); Vak vak=doolhof.geefvak(huidig); if (vak.geefvoorwerp()==null) { vak.plaatsvoorwerp(new Kruimel()); else { vak.verwijdervoorwerp (); Beperkt zicht In sectie 3 hebben we de mogelijkheid al opengelaten om het aantal rijen en kolommen in een Tabel Venster kleiner te maken dan de tabel zelf. De enige uitbreiding om steeds de omgeving rond het mannetje in het venster te zien, is dat we de positie van het venster steeds moeten zetten nadat het mannetje bewogen heeft. Dus in de methode verwerkcommando roepen we een methode centreervenster op voordat we het venster op de wereld tekenen. public void centreervenster(tabelvenster venster) { Positie center=doolhof.geefmannetje().geefpositie(); center=new Positie(center.geefX()-venster.geefAantalKolommen()/2, center.geefy()-venster.geefaantalrijen()/2); venster.zetvensterpositie(center); Onbereikbare posities opvullen We definiëren een methode 'vulop'voor de klasse Doolhof. In deze methode maken we een hulpmatrix. Zoals in de hint in de opgave aangegeven, vullen we die eerst met -1 (voor de muren) en 0 voor de rest. Op de positie van het mannetje (zeker bereikbaar) zetten we een 2. En dan roepen we de methode markeerbereikbaar op. Alle posities die hierna nog steeds 0 zijn in de hulpmatrix, worden in de wereld veranderd naar een muur. public void vulop() { int[][] hulp=new int[vakken.length][vakken[0].length]; for (int i=0; i<hulp[0].length; i++) { for (int j=0; j<hulp.length; j++) { if (vakken[j][i].blokkeertdoorgang()) { hulp[j][i]=-1; else { hulp[j][i]=0; 10

11 Positie bereikbaar=mannetje.geefpositie (); hulp[bereikbaar.geefy()][bereikbaar.geefx()]=2; markeerbereikbaar(hulp); for (int i=0; i<hulp[0].length; i++) { for (int j=0; j<hulp.length; j++) { if (hulp[j][i]==0) { vakken[j] [i]=new Muur(); Om de bereikbare vakjes te vinden blijven we over de wereld lopen om steeds de vakjes die een bereikbaar vakje als buur hebben ook als bereikbaar te markeren. Als je dit eens met de hand op een stukje papier probeert merk je dat het veel sneller gaat als je niet steeds in dezelfde richting de matrix doorloopt. Wij gaan een keer van links naar rechts en van boven naar onder, en een keer van rechts naar links en van onder naar boven. Het is dan ook voldoende om steeds maar twee buren te testen. Vandaar dat we 2 gebruiken i.p.v. 4. public void markeerbereikbaar(int[][] hulp) { int changed; do { changed=0; for (int i=1; i<hulp[0].length; i++) { for (int j=1; j<hulp.length; j++) { if (hulp[j][i]==0 && hulp[j][i-1]+hulp[j-1][i]>0) { hulp[j][i]=2; changed++; for (int i=hulp[0].length-2; i>=0; i--) { for (int j=hulp.length-2; j>=0; j--) { if (hulp[j] [i]==0 && hulp[j] [i+1]+hulp[j+1] [i]>0) { hulp[j] [i]=2; changed++; while (changed!=0); Muren uit één stuk We gaan zoals in de opgave staat aangegeven, elke muur tekenen als 4 aparte stukken. We maken hiervoor een methode tekenvak in de klasse Muur, die de methode in de superklasse Vak vervangt. We houden in de klasse Muur ook 4 instantievariabelen bij, die aangeven welke soort muurdeel moet getekend worden. Deze variabelen van type String heten muurbl, muurbr, muurol en muuror. 11

12 public void tekenvak (Figuur canvas, int x, int y, Figuren figuren) { Figuur bl=figuren.getfiguur(muurbl); if (bl==null) { //Als er geen muurdelen gedefinieerd zijn in het set van //tegelfiguren dat we gebruiken, gebruiken we de originele //muur figuur canvas.plaatsfiguur(figuren.getfiguur("muur"), x, y); else { int h=bl.gethoogte(); int b=bl.getbreedte(); canvas.plaatsfiguur(bl, x, y); canvas.plaatsfiguur(figuren.getfiguur(muurbr), x+b, y); canvas.plaatsfiguur(figuren.getfiguur(muurol), x, y+h); canvas.plaatsfiguur(figuren.getfiguur(muuror), x+b, y+h); Op de moment dat het doolhof gemaakt wordt, kennen we nog niet alle buren van een gegeven muur (de volgende rij is nog niet ingelezen). En als we muren opvullen kan dat ook nog veranderen. Daarom wachten we tot het doolhof af is, en lopen dan nog eens over alle muren. Elke muur moet dan zijn buren checken, en de juiste waarden in de variabelen voor de muurdelen invullen. We roepen daarvoor de methode pasmurenaan op, op het doolhof. In deze methode kijken we of de buren muren zijn. Als een buur buiten de wereld valt, is die buur een muur als we het doolhof opgevuld hebben, en anders is het geen muur. We houden een instantievariabele opgevuld bij in doolhof, die aangeeft of de onbereikbare plaatsen opgevuld zijn of niet. public void pasmurenaan() { int maxx=vakken[0].length; int maxy=vakken.length; for (int i=0; i<=maxx; i++) { for (int j=0; j<=maxy; j++) { if (vakken[j][i].ismuur()) { boolean boven=opgevuld; if (j>0) boven=vakken[j-1][i].ismuur(); boolean bovenrechts=opgevuld; if (j>0 && i<maxx) bovenrechts=vakken[j-1][i+1].ismuur(); boolean rechts=opgevuld; if (i<maxx) rechts=vakken[j][i+1].ismuur(); boolean onderrechts=opgevuld; if (i<maxx && j<maxy) onderrechts=vakken[j+1][i+1].ismuur(); boolean onder=opgevuld; if (j<maxy) onder=vakken[j+1][i].ismuur(); if (i>0 && j<maxy) onderlinks=vakken[j+1][i-1].ismuur(); boolean links=opgevuld; if (i>0) links=vakken[j][i-1].ismuur(); boolean bovenlinks=opgevuld; 12

13 if (i>0 && j>0) bovenlinks=vakken[j-1][i-1].ismuur(); ((Muur)vakken[j][i]).zetBuren(boven, bovenrechts, rechts, onderrechts, onder, onderlinks, links, bovenlinks); De methode zetburen ziet er dan als volgt uit. public void zetburen(boolean boven, boolean bovenrechts, boolean rechts, boolean onderrechts, boolean onder, boolean onderlinks, boolean links, boolean bovenlinks) { int br=(boven?4:0)+(rechts?2:0)+(bovenrechts?1:0); int or=(onder?4:0)+(rechts?2:0)+(onderrechts?1:0); int bl=(boven?4:0)+(links?2:0)+(bovenlinks?1:0); int ol=(onder?4:0)+(links?2:0)+(onderlinks?1:0); muurbl="muurbl"+gettype(bl); muurbr="muurbr"+gettype(br); muurol="muurol"+gettype(ol); muuror="muuror"+gettype(or); private String gettype(int t) { String res=null; switch (t) { case 0: case 1: res="punt"; break; case 2: case 3: res="hor"; break; case 4: case 5: res="ver"; break; case 6: res="hoek"; break; case 7: res="vol"; break; return res; 13

14 Extra uitbreidingen In dit laatste stukje bespreken we nog een paar uitbreidingen, die niet in de opgave stonden. Je kan de code voor het programma met deze uitbreidingen terugvinden in de folder uitbreiding (in de zip model.zip ). Realistischer zicht In de huidige implementatie kunnen we wat we zien beperken tot een klein venster, maar dan kunnen we nog over muren kijken naar stukken waar we nog nooit geweest zijn. We proberen als eerste uitbreiding eens enkel te tonen wat het mannetje kan zien. In een eerste stap maken we een soort bibliotheek om in een tabel te kijken. Stel dat we een kijker hebben die vanuit een bepaalde positie in een tabel de elementen van die tabel kan zien, terwijl sommige elementen het zicht belemmeren. We maken hiervoor een interface 'ZichtElement'en 'Kijker'. public interface ZichtElement { public boolean blokkeertzicht(kijker kijker); public interface Kijker { public void ziet(zichtelement element, int x, int y); public int geefx(); public int geefy(); We maken verder een algoritme 'kijk', dat voor een tabel en een kijker in die tabel, alle elementen bepaalt die zichtbaar zijn voor de kijker (360 graden). Voor elk van de zichtbare elementen zal de methode 'ziet'worden opgeroepen op de kijker. We steken deze methode in de klasse KijkAlgoritme. Deze methode gebruikt ook een hulpklasse ScanElement. Dit algoritme is sterk geoptimaliseerd, trek het je dus niet aan als het niet te volgen is. public class KijkAlgoritme { public static void kijk(kijker kijker, ZichtElement[][] wereld) {... In een tweede stap gaan we dit algoritme gebruiken in ons doolhof programma. Elk vak kan zichtbaar zijn of niet. Na elke stap van ons mannetje hebben we echter een andere versie van ons doolhof, waarin vakken zichtbaar of onzichtbaar worden. We kiezen voor de volgende manier om de zichtbaarheid bij te houden: In elk vakje houden we een variabele 'laatstgezien'bij die aangeeft wanneer het vakje het laatst gezien is (we hogen bij elke versie het versienummer op). We kunnen dan in Vak de volgende methodes definiëren. public boolean isnooitgezien() { return laatstgezien==-1; 14

15 public boolean iszichtbaar() { return laatstgezien==doolhof.geefversie().geefnummer(); public void gezien() { laatstgezien=doolhof.geefversie().geefnummer(); Om te zorgen dat voor elk vakje de variabele laatstgezien de juiste waarde heeft gaan we als volgt tewerk: We passen de klasse Vak aan zodat die de interface ZichtElement implementeert. En we passen de klasse persoon aan zodat die de interface kijker implementeert. Na elke stap van het mannetje roepen we de methode kijk op. De methode ziet in de klasse Persoon roept de methode gezien op voor elk vakje dat hij ziet. We kunnen nu de vakjes anders tekenen afhankelijk of ze zichtbaar zijn of niet. Een eerste mogelijkheid is om alle zichtbare vakjes gewoon te tekenen, en alle onzichtbare vakjes te tekenen door een zwart vakje. Dan wordt er enkel getekend wat het mannetje ziet. Zoals in de figuur hieronder. Een andere mogelijkheid is om de vakjes die nooit gezien zijn zwart te kleuren, de vakjes die zichtbaar zijn gewoon te tekenen, en de vakjes die niet zichtbaar zijn, maar wel ooit gezien, donkerder te tekenen. Dan krijgen we een soort beeld van het geheugen van het mannetje. Een voorbeeld hiervan zie je in de figuur hieronder. 15

16 Voor de tweede mogelijkheid passen we de methode tekenop in de klasse Vak aan als volgt. public void tekenop(figuur canvas, int x, int y, Figuren figuren) { if (iszichtbaar() wereld.alleszichtbaar()) { tekenvak(canvas, x, y, figuren); else { if (isnooitgezien()) { canvas.vulrechthoek(x, y, geefbreedte(figuren), geefhoogte(figuren), new Color (0f, 0f, 0f)); else { tekenvak(canvas, x, y, figuren); canvas.vulrechthoek(x, y, geefbreedte(figuren), geefhoogte(figuren), new Color(0f,0f,0f,.5f)); Als we onze wereld echter met aaneengesloten muren tekenen, dan kunnen we nog altijd een beetje over de muren kijken. We kunnen zien of er een gang of een muur achter ligt. 16

17 Als we dit willen vermijden moeten we onze code aanpassen, zodat de een Muur kan bepalen welke van zijn 4 subdelen zichtbaar is en welke niet. De methode gezien heeft dan wel extra parameters nodig om de richting aan te geven van waaruit we kijken. We roepen gezien daarom als volgt op in de methode ziet van Persoon. ((Vak)element).gezien(x-positie.geefX(), y-positie.geefy()); In de klasse Muur herschrijven we de methodes gezien, tekenop en isveranderd, zodat die elk muurdeel apart behandelen. 17

18 Snellere visualisatie In de huidige implementatie tekenen we alles steeds opnieuw. Het is echter voldoende om alleen de vakjes die effectief veranderd zijn te hertekenen. In de oorspronkelijke versie was dit alleen de oude positie van het mannetje en de nieuwe positie. In de uitgebreide versie zijn dit echter ook de vakjes die zichtbaar of onzichtbaar worden. We vullen de interface Tekenbaar aan met een methode isveranderd(). Voor de klasse Vak geeft deze methode aan of het vak aangepast is ten opzichte van de voorgaande versie van de wereld. public boolean isveranderd() { boolean res=laatstveranderd==wereld.geefversie().geefnummer(); // we controleren of het vak onzichtbaar geworden is in deze versie res = res laatstgezien==wereld.geefversie().geefnummer()-1; return res; public void zetveranderd() { laatstveranderd=wereld.geefversie().geefnummer(); De methode zetveranderd wordt opgeroepen in de methodes verwijdervoorwerp, plaatsvoorwerp, verwijderpersoon, plaatspersoon, en in de methode gezien wanneer het vak in de vorige versie nog onzichtbaar was. Nu kan de methode tekenop in de klasse TabelVenster aangepast worden zodat alleen de veranderde objecten opnieuw getekend worden. Merk op dat wanneer we een klein gecentreerd venster van de wereld tekenen, we ook de vakken moeten hertekenen die niet veranderd zijn, omdat het venster van positie veranderd. We laten dus een optie toe in de klasse TabelVenster om toch alles te hertekenen wanneer nodig. Zo kunnen we een venster op de wereld maken dat steeds volledig hertekend word, en daarnaast de volledige wereld tekenen, waarbij enkel de veranderingen getekend worden. 18