From b9a3015124261f33c52b41c22ed4aba5f285144b Mon Sep 17 00:00:00 2001 From: Zughy <4279489-marco_a@users.noreply.gitlab.com> Date: Wed, 19 Apr 2023 23:28:13 +0200 Subject: [PATCH] IT | translate callbacks chapter --- _it/items/callbacks.md | 178 +++++++++++++----------------- _it/items/nodes_items_crafting.md | 42 ------- 2 files changed, 78 insertions(+), 142 deletions(-) diff --git a/_it/items/callbacks.md b/_it/items/callbacks.md index 2c03bce..662b6e7 100644 --- a/_it/items/callbacks.md +++ b/_it/items/callbacks.md @@ -8,95 +8,86 @@ description: Learn about callbacks, actions, and events, including on_use, on_pu ## Introduction -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. diff --git a/_it/items/nodes_items_crafting.md b/_it/items/nodes_items_crafting.md index 25c87ec..9088635 100644 --- a/_it/items/nodes_items_crafting.md +++ b/_it/items/nodes_items_crafting.md @@ -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`.