Java, som er språket eclipse er skrevet i, er et objektorientert språk. Begrepet “objektorientert programmeringsspråk” kommer fra Universitetet i Oslo, på 1960-tallet og fra et språk som heter Simula.

Som navnet “Simula” antyder, så var språket beregnet på å gjøre datasimuleringer. Ideen var at man skulle beskrive ting i den virkelige verden med objekter i datamaskinen, og at objektene skulle ha sin egen kode som beskrev oppførsel og hvordan de reagerte mot andre objekt.

I simuleringa skal vi la en drage og et troll vandre fra rom til rom i ei grotte.

Om dragen og trollet møtes i samme rom, vil de slåss. Normalt vil trollet vinne over dragen.

Men det vil også finnes en gullskatt i et av rommene, og om dragen kommer over gullskatten før den treffer trollet, så vil dragen bli i det rommet og beskytte gullskatten. Gullskatten vil også gi dragen styrke sånn at den klarer å vinne over trollet, om trollet skulle virre inn i rommet til dragen.

Start eclipse og i “Select a workspace”-dialogen, angi

C:userssteinarbworkspacesmonstersim

(bytt ut “steinarb” med navnet på din egen bruker)

Velg du fra menyen

File -> Java Project

I “Project name:” skriver du

monstersim

og klikk på “Finish”-knappen, og klikk på teksten “Workbench” i vinduet under.

Høyreklikk så på “monstersim” i “Package Explorer” (til venstre i Eclipse) og velg “Package”. I Name-ruta, gi teksten:

no.example.monstersim

Høyreklikk så på teksten “no.example.monstersim”, og velg

New -> Class

I “Name:” skriver du:

Monstersim

Klikk også i sjekkboksen ved teksten “public static void main(String[] args”, og klikk så på “Finish”-knappen.

I Monstersim.java som dukker opp i Eclipse, endre main()-metoden, til:

public static void main(String[] args) {
        int numberOfSimulations = 10;
        int caveWidth = 3;
        int caveHeight = 3;
        Simulator simulator = new Simulator(caveWidth, caveHeight);

        simulator.simulate(numberOfSimulations);
}

I venstre marg på Monstersim.java, så vises et ikon som består av ei lyspære, delvis overlappet av en rød firkant med en hvit “X” i seg.

Når du klikker på dette ikonet vil meny (“quick fix”-menyen) åpne seg. Dobbeltklikk på valget

Create class "Simulator"

I “Java Class”-dialogen, klikk på “Finish”-knappen. En ny tab med “Simulator.java” vil åpne seg.

Nede i eclipse er det en tab som heter “Problems”. Velg “Problems. I “Problems”, er det to linjer som starter med samme ikon som det du klikket på. Høyreklikk på linja som sier

The constructor Simulator(int, int) is undefined

og velg “Quick Fix”.

Velg

Create constructor "Simulator(int, int)"

og klikk på “Finish”-knappen. Eclipe bytter til Simulator.java igjen. Bytt ut TODO-linja i “Simulator(int, int)” sånn at konstruktøren blir seende sånn ut:

public Simulator(int caveWidth, int caveHeight) {
        this.caveWidth = caveWidth;
        this.caveHeight = caveHeight;
}

Set cursoren på “this.caveWidth” i første linje, og trykk “Ctrl-1” (hold nede “Ctrl”-tasten mens du trykker og slipper “1”). Dette aktiverer vår venn “Quick Fix”. Velg

Create field 'caveWidth'

Trykk Ctrl-. (hold nede Ctrl og trykk og slipp punktum-tasten) for å gå til neste feil, og trykk Ctrl-1 og bruk “Quick Fix” for å lage et felt for “caveHeight” også.

Velg fra toppmenyen

File -> Save All

I Problems-tabben står ei linje med teksten “The method simulate(int) is undefined for the type Simulator” (det er også to Warnings, men dem bryr vi oss ikke om nå). Høyreklikk på linja, velg “Quick Fix” og i “Quick Fix”-dialogen, velg linja

Create method 'simulate(int)' in type 'Simulator'

og klikk på “Finish”-knappen.

Velg nok en gang fra toppmenyen

File -> Save All

Endre Simulator.simulate()-metoden sånn at den ser sånn ut:

public void simulate(int numberOfSimulations) {
        System.out.println("Simulating a " + caveWidth + "x" + caveHeight + " cave:");
        Cave cave = new Cave(caveWidth, caveHeight);
        List<Actor> actors = setupActors();
        cave.addActorsToRooms(actors);
        cave.printDescriptions();
        for (int simulationStepNumber=0; simulationStepNumber<numberOfSimulations; ++simulationStepNumber) {
                Actor deadActor = oneStep(simulationStepNumber, actors);
                if (null != deadActor) {
                        System.out.println(deadActor.getName() + " is dead.  Ending simulation!");
                        return ;
                }
        }
}

Sett kursoren på “Cave” i “Cave cave”, og så Ctrl-1, og velg

Create class 'Cave'

Ta Ctrl-Shift-s for å lagre alle filer.

Ta Ctrl-F6 for å gå til “Simulator.java”. Ta Ctrl-. for å gå til neste feil, og så “Quick Fix” og velg

Create constructor 'Cave(int, int)'

Trykk RET to ganger.

Ta Ctrl-Shift-s for å lagre alle filer.

Ta Ctrl-F6 for å gå til “Simulator.java”. Ta Ctrl-. for å gå til neste feil, og så “Quick Fix” og velg

Import 'List' (java.util)

Ny Ctrl-., og så ny “Quick Fix” og velg

Create class 'Actor'

klikk på Finish.

Ta Ctrl-Shift-s for å lagre alle filer, og så Ctrl-F6 for å gå tilbake til Simulator.java.

Gå til feilen ved “setupActors()” og ny “Quick Fix” og velg

Create method 'setupActors()'

Gå til feilen ved “addActorsToRoom” og ta “Quick Fix” og velg

Create method 'addActorsToRoom(List<Actor>)' in type 'Cave'

Trykk RET to ganger for å velge default-verdier, og så lagre alle filer.

Gå tilbake til Simulator.java og velg feilen ved “printDescription” og ta “Quick Fix” og velg

Create method 'printDescriptions() in type 'Cave'

trykk RET to ganger, og så Ctrl-Shift-s for å lagre alle filer.

Gå til feilen ved “oneStep”, ta “Quick Fix” og velg

Create method 'oneStep(int, List<Actor>)'

Gå til feilen ved “getName”, ta “Quick Fix” og velg

Create method 'getName()' in type 'Actor'

trykk RET to ganger svar for å velge default-verdier og lagre alle filer, med Ctrl-Shift-s.

Bruk Ctrl-F6 til å bytte tilbake til Simulator.java og endre “oneStep” sånn at metoden blir seende sånn ut:

private Actor oneStep(int simulationStepNumber, List<Actor> actors) {
        System.out.println("Simulation step: "+(simulationStepNumber+1));
        moveTheActors(actors);
        letActorsAct(actors);
        return checkForDeadActors(actors);
}

Velg feilen i “checkForDeadActors”.

Bruk så “Quick Fix” (først Ctrl-1, så Ctrl-, til å gå til forrige feil, så Ctrl-1 for å trigge “Quick Fix”, så Ctrl-, for å gå til forrige feil osv.) til å lage de tre manglende metodene. Grunnen til å ta “Quick Fix” baklengs, er for å få de nylagde metodene i logisk rekkefølge i fila. “Quick Fix” lager alltid nye metoder rett under den metoden du står i når du kjører “Quick Fix”.

Bytt ut TODO i “moveTheActors”:

private void moveTheActors(List<Actor> actors) {
        for (Actor actor : actors) {
                actor.move();
        }
}

(om du bruker kopiering og liming herfra, vil innrykket på siste klammeparantes være feil)

Ta “Quick Fix” på feilen i “move” og velg

Create method 'move()' in type 'Actor'

trykk RET to ganger for å velge default, og lagre alle filer. Ta Ctrl-F6 for å gå tilbake til Simulator.java.

Ta Ctrl-Shift-f (hold nede Ctrl og Shift, mens du trykker og slipper f-tasten). Det vil reformatere Simulator.java og sørge for at innrykket på siste klammeparantes blir riktig.

Bytt ut TODO i “letActorsAct”:

private void letActorsAct(List<Actor> actors) {
        for (Actor actor : actors) {
                actor.act();
        }
}

Ta “Quick Fix” på feilen i “move” og velg

Create method 'act()' in type 'Actor'

trykk RET to ganger for å velge default, og lagre alle filer. Ta Ctrl-F6 for å gå tilbake til Simulator.java.

Om innrykket på nest siste klammeparantes er feil, ta en ny Ctrl-Shift-f.

Bytt ut TODO i “checkForDeadActors”:

private Actor checkForDeadActors(List<Actor> actors) {
        for (Actor actor : actors) {
                if (actor.isDead()) {
                        return actor;
                }
        }

        return null;
}

Ta “Quick Fix” på “isDead” og velg

Create method 'isDead()' in type 'Actor'

trykk RET to ganger for å velge default, og lagre alle filer. Ta Ctrl-F6 for å gå tilbake til Simulator.java.

Om innrykket på nest siste klammeparantes er feil, ta en ny Ctrl-Shift-f.

“Motoren” i simuleringen består av løkker. Ytterst er en løkke som teller gjennom alle stegene i simuleringen. For hvert steg går man gjennom løkker som animerer alle deltagerene i simuleringen.

Gå til Cave.java og bytt ut TODO i konstruktøren “Cave(caveWidth, caveHeight)” med:

public Cave(int caveWidth, int caveHeight) {
        this.caveWidth = caveWidth;
        this.caveHeight = caveHeight;
        createCave();
        connectRooms();
}

Sett kursoren på “caveWidth” i “this.caveWidth” og ta “Quick Fix”, og velg:

Create field 'caveWidth' in type 'Cave'

Gjør det samme for “caveHeight”

La “Quick Fix” lage metodene “createCave” og “connectRooms” og lagre alle filer.

Merk: “Outline”-vinduet til høyre i Eclipse viser metodene etterhvert som du lager dem. Ved å klikke på metodene der kan du navigere rett til metoden. Du kan også endre rekkefølgen på metodene med å dra og slippe dem i Outline-vinduet.

Merk2: På høyre side av Cave.java-vinduet vises blå firkanter for alle linjene som inneholder TODO. Ved å klikke på en blå firkant kan du navigere rett til TODO-linja.

Bytt ut TODO i “createCave” med dette:

private void createCave() {
        rooms = new Room[caveWidth][caveHeight];
        for (int xPos=0; xPos<caveWidth; ++xPos)
        {
                for (int yPos=0; yPos<caveHeight; ++yPos)
                {
                        rooms[xPos][yPos] = new Room(xPos, yPos);
                }
        }
}

Sett kursoren over “Room” i første linje og la “Quick Fix” lage klassen “Room”. Lagre alle filer og bruk Ctrl-F6 til å gå tilbake til Cave.java.

Sett kursoren over “rooms” i første linje og la “Quick Fix” lage feltet rooms, som skal se slik ut når det er ferdig:

private Room[][] rooms;

La “Quick Fix” lage konstruktøren “Room(int, int)”, og endre metoden til dette:

public Room(int xPos, int yPos) {
        super();
        name = "Room at (" + xPos + "," + yPos + ")";
}

La “Quick Fix” lage feltet “name”, og lagre alle filer.

Ta Ctrl-F6 for å gå tilbake til Cave.java. Bytt så ut innholdet i “connectRooms” med dette:

private void connectRooms() {
        for (int xPos=0; xPos<caveWidth; ++xPos)
        {
                for (int yPos=0; yPos<caveHeight; ++yPos)
                {
                        Room room = rooms[xPos][yPos];

                        if (xPos>0)
                        {
                                Direction direction = Direction.WEST;
                                Room neighbour = rooms[xPos-1][yPos];
                                room.setNeighbour(direction, neighbour);
                        }

                        if (xPos<caveWidth-1)
                        {
                                room.setNeighbour(Direction.NORTH, rooms[xPos+1][yPos]);
                        }

                        if (yPos>0)
                        {
                                room.setNeighbour(Direction.EAST, rooms[xPos][yPos-1]);
                        }

                        if (yPos<caveHeight-1)
                        {
                                room.setNeighbour(Direction.SOUTH, rooms[xPos][yPos+1]);
                        }
                }
        }
}

Sett kursoren på første feil i “Direction direction”, ta “Quick Fix” og velg:

Create enum 'Direction'

og klikk på “Finish”-knappen (eller bare trykk RET), lagre alle filer.

Ta Ctrl-F6 for å komme tilbake til Cave.java. Ta Ctrl-. for å gå til “WEST” og Ctrl-1 for å velge “Quick Fix” og velg så

Create enum constant 'WEST' in 'Direction'

Lagre alle filer og ta Ctrl-F6 for å komme tilbake til Cave.java og ta “Quick Fix” på “setNeighbour” og velg

Create method 'setNeighbour(Direction, Room)' in type 'Room'

og trykk RET to ganger for å velge default-verdier. Endre metoden til dette:

public void setNeighbour(Direction direction, Room neighbour)
{
        neighbours.put(direction, neighbour);
}

Gjør så en “Quick Fix” på “neighbours” og lag et felt. Endre feltet så det blir seende sånn ut (det blir default av type Object):

Map<Direction, Room> neighbours = new EnumMap<Direction, Room>(Direction.class);

Lagre alle filer og sett kursoren på “Map”, ta “Quick Fix”, og velg:

Import 'Map' (java.util)

Ta Ctrl-. og så Ctrl-1 og velg:

Import 'EnumMap' (java.util)

og lagre så alle filer.

Lagre alle filer og ta Ctrl-F6 for å komme tilbake til Cave.java og bruk så Ctrl-. og Ctrl-1 for å lage de resterende enum-konstantene. Lagre alle filer når du er ferdig, og gå til Cave.java.

Gå til “printDescriptions”, og endre TODO sånn at metoden blir seende sånn ut:

void printDescriptions() {
        for (int xPos=0; xPos<caveWidth; ++xPos)
        {
                for (int yPos=0; yPos<caveHeight; ++yPos)
                {
                        System.out.print(rooms[xPos][yPos].describe());
                }
        }
}

Gjør “Quick Fix” på linja med “describe()” og velg

Create method 'describe()' in type 'Room'

trykk RET en gang for å velge default, og skriv så “strin” (uten anførselstegn), skriv Ctrl-SPC og trykk RET.

Endre innhold i den nylagde metoden sånn at den blir seende sånn ut:

public String describe()
{
        if (contents.size()>0)
        {
                StringBuffer sb = new StringBuffer(name);
                sb.append(" contains:n");
                for (Actor actor : contents)
                {
                        sb.append(" ");
                        sb.append(actor.describe());
                        sb.append("n");
                }

                return sb.toString();
        }

        return "";
}

Gjør “Quick Fix” på feilen i “describe” og velg

Create field 'contents'

Trykk F3 for å gå til “contents” og endre feltet fra en Map til et Set:

Set<Actor> contents = new HashSet<Actor>();

“Quick Fix” feilen i Set og velg:

Import 'Set' (java.util)

“Quick Fix” feilen i HashSet og velg:

Import 'HashSet' (java.util)

Lagre alle filer med Ctrl-Shift-s.

Trykk Ctrl-. for å gå til feilen i “describe” og bruk “Quick Fix” og velg

Create method 'describe()' in type 'Actor'

trykk RET en gang for å velge default, og skriv så “strin” (uten anførselstegn), skriv Ctrl-SPC og trykk RET.

Endre “describe()” fra dette:

public String describe() {
        // TODO Auto-generated method stub
        return null;
}

til dette

public abstract String describe();

Lagre alle filer.

Ta “Quick Fix” på “describe”, og velg:

Make type 'Actor' abstract

Lagre alle filer og bruk Ctrl-F6 til å gå til Cave.java.

Sett kursoren på “name” og gjør “Quick Fix”, og velg:

Create getter and setter for 'name'

I dialogen “Encapsulate Field”, trykk på “OK”-knappen.

Lagre alle filer.

Gå til Cave.java, finn metoden “addActorsToRooms” og endre den til å se sånn ut:

void addActorsToRooms(List<Actor> actors) {
        for (Actor actor : actors) {
                rooms[randX()][randY()].enter(actor);
        }
}

Bruk “Quick Fix” for å lage metoden “randX” og endre den til å se sånn ut:

private int randX() {
        return randomGenerator.nextInt(caveWidth);
}

Bruk “Quick Fix” til å lage feltet “randomGenerator”, trykk F3 for å navigere til feltet og endre det fra

private Object randomGenerator;

til

private Random randomGenerator = new Random();

Bruk “Quick Fix” på “Random” og velg

Import 'Random' (java.util)

Gå til feilen med Ctrl-. og bruk “Quick Fix” til å lage metoden “randY”, som så endres til:

private int randY() {
        return randomGenerator.nextInt(caveHeight);
}

Sett kursoren i “enter”, bruk “Quick Fix” til å lage metoden i Room, og endre metoden “enter” sånn at den blir seende sånn ut:

public void enter(Actor actor) {
        contents.add(actor);
        actor.setCurrentLocation(this);
}

Lagre alle filer.

Gjør “Quick Fix” på “setCurrentLocation” og velg:

Create method 'setCurrentLocation(Room)' in type 'Actor'

trykk RET to ganger for å velge default

Endre innholdet i “setCurrentLocation” sånn at den blir seende sånn ut:

public void setCurrentLocation(Room room) {
        currentLocation = room;
}

Bruk “Quick Fix” til å lage feltet “currentLocation”.

Dette er objektene som blir animert av Simulator.

public String getName() {
        return name;
}

public void move() {}
public void act() {}

public boolean isDead() {
        return dead;
}

Source -> Generate Getters and Setters...

New -> Class

Source -> Override/Implement Methods...

@Override
public void move() {
        if (isDead()) {
                return;
        }

        Room thisRoom = getCurrentLocation();
        Direction direction = randomDirection();
        Room nextRoom = thisRoom.getNeighbour(direction);
        while (null == nextRoom) {
                nextRoom = thisRoom.getNeighbour(randomDirection());
        }

        thisRoom.leave((Actor)this);
        nextRoom.enter(this);
        System.out.println(" " + getName() + " moves from " + thisRoom.getName() + " to " + nextRoom.getName());
}

Direction randomDirection() {
        double number = Math.random();
        if (number < 0.25) {
                return Direction.WEST;
        } else if (number < 0.5) {
                return Direction.NORTH;
        } else if (number < 0.75) {
                return Direction.EAST;
        }

        return Direction.SOUTH;
}

Create method 'getNeighbour(Direction)' in type 'Room'

public Room getNeighbour(Direction direction)
{
        return neighbours.get(direction);
}

Create method 'leave(Monster)' in type 'Room'

public void leave(Actor actor) {
        actor.setCurrentLocation(null);
        contents.remove(actor);
}

@Override
public void act() {
        if (isDead()) {
                return;
        }

        Set<Actor> roomContents = getRoomContentsExceptForMe();
        look(roomContents);
        take(roomContents);
        fight(roomContents);
}

Import 'Set' (java.util)

Create method 'getRoomContentsExceptForMe'

private Set<Actor> getRoomContentsExceptForMe() {
        Set<Actor> roomContents = getCurrentLocation().getContents();
        roomContents.remove(this);
        return roomContents;
}

Create method "getContents()" in type 'Room'

public Set<Actor> getContents() {
        return new HashSet<Actor>(contents);
}

Create method 'fight(Set<Actor>)

public void look(Set<Actor> roomContents)
{
        if (roomContents.size() > 0) {
                System.out.println(" " + getName() + " sees the following actors: ");
                for (Actor actor : roomContents) {
                        System.out.println("  " + actor.describe());
                }
        }
}

public void take(Collection<Actor> roomContents)
{
        Actor thePicker = this;
        for (Actor actor : roomContents) {
                actor.pickedUpBy(thePicker);
        }
}

Create method 'pickedUpBy(Actor)' in type 'Actor'

public void pickedUpBy(Actor thePicker) {
        // TODO Auto-generated method stub

}

public void pickedUpBy(Actor thePicker) {}

public void fight(Collection<Actor> roomContents)
{
        Actor opponent = this;
        for (Actor actor : roomContents) {
                actor.fightMe(opponent);
        }
}

public void fightMe(Actor opponent) {
        // TODO Auto-generated method stub

}

public void fightMe(Actor opponent) {}

public double strength() { return 0.0; }
public void takeMe(Actor pickedUpThing) {}

Source -> Override/Implement Methods...

@Override
public void fightMe(Actor opponent) {
        System.out.println(" " + opponent.getName() + " fights " + getName() + "!");
        if (opponent.strength() > strength()) {
                setDead(true);
                System.out.println(" Arrrrgh! " + getName() + " dies!");
        }
}

New -> Class

@Override
public String describe() {
        return "A dragon with green shimmering scales";
}

Source -> Generate Constructors from Superclass...

public Dragon() {
        super();
        setName("Dragon");
}

Source -> Override/Implement Methods...

@Override
public void takeMe(Actor pickedUpThing) {
        if (null == gold) {
                gold = pickedUpThing;
                System.out.println(" " + getName() + " picked up " + pickedUpThing.getName());
        }
}

gold = pickedUpThing

@Override
public double strength() {
        double myStrength = 0.25;
        if (null == gold) {
                return myStrength;
        }

        return myStrength + gold.strength();
}

@Override
public void move() {
        // A dragon that has found gold stays with it.
        if (null == gold) {
                super.move();
        }
}

New -> Class

@Override
public String describe() {
        return "A warty and ugly troll";
}

Source -> Generate Constructors from Superclass...

public Troll() {
        super();
        setName("Troll");
}

Source -> Override/Implement Methods...

@Override
public double strength() {
        return 0.4;
}

New -> Class

@Override
public String describe() {
        return "A mound of gold";
}

Source -> Generate Constructors from Superclass...

public Gold() {
        super();
        setName("Gold");
}

Source -> Override/Implement Methods...

@Override
public double strength() {
        return 0.5;
}

@Override
public void pickedUpBy(Actor thePicker) {
        thePicker.takeMe(this);
}

Nå gjenstår bare en kodebit. Gå til Simulator.java og finn metoden “setupActors” og endre den til dette:

private List<Actor> setupActors() {
        ArrayList<Actor> actors = new ArrayList<Actor>();
        actors.add(new Dragon());
        actors.add(new Gold());
        actors.add(new Troll());
        return actors;
}

Bruk “Quick Fix” på feilen i ArrayList og velg:

Import 'ArrayList' (java.util)

Lagre alle filer.

Så kan simuleringen kjøres. Bruk Ctrl-F6 til å gå til Monstersim.java. Kjør fra menyen:

Run -> Run As -> Java Application

(påfølgende kjøringer kan gjøres med Ctrl-F11)

Da vil en utskrift av en simulering komme i Console-vinduet i eclipse. Her er et eksempel på ei simulering:

Simulating a 3x3 cave:
Room at (0,2) contains:
 A dragon with green shimmering scales
Room at (1,1) contains:
 A warty and ugly troll
Room at (2,1) contains:
 A mound of gold
Simulation step: 1
 Dragon moves from Room at (0,2) to Room at (1,2)
 Troll moves from Room at (1,1) to Room at (1,2)
 Dragon sees the following actors: 
  A warty and ugly troll
 Dragon fights Troll!
 Troll sees the following actors: 
  A dragon with green shimmering scales
 Troll fights Dragon!
 Arrrrgh! Dragon dies!
Dragon is dead.  Ending simulation!

Merk: Dobbeltklikk på Console-tabben for å la Console fylle hele Eclipse-vinduet. Dobbelt-klikk på Console-tabben igjen, for å ta den ned til normal størrelse. Denne oppførselen gjelder alle vindu i Eclipse. Tastatursnarveien til denne kommandoen er Ctrl-m.

Noen ting å merke seg:

• Dette programmet ble skrevet fra toppen og nedover, fordi vi visste hvor vi skulle. Det er som regel ikke tilfelle. Som regel starter man med de objektene man vet skal være med (i dette tilfelle i første omgang Dragon, Troll og Gold, og kanskje Room), og så begynner man å lage metoder for det man vet de skal gjøre: flytte på seg, se seg om, ta opp gjenstander, slåss. Så leter man etter felles ting med gjenstandene og lager super-typer (Monster for både Dragon og Troll og Actor for typene til alle objektene som skal delta i simuleringen)
• Mesteparten av koden er rammeverk. Det er først når man begynner på subtypene til Actor at det kommer ting som faktisk har med simuleringen å gjøre
• Det er kanskje litt rart at gullet er en Actor, ettersom det ikke kan røre på seg? Forklaringen er at det er heller navnet Actor som ikke passer. Alle ting som skal delta i simuleringen bør ha en felles type. Men AThingThatParticipatesInSimulation virket litt langt…
• Det er kanskje litt rart at Room ikke er en Actor, når Gold er det…? Svaret er at i en annen sammenheng og en annen simulering så kunne det vært det. Men i den modellen her så er rom posisjonen til objektet
• Simuleringen er ikke så langt unna starten på et tekstbasert adventure-spill. Det som trengs er
  • at den ytterste løkka i simuleringsmotoren ikke går et endelig antall steg, men at den avbrytes, f.eks. når spilleren avslutter
  • å lage en Actor, som på Actor.act() vil presentere spilleren med en beskrivelse av rommet han befinner seg i, og et spørsmål om hva han vil gjøre (gå? Slåss? Plukke opp en gjenstand?)

Ting å prøve:

• Øke størrelsen på grotta? 3×3 er litt lite. Jeg gjorde den så liten for at monstrene skulle ha større sannsynlighet for å støte på hverandre i løpet av 10 simuleringssteg, som er ca. en skjermside
• En morsommere grotte med mer tilfeldige koblinger?
• Trollet kan kanskje også finne ting som øker styrken? En klubbe, f.eks.?
• Flere monstre?
• Flere gjenstander? (isåfall blir protokollen for å finne gull mer komplisert)
• En rikere interaksjonsprotokoll? Idag har man mulighet for å slåss (“fightMe”) og å plukke opp ting “pickedUpBy”/”takeMe”. Er det flere ting man ønsker å gjøre?
• Mer intelligens i monstrene? Kanskje drager og troll kan lukte gull, og at dragene vil søke mot gull, mens trollene vil unnvike det (kan ikke være absolutt, men kanskje sannsynligheten for å gå i retning av gull kan økes, eller senkes?)
• Bør “look” være en egen operasjon som kjøres av simulatoren, på linje med “move” og “act”? Det vil gjøre det enklere å lage mer intelligens i Actorene
• Spørsmål: hvorfor kjøres “move” separat, og ikke som en del av “act”?