From 2b949d68f70dd5b9c55eca0df947206d1415f824 Mon Sep 17 00:00:00 2001 From: debiankaios Date: Fri, 19 Aug 2022 13:26:42 +0200 Subject: [PATCH] Finished enviroment.md --- _de/map/environment.md | 175 ++++++++++++++++++++--------------------- 1 file changed, 87 insertions(+), 88 deletions(-) diff --git a/_de/map/environment.md b/_de/map/environment.md index 4a84c0f..5cd559d 100644 --- a/_de/map/environment.md +++ b/_de/map/environment.md @@ -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 @@ -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.