lny-interpreter 0.99.0

package/.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Lny: Aktive Datei ausfuehren",
+      "type": "node-terminal",
+      "request": "launch",
+      "command": "npm run start:repl -- \"${relativeFile}\"",
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Lny: REPL starten",
+      "type": "node-terminal",
+      "request": "launch",
+      "command": "npm run start:repl",
+      "cwd": "${workspaceFolder}"
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,96 @@
+# Lenny2
+
+Letzte Aktualisierung: **01/04/2026**
+
+Interpreter-Implementierung fuer **Lny 1.0** in TypeScript mit:
+
+- Lexer + Parser + AST + Evaluator
+- Mehrsprachigen Kernbefehlen (de, en, fr, es, it)
+- Mehrsprachigen Weltbefehlen (LennyWorld)
+- REPL fuer die Konsole
+- Browser-UI (index.html)
+
+## Schnellstart
+
+```bash
+npm install
+npm run build
+npm run test
+npm run start:repl
+# optional: direkt ein Skript starten
+npm run start:repl -- examples/00-demo.lny
+```
+
+## Installation des npm package
+
+## Installation & Ausführung als npm-Package
+
+1. **Installation (empfohlen):**
+   ```bash
+   npm install -g lny-interpreter
+   ```
+
+2. **Starten der Lny-Konsole (REPL):**
+   ```bash
+   lny
+   ```
+
+3. **Direktes Ausführen eines Skripts:**
+   ```bash
+   lny examples/00-demo.lny
+   ```
+
+4. **Ohne Installation (direkt mit npx):**
+   ```bash
+   npx lny-interpreter
+   ```
+
+**Hinweis:**  
+Die REPL unterstützt Kommandos wie `:help`, `:echo on|off`, `:lang <de|en|fr|es|it>`, `:state`, `:run <skript.lny>`, `:exit`.
+
+## Projektstruktur
+
+- `src/lexer/lexer.ts`: Tokenizer mit sprachuebergreifender Keyword-Erkennung
+- `src/parser/parser.ts`: Parser mit Operator-Prioritaet und Klammerausdruecken
+- `src/interpreter/interpreter.ts`: AST-Interpreter inkl. Kontrollfluss
+- `src/world/world.ts`: LennyWorld + Built-ins (`RUN`, `TURN_LEFT`, ...)
+- `src/i18n/i18n.ts`: Uebersetzungen fuer Befehle und Meldungen
+- `src/repl.ts`: Interaktive Konsolen-REPL
+- `examples/*.lny`: Ausfuehrbare Lny-Skriptdateien (Beispiel: `examples/00-demo.lny`)
+- `index.html`: Browser-Oberflaeche
+
+## Spracheigenschaften
+
+- Kernbefehle intern auf Englisch modelliert (Token/AST)
+- Eingabe in einer der unterstuetzten Landessprachen
+- Auswertung von verschachtelten Ausdruecken inkl. Klammern
+- Unterstuetzung fuer:
+	- `IF/THEN/ELSE/END`
+	- `WHILE/END`
+	- `FOR/IN/END`
+	- `VAR`, `SET` (per `<=`)
+	- `LOG`, `PROC`, `REM`
+	- Arithmetik, Vergleich, Logik, Potenz, zusammengesetzte Zuweisungen
+
+## Hinweise
+
+- Die REPL unterstuetzt zusaetzlich:
+	- `:lang <de|en|fr|es|it>`
+	- `:state`
+	- `:clear`
+	- `:echo on|off`
+	- `:run <pfad/zum/skript.lny>`
+	- `:help`
+	- `:exit`
+
+- Konfiguration ueber `lny-config.yml`:
+	- `language: de`
+	- `field_size: 10x10` (Default)
+
+- `.lny`-Skripte ausfuehren:
+	- Beim Start: `npm run start:repl -- examples/00-demo.lny`
+	- In der REPL: `:run examples/00-demo.lny`
+
+- Eine ausfuehrliche Dokumentation liegt in `docs/INTERPRETER.md`.
+
+

package/book_ALT/chapter01.md

@@ -0,0 +1,141 @@
+# Kapitel 1: Willkommen in Lennys Welt
+
+Stell dir vor, du hast einen Hund.
+
+Er heißt Lenny.
+
+Lenny ist schlau.
+
+Aber er versteht nur ganz bestimmte Befehle.
+
+Und genau hier beginnt Programmieren.
+
+##💡 Was ist ein Programm?
+
+Ein Programm ist einfach:
+
+ Eine Liste von Befehlen, die Schritt für Schritt ausgeführt werden.
+
+ So wie eine Anleitung
+
+```lny
+LAUF
+LAUF
+DREH_LINKS
+LAUF
+```
+
+Was passiert hier?
+
+👉 Lenny läuft zweimal, dreht sich und läuft weiter.
+
+Das ist schon ein Programm.
+
+## 🧩 Was ist ein Befehl?
+
+Ein Befehl ist eine Anweisung, die Lenny versteht.
+
+Zum Beispiel:
+
+- LAUF
+- DREH_LINKS
+- NIMM
+
+👉 Jeder Befehl löst eine Aktion aus.
+
+💡 Wichtig:
+
+ Lenny macht genau das, was du sagst.
+ Nicht mehr. Nicht weniger.
+
+ ## 🧠 Was macht der Interpreter?
+
+ Du schreibst den Code.
+Aber wer führt ihn aus?
+
+👉 Das macht der Interpreter.
+
+Er liest dein Programm Zeile für Zeile und sagt Lenny:
+
+ Mach jetzt DAS.
+
+💡 Ohne Interpreter passiert… nichts.
+
+## 📏 Wozu gibt es eine Syntax?
+
+Syntax ist wie Grammatik.
+
+Wenn du sagst:
+
+„Lauf links drehen jetzt“
+
+… versteht dich niemand.
+
+Wenn du sagst:
+
+```lny
+DREH_LINKS
+```
+
+👉 Alles klar
+
+💡 Computer sind da streng:
+
+falsches Wort → Fehler
+
+falsche Reihenfolge → Fehler
+
+## 🤖 Warum versteht der Computer nur „komische Befehle“?
+
+Computer funktioneieren anders als wir Menschen.
+
+Sie verstehen nicht so etwas wie:
+
+ Lenny, geh mal ein bisschen nach vorne.
+
+Sie verstehen nur:
+
+```lny
+LAUF
+```
+
+oder
+
+```lny
+LAUF 50
+```
+👉 Klar, eindeutig, keine Missverständnisse.
+
+Die Zahl *50* hat irgendetwas zu bedeuten. Was genau, hängt natürlich von der *Syntax* des Befehls ab. Und diese Syntax mussst Du natürlich kennen.
+
+![images/Lenny03.png](images/Lenny03.png)
+
+## 🚀 KI ändert (fast) alles
+
+Früher:
+Computer konnten nur exakte Befehle verstehen.
+
+Heute mit KI:
+
+- Natürliche Sprache wird verstanden
+- Bilder werden erkannt
+- Texte werden so geschrieben, dass sie auch von einem Menschen stammen könnten
+
+👉 Aber:
+ Im Hintergrund läuft trotzdem Code.
+
+Auch mit KI werden Programmierer gebraucht, wenngleich sich ihre Aufgaben ändern werden 😉
+
+Kann KI auch Lny-Programme schreiben?
+
+Selbstverständlich.Das wird auch noch ein Thema dieses Buches sein.
+
+Dann muss ich doch eigentlich selber nicht mehr programmieren, oder?
+
+Das kommt darauf an. Wenn Du es lernen willst, und das willst Du, dann musst Du den Code auch selber schreiben.
+
+Später im Berufsleben wird Dir KI aber sehr viel unter die Arme greifen und sehr viel Code für Dich schreiben.
+
+Es wird aber trotzdem sehr wichtig, dass Du den Code verstehts, denn die KI für Dich schreib.
+
+Bleib also dran. Es wird Dir mit Sicherheit Spaß machen.

package/book_ALT/chapter02.md

@@ -0,0 +1,48 @@
+# 📦 Variablen – das Gedächtnis des Programms
+
+Eine Variable ist wie eine Kiste.
+
+Du kannst etwas hineinlegen:
+
+```lny
+VAR x
+SETZE x << 5
+```
+
+👉 Jetzt merkt sich x die Zahl 5.
+
+🔤 Texte sind etwas Besonderes
+
+Zahlen sind einfach:
+
+```lny
+SETZE x << 5
+```
+
+Texte brauchen Anführungszeichen:
+
+```lny
+SETZE name << "Lenny rennt"
+```
+
+oder Apostrophe:
+
+```lny
+SETZE name << 'Lenny rennt'
+```
+
+🔄 Wie bekommt eine Variable ihren Wert?
+
+Durch Zuweisung:
+
+```lny
+SETZE x << 10
+```
+
+👉 Lies das wie:
+
+ Setze x auf den Wert 10
+
+## Zusammmenfassung
+
+Über eine Variable merkt sich ein Programm einen Wert. Allerdings nur solange wie das Programm "läuft". Danach ist alles wieder vergessen. Damit sich ein Programm einen Wert dauerhaft merken kann, muss es ihn auf einem Speichermedium wie einer Festplatte abspeichern. Das ist bei *lny* aber nicht möglich.

package/book_ALT/chapter03.md

@@ -0,0 +1,28 @@
+# ⚖️ Entscheidungen – wahr oder falsch
+
+Computer denken nicht wie wir.
+
+Sie kennen nur:
+
+- WAHR
+- FALSCH
+
+Hier ein Beispiel
+
+```lny
+WENN IST_FREI
+DANN
+    LAUF
+SONST
+    DREH_LINKS
+ENDE
+```
+
+![images/Lenny02.png](images/Lenny02.png)
+
+👉 Entweder frei oder nicht.
+ Es gibt für den Computer kein „vielleicht“.
+
+ ## Zusammenfassung
+
+Eine Entscheidung ist ein Befehl, der entscheidet, ob ein anderer Befehl (meistens aber mehrere Befehle) ausgeführt wird oder nicht. Für Entscheidungen hat *lny* die Befehle *WENN*, *DANN* und *SONST* im Angebot. Und am Ende muss wieder ein *ENDE* stehen, damit der Interpreter weiß, welche Befehle zur Entscheidung gehören.

package/book_ALT/chapter04.md

@@ -0,0 +1,19 @@
+# 🔁 Wiederholungen – die Superkraft des Computers
+
+Computer werden nicht müde (höchstens mal etwas langsammer).
+
+Das hier:
+
+```lny
+SOLANGE IST_FREI
+    LAUF
+ENDE
+```
+
+👉 läuft so lange…
+ bis es nicht mehr frei ist.
+
+Ob 3-mal oder 3 Milliarden Mal: egal.
+
+Und wenn das Feld nie frei wird? Dann werden die Befehle ewig wiederholt. Eventuell bis zum Tag des jüngsten Gericht.
+

package/book_ALT/chapter05.md

@@ -0,0 +1,21 @@
+# 🗂️ Listen – Variablen mit Schubladen
+
+Eine Liste ist wie eine Kommode:
+
+```lny
+VAR zahlen
+SETZE zahlen << [1, 2, 3, 4]
+```
+
+👉 Eine Variable, mehrere Werte.
+
+## 🔁 Listen durchlaufen mit FUER
+
+```lny
+FUER x IN [1, 2, 3]
+    SCHREIB x
+ENDE
+```
+
+👉 Der Computer geht jeden Wert durch.
+

package/book_ALT/chapter06.md

@@ -0,0 +1,167 @@
+# 🔧 Kapitel 6 – Prozeduren
+
+## 💡 Warum Prozeduren?
+
+Stell dir vor, du musst immer wieder die gleichen Befehle schreiben.
+
+👉 Das ist mühsam und fehleranfällig.
+
+Prozeduren helfen dir dabei:
+
+- Code wiederzuverwenden
+- Programme übersichtlicher zu machen
+- Fehler zu vermeiden
+
+---
+
+## 🐾 Erste Prozedur
+
+```lny
+PROZEDUR geheDreiSchritte
+    LAUF
+    LAUF
+    LAUF
+ENDE
+```
+
+👉 Hier definierst du eine neue Prozedur.
+
+---
+
+## ▶️ Prozedur aufrufen
+
+```lny
+geheDreiSchritte
+```
+
+---
+
+## 🔁 Mehrfach verwenden
+
+```lny
+geheDreiSchritte
+geheDreiSchritte
+```
+
+---
+
+## 🔄 Kombination
+
+```lny
+PROZEDUR geheEcke
+    LAUF
+    DREH_LINKS
+ENDE
+
+geheEcke
+geheEcke
+geheEcke
+geheEcke
+```
+
+---
+
+# 🧠 Prozeduren mit Parametern
+
+## 💡 Idee
+
+Manchmal soll sich eine Prozedur unterschiedlich verhalten.
+
+👉 Dafür gibt es **Parameter**.
+
+---
+
+## 🐾 Beispiel
+
+```lny
+PROZEDUR geheXSchritte(x)
+    SOLANGE x > 0
+        LAUF
+        SETZE x << x - 1
+    ENDE
+ENDE
+```
+
+---
+
+## ▶️ Aufruf
+
+```lny
+geheXSchritte(3)
+geheXSchritte(5)
+```
+
+👉 Lenny läuft unterschiedlich weit!
+
+---
+
+## 🔄 Noch ein Beispiel
+
+```lny
+PROZEDUR dreheMehrfach(n)
+    SOLANGE n > 0
+        DREH_LINKS
+        SETZE n << n - 1
+    ENDE
+ENDE
+
+dreheMehrfach(2)
+```
+
+---
+
+## 🧠 Vorteil
+
+- flexibler Code
+- weniger Wiederholungen
+- mächtiger
+
+---
+
+## ⚠️ Typische Fehler
+
+- Parameter vergessen
+- falscher Name
+- Wert wird nicht verändert
+
+---
+
+## 🎯 Aufgabe 1
+
+Was macht das?
+
+```lny
+PROZEDUR test(x)
+    SCHREIB x
+ENDE
+
+test(5)
+```
+
+---
+
+## 🎯 Aufgabe 2
+
+Schreibe:
+
+👉 eine Prozedur, die 4 Schritte läuft
+
+(aber mit Parameter!)
+
+---
+
+## 🎯 Aufgabe 3 (Bonus)
+
+👉 Prozedur für ein Quadrat mit Seitenlänge x
+
+---
+
+## 🚀 Fazit
+
+Mit Parametern kannst du:
+
+- Programme verallgemeinern
+- echte Probleme lösen
+- wie ein Profi programmieren
+
+🐶 Lenny wird immer schlauer – dank dir!