Share
In questo tutorial ti mostrerò le basi dell'utilizzo della personalizzazione procedurale dell'oggetto a tuo vantaggio, in Unity. In sostanza si riduce a usando la casualità all'interno di certe regole. Se utilizzi una sorta di sistema procedurale (anche semplice), puoi aggiungere un'ampia varietà di diversità e dettagli al tuo gioco, senza doverli creare tutti manualmente.
Inizieremo creando manualmente un albero semplice e quindi utilizzeremo tecniche di personalizzazione procedurale per automatizzare la creazione di una gamma di alberi simili ma notevolmente diversi. Quindi, metteremo questi alberi in un gioco semplice, per mostrare come appaiono in "azione".
Ecco come appariranno i nostri alberi generati proceduralmente:
Come nel mio precedente tutorial, dovrai aver installato Unity e avere una conoscenza di base di ciò. (Vedi Come imparare Unità per un buon punto di partenza.)
Crea un nuovo progetto per questo tutorial e seleziona la casella di controllo controller di caratteri; potremmo averne bisogno in seguito.
Ho preparato alcuni alberi che useremo, che puoi trovare nel 3d-files cartella del download sorgente. I file dell'intero progetto, nel caso in cui si desideri utilizzarli, possono anche essere trovati nel download sorgente, ma non sono necessari per questo tutorial.
Pronto? Andiamo!
Iniziamo con la creazione di un albero semplice poiché, per aggiungere tocchi procedurali, abbiamo bisogno di un modello base da cui partire.
Metti i file 3D che ho menzionato sopra nella cartella delle risorse. Ricordarsi di impostare il ridimensionamento nell'importatore su 1 piuttosto che 0.001, in modo che le taglie si allineino.
Ora crea un cubo e chiamalo Albero. Vai al Filtro a rete componente e scambiare la mesh del cubo per il tree_01 maglia. Dovrebbe apparire se hai i file 3D nella tua cartella delle risorse.
L'albero potrebbe non essere ancora completamente visualizzato. Questo perché il modello 3D per l'albero supporta due materiali (corteccia e foglie), ma al momento è ancora impostato su uno. Per risolvere questo problema, apri il materiale matrice nel Renderizzatore di mesh componente del cubo e impostare il Taglia a 2. Dovrebbe sembrare come questo:
Ora abbiamo bisogno di materiali per la corteccia e le foglie. Crea due nuovi materiali e dai loro un colore marrone e verde di base. Assegna questi due materiali al materiale slot nel Renderizzatore di mesh dell'albero, e dovrebbe apparire con quei materiali visualizzati, come questo:
Per completare questo albero base, aggiungi un collettore di capsule facendo clic Componente> Fisica> Capsule Collider. Questo è così che non ci sposteremo "attraverso" l'albero quando lo testeremo più tardi. Unity ti chiederà se vuoi sostituire il box collider corrente sull'albero, che dovresti confermare. Una volta aggiunto il nuovo collisore, modificare i valori in modo che la forma della capsula si sovrapponga approssimativamente al tronco dell'albero, in questo modo:
Questi valori funzioneranno:
Ora, trascina l'oggetto albero nella cartella del progetto per trasformarlo in prefabbricato. Il nostro albero base è finito!
Crea un nuovo script chiamato tree.js e aggiungilo al prefabbricato dell'albero. Ora, aggiungi le seguenti linee al Inizio() funzione:
transform.localEulerAngles.y = Random.Range (0, 360);
L'albero verrà ora ruotato di una quantità casuale sull'asse y quando viene creato. Ciò significa che se posizioni una fila di alberi, in questo modo:
... poi si girano tutti nella propria direzione all'avvio del gioco. Metti un gruppo di alberi nel tuo livello e provalo!
In un modo simile, possiamo cambiare la dimensione di qualsiasi oggetto. Aggiungi il seguente codice al tree.js script:
transform.localScale = transform.localScale * Random.Range (0.5, 1.5);
Ciò ridurrà o aumenterà la dimensione dell'albero. Se inizi con una scala di 1 (che dovrebbe essere il caso se tutto è impostato correttamente), la nuova scala sarà tra 0,5 (la metà grande) e 1,5 (il 50% più grande). Ora i tuoi alberi dovrebbero apparire ancora più diversi:
Potresti aver notato che ci sono in realtà tre alberi nei file che ti ho dato in precedenza. Questo perché ora stiamo per cambiare casualmente il modello 3D per un altro, creando ancora più alberi dal modello.
Per fare ciò, aggiungi il seguente codice al tree.js script:
var treeMeshes: Mesh []; function Start () gameObject.GetComponent (MeshFilter) .mesh = treeMeshes [Random.Range (0, treeMeshes.Length)];
Prima di iniziare la scena, però, assegna le tre mesh che abbiamo a quell'array, in questo modo:
Se suoni la scena, noterai che ora ottieni tre diverse maglie degli alberi, assegnate casualmente.
Puoi provare tutto questo nella demo qui sotto. Se premi il pulsante, tutti gli alberi saranno sostituiti con nuovi e unici.
Questo potrebbe essere un po 'complicato. Oltre a tutte le funzionalità precedenti, daremo ad ogni albero una tonalità unica di verde e marrone.
Per prima cosa, dobbiamo sapere come accedere ai colori. Solitamente il materiale di un oggetto è accessibile tramite renderer.material.color. Nel nostro caso, tuttavia, abbiamo due colori, il che significa che dobbiamo accedervi tramite renderer.materials [0] .color e renderer.materials [1] .color. Controlla il renderer mesh dell'albero per vedere quale materiale (foglie o corteccia) si trova nello slot 0 e quale è nello slot 1.
La creazione di un colore casuale funziona in modo simile ai passaggi precedenti. Se aggiungi queste righe:
renderer.materials [0] .color = Color (Random.Range (0, 1.1), Random.Range (0, 1.1), Random.Range (0, 1.1)); renderer.materials [1] .color = Color (Random.Range (0, 1.1), Random.Range (0, 1.1), Random.Range (0, 1.1));
... quindi sia il materiale della corteccia che il materiale delle foglie otterranno un colore completamente nuovo assegnato. Controlliamolo:
Ok, non è quello che stiamo effettivamente facendo. Questi sono colori casuali dell'intero spettro disponibile! Per oggetti artificiali, come le auto, questo potrebbe essere sufficiente. Ma abbiamo alberi, quindi abbiamo bisogno di verdi e marroni.
Sostituisci il codice colore che abbiamo appena aggiunto con questo:
renderer.materials [0] .color = Color (Random.Range (0.8, 1.1), Random.Range (0.4, 0.6), Random.Range (0, 0.2)); renderer.materials [1] .color = Color (Random.Range (0, 0.4), Random.Range (0.6, 1.1), Random.Range (0, 0.4));
E provalo:
Molto meglio. (Se improvvisamente le foglie sono marroni e il tronco è verde, scambia il 1 e 0 nel renderer.materials [0].)
Il codice produce un nuovo colore all'inizio del colore del programma. I tre valori casuali vanno da 0 (minimo) a 1 (massimo), che corrisponde quindi ai valori rosso, verde e blu del colore. Limitando la portata della casualità, come dicendo Random.Range (0.3, 0.6), i valori sono limitati a un certo intervallo. Questo ci consente di creare una gamma di nuovi colori che sono ancora "verdi" o di qualsiasi colore che potremmo specificare.
Questo è solo un piccolo ritocco, ma comunque bello. Possiamo lasciare l'albero leggermente inclinato su un lato, eliminando quella sensazione di "posizione pulita" che potrebbe essersi presentata in precedenza
transform.localEulerAngles.x = Random.Range (-10, 10);
Questa volta viene applicata una rotazione molto piccola all'asse x, facendo inclinare l'albero in quella direzione. Per assicurarsi che non vi sia uno "spazio" tra le radici dell'albero e il terreno, il "perno" (o il centro) delle maglie degli alberi è leggermente al di sopra delle radici, il che significa che c'è abbastanza spazio per la manovra disponibile.
L'intero albero-script dovrebbe assomigliare a questo:
var treeMeshes: Mesh []; function Start () transform.localEulerAngles.y = Random.Range (0, 360); transform.localEulerAngles.x = Random.Range (-10, 10); transform.localScale = transform.localScale * Random.Range (0.5, 1.5); gameObject.GetComponent (MeshFilter) .mesh = treeMeshes [Random.Range (0, treeMeshes.Length)]; renderer.materials [0] .color = Color (Random.Range (0.8, 1.1), Random.Range (0.4, 0.6), Random.Range (0, 0.2)); renderer.materials [1] .color = Color (Random.Range (0, 0.4), Random.Range (0.6, 1.1), Random.Range (0, 0.4));
Puoi provare tutto in questa demo:
Vediamo come si sentono in un gioco reale.
Metti un aereo a terra e ridimensionalo. Questo sarà il nostro "piano" per il livello. Mentre ci sei, crea un materiale per il pavimento e assegnalo al pavimento. Impostare il fattore di scala del piano su 50.1.50, quindi abbiamo abbastanza spazio.
Quindi, metti un controllore in prima persona nella scena. Può essere trovato nei controller di caratteri che sono stati importati all'inizio del tutorial. (Se non li hai, clicca Risorse> Importa pacchetto> Controller caratteri). Dopo aver posizionato i controller FPS, rimuovere la fotocamera principale; il controller viene fornito con il suo, quindi non avremo più bisogno della telecamera nella scena. Inoltre, aggiungi una luce direzionale.
Per creare automaticamente alberi, crea un nuovo file JavaScript e chiamalo treeGenerator.js. Inserisci il seguente codice:
var treePrefab: GameObject; var numberOfTrees: int = 20; function Start () for (var i: int = 0; i < numberOfTrees; i++) Instantiate(treePrefab, Vector3(transform.position.x + Random.Range(-40.0, 40.0), 0, transform.position.z + Random.Range(-40.0, 40.0)), transform.rotation);
Metti il treeGenerator.js script sul pavimento, assegnare il prefabbricato dell'albero al treePrefab slot variabile e provalo:
E fatto! Ora hai un semplice gioco esplorativo, che creerà un livello unico per ogni corsa.
Il gioco che hai ora può essere esteso selvaggiamente. Potresti aggiungere più piante, come palme o cespugli. Potresti aggiungere altri oggetti, come rocce o mele. O potresti aggiungere qualche tipo di moneta o di pickup, che il giocatore potrebbe eseguire per aumentare il proprio punteggio.
I tocchi procedurali sono un modo semplice ed efficace per creare automaticamente i dettagli. Invece di avere dieci oggetti, potresti avere infinitamente molti.
Puoi utilizzare gli elementi con cui abbiamo giocato nel tuo gioco, oppure puoi smontarli e riscriverli per adattarli ai tuoi scopi. Ad esempio, ho creato un sistema che crea diverse lunghezze di bambù:
Puoi creare auto con elementi variabili o posizionare automaticamente i nemici in un livello. Le possibilità sono infinite.
Accentsconagua