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

2 - Lua Scripting, Italian translation added

Browse Source
This commit is contained in:
Marco 2020-05-01 16:53:35 +02:00 committed by rubenwardy
parent 2509ac89f1
commit e2b2cd79de
1 changed files with 136 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

272
_it/basics/lua.md
View File

@ -1,34 +1,34 @@
--- ---
title: Lua Scripting title: Scriptare in Lua
layout: default layout: default
root: ../.. root: ../..
idx: 1.2 idx: 1.2
description: A basic introduction to Lua, including a guide on global/local scope. description: Un'introduzione a Lua, con inclusa una guida alla portata globale/locale.
redirect_from: /en/chapters/lua.html redirect_from: /it/chapters/lua.html
--- ---
## Introduction <!-- omit in toc --> ## Introduzione <!-- omit in toc -->
In this chapter we will talk about scripting in Lua, the tools required, In questo capitolo parleremo dello scripting in Lua, degli strumenti necessari,
and go over some techniques which you will probably find useful. e tratteremo alcune tecniche che troverai probabilmente utili.
- [Code Editors](#code-editors) - [Editor di codice](#editor-di-codice)
- [Coding in Lua](#coding-in-lua) - [Programmare in Lua](#programmare-in-lua)
- [Program Flow](#program-flow) - [Flusso del programma](#flusso-del-programma)
- [Variable Types](#variable-types) - [Tipi di variabili](#tipi-di-variabili)
- [Arithmetic Operators](#arithmetic-operators) - [Operatori matematici](#operatori-matematici)
- [Selection](#selection) - [Selezione](#selezione)
- [Logical Operators](#logical-operators) - [Operatori logici](#operatori-logici)
- [Programming](#programming) - [Programmare](#programmare)
- [Local and Global Scope](#local-and-global-scope) - [Portata locale e globale](#portata-locale-e-globale)
- [Locals should be used as much as possible](#locals-should-be-used-as-much-as-possible) - [Local dovrebbe essere usato il più possibile](#local-dovrebbe-essere-usato-il-piu-possibile)
- [Including other Lua Scripts](#including-other-lua-scripts) - [Inclusione di altri script Lua](#inclusione-di-altri-script-lua)
## Code Editors ## Editor di codice
A code editor with code highlighting is sufficient for writing scripts in Lua. Un editor di codice con evidenziamento delle parole chiave è sufficiente per scrivere script in Lua.
Code highlighting gives different colours to different words and characters L'evidenziamento assegna colori diversi a parole e caratteri diversi a seconda del loro significato.
depending on what they mean. This allows you to spot mistakes. Questo ti permette di individuare più facilmente eventuali errori.
```lua ```lua
function ctf.post(team,msg) function ctf.post(team,msg)
@ -46,86 +46,87 @@ function ctf.post(team,msg)
end end
``` ```
For example, keywords in the above snippet are highlighted such as if, then, end, and return. Per esempio, parole chiave come if, then, end e return sono evidenziate nel passaggio qui sopra.
table.insert is a function which comes with Lua by default. table.insert è invece una funzione base che deriva direttamente da Lua.
Here is a list of common editors well suited for Lua. Segue una lista di editor noti che si prestano bene per programmare in Lua.
Other editors are available, of course. Non sono, ovviamente, gli unici esisteneti.
* Windows: [Notepad++](http://notepad-plus-plus.org/), [Atom](http://atom.io/), [VS Code](https://code.visualstudio.com/) * Windows: [Notepad++](http://notepad-plus-plus.org/), [Atom](http://atom.io/), [VS Code](https://code.visualstudio.com/)
* Linux: Kate, Gedit, [Atom](http://atom.io/), [VS Code](https://code.visualstudio.com/) * Linux: Kate, Gedit, [Atom](http://atom.io/), [VS Code](https://code.visualstudio.com/)
* OSX: [Atom](http://atom.io/), [VS Code](https://code.visualstudio.com/) * OSX: [Atom](http://atom.io/), [VS Code](https://code.visualstudio.com/)
## Coding in Lua ## Programmare in Lua
### Program Flow ### Flusso del programma
Programs are a series of commands that run one after another. I programmi sono una serie di comandi che vengono eseguiti uno dopo l'altro.
We call these commands "statements." Chiamiamo questi comandi "istruzioni".
Program flow is how these statements are executed. Il flusso del programma è il come queste istruzioni vengono eseguite.
Different types of flow allow you to skip or jump over sets of commands. Differenti tipi di flusso ti permettono di saltare o meno serie di comandi.
There are three main types of flow: Ci sono tre tipi di flusso:
* Sequence: Just run one statement after another, no skipping. * Sequenziale: esegue un'istruzione dopo l'altra, senza salti.
* Selection: Skip over sequences depending on conditions. * Selettivo: salta alcune sequenze a seconda delle condizioni.
* Iteration: Repeating, looping. Keep running the same * Iterante: ripete ciclicamente. Continua a eseguire le stesse istruzioni
statements until a condition is met. finché una condizione non è soddisfatta.
So, what do statements in Lua look like? Quindi, come vengono rappresentate le istruzioni in Lua?
```lua ```lua
local a = 2 -- Set 'a' to 2 local a = 2 -- Imposta 'a' a 2
local b = 2 -- Set 'b' to 2 local b = 2 -- Imposta 'b' a 2
local result = a + b -- Set 'result' to a + b, which is 4 local risultato = a + b -- Imposta 'risultato' ad a + b, cioè 4
a = a + 10 a = a + 10
print("Sum is "..result) print("La somma è ".. risultato)
``` ```
Whoa, what happened there? Whoa, cos'è appena successo?
a, b, and result are *variables*. Local variables are declared a, b, e risultato sono *variabili*. Le variabili locali si dichiarano
by using the local keyword, and then given an initial value. tramite l'uso della parola chiave local, e assegnando loro un valore iniziale.
Local will be discussed in a bit, as it's part of a very important concept called Local sarà discussa in un attimo, in quanto parte di un concetto molto importante
*scope*. chiamato *portata*.
The `=` means *assignment*, so `result = a + b` means set "result" to a + b. Il simbolo `=` significa *assegnazione*, quindi `risultato = a + b` significa impostare "risultato" ad a + b.
Variable names can be longer than one character unlike in mathematics, as seen with the "result" variable. I nomi delle variabili possono essere più lunghi di un carattere, al contrario che in matematica, come
It's also worth noting that Lua is *case-sensitive*; A is a different variable to a. visto nella variabile "risultato".
Vale anche la pena notare che Lua è *case-sensitive* (differenzia maiscuole da minuscole);
A è una variabile diversa da a.
### Variable Types ### Tipi di variabili
A variable will be only one of the following types and can change type after an Una variabile può equivalere solo a uno dei seguenti tipi e può cambiare tipo dopo l'assegnazione.
assignment. È buona pratica assicurarsi che una variabile sia sempre solo o nil o diversa da nil.
It's good practice to make sure a variable is only ever nil or a single non-nil type.
| Type | Description | Example | | Tipo | Descrizione | Esempio |
|----------|---------------------------------|----------------| |----------|---------------------------------|----------------|
| Nil | Not initialised. The variable is empty, it has no value | `local A`, `D = nil` | | Nil | Non inizializzata. La variabile è vuota, non ha valore | `local A`, `D = nil` |
| Number | A whole or decimal number. | `local A = 4` | | Numero | Un numero intero o decimale | `local A = 4` |
| String | A piece of text | `local D = "one two three"` | | Stringa | Una porzione di testo | `local D = "one two three"` |
| Boolean | True or False | `local is_true = false`, `local E = (1 == 1)` | | Booleano | Vero o falso (true, false) | `local is_true = false`, `local E = (1 == 1)` |
| Table | Lists | Explained below | | Tabella | Liste | Spiegate sotto |
| Function | Can run. May require inputs and may return a value | `local result = func(1, 2, 3)` | | Funzione | Può essere eseguita. Può richiedere input e ritornare un valore | `local result = func(1, 2, 3)` |
### Arithmetic Operators ### Operatori matematici
Not an exhaustive list. Doesn't contain every possible operator. Lista non esaustiva, ce ne sono altri
| Symbol | Purpose | Example | | Simbolo | Scopo | Esempio |
|--------|----------------|---------------------------| |---------|--------------------|---------------------------|
| A + B | Addition | 2 + 2 = 4 | | A + B | Addizione | 2 + 2 = 4 |
| A - B | Subtraction | 2 - 10 = -8 | | A - B | Sottrazione | 2 - 10 = -8 |
| A * B | Multiplication | 2 * 2 = 4 | | A * B | Moltiplicazione | 2 * 2 = 4 |
| A / B | Division | 100 / 50 = 2 | | A / B | Divisione | 100 / 50 = 2 |
| A ^ B | Powers | 2 ^ 2 = 2<sup>2</sup> = 4 | | A ^ B | Potenze | 2 ^ 2 = 2<sup>2</sup> = 4 |
| A .. B | Join strings | "foo" .. "bar" = "foobar" | | A .. B | Concatena stringhe | "foo" .. "bar" = "foobar" |
### Selection ### Selezione
The most basic selection is the if statement. It looks like this: La selezione più basica è il costrutto if. Si presenta così:
```lua ```lua
local random_number = math.random(1, 100) -- Between 1 and 100. local random_number = math.random(1, 100) -- Tra 1 e 100.
if random_number > 50 then if random_number > 50 then
print("Woohoo!") print("Woohoo!")
else else
@ -133,25 +134,25 @@ else
end end
``` ```
That example generates a random number between 1 and 100. It then prints Questo esempio genera un numero casuale tra 1 e 100. Stampa poi
"Woohoo!" if that number is bigger than 50, otherwise it prints "No!". "Woohoo!" se il numero è superiore a 50, altrimenti stampa "No!".
What else can you get apart from '>'? Cos'altro puoi usare oltre a '>'?
### Logical Operators ### Operatori logici
| Symbol | Purpose | Example | | Simbolo | Scopo | Esempio |
|---------|--------------------------------------|-------------------------------------------------------------| |---------|--------------------------------------|-------------------------------------------------------------|
| A == B | Equals | 1 == 1 (true), 1 == 2 (false) | | A == B | Uguale a | 1 == 1 (true), 1 == 2 (false) |
| A ~= B | Doesn't equal | 1 ~= 1 (false), 1 ~= 2 (true) | | A ~= B | Non uguale a (diverso da) | 1 ~= 1 (false), 1 ~= 2 (true) |
| A > B | Greater than | 5 > 2 (true), 1 > 2 (false), 1 > 1 (false) | | A > B | Maggiore di | 5 > 2 (true), 1 > 2 (false), 1 > 1 (false) |
| A < B | Less than | 1 < 3 (true), 3 < 1 (false), 1 < 1 (false) | | A < B | Minore di | 1 < 3 (true), 3 < 1 (false), 1 < 1 (false) |
| A >= B | Greater than or equals | 5 >= 5 (true), 5 >= 3 (true), 5 >= 6 (false) | | A >= B | Maggiore o uguale a | 5 >= 5 (true), 5 >= 3 (true), 5 >= 6 (false) |
| A <= B | Less than or equals | 3 <= 6 (true), 3 <= 3 (true) | | A <= B | Minore o uguale a | 3 <= 6 (true), 3 <= 3 (true) |
| A and B | And (both must be correct) | (2 > 1) and (1 == 1) (true), (2 > 3) and (1 == 1) (false) | | A and B | E (entrambi devono essere veri) | (2 > 1) and (1 == 1) (true), (2 > 3) and (1 == 1) (false) |
| A or B | either or. One or both must be true. | (2 > 1) or (1 == 2) (true), (2 > 4) or (1 == 3) (false) | | A or B | O (almeno uno dei due vero) | (2 > 1) or (1 == 2) (true), (2 > 4) or (1 == 3) (false) |
| not A | not true | not (1 == 2) (true), not (1 == 1) (false) | | not A | non vero | not (1 == 2) (true), not (1 == 1) (false) |
That doesn't contain every possible operator, and you can combine operators like this: La lista non è esaustiva, e puoi inoltre combinare gli operatori in questo modo:
```lua ```lua
if not A and B then if not A and B then
@ -159,73 +160,72 @@ if not A and B then
end end
``` ```
Which prints "Yay!" if A is false and B is true. Che stampa "Yay!" se A è falso e B vero.
Logical and arithmetic operators work exactly the same; Gli operatori logici e matematici funzionano esattamente allo stesso modo;
they both accept inputs and return a value which can be stored. entrambi accettano input e ritornano un valore che può essere immagazzinato.
```lua ```lua
local A = 5 local A = 5
local is_equal = (A == 5) local is_equal = (A == 5)
if is_equal then if is_equal then
print("Is equal!") print("È equivalente!")
end end
``` ```
## Programming ## Programmare
Programming is the action of taking a problem, such as sorting a list Programmare è l'azione di prendere un problema, come ordinare una lista di oggetti,
of items, and then turning it into steps that a computer can understand. e tramutarlo in dei passaggi che il computer può comprendere.
Teaching you the logical process of programming is beyond the scope of this book; Insegnarti i processi logici della programmazione non rientra nell'ambito di questo libro;
however, the following websites are quite useful in developing this: tuttavia, i seguenti siti sono alquanto utili per approfondire l'argomento:
* [Codecademy](http://www.codecademy.com/) is one of the best resources for * [Codecademy](http://www.codecademy.com/) è una delle migliori risorse per
learning to 'code', it provides an interactive tutorial experience. imparare a 'programmare'; offre un'esperienza guidata interattiva.
* [Scratch](https://scratch.mit.edu) is a good resource when starting from * [Scratch](https://scratch.mit.edu) è una buona risorsa quando si comincia
absolute basics, learning the problem-solving techniques required to program.\\ dalle basi assolute, imparando le tecniche di problem solving necessarie per programmare.\\
Scratch is **designed to teach children** how to program and isn't a serious Scratch è **ideato per insegnare ai bambini** e non è un linguaggio serio di programmazione.
programming language.
## Local and Global Scope ## Portata locale e globale
Whether a variable is local or global determines where it can be written to or read to. L'essere locale o globale di una variabile determina da dove è possibile accederci.
A local variable is only accessible from where it is defined. Here are some examples: Una variabile locale è accessibile soltanto da dove viene definita. Ecco alcuni esempi:
```lua ```lua
-- Accessible from within this script file -- Accessibile dall'interno dello script
local one = 1 local one = 1
function myfunc() function myfunc()
-- Accessible from within this function -- Accessibile dall'interno della funzione
local two = one + one local two = one + one
if two == one then if two == one then
-- Accessible from within this if statement -- Accessible dall'interno del costrutto if
local three = one + two local three = one + two
end end
end end
``` ```
Whereas global variables can be accessed from anywhere in the script file, and from any other mod. Mentre le variabili globali sono accessibili da qualsiasi script di qualsiasi mod.
```lua ```lua
my_global_variable = "blah" my_global_variable = "ciao"
function one() function one()
my_global_variable = "three" my_global_variable = "hey"
end end
print(my_global_variable) -- Output: "blah" print(my_global_variable) -- Output: "ciao"
one() one()
print(my_global_variable) -- Output: "three" print(my_global_variable) -- Output: "hey"
``` ```
### Locals should be used as much as possible ### Local dovrebbe essere usato il più possibile
Lua is global by default (unlike most other programming languages). Lua è globale di default (a differenza di molti altri linguaggi di programmazione).
Local variables must be identified as such. Le variabili locali devono essere identificate come tali.
```lua ```lua
function one() function one()
@ -240,15 +240,15 @@ one()
two() two()
``` ```
dump() is a function that can turn any variable into a string so the programmer can dump() è una funzione che può trasformare qualsiasi variabile in una stringa, cosicché
see what it is. The foo variable will be printed as "bar", including the quotes il programmatore possa vedere cosa rappresenta. La variabile foo sarà stampata come
which show it is a string. "bar", virgolette incluse (che dimostrano che è una stringa).
This is sloppy coding and Minetest will, in fact, warn about this: L'esempio precedente non è buona programmazione e Minetest, infatti, avviserà di ciò:
Assignment to undeclared global 'foo' inside function at init.lua:2 Assignment to undeclared global 'foo' inside function at init.lua:2
To correct this, use "local": Per ovviare, usa "local":
```lua ```lua
function one() function one()
@ -263,12 +263,13 @@ one()
two() two()
``` ```
Remember that nil means **not initialised**. Ricorda che nil significa **non inizializzato**.
The variable hasn't been assigned a value yet, Ovvero la variabile non è stata ancora assegnata a un valore,
doesn't exist, or has been uninitialised (ie: set to nil). non esiste o è stata deinizializzata (cioè impostata a nil)
The same goes for functions. Functions are variables of a special type, and La stessa cosa vale per le funzioni. Le funzioni sono variabili di tipo speciale,
should be made local, as other mods could have functions of the same name. e dovrebbero essere dichiarate locali, in quanto altre mod potrebbero sennò avere funzioni
con lo stesso nome.
```lua ```lua
local function foo(bar) local function foo(bar)
@ -276,7 +277,7 @@ local function foo(bar)
end end
``` ```
API tables should be used to allow other mods to call the functions, like so: Le tabelle API dovrebbero essere usate per permettere ad altre mod di chiamare le funzioni, come in:
```lua ```lua
mymod = {} mymod = {}
@ -285,20 +286,19 @@ function mymod.foo(bar)
return "foo" .. bar return "foo" .. bar
end end
-- In another mod, or script: -- In un'altra mod o script:
mymod.foo("foobar") mymod.foo("foobar")
``` ```
## Including other Lua Scripts ## Inclusione di altri script Lua
The recommended way to include other Lua scripts in a mod is to use *dofile*. Il metodo consigliato per includere in una mod altri script Lua è usare *dofile*.
```lua ```lua
dofile(minetest.get_modpath("modname") .. "/script.lua") dofile(minetest.get_modpath("modname") .. "/script.lua")
``` ```
"local" variables declared outside of any functions in a script file will be local to that script. Uno script può ritornare un valore, che è utile per condividere variabili locali private:
A script can return a value, which is useful for sharing private locals:
```lua ```lua
-- script.lua -- script.lua
@ -309,6 +309,6 @@ local ret = dofile(minetest.get_modpath("modname") .. "/script.lua")
print(ret) -- Hello world! print(ret) -- Hello world!
``` ```
Later chapters will discuss how to split up the code of a mod in a lot of detail. Nei capitoli seguenti si parlerà nel dettaglio di come suddividere il codice di una mod.
However, the simplistic approach for now is to have different files for different Tuttavia, per ora l'approccio semplicistico è di avere file differenti per diversi tipi di cose
types of things - nodes.lua, crafts.lua, craftitems.lua, etc. — nodi.lua, craft.lua, oggetti.lua ecc.