minetest_modding_book/_it/items/nodes_items_crafting.md

---
title: Nodi, Oggetti e Fabbricazione
layout: default
root: ../..
idx: 2.1
description: Impara come registrare nodi, oggetti e ricette di fabbricazione usando register_node, register_item e register_craft.
redirect_from: /it/chapters/nodes_items_crafting.html
---

## Introduzione <!-- omit in toc -->

Saper registrare nuovi nodi, oggetti fabbricabili e conseguenti ricette, è un requisito fondamentale per molte mod.

- [Cosa sono i nodi e gli oggetti?](#cosa-sono-i-nodi-e-gli-oggetti)
- [Registrare gli oggetti](#registrare-gli-oggetti)
  - [Nomi oggetto e alias](#nomi-oggetto-e-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)
  - [Cottura (cooking) e Carburante (fuel)](#cottura-cooking-e-carburante-fuel)
- [Gruppi](#gruppi)
- [Strumenti, Capacità e Friabilità](#strumenti-capacita-e-friabilita)

## Cosa sono i nodi e gli oggetti?

Nodi, oggetti fabbricabili e strumenti sono tutti oggetti.
Un oggetto è qualcosa che può essere trovato in un inventario —
anche se potrebbe non risultare possibile durante una normale sessione di gioco.

Un nodo è un oggetto che può essere piazzato o trovato nel mondo.
Ogni coordinata nel mondo deve essere occupata da un unico nodo —
ciò che appare vuoto è solitamente un nodo d'aria.

Un oggetto fabbricabile (*craftitem*) non può essere invece piazzato, potendo apparire solo negli inventari
o come oggetto rilasciato nel mondo.

Uno strumento (*tool*) può usurarsi e solitamente non possiede la capacità di scavare.
In futuro, è probabile che gli oggetti fabbricabili e gli strumenti verranno fusi in un unico tipo,
in quanto la distinzione fra di essi è alquanto artificiosa.

## Registrare gli oggetti

Le definizioni degli oggetti consistono in un *nome oggetto* e una *tabella di definizioni*.
La tabella di definizioni contiene attributi che influenzano il comportamento dell'oggetto.

```lua
minetest.register_craftitem("nomemod:nomeoggetto", {
    description = "Il Mio Super Oggetto",
    inventory_image = "nomemod_nomeoggetto.png"
})
```

### Nomi oggetto e alias

Ogni oggetto ha un nome usato per riferirsi a esso, che dovrebbe seguire la seguente struttura:

    nomemod:nomeoggetto

Il nomemod equivale appunto al nome della mod che registra l'oggetto, e nomeoggetto è
il nome che si vuole assegnare a quest'ultimo.
Il nome dell'oggetto dovrebbe essere inerente a quello che rappresenta e deve essere unico nella mod.

Gli oggetti possono anche avere degli *alias* che puntano al loro nome.
Un *alias* è uno pseudonimo che dice al motore di gioco di trattarlo come se fosse il nome a cui punta.
Ciò è comunemente usato in due casi:

* Rinominare gli oggetti rimossi in qualcos'altro.
  Ci potrebbero essere nodi sconosciuti nel mondo e negli inventari se un oggetto
  viene rimosso da una mod senza nessun codice per gestirlo.
  È importante evitare di assegnare come alias nomi di nodi inottenibili già esistenti 
  al nodo rimosso, se quest'ultimo poteva essere ottenuto.
* Aggiungere una scorciatoia. `/giveme dirt` è più semplice di `/giveme default:dirt`.

Registrare un alias è alquanto semplice.
Un buon modo per ricordarne il funzionamento è `da → a`, dove *da*
è l'alias e *a* è il nome dell'oggetto a cui punta.

```lua
minetest.register_alias("dirt", "default:dirt")
```

Le mod devono assicurarsi di elaborare gli alias prima di occuparsi direttamente
del nome dell'oggeto, in quanto l'engine non lo fa di suo.
Ciò è comunque molto semplice:

```lua
itemname = minetest.registered_aliases[itemname] or itemname
```

### Texture

Per convenzione le texture andrebbero messe nella cartella textures/ con nomi che seguono la struttura
`nomemod_nomeoggetto.png`.\\
Le immagini in JPEG sono supportate, ma non supportano la trasparenza e sono generalmente
di cattiva qualità nelle basse risoluzioni.
Si consiglia quindi il formato PNG.

Le texture su Minetest sono generalmente 16x16 pixel.
Possono essere di qualsiasi dimensione, ma è buona norma che rientrino nelle potenze di 2,
per esempio 16, 32, 64 o 128.
Questo perché dimensioni differenti potrebbero non essere supportate dai vecchi dispositivi,
comportando una diminuzione delle performance.

## Registrare un nodo base

```lua
minetest.register_node("miamod:diamante", {
    description = "Diamante alieno",
    tiles = {"miamod_diamante.png"},
    is_ground_content = true,
    groups = {cracky=3, stone=1}
})
```

La proprietà `tiles` è una tabella contenente le texture che il nodo userà.
Quando è presente una sola texture, questa sarà applicata su tutte le facce.
Per assegnarne invece di diverse, bisogna fornire il nome di 6 texture in quest'ordine:

    sopra (+Y), sotto (-Y), destra (+X), sinistra (-X), dietro (+Z), davanti (-Z).
    (+Y, -Y, +X, -X, +Z, -Z)

Ricorda che su Minetest, come nella convenzione della computer grafica 3D, +Y punta verso l'alto.

```lua
minetest.register_node("miamod:diamante", {
    description = "Diamante alieno",
    tiles = {
        "miamod_diamante_up.png",    -- y+
        "miamod_diamante_down.png",  -- y-
        "miamod_diamante_right.png", -- x+
        "miamod_diamante_left.png",  -- x-
        "miamod_diamante_back.png",  -- z+
        "miamod_diamante_front.png", -- z-
    },
    is_ground_content = true,
    groups = {cracky = 3},
    drop = "miamod:diamante_frammenti"
    -- ^  Al posto di rilasciare diamanti, rilascia miamod:diamante_frammenti
})
```

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.

### 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.
Quest'ultimi non devono per forza essere interi, bensì possono anche essere 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`.

* shaped - Gli ingredienti devono essere nel giusta posizione.
* shapeless - Non importa dove sono gli ingredienti, solo che siano abbastanza.
* cooking - Ricette di cottura per la fornace.
* fuel - Definisce gli oggetti che possono alimentare il fuoco nella fornace.
* tool_repair - Definisce gli oggetti che possono essere riparati.

Le ricette di fabbricazione non sono oggetti, perciò non usano nomi oggetto per
identificare in maniera univoca se stesse

### Fisse (shaped)

Le ricette fisse avvengono quando gli ingredienti devono essere nella forma o sequenza
corretta per funzionare. Nell'esempio sotto, i frammenti necessitano di essere in
in una figura a forma di sedia per poter fabbricare appunto 99 sedie.

```lua
minetest.register_craft({
    type = "shaped",
    output = "miamod:diamante_sedia 99",
    recipe = {
        {"miamod:diamante_frammenti", "",                         ""},
        {"miamod:diamante_frammenti", "miamod:diamante_frammenti",  ""},
        {"miamod:diamante_frammenti", "miamod:diamante_frammenti",  ""}
    }
})
```

Una cosa da tener presente è la colonna vuota sulla parte destra.
Questo significa che ci *deve* essere una colonna vuota a destra della forma, altrimenti
ciò non funzionerà.
Se invece la colonna non dovesse servire, basta ometterla in questo modo:

```lua
minetest.register_craft({
    output = "miamod:diamante_sedia 99",
    recipe = {
        {"miamod:diamante_frammenti", ""                         },
        {"miamod:diamante_frammenti", "miamod:diamante_frammenti"},
        {"miamod:diamante_frammenti", "miamod:diamante_frammenti"}
    }
})
```

Il campo type non è davvero necessario per le ricette fisse, in quanto sono
il tipo di base.

### Informi (shapeless)

Le ricette informi sono ricette che vengono usate quando non importa
dove sono posizionati gli ingredienti, ma solo che ci siano.

```lua
minetest.register_craft({
    type = "shapeless",
    output = "miamod:diamante 3",
    recipe = {
        "miamod:diamante_frammenti",
        "miamod:diamante_frammenti",
        "miamod:diamante_frammenti",
    },
})
```

### Cottura (cooking) e carburante (fuel)

Le ricette di tipo "cottura" non vengono elaborate nella griglia di fabbricazione,
bensì nelle fornaci o in qualsivoglia altro strumento di cottura che può essere trovato
nelle mod.

```lua
minetest.register_craft({
    type = "cooking",
    output = "miamod_diamante_frammenti",
    recipe = "default:coalblock",
    cooktime = 10,
})
```

L'unica vera differenza nel codice è che in questo la ricetta non è una tabella (tra parentesi graffe),
bensì un singolo oggetto.
Le ricette di cottura dispongono anche di un parametro aggiuntivo "cooktime"
che indica in secondi quanto tempo ci impiega l'oggetto a cuocersi.
Se non è impostato, di base è 3.

La ricetta qui sopra genera un'unità di frammenti di diamante dopo 10 secondi quando
il blocco di carbone (coalblock) è nello slot di input, con un qualche tipo di carburante sotto di esso.

Il tipo "carburante" invece funge da accompagnamento alle ricette di cottura,
in quanto definisce cosa può alimentare il fuoco.

```lua
minetest.register_craft({
    type = "fuel",
    recipe = "miamod:diamante",
    burntime = 300,
})
```

Esso non ha un output come le altre ricette, e possiede un tempo di arsura (burntime)
che definisce in secondi per quanto alimenterà la fiamma. In questo caso, 300 secondi!

## Gruppi

Gli oggetti possono essere membri di più gruppi, e i gruppi possono avere più membri.
Essi sono definiti usando la proprietà `groups` nella tabella di definizione,
e possiedono un valore associato.

```lua
groups = {cracky = 3, wood = 1}
```

Ci sono diverse ragioni per cui usare i gruppi.
In primis, vengono utilizzati per descrivere proprietà come friabilità e infiammabilità.
In secundis, possono essere usati in una ricetta al posto di un nome oggetto per permettere
a qualsiasi oggetto nel gruppo di essere utilizzato.

```lua
minetest.register_craft({
    type = "shapeless",
    output = "miamod:diamante_qualcosa 3",
    recipe = {"group:wood", "miamod:diamante"}
})
```

## Strumenti, Capacità e Friabilità

Le friabilità sono dei gruppi particolari utilizzati per definire la resistenza di un nodo
quando scavato con un determinato strumento.
Una friabilità elevata equivale a una maggior facilità e velocità nel romperlo.
È possibile combinarne di più tipi per permettere al nodo di essere distrutto da più tipi di strumento.
Un nodo senza friabilità non può essere distrutto da nessuno strumento.

| Gruppo  | Miglior strumento | Descrizione |
|---------|-------------------|-------------|
| crumbly | pala              | Terra, sabbia |
| cracky  | piccone           | Cose dure e sgretolabili come la pietra |
| snappy  | *qualsiasi*       | Può essere rotto usando uno strumento adatto;<br>es. foglie, piantine, filo, lastre di metallo |
| choppy  | ascia             | Può essere rotto con dei fendenti; es. alberi, assi di legno |
| fleshy  | spada             | Esseri viventi come animali e giocatori.<br>Potrebbe implicare effetti di sangue al colpire |
| explody | ?                 | Predisposti ad esplodere  |
| oddly_breakable_by_hand | *qualsiasi* | Torce e simili — molto veloci da rompere |


Ogni strumento possiede poi delle capacità (capability).
Una capacità include una lista di friabilità supportate, e proprietà associate
per ognuna di esse come la velocità di scavata e il livello di usura.
Gli strumenti possono anche avere una durezza massima supportata per ogni tipo;
ciò serve a prevenire che strumenti più deboli possano rompere nodi meno friabili.
È poi molto comune che uno strumento includa tutte le friabilità nelle sue capacità,
con quelle meno adatte equivalenti a proprietà inefficienti.
Se l'oggetto impugnato dal giocatore non ha una capacità esplicitata,
verrà allora usata quella della mano.

```lua
minetest.register_tool("miamod:strumento", {
    description = "Il mio strumento",
    inventory_image = "miamod_strumento.png",
    tool_capabilities = {
        full_punch_interval = 1.5,
        max_drop_level = 1,
        groupcaps = {
            crumbly = {
                maxlevel = 2,
                uses = 20,
                times = { [1]=1.60, [2]=1.20, [3]=0.80 }
            },
        },
        damage_groups = {fleshy=2},
    },
})
```
I gruppi limite (groupcaps) sono una lista delle friabilità supportate dallo strumento.
I gruppi di danno invece (damage_groups) servono a controllare come uno strumento (esterno) danneggia
quell'oggetto. Quest'ultimi verranno discussi in seguito nel capitolo Oggetti, Giocatori e Entità.