{"id":33833,"date":"2025-08-13T11:55:47","date_gmt":"2025-08-13T09:55:47","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/?p=33833"},"modified":"2025-08-13T11:55:48","modified_gmt":"2025-08-13T09:55:48","slug":"le-basi-della-generazione-procedurale-di-terreno-in-unity","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/it\/frontend-it\/sviluppo-videogiochi\/le-basi-della-generazione-procedurale-di-terreno-in-unity\/","title":{"rendered":"Le basi della generazione procedurale di terreno in Unity"},"content":{"rendered":"\n

Nel contesto del game developement, la generazione procedurale del terreno \u00e8 una tecnica che utilizza algoritmi specifici per creare automaticamente ambienti di gioco<\/strong> (montagne, colline, isole…) in modo dinamico<\/strong>, ovvero senza che gli sviluppatori debbano realizzarli a mano.<\/p>\n\n\n\n

La generazione procedurale \u00e8 particolarmente comuni in giochi in cui si vuole fare in modo che il giocatore viva un’esperienza diversa ad ogni partita<\/strong>. \u00c8 infatti molto comune in quei videogiochi in cui il gameplay \u00e8 incentrato sull’esplorazione, la rigiocabilit\u00e0, la scoperta e la variet\u00e0 del mondo di gioco. Essa non \u00e8 limitata solo al terreno o al mondo di gioco, ma pu\u00f2 anche essere estesa a grafiche, effetti sonori, animazioni, questlines e molto altro.<\/p>\n\n\n\n

In questo articolo cerchiamo di capire meglio come funziona la generazione procedurale del terreno, osservando un esempio funzionante realizzato in Unity<\/strong>.<\/p>\n\n\n\n

Il funzionamento di un generatore procedurale, ad alto livello<\/h2><\/div>\n\n\n\n

Un generatore procedurale per un mondo di gioco \u00e8 essenzialmente un algoritmo che prende in input un numero intero, detto seed<\/strong>, e eventualmente altri parametri utili, e genera il mondo di gioco in maniera automatica sulla base dei parametri passati e del seed.<\/p>\n\n\n\n

Il seed \u00e8 utilizzato per garantire che il mondo sia generato in maniera deterministica<\/strong>: a parit\u00e0 di seed e parametri, il mondo generato dall’algoritmo sar\u00e0 sempre identico.<\/p>\n\n\n\n

Il seed \u00e8 infatti utilizzato per inizializzare uno o pi\u00f9 generatori di numeri pseudo-casuali<\/strong>, che, in quanto tali, generano numeri che sembrano casuali, ma che sono in realt\u00e0 completamente deterministici. Attraverso lunghe serie di trasformazioni, questi dati determinano la struttura del mondo di gioco.<\/p>\n\n\n\n

Questo pu\u00f2 non sembrare molto interessante, ma offre in realt\u00e0 un grande vantaggio: un mondo generato proceduralmente non ha bisogno di essere memorizzato localmente<\/strong>. Questo significa che anche mondi di dimensioni “infinite” sono tranquillamente realizzabili e riproducibili.<\/p>\n\n\n\n

Vediamo allora pi\u00f9 nel dettaglio una semplice implementazione per un generatore procedurale per il terreno di un generico mondo di gioco.<\/p>\n\n\n\n

Perlin noise – che cos’\u00e8 e come funziona<\/h2>\n\n\n\n

Il Perlin noise<\/strong> \u00e8 un tipo di rumore sviluppato da Ken Perlin<\/strong> nel 1983. Si tratta di una funzione pseudo-casuale che restituisce valori numerici compresi tra -1 e 1 che variano in maniera graduale<\/strong> e “naturale” tra loro.<\/p>\n\n\n\n

\"Immagine
Rappresentazione grafica del Perlin noise bidimensionale (normalizzato): le zone scure corrispondono a zone con valori prossimi allo zero, quelle chiare a zone con valori prossimi a 1.<\/figcaption><\/figure>\n\n\n\n

Il Perlin noise \u00e8 implementato creando una griglia sui cui vertici vengono definiti dei vettori di lunghezza unitaria con direzione scelta in maniera pseudo-casuale. Questi vettori sono detti “gradienti<\/strong>“.<\/p>\n\n\n\n

Per ogni singolo punto all’interno della griglia si calcola poi il vettore di offset<\/strong> rispetto ai vertici della cella della griglia in cui si trova il punto (che in 2D sono 4).<\/p>\n\n\n\n

Si calcola poi il prodotto scalare tra i vettori di offset e i gradienti dei rispettivi vertici. Si ottengono cos\u00ec degli scalari che sono poi “fusi” insieme tramite interpolazione<\/strong>, ottenendo il risultato sopra.<\/p>\n\n\n\n

Perlin noise – utilizzi<\/h2>\n\n\n\n

La maggior parte dei game engine mettono a disposizione funzioni come il Perlin noise pronte per l’uso. Tipicamente l’output di queste funzioni \u00e8 normalizzato nel range 0-1<\/strong>.<\/p>\n\n\n\n

Unity, ad esempio, mette a disposizione la funzione PerlinNoise<\/code> nella classe Mathf<\/code>, definita come:<\/p>\n\n\n

public<\/span> static<\/span> float PerlinNoise(float x, float y);<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Questa funzione prende in input i punti di sample x<\/code> e y<\/code>, da cui sar\u00e0 calcolato il valore in output.<\/p>\n\n\n\n
La chiave di moltissimi algoritmi di generazione procedurale del terreno \u00e8 utilizzare il valore in output dal Perlin noise come offset verticale per i vertici di un piano<\/strong>.<\/p>\n\n\n\n
Possiamo infatti costruire un piano suddiviso tante volte<\/strong> in modo da essere costituito da tante celle della stessa dimensione allineate a formare una griglia. Calcolando il Perlin noise in corrispondenza delle coordinate dei vertici della griglia<\/strong>, otteniamo un valore per ciascun vertice. Questo valore \u00e8 utilizzato per determinare di quanto alzare il vertice<\/strong> da cui \u00e8 stato calcolato.<\/p>\n\n\n\n
In questo modo il Perlin noise viene “proiettato” sul terreno, alzandolo e facendogli assumere una forma ondulatoria<\/strong>, simile a un paesaggio collinare.<\/p>\n\n\n\n
\n\n\n\n
Si noti che il metodo Mathf.PerlinNoise<\/code> offerto da Unity \u00e8 una funzione deterministica: dato lo stesso input, restituisce sempre lo stesso valore, ma non consente di specificare un seed in maniera diretta, perch\u00e9 non si basa su un generatore di numeri pseudo-casuali interno.<\/em><\/p>\n\n\n\n
\u00c8 comunque possibile simulare un comportamento simile al seed introducendo un offset costante nelle coordinate di input. Ad esempio, usando x + seedOffsetX<\/code> e y + seedOffsetY<\/code>, \u00e8 possibile ottenere varianti del terreno generate in modo consistente a partire da un seed arbitrario.<\/em><\/p>\n\n\n\n
Generazione della mesh<\/h2>\n\n\n\n
Per questo esempio rimaniamo su qualcosa di molto semplice. La prima cosa da fare \u00e8 costruire la mesh di partenza che poi deformeremo utilizzando il Perlin noise.<\/p>\n\n\n\n
La mesh in questione non \u00e8 altro che un piano suddiviso un certo numero di volte.<\/p>\n\n\n\n
Definiamo allora due variabili:<\/p>\n\n\n\n