212 lines
8.5 KiB
Markdown
212 lines
8.5 KiB
Markdown
---
|
|
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.
|