IT | translation chapter + cleanup
This commit is contained in:
Zughy
parent
f6c8a42696
commit
f9bc3f1fc0
@ -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.
|
||||
|
||||
- [Programmare](#programmare)
|
||||
- [Programmare in Lua](#programmare-in-lua)
|
||||
- [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)
|
||||
- [Precedenza alla portata locale](#precedenza-alla-portata-locale)
|
||||
- [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
|
||||
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
|
||||
|
||||
@ -70,117 +71,6 @@ Tra gli editor più famosi che ben si prestano a lavorare in Lua, troviamo:
|
||||
(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
|
||||
|
||||
L'essere locale o globale di una variabile determina da dove è possibile accederci.
|
||||
@ -216,6 +106,9 @@ one()
|
||||
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.
|
||||
Crearne di ulteriori è considerato cattiva programmazione, e Minetest ci avviserà di ciò:
|
||||
|
||||
|
||||
@ -8,17 +8,19 @@ redirect_from: /it/chapters/chat.html
|
||||
cmd_online:
|
||||
level: warning
|
||||
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.
|
||||
Per esempio, il bridge IRC permette ai giocatori di eseguire comandi senza dover entrare in gioco.</p>
|
||||
message: |
|
||||
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.
|
||||
Puoi controllare ciò tramite <pre>minetest.get_player_by_name</pre>, per vedere se ritorna qualcosa o meno.</p>
|
||||
Assicurati quindi di non dar per scontato che un giocatore sia connesso.
|
||||
Puoi controllare ciò tramite `minetest.get_player_by_name`, per vedere se ritorna qualcosa o meno.
|
||||
|
||||
cb_cmdsprivs:
|
||||
level: warning
|
||||
title: Privilegi e comandi
|
||||
message: Il privilegio shout non è necessario per far sì che un giocatore attivi questo callback.
|
||||
Questo perché i comandi sono implementati in Lua, e sono semplicemente dei messaggi in chat che iniziano con /.
|
||||
message: |
|
||||
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.
|
||||
|
||||
- [Inviare messaggi a tutti i giocatori](#inviare-messaggi-a-tutti-i-giocatori)
|
||||
- [Inviare messaggi a giocatori specifici](#inviare-messaggi-a-giocatori-specifici)
|
||||
- [Inviare messaggi](#inviare-messaggi)
|
||||
- [A tutti i giocatori](#a-tutti-i-giocatori)
|
||||
- [A giocatori specifici](#a-giocatori-specifici)
|
||||
- [Comandi](#comandi)
|
||||
- [Complex Subcommands](#complex-subcommands)
|
||||
- [Using string.split](#using-stringsplit)
|
||||
- [Using Lua patterns](#using-lua-patterns)
|
||||
- [Accettare più argomenti](#accettare-più-argomenti)
|
||||
- [Usare string.split](#usare-stringsplit)
|
||||
- [Usare i pattern Lua](#usare-i-pattern-lua)
|
||||
- [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`:
|
||||
|
||||
@ -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.
|
||||
|
||||
## 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`:
|
||||
|
||||
@ -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.
|
||||
|
||||
`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.
|
||||
|
||||
{% include notice.html notice=page.cmd_online %}
|
||||
|
||||
|
||||
## Complex Subcommands
|
||||
### Accettare più argomenti
|
||||
|
||||
It's common for chat commands to require multiple arguments, for example,
|
||||
`/team join <team_name>`. There are two ways
|
||||
of doing this, either using Minetest's string split or Lua patterns.
|
||||
Non è raro che i comandi richiedano più argomenti, come per esempio `/squadra entra <nome_squadra>`.
|
||||
Ci sono due modi per implementare ciò: usare `string.split` o i pattern Lua.
|
||||
|
||||
|
||||
### 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
|
||||
local parts = param:split(" ")
|
||||
local cmd = parts[1]
|
||||
local parti = param:split(" ")
|
||||
local cmd = parti[1]
|
||||
|
||||
if cmd == "join" then
|
||||
local team_name = parts[2]
|
||||
team.join(name, team_name)
|
||||
return true, "Joined team!"
|
||||
elseif cmd == "max_users" then
|
||||
local team_name = parts[2]
|
||||
local max_users = tonumber(parts[3])
|
||||
if team_name and max_users then
|
||||
return true, "Set max users of team " .. team_name .. " to " .. max_users
|
||||
if cmd == "entra" then
|
||||
local nome_squadra = parti[2]
|
||||
squadra.entra(name, nome_squadra)
|
||||
return true, "Sei dentro la squadra!"
|
||||
elseif cmd == "gioc_max" then
|
||||
local nome_squadra = parti[2]
|
||||
local gioc_max = tonumber(parti[3])
|
||||
if nome_squadra and gioc_max then
|
||||
return true, "Giocatori massimi della squadra " .. nome_squadra .. " impostati a " .. gioc_max
|
||||
else
|
||||
return false, "Usage: /team max_users <team_name> <number>"
|
||||
return false, "Uso: /squadra gioc_max <nome_squadra> <numero>"
|
||||
end
|
||||
else
|
||||
return false, "Command needed"
|
||||
return false, "È necessario un comando"
|
||||
end
|
||||
```
|
||||
|
||||
|
||||
### Using Lua patterns
|
||||
|
||||
[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.
|
||||
#### Usare i pattern Lua
|
||||
|
||||
[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
|
||||
local a, msg = string.match(param, "^([%a%d_-]+) (*+)$")
|
||||
@ -161,7 +166,7 @@ minetest.register_on_chat_message(function(name, message)
|
||||
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.
|
||||
|
||||
{% include notice.html notice=page.cb_cmdsprivs %}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
---
|
||||
title: Translation (i18n / l10n)
|
||||
title: Traduzione
|
||||
layout: default
|
||||
root: ../..
|
||||
idx: 8.05
|
||||
@ -7,117 +7,92 @@ marked_text_encoding:
|
||||
level: info
|
||||
title: Marked Text Encoding
|
||||
message: |
|
||||
You don't need to know the exact format of marked text, but it might help
|
||||
you understand.
|
||||
Non hai davvero bisogno di capire come funziona il testo formattato, ma potrebbe aiutarti a capire meglio.
|
||||
|
||||
```
|
||||
"\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
|
||||
something special is coming up. This is used for both translations and text
|
||||
colorisation.
|
||||
* `(T@mymod)` says that the following text is translatable using the `mymod`
|
||||
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.
|
||||
* `\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.
|
||||
* `(T@miamod)` dice che il testo a seguire è traducibile usando il dominio testuale di `miamod`.
|
||||
* `Hello everyone!` è il testo in inglese da tradurre, passato alla funzione di traduzione.
|
||||
* `\27E` è di nuovo il carattere di escape, dove `E` è usato per segnalare che si è arrivati alla fine.
|
||||
---
|
||||
|
||||
## Introduction <!-- omit in toc -->
|
||||
## Introduzione <!-- omit in toc -->
|
||||
|
||||
Adding support for translation to your mods and games allows more people to
|
||||
enjoy them. According to Google Play, 64% of Minetest Android users don't have
|
||||
English as their primary language. Minetest doesn't track stats for user
|
||||
languages across all platforms, but there's likely to be a high proportion of
|
||||
non-English speaking users.
|
||||
Aggiungere il supporto per le traduzioni nelle tue mod e giochi dà la possibilità a più persone di gustarsele.
|
||||
Stando a Google Play, il 64% dei giocatori di Minetest Android non usano l'inglese come prima lingua.
|
||||
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.
|
||||
|
||||
Minetest allows you to translate your mods and games into different languages by
|
||||
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.
|
||||
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).
|
||||
|
||||
|
||||
- [How does client-side translation work?](#how-does-client-side-translation-work)
|
||||
- [Marked text](#marked-text)
|
||||
- [Translation files](#translation-files)
|
||||
- [Format strings](#format-strings)
|
||||
- [Best practices and Common Falsehoods about Translation](#best-practices-and-common-falsehoods-about-translation)
|
||||
- [Server-side translations](#server-side-translations)
|
||||
- [Conclusion](#conclusion)
|
||||
- [Come funziona la traduzione lato client?](#come-funziona-la-traduzione-lato-client)
|
||||
- [Testo formattato](#testo-formattato)
|
||||
- [File di traduzione](#file-di-traduzione)
|
||||
- [Formattare una stringa](#formattare-una-stringa)
|
||||
- [Buona prassi per una buona traduzione](#buona-prassi-per-una-buona--traduzione)
|
||||
- [Traduzioni lato server](#traduzioni-lato-server)
|
||||
- [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
|
||||
text as translatable using a translator function (`S()`), returned by
|
||||
`minetest.get_translator(textdomain)`:
|
||||
Il server ha bisogno di dire ai client come tradurre il testo.
|
||||
Questo accade grazie alla funzione `minetest.get_translator(dominiotestuale)`, che abbrevieremo con `S()`:
|
||||
|
||||
```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"),
|
||||
})
|
||||
```
|
||||
|
||||
The first argument of `get_translator` is the `textdomain`, which acts as a
|
||||
namespace. Rather than having all translations for a language stored in the same
|
||||
file, translations are separated into textdomains, with a file per textdomain
|
||||
per language. The textdomain should be the same as the mod name, as it helps
|
||||
avoid mod conflicts.
|
||||
Il primo parametro di `get_translator` è il dominio testuale, che funge da [spazio dei nomi](https://it.wikipedia.org/wiki/Namespace).
|
||||
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).
|
||||
È buona norma assegnare al dominio testuale lo stesso nome della mod, onde evitare conflitti tra mod diverse.
|
||||
|
||||
Marked text can be used in most places where human-readable text is accepted,
|
||||
including formspecs, item def fields, infotext, and more. When including marked
|
||||
text in formspecs, you need to escape the text using
|
||||
`minetest.formspec_escape`.
|
||||
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.
|
||||
Nel caso dei formspec, tieni presente che dovrai usare la funzione di escape `minetest.formspec_escape` per una corretta visualizzazione.
|
||||
|
||||
When the client encounters marked text, such as that passed to `description`, it
|
||||
looks it up in the player's language's translation file. If a translation cannot
|
||||
be found, it falls back to the English translation.
|
||||
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.
|
||||
|
||||
Marked text contains the English source text, the textdomain, and any additional
|
||||
arguments passed to `S()`. It's essentially a text encoding of the `S` call,
|
||||
containing all the required information.
|
||||
Nel testo formattato sono presenti il testo sorgente in inglese, il dominio testuale, e qualsivoglia altro parametro passato a `S()`.
|
||||
Essenzialmente, è una codifica testuale della chiamata a `S` che contiene tutte le informazioni necessarie.
|
||||
|
||||
{% 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
|
||||
each mod. Currently, the only supported format is `.tr`, but support for more
|
||||
common formats is likely in the future. Translation files must be named
|
||||
in the following way: `[textdomain].[lang].tr`.
|
||||
I file di traduzione sono file che possono essere trovati nella cartella `locale` di ogni mod.
|
||||
Al momento, l'unico formato supportato è `.tr`, ma è probabile che altri formati più tipici saranno aggiunti in futuro.
|
||||
I file di traduzione devono essere nominati nel seguente modo: `[dominiotestuale].[codicelingua].tr`.
|
||||
|
||||
Files in the `.tr` start with a comment specifying the textdomain, and then
|
||||
further lines mapping from the English source text to the translation.
|
||||
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.
|
||||
|
||||
For example, `mymod.fr.tr`:
|
||||
Per esempio, `miamod.it.tr`:
|
||||
|
||||
```
|
||||
# textdomain: mymod
|
||||
Hello everyone!=Bonjour à tous !
|
||||
I like grapefruit=J'aime le pamplemousse
|
||||
# textdomain: miamod
|
||||
Hello everyone!=Ciao a tutti!
|
||||
I like grapefruit=Mi piace il pompelmo
|
||||
```
|
||||
|
||||
You should create translation files based on your mod/game's source code,
|
||||
using a tool like
|
||||
[update_translations](https://github.com/minetest-tools/update_translations).
|
||||
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.
|
||||
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).
|
||||
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.
|
||||
Inoltre, si prenderà cura di aggiornare i file di traduzione ogniqualvolta verranno effettuate modifiche al codice.
|
||||
|
||||
|
||||
## Format strings
|
||||
## Formattare una stringa
|
||||
|
||||
It's common to need to include variable information within a translation
|
||||
string. It's important that text isn't just concatenated, as that prevents
|
||||
translators from changing the order of variables within a sentence. Instead,
|
||||
you should use the translation system's format/arguments system:
|
||||
Non è raro dover inserire una variabile dentro una stringa da tradurre.
|
||||
È importante che il testo non sia semplicemente concatenato, in quanto impedirebbe a chi traduce di cambiare l'ordine delle variabili all'interno della frase.
|
||||
Al contrario, dovresti usare il seguente sistema di formattazione:
|
||||
|
||||
```lua
|
||||
minetest.register_on_joinplayer(function(player)
|
||||
@ -125,39 +100,29 @@ minetest.register_on_joinplayer(function(player)
|
||||
end)
|
||||
```
|
||||
|
||||
If you want to include a literal `@` in your translation, you'll need to escape
|
||||
by writing `@@`.
|
||||
Se vuoi scrivere letteralmente `@` nella tua frase, dovrai usare una sequenza di escape scrivendo `@@`.
|
||||
|
||||
You should avoid concatenation *within* a sentence, but it's recommended that
|
||||
you join multiple sentences using concatenation. This helps translators by
|
||||
keeping strings smaller.
|
||||
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:
|
||||
|
||||
```lua
|
||||
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
|
||||
translators full control over changing the order of things.
|
||||
* Create translation files automatically, using
|
||||
[update_translations](https://github.com/minetest-tools/update_translations).
|
||||
* It's common for variables to change the surrounding text, for example, with
|
||||
gender and pluralisation. This is often hard to deal with, so is
|
||||
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.
|
||||
* Evita di concatenare il testo, optando invece per formattare le stringhe. Questo permette a chi traduce di avere pieno controllo sull'ordine degli elementi;
|
||||
* Crea i file di traduzione in automatico usando [update_translations](https://github.com/minetest-tools/update_translations);
|
||||
* È 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)");
|
||||
* Le traduzioni potrebbero essere molto più lunghe o molto più corte rispetto all'originale. Assicurati di lasciare sempre un po' di respiro;
|
||||
* Non tutte le lingue scrivono i numeri nella stessa maniera, come per esempio `1.000` e `1'000`;
|
||||
* Non dar per scontato che le altre lingue usino le maiscuole nella stessa maniera della tua.
|
||||
|
||||
|
||||
## Server-side translations
|
||||
## Traduzioni lato server
|
||||
|
||||
Sometimes you need to know the translation of text on the server, for example,
|
||||
to sort or search text. You can use `get_player_information` to get a player's
|
||||
lang,uage and `get_translated_string` to translate marked text.
|
||||
Certe volte ti capiterà di voler sapere quale traduzione di una tal stringa stia venendo visualizzata dal giocatore.
|
||||
Puoi usare `get_player_information` per ottenere la lingua utilizzata e `get_translated_string` per tradurne il testo formattato.
|
||||
|
||||
```lua
|
||||
local list = {
|
||||
@ -168,24 +133,21 @@ local list = {
|
||||
minetest.register_chatcommand("find", {
|
||||
func = function(name, param)
|
||||
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
|
||||
local trans = minetest.get_translated_string(language, line)
|
||||
if trans:contains(query) then
|
||||
return line
|
||||
for _, riga in ipairs(lista) do
|
||||
local trad = minetest.get_translated_string(language, riga)
|
||||
if trad:contains(query) then
|
||||
return riga
|
||||
end
|
||||
end
|
||||
end,
|
||||
})
|
||||
```
|
||||
|
||||
## Conclusion
|
||||
## Per concludere
|
||||
|
||||
The translation API allows making mods and games more accessible, but care is
|
||||
needed in order to use it correctly.
|
||||
Se ben gestita, l'API per le traduzioni permette di rendere mod e giochi più accessibili.
|
||||
|
||||
Minetest is continuously improving, and the translation API is likey to be
|
||||
extended in the future. For example, support for gettext translation files will
|
||||
allow common translator tools and platforms (like weblate) to be used, and
|
||||
there's likely to be support for pluralisation and gender added.
|
||||
Si tenga comunque conto che Minetest è in continua evoluzione e che l'API verrà probabilmente ampliata in futuro.
|
||||
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.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user