diff --git a/_de/map/storage.md b/_de/map/storage.md index 91558a0..02b6664 100644 --- a/_de/map/storage.md +++ b/_de/map/storage.md @@ -15,16 +15,16 @@ In diesem Kapitel erfahren Sie, wie Sie Daten speichern können. - [Metadaten](#metadaten) - [Was sind Metadaten?](#was-sind-metadaten) - - [Obtaining a Metadata Object](#obtaining-a-metadata-object) - - [Reading and Writing](#reading-and-writing) - - [Special Keys](#special-keys) - - [Storing Tables](#storing-tables) - - [Private Metadata](#private-metadata) - - [Lua Tables](#lua-tables) + - [Abrufen eines Metadatenobjekts](#abrufen-eines-metadatenobjekts) + - [Lesen und Schreiben](#lesen-und-schreiben) + - [Besondere Schlüssel](#besondere-schlüssel) + - [Speichern von Tabellen](#speichern-von-tabellen) + - [Private Metadaten](#private-metadaten) + - [Lua Tabellen](#lua-tabellen) - [Mod Storage](#mod-storage) -- [Databases](#databases) -- [Deciding Which to Use](#deciding-which-to-use) -- [Your Turn](#your-turn) +- [Datenbanken](#datenbanken) +- [Entscheidung was man benutzt](#entscheidung-was-man-benutzt) +- [Sie sind dran](#sie-sind-dran) ## Metadata @@ -33,41 +33,41 @@ In diesem Kapitel erfahren Sie, wie Sie Daten speichern können. In Minetest sind Metadaten ein Key-Value-Speicher, der verwendet wird, um benutzerdefinierte Daten an etwas anzuhängen. Sie können Metadaten verwenden, um Informationen zu einem Block, Spieler oder ItemStack zu speichern. -Each type of metadata uses the exact same API. -Metadata stores values as strings, but there are a number of methods to -convert and store other primitive types. +Jede Art von Metadaten verwendet genau dieselbe API. +Metadaten speichern Werte als Strings, aber es gibt eine Reihe von Methoden um +andere primitive Typen zu konvertieren und zu speichern. -Some keys in metadata may have special meaning. -For example, `infotext` in node metadata is used to store the tooltip which shows -when hovering over the node using the crosshair. -To avoid conflicts with other mods, you should use the standard namespace -convention for keys: `modname:keyname`. -The exception is for conventional data such as the owner name which is stored as -`owner`. +Einige Schlüssel in Metadaten können eine besondere Bedeutung haben. +Zum Beispiel wird `infotext` in den Block-Metadaten verwendet, um den Tooltip zu speichern, der angezeigt wird +angezeigt wird, wenn man mit dem Fadenkreuz über den Block fährt. +Um Konflikte mit anderen Mods zu vermeiden, sollten Sie die Standard-Namensraum +Konvention für Schlüssel verwenden: `Modname:Schlüsselname`. +Die Ausnahme sind konventionelle Daten wie der Name des Besitzers, der als +`Besitzer`. -Metadata is data about data. -The data itself, such as a node's type or an stack's count, is not metadata. +Metadaten sind Daten über Daten. +Die Daten selbst, wie der Typ eines Blockes oder die Anzahl eines Stapels, sind keine Metadaten. -### Obtaining a Metadata Object +### Abrufen eines Metadatenobjekts -If you know the position of a node, you can retrieve its metadata: +Wenn du die Position eines Blockes kennst, kannst du seine Metadaten abrufen: ```lua local meta = minetest.get_meta({ x = 1, y = 2, z = 3 }) ``` -Player and ItemStack metadata are obtained using `get_meta()`: +Spieler- und ItemStack-Metadaten werden mit `get_meta()` ermittelt.: ```lua local pmeta = player:get_meta() local imeta = stack:get_meta() ``` -### Reading and Writing +### Lesen und Schreiben -In most cases, `get_()` and `set_()` methods will be used to read -and write to meta. -Metadata stores strings, so the string methods will directly set and get the value. +In den meisten Fällen werden die Methoden `get_()` und `set_()` zum Lesen +und zum schreiben in Metadaten verwendet . +Metadaten speichern Strings, so dass die String-Methoden direkt den Wert setzen und holen. ```lua print(meta:get_string("foo")) --> "" @@ -75,15 +75,15 @@ meta:set_string("foo", "bar") print(meta:get_string("foo")) --> "bar" ``` -All of the typed getters will return a neutral default value if the key doesn't -exist, such as `""` or `0`. -You can use `get()` to return a string or nil. +Alle typisierten Getter geben einen neutralen Standardwert zurück, wenn der Schlüssel nicht +nicht existiert, wie zum Beispiel `""` oder `0`. +Sie können `get()` verwenden, um einen String oder nil zurückzugeben. -As Metadata is a reference, any changes will be updated to the source automatically. -ItemStacks aren't references however, so you'll need to update the itemstack in the -inventory. +Da es sich bei Metadaten um eine Referenz handelt, werden alle Änderungen automatisch in der Quelle aktualisiert. +ItemStacks sind jedoch keine Referenzen, daher müssen Sie den Itemstack im +Inventar aktualisieren. -The non-typed getters and setters will convert to and from strings: +Die nicht typisierten Getter und Setter werden in und aus Strings konvertiert: ```lua print(meta:get_int("count")) --> 0 @@ -92,48 +92,48 @@ print(meta:get_int("count")) --> 3 print(meta:get_string("count")) --> "3" ``` -### Special Keys +### Besondere Schlüssel -`infotext` is used in Node Metadata to show a tooltip when hovering the crosshair over a node. -This is useful when showing the ownership or status of a node. +`infotext` wird in Block-Metadaten verwendet, um einen Tooltip anzuzeigen, wenn das Fadenkreuz über einem Block schwebt. +Dies ist nützlich, um die Eigentümerschaft oder den Status eines Blockes anzuzeigen. -`description` is used in ItemStack Metadata to override the description when -hovering over the stack in an inventory. -You can use colours by encoding them with `minetest.colorize()`. +`description` wird in ItemStack-Metadaten verwendet, um die Beschreibung zu überschreiben, +wenn der Mauszeiger über den Stack in einem Inventar bewegt wird. +Sie können Farben verwenden, indem Sie sie mit `minetest.colorize()` kodieren. -`owner` is a common key used to store the username of the player that owns the -item or node. +`owner` ist ein allgemeiner Schlüssel, der verwendet wird, um den Benutzernamen des Spielers zu speichern, der Eigentümer des +Element oder Block besitzt. -### Storing Tables +### Speichern von Tabellen -Tables must be converted to strings before they can be stored. -Minetest offers two formats for doing this: Lua and JSON. +Tabellen müssen in Strings umgewandelt werden, bevor sie gespeichert werden können. +Minetest bietet dafür zwei Formate an: Lua und JSON. -The Lua method tends to be a lot faster and matches the format Lua -uses for tables, while JSON is a more standard format, is better -structured, and is well suited for when you need to exchange information -with another program. +Die Lua-Methode ist in der Regel viel schneller und entspricht dem Format, das Lua +für Tabellen verwendet, während JSON ein standardisierteres Format ist, das besser +strukturiert und sich gut für den Austausch von Informationen mit +einem anderen Programm eignet. ```lua -local data = { username = "player1", score = 1234 } -meta:set_string("foo", minetest.serialize(data)) +local daten = { benutzername = "spieler1", punktestand = 1234 } +meta:set_string("foo", minetest.serialize(daten)) -data = minetest.deserialize(minetest:get_string("foo")) +daten = minetest.deserialize(minetest:get_string("foo")) ``` -### Private Metadata +### Private Metadaten -By default, all node metadata is sent to the client. -You can mark keys as private to prevent this. +Standardmäßig werden alle Block-Metadaten an den Client gesendet. +Sie können Schlüssel als privat markieren, um dies zu verhindern. ```lua -meta:set_string("secret", "asd34dn") -meta:mark_as_private("secret") +meta:set_string("geheim", "asd34dn") +meta:mark_as_private("geheim") ``` -### Lua Tables +### Lua Tabellen -You can convert to and from Lua tables using `to_table` and `from_table`: +Sie können mit `to_table` und `from_table` in und aus Lua-Tabellen konvertieren: ```lua local tmp = meta:to_table() @@ -143,105 +143,105 @@ meta:from_table(tmp) ## Mod Storage -Mod storage uses the exact same API as Metadata, although it's not technically -Metadata. -Mod storage is per-mod, and can only be obtained during load time in order to -know which mod is requesting it. +Mod-Storage verwendet genau dieselbe API wie Metadaten, obwohl sie technisch gesehen keine +Metadaten sind. +Mod-Speicher ist pro Mod und kann nur während der Ladezeit abgefragt werden, um zu wissen, +welche Mod sie anfordert. ```lua local storage = minetest.get_mod_storage() ``` -You can now manipulate the storage just like metadata: +Sie können den Speicher nun genau wie Metadaten manipulieren: ```lua storage:set_string("foo", "bar") ``` -## Databases +## Datenbanken -If the mod is likely to be used on a server and will store lots of data, -it's a good idea to offer a database storage method. -You should make this optional by separating how the data is stored and where -it is used. +Wenn der Mod wahrscheinlich auf einem Server verwendet wird und viele Daten speichert, +ist es eine gute Idee, eine Datenbank-Speichermethode anzubieten. +Sie sollten dies optional machen, indem Sie trennen, wie die Daten gespeichert werden und wo +sie verwendet werden. ```lua local backend -if use_database then +if verwende_datenbank then backend = - dofile(minetest.get_modpath("mymod") .. "/backend_sqlite.lua") + dofile(minetest.get_modpath("meinemod") .. "/backend_sqlite.lua") else backend = - dofile(minetest.get_modpath("mymod") .. "/backend_storage.lua") + dofile(minetest.get_modpath("meinemod") .. "/backend_storage.lua") end backend.get_foo("a") backend.set_foo("a", { score = 3 }) ``` -The backend_storage.lua file should include a mod storage implementation: +Die Datei backend_storage.lua sollte eine Mod-Storage-Implementierung enthalten: ```lua local storage = minetest.get_mod_storage() local backend = {} -function backend.set_foo(key, value) - storage:set_string(key, minetest.serialize(value)) +function backend.set_foo(schluessel, wert) + storage:set_string(schluessel, minetest.serialize(wert)) end -function backend.get_foo(key) - return minetest.deserialize(storage:get_string(key)) +function backend.get_foo(schluessel) + return minetest.deserialize(storage:get_string(schluessel)) end return backend ``` -The backend_sqlite would do a similar thing, but use the Lua *lsqlite3* library -instead of mod storage. +Das Backend_sqlite würde eine ähnliche Funktion erfüllen, aber die Lua-Bibliothek *lsqlite3* verwenden +anstelle des Mod-Speichers. -Using a database such as SQLite requires using an insecure environment. -An insecure environment is a table that is only available to mods -explicitly whitelisted by the user, and it contains a less restricted -copy of the Lua API which could be abused if available to malicious mods. -Insecure environments will be covered in more detail in the -[Security](../quality/security.html) chapter. +Die Verwendung einer Datenbank wie SQLite erfordert die Verwendung einer unsicheren Umgebung. +Eine unsichere Umgebung ist eine Tabelle, die nur für Mods verfügbar ist, +die vom Benutzer explizit auf eine Whitelist gesetzt wurden, und sie enthält eine weniger eingeschränkte +Kopie der Lua-API, die missbraucht werden könnte, wenn sie böswilligen Mods zur Verfügung stünde. +Unsichere Umgebungen werden im Detail in dem +Kapitel [Sicherheit](../quality/security.html) behandelt. ```lua -local ie = minetest.request_insecure_environment() -assert(ie, "Please add mymod to secure.trusted_mods in the settings") +local uu = minetest.request_insecure_environment() +assert(uu, "Bitte fügen Sie meinemod zu secure.trusted_mods in den Einstellungen hinzu") -local _sql = ie.require("lsqlite3") --- Prevent other mods from using the global sqlite3 library +local _sql = uu.require("lsqlite3") +-- Andere Mods daran hindern, die globale sqlite3-Bibliothek zu verwenden if sqlite3 then sqlite3 = nil end ``` -Teaching about SQL or how to use the lsqlite3 library is out of scope for this book. +Die Vermittlung von Wissen über SQL oder die Verwendung der lsqlite3-Bibliothek ist nicht Gegenstand dieses Buches. -## Deciding Which to Use +## Entscheidung was man benutzt -The type of method you use depends on what the data is about, -how it is formatted, and how large it is. -As a guideline, small data is up to 10K, medium data is up to 10MB, and large -data is any size above that. +Welche Methode Sie verwenden, hängt davon ab, worum es sich bei den Daten handelt, +wie sie formatiert sind und wie groß sie sind. +Als Richtlinie gilt, dass kleine Daten bis zu 10K, mittlere Daten bis zu 10MB und große +Daten jede Größe darüber sind. -Node metadata is a good choice when you need to store node-related data. -Storing medium data is fairly efficient if you make it private. +Block-Metadaten sind eine gute Wahl, wenn Sie blockbezogene Daten speichern müssen. +Die Speicherung mittlerer Daten ist recht effizient, wenn Sie sie privat machen. -Item metadata should not be used to store anything but small amounts of data as it is not -possible to avoid sending it to the client. -The data will also be copied every time the stack is moved, or accessed from Lua. +Item-Metadaten sollten nur zum Speichern kleiner Datenmengen verwendet werden, da es nicht möglich ist, +sie an den Client zu senden. +Die Daten werden auch jedes Mal kopiert, wenn der Stack verschoben oder von Lua aus aufgerufen wird. -Mod storage is good for medium data but writing large data may be inefficient. -It's better to use a database for large data to avoid having to write all the -data out on every save. +Mod-Storage ist gut für mittlere Daten, aber das Schreiben großer Daten kann ineffizient sein. +Es ist besser, eine Datenbank für große Daten zu verwenden, um zu vermeiden, +dass alle Daten bei jedem Speichern geschrieben werden müssen. -Databases are only viable for servers due to the -need to whitelist the mod to access an insecure environment. -They're well suited for large data sets. +Datenbanken kommen nur für Server in Frage, da die +der Mod auf eine Whitelist gesetzt werden muss, um auf eine unsichere Umgebung zugreifen zu können. +Sie sind gut geeignet für große Datenmengen. -## Your Turn +## Sie sind dran -* Make a node which disappears after it has been punched five times. -(Use `on_punch` in the node definition and `minetest.set_node`.) +* Erstellen Sie einen Block, der verschwindet, nachdem er fünfmal geschlagen wurde. +(Verwenden Sie `on_punch` in der Definition des Blockes und `minetest.set_node`.) diff --git a/_de/wörterbuch.txt b/_de/wörterbuch.txt index 2eac9e1..1fd0045 100644 --- a/_de/wörterbuch.txt +++ b/_de/wörterbuch.txt @@ -4,30 +4,40 @@ bulk = bulk Chapter = Kapitel Cubic Nodes = Würfelförmiger Block craft slots = Handwerksplätze +database = Datenbank detached inventory = freistehendes Inventar dig = abbauen drawtype = Zeichnungstyp Entities = Entities Folder = Verzeichnis games = Spiele +getter = Getter glasslike = Glasartig grid = Raster +insecure environment = unsichere Umgebung Introduction = Einleitung Inventory = Inventar Inventory List = Inventarliste Inventory Location = Inventarstandort Inventory reference = Inventar-Referenz +Item metadata = Item-Metadaten ItemStack = ItemStack +key = Schlüssel +large data = große Daten main inventory = Hauptinventar map = Karte MapBlock = Map-Block +medium data = mittlere Daten Mesh = Mesh Mesh Nodes = Mesh Nodes +Metadata Object = Metadatenobjekt mod load paths = Mod-Lade-Verzeichnisse mod's folder = Mod-Verzeichnis mods = Mods +Mod storage = Mod-Storage module = Modul node = Block +Node metadata = Block-Metadaten nodes = Blöcke nodebox = Nodebox nodeboxes = Nodeboxen @@ -38,9 +48,12 @@ placer = plazierer player inventory = Spielerinventar player reference = Spielerreferenz pointed_thing = angeschautes_ding +small data = kleine Daten Stack = Stack +storage = Storage table = Tabelle tile = Kachel tiles = Kacheln timer = timer wear = Abnutzung +Your turn = Sie sind dran