Einstieg - Simulation eines Roboters

Einen Roboter simulieren

Hast du schon einmal einen Roboter in Aktion gesehen?

Es ist ganz schön schwierig, einen Roboter zu bauen. Wir machen uns daher das Leben etwas einfacher, indem wir einen Roboter nur simulieren.

Unser Roboter soll sich in einer rechteckigen Welt bewegen, die in einzelne quadratische Felder aufgeteilt ist. Da soll er hin und her laufen und einige (mehr oder weniger nützliche) Aktionen durchführen. Was genau, wird in den weiteren Abschnitten beschrieben.

Als erstes soll der Roboter etwas genauer beschrieben werden. Wir beginnen mit einer ganz einfachen Roboter-Variante.

Der Roboter befindet sich in einem Zustand

Der aktuelle Zustand des Roboters wird durch das Feld, in dem er sich gerade befindet, und durch die Richtung, in die er gerade schaut, bestimmt.

Der Zustand des Roboters im Bild oben kann wie folgt genauer beschrieben werden: Er befindet sich im Feld (2, 3) und schaut in Richtung Osten. Die Felder der Welt werden dabei nach folgender Systematik durchnummeriert: Das Feld in der Ecke hinten links wird als Bezugsfeld gesetzt und mit den Koordinaten (0, 0) versehen. Ein Feld mit den Koordinaten (x, y) befindet sich ausgehend von (0, 0) x Schritte nach rechts (Osten) und y Schritte nach vorne (Süden). Beachte, dass die Himmelsrichtungen wie im Bild angezeigt festgelegt sind.

Wenn man dem Roboter den Namen rob gibt, dann lässt sich der Zustand des Roboters im Bild oben mit folgendem Diagramm beschreiben:

Hier werden mit x und y die Koordinaten des Feldes, in dem sich der Roboter befindet, abgekürzt und mit r die Richtung, in die der Roboter gerade schaut.

Wie verhält sich der Roboter?

Der Roboter soll folgende Operationen ausführen können:

• einen Schritt vorwärts gehen
• um 90° nach rechts drehen
• um 90° nach links drehen

Das folgende Ablaufprotokoll zeigt exemplarisch, wie sich solche Operationen auf den aktuellen Zustand des Roboters auswirken:

Im Ablaufprotokoll werden auch schon spezielle Schreibweisen für die Ausführung von Operationen benutzt:

• rob.schritt(): Der Roboter rob soll einen Schritt vorwärts gehen.
• rob.rechts(): Der Roboter rob soll sich um 90° nach rechts drehen.
• rob.links(): Der Roboter rob soll sich um 90° nach links drehen.

Aufgabe 1

Ergänze die fehlenden Zustandsbeschreibungen:

{rob: x -> 0, y -> 0, r ->'S'}
rob.schritt()
?
rob.schritt()
?
rob.links()
?
rob.schritt()
?
rob.rechts()
?
rob.rechts()
?

Aufgabe 2

Ergänze die fehlenden Operationen:

{rob: x -> 0, y -> 0, r ->'S'}
?
{rob: x -> 0, y -> 0, r ->'O'}
?
{rob: x -> 1, y -> 0, r ->'O'}
?
{rob: x -> 1, y -> 0, r ->'S'}
?
{rob: x -> 1, y -> 1, r ->'S'}
?
{rob: x -> 1, y -> 1, r ->'w'}

Ein Software-Objekt zur Simulation des Roboters

Ein Roboter-Objekt muss - genau so wie in der realen Welt - erst einmal erzeugt (gebaut) werden, bevor es in Aktion treten kann. Hierzu wird ein Bauplan benötigt.

Die folgende Klassendeklaration enthält den Bauplan für unsere einfachen Roboter-Objekte.

class Roboter(object):
    def __init__(self):
        self.x = 0
        self.y = 0
        self.r = 'S'

    def schritt(self):
        if self.r == 'O':
            self.x = self.x + 1
        elif self.r == 'S':
            self.y = self.y + 1
        elif self.r == 'W':
            # ...
        elif self.r == 'N':
            # ...

    def rechts(self):
        if self.r == 'O':
            self.r = 'S'
        elif self.r == 'S':
            self.r = 'W'
        elif self.r == 'W':
            self.r = 'N'
        elif self.r == 'N':
            self.r = 'O'

    def links(self):
        # ...

Aufgabe 3

Analysiere diese Klassendeklaration und versuche, die fehlenden Teile # ... zu ergänzen.

Aufgabe 4

Überprüfen kannst du deinen Lösungsvorschlag, indem du die Klassendeklaration unter einem geeigneten Namen (z. B. roboter.py) abspeicherst und ausführst. Wenn du alles richtig gemacht hast, dann sollte jetzt z. B. folgender Python-Dialog möglich sein:

>>> rob = Roboter()
>>> rob.x
0
>>> rob.y
0
>>> rob.r
'S'
>>> rob.links()
>>> rob.schritt()
>>> rob.rechts()
>>> rob.x
1
>>> rob.y
0
>>> rob.r
'S'

Hier wird ein (Software-) Objekt rob erzeugt, das sich genauso verhält, wie oben beschrieben.

(a) Probiere das selbst aus. Versuche auch, den Roboter rob mit Hilfe geeigneter Operationen in den Zustand wie im Bild oben zu bringen.

(b) Versuche auch einmal, mehrere Roboter-Objekte zu erzeugen.

>>> rob1 = Roboter()
>>> rob1.schritt()
>>> rob2 = Roboter()
>>> rob2.links()
>>> rob2.schritt()
>>> ...

Verhalten sich mehrere solche Roboter wie in der realen Welt?