MTSR/minetest_modding_book
4
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Finished enviroment.md

Browse Source
This commit is contained in:
debiankaios 2022-08-19 13:26:42 +02:00
parent 80319c51e5
commit 2b949d68f7
1 changed files with 87 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
_de/map/environment.md
View File

@ -4,7 +4,7 @@ layout: default
root: ../.. root: ../..
idx: 3.1 idx: 3.1
description: Grundlegende Operationen wie set_node und get_node description: Grundlegende Operationen wie set_node und get_node
redirect_from: /en/chapters/environment.html redirect_from: /de/chapters/environment.html
--- ---
## Einleitung <!-- omit in toc --> ## Einleitung <!-- omit in toc -->
@ -14,12 +14,12 @@ In diesem Kapitel erfahren Sie, wie Sie grundlegende Aktionen auf der Karte durc
- [Karten Struktur](#karten-struktur) - [Karten Struktur](#karten-struktur)
- [Lesen](#lesen) - [Lesen](#lesen)
- [Blöcke lesen](#blöcke-lesen) - [Blöcke lesen](#blöcke-lesen)
- [Finding Nodes](#finding-nodes) - [Blöcke finden](#blöcke-finden)
- [Writing](#writing) - [Schreiben](#schreiben)
- [Writing Nodes](#writing-nodes) - [Blöcke schreiben](#blöcke-schreiben)
- [Removing Nodes](#removing-nodes) - [Blöcke löschen](#blöcke-löschen)
- [Loading Blocks](#loading-blocks) - [Mapblöcke laden](#mapblöcke-laden)
- [Deleting Blocks](#deleting-blocks) - [Blöcke löschen](#blöcke-löschen)
## Karten Struktur ## Karten Struktur
@ -47,7 +47,7 @@ außerhalb des Generierungslimits aus der Weltdatenbank geladen werden.
Sobald Sie eine Position haben, können Sie diese auf der Karte ablesen: Sobald Sie eine Position haben, können Sie diese auf der Karte ablesen:
```lua ```lua
local node = minetest.get_node({ x = 1, y = 3, z = 4 }) --Warnung: Im Englischen ist mit block der Map-Block gemeint. Daher emphielt sich für die Variabelnamen node(Knoten) zu nehmen local node = minetest.get_node({ x = 1, y = 3, z = 4 }) --Warnung: Im Englischen ist mit block der Map-Block gemeint. Daher emphielt sich für die Variabelnamen node(Knoten) anstatt block zu nehmen
print(dump(node)) --> { name=.., param1=.., param2=.. } print(dump(node)) --> { name=.., param1=.., param2=.. }
``` ```
@ -67,42 +67,41 @@ Dies kann immer noch `ignore` zurückgeben, wenn ein Block tatsächlich ignore e
Dies wird in der Nähe des Randes der Karte passieren, wie es durch die Kartengenerierung definiert ist Dies wird in der Nähe des Randes der Karte passieren, wie es durch die Kartengenerierung definiert ist
Grenze (`mapgen_limit`) definiert ist. Grenze (`mapgen_limit`) definiert ist.
### Finding Nodes ### Blöcke finden
Minetest offers a number of helper functions to speed up common map actions. Minetest bietet eine Reihe von Hilfsfunktionen, um gängige Map-Aktionen zu beschleunigen.
The most commonly used of these are for finding nodes. Die am häufigsten verwendeten Funktionen dienen dem Auffinden von Blöcken.
For example, say we wanted to make a certain type of plant that grows Angenommen, wir wollen eine bestimmte Pflanzenart herstellen, die besser in der Nähe von Mese wächst;
better near mese; you would need to search for any nearby mese nodes, müssten Sie nach allen Mese-Blöcke in der Nähe suchen,
and adapt the growth rate accordingly. und die Wachstumsrate entsprechend anpassen.
`minetest.find_node_near` will return the first found node in a certain radius
which matches the node names or groups given. In the following example,
we look for a mese node within 5 nodes of the position:
`minetest.find_node_near` liefert den ersten gefundenen Block in einem bestimmten Radius
der mit den angegebenen Knotennamen oder Gruppen übereinstimmt. Im folgenden Beispiel,
suchen wir nach einem Mese-Block innerhalb von 5 Knoten von der Position:
```lua ```lua
local grow_speed = 1 local wachstums_geschwindigkeit = 1
local node_pos = minetest.find_node_near(pos, 5, { "default:mese" }) local node_pos = minetest.find_node_near(pos, 5, { "default:mese" })
if node_pos then if node_pos then
minetest.chat_send_all("Node found at: " .. dump(node_pos)) minetest.chat_send_all("Bei " .. dump(node_pos) .. " Block gefunden")
grow_speed = 2 wachstums_geschwindigkeit = 2
end end
``` ```
Let's say, for example, that the growth rate increases the more mese there is Nehmen wir zum Beispiel an, dass die Wachstumsrate steigt, je mehr Mese in der Nähe ist.
nearby. You should then use a function that can find multiple nodes in the area: in der Nähe ist. Dann sollten Sie eine Funktion verwenden, die mehrere Blöcke in dem Gebiet finden kann:
```lua ```lua
local pos1 = vector.subtract(pos, { x = 5, y = 5, z = 5 }) local pos1 = vector.subtract(pos, { x = 5, y = 5, z = 5 })
local pos2 = vector.add(pos, { x = 5, y = 5, z = 5 }) local pos2 = vector.add(pos, { x = 5, y = 5, z = 5 })
local pos_list = local pos_list =
minetest.find_nodes_in_area(pos1, pos2, { "default:mese" }) minetest.find_nodes_in_area(pos1, pos2, { "default:mese" })
local grow_speed = 1 + #pos_list local wachstums_geschwindigkeit = 1 + #pos_list
``` ```
The above code finds the number of nodes in a *cuboid volume*. This is different Der obige Code ermittelt die Anzahl der Knoten in einem *kubischen Volumen*. Dies ist anders
to `find_node_near`, which uses the distance to the position (ie: a *sphere*). In zu `find_node_near`, das den Abstand zur Position (d.h. einer *Kugel*) verwendet.
order to fix this, we will need to manually check the range ourselves: Um dies zu beheben, müssen wir den Bereich manuell selbst überprüfen:
```lua ```lua
local pos1 = vector.subtract(pos, { x = 5, y = 5, z = 5 }) local pos1 = vector.subtract(pos, { x = 5, y = 5, z = 5 })
@ -113,28 +112,28 @@ local grow_speed = 1
for i=1, #pos_list do for i=1, #pos_list do
local delta = vector.subtract(pos_list[i], pos) local delta = vector.subtract(pos_list[i], pos)
if delta.x*delta.x + delta.y*delta.y + delta.z*delta.z <= 5*5 then if delta.x*delta.x + delta.y*delta.y + delta.z*delta.z <= 5*5 then
grow_speed = grow_speed + 1 wachstums_geschwindigkeit = wachstums_geschwindigkeit + 1
end end
end end
``` ```
Now the code will correctly increase `grow_speed` based on mese nodes in range. Jetzt erhöht der Code korrekt die `wachstums_geschwindigkeit` basierend auf der Anzahl der Knoten in Reichweite.
Note how we compared the squared distance from the position, rather than square Beachten Sie, dass wir den quadrierten Abstand von der Position verglichen haben, anstatt ihn zu quadrieren
rooting it to obtain the actual distance. This is because computers find square um die tatsächliche Entfernung zu erhalten. Dies liegt daran, dass Computer Quadratwurzeln
roots computationally expensive, so they should avoided as much as possible. Wurzel sehr rechenintensiv sind und daher möglichst vermieden werden sollten.
There are more variations of the above two functions, such as Es gibt weitere Variationen der beiden oben genannten Funktionen, wie z.B.
`find_nodes_with_meta` and `find_nodes_in_area_under_air`, which work similarly `find_nodes_with_meta` und `find_nodes_in_area_under_air`, die ähnlich funktionieren
and are useful in other circumstances. und unter anderen Umständen nützlich sind.
## Writing ## Schreiben
### Writing Nodes ### Blöcke schreiben
You can use `set_node` to write to the map. Each call to set_node will cause Sie können `set_node` verwenden, um in die Karte zu schreiben. Jeder Aufruf von set_node wird dazu führen, dass
lighting to be recalculated and node callbacks to run, which means that set_node Beleuchtung neu berechnet und Block-Callbacks ausgeführt werden, was bedeutet, dass set_node
is fairly slow for large numbers of nodes. bei einer großen Anzahl von Blöcken ziemlich langsam ist.
```lua ```lua
minetest.set_node({ x = 1, y = 3, z = 4 }, { name = "default:mese" }) minetest.set_node({ x = 1, y = 3, z = 4 }, { name = "default:mese" })
@ -143,91 +142,91 @@ local node = minetest.get_node({ x = 1, y = 3, z = 4 })
print(node.name) --> default:mese print(node.name) --> default:mese
``` ```
set_node will remove any associated metadata or inventory from that position. set_node entfernt alle zugehörigen Metadaten oder Bestände von dieser Position.
This isn't desirable in all circumstances, especially if you're using multiple Dies ist nicht unter allen Umständen wünschenswert, insbesondere wenn Sie mehrere
node definitions to represent one conceptual node. An example of this is the Block-Definitionen verwenden, um einen konzeptionellen Blöcke zu repräsentieren. Ein Beispiel hierfür ist der
furnace node - whilst you conceptually think of it as one node, it's actually Ofenblock - während man ihn konzeptionell als einen Block betrachtet, sind es eigentlich
two. zwei.
You can set a node without deleting metadata or the inventory like so: Sie können einen Knoten setzen, ohne die Metadaten oder das Inventar zu löschen, wie folgt:
```lua ```lua
minetest.swap_node({ x = 1, y = 3, z = 4 }, { name = "default:mese" }) minetest.swap_node({ x = 1, y = 3, z = 4 }, { name = "default:mese" })
``` ```
### Removing Nodes ### Blöcke löschen
A node must always be present. To remove a node, you set the position to `air`. Ein Block muss immer vorhanden sein. Um einen Block zu entfernen, setzen Sie die Position auf "Luft".
The following two lines will both remove a node, and are both identical: Die folgenden beiden Zeilen entfernen beide einen Block und sind identisch:
```lua ```lua
minetest.remove_node(pos) minetest.remove_node(pos)
minetest.set_node(pos, { name = "air" }) minetest.set_node(pos, { name = "air" })
``` ```
In fact, remove_node is just a helper function that calls set_node with `"air"`. Tatsächlich ist remove_node nur eine Hilfsfunktion, die set_node mit `"air"` aufruft.
## Loading Blocks ## Mapblöcke laden
You can use `minetest.emerge_area` to load map blocks. Emerge area is asynchronous, Sie können `minetest.emerge_area` verwenden, um Map-Blöcke zu laden. Emerge area ist asynchron,
meaning the blocks won't be loaded instantly. Instead, they will be loaded das heißt, die Mapblöcke werden nicht sofort geladen. Stattdessen werden sie
soon in the future, and the callback will be called each time. in der Zukunft geladen und der Callback wird jedes Mal aufgerufen.
```lua ```lua
-- Load a 20x20x20 area -- Lädt einen 20x20x20-Bereich
local halfsize = { x = 10, y = 10, z = 10 } local halbegroesse = { x = 10, y = 10, z = 10 } --ss = ß
local pos1 = vector.subtract(pos, halfsize) local pos1 = vector.subtract(pos, halbegroesse)
local pos2 = vector.add (pos, halfsize) local pos2 = vector.add (pos, halbegroesse)
local context = {} -- persist data between callback calls local kontext = {} -- Daten zwischen Callback-Aufrufen aufrechterhalten
minetest.emerge_area(pos1, pos2, emerge_callback, context) minetest.emerge_area(pos1, pos2, emerge_callback, kontext)
``` ```
Minetest will call `emerge_callback` whenever it loads a block, with some Minetest ruft `emerge_callback` immer dann auf, wenn er einen Mapblock, mit einigen
progress information. Fortschrittsinformationen, lädt.
```lua ```lua
local function emerge_callback(pos, action, local function emerge_callback(pos, aktion,
num_calls_remaining, context) verbleibende_calls, kontext)
-- On first call, record number of blocks -- Beim ersten Aufruf, Anzahl der Mapblöcke erfassen
if not context.total_blocks then if not kontext.bloecke_insgesamt then
context.total_blocks = num_calls_remaining + 1 kontext.bloecke_insgesamt = verbleibende_calls + 1
context.loaded_blocks = 0 kontext.geladene_bloecke = 0
end end
-- Increment number of blocks loaded -- Erhöhung der Anzahl der geladenen Blöcke
context.loaded_blocks = context.loaded_blocks + 1 kontext.bloecke_insgesamt = kontext.geladene_bloecke + 1
-- Send progress message -- Fortschrittsmeldung senden
if context.total_blocks == context.loaded_blocks then if kontext.bloecke_insgesamt == kontext.geladene_bloecke then
minetest.chat_send_all("Finished loading blocks!") minetest.chat_send_all("Blöcke laden abgeschlossen!")
end end
local perc = 100 * context.loaded_blocks / context.total_blocks local perc = 100 * kontext.geladene_bloecke / kontext.bloecke_insgesamt
local msg = string.format("Loading blocks %d/%d (%.2f%%)", local msg = string.format("Geladene Blöcke %d/%d (%.2f%%)",
context.loaded_blocks, context.total_blocks, perc) kontext.geladene_bloecke, kontext.bloecke_insgesamt, perc)
minetest.chat_send_all(msg) minetest.chat_send_all(msg)
end end
end end
``` ```
This is not the only way of loading blocks; using an Dies ist nicht die einzige Möglichkeit, Mapblöcke zu laden; die Verwendung eines
[Lua Voxel Manipulator (LVM)](../advmap/lvm.html) will also cause the [Lua Voxel Manipulator (LVM)](../advmap/lvm.html) bewirkt ebenfalls, dass die
encompassed blocks to be loaded synchronously. umschlossenen Mapblöcke synchron geladen werden.
## Deleting Blocks ## Blöcke löschen
You can use delete_blocks to delete a range of map blocks: Sie können delete_blocks verwenden, um einen Bereich von Map-Blöcken zu löschen:
```lua ```lua
-- Delete a 20x20x20 area -- Löscht einen 20x20x20-Bereich
local halfsize = { x = 10, y = 10, z = 10 } local halbegroesse = { x = 10, y = 10, z = 10 }
local pos1 = vector.subtract(pos, halfsize) local pos1 = vector.subtract(pos, halbegroesse)
local pos2 = vector.add (pos, halfsize) local pos2 = vector.add (pos, halbegroesse)
minetest.delete_area(pos1, pos2) minetest.delete_area(pos1, pos2)
``` ```
This will delete all map blocks in that area, *inclusive*. This means that some Dadurch werden alle Map-Blöcke in diesem Bereich *inklusive* gelöscht. Das bedeutet, dass einige
nodes will be deleted outside the area as they will be on a mapblock which overlaps Blöcke außerhalb des Bereichs gelöscht werden, da sie sich auf einem Map-Block befinden, der sich mit den
the area bounds. die Bereichsgrenzen überlappen.