lny 1.0 Befehlsreferenz

Letzte Aktualisierung: 10/09/2026

Kernbefehle

WENN – Leitet einen WANN-DANN-Befehl ein (es folgt immer eine Bedingung)
DANN – Leitet den Bedingungszweig ein
SONST – Leitet den Alternativzweig ein
ENDE – Beendet WENN, SONST, SOLANGE, WIEDEHROLE, FUER und PROZEDUR.
SOLANGE – Leitet eine Solange-Wiederholung ein (es folgt immer eine Bedingung)
WIEDERHOLE* - Wiederholt einen Block die angegebene Zahl
ALS - Ergänzt WIEDERHOLE um eine Schleifenvariable
FUER – Leitet eine FUER-Wiederholung ein (es folgt immer eine Variable)
IN – Gibt an, was bei FUER durchlaufen werden soll (es folgt immer eine Liste)
VAR – Definiert eine Variable (es gibt keine Datentypen)
SETZE – Weist einer Variablen einen Wert per << zu
SCHREIB – Gibt eine Meldung in der Konsole aus
EINGABE [frage] – Fragt nach einem Wert und gibt ihn zurück
AUF - Ergänzt SCHREIB um den Wert, den die Variable erhalten soll
PROZEDUR – Leitet eine Prozedur ein (es folgt immer ein Name)
ABBRUCH – Beendet die umgebende Schleife sofort; bei zwei ineinander nur die innere
RUECKGABE [wert] – Verlässt eine Prozedur, wahlweise mit einem Wert als Ergebnis
KOM – Leitet eine Kommentarzeile ein
ELEMENT - Holt ein Element aus einer Liste
LAENGE - Sagt, wie viele Elemente eine Liste hat
ANFUEGEN - Fügt ein Element zu einer Liste hinzu
LIST2STR - Verbindet die Elemente einer Liste zu einer Zeichenkette
STR2LIST - Zerlegt eine Zeichenkette in eine Liste

Weltbefehle (built-ins)

LAUF [anzahl] – Lenny läuft in der Laufrichtung nach vorn, auf Wunsch mehrere Schritte
DREH_LINKS [anzahl] – Die Laufrichtung von Lenny dreht sich nach links, auf Wunsch mehrfach
NIMM – Lenny nimmt einen Knochen vom Feld auf
GIB – Lenny legt einen Knochen aus der Knochenbox auf das Feld
IST_FREI – Prüft, ob das Feld in der Laufrichtung frei ist (gibt TRUE/FALSE zurück)
HAT_KNOCHEN – Prüft, ob auf dem aktuellen Feld (dort, wo Lenny steht) ein Knochen liegt (gibt TRUE/FALSE zurück)
KNOCHEN – Anzahl der Knochen in Lennys Maul; nur lesbar, eine Zuweisung ist nicht möglich
TRINK – Lenny trinkt, wenn er auf einer Wasserfläche steht
HAT_WASSER – Prüft, ob auf dem aktuellen Feld Wasser ist
DURST – Wie durstig Lenny ist; nur lesbar
SPIEL – Lenny spielt; nur auf einem Spielplatz möglich
SPRING – Lenny überspringt das nächste Feld und landet auf dem übernächsten. Eine Anzahl gibt es nicht: SPRING 2 meldet einen Fehler, nur die ausgeschriebene SPRING 1 ist erlaubt. Der Sprung scheitert, und Lenny bleibt stehen, wenn das Landefeld außerhalb des Spielfelds liegt oder dort ein Hindernis steht. Ein Sprung geht über zwei Felder und macht doppelt durstig.
SCHAU – Sagt, was auf dem Feld in Laufrichtung liegt
POSITION – Gibt die aktuelle Position von Lenny als String x:y zurück
ZUFALL [min,] [max] – Erzeugt eine ganzzahlige Zufallszahl. Ohne Argument: 0 oder 1, also ein Münzwurf. Mit einem Argument: Zahl zwischen 0 und max, beide Grenzen eingeschlossen (bei negativem Argument entsprechend zwischen max und 0). Mit zwei Argumenten: Zahl zwischen min und max, beide Grenzen eingeschlossen; negative Werte sind erlaubt, und die Reihenfolge der Grenzen spielt keine Rolle.
ENTHAELT Liste, Wert – Prüft, ob die Liste den Wert enthält (gibt WAHR/FALSCH zurück)
START [x, y] – Setzt Lenny auf sein Startfeld zurück oder auf (x, y); die Welt bleibt unverändert

Operatoren

<< – Wertzuweisung
<, >, <=, >= – Kleiner, größer, Kleiner-Gleich, Größer-Gleich
== – Gleich
<> – Ungleich
+, -, /, * – Grundrechenarten
+ mit Zeichenketten und Listen – Ist eine Seite eine Zeichenkette, werden beide Seiten als Text verbunden (Darstellung wie bei SCHREIB: WAHR, FALSCH und NICHTS als Wort in Großbuchstaben, Listen in eckigen Klammern). Ist die linke Seite eine Liste, wird der rechte Wert angehängt bzw. die rechte Liste angefügt. += folgt denselben Regeln. Nicht erlaubte Kombinationen wie WAHR + 1 führen zu einem Typfehler.
% – Modulo
** – Potenz
NICHT – Umkehrung (Unär)
UND – Und-Verknüpfung
ODER – Oder-Verknüpfung
+= – Inkrement
-= – Dekrement
*= – Multipliation und Zuweisung
/= – Division und Zuweisung

Private Attribute von Lenny

name – Der Name des Hundes (aktuell immer "Lenny")
birthday – Der Geburtstag des Hundes
hungry – Wie hungrig ist der Hund
thirsty – Wie durstig ist der Hund
howManyRun – Wie oft ist der Hund bereits gelaufen
howManyTurn – Wie oft hat sich der Hund bereits gedreht
howManyJump – Wie oft ist der Hund bereits gesprungen

Weltbefehle (BuiltIns) - Detailliert

Weltbefehle (BuiltIns) sind Befehle, die mit einer bestimmten "Welt" geladen werden. Eine Welt stellt eine Umgebung zur Verfügung, auf die die Kernbefehle angewendet werden.

Am Anfang gibt es nur eine Welt, die "LennyWorld". Sie besteht aus einem Terrain, auf dem Lenny laufen, über Hindernisse springen und Knochen einsammeln und ablegen kann.

Die Menge der Weltbefehle wird absichtlich klein gehalten. In der "LennyWorld" gibt es z.B. nur einen DREH_LINKS-Befehl und kein *DREH_RECHTS`-Pendant. Auch wenn dadurch die Programmierung etwas umständlicher wird, soll damit das algorithmische Denkvermögen trainiert werden.

Zu einer Welt gehören auch globale Variablen.

BuiltIn	Bedeutung	Rückgabe
LAUF [anzahl]	Lenny läuft in der Laufrichtung nach vorn; mit Anzahl mehrere Schritte, ein Hindernis beendet den Lauf	NICHTS
DREH_LINKS	Die Laufrichtung von Lenny dreht sich nach links	NICHTS
NIMM	Lenny nimmt einen Knochen vom Feld auf	NICHTS
GIB	Lenny legt einen Knochen aus der Knochenbox auf das Feld	NICHTS
IST_FREI	Prüft,ob das Feld in der Laufrichtung frei ist	WAHR/FALSCH
HAT_KNOCHEN	Prüft, ob auf dem aktuellen Feld (dort, wo Lenny steht) ein Knochen liegt	WAHR/FALSCH
KNOCHEN	Anzahl der Knochen in Lennys Maul (nur lesbar)	Zahl
TRINK	Lenny trinkt auf einer Wasserfläche	NICHTS
HAT_WASSER	Prüft, ob auf dem aktuellen Feld Wasser ist	WAHR/FALSCH
DURST	Wie durstig Lenny ist (nur lesbar)	Zahl
SPIEL	Lenny spielt, nur auf einem Spielplatz	NICHTS
SPRING	Überspringt das nächste Feld; ohne Wirkung am Rand und vor einem besetzten Landefeld	NICHTS
SCHAU	Sagt, was auf dem Feld in Laufrichtung liegt	TEXT
POSITION	Gibt die aktuelle Position von Lenny als Liste zurück	LISTE

WAHR, FALSCH und NICHTS sind Konstanten. Bei Ausgaben erscheinen sie immer in Großbuchstaben, egal wie sie im Programm geschrieben wurden.

Zugriff auf Listenelemente

Mit dem Schlüsselwort ELEMENT kann auf ein bestimmtes Element einer Liste zugegriffen werden. Die Zählung beginnt bei 1.

Syntax: ELEMENT <liste>, <index>

<liste> ist die Variable oder der Ausdruck, der eine Liste ergibt.
<index> ist die Position des gewünschten Elements (erstes Element = 1).

Beispiel:

    VAR l
    SETZE l AUF [10, 20, 30]
    VAR zweites
    SETZE zweites AUF ELEMENT l, 2
    SCHREIB zweites   // Ausgabe: 20

Wird ein ungültiger Index (z.B. 0 oder größer als die Listenlänge) verwendet, gibt es natürlich einen Fehler.

Am Rand des Spielfeldes

Lenny kann das Spielfeld nicht verlassen. Läuft er gegen den Rand, bleibt er stehen — ohne Fehler, ohne Abbruch. Dasselbe gilt vor einer Hürde und vor der Hütte, und bei SPRING auch dann, wenn auf dem Landefeld ein Hindernis steht.

    START 10, 1
    LAUF           // Lenny steht schon am rechten Rand und bleibt stehen
    SCHREIB POSITION

Das ist Absicht: So lässt sich LAUF 10 als „laufe bis zur Wand" benutzen, und ein Programm bricht nicht ab, nur weil der Hund angestoßen ist. Damit niemand rätselt, warum nichts passiert, schreibt die Oberfläche am Ende des Laufs eine Zeile dazu — je Grund eine, mit der Anzahl dahinter:

    Lenny stand am Rand des Feldes und kam nicht weiter. (3×)

Im Programm lässt sich der Rand vorher prüfen: IST_FREI gibt FALSCH zurück, wenn in Laufrichtung der Rand kommt — genau wie bei einer Hürde.

    SOLANGE IST_FREI
      LAUF
    ENDE

Groß- und Kleinschreibung beim Vergleich

Bei Texten kommt es nicht darauf an, wie sie geschrieben sind. ==, <> und ENTHAELT vergleichen ohne Rücksicht auf Groß- und Kleinschreibung:

    SCHREIB "HÜTTE" == "hütte"              // WAHR
    SCHREIB ENTHAELT ["Knochen"], "KNOCHEN" // WAHR

Das ist vor allem bei SCHAU nützlich: Nicht alles, was auf einem Feld liegen kann, meldet lny in derselben Schreibweise, und eigene Dinge aus einer Weltdatei schreibt man ohnehin, wie man möchte. So muss man die Schreibweise nicht kennen, um zu prüfen, was Lenny gefunden hat.

Für Zahlen und Wahrheitswerte ändert sich nichts, und ein Text ist weiterhin keine Zahl: "1" == 1 ergibt FALSCH. Die Schlüssel einer Schlüssel-Wert-Liste bleiben ebenfalls unterscheidbar; nur ihre Werte folgen der Regel.

Die Länge einer Liste

LAENGE sagt, wie viele Elemente eine Liste hat.

    VAR zahlen << [4, 8, 15]
    SCHREIB LAENGE zahlen     // Ausgabe: 3

Steht LAENGE mitten in einer Rechnung, gehören Klammern darum. Ohne sie nimmt sich der Befehl alles, was rechts von ihm steht:

    SCHREIB "Es sind " + (LAENGE zahlen) + " Stueck"

Anhängen oder verbinden

+= verbindet zwei Listen zu einer, ANFUEGEN hängt einen Wert als ein Element an. Bei Zahlen fällt der Unterschied nicht auf, bei Listen schon:

    VAR a << []
    a += [1, 2]                // a ist [1, 2]       - zwei Elemente
    VAR b << []
    ANFUEGEN b, [1, 2]         // b ist [[1, 2]]     - ein Element

Wer Positionen sammelt, braucht ANFUEGEN, sonst findet ENTHAELT sie später nicht wieder.

Ein Listenelement ändern

Dasselbe ELEMENT steht auch links vom AUF und überschreibt dann die Stelle, statt sie zu lesen.

Syntax: SETZE ELEMENT <liste>, <index> AUF <wert>

    VAR zahlen << [10, 20, 30]
    SETZE ELEMENT zahlen, 2 AUF 99
    SCHREIB zahlen            // Ausgabe: [10, 99, 30]

Die Rechenzeichen +=, -=, *= und /= gehen genauso wie bei einer Variablen. Damit lässt sich in einer Liste zählen:

    KOM Wie oft fällt welche Augenzahl?
    VAR felder << [0, 0, 0, 0, 0, 0]
    VAR wurf
    FUER wurf IN [1..100]
      VAR augen << ZUFALL 1, 6
      SETZE ELEMENT felder, augen += 1
    ENDE
    SCHREIB felder            // z.B. [14, 18, 18, 19, 19, 12]

Steht links eine Zeile einer Liste von Listen, trifft es die Zelle darin. Die Klammern sind nötig, damit klar ist, welche Nummer zu welcher Liste gehört:

    VAR m << [[1, 2], [3, 4]]
    SETZE ELEMENT (ELEMENT m, 2), 1 AUF 99
    SCHREIB m                 // Ausgabe: [[1, 2], [99, 4]]

Schleifen und Prozeduren vorzeitig verlassen

ABBRUCH beendet die umgebende Schleife sofort. Das funktioniert bei SOLANGE, FUER und WIEDERHOLE. Sind zwei Schleifen ineinander, endet nur die innere.

    VAR z
    FUER z IN [1..10]
      WENN z > 3 DANN
        ABBRUCH
      ENDE
      SCHREIB z
    ENDE

RUECKGABE verlässt eine Prozedur. Ohne Wert bricht sie einfach ab, mit Wert wird dieser zum Ergebnis des Aufrufs. Die Schreibweise RÜCKGABE mit Umlaut ist ebenfalls erlaubt.

    PROZEDUR Doppelt x
      RUECKGABE x * 2
    ENDE
    SCHREIB Doppelt 21          KOM 42

Praktisch ist das vor allem, um aus einer Schleife heraus ein Ergebnis zurückzugeben:

    PROZEDUR Suche Werte, wert
      VAR z
      VAR i << 0
      FUER z IN Werte
        SETZE i AUF i + 1
        WENN z == wert DANN
          RUECKGABE i
        ENDE
      ENDE
      RUECKGABE 0
    ENDE
    SCHREIB Suche [4, 8, 15], 8   KOM 2

In den anderen Sprachen heißen die Befehle BREAK und RETURN, INTERROMPRE und RETOUR, ABORTAR und DEVOLVER sowie INTERROMPI und RITORNA.

Wasser und Durst

Auf dem Feld gibt es Wasserflächen. Lenny darf darüber laufen, sie sind kein Hindernis, und er kann dort trinken.

DURST zählt mit: Jeder Schritt erhöht den Wert um 1, TRINK setzt ihn zurück auf 0. Steht Lenny nicht im Wasser, meldet TRINK einen Fehler. Schlimmes passiert bei großem Durst nicht; der Wert ist eine Zahl, mit der Programme arbeiten können.

    SOLANGE NICHT HAT_WASSER
      LAUF
    ENDE
    TRINK
    SCHREIB "Durst: " + DURST       KOM 0

SCHAU meldet eine Wasserfläche voraus als water, einen Spielplatz als playground und ein Spielzeug als toy.

Ein Spielzeug liegt nur herum: Es lässt sich weder aufnehmen noch benutzen, und es gibt keinen Befehl dafür. Man sieht es in der Weltansicht und erfährt mit SCHAU, dass es vor einem liegt. Festgelegt wird es in der Weltkonfiguration als Liste spielzeug mit Koordinaten wie "7:4" oder über die legend.

Wo das Wasser liegt, steht in der Weltkonfiguration. In der Darstellung mit rows und legend genügt ein Buchstabe, dessen Bedeutung das Wort Wasser enthält:

    legend:
      L: Lenny
      W: Wasser
      H: Huerde
      ".": leer

In den anderen Sprachen heißen die Befehle DRINK, HAS_WATER und THIRST, BOIS, EST_EAU und SOIF, BEBE, ES_AGUA und SED sowie BEVI, E_ACQUA und SETE.

Spielplätze

Auf einem Spielplatz kann Lenny spielen, und nur dort. SPIEL meldet an jeder anderen Stelle den Fehler „Hier ist kein Spielplatz!". Ein Spielplatz ist kein Hindernis, Lenny darf darüber laufen. SCHAU meldet ihn voraus als playground.

    SOLANGE SCHAU <> "playground"
      LAUF
    ENDE
    LAUF
    SPIEL

Wo Spielplätze liegen, steht in der Weltkonfiguration, als Liste spielplatz mit Koordinaten wie "2:9" oder in der Darstellung mit rows und legend über einen Buchstaben, dessen Bedeutung das Wort Spielplatz enthält. In der Weltansicht ist das Feld hellgrün und trägt ein Karussell.

In den anderen Sprachen heißt der Befehl PLAY, JOUE, JUEGA, GIOCA, SPEEL, BAW_SIE, HRAY und PAIXE.

Knochen im Maul

KNOCHEN ist keine Funktion, sondern eine feste Größe: Sie enthält die Anzahl der Knochen, die Lenny gerade trägt. Sie lässt sich überall dort verwenden, wo eine Zahl stehen darf.

Beispiel:

    SCHREIB "Im Maul: " + KNOCHEN
    WENN KNOCHEN > 0 DANN
      GIB
    ENDE

Ein Wert lässt sich ihr nicht zuweisen; SETZE KNOCHEN AUF 5 meldet einen Fehler. Dasselbe gilt für alle anderen festen Größen wie POSITION, RICHTUNG oder ZEIT.

Eine Obergrenze gibt es nicht, Lenny kann beliebig viele Knochen tragen. Der Startwert hängt von der Weltkonfiguration ab: Steht unter start_bones eine Zahl, beginnt Lenny mit so vielen Knochen. Steht dort eine Liste von Feldern, wie in der mitgelieferten lny-world-config.yml, liegen die Knochen auf dem Feld und Lenny beginnt mit leerem Maul.

In den anderen Sprachen heißt die Größe BONES, OS, HUESOS und OSSI.

Nicht mehr verwenden: IST_KNOCHEN war ein zweiter Name für HAT_KNOCHEN und ist missverständlich, weil unklar bleibt, worauf sich das IST bezieht. Der Name funktioniert noch, damit ältere Programme weiterlaufen, sollte aber nicht mehr verwendet werden.

Von vorn beginnen

START setzt Lenny auf seinen Startplatz zurück: Blickrichtung, Knochen im Maul, Durst und die Zähler (LAEUFE und Verwandte) beginnen wieder von vorn.

Das Spielfeld bleibt dabei unangetastet. Aufgenommene Knochen liegen nicht wieder da, und eine selbst geladene Welt bleibt erhalten — bis 1.0.28 baute START die Welt aus der Konfiguration neu auf und machte damit jede geladene Welt zunichte. Wer das Standardfeld zurückhaben möchte, lädt es in der Oberfläche über Standardwelt.

Syntax:

START START <x>, <y>

Ohne Angabe steht Lenny auf dem Startfeld der aktuellen Welt (im Standardfeld (1, 1)) und schaut nach Osten.
Mit x und y steht er auf dem angegebenen Feld, gezählt wie bei POSITION ab 1.
Fehler gibt es bei nur einem Argument, bei Kommazahlen, bei Feldern außerhalb des Spielfelds

und bei Feldern, auf denen ein Hindernis steht. Geprüft wird gegen die Welt, wie sie gerade aussieht — in einer geladenen Welt stehen die Hindernisse anderswo.

Beispiel:

    START           // zurück auf (1, 1), Blick nach Osten
    START 3, 6      // Lenny beginnt auf Feld (3, 6)

In anderen Sprachen heißt der Befehl START (englisch), DEBUT, INICIO und INIZIO.

Prüfen, ob ein Wert in einer Liste vorkommt

ENTHAELT gibt WAHR zurück, wenn die Liste den Wert enthält, sonst FALSCH.

Syntax:

ENTHAELT <liste>, <wert>

Die Liste kann eine Variable oder direkt notiert sein.
Verglichen werden Zahlen, Zeichenketten, Wahrheitswerte und auch verschachtelte Listen.
Zahl und Zeichenkette gelten dabei als gleich, wenn sie gleich geschrieben werden: ENTHAELT [1, 2], "1" ergibt WAHR.
Ist das erste Argument keine Liste oder fehlt ein Argument, gibt es einen Fehler.
In den anderen Sprachen heißt der Befehl CONTAINS, CONTIENT und CONTIENE.

Beispiel:

    VAR Zahlen << [4, 8, 15]
    SCHREIB ENTHAELT Zahlen, 8              // Ausgabe: WAHR
    SCHREIB ENTHAELT Zahlen, 9              // Ausgabe: FALSCH
    WENN NICHT ENTHAELT Zahlen, z DANN      // z kommt noch nicht vor
      Zahlen += z
    ENDE

Listen und Zeichenketten umwandeln

Mit LIST2STR und STR2LIST wird eine Liste in eine Zeichenkette umgewandelt und umgekehrt. Beide Befehle heißen in allen Landessprachen gleich.

Syntax:

LIST2STR <liste> [, <trennzeichen>] STR2LIST <text> [, <trennzeichen>]

LIST2STR hängt alle Elemente aneinander. Ohne Trennzeichen stehen sie direkt hintereinander. WAHR, FALSCH und NICHTS werden als Wort, verschachtelte Listen in eckigen Klammern ausgegeben.
STR2LIST zerlegt den Text am Trennzeichen. Ohne Trennzeichen wird jedes einzelne Zeichen ein Element. Teile, die wie eine Zahl aussehen, werden zu Zahlen, alle anderen bleiben Zeichenketten.
Ein leerer Text ergibt eine leere Liste.

Beispiel:

    SCHREIB LIST2STR ["L", "e", "n", "n", "y"]     // Ausgabe: Lenny
    SCHREIB LIST2STR [1, 2, 3], ", "               // Ausgabe: 1, 2, 3
    VAR Zahlen << STR2LIST "4,8,15", ","           // Zahlen ist [4, 8, 15]
    VAR Zeichen << STR2LIST "Knochen"              // [K, n, o, c, h, e, n]

Da beide Befehle ihre Argumente per Komma erhalten, sollten sie nicht ineinander verschachtelt werden. Besser ist ein Zwischenschritt über eine Variable.