From 65188ee7bd3093cb31533f20e84a269c1b43f43c Mon Sep 17 00:00:00 2001 From: debiankaios Date: Thu, 1 Dec 2022 20:05:38 +0100 Subject: [PATCH] getting_started.md and lua.md by Tuxilio and solars --- _de/basics/getting_started.md | 149 ++++++++++++++++++ _de/basics/lua.md | 284 ++++++++++++++++++++++++++++++++++ _de/index.md | 2 +- 3 files changed, 434 insertions(+), 1 deletion(-) create mode 100644 _de/basics/getting_started.md create mode 100644 _de/basics/lua.md diff --git a/_de/basics/getting_started.md b/_de/basics/getting_started.md new file mode 100644 index 0000000..a8d32e9 --- /dev/null +++ b/_de/basics/getting_started.md @@ -0,0 +1,149 @@ +--- +title: Erste Schritte +layout: default +root: ../.. +idx: 1.1 +description: Lerne wie man einen Mod-Ordner mit init.lua, mod.conf und mehr anlegt. +redirect_from: +- /de/chapters/folders.html +- /de/basics/folders.html +--- + +## Einführung + +Es ist wesentlich, den Aufbau der grundlegenden Strukturen des Mod-Verzeichnisses zu verstehen, wenn man Mods erstellt. + +- [Was sind Spiele und Mods?](#was-sind-spiele-und-mods) +- [Wo werden die Mods gespeichert?](#wo-werden-die-mods-gespeichert) +- [Ihren ersten Mod erstellen](#ihren-ersten-mod-erstellen) + - [Mod-Verzeichnis](#mod-verzeichnis) + - [mod.conf](#modconf) + - [init.lua](#initlua) + - [Zusammenfassung](#summary) +- [Abhängigkeiten](#abhängigkeiten) +- [Mod-Pakete](#mod-pakete-modpacks) + + +## Was sind Spiele und Mods? + +Die Stärke von Minetest ist die Fähigkeit, Spiele zu erstellen, ohne eigene Voxel-Grafik, Voxel Algorithmen und raffinierten Netzwerk-Code erstellen zu müssen. + +In Minetest ist ein Spiel eine Sammlung von Modulen, welche miteinander arbeiten, um den Inhalt und das Verhalten des Spiels zur Verfügung zu stellen. +Ein Modul, allgemein als Mod bezeichnet, ist eine Sammlung von Skripten und Ressourcen. +Es ist möglich, ein Spiel mit nur einem Mod zu erstellen, aber das wird nur selten gemacht, weil es sonst nicht mehr so einfach ist, Teile des Spieles unabhängig von den Anderen anzupassen oder zu ersetzen. + +Ebenfalls ist es möglich, Mods außerhalb eines Spieles zu verbreiten. In diesem Fall sind sie ebenfalls *Mods*, aber in einem traditionellerem Sinn: *Modifikationen*. Diese Mods verändern oder erweitern die Eigenschaften eines Spiels. + +Sowohl die Mods die im Spiel enthalten sind, als auch die Mods von Dritten nutzen die selbe API (Programmierschnittstelle). + + +## Wo werden die Mods gespeichert? + + + +Jede Mod hat ihr eigenes Verzeichnis, wo sich ihre Lua-Quelltexte, Texturen, Modelle und Tondateien befinden. Minetest überprüft verschiedene Orte auf Mods. Diese Orte werden allgemein *Mod-Lade-Verzeichnisse* genannt. + +Für eine bestimmte Welt/ein bestimmtes Spiel werden drei Mod-Speicherorte überprüft. Diese sind, in dieser Reihenfolge: + +1. Spiel-Mods. Dies sind die Mods, die das Spiel (die Welt) bilden. + z.B.: `minetest/games/minetest_game/mods/`, `/usr/share/minetest/games/minetest/` +2. Globale Mods. Der Ort, an dem Mods fast immer installiert werden. + Im Zweifelsfall legen Sie Mods hier ab. + z.B.: `minetest/mods/` +3. Welt-Mods. Der Ort, an dem Mods gespeichert werden, die für eine bestimmte bestimmte Welt sind. + z.B.: `minetest/worlds/world/worldmods/` + +`minetest` ist das Verzeichnis für die Benutzerdaten. Sie können den Ort des Benutzerdaten-Verzeichnis finden, indem Sie Minetest öffnen und auf "Benutzerdatenverzeichnis öffnen" in der Registerkarte "Über" klicken. +Falls Minetest mithilfe von Flathub installiert wurde, kann es sein, dass bei einem Klick nichts passiert. Normalerweise ist das `minetest`-Verzeichnis dann in `/home/USER/.var/app/net.minetest.Minetest/.minetest/` + +Beim Laden von Mods prüft Minetest alle oben genannten Verzeichnisse der Reihe nach. Wenn es auf einen Mod stößt, der denselben Namen trägt wie ein zuvor gefundener, wird der spätere Mod anstelle des früheren Mods geladen. Das bedeutet, dass Sie die Spielmods überschreiben, indem Sie einen Mod mit demselben Namen in den globalen Mod-Speicherort einfügen. + + +## Ihren ersten Mod erstellen + +### Mod-Verzeichnis + +Gehen Sie in das globale Mods-Verzeichnis (Über > enutzerdatenverzeichnis öffnen > mods) und +erstellen Sie einen neuen Ordner namens `mymod`. mymod ist der Name des Mods. + +Jeder Mod sollte einen eindeutigen *Mod-Namen* haben, eine technische Kennung (id), die auf den Mod verweist. Mod-Namen können Buchstaben, Zahlen und Unterstriche enthalten. Ein guter Name sollte beschreiben, was der Mod tut. Das Verzeichnis, das die Komponenten eines Mods enthält, muss denselben Namen wie der Mod-Name haben. Um herauszufinden, ob ein Mod-Name verfügbar ist, suchen Sie ihn auf +[content.minetest.net](https://content.minetest.net). + + mymod + ├── textures + │   └── mymod_node.png Dateien + ├── init.lua + └── mod.conf + +Mods benötigen nur eine init.lua-Datei. Es wird jedoch empfohlen, die Datei mod.conf zu verwenden und je nach Funktionsumfang können weitere Komponenten erforderlich sein, abhängig von der Funktionalität des Mods. + +### mod.conf + +Erstellen Sie eine `mod.conf`-Datei mit folgendem Inhalt: + +``` +name = mymod +description = Fügt foo, bar und bo hinzu. +depends = default +``` + +Diese Datei wird für Mod-Metadaten verwendet, darunter der Name des Mods, die Beschreibung und andere +Informationen. + +### init.lua + +Erstellen Sie eine `init.lua`-Datei mit folgendem Inhalt: + +```lua +print("Diese Datei wird zum Zeitpunkt des Ladens ausgeführt!") + +minetest.register_node("mymod:node", { + description = "Das ist ein Knoten", + tiles = {"mymod_node.png"}, + groups = {cracky = 1} +}) + +minetest.register_craft({ + type = "shapeless", + output = "mymod:node 3", + recipe = { "default:dirt", "default:stone" }, +}) +``` + +Die Datei init.lua ist der Einstiegspunkt für einen Mod und wird ausgeführt, wenn der Mod geladen wird. + +### Zusammenfassung + + +Dieser Mod hat den Namen "mymod". Er hat zwei Textdateien: init.lua und mod.conf. Das Skript gibt eine Nachricht aus und registriert dann einen Knoten und ein Handwerksrezept - diese +werden später erklärt. Es gibt eine einzige Abhängigkeit, die +[default mod](https://content.minetest.net/metapackages/default/), die +normalerweise im Minetest-grundspiel (Minetest Game) zu finden ist. Außerdem gibt es eine Textur in textures/ für den Knoten. + + +## Abhängigkeiten + +Eine Abhängigkeit entsteht, wenn ein Mod einen anderen Mod benötigt, der vor ihr geladen werden muss. Ein Mod kann verlangen, dass der Code, die Gegenstände oder andere Ressourcen eines anderen Mods verfügbar sein müssen, damit sie verwendet werden können. + +Es gibt zwei Arten von Abhängigkeiten: feste und optionale Abhängigkeiten. Beide erfordern, dass der Mod zuerst geladen wird. Wenn der Mod, von der die Abhängigkeit besteht, nicht nicht verfügbar ist, führt eine harte Abhängigkeit dazu, dass der Mod nicht geladen wird, während eine optionale Abhängigkeit dazu führen kann, dass weniger Funktionen aktiviert werden. + +Eine optionale Abhängigkeit ist nützlich, wenn Sie optional einen anderen Mod unterstützen wollen; diese kann zusätzliche Inhalte aktivieren, wenn der Benutzer beide Mods gleichzeitig nutzen möchte. + +Abhängigkeiten werden in einer kommagetrennten Liste in mod.conf angegeben. + + depends = modeins, modzwei + optional_depends = moddrei + +## Mod-Pakete (Modpacks) + +Mods können in Mod-Pakete gruppiert werden, die es ermöglichen, mehrere Mods zu verpacken und zusammen zu verschieben. Sie sind nützlich, wenn Sie einem Spieler mehrere Mods zur Verfügung stellen wollen, aber nicht wollen, dass er sie einzeln herunterladen muss. + + modpack1 + ├── modpack.conf (required) - signalisiert, dass es sich um ein Mod-Paket handelt + ├── mod1 + │   └── ... Mod-Dateien + └── mymod (optional) +    └── ... Mod-Dateien + +Bitte beachten Sie, dass ein Modpack kein *Spiel* ist. +Spiele haben ihre eigene Organisationsstruktur, die im Kapitel "Spiele" erklärt wird. diff --git a/_de/basics/lua.md b/_de/basics/lua.md new file mode 100644 index 0000000..97caf43 --- /dev/null +++ b/_de/basics/lua.md @@ -0,0 +1,284 @@ +--- +title: Lua-Skripting +layout: default +root: ../.. +idx: 1.2 +description: Eine grundlegende Einführung in Lua, einschließlich eines Leitfadens zum globalen/lokalen Geltungsbereich. +redirect_from: /de/chapters/lua.html +--- + +## Einleitung + + In diesem Kapitel geht es um die Skripterstellung in Lua, die dazu benötigten Werkzeuge und einige Techniken, die Sie vielleicht nützlich finden. + +- [Code-Editoren](#code-editoren) +- [Programmieren in Lua](#programmieren-in-lua) + - [Programmablauf](#programmablauf) + - [Typen von Variablen](#typen-von-variablen) + - [Arithmetische, also Mathematische, Operatoren](#arithmetische-also-mathematische-operatoren) + - [Auswahl](#auswahl) + - [Logische Operatorens](#logische-operatoren) +- [Progarmmierung](#programmierung) +- [Lokale und globale Reichweite](#lokale-und-globale-reichweite) + - [Es sollte so viel wie möglich auf lokale Variablen zurückgegriffen werden.](#es-sollte-so-viel-wie-möglich-auf-lokale-variablen-zurckgegriffen-werden) +- [Einbindung anderer Lua-Skripte](#einbindung-anderer-lua-skripte) + +## Code-Editoren + +Für das Schreiben von Skripten in Lua reicht ein Code-Editor mit Code-Hervorhebung aus. +Die Codehervorhebung verwendet unterschiedliche Farben für Wörter und Zeichen je nachdem, wofür sie stehen. Auf diese Weise können Sie leicht Fehler und Ungereimtheiten erkennen. + +Zum Beispiel: + +```lua +function ctf.post(team,msg) + if not ctf.team(team) then + return false + end + if not ctf.team(team).log then + ctf.team(team).log = {} + end + + table.insert(ctf.team(team).log,1,msg) + ctf.save() + + return true +end +``` + +Die Schlüsselwörter in diesem Beispiel sind hervorgehoben, einschließlich `if`, `then`, `end` und `return`. Funktionen, die standardmäßig mit Lua ausgeliefert werden, wie z.B. `table.insert`, sind ebenfalls hervorgehoben. + +Zu den häufig verwendeten Editoren, die sich gut für Lua eignen, gehören: + +* [VSCode](https://code.visualstudio.com/) - quelloffen (als Code-OSS oder VSCodium), populär, und hat [Plugins für Minetest Modding](https://marketplace.visualstudio.com/items?itemName=GreenXenith.minetest-tools). +* [Notepad++](http://notepad-plus-plus.org/) - nur für Windows +* [Atom](http://atom.io/) + +Andere geeignete Editoren sind ebenfalls verfügbar. + +## Programmieren in Lua + +### Programmablauf + +Programme sind eine Reihe von Befehlen, die nacheinander ausgeführt werden. Wir nennen diese Befehle "Anweisungen". Der Programmablauf gibt an, wie diese Anweisungen ausgeführt werden. Verschiedene Arten des Ablaufs ermöglichen es Ihnen, Befehlsreihen zu überspringen. + +Es gibt drei Haupttypen von Abläufen: + +* Sequenz: führt eine Anweisung nach der anderen aus, ohne zu überspringen. +* Auswahl: Überspringt Sequenzen in Abhängigkeit von Bedingungen. +* Iteration: Wiederholung der gleichen Anweisungen, bis eine Bedingung erfüllt ist. + +Wie sehen also die Anweisungen in Lua aus? + +```lua +local a = 2 -- Setzt 'a' auf 2 +local b = 2 -- Setzt 'b' auf 2 +local result = a + b -- Setzt 'result' (Deutsch: Ergebnis) auf a + b, was 4 ergibt +a = a + 10 +print("Die Summe aus a und b ist "..result) +``` + +In diesem Beispiel sind `a`, `b` und `result` *Variablen*. Lokale Variablen werden +mit dem Schlüsselwort `local` deklariert und erhalten dann einen Anfangswert. `local` +wird später besprochen, denn es ist Teil eines sehr wichtigen Konzepts namens +*scope* (Deutsch: Geltungsbereich). + +Das `=`-Zeichen bedeutet *assignment* (Deutsch: Zuweisung), also bedeutet `result = a + b`, dass der Wert von `result` auf den Wert von `a + b` gesetzt wird. Variablennamen können länger als ein Zeichen lang sein, wie bei der Variable `result` zu sehen ist. Es ist auch erwähnenswert, dass, wie wie die meisten Sprachen die Groß- und Kleinschreibung beachtet wird; `A` ist eine andere Variable als `a`. + + +### Typen von Variablen + +Eine Variable hat nur einen der folgenden Typen und kann nach einer Zuweisung den Typ wechseln. Es ist gute Praxis, sicherzustellen, dass eine Variable immer nur nil oder einen einzigen Nicht-Nil-Typ hat. + +| Typ | Beschreibung | Beispiel | +|----------|---------------------------------|----------------| +| Nil | Nicht initialisiert. Die Variable ist leer, sie hat keinen Wert | `local A`, `D = nil` | +| Number | Eine ganze oder dezimale Zahl. | `local A = 4` | +| String | Ein Stück Text. | `local D = "one two three"` | +| Boolean | True oder False. (Wahr oder Falsch) | `local is_true = false`, `local E = (1 == 1)` | +| Table | Listen. | Explained below. | +| Function | Kann ausgeführt werden. Kann Eingaben erfordern und einen Wert zurückgeben. | `local result = func(1, 2, 3)` | + +### Arithmetische, also Mathematische, Operatoren + +Zu den Operatoren in Lua gehören: + +| Symbol | Zweck | Beispiel | +|--------|----------------|---------------------------| +| A + B | Addition | 2 + 2 = 4 | +| A - B | Subtraktion | 2 - 10 = -8 | +| A * B | Multiplikation | 2 * 2 = 4 | +| A / B | Division | 100 / 50 = 2 | +| A ^ B | Befugnisse | 2 ^ 2 = 22 = 4 | +| A .. B | Zeichenketten verbinden | "foo" .. "bar" = "foobar" | + +Bitte beachten Sie, dass diese Liste nicht vollständig ist; sie enthält nicht alle möglichen Operatoren. + +### Auswahl + +Die einfachste Methode der Auswahl ist die if-Anweisung. Zum Beispiel: + +```lua +local random_number = math.random(1, 100) -- Zwischen 1 und 100. +if random_number > 50 then + print("Woohoo!") +else + print("Oh nein!") +end +``` + +Dies erzeugt eine Zufallszahl zwischen 1 und 100. Es gibt dann "Woohoo!" aus, wenn diese Zahl größer als 50 ist, andernfalls wird "Oh nein!" ausgegeben. + + +### Logische Operatoren + +Zu den logischen Operatoren in Lua gehören: + +| Symbol | Zweck | Beispiel | +|---------|--------------------------------------|-------------------------------------------------------------| +| A == B | Gleich | 1 == 1 (true), 1 == 2 (false) | +| A ~= B | nicht gleich | 1 ~= 1 (false), 1 ~= 2 (true) | +| A > B | Größer als | 5 > 2 (true), 1 > 2 (false), 1 > 1 (false) | +| A < B | Kleiner als | 1 < 3 (true), 3 < 1 (false), 1 < 1 (false) | +| A >= B | Größer als oder gleich | 5 >= 5 (true), 5 >= 3 (true), 5 >= 6 (false) | +| A <= B | Kleiner als oder gleich | 3 <= 6 (true), 3 <= 3 (true) | +| A and B | Und (beides muss `True`, also wahr sein) | (2 > 1) and (1 == 1) (true), (2 > 3) and (1 == 1) (false) | +| A or B | Entweder oder. Eines oder beide müssen wahr sein. | (2 > 1) or (1 == 2) (true), (2 > 4) or (1 == 3) (false) | +| not A | Nicht `True`, also nicht wahr | not (1 == 2) (true), not (1 == 1) (false) | + +Bitte beachten Sie, dass dies nicht alle möglichen Operatoren enthält. + +Es ist auch möglich, Operatoren zu kombinieren. Zum Beispiel: + +```lua +if not A and B then + print("Yay!") +end +``` + +Dies gibt "Yay!" aus, wenn A `False`, also falsch, und B `True`, also wahr, ist. + +Logische und arithmetische Operatoren funktionieren auf die gleiche Weise; beide akzeptieren Eingaben und geben einen Wert zurück, der gespeichert werden kann. Zum Beispiel: + +```lua +local A = 5 +local ist_gleich = (A == 5) +if ist_gleich then + print("Ist gleich!") +end +``` + +## Progarmmierung + +Beim Programmieren geht es darum, ein Problem, z. B. das Sortieren einer Liste +und in Schritte umzuwandeln, die ein Computer verstehen kann. + +Ihnen den logischen Prozess des Programmierens beizubringen, würde den Rahmen dieses Buches sprengen. Die folgenden Websites sind jedoch sehr nützlich, um dies zu entwickeln: + +* [Codecademy](http://www.codecademy.com/) ist eine der besten Ressourcen, um + Lernen, wie man Code schreibt. Sie bietet ein interaktives Lernprogramm. +* [Scratch](https://scratch.mit.edu) ist eine gute Ressource, um mit den + absoluten Grundlagen zu beginnen und die zum Programmieren erforderlichen Problemlösungstechniken zu erlernen.\\ + Scratch wurde entwickelt, um Kindern das Programmieren beizubringen und ist keine ernsthafte, sondern ein Blockbasierte Programmiersprache. + +## Lokale und globale Reichweite + +Ob eine Variable lokal oder global ist, bestimmt, wohin sie geschrieben oder gelesen werden kann. Auf eine lokale Variable kann nur von dort aus zugegriffen werden, wo sie definiert ist. Hier sind einige Beispiele: + +```lua +-- Von dieser Skriptdatei aus zugänglich +local one = 1 + +function myfunc() + -- Von dieser Funktion aus zugänglich + local two = one + one + + if two == one then + -- Zugänglich aus dieser if-Anweisung + local three = one + two + end +end +``` + +Im Gegensatz dazu kann auf globale Variablen von jeder Stelle in der Skriptdatei aus zugegriffen werden und von jeder anderen Mod aus. + +```lua +function one() + foo = "bar" +end + +function two() + print(dump(foo)) -- Gibt "bar" aus +end + +one() +two() +``` + +### Es sollte so viel wie möglich auf lokale Variablen zurückgegriffen werden. + +Wann immer möglich, sollten lokale Variablen verwendet werden. Mods sollten nur eine globale variable mit dem gleichen Namen wie die Mod haben. Das Erstellen weiterer globaler Variablen ist unsaubere +Kodierung, und Minetest wird davor warnen: + + Assignment to undeclared global 'foo' inside function at init.lua:2 + +Auf Deutsch: Zuweisung an eine nicht deklarierte globale Variable 'foo' innerhalb der Funktion in init.lua:2 + +Um dies zu korrigieren, verwenden Sie "local": + +```lua +function one() + local foo = "bar" +end + +function two() + print(dump(foo)) -- Gibt "nil" aus +end + +one() +two() +``` + +Denken Sie daran, dass nil **nicht initialisiert** bedeutet. Die Variable wurde noch nicht mit einem Wert zugewiesen, existiert nicht oder wurde nicht initialisiert (d.h. auf null gesetzt). + +Funktionen sind Variablen eines besonderen Typs sollten aber auch lokal gemacht werden, weil andere Mods Funktionen mit demselben Namen haben könnten. + +```lua +local function foo(bar) + return bar * 2 +end +``` + +Damit Mods Ihre Funktionen aufrufen können, sollten Sie eine Tabelle mit dem gleichen Namen wie die Mod erstellen und darin ihre Funktion einfügen. Diese Tabelle wird oft als "API table" (Deutsch: API-Tabelle) oder Namespace bezeichnet. + +```lua +mymod = {} + +function mymod.foo(bar) + return "foo" .. bar +end + +-- In einer anderen Mod oder einem anderen Skript: +mymod.foo("foobar") +``` + +## Einbindung anderer Lua-Skripte + +Der empfohlene Weg, um andere Lua-Skripte in eine Mod einzubinden, ist die Verwendung von *dofile*. + +```lua +dofile(minetest.get_modpath("modname") .. "/script.lua") +``` + +Ein Skript kann einen Wert zurückgeben, der für die gemeinsame Nutzung privater locals nützlich ist: + +```lua +-- script.lua +return "Hallo Welt!" + +-- init.lua +local ret = dofile(minetest.get_modpath("modname") .. "/script.lua") +print(ret) -- Hallo Welt! +``` + +[In späteren Kapiteln](../quality/clean_arch.html) wird erklärt, wie man den Code einer Mod am besten aufteilt. diff --git a/_de/index.md b/_de/index.md index 133712c..f502963 100644 --- a/_de/index.md +++ b/_de/index.md @@ -12,7 +12,7 @@ idx: 0.1 von Editiert von Shara - Übersetzt von von debiankaios und Tuxilio + Übersetzt von von solars, debiankaios und Tuxilio Korrekturgelessen von jjk1 und Tuxilio