Finished storage.md
This commit is contained in:
debiankaios
parent
a3eb294b25
commit
dcdf4c3520
@ -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_<type>()` and `set_<type>()` 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_<type>()` und `set_<type>()` 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`.)
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user