IT | translate callbacks chapter
This commit is contained in:
Zughy
parent
69bb5c1a0d
commit
b9a3015124
@ -8,95 +8,86 @@ description: Learn about callbacks, actions, and events, including on_use, on_pu
|
||||
|
||||
## Introduction <!-- omit in toc -->
|
||||
|
||||
Minetest heavily uses a callback-based modding design. A callback is a function
|
||||
that you give to an API and is called when an event happens. For example, you
|
||||
can provide an `on_punch` function in a node definition to be called when a player
|
||||
punches a node. There are also global callbacks like
|
||||
`minetest.register_on_punchnode` to receive events for all nodes.
|
||||
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.
|
||||
Per esempio, puoi aggiungere una funzione `on_punch` nella definizione di un nodo, che verrà chiamata quando questo viene colpito.
|
||||
Ci sono poi anche dei richiami globali, come `minetest.register_on_punchnode`, che in questo caso verrà invocato al colpire qualsiasi nodo.
|
||||
|
||||
- [Item Callbacks](#item-callbacks)
|
||||
- [Richiami degli oggetti](#richiami-degli-oggetti)
|
||||
- [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)
|
||||
- [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)
|
||||
- [item_place contro place_item](#item_place-contro-place_item)
|
||||
- [Richiami dei nodi](#richiami-dei-nodi)
|
||||
- [Tasto destro e nodi piazzati](#tasto-destro-e-nodi-piazzati)
|
||||
- [Colpire e scavare](#colpire-e-scavare)
|
||||
- [...e altro!](#e-altro)
|
||||
|
||||
|
||||
## Item Callbacks
|
||||
## Richiami degli oggetti
|
||||
|
||||
When a player has a node, craftitem, or tool in their inventory, they may trigger
|
||||
certain events:
|
||||
Quando un giocatore ha un nodo, un oggetto fabbricabile o uno strumento nel proprio inventario, questi potrebbero innescare degli eventi:
|
||||
|
||||
| Callback | Default binding | Default value |
|
||||
| Richiamo | Assegnazione base | Valore base |
|
||||
|------------------|---------------------------|----------------------------------------------|
|
||||
| on_use | left-click | nil |
|
||||
| on_place | right-click on a node | `minetest.item_place` |
|
||||
| on_secondary_use | right-click not on a node | `minetest.item_secondary_use` (does nothing) |
|
||||
| on_use | clic sinistro | nil |
|
||||
| on_place | clic destro su un nodo | `minetest.item_place` |
|
||||
| on_secondary_use | clic destro a vuoto | `minetest.item_secondary_use` (non fa nulla) |
|
||||
| on_drop | Q | `minetest.item_drop` |
|
||||
| after_use | digging a node | nil |
|
||||
| after_use | allo scavare un nodo | nil |
|
||||
|
||||
|
||||
### on_use
|
||||
|
||||
Having a use callback prevents the item from being used to dig nodes. One common
|
||||
use of the use callback is for food:
|
||||
Sovrascrivere l'uso dell'oggetto impedisce che quest'ultimo possa essere usato per scavare nodi.
|
||||
Un impiego comune di questo richiamo lo si trova nel cibo:
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("mymod:mudpie", {
|
||||
description = "Alien Mud Pie",
|
||||
inventory_image = "myfood_mudpie.png",
|
||||
minetest.register_craftitem("miamod:fangotorta", {
|
||||
description = "Torta aliena di fango",
|
||||
inventory_image = "miamod_fangotorta.png",
|
||||
on_use = minetest.item_eat(20),
|
||||
})
|
||||
```
|
||||
|
||||
The number supplied to the minetest.item_eat function is the number of hit
|
||||
points healed when this food is consumed. Each heart icon the player has is
|
||||
worth two hitpoints. A player can usually have up to 10 hearts, which is equal
|
||||
to 20 hitpoints.
|
||||
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 - bensì anche decimali.
|
||||
|
||||
minetest.item_eat() is a function that returns a function, setting it as the
|
||||
on_use callback. This means the code above is equivalent to this:
|
||||
`minetest.item_eat()` è una funzione che ritorna un'altra funzione, in questo caso quindi impostandola come richiamo di on_use.
|
||||
Ciò significa che il codice in alto è alquanto simile al seguente:
|
||||
|
||||
```lua
|
||||
minetest.register_craftitem("mymod:mudpie", {
|
||||
description = "Alien Mud Pie",
|
||||
inventory_image = "myfood_mudpie.png",
|
||||
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,
|
||||
})
|
||||
```
|
||||
|
||||
By understanding how item_eat works by simply returning a function, it's
|
||||
possible to modify it to do more complex behaviour like playing a custom sound.
|
||||
Capendo come funziona item_eat, è possibile modificarlo per operazioni più complesse
|
||||
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
|
||||
called when the player is pointing at a node and `on_secondary_use` when the
|
||||
player isn't.
|
||||
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.
|
||||
|
||||
Both callbacks are called for all types of items. `on_place` defaults to the
|
||||
`minetest.item_place` function, which handles calling the `on_rightclick`
|
||||
callback of the pointed node or placing the wielded item if it is a node.
|
||||
Entrambi i richiami sono invocati per tutti i tipi di oggetti.
|
||||
`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.
|
||||
|
||||
|
||||
### on_drop
|
||||
|
||||
on_drop is called when the player requests to drop an item, for example using
|
||||
the drop key (Q) or dragging it outside of the inventory. It defaults to the
|
||||
`minetest.item_drop` function, which will handle dropping the item.
|
||||
|
||||
`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.
|
||||
Risponde alla funzione `minetest.item_drop`, la quale gestisce il buttare l'oggetto.
|
||||
|
||||
### 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` viene chiamato quando si scava un nodo, e permette di personalizzare come viene applicata l'usura a uno strumento.
|
||||
Se `after_use` non esiste, è come se ci fosse scritto:
|
||||
|
||||
```lua
|
||||
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
|
||||
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:
|
||||
L'API di Minetest include varie implementazioni già pronte di richiami.
|
||||
Queste seguono la nomenclatura "tipodioggetto_azione", per esempio `minetest.item_place` e `minetest.node_dig`.
|
||||
Alcune sono usate direttamente, mentre altre sono funzioni che ritornano il richiamo vero e proprio:
|
||||
|
||||
```lua
|
||||
minetest.register_item("mymod:example", {
|
||||
minetest.register_item("miamod:esempio", {
|
||||
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.
|
||||
Inoltre, l'API di Minetest include funzioni già pronte che _fanno_ qualcosa.
|
||||
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).
|
||||
|
||||
|
||||
## Node Callbacks
|
||||
## Richiami dei nodi
|
||||
|
||||
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.
|
||||
Quando un nodo si trova in un inventario, vengono invocati i richiami degli oggetti discussi poc'anzi.
|
||||
Al contrario, quando un nodo è situato nel mondo, vengono invocati i richiami dei nodi.
|
||||
Ce ne sono di svariati tipi, troppi per essere discussi in questo libro, tuttavia alcuni di questi verranno trattati nei capitoli successivi.
|
||||
|
||||
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.
|
||||
Molti richiami dei nodi sono collegati alle operazioni effettuate - appunto - sui nodi, come piazzarli e rimuoverli dal mondo.
|
||||
È 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).
|
||||
È meglio quindi non fare affidamento su un'esecuzione sicura al 100%.
|
||||
|
||||
|
||||
### 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
|
||||
`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.
|
||||
Quando un utente preme col tasto destro un nodo mentre ha un oggetto in mano, viene invocato il richiamo `on_place` dell'oggetto.
|
||||
Di base, questo è impostato a `minetest.item_place`.
|
||||
Se il nodo puntato ha un richiamo `on_rightclick` e il tasto accovacciati (shift) è tenuto premuto, allora verrà chiamato `on_rightclick`.
|
||||
Diversamente, `minetest.item_place` piazzerà il nodo.
|
||||
|
||||
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.
|
||||
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.
|
||||
`after_place_node` viene invece chiamato solamente al piazzare un nodo, contenendo di conseguenza più informazioni - come chi l'ha piazzato e l'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.
|
||||
È importante notare che i giocatori non sono le uniche realtà che possono piazzare nodi; anche le entità e le mod possono farlo.
|
||||
Per via di ciò, `place` potrebbe essere un giocatore, ma anche un'entità o `nil`.
|
||||
|
||||
```lua
|
||||
minetest.register_node("mymod:mynode", {
|
||||
minetest.register_node("miamod:mionodo", {
|
||||
on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
|
||||
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,
|
||||
on_construct = function(pos, node)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("infotext", "My node!")
|
||||
meta:set_string("infotext", "Il mio nodo!")
|
||||
end,
|
||||
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
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("owner", placer:get_player_name())
|
||||
meta:set_string("proprietario", placer:get_player_name())
|
||||
end
|
||||
end,
|
||||
})
|
||||
```
|
||||
|
||||
### Punching and digging
|
||||
### Colpire e scavare
|
||||
|
||||
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.
|
||||
Si ha un colpo quando un giocatore preme col tasto sinistro per un breve periodo.
|
||||
Se l'oggetto in mano possiede un richiamo `on_use`, questo verrà chiamato.
|
||||
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.
|
||||
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.
|
||||
Quando il giocatore tenta di scavare un nodo, viene eseguito il richiamo `on_dig` del nodo.
|
||||
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`.
|
||||
|
||||
|
||||
```lua
|
||||
minetest.register_node("mymod:mynode", {
|
||||
minetest.register_node("miamod:mionodo", {
|
||||
on_punch = function(pos, node, puncher, pointed_thing)
|
||||
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,
|
||||
})
|
||||
```
|
||||
|
||||
### ...and more!
|
||||
### ...e altro!
|
||||
|
||||
Check out Minetest's Lua API reference for a list of all node callbacks, and
|
||||
more information on the callbacks above.
|
||||
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.
|
||||
|
||||
@ -17,8 +17,6 @@ Saper registrare nuovi nodi, oggetti fabbricabili e conseguenti ricette, è un r
|
||||
- [Alias](#alias)
|
||||
- [Texture](#texture)
|
||||
- [Registrare un nodo base](#registrare-un-nodo-base)
|
||||
- [Azioni e callback](#azioni-e-callback)
|
||||
- [on_use](#onuse)
|
||||
- [Fabbricazione](#fabbricazione)
|
||||
- [Fisse (shaped)](#fisse-shaped)
|
||||
- [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.
|
||||
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
|
||||
|
||||
Ci sono diversi tipi di ricette di fabbricazione disponibili, indicate dalla proprietà `type`.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user