minetest_modding_book/_it/map/environment.md

---
title: "Mappa: operazioni base"
layout: default
root: ../..
idx: 3.1
description: Operazioni base come set_node e get_node
redirect_from: /it/chapters/environment.html
---

## Introduzione <!-- omit in toc -->

In questo capitolo imparerai come eseguire semplici azioni sulla mappa.

- [Struttura della mappa](#struttura-della-mappa)
- [Lettura](#lettura)
	- [Lettura dei nodi](#lettura-dei-nodi)
	- [Ricerca dei nodi](#ricerca-dei-nodi)
- [Scrittura](#scrittura)
	- [Scrittura dei nodi](#scrittura-dei-nodi)
	- [Rimozione dei nodi](#rimozione-dei-nodi)
- [Caricamento blocchi](#caricamento-blocchi)
- [Cancellazione blocchi](#cancellazione-blocchi)

## Struttura della mappa

La mappa di Minetest è suddivisa in Blocchi Mappa (*MapBlocks*), cubi di 16x16x16 nodi.
Man mano che i giocatori si addentrano per la mappa, i Blocchi Mappa vengono creati, caricati e rimossi dalla memoria.
Le aree della mappa che non sono ancora caricate sono piene di nodi *ignora*, dei nodi segnaposto che non possono
essere né attraversati né selezionati. Gli spazi vuoti delle aree già caricate, invece, sono nodi *d'aria*, dei
nodi invisibili e attraversabili.

Spesso, ci si rifà ai blocchi caricati (attenzione! Blocco non vuol dire nodo, come detto qui sopra!) chiamandoli *blocchi attivi*.
I blocchi attivi possono essere letti e sovrascritti dalle mod o dai giocatori, e contenere entità attive.
Anche il motore di gioco esegue operazioni sulla mappa, come il calcolare la fisica dei liquidi.

I Blocchi Mappa possono essere sia caricati dal database del mondo che generati.
Essi vengono generati fino al limite di generazione della mappa (`mapgen_limit`), che è impostato di base al suo valore massimo, 31000.
I Blocchi Mappa esistenti, tuttavia, ignorano questo limite quando caricati dal database del mondo.

## Lettura

### Lettura dei nodi

Un nodo può essere letto da un mondo fornendone la posizione:

```lua
local nodo = core.get_node({ x = 1, y = 3, z = 4 })
print(dump(nodo)) --> { name=.., param1=.., param2=.. }
```

Se la posizione è un decimale, verrà arrotondata alle coordinate del nodo.
`get_node` ritornerà sempre una tabella contenente le informazioni del nodo:

* `name` - Il nome del nodo, che sarà `ignore` quando l'area non è caricata.
* `param1` - Guarda la definizione dei nodi. È solitamente associato alla luce.
* `param2` - Guarda la definizione dei nodi.

Per vedere se un nodo è caricato si può utilizzare `core.get_node_or_nil`, che ritornerà `nil` se il nome del nodo risulta `ignore`
(la funzione non caricherà comunque il nodo).
Potrebbe comunque ritornare `ignore` se un blocco contiene effettivamente `ignore`: questo succede ai limiti della mappa.

### Ricerca dei nodi

Minetest offre un numero di funzioni d'aiuto per accelerare le azioni più comuni legate alla mappa.
Le più frequenti sono quelle per trovare i nodi.

Per esempio, mettiamo che si voglia creare un certo tipo di pianta che cresce più velocemente vicino alla pietra;
si dovrebbe controllare che ogni nodo nei pressi della pianta sia pietra, e modificarne il suo indice di crescita di conseguenza.

`core.find_node_near` ritornerà il primo nodo trovato in un dato raggio, combaciante con le informazioni passategli (nomi di nodi o gruppi).
Nell'esempio che segue, andiamo alla ricerca di un nodo di mese nel raggio di 5 nodi:

```lua
local vel_crescita = 1
local pos_nodo   = core.find_node_near(pos, 5, { "default:stone" })
if pos_nodo then
    core.chat_send_all("Nodo trovato a: " .. dump(pos_nodo))
    vel_crescita = 2
end
```

Mettiamo ora che l'indice di crescita debba incrementare per ogni nodo di pietra nei dintorni.
Si dovrebbe quindi usare una funzione in grado di trovare più nodi in un'area:

```lua
local pos1       = vector.subtract(pos, { x = 5, y = 5, z = 5 })
local pos2       = vector.add(pos, { x = 5, y = 5, z = 5 })
local lista_pos   =
        core.find_nodes_in_area(pos1, pos2, { "default:stone" })
local vel_crescita = 1 + #lista_pos
```

Il codice qui in alto ritorna il numero di nodi in un *volume cuboidale*.
Il che è diverso da usare `find_node_near`, il quale usa la distanza dalla posizione data (cioé una *sfera*).
Per ovviare a ciò, bisogna controllare l'intervallo manualmente.

```lua
local pos1       = vector.subtract(pos, { x = 5, y = 5, z = 5 })
local pos2       = vector.add(pos, { x = 5, y = 5, z = 5 })
local lista_pos   =
        core.find_nodes_in_area(pos1, pos2, { "default:stone" })
local vel_crescita = 1
for i=1, #lista_pos do
    local delta = vector.subtract(lista_pos[i], pos)
    if delta.x*delta.x + delta.y*delta.y + delta.z*delta.z <= 5*5 then
        vel_crescita = vel_crescita + 1
    end
end
```

Ora il codice aumenterà correttamente `vel_crescita` basandosi su quanti nodi di pietra ci sono in un intervallo.

Notare come si sia comparata la distanza al quadrato dalla posizione, invece che calcolarne la radice quadrata per ottenerne la distanza vera e propria.
Questo perché i computer trovano le radici quadrate computazionalmente pesanti, quindi dovrebbero essere evitate il più possibile.

Ci sono altre variazioni delle due funzioni sopracitate, come `find_nodes_with_meta` e `find_nodes_in_area_under_air`, che si comportano in modo simile e sono utili in altre circostanze.

## Scrittura

### Scrittura dei nodi

Puoi usare `set_node` per sovrascrivere nodi nella mappa.
Ogni chiamata a `set_node` ricalcolerà la luce e richiamerà i suoi callback, il che significa che `set_node` è alquanto lento quando usato su un elevato numero di nodi.

```lua
core.set_node({ x = 1, y = 3, z = 4 }, { name = "default:stone" })

local nodo = core.get_node({ x = 1, y = 3, z = 4 })
print(nodo.name) --> default:stone
```

`set_node` rimuoverà ogni metadato e inventario associato a quel nodo: ciò non è sempre desiderabile, specialmente se si stanno usando
più definizioni di nodi per rappresentarne concettualmente uno. Un esempio è il nodo fornace: per quanto lo si immagini come un nodo unico,
sono in verità due.

Si può impostare un nuovo nodo senza rimuoverne metadati e inventario con `swap_node`:

```lua
core.swap_node({ x = 1, y = 3, z = 4 }, { name = "default:stone" })
```

### Rimozione dei nodi

Un nodo deve sempre essere presente. Per rimuoverlo, basta impostarlo uguale a `air`.

Le seguenti due linee di codice sono equivalenti, rimuovendo in entrambi i casi il nodo:

```lua
core.remove_node(pos)
core.set_node(pos, { name = "air" })
```

Infatti, `remove_node` non fa altro che richiamare `set_node` con nome `air`.

## Caricamento blocchi

Puoi usare `core.emerge_area` per caricare i blocchi mappa.
Questo comando è asincrono, ovvero i blocchi non saranno caricati istantaneamente; al contrario, verranno caricati man mano e il callback associato sarà richiamato a ogni passaggio.

```lua
-- Carica un'area 20x20x20
local mezza_dimensione = { x = 10, y = 10, z = 10 }
local pos1 = vector.subtract(pos, mezza_dimensione)
local pos2 = vector.add     (pos, mezza_dimensione)

local param = {} -- dati persistenti tra un callback e l'altro
core.emerge_area(pos1, pos2, mio_callback, param)
```

Minetest chiamerà la funzione locale definita qua sotto `mio_callback` ogni volta che carica un blocco, con delle informazioni sul progresso.

```lua
local function mio_callback(pos, action,
        calls_remaining, param)
    -- alla prima chiamata, registra il numero di blocchi
    if not param.blocchi_totali then
        param.blocchi_totali  = calls_remaining + 1
        param.blocchi_caricati = 0
    end

    -- Incrementa il numero di blocchi caricati
    param.loaded_blocks = param.blocchi_caricati + 1

    -- Invia messaggio indicante il progresso
    if param.blocchi_totali == param.blocchi_caricati then
        core.chat_send_all("Ho finito di caricare blocchi!")
    else
        local percentuale = 100 * param.blocchi_caricati / param.blocchi_totali
        local msg  = string.format("Caricamento blocchi %d/%d (%.2f%%)",
                param.blocchi_caricati, param.blocchi_totali, percentuale)
        core.chat_send_all(msg)
    end
end
```

Questo non è l'unico modo per caricare blocchi; utilizzando un LVM (nel dettaglio nel capitolo 19) si potranno infatti caricare i blocchi selezionati in maniera sincrona.

## Cancellazione blocchi

Puoi usare `delete_area` per cancellare una serie di blocchi mappa:

```lua
-- Cancella un'area 20x20x20
local mezza_dimensione = { x = 10, y = 10, z = 10 }
local pos1 = vector.subtract(pos, mezza_dimensione)
local pos2 = vector.add     (pos, mezza_dimensione)

core.delete_area(pos1, pos2)
```

Questo cancellerà tutti i blocchi mappa in quell'area, anche quelli solo parzialmente selezionati.