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

IT | translation chapter + cleanup

Browse Source
This commit is contained in:
Zughy 2022-06-19 22:18:53 +00:00
parent f6c8a42696
commit f9bc3f1fc0
3 changed files with 123 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
_it/basics/lua.md
View File

@ -12,14 +12,10 @@ redirect_from: /it/chapters/lua.html
In questo capitolo parleremo della programmazione in Lua, degli strumenti necessari, e tratteremo alcune tecniche che troverai probabilmente utili. In questo capitolo parleremo della programmazione in Lua, degli strumenti necessari, e tratteremo alcune tecniche che troverai probabilmente utili.
- [Programmare](#programmare) - [Programmare](#programmare)
- [Programmare in Lua](#programmare-in-lua)
- [Editor di codice](#editor-di-codice) - [Editor di codice](#editor-di-codice)
- [Programmare in Lua](#programmare-in-lua)
- [Flusso del programma](#flusso-del-programma)
- [Tipi di variabili](#tipi-di-variabili)
- [Operatori matematici](#operatori-matematici)
- [Selezione](#selezione)
- [Operatori logici](#operatori-logici)
- [Portata locale e globale](#portata-locale-e-globale) - [Portata locale e globale](#portata-locale-e-globale)
- [Precedenza alla portata locale](#precedenza-alla-portata-locale)
- [Inclusione di altri script Lua](#inclusione-di-altri-script-lua) - [Inclusione di altri script Lua](#inclusione-di-altri-script-lua)
@ -35,6 +31,11 @@ Insegnarti i processi logici della programmazione non rientra nell'ambito di que
* [Programming with Mosh](https://www.youtube.com/user/programmingwithmosh) is * [Programming with Mosh](https://www.youtube.com/user/programmingwithmosh) is
a good YouTube series to learn programming. a good YouTube series to learn programming.
### Programmare in Lua
Neanche insegnarti come programmare in lua rientra nell'ambito di questo libro.
Tuttavia, se mastichi l'inglese puoi rifarti a quest'altro libro, ["Programming in Lua"](https://www.lua.org/pil/contents.html), per un'eccellente infarinatura sull'argomento. Se invece l'inglese non è il tuo forte, troverai comunque svariate guide in italiano in giro per la rete.
## Editor di codice ## Editor di codice
@ -70,117 +71,6 @@ Tra gli editor più famosi che ben si prestano a lavorare in Lua, troviamo:
(ne esistono ovviamente anche altri) (ne esistono ovviamente anche altri)
## Programmare in Lua
### Flusso del programma
I programmi sono una serie di comandi che vengono eseguiti uno dopo l'altro.
Chiamiamo questi comandi "istruzioni".
Il flusso del programma è il come queste istruzioni vengono eseguite, e a differenti tipi di flusso corrispondono comportamenti diversi.
Essi possono essere:
* Sequenziali: eseguono un'istruzione dopo l'altra, senza salti.
* Selettivi: saltano alcune sequenze a seconda delle condizioni.
* Iteranti: continuano a eseguire le stesse istruzioni finché una condizione non è soddisfatta.
Quindi, come vengono rappresentate le istruzioni in Lua?
```lua
local a = 2 -- Imposta 'a' a 2
local b = 2 -- Imposta 'b' a 2
local risultato = a + b -- Imposta 'risultato' ad a + b, cioè 4
a = a + 10
print("La somma è ".. risultato)
```
In quest'esempio, `a`, `b`, e `risultato` sono *variabili*. Le variabili locali si dichiarano tramite l'uso della parola chiave `local` (che vedremo tra poco), e assegnando eventualmente loro un valore iniziale.
Il simbolo `=` significa *assegnazione*, quindi `risultato = a + b` significa impostare "risultato" ad a + b.
Per quanto riguarda i nomi delle variabili, essi possono essere più lunghi di un carattere - al contrario che in matematica - come visto in `risultato`, e vale anche la pena notare che Lua è *case-sensitive* (differenzia maiuscole da minuscole); `A` è una variabile diversa da `a`.
### Tipi di variabili
Una variabile può equivalere solo a uno dei seguenti tipi e può cambiare tipo dopo l'assegnazione.
È buona pratica assicurarsi che sia sempre solo o nil o diversa da nil.
| Tipo | Descrizione | Esempio |
|----------|---------------------------------|----------------|
| Nil | Non inizializzata. La variabile è vuota, non ha valore | `local A`, `D = nil` |
| Numero | Un numero intero o decimale | `local A = 4` |
| Stringa | Una porzione di testo | `local D = "one two three"` |
| Booleano | Vero o falso (true, false) | `local is_true = false`, `local E = (1 == 1)` |
| Tabella | Liste | Spiegate sotto |
| Funzione | Può essere eseguita. Può richiedere input e ritornare un valore | `local result = func(1, 2, 3)` |
### Operatori matematici
Tra gli operatori di Lua ci sono:
| Simbolo | Scopo | Esempio |
|---------|--------------------|---------------------------|
| A + B | Addizione | 2 + 2 = 4 |
| A - B | Sottrazione | 2 - 10 = -8 |
| A * B | Moltiplicazione | 2 * 2 = 4 |
| A / B | Divisione | 100 / 50 = 2 |
| A ^ B | Potenze | 2 ^ 2 = 2<sup>2</sup> = 4 |
| A .. B | Concatena stringhe | "foo" .. "bar" = "foobar" |
Si tenga presente che questa non è comunque una lista esaustiva.
### Selezione
Il metodo di selezione più basico è il costrutto if.
Si presenta così:
```lua
local random_number = math.random(1, 100) -- Tra 1 e 100.
if random_number > 50 then
print("Woohoo!")
else
print("No!")
end
```
Questo esempio genera un numero casuale tra 1 e 100.
Stampa poi "Woohoo!" se il numero è superiore a 50, altrimenti stampa "No!".
### Operatori logici
Tra gli operatori logici di Lua ci sono:
| Simbolo | Scopo | Esempio |
|---------|--------------------------------------|-------------------------------------------------------------|
| A == B | Uguale a | 1 == 1 (true), 1 == 2 (false) |
| A ~= B | Non uguale a (diverso da) | 1 ~= 1 (false), 1 ~= 2 (true) |
| A > B | Maggiore di | 5 > 2 (true), 1 > 2 (false), 1 > 1 (false) |
| A < B | Minore di | 1 < 3 (true), 3 < 1 (false), 1 < 1 (false) |
| A >= B | Maggiore o uguale a | 5 >= 5 (true), 5 >= 3 (true), 5 >= 6 (false) |
| A <= B | Minore o uguale a | 3 <= 6 (true), 3 <= 3 (true) |
| A and B | E (entrambi devono essere veri) | (2 > 1) and (1 == 1) (true), (2 > 3) and (1 == 1) (false) |
| A or B | O (almeno uno dei due vero) | (2 > 1) or (1 == 2) (true), (2 > 4) or (1 == 3) (false) |
| not A | non vero | not (1 == 2) (true), not (1 == 1) (false) |
La lista non è esaustiva, e gli operatori possono essere combinati, come da esempio:
```lua
if not A and B then
print("Yay!")
end
```
Che stampa "Yay!" se `A` è falso e `B` vero.
Gli operatori logici e matematici funzionano esattamente allo stesso modo; entrambi accettano input e ritornano un valore che può essere immagazzinato. Per esempio:
```lua
local A = 5
local is_equal = (A == 5)
if is_equal then
print("È equivalente!")
end
```
## Portata locale e globale ## Portata locale e globale
L'essere locale o globale di una variabile determina da dove è possibile accederci. L'essere locale o globale di una variabile determina da dove è possibile accederci.
@ -216,6 +106,9 @@ one()
two() two()
``` ```
### Precedenza alla portata locale
Le variabili locali dovrebbero venire usate il più possibile, con le mod che creano al massimo una globale corrispondente al nome della mod. Le variabili locali dovrebbero venire usate il più possibile, con le mod che creano al massimo una globale corrispondente al nome della mod.
Crearne di ulteriori è considerato cattiva programmazione, e Minetest ci avviserà di ciò: Crearne di ulteriori è considerato cattiva programmazione, e Minetest ci avviserà di ciò:

81
_it/players/chat.md
View File

@ -8,17 +8,19 @@ redirect_from: /it/chapters/chat.html
cmd_online: cmd_online:
level: warning level: warning
title: I giocatori offline possono eseguire comandi title: I giocatori offline possono eseguire comandi
message: <p>Viene passato il nome del giocatore al posto del giocatore in sé perché le mod possono eseguire comandi in vece di un giocatore offline. message: |
Per esempio, il bridge IRC permette ai giocatori di eseguire comandi senza dover entrare in gioco.</p> Viene passato il nome del giocatore al posto del giocatore in sé perché le mod possono eseguire comandi in vece di un giocatore offline.
Per esempio, il ponte IRC permette ai giocatori di eseguire comandi senza dover entrare in gioco.
<p>Assicurati quindi di non dar per scontato che un giocatore sia connesso. Assicurati quindi di non dar per scontato che un giocatore sia connesso.
Puoi controllare ciò tramite <pre>minetest.get_player_by_name</pre>, per vedere se ritorna qualcosa o meno.</p> Puoi controllare ciò tramite `minetest.get_player_by_name`, per vedere se ritorna qualcosa o meno.
cb_cmdsprivs: cb_cmdsprivs:
level: warning level: warning
title: Privilegi e comandi title: Privilegi e comandi
message: Il privilegio shout non è necessario per far sì che un giocatore attivi questo callback. message: |
Questo perché i comandi sono implementati in Lua, e sono semplicemente dei messaggi in chat che iniziano con /. Il privilegio shout non è necessario per far sì che un giocatore attivi questo richiamo.
Questo perché i comandi sono implementati in Lua, e sono semplicemente dei messaggi in chat che iniziano con /.
--- ---
@ -26,15 +28,18 @@ cb_cmdsprivs:
Le mod possono interagire con la chat del giocatore, tra l'inviare messaggi, intercettarli e registrare dei comandi. Le mod possono interagire con la chat del giocatore, tra l'inviare messaggi, intercettarli e registrare dei comandi.
- [Inviare messaggi a tutti i giocatori](#inviare-messaggi-a-tutti-i-giocatori) - [Inviare messaggi](#inviare-messaggi)
- [Inviare messaggi a giocatori specifici](#inviare-messaggi-a-giocatori-specifici) - [A tutti i giocatori](#a-tutti-i-giocatori)
- [A giocatori specifici](#a-giocatori-specifici)
- [Comandi](#comandi) - [Comandi](#comandi)
- [Complex Subcommands](#complex-subcommands) - [Accettare più argomenti](#accettare-più-argomenti)
- [Using string.split](#using-stringsplit) - [Usare string.split](#usare-stringsplit)
- [Using Lua patterns](#using-lua-patterns) - [Usare i pattern Lua](#usare-i-pattern-lua)
- [Intercettare i messaggi](#intercettare-i-messaggi) - [Intercettare i messaggi](#intercettare-i-messaggi)
## Inviare messaggi a tutti i giocatori ## Inviare messaggi
### A tutti i giocatori
Per inviare un messaggio a tutti i giocatori connessi in gioco, si usa la funzione `chat_send_all`: Per inviare un messaggio a tutti i giocatori connessi in gioco, si usa la funzione `chat_send_all`:
@ -50,7 +55,7 @@ Segue un esempio di come apparirerebbe in gioco:
Il messaggio appare su una nuova riga, per distinguerlo dai messaggi dei giocatori. Il messaggio appare su una nuova riga, per distinguerlo dai messaggi dei giocatori.
## Inviare messaggi a giocatori specifici ### A giocatori specifici
Per inviare un messaggio a un giocatore in particolare, si usa invece la funzione `chat_send_player`: Per inviare un messaggio a un giocatore in particolare, si usa invece la funzione `chat_send_player`:
@ -77,50 +82,50 @@ minetest.register_chatcommand("foo", {
Nel codice qui in alto, `interact` è elencato come [privilegio](privileges.html) necessario; in altre parole, solo i giocatori che hanno quel privilegio possono usare il comando. Nel codice qui in alto, `interact` è elencato come [privilegio](privileges.html) necessario; in altre parole, solo i giocatori che hanno quel privilegio possono usare il comando.
`param` è una stringa contenente tutto ciò che un giocatore scrive dopo il nome del comando.
Per esempio, in `/grantme uno,due,tre`, `param` equivarrà a `uno,due,tre`.
I comandi ritornano un massimo di due valori, dove il primo è un booleano che indica l'eventuale successo, mentre il secondo è un messaggio da inviare all'utente. I comandi ritornano un massimo di due valori, dove il primo è un booleano che indica l'eventuale successo, mentre il secondo è un messaggio da inviare all'utente.
{% include notice.html notice=page.cmd_online %} {% include notice.html notice=page.cmd_online %}
## Complex Subcommands ### Accettare più argomenti
It's common for chat commands to require multiple arguments, for example, Non è raro che i comandi richiedano più argomenti, come per esempio `/squadra entra <nome_squadra>`.
`/team join <team_name>`. There are two ways Ci sono due modi per implementare ciò: usare `string.split` o i pattern Lua.
of doing this, either using Minetest's string split or Lua patterns.
### Using string.split #### Usare string.split
A string can be split up into words using `string.split(" ")`: Una stringa può essere spezzettata in più parti tramite `string.split(" ")`:
```lua ```lua
local parts = param:split(" ") local parti = param:split(" ")
local cmd = parts[1] local cmd = parti[1]
if cmd == "join" then if cmd == "entra" then
local team_name = parts[2] local nome_squadra = parti[2]
team.join(name, team_name) squadra.entra(name, nome_squadra)
return true, "Joined team!" return true, "Sei dentro la squadra!"
elseif cmd == "max_users" then elseif cmd == "gioc_max" then
local team_name = parts[2] local nome_squadra = parti[2]
local max_users = tonumber(parts[3]) local gioc_max = tonumber(parti[3])
if team_name and max_users then if nome_squadra and gioc_max then
return true, "Set max users of team " .. team_name .. " to " .. max_users return true, "Giocatori massimi della squadra " .. nome_squadra .. " impostati a " .. gioc_max
else else
return false, "Usage: /team max_users <team_name> <number>" return false, "Uso: /squadra gioc_max <nome_squadra> <numero>"
end end
else else
return false, "Command needed" return false, "È necessario un comando"
end end
``` ```
### Using Lua patterns #### Usare i pattern Lua
[Lua patterns](https://www.lua.org/pil/20.2.html) are a way of extracting stuff
from text using rules. They're best suited for when there are arguments that can
contain spaces or more control is needed on how parameters are captured.
[I pattern Lua](https://www.lua.org/pil/20.2.html) sono un modo per estrapolare pezzi di testo seguendo delle regole.
Sono perfetti in caso di argomenti che contengono spazi, o comunque quando è richiesto un controllo più meticoloso dei parametri catturati.
```lua ```lua
local a, msg = string.match(param, "^([%a%d_-]+) (*+)$") local a, msg = string.match(param, "^([%a%d_-]+) (*+)$")
@ -161,7 +166,7 @@ minetest.register_on_chat_message(function(name, message)
end) end)
``` ```
Ritornando false, si permette al messaggio di essere inviato. Ritornando `false`, si permette al messaggio di essere inviato.
In verità `return false` può anche essere omesso in quanto `nil` verrebbe ritornato implicitamente, e nil è trattato come false. In verità `return false` può anche essere omesso in quanto `nil` verrebbe ritornato implicitamente, e nil è trattato come false.
{% include notice.html notice=page.cb_cmdsprivs %} {% include notice.html notice=page.cb_cmdsprivs %}

178
_it/quality/translations.md
View File

@ -1,5 +1,5 @@
--- ---
title: Translation (i18n / l10n) title: Traduzione
layout: default layout: default
root: ../.. root: ../..
idx: 8.05 idx: 8.05
@ -7,117 +7,92 @@ marked_text_encoding:
level: info level: info
title: Marked Text Encoding title: Marked Text Encoding
message: | message: |
You don't need to know the exact format of marked text, but it might help Non hai davvero bisogno di capire come funziona il testo formattato, ma potrebbe aiutarti a capire meglio.
you understand.
``` ```
"\27(T@mymod)Hello everyone!\27E" "\27(T@miamod)Hello everyone!\27E"
``` ```
* `\27` is the escape character - it's used to tell Minetest to pay attention as * `\27` è il carattere di escape - è usato per dire a Minetest di far attenzione, in quanto sta per seguire qualcosa di speciale. È usato sia per le traduzioni che per la colorazione del testo.
something special is coming up. This is used for both translations and text * `(T@miamod)` dice che il testo a seguire è traducibile usando il dominio testuale di `miamod`.
colorisation. * `Hello everyone!` è il testo in inglese da tradurre, passato alla funzione di traduzione.
* `(T@mymod)` says that the following text is translatable using the `mymod` * `\27E` è di nuovo il carattere di escape, dove `E` è usato per segnalare che si è arrivati alla fine.
textdomain.
* `Hello everyone!` is the translatable text in English, as passed to the
translator function.
* `\27E` is the escape character again and `E`, used to signal that the end has
been reached.
--- ---
## Introduction <!-- omit in toc --> ## Introduzione <!-- omit in toc -->
Adding support for translation to your mods and games allows more people to Aggiungere il supporto per le traduzioni nelle tue mod e giochi dà la possibilità a più persone di gustarsele.
enjoy them. According to Google Play, 64% of Minetest Android users don't have Stando a Google Play, il 64% dei giocatori di Minetest Android non usano l'inglese come prima lingua.
English as their primary language. Minetest doesn't track stats for user Per quanto Minetest non tenga traccia di questo parametro nelle altre piattaforme, vien comunque da sé pensare che una buona parte di giocatrici e giocatori non siano madrelingua inglesi.
languages across all platforms, but there's likely to be a high proportion of
non-English speaking users.
Minetest allows you to translate your mods and games into different languages by Minetest ti permette di localizzare i tuoi contenuti in tante lingue diverse, chiedendoti il testo base in inglese, seguito da dei file di traduzione che mappano le parole/frasi equivalenti nelle altre lingue. Questo processo di traduzione è fatto a lato client, cosicché ogni giocatore possa vedere il contenuto nella propria lingua (se disponibile).
writing your text in English, and using translation files to map into other
languages. Translation is done on each player's client, allowing each player to
see a different language.
- [How does client-side translation work?](#how-does-client-side-translation-work) - [Come funziona la traduzione lato client?](#come-funziona-la-traduzione-lato-client)
- [Marked text](#marked-text) - [Testo formattato](#testo-formattato)
- [Translation files](#translation-files) - [File di traduzione](#file-di-traduzione)
- [Format strings](#format-strings) - [Formattare una stringa](#formattare-una-stringa)
- [Best practices and Common Falsehoods about Translation](#best-practices-and-common-falsehoods-about-translation) - [Buona prassi per una buona traduzione](#buona-prassi-per-una-buona--traduzione)
- [Server-side translations](#server-side-translations) - [Traduzioni lato server](#traduzioni-lato-server)
- [Conclusion](#conclusion) - [Per concludere](#per-concludere)
## How does client-side translation work? ## Come funziona la traduzione lato client?
### Marked text ### Testo formattato
The server needs to tell clients how to translate text. This is done by marking Il server ha bisogno di dire ai client come tradurre il testo.
text as translatable using a translator function (`S()`), returned by Questo accade grazie alla funzione `minetest.get_translator(dominiotestuale)`, che abbrevieremo con `S()`:
`minetest.get_translator(textdomain)`:
```lua ```lua
local S = minetest.get_translator("mymod") local S = minetest.get_translator("miamod")
minetest.register_craftitem("mymod:item", { minetest.register_craftitem("miamod:oggetto", {
description = S("My Item"), description = S("My Item"),
}) })
``` ```
The first argument of `get_translator` is the `textdomain`, which acts as a Il primo parametro di `get_translator` è il dominio testuale, che funge da [spazio dei nomi](https://it.wikipedia.org/wiki/Namespace).
namespace. Rather than having all translations for a language stored in the same Piuttosto che avere tutte le traduzioni di una lingua salvate nello stesso file, queste possono essere suddivise in domini testuali (un file per dominio per lingua).
file, translations are separated into textdomains, with a file per textdomain È buona norma assegnare al dominio testuale lo stesso nome della mod, onde evitare conflitti tra mod diverse.
per language. The textdomain should be the same as the mod name, as it helps
avoid mod conflicts.
Marked text can be used in most places where human-readable text is accepted, Il testo formattato può essere usato nella maggior parte dei casi dove è richiesto un testo fatto per gli esseri umani - come i formspec, i campi di definizioni di un oggetto, `infotext` ecc.
including formspecs, item def fields, infotext, and more. When including marked Nel caso dei formspec, tieni presente che dovrai usare la funzione di escape `minetest.formspec_escape` per una corretta visualizzazione.
text in formspecs, you need to escape the text using
`minetest.formspec_escape`.
When the client encounters marked text, such as that passed to `description`, it Quando il client incontra del testo formattato, come quello passato in `description`, ne andrà a cercare il corrispettivo nel file di traduzione della lingua del giocatore. Se la ricerca non avrà avuto esito positivo, ritornerà quello in inglese.
looks it up in the player's language's translation file. If a translation cannot
be found, it falls back to the English translation.
Marked text contains the English source text, the textdomain, and any additional Nel testo formattato sono presenti il testo sorgente in inglese, il dominio testuale, e qualsivoglia altro parametro passato a `S()`.
arguments passed to `S()`. It's essentially a text encoding of the `S` call, Essenzialmente, è una codifica testuale della chiamata a `S` che contiene tutte le informazioni necessarie.
containing all the required information.
{% include notice.html notice=page.marked_text_encoding %} {% include notice.html notice=page.marked_text_encoding %}
### Translation files ### File di traduzione
Translation files are media files that can be found in the `locale` folder for I file di traduzione sono file che possono essere trovati nella cartella `locale` di ogni mod.
each mod. Currently, the only supported format is `.tr`, but support for more Al momento, l'unico formato supportato è `.tr`, ma è probabile che altri formati più tipici saranno aggiunti in futuro.
common formats is likely in the future. Translation files must be named I file di traduzione devono essere nominati nel seguente modo: `[dominiotestuale].[codicelingua].tr`.
in the following way: `[textdomain].[lang].tr`.
Files in the `.tr` start with a comment specifying the textdomain, and then I file `.tr` iniziano con un commento che ne specifica il dominio, seguito poi da righe che mappano il testo originale in inglese nella lingua del file.
further lines mapping from the English source text to the translation.
For example, `mymod.fr.tr`: Per esempio, `miamod.it.tr`:
``` ```
# textdomain: mymod # textdomain: miamod
Hello everyone!=Bonjour à tous ! Hello everyone!=Ciao a tutti!
I like grapefruit=J'aime le pamplemousse I like grapefruit=Mi piace il pompelmo
``` ```
You should create translation files based on your mod/game's source code, Dovresti creare dei file di traduzione basati sul codice sorgente delle tue mod/giochi, usando uno strumento come [update_translations](https://github.com/minetest-tools/update_translations).
using a tool like Questo cercherà tutte le occorrenze di `S(` nel tuo codice Lua, creando in automatico un modello che traduttrici e traduttori potranno usare per tradurre nella loro lingua.
[update_translations](https://github.com/minetest-tools/update_translations). Inoltre, si prenderà cura di aggiornare i file di traduzione ogniqualvolta verranno effettuate modifiche al codice.
This tool will look for `S(` in your Lua code, and automatically create a
template that translators can use to translate into their language.
It also handles updating the translation files when your source changes.
## Format strings ## Formattare una stringa
It's common to need to include variable information within a translation Non è raro dover inserire una variabile dentro una stringa da tradurre.
string. It's important that text isn't just concatenated, as that prevents È importante che il testo non sia semplicemente concatenato, in quanto impedirebbe a chi traduce di cambiare l'ordine delle variabili all'interno della frase.
translators from changing the order of variables within a sentence. Instead, Al contrario, dovresti usare il seguente sistema di formattazione:
you should use the translation system's format/arguments system:
```lua ```lua
minetest.register_on_joinplayer(function(player) minetest.register_on_joinplayer(function(player)
@ -125,39 +100,29 @@ minetest.register_on_joinplayer(function(player)
end) end)
``` ```
If you want to include a literal `@` in your translation, you'll need to escape Se vuoi scrivere letteralmente `@` nella tua frase, dovrai usare una sequenza di escape scrivendo `@@`.
by writing `@@`.
You should avoid concatenation *within* a sentence, but it's recommended that Dovresti evitare di concatenare stringhe *all'interno* di una frase; piuttosto, sarebbe meglio concatenare più frasi come da esempio, in quanto permette a chi traduce di lavorare su stringhe più piccole:
you join multiple sentences using concatenation. This helps translators by
keeping strings smaller.
```lua ```lua
S("Hello @1!", player_name) .. " " .. S("You have @1 new messages.", #msgs) S("Hello @1!", player_name) .. " " .. S("You have @1 new messages.", #msgs)
``` ```
## Best practices and Common Falsehoods about Translation ## Buona prassi per una buona traduzione
* Avoid concatenating text and use format arguments instead. This gives * Evita di concatenare il testo, optando invece per formattare le stringhe. Questo permette a chi traduce di avere pieno controllo sull'ordine degli elementi;
translators full control over changing the order of things. * Crea i file di traduzione in automatico usando [update_translations](https://github.com/minetest-tools/update_translations);
* Create translation files automatically, using * È cosa comune che le variabili cambino il testo circostante, per esempio tramite genere e numero. Risulta spesso difficile trovare qualcosa che si sposi bene in tutti i casi, perciò si tende a cambiare la struttura della frase in modo che risulti sempre corretta ("Hai ottenuto 3 mele" -> "Hai ottenuto mela (x3)");
[update_translations](https://github.com/minetest-tools/update_translations). * Le traduzioni potrebbero essere molto più lunghe o molto più corte rispetto all'originale. Assicurati di lasciare sempre un po' di respiro;
* It's common for variables to change the surrounding text, for example, with * Non tutte le lingue scrivono i numeri nella stessa maniera, come per esempio `1.000` e `1'000`;
gender and pluralisation. This is often hard to deal with, so is * Non dar per scontato che le altre lingue usino le maiscuole nella stessa maniera della tua.
frequently glossed over or worked around with gender neutral phrasings.
* Translations may be much longer or much smaller than the English text. Make
sure to leave plenty of space.
* Other languages may write numbers in a different way, for example, with commas
as decimal points. `1.000,23`, `1'000'000,32`
* Don't assume that other languages use capitalisation in the same way.
## Server-side translations ## Traduzioni lato server
Sometimes you need to know the translation of text on the server, for example, Certe volte ti capiterà di voler sapere quale traduzione di una tal stringa stia venendo visualizzata dal giocatore.
to sort or search text. You can use `get_player_information` to get a player's Puoi usare `get_player_information` per ottenere la lingua utilizzata e `get_translated_string` per tradurne il testo formattato.
lang,uage and `get_translated_string` to translate marked text.
```lua ```lua
local list = { local list = {
@ -168,24 +133,21 @@ local list = {
minetest.register_chatcommand("find", { minetest.register_chatcommand("find", {
func = function(name, param) func = function(name, param)
local info = minetest.get_player_information(name) local info = minetest.get_player_information(name)
local language = info and info.language or "en" local lingua = info and info.language or "en"
for _, line in ipairs(list) do for _, riga in ipairs(lista) do
local trans = minetest.get_translated_string(language, line) local trad = minetest.get_translated_string(language, riga)
if trans:contains(query) then if trad:contains(query) then
return line return riga
end end
end end
end, end,
}) })
``` ```
## Conclusion ## Per concludere
The translation API allows making mods and games more accessible, but care is Se ben gestita, l'API per le traduzioni permette di rendere mod e giochi più accessibili.
needed in order to use it correctly.
Minetest is continuously improving, and the translation API is likey to be Si tenga comunque conto che Minetest è in continua evoluzione e che l'API verrà probabilmente ampliata in futuro.
extended in the future. For example, support for gettext translation files will Per esempio, il supporto per i file di traduzione *gettext* permetterà l'utilizzo di piattaforme e strumenti consolidati come Weblate, mentre nel frattempo si sta lavorando al supporto per il genere e il numero.
allow common translator tools and platforms (like weblate) to be used, and
there's likely to be support for pluralisation and gender added.