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

ItemStacks and Inventories - Italian translation added

Browse Source
This commit is contained in:
Marco 2020-06-12 19:14:49 +02:00 committed by rubenwardy
parent 4f00b12b1d
commit 03625f6448
1 changed files with 154 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

306
_it/items/inventories.md Normal file → Executable file
View File

@ -1,68 +1,66 @@
--- ---
title: ItemStacks and Inventories title: ItemStack e Inventari
layout: default layout: default
root: ../.. root: ../..
idx: 2.4 idx: 2.4
description: Manipulate InvRefs and ItemStacks description: Manipola gli InvRef e gli ItemStack
redirect_from: redirect_from:
- /en/chapters/inventories.html - /it/chapters/inventories.html
- /en/chapters/itemstacks.html - /it/chapters/itemstacks.html
- /en/inventories/inventories.html - /it/inventories/inventories.html
- /en/inventories/itemstacks.html - /it/inventories/itemstacks.html
--- ---
## Introduction <!-- omit in toc --> ## Introduzione <!-- omit in toc -->
In this chapter, you will learn how to use and manipulate inventories, whether In questo capitolo, imparerai come usare e manipolare gli inventari, siano essi quelli
that be a player inventory, a node inventory, or a detached inventory. di un giocatore, di un nodo o a sé stanti.
- [What are ItemStacks and Inventories?](#what-are-itemstacks-and-inventories) - [Cosa sono gli ItemStack e gli inventari?](#cosa-sono-gli-itemstack-e-gli-inventari)
- [ItemStacks](#itemstacks) - [ItemStack](#itemstack)
- [Inventory Locations](#inventory-locations) - [Collocazione inventari](#collocazione-inventari)
- [Lists](#lists) - [Liste](#liste)
- [Size and Width](#size-and-width) - [Dimensione e ampiezza](#dimensione-e-ampiezza)
- [Checking Contents](#checking-contents) - [Controllare il contenuto](#controllare-il-contenuto)
- [Modifying Inventories and ItemStacks](#modifying-inventories-and-itemstacks) - [Modificare inventari e ItemStack](#modificare-inventari-e-itemstack)
- [Adding to a List](#adding-to-a-list) - [Aggiungere a una lista](#aggiungere-a-una-lista)
- [Taking Items](#taking-items) - [Rimuovere oggetti](#rimuovere-oggetti)
- [Manipulating Stacks](#manipulating-stacks) - [Manipolazione pile](#manipolazione-pile)
- [Wear](#wear) - [Usura](#usura)
- [Lua Tables](#lua-tables) - [Tabelle Lua](#tabelle-lua)
## What are ItemStacks and Inventories? ## Cosa sono gli ItemStack e gli inventari?
An ItemStack is the data behind a single cell in an inventory. Un ItemStack (*pila di oggetti*) è il dato dietro una singola cella di un inventario.
An *inventory* is a collection of *inventory lists*, each of which Un *inventario* è una collezione di *liste* apposite, ognuna delle quali è una griglia
is a 2D grid of ItemStacks. 2D di ItemStack.
Inventory lists are simply called *lists* in the context Lo scopo di un inventario è quello di raggruppare più liste in un singolo oggetto (l'inventario appunto),
of inventories. in quanto a ogni giocatore e a ogni nodo può essere associato massimo un inventario.
The point of an inventory is to allow multiple grids when Players
and Nodes only have at most one inventory in them.
## ItemStacks ## ItemStack
ItemStacks have three components to them. Gli ItemStack sono composti da quattro parametri: nome, quantità, durabilità e metadati.
The item name may be the item name of a registered item, an alias, or an unknown Il nome dell'oggetto può essere il nome di un oggetto registrato, di uno sconosciuto (non registrato)
item name. o un alias.
Unknown items are common when users uninstall mods, or when mods remove items without Gli oggetti sconosciuti sono tipici di quando si disinstallano le mod, o quando le mod rimuovono
precautions, such as registering aliases. degli oggetti senza nessun accorgimento, tipo senza registrarne un alias.
```lua ```lua
print(stack:get_name()) print(stack:get_name())
stack:set_name("default:dirt") stack:set_name("default:dirt")
if not stack:is_known() then if not stack:is_known() then
print("Is an unknown item!") print("È un oggetto sconosciuto!")
end end
``` ```
The count will always be 0 or greater. La quantità sarà sempre 0 o maggiore.
Through normal gameplay, the count should be no more than the maximum stack size Durante una normale sessione di gioco, la quantità non dovrebbe mai essere maggiore della dimensione
of the item - `stack_max`. massima della pila dell'oggetto - `stack_max`.
However, admin commands and buggy mods may result in stacks exceeding the maximum Tuttavia, comandi da amministratore e mod fallate potrebbero portare a oggetti impilati che superano
size. la grandezza massima.
```lua ```lua
print(stack:get_stack_max()) print(stack:get_stack_max())
@ -71,14 +69,14 @@ print(stack:get_stack_max())
An ItemStack can be empty, in which case the count will be 0. Un ItemStack può essere vuoto, nel qual caso avrà come quantità 0.
```lua ```lua
print(stack:get_count()) print(stack:get_count())
stack:set_count(10) stack:set_count(10)
``` ```
ItemStacks can be constructed in multiple ways using the ItemStack function. Gli ItemStack possono essere creati in diversi modi usando la funzione ItemStack.
```lua ```lua
ItemStack() -- name="", count=0 ItemStack() -- name="", count=0
@ -87,255 +85,259 @@ ItemStack("default:stone 30")
ItemStack({ name = "default:wood", count = 10 }) ItemStack({ name = "default:wood", count = 10 })
``` ```
Item metadata is an unlimited key-value store for data about the item. I metadati di un oggetto sono una o più coppie chiave-valore custodite in esso.
Key-value means that you use a name (called the key) to access the data (called the value). Chiave-valore significa che si usa un nome (la chiave) per accedere al dato corrispettivo (il valore).
Some keys have special meaning, such as `description` which is used to have a per-stack Alcune chiavi hanno significati predefiniti, come `description` che è usato per specificare la descrizione
item description. di una pila di oggetti.
This will be covered in more detail in the Metadata and Storage chapter. Questo sarà trattato più dettagliatamente nel capitolo Metadati e Storage.
## Inventory Locations ## Collocazione inventari
An Inventory Location is where and how the inventory is stored. La collocazione di un inventario è dove e come un inventario viene conservato.
There are three types of inventory location: player, node, and detached. Ci sono tre tipi di collocazione: giocatore, nodo e separata.
An inventory is directly tied to one and only one location - updating the inventory Un inventario è direttamente legato a una e a una sola collocazione.
will cause it to update immediately.
Node inventories are related to the position of a specific node, such as a chest. Gli inventari collocati nei nodi sono associati alle coordinate di un nodo specifico, come le casse.
The node must be loaded because it is stored in [node metadata](../map/storage.html#metadata). Il nodo deve essere stato caricato perché viene salvato [nei suoi metadati](../map/storage.html#metadata).
```lua ```lua
local inv = minetest.get_inventory({ type="node", pos={x=1, y=2, z=3} }) local inv = minetest.get_inventory({ type="node", pos={x=1, y=2, z=3} })
``` ```
The above obtains an *inventory reference*, commonly referred to as *InvRef*. L'esempio in alto ottiene il *riferimento a un inventario*, comunemente definito *InvRef*.
Inventory references are used to manipulate an inventory. Questi riferimenti sono usati per manipolare l'inventario, e son chiamati così perché i dati
*Reference* means that the data isn't actually stored inside that object, non sono davvero salvati dentro all'oggetto (in questo caso "inv"), bensì *puntano* a quei dati.
but the object instead directly updates the data in-place. In questo modo, modificando "inv", stiamo in verità modificando l'inventario.
The location of an inventory reference can be found like so: La collocazione di tali riferimenti può essere ottenuta nel seguente modo:
```lua ```lua
local location = inv:get_location() local location = inv:get_location()
``` ```
Player inventories can be obtained similarly or using a player reference. Gli inventari dei giocatori si ottengono in maniera simile, oppure usando il riferimento
The player must be online to access their inventory. a un giocatore (*PlayerRef*). In entrambi casi, il giocatore deve essere connesso.
```lua ```lua
local inv = minetest.get_inventory({ type="player", name="player1" }) local inv = minetest.get_inventory({ type="player", name="player1" })
-- or -- oppure
local inv = player:get_inventory() local inv = player:get_inventory()
``` ```
A detached inventory is one which is independent of players or nodes. Gli inventari separati, infine, sono quelli non collegati né a nodi né a giocatori,
Detached inventories also don't save over a restart. e al contrario degli altri, vengono persi dopo un riavvio.
Detached inventories need to be created before they can be used -
this will be covered later.
```lua ```lua
local inv = minetest.get_inventory({ local inv = minetest.get_inventory({
type="detached", name="inventory_name" }) type="detached", name="nome_inventario" })
``` ```
Unlike the other types of inventory, you must first create a detached inventory: Un'ulteriore differenza, è che gli inventari separati devono essere creati prima di poterci accedere:
```lua ```lua
minetest.create_detached_inventory("inventory_name") minetest.create_detached_inventory("inventory_name")
``` ```
The create_detached_inventory function accepts 3 arguments, only first is required. La funzione create_detached_inventory accetta 3 parametri, di cui solo il primo - il nome - è necessario.
The second argument takes a table of callbacks, which can be used to control how Il secondo parametro prende una tabella di callback, che possono essere utilizzati
players interact with the inventory: per controllare come i giocatori interagiscono con l'inventario:
```lua ```lua
-- Input only detached inventory -- Input only detached inventory
minetest.create_detached_inventory("inventory_name", { minetest.create_detached_inventory("inventory_name", {
allow_move = function(inv, from_list, from_index, to_list, to_index, count, player) allow_move = function(inv, from_list, from_index, to_list, to_index, count, player)
return count -- allow moving return count -- permette di spostare gli oggetti
end, end,
allow_put = function(inv, listname, index, stack, player) allow_put = function(inv, listname, index, stack, player)
return stack:get_count() -- allow putting return stack:get_count() -- permette di inserirli
end, end,
allow_take = function(inv, listname, index, stack, player) allow_take = function(inv, listname, index, stack, player)
return -1 -- don't allow taking return -1 -- non permette di rimuoverli
end, end,
on_put = function(inv, listname, index, stack, player) on_put = function(inv, listname, index, stack, player)
minetest.chat_send_all(player:get_player_name() .. minetest.chat_send_all(player:get_player_name() ..
" gave " .. stack:to_string() .. " ha messo " .. stack:to_string() ..
" to the donation chest at " .. minetest.pos_to_str(pos)) " nella cassa delle donazioni da " .. minetest.pos_to_string(player:get_pos()))
end, end,
}) })
``` ```
Permission callbacks - ie: those starting with `allow_`- return the number I callback dei permessi - quelle che iniziano con `allow_` - ritornano il numero
of items to transfer, with -1 being used to prevent transfer completely. degli oggetti da trasferire, e si usa -1 per impedirne del tutto l'azione.
Action callbacks - starting with `on_` - don't have a return value and I callback delle azioni - quelle che iniziano con `on_` - non ritornano invece alcun valore.
can't prevent transfers.
## Lists ## Liste
Inventory Lists are a concept used to allow multiple grids to be stored inside a single location. Le liste negli inventari permettono di disporre più griglie nello stesso luogo (l'inventario).
This is especially useful for the player as there are a number of common lists Esse sono particolarmente utili per il giocatore, e infatti di base ogni gioco possiede già
which all games have, such as the *main* inventory and *craft* slots. delle liste come *main* per il corpo principale dell'inventario e *craft* per l'area di fabbricazione.
### Size and Width ### Dimensione e ampiezza
Lists have a size, which is the total number of cells in the grid, and a width, Le liste hanno una dimensione, equivalente al numero totale di celle nella griglia, e un'ampiezza,
which is only used within the engine. che è usata esclusivamente dentro il motore di gioco: quando viene disegnato un inventario in una finestra,
The width of the list is not used when drawing the inventory in a window, infatti, il codice dietro di essa già determina che ampiezza usare.
because the code behind the window determines the width to use.
```lua ```lua
if inv:set_size("main", 32) then if inv:set_size("main", 32) then
inv:set_width("main", 8) inv:set_width("main", 8)
print("size: " .. inv.get_size("main")) print("dimensione: " .. inv.get_size("main"))
print("width: " .. inv:get_width("main")) print("ampiezza: " .. inv:get_width("main"))
else else
print("Error! Invalid itemname or size to set_size()") print("Errore! Nome dell'oggetto o dimensione non validi")
end end
``` ```
`set_size` will fail and return false if the listname or size is invalid. `set_size` non andrà in porto e ritornerà "false" se il nome della lista o la dimensione dichiarata
For example, the new size may be too small to fit all the current items non risultano valide.
in the inventory. Per esempio, la nuova dimensione potrebbe essere troppo piccola per contenere gli oggetti attualmente
presenti nell'inventario.
### Checking Contents ### Controllare il contenuto
`is_empty` can be used to see if a list contains any items: `is_empty` può essere usato per vedere se una lista contiene o meno degli oggetti:
```lua ```lua
if inv:is_empty("main") then if inv:is_empty("main") then
print("The list is empty!") print("La lista è vuota!")
end end
``` ```
`contains_item` can be used to see if a list contains a specific item. `contains_item` può invece essere usato per vedere se la lista contiene un oggetto specifico:
## Modifying Inventories and ItemStacks ```lua
if inv:contains_item("main", "default:stone") then
print("Ho trovato della pietra!")
end
```
### Adding to a List ## Modificare inventari e ItemStack
To add items to a list named `"main"` while respecting maximum stack sizes: ### Aggiungere a una lista
Per aggiungere degli oggetti a una lista (in questo caso "main") usiamo `add_item`. Nell'esempio
sottostante ci accertiamo anche di rispettare la dimensione:
```lua ```lua
local stack = ItemStack("default:stone 99") local stack = ItemStack("default:stone 99")
local leftover = inv:add_item("main", stack) local leftover = inv:add_item("main", stack)
if leftover:get_count() > 0 then if leftover:get_count() > 0 then
print("Inventory is full! " .. print("L'inventario è pieno! " ..
leftover:get_count() .. " items weren't added") leftover:get_count() .. " oggetti non sono stati aggiunti")
end end
``` ```
### Taking Items ### Rimuovere oggetti
To remove items from a list: Per rimuovere oggetti da una lista, `remove_item`:
```lua ```lua
local taken = inv:remove_item("main", stack) local taken = inv:remove_item("main", stack)
print("Took " .. taken:get_count()) print("Rimossi " .. taken:get_count())
``` ```
### Manipulating Stacks ### Manipolare pile
You can modify individual stacks by first getting them: Puoi modificare le singole pile prima ottenendole:
```lua ```lua
local stack = inv:get_stack(listname, 0) local stack = inv:get_stack(listname, 0)
``` ```
Then modifying them by setting properties or by using the methods which E poi modificandole impostando le nuove proprietà o usando i metodi che
respect `stack_size`: rispettano `stack_size`:
```lua ```lua
local stack = ItemStack("default:stone 50") local pila = ItemStack("default:stone 50")
local to_add = ItemStack("default:stone 100") local da_aggiungere = ItemStack("default:stone 100")
local leftover = stack:add_item(to_add) local resto = pila:add_item(da_aggiungere)
local taken = stack:take_item(19) local rimossi = pila:take_item(19)
print("Could not add" .. leftover:get_count() .. " of the items.") print("Impossibile aggiungere " .. resto:get_count() .. " degli oggetti.")
-- ^ will be 51 -- ^ sarà 51
print("Have " .. stack:get_count() .. " items") print("Hai " .. pila:get_count() .. " oggetti")
-- ^ will be 80 -- ^ sarà 80
-- min(50+100, stack_max) - 19 = 80 -- min(50+100, stack_max) - 19 = 80
-- where stack_max = 99 -- dove stack_max = 99
``` ```
`add_item` will add items to an ItemStack and return any that could not be added. `add_item` aggiungerà gli oggetti all'ItemStack e ritornerà quelli in eccesso.
`take_item` will take up to the number of items but may take less, and returns the stack taken. `take_item` rimuoverà gli oggetti indicati (o meno se ce ne sono meno), e ritornerà
l'ammontare rimosso.
Finally, set the item stack: Infine, si imposta la pila modificata:
```lua ```lua
inv:set_stack(listname, 0, stack) inv:set_stack(listname, 0, pila)
``` ```
## Wear ## Usura
Tools can have wear; wear shows a progress bar and makes the tool break when completely worn. Gli strumenti possono avere un livello di usura; l'usura è rappresentata da un barra progressiva
Wear is a number out of 65535; the higher it is, the more worn the tool is. e fa rompere lo strumento quando completamente logorato.
L'usura è un numero da 0 a 65535; più è alto, più è consumato l'oggetto.
Wear can be manipulated using `add_wear()`, `get_wear()`, and `set_wear(wear)`. Il livello di usura può essere manipolato usando `add_wear()`, `get_wear()`, e `set_wear(wear)`.
```lua ```lua
local stack = ItemStack("default:pick_mese") local pila = ItemStack("default:pick_mese")
local max_uses = 10 local usi_massimi = 10
-- This is done automatically when you use a tool that digs things -- Questo viene fatto in automatico quando usi uno strumento che scava cose.
-- It increases the wear of an item by one use. -- Aumenta l'usura dell'oggetto dopo un uso
stack:add_wear(65535 / (max_uses - 1)) pila:add_wear(65535 / (usi_massimi - 1))
``` ```
When digging a node, the amount of wear a tool gets may depend on the node Quando scavi un nodo, l'incremento di usura di uno strumento dipende da che tipo di nodo è.
being dug. So max_uses varies depending on what is being dug. Di conseguenza, `usi_massimi` varia a seconda di cos'è stato scavato.
## Lua Tables ## Tabelle Lua
ItemStacks and Inventories can be converted to and from tables. Gli ItemStack e gli inventari possono essere convertiti in/dalle tabelle.
This is useful for copying and bulk operations. Questo è utile per operazioni di copiatura e immagazzinaggio.
```lua ```lua
-- Entire inventory -- Inventario intero
local data = inv1:get_lists() local data = inv1:get_lists()
inv2:set_lists(data) inv2:set_lists(data)
-- One list -- Una lista
local listdata = inv1:get_list("main") local listdata = inv1:get_list("main")
inv2:set_list("main", listdata) inv2:set_list("main", listdata)
``` ```
The table of lists returned by `get_lists()` will be in this form: La tabella di liste ritornata da `get_lists()` sarà nel seguente formato:
```lua ```lua
{ {
list_one = { lista_uno = {
ItemStack, ItemStack,
ItemStack, ItemStack,
ItemStack, ItemStack,
ItemStack, ItemStack,
-- inv:get_size("list_one") elements -- inv:get_size("lista_uno") elementi
}, },
list_two = { lista_due = {
ItemStack, ItemStack,
ItemStack, ItemStack,
ItemStack, ItemStack,
ItemStack, ItemStack,
-- inv:get_size("list_two") elements -- inv:get_size("lista_due") elementi
} }
} }
``` ```
`get_list()` will return a single list as just a list of ItemStacks. `get_list()` ritornerà una lista singola fatta di ItemStack.
One important thing to note is that the set methods above don't change the size Una cosa importante da sottolineare è che i metodi `set` qui in alto non cambiano
of the lists. la dimensione delle liste.
This means that you can clear a list by setting it to an empty table and it won't Questo significa che si può svuotare una lista dichiarandola uguale a una tabella vuota,
decrease in size: e la sua dimensione tuttavia non cambierà:
```lua ```lua
inv:set_list("main", {}) inv:set_list("main", {})