Finished translating callbacks.md
This commit is contained in:
debiankaios
parent
7016856ade
commit
63b316e81c
@ -3,14 +3,14 @@ title: Block und Item Callbacks
|
||||
layout: default
|
||||
root: ../..
|
||||
idx: 2.15
|
||||
description: Learn about callbacks, actions, and events, including on_use, on_punch, on_place, on_rightclick
|
||||
description: Erfahren sie über callbacks, Aktionen, und Ereignissen, einschließlich on_use, on_punch, on_place, on_rightclick
|
||||
---
|
||||
|
||||
## Einleitung <!-- omit in toc -->
|
||||
|
||||
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
|
||||
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.
|
||||
|
||||
@ -20,10 +20,10 @@ einen Knoten anstößt. Es gibt auch globale Callbacks wie
|
||||
- [on_drop](#on_drop)
|
||||
- [after_use](#after_use)
|
||||
- [item_place vs place_item](#item_place-vs-place_item)
|
||||
- [Node Callbacks](#node-callbacks)
|
||||
- [Right-clicking and placing a node](#right-clicking-and-placing-a-node)
|
||||
- [Punching and digging](#punching-and-digging)
|
||||
- [...and more!](#and-more)
|
||||
- [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
|
||||
@ -83,8 +83,6 @@ Beide Callbacks werden für alle Arten von Items aufgerufen. `on_place` ist stan
|
||||
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.
|
||||
|
||||
Übersetzt mit www.DeepL.com/Translator (kostenlose Version)
|
||||
|
||||
|
||||
### on_drop
|
||||
|
||||
@ -95,12 +93,12 @@ die Abwurftaste (Q) oder durch Ziehen außerhalb des Inventars. Es wird standard
|
||||
|
||||
### after_use
|
||||
|
||||
`after_use` is called when digging a node and allows you to customise how wear
|
||||
is applied to a tool. If after_use doesn't exist, then it is the same as:
|
||||
`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, user, node, digparams)
|
||||
itemstack:add_wear(digparams.wear)
|
||||
after_use = function(itemstack, benutzer, block, abbauparams)
|
||||
itemstack:add_wear(abbauparams.wear)
|
||||
return itemstack
|
||||
end
|
||||
```
|
||||
@ -108,99 +106,98 @@ end
|
||||
|
||||
## item_place vs place_item
|
||||
|
||||
Minetest's API includes many different built-in callback implementations for you
|
||||
to use. These callbacks are named with the item type first, for example,
|
||||
`minetest.item_place` and `minetest.node_dig`. Some callback implementations are
|
||||
used directly whereas some are functions that return the callback:
|
||||
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("mymod:example", {
|
||||
minetest.register_item("meinemod:beispiel", {
|
||||
on_place = minetest.item_place,
|
||||
on_use = minetest.item_eat(10),
|
||||
})
|
||||
```
|
||||
|
||||
Minetest's API also includes built-in functions that _do_ something. These are
|
||||
often named in a confusingly similar way to built-in callback implementations
|
||||
but have the verb first. Examples include `minetest.place_item` and
|
||||
`minetest.dig_node` - these functions allow you to dig and place nodes with a
|
||||
similar effect to players.
|
||||
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.
|
||||
|
||||
|
||||
## Node Callbacks
|
||||
## Block Callbacks
|
||||
|
||||
When a node is in an inventory, it uses Item Callbacks, as discussed above. When
|
||||
a node is placed in the world, it uses Node Callbacks. There are quite a lot of
|
||||
node callbacks, too many to discuss in this book. However, quite a few of them
|
||||
will be talked about later in the book.
|
||||
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.
|
||||
|
||||
Several of the callbacks are related to node operations such as placing and
|
||||
removing from the world. It's important to note that node operation callbacks
|
||||
like these aren't called from bulk changes - those that set a large number of
|
||||
nodes at once - for performance reasons. Therefore, you can't rely on these
|
||||
callbacks to always be called.
|
||||
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.
|
||||
|
||||
|
||||
### Right-clicking and placing a node
|
||||
### Rechtsklick und Platzieren eines Blockes
|
||||
|
||||
When the user right-clicks with an item whilst pointing at a node, the item's
|
||||
`on_place` callback is called. By default, this is set to `minetest.item_place`.
|
||||
If the pointed node has an `on_rightclick` callback and sneak (shift) is held,
|
||||
then the `on_rightclick` callback is called. Otherwise, `minetest.item_place`
|
||||
will place the node.
|
||||
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.
|
||||
|
||||
Placing a node will call both `on_construct` and `after_place_node`.
|
||||
`on_construct` is called by any node set event that wasn't in bulk and is just
|
||||
given the node's position and value .`after_place_node` is only called by node
|
||||
place, and so has more information - such as the placer and itemstack.
|
||||
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.
|
||||
|
||||
It's important to note that players aren't the only objects that can place
|
||||
nodes; it's common for mobs and mods to place nodes. To account for this,
|
||||
`placer` could be a player, entity, or nil.
|
||||
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("mymod:mynode", {
|
||||
on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
|
||||
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(), "Hello world!")
|
||||
minetest.chat_send_player(clicker:get_player_name(), "Hallo Welt!")
|
||||
end
|
||||
end,
|
||||
on_construct = function(pos, node)
|
||||
on_construct = function(pos, block)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("infotext", "My node!")
|
||||
meta:set_string("infotext", "Mein Block!")
|
||||
end,
|
||||
after_place_node = function(pos, placer, itemstack, pointed_thing)
|
||||
-- Make sure to check placer
|
||||
if placer and placer:is_player() then
|
||||
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("owner", placer:get_player_name())
|
||||
meta:set_string("besitzer", plazierer:get_player_name())
|
||||
end
|
||||
end,
|
||||
})
|
||||
```
|
||||
|
||||
### Punching and digging
|
||||
### Schlagen und abbauen
|
||||
|
||||
Punching is when the player left-clicks for a short period. If the wielded item
|
||||
has an `on_use` callback, this will be called. Otherwise, the `on_punch`
|
||||
callback on the pointed node will be called.
|
||||
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.
|
||||
|
||||
When the player attempts to dig a node, the `on_dig` callback on the node will be called.
|
||||
This defaults to `minetest.node_dig`, which will check for area protection, wear
|
||||
out the tool, remove the node, and run the `after_dig_node` callback.
|
||||
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("mymod:mynode", {
|
||||
on_punch = function(pos, node, puncher, pointed_thing)
|
||||
if puncher:is_player() then
|
||||
minetest.chat_send_player(clicker:get_player_name(), "Ow!")
|
||||
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,
|
||||
})
|
||||
```
|
||||
|
||||
### ...and more!
|
||||
### ...und mehr!
|
||||
|
||||
Check out Minetest's Lua API reference for a list of all node callbacks, and
|
||||
more information on the callbacks above.
|
||||
In der Lua-API-Referenz von Minetest finden Sie eine Liste aller Node-Callbacks und
|
||||
weitere Informationen zu den oben genannten Rückrufen.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user