--- title: Block und Item Callbacks layout: default root: ../.. idx: 2.15 description: Erfahren sie über callbacks, Aktionen, und Ereignissen, einschließlich on_use, on_punch, on_place, on_rightclick --- ## Einleitung Minetest verwendet hauptsächlich ein Callback-basiertes Modding-Design. Ein Rückruf ist eine Funktion die Sie an eine API übergeben und die aufgerufen wird, wenn ein Ereignis eintritt. Zum Beispiel können Sie eine Funktion `on_punch` in einer Node-Definition angeben, die aufgerufen wird, wenn ein Spieler einen Knoten anstößt. Es gibt auch globale Callbacks wie `minetest.register_on_punchnode`, um Ereignisse für alle Knoten zu empfangen. - [Item Callbacks](#item-callbacks) - [on_use](#on_use) - [on_place und on_secondary_use](#on_place-und-on_secondary_use) - [on_drop](#on_drop) - [after_use](#after_use) - [item_place vs place_item](#item_place-vs-place_item) - [Block Callbacks](#block-callbacks) - [Rechtsklick und Platzieren eines Blockes](#rechtsklick-und-platzieren-eines blockes) - [Schlagen und abbauen](#schlagen-und-abbauen) - [...und mehr!](#und-mehr) ## Item Callbacks Wenn ein Spieler einen Block, einen Handwerksgegenstand oder ein Werkzeug in seinem Inventar hat, kann er folgende Ereignisse auslösen bestimmte Ereignisse: | Callback | Standard-Bindung | Standard Wert | |------------------|-------------------------------|----------------------------------------------| | on_use | links-click | nil | | on_place | rechts-click auf einen Block | `minetest.item_place` | | on_secondary_use | rechts-click auf keinen Block | `minetest.item_secondary_use` (does nothing) | | on_drop | Q | `minetest.item_drop` | | after_use | Abbauen eines Blockes | nil | ### on_use Mit einem Verwendungsrückruf wird verhindert, dass das Item zum abbauen von Blöcken verwendet wird. Eine häufige Verwendung des Verwendungsrückrufs ist für Lebensmittel: ```lua minetest.register_craftitem("meinemod:matschekuchen", { description = "Alien Matschekuchen", inventory_image = "meinessen_matschekuchen.png", on_use = minetest.item_eat(20), }) ``` Die Zahl, die an die Funktion minetest.item_eat übergeben wird, ist die Anzahl der Hitpoints, Punkte, die durch den Verzehr dieser Nahrung geheilt werden. Jedes Herzsymbol, das der Spieler hat, ist zwei Hitpoints wert. Ein Spieler kann in der Regel bis zu 10 Herzen haben, was gleichbedeutend ist mit 20 Hitpoints. minetest.item_eat() ist eine Funktion, die eine Funktion zurückgibt und diese als on_use-Rückruf. Das bedeutet, dass der obige Code dem hier entspricht: ```lua minetest.register_craftitem("meinemod:matschekuchen", { description = "Alien Matschekuchen", inventory_image = "meinessen_matschekuchen.png", on_use = function(...) return minetest.do_item_eat(20, nil, ...) end, }) ``` Wenn man versteht, wie item_eat funktioniert, indem es einfach eine Funktion zurückgibt, ist es möglich, die Funktion so zu ändern, dass sie ein komplexeres Verhalten wie das Abspielen eines benutzerdefinierten Sounds ermöglicht. ### on_place und on_secondary_use Der Unterschied zwischen `on_place` und `on_secondary_use` ist, dass `on_place` aufgerufen wird, wenn der Spieler auf einen Knoten zeigt und `on_secondary_use`, wenn der Spieler dies nicht tut. Beide Callbacks werden für alle Arten von Items aufgerufen. `on_place` ist standardmäßig auf die Funktion `minetest.item_place`, die den Aufruf des `on_rightclick` Callback des angezeigten Knotens aufruft oder den geschwungenen Gegenstand platziert, wenn es ein Knoten ist. ### on_drop on_drop wird aufgerufen, wenn der Spieler einen Gegenstand fallen lassen will, zum Beispiel mit die Abwurftaste (Q) oder durch Ziehen außerhalb des Inventars. Es wird standardmäßig die Funktion `minetest.item_drop`, die das Fallenlassen des Gegenstandes übernimmt. ### after_use `after_use` wird beim abbauen eines Blockes aufgerufen und ermöglicht es Ihnen, dass die Art der Abnutzung auf ein Werkzeug angewendet wird. Wenn after_use nicht existiert, dann ist es das gleiche wie: ```lua after_use = function(itemstack, benutzer, block, abbauparams) itemstack:add_wear(abbauparams.wear) return itemstack end ``` ## item_place vs place_item Die API von Minetest enthält viele verschiedene integrierte Callback-Implementierungen, zur Benutzung von ihnen. Diese Rückrufe werden mit dem Elementtyp zuerst benannt, zum Beispiel, `minetest.item_place` und `minetest.node_dig`. Einige Callback-Implementierungen werden direkt verwendet, während einige Funktionen sind, die den Rückruf zurückgeben: ```lua minetest.register_item("meinemod:beispiel", { on_place = minetest.item_place, on_use = minetest.item_eat(10), }) ``` Die API von Minetest enthält auch eingebaute Funktionen, die etwas _tun_. Diese sind oft verwirrend ähnlich benannt wie die eingebauten Callback-Implementierungen haben aber das Verb vorangestellt. Beispiele sind `minetest.place_item` und `minetest.dig_node` - diese Funktionen ermöglichen das abbauen und Platzieren von Blöcken mit einem ähnlichen Effekt wie Spieler. ## Block Callbacks Wenn sich ein Block in einem Inventar befindet, verwendet er, wie oben beschrieben, Item Callbacks. Wenn ein Knoten in der Welt platziert ist, verwendet er Block Callbacks. Es gibt eine ganze Menge von Block Callbacks, zu viele, um sie in diesem Buch zu besprechen. Allerdings werden einige von ihnen später in diesem Buch besprochen. Einige der Rückrufe beziehen sich auf Blockoperationen wie das Platzieren und Entfernen aus der Welt. Es ist wichtig zu beachten, dass Blockoperationen-Callbacks wie diese nicht von bulk changes aufgerufen werden - also solchen, die eine große Anzahl von Blöcken auf einmal setzen - aus Leistungsgründen nicht aufgerufen werden. Daher kann man sich nicht darauf verlassen, dass diese Rückrufe immer aufgerufen werden. ### Rechtsklick und Platzieren eines Blockes Wenn der Benutzer mit der rechten Maustaste auf ein Element klickt, während er auf einen Block zeigt, wird der Callback des Elements `on_place`-Callback aufgerufen. Standardmäßig ist dieser auf `minetest.item_place` gesetzt. Wenn der gezeigte Knoten einen `on_rightclick` Callback hat und sneak (shift) gehalten wird, dann wird der `on_rightclick` Callback aufgerufen. Andernfalls wird `minetest.item_place` den Knoten platzieren. Das Platzieren eines Blockes ruft sowohl `on_construct` als auch `after_place_node` auf. `on_construct` wird von jedem Block-Plazier-Ereignis aufgerufen, das nicht in Bulk war und wird nur die Position und den Wert des Blockes gegeben. `after_place_node` wird nur von node place aufgerufen und hat daher mehr Informationen - wie den Placer und den Itemstack. Es ist wichtig zu wissen, dass Spieler nicht die einzigen Objekte sind, die Blöcke platzieren können; es ist üblich, dass auch Mobs und Mods Blöcke platzieren können. Um dies zu berücksichtigen, `Placer` kann ein Spieler, eine Entity oder nil sein. ```lua minetest.register_node("meinemod:meinblock", { on_rightclick = function(pos, block, clicker, itemstack, angeschautes_ding) if clicker:is_player() then minetest.chat_send_player(clicker:get_player_name(), "Hallo Welt!") end end, on_construct = function(pos, block) local meta = minetest.get_meta(pos) meta:set_string("infotext", "Mein Block!") end, after_place_node = function(pos, plazierer, itemstack, angeschautes_ding) -- Stellen Sie sicher, dass Sie den Plazierer überprüfen if plazierer and plazierer:is_player() then local meta = minetest.get_meta(pos) meta:set_string("besitzer", plazierer:get_player_name()) end end, }) ``` ### Schlagen und abbauen Schlagen bedeutet, dass der Spieler kurz mit der linken Maustaste klickt. Wenn der benutze Gegenstand einen `on_use` Callback hat, wird dieser aufgerufen. Andernfalls wird der `on_punch` Callback auf dem angezeigten Block aufgerufen. Wenn der Spieler versucht, einen Block abzubauen, wird der `on_dig` Callback auf dem Knoten aufgerufen. Dieser ist standardmäßig auf `minetest.node_dig` eingestellt, der den Gebietsschutz prüft, das das Werkzeug verschleißt, den Block entfernt und den `after_dig_node` Callback ausführt. ```lua minetest.register_node("meinemod:meinblock", { on_punch = function(pos, block, schlaeger, angeschautes_ding) -- ä wird außer in strings und Kommentaren zu ae if schlaeger:is_player() then minetest.chat_send_player(clicker:get_player_name(), "Au!") end end, }) ``` ### ...und mehr! In der Lua-API-Referenz von Minetest finden Sie eine Liste aller Node-Callbacks und weitere Informationen zu den oben genannten Rückrufen.