From 80319c51e5979a44f04ea9cd737e3403f25f77b6 Mon Sep 17 00:00:00 2001 From: debiankaios Date: Thu, 18 Aug 2022 17:58:38 +0200 Subject: [PATCH] =?UTF-8?q?Begann=20environment.md=20and=20revised=20w?= =?UTF-8?q?=C3=B6rterbuch.txt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- _de/items/inventories.md | 6 +- _de/items/nodes_items_crafting.md | 2 +- _de/map/environment.md | 233 ++++++++++++++++++++++++++++++ _de/wörterbuch.txt | 16 +- 4 files changed, 252 insertions(+), 5 deletions(-) create mode 100644 _de/map/environment.md diff --git a/_de/items/inventories.md b/_de/items/inventories.md index d3e0288..7676e14 100644 --- a/_de/items/inventories.md +++ b/_de/items/inventories.md @@ -13,8 +13,8 @@ redirect_from: ## Einleitung -In diesem Kapitel werden Sie lernen, wie man Inventare verwendet und manipuliert, egal ob -ob es sich um ein Spielerinventar, ein Knoteninventar oder ein freistehendes Inventar handelt. +In diesem Kapitel werden Sie lernen, wie man Inventare verwendet und manipuliert, egal +ob es sich um ein Spielerinventar, ein Blockinventar oder ein freistehendes Inventar handelt. - [Was sind ItemStacks und Inventare?](#was-sind-itemstacks-und-inventare) - [ItemStacks](#itemstacks) @@ -25,7 +25,7 @@ ob es sich um ein Spielerinventar, ein Knoteninventar oder ein freistehendes Inv - [Ändern von Inventaren und ItemStacks](#ändern-von-inventaren-und-itemstacks) - [Zu einer Liste hinzufügen](#zu-einer-liste-hinzufügen) - [Items nehmen](#items-nehmen) - - [Stacks manipulieren](stacks-manipulieren) + - [Stacks manipulieren](#stacks-manipulieren) - [Abnutzung](#abnutzung) - [Lua Tabellen](#lua-tabellen) diff --git a/_de/items/nodes_items_crafting.md b/_de/items/nodes_items_crafting.md index 6bf0f7a..b483406 100644 --- a/_de/items/nodes_items_crafting.md +++ b/_de/items/nodes_items_crafting.md @@ -1,4 +1,4 @@ ---- + --- title: Blöcke, Items und Craften layout: default root: ../.. diff --git a/_de/map/environment.md b/_de/map/environment.md new file mode 100644 index 0000000..4a84c0f --- /dev/null +++ b/_de/map/environment.md @@ -0,0 +1,233 @@ +--- +title: Grundlegende Kartenoperationen +layout: default +root: ../.. +idx: 3.1 +description: Grundlegende Operationen wie set_node und get_node +redirect_from: /en/chapters/environment.html +--- + +## Einleitung + +In diesem Kapitel erfahren Sie, wie Sie grundlegende Aktionen auf der Karte durchführen können. + +- [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) + +## Karten Struktur + +Die Minetest-Karte ist in Map-Blöcke(nicht zu verwechseln mit Blöcken in deutschen) aufgeteilt, wobei jeder Map-Block ein Würfel der +Kantenlänge 16 ist. Während die Spieler auf der Karte unterwegs sind, werden Map-Blöcke erstellt, geladen, +aktiv und entladen. Bereiche der Karte, die noch nicht geladen sind, sind voll von +*ignore*-Blöcken, einem unpassierbaren, nicht auswählbaren Platzhalterblock. Leerer Raum ist +voll von *Luft*-Blöcken, einem unsichtbaren Block, durch den man hindurchgehen kann. + +Ein aktiver Map-Block ist ein Block, der geladen ist und für den Aktualisierungen durchgeführt werden. + +Geladene Map-Blöcke werden oft als *aktive Blöcke* bezeichnet. Aktive Blöcke können +von Mods oder Spielern gelesen oder beschrieben werden und haben aktive Entities. Die Engine +führt auch Operationen auf der Karte durch, wie z. B. die Ausführung der Flüssigkeitsphysik. + +Map-Blöcke können entweder aus der Weltdatenbank geladen oder generiert werden. Map-Blöcke +werden bis zum Limit der Kartengenerierung (`mapgen_limit`) generiert, das +standardmäßig auf den Maximalwert von 31000 gesetzt ist. Vorhandene Map-Blöcke können jedoch +außerhalb des Generierungslimits aus der Weltdatenbank geladen werden. + +## Lesen + +### Blöcke lesen + +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 +print(dump(node)) --> { name=.., param1=.., param2=.. } +``` + +Handelt es sich bei der Position um eine Dezimalzahl, so wird sie auf den enthaltenen Knoten gerundet. +Die Funktion gibt immer eine Tabelle mit den Blockinformationen zurück: + +* `name` - Der Knotenname, der beim Entladen des Bereichs *ignoriert* wird. +* `param1` - Siehe Block-Definition. Dieser ist in der Regel light. +* `param2` - Siehe Block-Definition. + +Es ist erwähnenswert, dass die Funktion den enthaltenen Block nicht lädt, wenn der Block +inaktiv ist, sondern stattdessen eine Tabelle zurückgibt, in der `name` `ignore` ist. + +Sie können stattdessen `minetest.get_node_or_nil` verwenden, was `nil` zurückgibt +und nicht eine Tabelle mit dem Namen `ignore`. Allerdings wird der Block dann immer noch nicht geladen. +Dies kann immer noch `ignore` zurückgeben, wenn ein Block tatsächlich ignore enthält. +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 + +Minetest offers a number of helper functions to speed up common map actions. +The most commonly used of these are for finding nodes. + +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: + +```lua +local grow_speed = 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 +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: + +```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 +``` + +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: + +```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 +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 + end +end +``` + +Now the code will correctly increase `grow_speed` based on mese nodes in range. + +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. + +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. + +## Writing + +### Writing Nodes + +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. + +```lua +minetest.set_node({ x = 1, y = 3, z = 4 }, { name = "default:mese" }) + +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. + +You can set a node without deleting metadata or the inventory like so: + +```lua +minetest.swap_node({ x = 1, y = 3, z = 4 }, { name = "default:mese" }) +``` + +### Removing Nodes + +A node must always be present. To remove a node, you set the position to `air`. + +The following two lines will both remove a node, and are both identical: + +```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"`. + +## Loading Blocks + +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. + +```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) + +local context = {} -- persist data between callback calls +minetest.emerge_area(pos1, pos2, emerge_callback, context) +``` + +Minetest will call `emerge_callback` whenever it loads a block, with some +progress information. + +```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 + end + + -- Increment number of blocks loaded + context.loaded_blocks = context.loaded_blocks + 1 + + -- Send progress message + if context.total_blocks == context.loaded_blocks then + minetest.chat_send_all("Finished loading blocks!") + 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) + 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. + +## Deleting Blocks + +You can use delete_blocks to delete a range of map blocks: + +```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) + +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. diff --git a/_de/wörterbuch.txt b/_de/wörterbuch.txt index 5a3aeeb..2eac9e1 100644 --- a/_de/wörterbuch.txt +++ b/_de/wörterbuch.txt @@ -1,16 +1,26 @@ +Active Block Modifiers = Aktive Mapblock Modifikatoren +block = Mapblock +bulk = bulk Chapter = Kapitel Cubic Nodes = Würfelförmiger Block +craft slots = Handwerksplätze detached inventory = freistehendes Inventar dig = abbauen drawtype = Zeichnungstyp +Entities = Entities Folder = Verzeichnis -glasslike = Glasartig games = Spiele +glasslike = Glasartig +grid = Raster Introduction = Einleitung Inventory = Inventar +Inventory List = Inventarliste Inventory Location = Inventarstandort Inventory reference = Inventar-Referenz ItemStack = ItemStack +main inventory = Hauptinventar +map = Karte +MapBlock = Map-Block Mesh = Mesh Mesh Nodes = Mesh Nodes mod load paths = Mod-Lade-Verzeichnisse @@ -22,11 +32,15 @@ nodes = Blöcke nodebox = Nodebox nodeboxes = Nodeboxen Node inventory = Blockinventar +node timer = Blocktimer path = Verzeichnis placer = plazierer player inventory = Spielerinventar player reference = Spielerreferenz pointed_thing = angeschautes_ding Stack = Stack +table = Tabelle tile = Kachel tiles = Kacheln +timer = timer +wear = Abnutzung