MTSR/minetest_modding_book
4
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

IT | translate callbacks chapter

Browse Source
This commit is contained in:
Zughy 2023-04-19 23:28:13 +02:00
parent 69bb5c1a0d
commit b9a3015124
2 changed files with 78 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
_it/items/callbacks.md
View File

@ -8,95 +8,86 @@ description: Learn about callbacks, actions, and events, including on_use, on_pu
## Introduction <!-- omit in toc --> ## Introduction <!-- omit in toc -->
Minetest heavily uses a callback-based modding design. A callback is a function Minetest usa una struttura di moddaggio estensivamente incentrata sui richiami. Un richiamo è una funzione che si dà a un'API e che viene chiamata quando l'evento registrato si verifica.
that you give to an API and is called when an event happens. For example, you Per esempio, puoi aggiungere una funzione `on_punch` nella definizione di un nodo, che verrà chiamata quando questo viene colpito.
can provide an `on_punch` function in a node definition to be called when a player Ci sono poi anche dei richiami globali, come `minetest.register_on_punchnode`, che in questo caso verrà invocato al colpire qualsiasi nodo.
punches a node. There are also global callbacks like
`minetest.register_on_punchnode` to receive events for all nodes.
- [Item Callbacks](#item-callbacks) - [Richiami degli oggetti](#richiami-degli-oggetti)
- [on_use](#on_use) - [on_use](#on_use)
- [on_place and on_secondary_use](#on_place-and-on_secondary_use) - [on_place e on_secondary_use](#on_place-e-on_secondary_use)
- [on_drop](#on_drop) - [on_drop](#on_drop)
- [after_use](#after_use) - [after_use](#after_use)
- [item_place vs place_item](#item_place-vs-place_item) - [item_place contro place_item](#item_place-contro-place_item)
- [Node Callbacks](#node-callbacks) - [Richiami dei nodi](#richiami-dei-nodi)
- [Right-clicking and placing a node](#right-clicking-and-placing-a-node) - [Tasto destro e nodi piazzati](#tasto-destro-e-nodi-piazzati)
- [Punching and digging](#punching-and-digging) - [Colpire e scavare](#colpire-e-scavare)
- [...and more!](#and-more) - [...e altro!](#e-altro)
## Item Callbacks ## Richiami degli oggetti
When a player has a node, craftitem, or tool in their inventory, they may trigger Quando un giocatore ha un nodo, un oggetto fabbricabile o uno strumento nel proprio inventario, questi potrebbero innescare degli eventi:
certain events:
| Callback | Default binding | Default value | | Richiamo | Assegnazione base | Valore base |
|------------------|---------------------------|----------------------------------------------| |------------------|---------------------------|----------------------------------------------|
| on_use | left-click | nil | | on_use | clic sinistro | nil |
| on_place | right-click on a node | `minetest.item_place` | | on_place | clic destro su un nodo | `minetest.item_place` |
| on_secondary_use | right-click not on a node | `minetest.item_secondary_use` (does nothing) | | on_secondary_use | clic destro a vuoto | `minetest.item_secondary_use` (non fa nulla) |
| on_drop | Q | `minetest.item_drop` | | on_drop | Q | `minetest.item_drop` |
| after_use | digging a node | nil | | after_use | allo scavare un nodo | nil |
### on_use ### on_use
Having a use callback prevents the item from being used to dig nodes. One common Sovrascrivere l'uso dell'oggetto impedisce che quest'ultimo possa essere usato per scavare nodi.
use of the use callback is for food: Un impiego comune di questo richiamo lo si trova nel cibo:
```lua ```lua
minetest.register_craftitem("mymod:mudpie", { minetest.register_craftitem("miamod:fangotorta", {
description = "Alien Mud Pie", description = "Torta aliena di fango",
inventory_image = "myfood_mudpie.png", inventory_image = "miamod_fangotorta.png",
on_use = minetest.item_eat(20), on_use = minetest.item_eat(20),
}) })
``` ```
The number supplied to the minetest.item_eat function is the number of hit Il numero fornito alla funzione minetest.item_eat è il numero di punti salute ripristinati al consumare il cibo.
points healed when this food is consumed. Each heart icon the player has is In gioco ogni cuore equivale a due punti.
worth two hitpoints. A player can usually have up to 10 hearts, which is equal Un giocatore ha solitamente un massimo di 10 cuori, ovvero 20 punti salute, e quest'ultimi non devono per forza essere interi - bensì anche decimali.
to 20 hitpoints.
minetest.item_eat() is a function that returns a function, setting it as the `minetest.item_eat()` è una funzione che ritorna un'altra funzione, in questo caso quindi impostandola come richiamo di on_use.
on_use callback. This means the code above is equivalent to this: Ciò significa che il codice in alto è alquanto simile al seguente:
```lua ```lua
minetest.register_craftitem("mymod:mudpie", { minetest.register_craftitem("miamod:fangotorta", {
description = "Alien Mud Pie", description = "Torta aliena di fango",
inventory_image = "myfood_mudpie.png", inventory_image = "miamod_fangotorta.png",
on_use = function(...) on_use = function(...)
return minetest.do_item_eat(20, nil, ...) return minetest.do_item_eat(20, nil, ...)
end, end,
}) })
``` ```
By understanding how item_eat works by simply returning a function, it's Capendo come funziona item_eat, è possibile modificarlo per operazioni più complesse
possible to modify it to do more complex behaviour like playing a custom sound. come per esempio riprodurre un suono personalizzato.
### on_place and on_secondary_use ### on_place e on_secondary_use
The difference between `on_place` and `on_secondary_use` is that `on_place` is La differenza tra `on_place` e `on_secondary_use` consiste nel fatto che `on_place` viene chiamato quando il giocatore sta puntando un nodo, mentre `on_secondary_use` quando non ne punta uno.
called when the player is pointing at a node and `on_secondary_use` when the
player isn't.
Both callbacks are called for all types of items. `on_place` defaults to the Entrambi i richiami sono invocati per tutti i tipi di oggetti.
`minetest.item_place` function, which handles calling the `on_rightclick` `on_place` risponde alla funzione `minetest.item_place`, la quale o gestisce la chiamata a `on_rightclick` del nodo puntato, o piazza l'oggetto in mano se questo è un nodo.
callback of the pointed node or placing the wielded item if it is a node.
### on_drop ### on_drop
on_drop is called when the player requests to drop an item, for example using `on_drop` viene chiamato quando il giocatore fa richiesta per buttare un oggetto, per esempio usando il tasto apposito (Q) o trascinando l'oggetto fuori dall'inventario.
the drop key (Q) or dragging it outside of the inventory. It defaults to the Risponde alla funzione `minetest.item_drop`, la quale gestisce il buttare l'oggetto.
`minetest.item_drop` function, which will handle dropping the item.
### after_use ### after_use
`after_use` is called when digging a node and allows you to customise how wear `after_use` viene chiamato quando si scava un nodo, e permette di personalizzare come viene applicata l'usura a uno strumento.
is applied to a tool. If after_use doesn't exist, then it is the same as: Se `after_use` non esiste, è come se ci fosse scritto:
```lua ```lua
after_use = function(itemstack, user, node, digparams) after_use = function(itemstack, user, node, digparams)
@ -106,101 +97,88 @@ end
``` ```
## item_place vs place_item ## item_place contro place_item
Minetest's API includes many different built-in callback implementations for you L'API di Minetest include varie implementazioni già pronte di richiami.
to use. These callbacks are named with the item type first, for example, Queste seguono la nomenclatura "tipodioggetto_azione", per esempio `minetest.item_place` e `minetest.node_dig`.
`minetest.item_place` and `minetest.node_dig`. Some callback implementations are Alcune sono usate direttamente, mentre altre sono funzioni che ritornano il richiamo vero e proprio:
used directly whereas some are functions that return the callback:
```lua ```lua
minetest.register_item("mymod:example", { minetest.register_item("miamod:esempio", {
on_place = minetest.item_place, on_place = minetest.item_place,
on_use = minetest.item_eat(10), on_use = minetest.item_eat(10),
}) })
``` ```
Minetest's API also includes built-in functions that _do_ something. These are Inoltre, l'API di Minetest include funzioni già pronte che _fanno_ qualcosa.
often named in a confusingly similar way to built-in callback implementations Queste sono spesso chiamate con nomi che rischiano di farle confondere con le implementazioni dei richiami, tuttavia hanno un verbo all'inizio (per esempio `minetest.place_item` e `minetest.dig_node`, che permettono rispettivamente di scavare e piazzare nodi come se lo stesse facendo un giocatore).
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.
## Node Callbacks ## Richiami dei nodi
When a node is in an inventory, it uses Item Callbacks, as discussed above. When Quando un nodo si trova in un inventario, vengono invocati i richiami degli oggetti discussi poc'anzi.
a node is placed in the world, it uses Node Callbacks. There are quite a lot of Al contrario, quando un nodo è situato nel mondo, vengono invocati i richiami dei nodi.
node callbacks, too many to discuss in this book. However, quite a few of them Ce ne sono di svariati tipi, troppi per essere discussi in questo libro, tuttavia alcuni di questi verranno trattati nei capitoli successivi.
will be talked about later in the book.
Several of the callbacks are related to node operations such as placing and Molti richiami dei nodi sono collegati alle operazioni effettuate - appunto - sui nodi, come piazzarli e rimuoverli dal mondo.
removing from the world. It's important to note that node operation callbacks È importante però sottolineare che, per motivi di prestazioni, operazioni come queste non vengono chiamate da modifiche in blocco (quelle che cambiano un grande numero di nodi in un colpo solo).
like these aren't called from bulk changes - those that set a large number of È meglio quindi non fare affidamento su un'esecuzione sicura al 100%.
nodes at once - for performance reasons. Therefore, you can't rely on these
callbacks to always be called.
### Right-clicking and placing a node ### Tasto destro e nodi piazzati
When the user right-clicks with an item whilst pointing at a node, the item's Quando un utente preme col tasto destro un nodo mentre ha un oggetto in mano, viene invocato il richiamo `on_place` dell'oggetto.
`on_place` callback is called. By default, this is set to `minetest.item_place`. Di base, questo è impostato a `minetest.item_place`.
If the pointed node has an `on_rightclick` callback and sneak (shift) is held, Se il nodo puntato ha un richiamo `on_rightclick` e il tasto accovacciati (shift) è tenuto premuto, allora verrà chiamato `on_rightclick`.
then the `on_rightclick` callback is called. Otherwise, `minetest.item_place` Diversamente, `minetest.item_place` piazzerà il nodo.
will place the node.
Placing a node will call both `on_construct` and `after_place_node`. Piazzare un nodo invocherà simultaneamente `on_construct` e `after_place_node`: il primo è chiamato da ogni evento che cambia i singoli nodi (quindi non in blocco) e ritorna la posizione e il valore del nodo.
`on_construct` is called by any node set event that wasn't in bulk and is just `after_place_node` viene invece chiamato solamente al piazzare un nodo, contenendo di conseguenza più informazioni - come chi l'ha piazzato e l'ItemStack.
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.
It's important to note that players aren't the only objects that can place È importante notare che i giocatori non sono le uniche realtà che possono piazzare nodi; anche le entità e le mod possono farlo.
nodes; it's common for mobs and mods to place nodes. To account for this, Per via di ciò, `place` potrebbe essere un giocatore, ma anche un'entità o `nil`.
`placer` could be a player, entity, or nil.
```lua ```lua
minetest.register_node("mymod:mynode", { minetest.register_node("miamod:mionodo", {
on_rightclick = function(pos, node, clicker, itemstack, pointed_thing) on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
if clicker:is_player() then if clicker:is_player() then
minetest.chat_send_player(clicker:get_player_name(), "Hello world!") minetest.chat_send_player(clicker:get_player_name(), "Ciao mondo!")
end end
end, end,
on_construct = function(pos, node) on_construct = function(pos, node)
local meta = minetest.get_meta(pos) local meta = minetest.get_meta(pos)
meta:set_string("infotext", "My node!") meta:set_string("infotext", "Il mio nodo!")
end, end,
after_place_node = function(pos, placer, itemstack, pointed_thing) after_place_node = function(pos, placer, itemstack, pointed_thing)
-- Make sure to check placer -- controlla chi sta piazzando
if placer and placer:is_player() then if placer and placer:is_player() then
local meta = minetest.get_meta(pos) local meta = minetest.get_meta(pos)
meta:set_string("owner", placer:get_player_name()) meta:set_string("proprietario", placer:get_player_name())
end end
end, end,
}) })
``` ```
### Punching and digging ### Colpire e scavare
Punching is when the player left-clicks for a short period. If the wielded item Si ha un colpo quando un giocatore preme col tasto sinistro per un breve periodo.
has an `on_use` callback, this will be called. Otherwise, the `on_punch` Se l'oggetto in mano possiede un richiamo `on_use`, questo verrà chiamato.
callback on the pointed node will be called. Diversamente, verrà chiamato il richiamo `on_punch` sul nodo selezionato.
When the player attempts to dig a node, the `on_dig` callback on the node will be called. Quando il giocatore tenta di scavare un nodo, viene eseguito il richiamo `on_dig` del nodo.
This defaults to `minetest.node_dig`, which will check for area protection, wear Di base, ciò equivale a `minetest.node_dig`, che controlla eventuali protezioni dell'area, usura l'oggetto, rimuove il nodo, e ne esegue il richiamo `after_dig_node`.
out the tool, remove the node, and run the `after_dig_node` callback.
```lua ```lua
minetest.register_node("mymod:mynode", { minetest.register_node("miamod:mionodo", {
on_punch = function(pos, node, puncher, pointed_thing) on_punch = function(pos, node, puncher, pointed_thing)
if puncher:is_player() then if puncher:is_player() then
minetest.chat_send_player(puncher:get_player_name(), "Ow!") minetest.chat_send_player(puncher:get_player_name(), "Ahia!")
end end
end, end,
}) })
``` ```
### ...and more! ### ...e altro!
Check out Minetest's Lua API reference for a list of all node callbacks, and Dài un occhio alla API Lua di Minetest per una lista di tutti i richiami, e per avere più informazioni riguardo quelli vista qui sopra.
more information on the callbacks above.

42
_it/items/nodes_items_crafting.md
View File

@ -17,8 +17,6 @@ Saper registrare nuovi nodi, oggetti fabbricabili e conseguenti ricette, è un r
- [Alias](#alias) - [Alias](#alias)
- [Texture](#texture) - [Texture](#texture)
- [Registrare un nodo base](#registrare-un-nodo-base) - [Registrare un nodo base](#registrare-un-nodo-base)
- [Azioni e callback](#azioni-e-callback)
- [on_use](#onuse)
- [Fabbricazione](#fabbricazione) - [Fabbricazione](#fabbricazione)
- [Fisse (shaped)](#fisse-shaped) - [Fisse (shaped)](#fisse-shaped)
- [Informi (shapeless)](#informi-shapeless) - [Informi (shapeless)](#informi-shapeless)
@ -138,46 +136,6 @@ minetest.register_node("miamod:diamante", {
L'attributo is_ground_content è essenziale per ogni nodo che si vuole far apparire sottoterra durante la generazione della mappa. L'attributo is_ground_content è essenziale per ogni nodo che si vuole far apparire sottoterra durante la generazione della mappa.
Le caverne vengono scavate nel mondo dopo che tutti gli altri nodi nell'area sono stati generati. Le caverne vengono scavate nel mondo dopo che tutti gli altri nodi nell'area sono stati generati.
## Azioni e callback
Minetest usa ampiamente una struttura per il modding incentrata sui callback (richiami).
I callback possono essere inseriti nella tabella di definizioni dell'oggetto per permettere una risposta a vari tipi di eventi generati dall'utente.
Vediamone un esempio.
### on_use
Di base, il callback on_use scatta quando un giocatore clicca col tasto sinistro con l'oggetto in mano.
Avere un callback sull'uso previene che l'oggetto venga utilizzato per scavare nodi.
Un utilizzo comune di questo callback è per il cibo:
```lua
minetest.register_craftitem("miamod:fangotorta", {
description = "Torta aliena di fango",
inventory_image = "miamod_fangotorta.png",
on_use = minetest.item_eat(20),
})
```
Il numero fornito alla funzione minetest.item_eat è il numero di punti salute ripristinati al consumare il cibo.
In gioco ogni cuore equivale a due punti.
Un giocatore ha solitamente un massimo di 10 cuori, ovvero 20 punti salute, e quest'ultimi non devono per forza essere interi - ovvero decimali.
`minetest.item_eat()` è una funzione che ritorna un'altra funzione, in questo caso quindi impostandola come callback di on_use.
Ciò significa che il codice in alto è alquanto simile al seguente:
```lua
minetest.register_craftitem("miamod:fangotorta", {
description = "Torta aliena di fango",
inventory_image = "miamod_fangotorta.png",
on_use = function(...)
return minetest.do_item_eat(20, nil, ...)
end,
})
```
Capendo come funziona item_eat, è possibile modificarlo per operazioni più complesse
come per esempio riprodurre un suono personalizzato.
## Fabbricazione ## Fabbricazione
Ci sono diversi tipi di ricette di fabbricazione disponibili, indicate dalla proprietà `type`. Ci sono diversi tipi di ricette di fabbricazione disponibili, indicate dalla proprietà `type`.