Wie spielt man das eigentlich?

Du musst den Roboter Marvin-10 so programmieren, dass er durch das Labyrinth fährt, dort alle Diamanten aufsammelt und anschließend damit herauskommt. Wenn du das Spiel startest, siehst du erst mal eine ganze Menge. Achte auf das Labyrinth und den Roboter, der ganz unten am Eingang steht.

Spielstart

Marvin-10 kann am Anfang leider überhaupt nichts. Aber du kannst ihn mit Hilfe der Sensorregeln programmieren, die du links im Bild siehst:

Sensor_blank

Und wie funktionieren die Sensorregeln?
Das ist ganz einfach: Links in der Sensorregel beschreibst du einen Zustand und rechts gibst du dem Roboter Befehle, die er ausführen soll, wenn er in diesem Zustand ist. Verändere jetzt die erste Sensorregel zum Beispiel so:

Sensor_filled

Das machst du, indem du mit der linken Maustaste auf die Felder klickst, die du verändern willst. Aber das hast du sicher schon gewußt. Supergut! Die Sensorregel, die du oben siehst, sagt dem Roboter:
"WENN du links und rechts eine Wand siehst, DANN gehe geradeaus".

Drück doch einmal auf den Startknopf, das ist dieser hier:

Start-Button

Der Roboter fährt nun los. Allerdings nicht weit, denn Marvin-10 kennt erst diese eine Regel und er fährt immer nur so weit wie er sich auskennt. Du musst also Marvin-10 noch klüger machen. Verändere dazu die zweite, dritte und vierte Sensorregel, um ihm zum Beispiel zu sagen:
"WENN nur links ein Weg ist, DANN drehe nach links".
Ich bin sicher, du kannst das alleine programmieren. Vier Sensorregeln sollten reichen, damit der Roboter durch das einfache Labyrinth fährt und am Ende mit allen Diamanten herauskommt.

Wenn du gut programmiert hast, holt Marvin-10 alle Diamanten aus dem Labyrinth heraus und in der Statusleiste unter dem Labyrinth bekommst du diese Meldung zu sehen:

geschafft

Wenn du das geschafft hast, dann weisst du bereits wie die Programmierung funktioniert. Allerdings bleibt es nicht so einfach! Klick doch einmal auf Schwierigkeitsgrad ganz oben in der grauen Menüleiste. So kannst du ein komplizierteres Labyrinth auswählen, und wenn du wieder Start drückst, dann werden deine vier Sensorregeln nicht mehr ausreichen und du musst dir weitere ausdenken. Weitere Regeln bekommst du übrigens mit diesem Knopf:

Button

Du hast dich sicher schon gefragt, wozu die anderen Schaltflächen der Sensorregeln da sind. Erinnere dich daran, daß jede Regel, die du machst, aus zwei Teilen besteht:
Einem WENN-Teil links und einem DANN-Teil auf der rechten Seite.
Du kannst bestimmen:
"WENN links und rechts Wände sind UND der Zustand des Roboters blau ist, DANN fahre geradeaus UND wechsle den Zustand auf rot."
Diese Regel sieht so aus:
Sensor, Farbe
Außerdem kann der Roboter Zahlen auf den Boden schreiben und lesen. So kann er markieren, wo er schon war. Praktisch, hm? Die folgende Regel bedeutet: "WENN links und rechts Wände sind UND am Boden eine Null steht, DANN gehe geradeaus und schreibe eine Eins auf den Boden."
Sensor, Zahl
So, jetzt weisst du alles was du brauchst, um Marvin-10 zu programmieren.
Kannst du alle Diamanten kriegen?

Ach ja, wenn dir der Roboter zu langsam ist, kannst du mit dem Schieber die Geschwindigkeit regeln. Du wirst sehen, der kann ganz schön herumflitzen! Wenn du die Geschwindigkeit hingegen auf 0 setzt, dann darfst du bei jeder Bewegung auf den Schritt-Knopf klicken.
Dumm? Nein, ganz und gar nicht, denn so kannst du genau sehen, welche Regel der Roboter verwendet hat und diese sogar ändern!

Der Expertenmodus

Regelsatz editieren

Im Expertenmodus Regelsatz editieren kannst du den Roboter auch neue Regeln lernen! Du brauchst nicht auf die Knöpfe klicken, sondern du schreibst sie einfach hin.
Dafür musst du wirklich kein Experte sein!
"WENN links und rechts Wände sind UND der Zustand des Roboters blau ist, DANN fahre geradeaus UND wechsle den Zustand auf rot."
Da der Satz aber ziemlich lange und für den Roboter schwer zu verstehen wäre, gibt es eine Abkürzung:

(fgf,blau,)->(,nach vorn,rot)

das heißt soviel wie:
WENN ('links Wand''vorne Gang''rechts Wand' , Zustand blau , keine Bodenmarkierung ) DANN (keine Bodenmarkierung, gehen nach vorne, neuer Zustand rot)

Hier findest du alle Wörter, die der Rooter schon schon versteht:

GeländeZuständeBodenmarkierungenBewegungsrichtungen
f -> Wand grün0 nach vorn
g -> Gang blau1nach rechts
rot2nach links
gelb3umdrehen

Was, das sind nicht genug Bodenmarkierungen und Zustände?
Erfinde einfach neue! Du kannst dafür bis zu 30 Zeichen verwenden.

Einen weiteren Vorteil bietet dir der Expertenmode: Wenn du möchtest, dass der Roboter eine von deinen Regeln nicht benützt, dann macht er das auch nicht!. Du brauchst nur // vor die Regel setzen.
Also so:
//(fgf,blau,)->(,nach vorn,rot)

Mehrere Regeln kannst du auch weglassen:
/* (fgf,grün,)->(0,nach vorn,blau)
(ffg,rot,1)->(2,nach rechts,gelb)
(fff,,3)->(,nach links,)
(ggg,,)->(,umdrehen,) */

Auf eines musst du noch aufpassen: Für den Roboter sind 'A' und 'a' NICHT gleich!!!
(FGG,,)->(,nach vorn,) wird er daher nicht verstehen!

Labyrinth editieren

Für das Erstellen eines Labyrinths werden Informationen über die Größe und das Aussehen benötigt.
Da das eine ganze Menge an Daten sind, reichen ein paar einfache Zeichen, wie bei "Regelsatz editieren", nicht mehr aus. Mit XML (Extensible Markup Language) kannst du Regeln erstellen, die von Computerprogrammen leicht verstanden werden können.

Zuerst muss die Neptun Simulation einmal wissen, dass sie jetzt XLM zu lesen bekommt und wie das Dokument aussehen soll.

      <?xml version="1.0" encoding="iso-8859-1"?>
      <!DOCTYPE LabyrinthLevel SYSTEM "LabyrinthLevel.dtd">

Jetzt sagen wir: "Wir wollen ein neues Level generieren, nimm alles was zwischen <LabyrinthLevel> und </LabyrinthLevel> steht."
Achtung! Zwischen diese beiden "Blöcke" definieren wir alles andere!! Das fertige Dokument sollte dann in etwa so aussehen:

      <?xml version="1.0" encoding="iso-8859-1"?>
      <!DOCTYPE LabyrinthLevel SYSTEM "LabyrinthLevel.dtd">
      <LabyrinthLevel>
           ...
            HIER stehen alle Infos, zur Gestaltung des Labyrinths!
           ...
      </LabyrinthLevel>

Name und Größe

Jedes Labyrinth hat einen Namen.
      <Name> Mein erstes Labyrinth </Name>

Die Größe deines Labyrinths gibts du so an:
      <Dimension>
            <width> 20 </width>
            <height> 20 </height>
      </Dimension>

Aussehen

Um das Aussehen festzulegen gibt es 3 Möglichkeiten:

  1. Fixes Labyrinth: Du zeichnest das Labyrinth genau so wie es dargestellt werden soll
  2. Zufalls-Labyrinth: Du bestimmst nur welche Eigenschaften (Verzweigungen, Plätze, Schleifen...) das Labyrinth haben soll und überlässt das genaue Aussehen der Simulation
  3. Kombiniertes-Labyrinth: Fixes Labyrinth das zufällig weitere Gänge einzeichnet
Fixes Labyrinth:

      <Labyrinth>
Welches Symbol (1 Zeichen) in deinem gezeichneten Labyrinth steht für Startpunkt, Wand, Gang und Diamant sowie für die Bodenmarkierungen 0, 1, 2 und 3
            <StartSymbol> S </StartSymbol>
            <WallSymbol> W </WallSymbol>
            <WaySymbol> . </WaySymbol>
            <DiamondSymbol> D </DiamondSymbol>
            <ZeroSymbol> 0 </ZeroSymbol>
            <OneSymbol> 1 </OneSymbol>
            <TwoSymbol> 2 </TwoSymbol>
            <ThreeSymbol> 3 </ThreeSymbol>
Weitere Symbole können so definiert werden:
      <SymbolList>
            <Symbol>
                  <CharSymbol> a </CharSymbol>
                  <StringSymbol> Test String </StringSymbol>
            </Symbol>
            <Symbol>
                  <CharSymbol> b </CharSymbol>
                  <StringSymbol> 2. Test String </StringSymbol>
            </Symbol>
      </SymbolList>
Mögliche Werte für die Startrichtung des Roboters: "up", "down", "left", "right"
            <StartingDirection> UP </StartingDirection>
Zeichnen des Labyrinths:
Die Anzahl der Zeichen muss mit der angegebenen Größe übereinstimmen.
(Verwende die oben festgelegten Zeichen!)
            <LabyrinthField>
            WWWWWWWWWWWWWWWWWWWW
            W.....b...........WW
            W.WWWWWWWWWWWWWWW.WW
            W.WWWWWWWWWWWWWWW.WW
            W.WWWWWWWWWWWWWWW.WW
            W...WWWWWWWWWWWWW.WW
            WWW.WWWWWWWWWWWWW.WW
            WWW.a....D........WW
            WWW.WWWWWWWWWWWWW.WW
            WWW.WWWWWWWWWWWWW.WW
            WWW.WWWWWWWWWWWWW.WW
            WWW.WWWWWWWWWWWWW.WW
            WWW.WWWWWWWWWWWWW.WW
            W.................WW
            W.WWWWWWWWWWWWWWWWWW
            W.WWWWWWWWWWWWWWWWWW
            W.WWWWWWWWWWWWWWWWWW
            W.WWWWWWWWWWWWWWWWWW
            W.WWWWWWWWWWWWWWWWWW
            WSWWWWWWWWWWWWWWWWWW
            </LabyrinthField>
      </Labyrinth>

Zufalls Labyrinth:

      <Create>
Anzahl der Diamanten
            <Diamonds> 20 </Diamonds>
Maximale Anzahl an Wegzellen
            <WayCells> 150 </WayCells>
Minimale Länge eines Weges
            <MinWayLenght> 3 </MinWayLenght>
Maximale Länge eines Weges (Es wird aber nicht verhindert, dass der Weg in die gleiche Richtung weitergebaut wird!)
            <MaxWayLenght> 5 </MaxWayLenght>
Kurfen bauen: 1 steht für ja, 0 für nein
            <BuildAngles> 1 </BuildAngles>
Verzweigungen bauen: 1 steht für ja, 0 für nein
            <BuildTrees> 1 </BuildTrees>
Schleifen bauen: 0 für nein, Zahlenwert für die maximale Anzahl an Schleifen
            <BuildLoops> 3 </BuildLoops>
Plätze bauen: 1 steht für ja, 0 für nein
            <BuildPlaces> 0 </BuildPlaces>
      </Create>

Fixes Labyrinth mit Zufallsanteil:

Verwende einfach
      <Labyrinth>
      </Labyrinth>
und
      <Create>
      </Create>