Finished enviroment.md
This commit is contained in:
debiankaios
parent
80319c51e5
commit
2b949d68f7
@ -4,7 +4,7 @@ layout: default
|
||||
root: ../..
|
||||
idx: 3.1
|
||||
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 -->
|
||||
@ -14,12 +14,12 @@ In diesem Kapitel erfahren Sie, wie Sie grundlegende Aktionen auf der Karte durc
|
||||
- [Karten Struktur](#karten-struktur)
|
||||
- [Lesen](#lesen)
|
||||
- [Blöcke lesen](#blöcke-lesen)
|
||||
- [Finding Nodes](#finding-nodes)
|
||||
- [Writing](#writing)
|
||||
- [Writing Nodes](#writing-nodes)
|
||||
- [Removing Nodes](#removing-nodes)
|
||||
- [Loading Blocks](#loading-blocks)
|
||||
- [Deleting Blocks](#deleting-blocks)
|
||||
- [Blöcke finden](#blöcke-finden)
|
||||
- [Schreiben](#schreiben)
|
||||
- [Blöcke schreiben](#blöcke-schreiben)
|
||||
- [Blöcke löschen](#blöcke-löschen)
|
||||
- [Mapblöcke laden](#mapblöcke-laden)
|
||||
- [Blöcke löschen](#blöcke-löschen)
|
||||
|
||||
## 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:
|
||||
|
||||
```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=.. }
|
||||
```
|
||||
|
||||
@ -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
|
||||
Grenze (`mapgen_limit`) definiert ist.
|
||||
|
||||
### Finding Nodes
|
||||
### Blöcke finden
|
||||
|
||||
Minetest offers a number of helper functions to speed up common map actions.
|
||||
The most commonly used of these are for finding nodes.
|
||||
Minetest bietet eine Reihe von Hilfsfunktionen, um gängige Map-Aktionen zu beschleunigen.
|
||||
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
|
||||
better near mese; you would need to search for any nearby mese nodes,
|
||||
and adapt the growth rate accordingly.
|
||||
|
||||
`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:
|
||||
Angenommen, wir wollen eine bestimmte Pflanzenart herstellen, die besser in der Nähe von Mese wächst;
|
||||
müssten Sie nach allen Mese-Blöcke in der Nähe suchen,
|
||||
und die Wachstumsrate entsprechend anpassen.
|
||||
|
||||
`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
|
||||
local grow_speed = 1
|
||||
local wachstums_geschwindigkeit = 1
|
||||
local node_pos = minetest.find_node_near(pos, 5, { "default:mese" })
|
||||
if node_pos then
|
||||
minetest.chat_send_all("Node found at: " .. dump(node_pos))
|
||||
grow_speed = 2
|
||||
minetest.chat_send_all("Bei " .. dump(node_pos) .. " Block gefunden")
|
||||
wachstums_geschwindigkeit = 2
|
||||
end
|
||||
```
|
||||
|
||||
Let's say, for example, that the growth rate increases the more mese there is
|
||||
nearby. You should then use a function that can find multiple nodes in the area:
|
||||
Nehmen wir zum Beispiel an, dass die Wachstumsrate steigt, je mehr Mese in der Nähe ist.
|
||||
in der Nähe ist. Dann sollten Sie eine Funktion verwenden, die mehrere Blöcke in dem Gebiet finden kann:
|
||||
|
||||
```lua
|
||||
local pos1 = vector.subtract(pos, { x = 5, y = 5, z = 5 })
|
||||
local pos2 = vector.add(pos, { x = 5, y = 5, z = 5 })
|
||||
local pos_list =
|
||||
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
|
||||
to `find_node_near`, which uses the distance to the position (ie: a *sphere*). In
|
||||
order to fix this, we will need to manually check the range ourselves:
|
||||
Der obige Code ermittelt die Anzahl der Knoten in einem *kubischen Volumen*. Dies ist anders
|
||||
zu `find_node_near`, das den Abstand zur Position (d.h. einer *Kugel*) verwendet.
|
||||
Um dies zu beheben, müssen wir den Bereich manuell selbst überprüfen:
|
||||
|
||||
```lua
|
||||
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
|
||||
local delta = vector.subtract(pos_list[i], pos)
|
||||
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
|
||||
```
|
||||
|
||||
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
|
||||
rooting it to obtain the actual distance. This is because computers find square
|
||||
roots computationally expensive, so they should avoided as much as possible.
|
||||
Beachten Sie, dass wir den quadrierten Abstand von der Position verglichen haben, anstatt ihn zu quadrieren
|
||||
um die tatsächliche Entfernung zu erhalten. Dies liegt daran, dass Computer Quadratwurzeln
|
||||
Wurzel sehr rechenintensiv sind und daher möglichst vermieden werden sollten.
|
||||
|
||||
There are more variations of the above two functions, such as
|
||||
`find_nodes_with_meta` and `find_nodes_in_area_under_air`, which work similarly
|
||||
and are useful in other circumstances.
|
||||
Es gibt weitere Variationen der beiden oben genannten Funktionen, wie z.B.
|
||||
`find_nodes_with_meta` und `find_nodes_in_area_under_air`, die ähnlich funktionieren
|
||||
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
|
||||
lighting to be recalculated and node callbacks to run, which means that set_node
|
||||
is fairly slow for large numbers of nodes.
|
||||
Sie können `set_node` verwenden, um in die Karte zu schreiben. Jeder Aufruf von set_node wird dazu führen, dass
|
||||
Beleuchtung neu berechnet und Block-Callbacks ausgeführt werden, was bedeutet, dass set_node
|
||||
bei einer großen Anzahl von Blöcken ziemlich langsam ist.
|
||||
|
||||
```lua
|
||||
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
|
||||
```
|
||||
|
||||
set_node will remove any associated metadata or inventory from that position.
|
||||
This isn't desirable in all circumstances, especially if you're using multiple
|
||||
node definitions to represent one conceptual node. An example of this is the
|
||||
furnace node - whilst you conceptually think of it as one node, it's actually
|
||||
two.
|
||||
set_node entfernt alle zugehörigen Metadaten oder Bestände von dieser Position.
|
||||
Dies ist nicht unter allen Umständen wünschenswert, insbesondere wenn Sie mehrere
|
||||
Block-Definitionen verwenden, um einen konzeptionellen Blöcke zu repräsentieren. Ein Beispiel hierfür ist der
|
||||
Ofenblock - während man ihn konzeptionell als einen Block betrachtet, sind es eigentlich
|
||||
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
|
||||
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
|
||||
minetest.remove_node(pos)
|
||||
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,
|
||||
meaning the blocks won't be loaded instantly. Instead, they will be loaded
|
||||
soon in the future, and the callback will be called each time.
|
||||
Sie können `minetest.emerge_area` verwenden, um Map-Blöcke zu laden. Emerge area ist asynchron,
|
||||
das heißt, die Mapblöcke werden nicht sofort geladen. Stattdessen werden sie
|
||||
in der Zukunft geladen und der Callback wird jedes Mal aufgerufen.
|
||||
|
||||
```lua
|
||||
-- Load a 20x20x20 area
|
||||
local halfsize = { x = 10, y = 10, z = 10 }
|
||||
local pos1 = vector.subtract(pos, halfsize)
|
||||
local pos2 = vector.add (pos, halfsize)
|
||||
-- Lädt einen 20x20x20-Bereich
|
||||
local halbegroesse = { x = 10, y = 10, z = 10 } --ss = ß
|
||||
local pos1 = vector.subtract(pos, halbegroesse)
|
||||
local pos2 = vector.add (pos, halbegroesse)
|
||||
|
||||
local context = {} -- persist data between callback calls
|
||||
minetest.emerge_area(pos1, pos2, emerge_callback, context)
|
||||
local kontext = {} -- Daten zwischen Callback-Aufrufen aufrechterhalten
|
||||
minetest.emerge_area(pos1, pos2, emerge_callback, kontext)
|
||||
```
|
||||
|
||||
Minetest will call `emerge_callback` whenever it loads a block, with some
|
||||
progress information.
|
||||
Minetest ruft `emerge_callback` immer dann auf, wenn er einen Mapblock, mit einigen
|
||||
Fortschrittsinformationen, lädt.
|
||||
|
||||
```lua
|
||||
local function emerge_callback(pos, action,
|
||||
num_calls_remaining, context)
|
||||
-- On first call, record number of blocks
|
||||
if not context.total_blocks then
|
||||
context.total_blocks = num_calls_remaining + 1
|
||||
context.loaded_blocks = 0
|
||||
local function emerge_callback(pos, aktion,
|
||||
verbleibende_calls, kontext)
|
||||
-- Beim ersten Aufruf, Anzahl der Mapblöcke erfassen
|
||||
if not kontext.bloecke_insgesamt then
|
||||
kontext.bloecke_insgesamt = verbleibende_calls + 1
|
||||
kontext.geladene_bloecke = 0
|
||||
end
|
||||
|
||||
-- Increment number of blocks loaded
|
||||
context.loaded_blocks = context.loaded_blocks + 1
|
||||
-- Erhöhung der Anzahl der geladenen Blöcke
|
||||
kontext.bloecke_insgesamt = kontext.geladene_bloecke + 1
|
||||
|
||||
-- Send progress message
|
||||
if context.total_blocks == context.loaded_blocks then
|
||||
minetest.chat_send_all("Finished loading blocks!")
|
||||
-- Fortschrittsmeldung senden
|
||||
if kontext.bloecke_insgesamt == kontext.geladene_bloecke then
|
||||
minetest.chat_send_all("Blöcke laden abgeschlossen!")
|
||||
end
|
||||
local perc = 100 * context.loaded_blocks / context.total_blocks
|
||||
local msg = string.format("Loading blocks %d/%d (%.2f%%)",
|
||||
context.loaded_blocks, context.total_blocks, perc)
|
||||
local perc = 100 * kontext.geladene_bloecke / kontext.bloecke_insgesamt
|
||||
local msg = string.format("Geladene Blöcke %d/%d (%.2f%%)",
|
||||
kontext.geladene_bloecke, kontext.bloecke_insgesamt, perc)
|
||||
minetest.chat_send_all(msg)
|
||||
end
|
||||
end
|
||||
```
|
||||
|
||||
This is not the only way of loading blocks; using an
|
||||
[Lua Voxel Manipulator (LVM)](../advmap/lvm.html) will also cause the
|
||||
encompassed blocks to be loaded synchronously.
|
||||
Dies ist nicht die einzige Möglichkeit, Mapblöcke zu laden; die Verwendung eines
|
||||
[Lua Voxel Manipulator (LVM)](../advmap/lvm.html) bewirkt ebenfalls, dass die
|
||||
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
|
||||
-- Delete a 20x20x20 area
|
||||
local halfsize = { x = 10, y = 10, z = 10 }
|
||||
local pos1 = vector.subtract(pos, halfsize)
|
||||
local pos2 = vector.add (pos, halfsize)
|
||||
-- Löscht einen 20x20x20-Bereich
|
||||
local halbegroesse = { x = 10, y = 10, z = 10 }
|
||||
local pos1 = vector.subtract(pos, halbegroesse)
|
||||
local pos2 = vector.add (pos, halbegroesse)
|
||||
|
||||
minetest.delete_area(pos1, pos2)
|
||||
```
|
||||
|
||||
This will delete all map blocks in that area, *inclusive*. This means that some
|
||||
nodes will be deleted outside the area as they will be on a mapblock which overlaps
|
||||
the area bounds.
|
||||
Dadurch werden alle Map-Blöcke in diesem Bereich *inklusive* gelöscht. Das bedeutet, dass einige
|
||||
Blöcke außerhalb des Bereichs gelöscht werden, da sie sich auf einem Map-Block befinden, der sich mit den
|
||||
die Bereichsgrenzen überlappen.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user