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

Storage and Metadata - Italian translation added

Browse Source
This commit is contained in:
Marco 2020-07-02 14:34:49 +02:00 committed by rubenwardy
parent 073bdaeb56
commit 35d9bf5a91
3 changed files with 96 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
_it/items/inventories.md
View File

@ -89,7 +89,7 @@ I metadati di un oggetto sono una o più coppie chiave-valore custodite in esso.
Chiave-valore significa che si usa un nome (la chiave) per accedere al dato corrispettivo (il valore). Chiave-valore significa che si usa un nome (la chiave) per accedere al dato corrispettivo (il valore).
Alcune chiavi hanno significati predefiniti, come `description` che è usato per specificare la descrizione Alcune chiavi hanno significati predefiniti, come `description` che è usato per specificare la descrizione
di una pila di oggetti. di una pila di oggetti.
Questo sarà trattato più dettagliatamente nel capitolo Metadati e Storage. Questo sarà trattato più in dettaglio nel capitolo Storaggio e Metadati.
## Collocazione inventari ## Collocazione inventari

216
_it/map/storage.md
View File

@ -1,73 +1,65 @@
--- ---
title: Storage and Metadata title: Storaggio e metadati
layout: default layout: default
root: ../.. root: ../..
idx: 3.3 idx: 3.3
description: Mod Storage, NodeMetaRef (get_meta). description: Scopri come funziona lo spazio d'archiviazione delle mod e come usare i metadati per passare informazioni.
redirect_from: redirect_from:
- /en/chapters/node_metadata.html - /it/chapters/node_metadata.html
- /en/map/node_metadata.html - /it/map/node_metadata.html
--- ---
## Introduction <!-- omit in toc --> ## Introduction <!-- omit in toc -->
In this chapter, you will learn how you can store data. In questo capitolo imparerai i vari modi per immagazzinare dati.
- [Metadata](#metadata) - [Metadati](#metadati)
- [What is Metadata?](#what-is-metadata) - [Cos'è un metadato?](#cos-e-un-metadato)
- [Obtaining a Metadata Object](#obtaining-a-metadata-object) - [Ottenere i metadati di un oggetto](#ottenere-i-metadati-di-un-oggetto)
- [Reading and Writing](#reading-and-writing) - [Lettura e scrittura](#lettura-e-scrittura)
- [Special Keys](#special-keys) - [Chiavi speciali](#chiavi-speciali)
- [Storing Tables](#storing-tables) - [Immagazzinare tabelle](#immagazzinare-tabelle)
- [Private Metadata](#private-metadata) - [Metadati privati](#metadati-privati)
- [Lua Tables](#lua-tables) - [Tabelle Lua](#tabelle-lua)
- [Mod Storage](#mod-storage) - [Storaggio mod](#storaggio-mod)
- [Databases](#databases) - [Database](#database)
- [Deciding Which to Use](#deciding-which-to-use) - [Decidere quale usare](#decidere-quale-usare)
- [Your Turn](#your-turn) - [Il tuo turno](#il-tuo-turno)
## Metadata ## Metadati
### What is Metadata? ### Cos'è un metadato?
In Minetest, Metadata is a key-value store used to attach custom data to something. In Minetest, un metadato è una coppia chiave-valore usata per collegare dei dati a qualcosa.
You can use metadata to store information against a Node, Player, or ItemStack. Puoi usare i metadati per salvare informazioni nei nodi, nei giocatori o negli ItemStack.
Each type of metadata uses the exact same API. Ogni tipo di metadato usa la stessa identica API.
Metadata stores values as strings, but there are a number of methods to Ognuno di essi salva i valori come stringhe, ma ci sono comunque dei metodi per convertire e salvare altri tipi di primitivi.
convert and store other primitive types.
Some keys in metadata may have special meaning. Per evitare conflitti con altre mod, dovresti usare la nomenclatura convenzionale per le chiavi: `nomemod:nomechiave`.
For example, `infotext` in node metadata is used to store the tooltip which shows Alcune chiavi hanno invece un significato speciale, come vedremo più in basso.
when hovering over the node using the crosshair.
To avoid conflicts with other mods, you should use the standard namespace
convention for keys: `modname:keyname`.
The exception is for conventional data such as the owner name which is stored as
`owner`.
Metadata is data about data. Ricorda che i metadati sono dati riguardo altri dati.
The data itself, such as a node's type or an stack's count, is not metadata. Il dato in sé, come il tipo di un nodo o la quantità di un ItemStack, non rientra perciò nella definizione.
### Obtaining a Metadata Object ### Ottenere i metadati di un oggetto
If you know the position of a node, you can retrieve its metadata: Se si conosce la posizione di un nodo, si possono ottenere i suoi metadati:
```lua ```lua
local meta = minetest.get_meta({ x = 1, y = 2, z = 3 }) local meta = minetest.get_meta({ x = 1, y = 2, z = 3 })
``` ```
Player and ItemStack metadata are obtained using `get_meta()`: Quelli dei giocatori e degli ItemStack invece sono ottenuti tramite `get_meta()`:
```lua ```lua
local pmeta = player:get_meta() local p_meta = player:get_meta()
local imeta = stack:get_meta() local i_meta = pila:get_meta()
``` ```
### Reading and Writing ### Lettura e scrittura
In most cases, `get_<type>()` and `set_<type>()` methods will be used to read Nella maggior parte dei casi, per leggere e scrivere metadati saranno usati i metodi `get_<type>()` e `set_<type>()`.
and write to meta.
Metadata stores strings, so the string methods will directly set and get the value.
```lua ```lua
print(meta:get_string("foo")) --> "" print(meta:get_string("foo")) --> ""
@ -75,15 +67,12 @@ meta:set_string("foo", "bar")
print(meta:get_string("foo")) --> "bar" print(meta:get_string("foo")) --> "bar"
``` ```
All of the typed getters will return a neutral default value if the key doesn't Tutti i getter ritorneranno un valore di default se la chiave non esiste, rispettivamente `""` per le stringhe e `0` per gli interi.
exist, such as `""` or `0`. Si può inoltre usare `get()` per ritornare o una stringa o nil.
You can use `get()` to return a string or nil.
As Metadata is a reference, any changes will be updated to the source automatically. Come gli inventari, anche i metadati sono riferimenti: ogni cambiamento applicato ad essi, cambierà la fonte originale.
ItemStacks aren't references however, so you'll need to update the itemstack in the
inventory.
The non-typed getters and setters will convert to and from strings: Inoltre, se è possibile convertire un intero in stringa e viceversa, basterà cambiare `get_int`/`get_string` per ottenerne la versione corrispondente:
```lua ```lua
print(meta:get_int("count")) --> 0 print(meta:get_int("count")) --> 0
@ -92,48 +81,42 @@ print(meta:get_int("count")) --> 3
print(meta:get_string("count")) --> "3" print(meta:get_string("count")) --> "3"
``` ```
### Special Keys ### Chiavi speciali
`infotext` is used in Node Metadata to show a tooltip when hovering the crosshair over a node. `infotext` è usato nei nodi per mostrare una porzione di testo al passare il mirino sopra il nodo.
This is useful when showing the ownership or status of a node. Questo è utile, per esempio, per mostrare lo stato o il proprietario di un nodo.
`description` is used in ItemStack Metadata to override the description when `description` è usato negli ItemStack per sovrascrivere la descrizione al passare il mouse sopra l'oggetto in un formspec (come l'inventario, li vedremo più avanti).
hovering over the stack in an inventory. È possibile utilizzare `minetest.colorize()` per cambiarne il colore.
You can use colours by encoding them with `minetest.colorize()`.
`owner` is a common key used to store the username of the player that owns the `owner` è una chiave comune, usata per immagazzinare il nome del giocatore a cui appartiene l'oggetto o il nodo.
item or node.
### Storing Tables ### Immagazzinare tabelle
Tables must be converted to strings before they can be stored. Le tabelle devono essere convertite in stringhe prima di essere immagazzinate.
Minetest offers two formats for doing this: Lua and JSON. Minetest offre due formati per fare ciò: Lua e JSON.
The Lua method tends to be a lot faster and matches the format Lua Quello in Lua tende a essere molto più veloce e corrisponde al formato usato da Lua per le tabelle, mentre JSON è un formato più standard, con una miglior struttura, e che ben si presta per scambiare informazioni con un altro programma.
uses for tables, while JSON is a more standard format, is better
structured, and is well suited when you need to exchange information
with another program.
```lua ```lua
local data = { username = "player1", score = 1234 } local data = { username = "utente1", score = 1234 }
meta:set_string("foo", minetest.serialize(data)) meta:set_string("foo", minetest.serialize(data))
data = minetest.deserialize(minetest:get_string("foo")) data = minetest.deserialize(minetest:get_string("foo"))
``` ```
### Private Metadata ### Metadati privati
Entries in Node Metadata can be marked as private, and not sent to the client. Le voci nei metadati di un nodo possono essere segnate come private, senza venire quindi inviate al client (al contrario delle normali).
Entries not marked as private will be sent to the client.
```lua ```lua
meta:set_string("secret", "asd34dn") meta:set_string("segreto", "asd34dn")
meta:mark_as_private("secret") meta:mark_as_private("segreto")
``` ```
### Lua Tables ### Tabelle Lua
You can convert to and from Lua tables using `to_table` and `from_table`: Le tabelle possono essere convertite da/a stringhe nei metadati tramite `to_table` e `from_table`:
```lua ```lua
local tmp = meta:to_table() local tmp = meta:to_table()
@ -141,107 +124,94 @@ tmp.foo = "bar"
meta:from_table(tmp) meta:from_table(tmp)
``` ```
## Mod Storage ## Storaggio Mod
Mod storage uses the exact same API as Metadata, although it's not technically Lo spazio d'archiviazione della mod (*storage*) usa la stessa identica API dei metadati, anche se non sono tecnicamente la stessa cosa.
Metadata. Il primo infatti è per mod, e può essere ottenuto solo durante l'inizializzazione - appunto - della mod.
Mod storage is per-mod, and can only be obtained during load time in order to
know which mod is requesting it.
```lua ```lua
local storage = minetest.get_mod_storage() local memoria = minetest.get_mod_storage()
``` ```
You can now manipulate the storage just like metadata: Nell'esempio è ora possibile manipolare lo spazio d'archiviazione come se fosse un metadato:
```lua ```lua
storage:set_string("foo", "bar") memoria:set_string("foo", "bar")
``` ```
## Databases ## Database
If the mod is likely to be used on a server and will store lots of data, Se la mod ha buone probabilità di essere usata su un server e tenere traccia di un sacco di dati, è buona norma offrire un database come metodo di storaggio.
it's a good idea to offer a database storage method. Dovresti rendere ciò opzionale, separando il come i dati vengono salvati e il dove vengono usati.
You should make this optional by separating how the data is stored and where
it is used.
```lua ```lua
local backend local backend
if use_database then if use_database then
backend = backend =
dofile(minetest.get_modpath("mymod") .. "/backend_sqlite.lua") dofile(minetest.get_modpath("miamod") .. "/backend_sqlite.lua")
else else
backend = backend =
dofile(minetest.get_modpath("mymod") .. "/backend_storage.lua") dofile(minetest.get_modpath("miamod") .. "/backend_storage.lua")
end end
backend.get_foo("a") backend.get_foo("a")
backend.set_foo("a", { score = 3 }) backend.set_foo("a", { score = 3 })
``` ```
The backend_storage.lua file should include a mod storage implementation: Il file `backend_storage.lua` dell'esempio (puoi nominarlo come vuoi) dovrebbe includere l'implementazione del metodo di storaggio:
```lua ```lua
local storage = minetest.get_mod_storage() local memoria = minetest.get_mod_storage()
local backend = {} local backend = {}
function backend.set_foo(key, value) function backend.set_foo(key, value)
storage:set_string(key, minetest.serialize(value)) memoria:set_string(key, minetest.serialize(value))
end end
function backend.get_foo(key, value) function backend.get_foo(key, value)
return minetest.deserialize(storage:get_string(key)) return minetest.deserialize(memoria:get_string(key))
end end
return backend return backend
``` ```
The backend_sqlite would do a similar thing, but use the Lua *lsqlite3* library Il file `backend_sqlite.lua` dovrebbe fare una cosa simile, ma utilizzando la libreria Lua *lsqlite3* al posto della memoria d'archiviazione interna.
instead of mod storage.
Using a database such as SQLite requires using an insecure environment. Usare un database come SQLite richiede l'utilizzo di un ambiente non sicuro (*insecure environment*).
An insecure environment is a table that is only available to mods Un ambiente non sicuro è una tabella disponibile solamente alle mod con accesso esplicito dato dall'utente, e contiene una copia meno limitata della API Lua, che potrebbe essere abusata da mod con intenzioni malevole.
explicitly whitelisted by the user, and it contains a less restricted Gli ambienti non sicuri saranno trattati più nel dettaglio nel capitolo sulla [Sicurezza](../quality/security.html).
copy of the Lua API which could be abused if available to malicious mods.
Insecure environments will be covered in more detail in the
[Security](../quality/security.html) chapter.
```lua ```lua
local ie = minetest.request_insecure_environment() local amb_nonsicuro = minetest.request_insecure_environment()
assert(ie, "Please add mymod to secure.trusted_mods in the settings") assert(amb_nonsicuro, "Per favore aggiungi miamod a secure.trusted_mods nelle impostazioni")
local _sql = ie.require("lsqlite3") local _sql = amb_nonsicuro.require("lsqlite3")
-- Prevent other mods from using the global sqlite3 library -- Previene che altre mod usino la libreria globale sqlite3
if sqlite3 then if sqlite3 then
sqlite3 = nil sqlite3 = nil
end end
``` ```
Teaching about SQL or how to use the lsqlite3 library is out of scope for this book. Spiegare il funzionamento di SQL o della libreria lsqlite non rientra nell'obiettivo di questo libro.
## Deciding Which to Use ## Decidere quale usare
The type of method you use depends on what the data is about, Il tipo di metodo che si sceglie di utilizzare dipende dal tipo di dati trattati, come sono formattati e quanto sono grandi.
how it is formatted, and how large it is. In linea di massima, i dati piccoli vanno fino ai 10KB, quelli medi 10MB, e quelli grandi oltre i 10MB.
As a guideline, small data is up to 10K, medium data is up to 10MB, and large
data is any size above that.
Node metadata is a good choice when you need to store node-related data. I metadati dei nodi sono un'ottima scelta quando si vogliono immagazzinare dati relativi al nodo.
Storing medium data is fairly efficient if you make it private. Inserirne di medi (quindi massimo 10MB) è abbastanza efficiente se si rendono privati.
Item metadata should not be used to store anything but small amounts of data as it is not Quelli degli oggetti invece dovrebbero essere usati solo per piccole quantità di dati e non è possibile evitare di inviarli al client.
possible to avoid sending it to the client. I dati, poi, saranno anche copiati ogni volta che la pila viene spostata o ne viene fatto accesso tramite Lua.
The data will also be copied every time the stack is moved, or accessed from Lua.
Mod storage is good for medium data but writing large data may be inefficient. La memoria interna della mod va bene per i dati di medie dimensioni, tuttavia provare a salvarne di grandi potrebbe rivelarsi inefficiente.
It's better to use a database for large data to avoid having to write all the È meglio usare un database per le grandi porzioni di dati, onde evitare di dover sovrascrivere tutti i dati a ogni salvataggio.
data out on every save.
Databases are only viable for servers due to the I database sono fattibili solo per i server a causa della necessità di lasciar passare la mod nell'ambiente non sicuro.
need to whitelist the mod to access an insecure environment. Si prestano bene per i grandi ammontare di dati.
They're well suited for large data sets.
## Your Turn ## Il tuo turno
* Make a node which disappears after it has been punched five times. * Crea un nodo che sparisce dopo essere stato colpito cinque volte.
(Use `on_punch` in the node definition and `minetest.set_node`.) (Usa `on_punch` nella definizione del nodo e `minetest.set_node`)

4
_it/map/timers.md
View File

@ -16,11 +16,11 @@ Minetest fornisce due metodi per fare ciò: gli ABM (*Active Block Modifiers*, M
Gli ABM scansionano tutti i Blocchi Mappa alla ricerca dei nodi che rientrano nei canoni: Gli ABM scansionano tutti i Blocchi Mappa alla ricerca dei nodi che rientrano nei canoni:
essi sono quindi ottimali per quei nodi che si trovano con frequenza in giro per il mondo, come l'erba. essi sono quindi ottimali per quei nodi che si trovano con frequenza in giro per il mondo, come l'erba.
Possiedono un alto consumo della CPU, senza invece pressoché impattare sulla memoria e lo storage. Possiedono un alto consumo della CPU, senza invece pressoché impattare sulla memoria e lo spazio d'archiviazione.
Per i nodi invece non troppo comuni o che già usano metadati, come le fornaci e i macchinari, dovrebbero venire impiegati i timer. Per i nodi invece non troppo comuni o che già usano metadati, come le fornaci e i macchinari, dovrebbero venire impiegati i timer.
I timer dei nodi tengon traccia dei timer accodati in ogni Blocco Mappa, eseguendoli quando raggiungono lo zero. I timer dei nodi tengon traccia dei timer accodati in ogni Blocco Mappa, eseguendoli quando raggiungono lo zero.
Ciò significa che non hanno bisogno di cercare tra tutti i nodi caricati per trovare un match, bensì, richiedendo un po' più di memoria e storage, vanno alla ricerca dei soli nodi con un timer in corso. Ciò significa che non hanno bisogno di cercare tra tutti i nodi caricati per trovare un match, bensì, richiedendo un po' più di memoria e spazio d'archiviazione, vanno alla ricerca dei soli nodi con un timer in corso.
- [Timer dei nodi](#timer-dei-nodi) - [Timer dei nodi](#timer-dei-nodi)
- [ABM: modificatori di blocchi attivi](#abm-modificatori-di-blocchi-attivi) - [ABM: modificatori di blocchi attivi](#abm-modificatori-di-blocchi-attivi)