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

3 - Nodes, Items and Crafting, Italian translation

Browse Source
This commit is contained in:
Marco 2020-05-04 19:46:53 +02:00 committed by rubenwardy
parent 287da22236
commit 765e60a133
1 changed files with 204 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

420
_it/items/nodes_items_crafting.md
View File

@ -1,367 +1,356 @@
--- ---
title: Nodes, Items, and Crafting title: Nodi, Oggetti e Fabbricazione
layout: default layout: default
root: ../.. root: ../..
idx: 2.1 idx: 2.1
description: Learn how to register node, items, and craft recipes using register_node, register_item, and register_craft. description: Impara come registrare nodi, oggetti e ricette di fabbricazione usando register_node, register_item e register_craft.
redirect_from: /en/chapters/nodes_items_crafting.html redirect_from: /it/chapters/nodes_items_crafting.html
--- ---
## Introduction <!-- omit in toc --> ## Introduzione <!-- omit in toc -->
Registering new nodes and craftitems, and creating craft recipes, are Saper registrare nuovi nodi, oggetti fabbricabili e conseguenti ricette, è un requisito fondamentale per molte mod.
basic requirements for many mods.
- [What are Nodes and Items?](#what-are-nodes-and-items) - [Cosa sono i nodi e gli oggetti?](#cosa-sono-i-nodi-e-gli-oggetti)
- [Registering Items](#registering-items) - [Registrare gli oggetti](#registrare-gli-oggetti)
- [Item Names and Aliases](#item-names-and-aliases) - [Nomi oggetto e alias](#nomi-oggetto-e-alias)
- [Textures](#textures) - [Texture](#texture)
- [Registering a basic node](#registering-a-basic-node) - [Registrare un nodo base](#registrare-un-nodo-base)
- [Actions and Callbacks](#actions-and-callbacks) - [Azioni e callback](#azioni-e-callback)
- [on_use](#onuse) - [on_use](#onuse)
- [Crafting](#crafting) - [Fabbricazione](#fabbricazione)
- [Shaped](#shaped) - [Fisse (shaped)](#fisse-shaped)
- [Shapeless](#shapeless) - [Informi (shapeless)](#informi-shapeless)
- [Cooking and Fuel](#cooking-and-fuel) - [Cottura (cooking) e Carburante (fuel)](#cottura-cooking-e-carburante-fuel)
- [Groups](#groups) - [Gruppi](#gruppi)
- [Tools, Capabilities, and Dig Types](#tools-capabilities-and-dig-types) - [Strumenti, Capacità e Friabilità](#strumenti-capacita-e-friabilita)
## What are Nodes and Items? ## Cosa sono i nodi e gli oggetti?
Nodes, craftitems, and tools are all Items. Nodi, oggetti fabbricabili e strumenti sono tutti oggetti.
An item is something that could be found in an inventory - Un oggetto è qualcosa che può essere trovato in un inventario —
even though it may not be possible through normal gameplay. anche se potrebbe non risultare possibile durante una normale sessione di gioco.
A node is an item which can be placed or be found in the world. Un nodo è un oggetto che può essere piazzato o trovato nel mondo.
Every position in the world must be occupied with one and only one node - Ogni coordinata nel mondo deve essere occupata da un unico nodo —
seemingly blank positions are usually air nodes. ciò che appare vuoto è solitamente un nodo d'aria.
A craftitem can't be placed and is only found in inventories or as a dropped item Un oggetto fabbricabile (*craftitem*) non può essere invece piazzato, potendo apparire solo negli inventari
in the world. o come oggetto rilasciato nel mondo.
A tool has the ability to wear and typically has non-default digging capabilities. Uno strumento (*tool*) può usurarsi e solitamente non possiede la capacità di scavare.
In the future, it's likely that craftitems and tools will merge into one type of In futuro, è probabile che gli oggetti fabbricabili e gli strumenti verranno fusi in un unico tipo,
item, as the distinction between them is rather artificial. in quanto la distinzione fra di essi è alquanto artificiosa.
## Registering Items ## Registrare gli oggetti
Item definitions consist of an *item name* and a *definition table*. Le definizioni degli oggetti consistono in un *nome oggetto* e una *tabella di definizioni*.
The definition table contains attributes which affect the behaviour of the item. La tabella di definizioni contiene attributi che influenzano il comportamento dell'oggetto.
```lua ```lua
minetest.register_craftitem("modname:itemname", { minetest.register_craftitem("nomemod:nomeoggetto", {
description = "My Special Item", description = "Il Mio Super Oggetto",
inventory_image = "modname_itemname.png" inventory_image = "nomemod_nomeoggetto.png"
}) })
``` ```
### Item Names and Aliases ### Nomi oggetto e alias
Every item has an item name used to refer to it, which should be in the Ogni oggetto ha un nome usato per riferirsi a esso, che dovrebbe seguire la seguente struttura:
following format:
modname:itemname nomemod:nomeoggetto
The modname is the name of the mod in which the item is registered, and the Il nomemod equivale appunto al nome della mod che registra l'oggetto, e nomeoggetto è
item name is the name of the item itself. il nome che si vuole assegnare a quest'ultimo.
The item name should be relevant to what the item is and can't already be registered. Il nome dell'oggetto dovrebbe essere inerente a quello che rappresenta e deve essere unico nella mod.
Items can also have *aliases* pointing to their name. Gli oggetti possono anche avere degli *alias* che puntano al loro nome.
An *alias* is a pseudo-item name which results in the engine treating any Un *alias* è uno pseudonimo che dice al motore di gioco di trattarlo come se fosse il nome a cui punta.
occurrences of the alias as if it were the item name. Ciò è comunemente usato in due casi:
There are two main common uses of this:
* Renaming removed items to something else. * Rinominare gli oggetti rimossi in qualcos'altro.
There may be unknown nodes in the world and in inventories if an item is Ci potrebbero essere nodi sconosciuti nel mondo e negli inventari se un oggetto
removed from a mod without any corrective code. viene rimosso da una mod senza nessun codice per gestirlo.
It's important to avoid aliasing to an unobtainable node if the remove node È importante evitare di assegnare come alias nomi di nodi inottenibili già esistenti
could be obtained. al nodo rimosso, se quest'ultimo poteva essere ottenuto.
* Adding a shortcut. `/giveme dirt` is easier than `/giveme default:dirt`. * Aggiungere una scorciatoia. `/giveme dirt` è più semplice di `/giveme default:dirt`.
Registering an alias is pretty simple. Registrare un alias è alquanto semplice.
A good way to remember the order of the arguments is `from → to` where Un buon modo per ricordarne il funzionamento è `da → a`, dove *da*
*from* is the alias and *to* is the target. è l'alias e *a* è il nome dell'oggetto a cui punta.
```lua ```lua
minetest.register_alias("dirt", "default:dirt") minetest.register_alias("dirt", "default:dirt")
``` ```
Mods need to make sure to resolve aliases before dealing directly with item names, Le mod devono assicurarsi di elaborare gli alias prima di occuparsi direttamente
as the engine won't do this. del nome dell'oggeto, in quanto l'engine non lo fa di suo.
This is pretty simple though: Ciò è comunque molto semplice:
```lua ```lua
itemname = minetest.registered_aliases[itemname] or itemname itemname = minetest.registered_aliases[itemname] or itemname
``` ```
### Textures ### Texture
Textures should be placed in the textures/ folder with names in the format Per convenzione le texture andrebbero messe nella cartella textures/ con nomi che seguono la struttura
`modname_itemname.png`.\\ `nomemod_nomeoggetto.png`.\\
JPEG textures are supported, but they do not support transparency and are generally Le immagini in JPEG sono supportate, ma non supportano la trasparenza e sono generalmente
bad quality at low resolutions. di cattiva qualità nelle basse risoluzioni.
It is often better to use the PNG format. Si consiglia quindi il formato PNG.
Textures in Minetest are usually 16 by 16 pixels. Le texture su Minetest sono generalmente 16x16 pixel.
They can be any resolution, but it is recommended that they are in the order of 2, Possono essere di qualsiasi dimensione, ma è buona norma che rientrino nelle potenze di 2,
for example, 16, 32, 64, or 128. per esempio 16, 32, 64 o 128.
This is because other resolutions may not be supported correctly on older devices, Questo perché dimensioni differenti potrebbero non essere supportate dai vecchi dispositivi,
resulting in decreased performance. comportando una diminuzione delle performance.
## Registering a basic node ## Registrare un nodo base
```lua ```lua
minetest.register_node("mymod:diamond", { minetest.register_node("miamod:diamante", {
description = "Alien Diamond", description = "Diamante alieno",
tiles = {"mymod_diamond.png"}, tiles = {"miamod_diamante.png"},
is_ground_content = true, is_ground_content = true,
groups = {cracky=3, stone=1} groups = {cracky=3, stone=1}
}) })
``` ```
The `tiles` property is a table of texture names the node will use. La proprietà `tiles` è una tabella contenente le texture che il nodo userà.
When there is only one texture, this texture is used on every side. Quando è presente una sola texture, questa sarà applicata su tutte le facce.
To give a different texture per-side, supply the names of 6 textures in this order: Per assegnarne invece di diverse, bisogna fornire il nome di 6 texture in quest'ordine:
up (+Y), down (-Y), right (+X), left (-X), back (+Z), front (-Z). sopra (+Y), sotto (-Y), destra (+X), sinistra (-X), dietro (+Z), davanti (-Z).
(+Y, -Y, +X, -X, +Z, -Z) (+Y, -Y, +X, -X, +Z, -Z)
Remember that +Y is upwards in Minetest, as is the convention with Ricorda che su Minetest, come nella convenzione della computer grafica 3D, +Y punta verso l'alto.
3D computer graphics.
```lua ```lua
minetest.register_node("mymod:diamond", { minetest.register_node("miamod:diamante", {
description = "Alien Diamond", description = "Diamante alieno",
tiles = { tiles = {
"mymod_diamond_up.png", -- y+ "miamod_diamante_up.png", -- y+
"mymod_diamond_down.png", -- y- "miamod_diamante_down.png", -- y-
"mymod_diamond_right.png", -- x+ "miamod_diamante_right.png", -- x+
"mymod_diamond_left.png", -- x- "miamod_diamante_left.png", -- x-
"mymod_diamond_back.png", -- z+ "miamod_diamante_back.png", -- z+
"mymod_diamond_front.png", -- z- "miamod_diamante_front.png", -- z-
}, },
is_ground_content = true, is_ground_content = true,
groups = {cracky = 3}, groups = {cracky = 3},
drop = "mymod:diamond_fragments" drop = "miamod:diamante_frammenti"
-- ^ Rather than dropping diamond, drop mymod:diamond_fragments -- ^ Al posto di rilasciare diamanti, rilascia miamod:diamante_frammenti
}) })
``` ```
The is_ground_content attribute allows caves to be generated over the stone. L'attributo is_ground_content è essenziale per ogni nodo che si vuole far apparire sottoterra
This is essential for any node which may be placed during map generation underground. durante la generazione della mappa.
Caves are cut out of the world after all the other nodes in an area have generated. Le caverne vengono scavate nel mondo dopo che tutti gli altri nodi nell'area sono stati generati.
## Actions and Callbacks ## Azioni e callback
Minetest heavily uses a callback-based modding design. Minetest usa ampiamente una struttura per il modding incentrata sui callback (richiami).
Callbacks can be placed in the item definition table to allow response to various I callback possono essere inseriti nella tabella di definizioni dell'oggetto per permettere una
different user events. risposta a vari tipi di eventi generati dall'utente.
### on_use ### on_use
By default, the use callback is triggered when a player left-clicks with an item. Di base, il callback on_use scatta quando un giocatore clicca col tasto sinistro con l'oggetto in mano.
Having a use callback prevents the item being used to dig nodes. Avere un callback sull'uso previene che l'oggetto venga utilizzato per scavare nodi.
One common use of the use callback is for food: Un utilizzo comune di questo callback è per il 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 points Il numero fornito alla funzione minetest.item_eat è il numero di punti salute ripristinati al
healed when this food is consumed. consumare il cibo.
Each heart icon the player has is worth two hitpoints. In gioco ogni cuore equivale a due punti.
A player can usually have up to 10 hearts, which is equal to 20 hitpoints. Un giocatore ha solitamente un massimo di 10 cuori, ovvero 20 punti salute.
Hitpoints don't have to be integers (whole numbers); they can be decimals. Quest'ultimi non devono per forza essere interi, bensì possono anche essere decimali.
minetest.item_eat() is a function which returns a function, setting it minetest.item_eat() è una funzione che ritorna un'altra funzione, in questo caso
as the on_use callback. quindi impostandola come callback di on_use.
This means the code above is roughly similar 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 such as play a custom sound. come per esempio riprodurre un suono personalizzato.
## Crafting ## Fabbricazione
There are several types of crafting recipe available, indicated by the `type` Ci sono diversi tipi di ricette di fabbricazione disponibili, indicate dalla proprietà `type`.
property.
* shaped - Ingredients must be in the correct position. * shaped - Gli ingredienti devono essere nel giusta posizione.
* shapeless - It doesn't matter where the ingredients are, * shapeless - Non importa dove sono gli ingredienti, solo che siano abbastanza.
just that there is the right amount. * cooking - Ricette di cottura per la fornace.
* cooking - Recipes for the furnace to use. * fuel - Definisce gli oggetti che possono alimentare il fuoco nella fornace.
* fuel - Defines items which can be burned in furnaces. * tool_repair - Definisce gli oggetti che possono essere riparati.
* tool_repair - Defines items which can be tool repaired.
Craft recipes are not items, so they do not use Item Names to uniquely Le ricette di fabbricazione non sono oggetti, perciò non usano nomi oggetto per
identify themselves. identificare in maniera univoca se stesse
### Shaped ### Fisse (shaped)
Shaped recipes are when the ingredients need to be in the right shape or Le ricette fisse avvengono quando gli ingredienti devono essere nella forma o sequenza
pattern to work. In the example below, the fragments need to be in a corretta per funzionare. Nell'esempio sotto, i frammenti necessitano di essere in
chair-like pattern for the craft to work. in una figura a forma di sedia per poter fabbricare appunto 99 sedie.
```lua ```lua
minetest.register_craft({ minetest.register_craft({
type = "shaped", type = "shaped",
output = "mymod:diamond_chair 99", output = "miamod:diamante_sedia 99",
recipe = { recipe = {
{"mymod:diamond_fragments", "", ""}, {"miamod:diamante_frammenti", "", ""},
{"mymod:diamond_fragments", "mymod:diamond_fragments", ""}, {"miamod:diamante_frammenti", "miamod:diamante_frammenti", ""},
{"mymod:diamond_fragments", "mymod:diamond_fragments", ""} {"miamod:diamante_frammenti", "miamod:diamante_frammenti", ""}
} }
}) })
``` ```
One thing to note is the blank column on the right-hand side. Una cosa da tener presente è la colonna vuota sulla parte destra.
This means that there *must* be an empty column to the right of the shape, otherwise Questo significa che ci *deve* essere una colonna vuota a destra della forma, altrimenti
this won't work. ciò non funzionerà.
If this empty column shouldn't be required, then the empty strings can be left Se invece la colonna non dovesse servire, basta ometterla in questo modo:
out like so:
```lua ```lua
minetest.register_craft({ minetest.register_craft({
output = "mymod:diamond_chair 99", output = "miamod:diamante_sedia 99",
recipe = { recipe = {
{"mymod:diamond_fragments", "" }, {"miamod:diamante_frammenti", "" },
{"mymod:diamond_fragments", "mymod:diamond_fragments"}, {"miamod:diamante_frammenti", "miamod:diamante_frammenti"},
{"mymod:diamond_fragments", "mymod:diamond_fragments"} {"miamod:diamante_frammenti", "miamod:diamante_frammenti"}
} }
}) })
``` ```
The type field isn't actually needed for shaped crafts, as shaped is the Il campo type non è davvero necessario per le ricette fisse, in quanto sono
default craft type. il tipo di base.
### Shapeless ### Informi (shapeless)
Shapeless recipes are a type of recipe which is used when it doesn't matter Le ricette informi sono ricette che vengono usate quando non importa
where the ingredients are placed, just that they're there. dove sono posizionati gli ingredienti, ma solo che ci siano.
```lua ```lua
minetest.register_craft({ minetest.register_craft({
type = "shapeless", type = "shapeless",
output = "mymod:diamond 3", output = "miamod:diamante 3",
recipe = { recipe = {
"mymod:diamond_fragments", "miamod:diamante_frammenti",
"mymod:diamond_fragments", "miamod:diamante_frammenti",
"mymod:diamond_fragments", "miamod:diamante_frammenti",
}, },
}) })
``` ```
### Cooking and Fuel ### Cottura (cooking) e carburante (fuel)
Recipes with the type "cooking" are not made in the crafting grid, Le ricette di tipo "cottura" non vengono elaborate nella griglia di fabbricazione,
but are cooked in furnaces, or other cooking tools that might be found in mods. bensì nelle fornaci o in qualsivoglia altro strumento di cottura che può essere trovato
nelle mod.
```lua ```lua
minetest.register_craft({ minetest.register_craft({
type = "cooking", type = "cooking",
output = "mymod:diamond_fragments", output = "miamod_diamante_frammenti",
recipe = "default:coalblock", recipe = "default:coalblock",
cooktime = 10, cooktime = 10,
}) })
``` ```
The only real difference in the code is that the recipe is just a single item, L'unica vera differenza nel codice è che in questo la ricetta non è una tabella (tra parentesi graffe),
compared to being in a table (between braces). bensì un singolo oggetto.
They also have an optional "cooktime" parameter which Le ricette di cottura dispongono anche di un parametro aggiuntivo "cooktime"
defines how long the item takes to cook. che indica in secondi quanto tempo ci impiega l'oggetto a cuocersi.
If this is not set, it defaults to 3. Se non è impostato, di base è 3.
The recipe above works when the coal block is in the input slot, La ricetta qui sopra genera un'unità di frammenti di diamante dopo 10 secondi quando
with some form of fuel below it. il blocco di carbone (coalblock) è nello slot di input, con un qualche tipo di carburante sotto di esso.
It creates diamond fragments after 10 seconds!
This type is an accompaniment to the cooking type, as it defines Il tipo "carburante" invece funge da accompagnamento alle ricette di cottura,
what can be burned in furnaces and other cooking tools from mods. in quanto definisce cosa può alimentare il fuoco.
```lua ```lua
minetest.register_craft({ minetest.register_craft({
type = "fuel", type = "fuel",
recipe = "mymod:diamond", recipe = "miamod:diamante",
burntime = 300, burntime = 300,
}) })
``` ```
They don't have an output like other recipes, but they have a burn time Esso non ha un output come le altre ricette, e possiede un tempo di arsura (burntime)
which defines how long they will last as fuel in seconds. che definisce in secondi per quanto alimenterà la fiamma. In questo caso, 300 secondi!
So, the diamond is good as fuel for 300 seconds!
## Groups ## Gruppi
Items can be members of many groups and groups can have many members. Gli oggetti possono essere membri di più gruppi, e i gruppi possono avere più membri.
Groups are defined using the `groups` property in the definition table Essi sono definiti usando la proprietà `groups` nella tabella di definizione,
and have an associated value. e possiedono un valore associato.
```lua ```lua
groups = {cracky = 3, wood = 1} groups = {cracky = 3, wood = 1}
``` ```
There are several reasons you use groups. Ci sono diverse ragioni per cui usare i gruppi.
Firstly, groups are used to describe properties such as dig types and flammability. In primis, vengono utilizzati per descrivere proprietà come friabilità e infiammabilità.
Secondly, groups can be used in a craft recipe instead of an item name to allow In secundis, possono essere usati in una ricetta al posto di un nome oggetto per permettere
any item in the group to be used. a qualsiasi oggetto nel gruppo di essere utilizzato.
```lua ```lua
minetest.register_craft({ minetest.register_craft({
type = "shapeless", type = "shapeless",
output = "mymod:diamond_thing 3", output = "miamod:diamante_qualcosa 3",
recipe = {"group:wood", "mymod:diamond"} recipe = {"group:wood", "miamod:diamante"}
}) })
``` ```
## Tools, Capabilities, and Dig Types ## Strumenti, Capacità e Friabilità
Dig types are groups which are used to define how strong a node is when dug Le friabilità sono dei gruppi particolari utilizzati per definire la resistenza di un nodo
with different tools. quando scavato con un determinato strumento.
A dig type group with a higher associated value means the node is easier Una friabilità elevata equivale a una maggior facilità e velocità nel romperlo.
and quicker to cut. È possibile combinarne di più tipi per permettere al nodo di essere distrutto da più tipi di strumento.
It's possible to combine multiple dig types to allow the more efficient use Un nodo senza friabilità non può essere distrutto da nessuno strumento.
of multiple types of tools.
A node with no dig types cannot be dug by any tools. | 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 |
| Group | Best Tool | Description | Ogni strumento possiede poi delle capacità (capability).
|--------|-----------|-------------| Una capacità include una lista di friabilità supportate, e proprietà associate
| crumbly | spade | Dirt, sand | per ognuna di esse come la velocità di scavata e il livello di usura.
| cracky | pickaxe | Tough (but brittle) stuff like stone | Gli strumenti possono anche avere una durezza massima supportata per ogni tipo;
| snappy | *any* | Can be cut using fine tools;<br>e.g. leaves, smallplants, wire, sheets of metal | ciò serve a prevenire che strumenti più deboli possano rompere nodi meno friabili.
| choppy | axe | Can be cut using a sharp force; e.g. trees, wooden planks | È poi molto comune che uno strumento includa tutte le friabilità nelle sue capacità,
| fleshy | sword | Living things like animals and the player.<br>This could imply some blood effects when hitting. | con quelle meno adatte equivalenti a proprietà inefficienti.
| explody | ? | Especially prone to explosions | Se l'oggetto impugnato dal giocatore non ha una capacità esplicitata,
| oddly_breakable_by_hand | *any* | Torches and such - very quick to dig | verrà allora usata quella della mano.
Every tool has a tool capability.
A capability includes a list of supported dig types, and associated properties
for each type such as dig times and the amount of wear.
Tools can also have a maximum supported hardness for each type, which makes
it possible to prevent weaker tools from digging harder nodes.
It's very common for tools to include all dig types in their capabilities,
with the less suitable ones having very inefficient properties.
If the item a player is currently wielding doesn't have an explicit tool
capability, then the capability of the current hand is used instead.
```lua ```lua
minetest.register_tool("mymod:tool", { minetest.register_tool("miamod:strumento", {
description = "My Tool", description = "Il mio strumento",
inventory_image = "mymod_tool.png", inventory_image = "miamod_strumento.png",
tool_capabilities = { tool_capabilities = {
full_punch_interval = 1.5, full_punch_interval = 1.5,
max_drop_level = 1, max_drop_level = 1,
@ -376,7 +365,6 @@ minetest.register_tool("mymod:tool", {
}, },
}) })
``` ```
I gruppi limite (groupcaps) sono una lista delle friabilità supportate dallo strumento.
Groupcaps is the list of supported dig types for digging nodes. I gruppi di danno invece (damage_groups) servono a controllare come uno strumento (esterno) danneggia
Damage groups are for controlling how tools damage objects, which will be quell'oggetto. Quest'ultimi verranno discussi in seguito nel capitolo Oggetti, Giocatori e Entità.
discussed later in the Objects, Players, and Entities chapter.