From 02ab233debfa000d625d4f99ffbfc07feb692b8b Mon Sep 17 00:00:00 2001 From: debiankaios Date: Tue, 16 Aug 2022 13:34:53 +0200 Subject: [PATCH] Finished inventories.md --- _de/items/inventories.md | 174 +++++++++++++++++++-------------------- 1 file changed, 86 insertions(+), 88 deletions(-) diff --git a/_de/items/inventories.md b/_de/items/inventories.md index 2971378..d3e0288 100644 --- a/_de/items/inventories.md +++ b/_de/items/inventories.md @@ -19,15 +19,15 @@ ob es sich um ein Spielerinventar, ein Knoteninventar oder ein freistehendes Inv - [Was sind ItemStacks und Inventare?](#was-sind-itemstacks-und-inventare) - [ItemStacks](#itemstacks) - [Inventarstandorte](#inventarstandorte) -- [Lists](#lists) - - [Size and Width](#size-and-width) - - [Checking Contents](#checking-contents) -- [Modifying Inventories and ItemStacks](#modifying-inventories-and-itemstacks) - - [Adding to a List](#adding-to-a-list) - - [Taking Items](#taking-items) - - [Manipulating Stacks](#manipulating-stacks) -- [Wear](#wear) -- [Lua Tables](#lua-tables) +- [Listen](#listen) + - [Größe und Breite](#größe-und-breite) + - [Inhalt überprüfen](#inhalt-überprüfen) +- [Ä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) +- [Abnutzung](#abnutzung) +- [Lua Tabellen](#lua-tabellen) ## Was sind ItemStacks und Inventare? @@ -173,173 +173,171 @@ der zu übertragenden Items zurück, wobei 0 verwendet wird, um die Übertragung Im Gegensatz dazu haben Aktionsrückrufe - beginnend mit `on_` - keinen Rückgabewert. -## Lists +## Listen -Inventory Lists are a concept used to allow multiple grids to be stored inside a single location. -This is especially useful for the player as there are a number of common lists -which all games have, such as the *main* inventory and *craft* slots. +Inventarlisten sind ein Konzept, das es ermöglicht, mehrere Raster an einem einzigen Ort zu speichern. +Dies ist besonders nützlich für den Spieler, da es eine Reihe von allgemeinen Listen +gibt die alle Spiele haben, wie das *Hauptinventar* und die *Handwerksplätze*. -### Size and Width +### Größe und Breite -Lists have a size, which is the total number of cells in the grid, and a width, -which is only used within the engine. -The width of the list is not used when drawing the inventory in a window, -because the code behind the window determines the width to use. +Listen haben eine Größe, die die Gesamtzahl der Zellen im Raster angibt, und eine +Breite, die nur innerhalb der Engine verwendet wird. +Die Breite der Liste wird beim Zeichnen des Inventars in einem Fenster nicht verwendet, denn der Code hinter dem Fenster bestimmt die zu verwendende Breite. ```lua if inv:set_size("main", 32) then inv:set_width("main", 8) - print("size: " .. inv:get_size("main")) - print("width: " .. inv:get_width("main")) + print("Größe: " .. inv:get_size("main")) + print("Breite: " .. inv:get_width("main")) else - print("Error! Invalid itemname or size to set_size()") + print("Fehler! Ungültiger itemname oder ungültige Größe für set_size()") end ``` -`set_size` will fail and return false if the listname or size is invalid. -For example, the new size may be too small to fit all the current items -in the inventory. +`set_size` wird fehlschlagen und false zurückgeben, wenn der Listenname oder die Größe ungültig ist. +Zum Beispiel kann die neue Größe zu klein sein, damit alle aktuellen Gegenstände +im Inventar zu passen. -### Checking Contents +### Inhalt überprüfen -`is_empty` can be used to see if a list contains any items: +`is_empty` kann benutzt werden, um zu sehen, ob eine Liste Items enthält: ```lua if inv:is_empty("main") then - print("The list is empty!") + print("Die Liste ist leer!") end ``` -`contains_item` can be used to see if a list contains a specific item: +`contains_item` kann verwendet werden, um festzustellen, ob eine Liste ein bestimmtes Item enthält: ```lua if inv:contains_item("main", "default:stone") then - print("I've found some stone!") + print("Ich habe ein paar Steine gefunden!") end ``` -## Modifying Inventories and ItemStacks +## Ändern von Inventaren und ItemStacks -### Adding to a List +### Zu einer Liste hinzufügen -`add_item` adds items to a list (in this case `"main"`). In the example below, -the maximum stack size is also respected: +`add_item` fügt Items zu einer Liste hinzu (in diesem Fall `"main"`). Im folgenden +Beispiel, wird auch die maximale Stapelgröße beachtet: ```lua local stack = ItemStack("default:stone 99") -local leftover = inv:add_item("main", stack) -if leftover:get_count() > 0 then - print("Inventory is full! " .. - leftover:get_count() .. " items weren't added") +local reste = inv:add_item("main", stack) +if reste:get_count() > 0 then + print("Inventar ist voll! " .. + reste:get_count() .. " Items wurden nicht hinzugefügt") end ``` -### Taking Items +### Items nehmen -To remove items from a list: +Um Items von einer Liste zu löschen: ```lua -local taken = inv:remove_item("main", stack) -print("Took " .. taken:get_count()) +local genommen = inv:remove_item("main", stack) +print("Nahm " .. genommen:get_count()) ``` -### Manipulating Stacks +### Stacks manipulieren -You can modify individual stacks by first getting them: +Sie können einzelne Stacks ändern, indem Sie sie zuerst erhalten: ```lua -local stack = inv:get_stack(listname, 0) +local stack = inv:get_stack(listenname, 0) ``` -Then modifying them by setting properties or by using the methods which -respect `stack_size`: +Dann ändern Sie sie durch das Setzen von Eigenschaften oder durch die Verwendung von +Methoden, welche die `stack_size` respektieren: ```lua -local stack = ItemStack("default:stone 50") -local to_add = ItemStack("default:stone 100") -local leftover = stack:add_item(to_add) -local taken = stack:take_item(19) +local stack = ItemStack("default:stone 50") +local zum_hinzufuegen = ItemStack("default:stone 100") +local reste = stack:add_item(to_add) +local genommen = stack:take_item(19) -print("Could not add" .. leftover:get_count() .. " of the items.") --- ^ will be 51 +print("Konnte nicht" .. reste:get_count() .. " der items hinzufügen.") +-- ^ wird 51 seind -print("Have " .. stack:get_count() .. " items") --- ^ will be 80 +print("Habe " .. stack:get_count() .. " items") +-- ^ wird 80 sein -- min(50+100, stack_max) - 19 = 80 --- where stack_max = 99 +-- wobei stack_max = 99 ``` -`add_item` will add items to an ItemStack and return any that could not be added. -`take_item` will take up to the number of items but may take less, and returns the stack taken. +`add_item` fügt Items zu einem ItemStack hinzu und gibt alle zurück, die nicht hinzugefügt werden konnten. +`take_item` nimmt bis zu der Anzahl der Items, kann aber auch weniger nehmen, und gibt den genommenen Stack zurück. -Finally, set the item stack: +Legen Sie schließlich den ItemStack fest: ```lua -inv:set_stack(listname, 0, stack) +inv:set_stack(listenname, 0, stack) ``` -## Wear +## Abnutzung -Tools can have wear; wear shows a progress bar and makes the tool break when completely worn. -Wear is a number out of 65535; the higher it is, the more worn the tool is. +Werkzeuge können abgenutzt sein; die Abnutzung wird in einem Fortschrittsbalken angezeigt und führt zum Abbruch des Werkzeugs, wenn es vollständig abgenutzt ist. +Die Abnutzung ist eine Zahl bis 65535; je höher sie ist, desto mehr ist das Werkzeug abgenutzt. -Wear can be manipulated using `add_wear()`, `get_wear()`, and `set_wear(wear)`. +Die Abnutzung kann mit `add_wear()`, `get_wear()` und `set_wear(wear)` beeinflusst werden. ```lua local stack = ItemStack("default:pick_mese") -local max_uses = 10 +local max_nutzungen = 10 --- This is done automatically when you use a tool that digs things --- It increases the wear of an item by one use. -stack:add_wear(65535 / (max_uses - 1)) +-- Dies geschieht automatisch, wenn Sie ein Werkzeug verwenden, das Dinge abbaut +-- Sie erhöht die Abnutzung eines Gegenstandes um einen Einsatz. +stack:add_wear(65535 / (max_nutzungen - 1)) ``` -When digging a node, the amount of wear a tool gets may depend on the node -being dug. So max_uses varies depending on what is being dug. +Beim abbauen eines Blockes kann die Abnutzung des Werkzeugs von dem Block abhängen +der gegraben wird. Daher variiert max_nutzungen je nachdem, was gegraben wird. -## Lua Tables +## Lua Tabellen -ItemStacks and Inventories can be converted to and from tables. -This is useful for copying and bulk operations. +ItemStacks und Inventare können in und aus Tabellen konvertiert werden. +Dies ist nützlich für Kopier- und Bulk-Operationen. ```lua --- Entire inventory -local data = inv1:get_lists() -inv2:set_lists(data) +-- Gesamtes Inventar +local daten = inv1:get_lists() +inv2:set_lists(daten) --- One list -local listdata = inv1:get_list("main") -inv2:set_list("main", listdata) +-- Eine Liste +local listendaten = inv1:get_list("main") +inv2:set_list("main", listendaten) ``` -The table of lists returned by `get_lists()` will be in this form: +Die Tabelle der Listen, die von `get_lists()` zurückgegeben wird, wird in dieser Form vorliegen: ```lua { - list_one = { + liste_eins = { ItemStack, ItemStack, ItemStack, ItemStack, - -- inv:get_size("list_one") elements + -- inv:get_size("liste_eins") Elemente }, - list_two = { + liste_zwei = { ItemStack, ItemStack, ItemStack, ItemStack, - -- inv:get_size("list_two") elements + -- inv:get_size("liste_zwei") Elemente } } ``` -`get_list()` will return a single list as just a list of ItemStacks. +`get_list()` gibt eine einzelne Liste zurück, die lediglich eine Liste von ItemStacks ist. -One important thing to note is that the set methods above don't change the size -of the lists. -This means that you can clear a list by setting it to an empty table and it won't -decrease in size: +Ein wichtiger Punkt ist, dass die obigen Set-Methoden die Größe der Listen nicht verändern. +Das bedeutet, dass Sie eine Liste löschen können, indem Sie sie auf eine leere Tabelle setzen, und sie wird nicht +verkleinert: ```lua inv:set_list("main", {})