8.5 KiB
| title | layout | root | idx | description | redirect_from |
|---|---|---|---|---|---|
| Mappa: operazioni base | default | ../.. | 3.1 | Operazioni base come set_node e get_node | /it/chapters/environment.html |
Introduzione
In questo capitolo imparerai come eseguire semplici azioni sulla mappa.
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:
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àignorequando 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:
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:
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.
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.
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:
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:
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.
-- 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.
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:
-- 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.