Indie development: Il tirocinio

E dopo le premesse (e la lista della spesa) si può dare il via alle danze con Unity, e con tutto ciò che scaturirà dalle vostre cervella.

Occorrente:

• Unity 4.5 (più nuova è meglio è), link.
• Una minima conoscenza della lingua Inglese (e se non l’avete cazzi vostri, al giorno d’oggi la sua necessità è comparabile solo a quella del pane)
• Pazienza, tanta pazienza. (E se non l’avete pazienza ahaha)
• Un minimo di spirito di iniziativa (la guida fornisce il materiale, l’inventiva e le future scoperte spettano a voi, o pensavate di essere in presenza di un dio? O.o).

Partiamo subito con l’esplicare la struttura dell’editor, o quantomeno le aree fondamentali che vi consentiranno di districarvi nella creazione di progetti specifici senza dare di matto:

Compilazione

Settaggi fisica

Settaggi sonoro

Settaggi qualitativi

Settaggi esecuzione

Input

Tags e Layers

Console

Scene e Game

Implementazione pacchetti (default e custom)

Pacchetto image effects

Creazione elementi scena (nulli, primitivi, particle system ecc…)

Implementazione estensioni ad elementi scena

Creazione elementi di progetto (cartelle, script, shader, material, cubemap, render texture, prefab)

Lightmapping

E senza scendere troppo nei dettagli (gli screen ed i commenti sui nomi dei settaggi faranno il resto), passiamo subito alla struttura degli script (con annessa dentatura), che ricordo essere scritti in Javascript, dal momento che questo risulta essere quasi sempre la scelta migliore per un novello indie:

Struttura script

Lista funzioni maggiormente utilizzate in fase di progettazione:

function nomeascelta() {}: esegue il codice solo se chiamata mediante le seguenti istruzioni:

• nomeascelta();
• StartCoroutine(“nomeascelta”); (questa funzione risulta particolarmente utile se si è propensi ad avviare o stoppare la funzione più volte nel corso dell’esecuzione).
• StopCoroutine(“nomeascelta”); (in caso di suddetta situazione).

function Start() {}: esegue il codice una sola volta alla prima esecuzione della scena.

function Update() {}: esegue il codice in maniera costante, senza nessun salto di frame.

function FixedUpdate() {}: esegue il codice dopo aver saltato tot frame prestabiliti per la scena.

function LateUpdate() {}: esegue il codice in maniera costante, effettuando pause o salti di frame in presenza di funzioni yield.

function OnCollisionEnter(collision : Collision) {} / function OnTriggerEnter(collision : Collider) {}: esegue il codice una sola volta dopo una o più collisioni.

function OnCollisionStay(collision : Collision) {}: esegue il codice in maniera costante dopo una o più collisioni, se questa persistono.

function OnCollisionExit(collision : Collision) {} / function OnTriggerExit(collision : Collider) {}: esegue il codice una sola volta dopo essere usciti da una o più collisioni.

function OnMouseDown() {}: esegue il codice una sola volta, se viene effettuato un click sull’oggetto che la contiene.

function OnMouseOver() {}: esegue il codice una sola volta, se si esegue un passaggio sull’oggetto che la contiene.

function OnMouseExit() {}: esegue il codice una sola volta, dopo aver terminato OnMouseDown() ed eventuali click ad esso correlati.

Lista istruzioni maggiormente utilizzare in fase di progettazione:

Debug.Log(condizione o variabile): istruzione accessibile in sola lettura, che consente la semplice messa a console di una variabile o di una condizione, per verificarne i valori di output.

Debug.DrawLine(oggetto1.transform.position, oggetto2.transform.position, Color.white): istruzione utile a segnare la distanza fra 2 punti, mediante la presenza di una linea nella tab scene.

Physics.Linecast(oggetto1.transform.position, oggetto2.transform.position, oggettocolliso : RaycastHit): condizione di tipo boolean, che segna la distanza fra 2 punti mediante una linea nella tab scene, che restituisce un valore positivo o negativo in caso di collisione.

Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward)): condizione di tipo boolean, che restituisce un valore positivo o negativo, in base alla collisione di un “raggio” fittizio, basato sulla distanza fra la posizione di un oggetto e la direzione prescelta.

Screen.width: variabile di tipo int, che restituisce la larghezza dello schermo in base alla risoluzione.

Screen.height: variabile di tipo int, che restituisce l’altezza dello schermo in base alla risoluzione.

Screen.showCursor = false/true: istruzione di tipo boolean, che consente la disabilitazione o l’attivazione del cursore in fase di esecuzione.

Application.isEditor: condizione di tipo boolean, che restituisce un responso negativo o positivo in base all’area di esecuzione utilizzata (in questo caso l’editor).

Application.runInBackground = false/true: istruzione di tipo boolean, accessibile in lettura e scrittura, che consente o meno l’esecuzione di una scena in background.

Application.targetFrameRate = valore: istruzione di tipo int accessibile in lettura e scrittura, utile per settare un framerate massimo per la scena.

Application.loadLevel(idscena): istruzione che consente il caricamento di una specifica scena nella lista della compilazione (idscena).

yield: istruzione che consente lo skip di un singolo frame, o di più frame se accompagnato da un ciclo for o while.

yield WaitForSeconds(valore): istruzione che consente la messa in pausa del codice per tot secondi (non soggetta all’ammontare di fps).

Time.time: istruzione di tipo float, che fornisce un valore incrementale basato sul tempo di esecuzione di un singolo frame (varia in base agli fps).

Time.deltaTime: istruzione di tipo float, che fornisce un valore di esecuzione massimo per un singolo frame (varia in base agli fps).

Time.timeScale: Istruzione di tipo float, accessibile in lettura e scrittura, essa regola la velocità di esecuzione di uno scenario, sempre ammesso che esso contenga oggetti, la cui interazione è relegata ad istruzioni “Time” e non ad altre di tipo “Input” ad esempio.

if(condizione) {}: utile per l’esecuzione di una o più istruzioni nel momento in cui la condizione è verificata.

for(var nome = 0; var < massimovalore; nome++){ }: utile per cicli di una o più istruzioni.

while(condizione){yield}: utile per l’esecuzione di una o più istruzioni, fino a quando la condizione non è verificata (richiede la presenza di almeno uno yield).

transform.position: istruzione di tipo Vector3 accessibile in lettura e scrittura, essa regola la posizione di un oggetto utilizzando l’intera scena come coordinata iniziale.

transform.localPosition: istruzione di tipo Vector3 accessibile in lettura e scrittura, essa regola la posizione di un oggetto utilizzando l’oggetto parent (per avere un senso, tale istruzione richiede che l’oggetto in questione sia collegato ad un altro oggetto) come coordinata iniziale.

transform.eulerAngles: istruzione di tipo Vector3 accessibile in lettura e scrittura, essa regola la rotazione di un oggetto in gradi, con un range che va da 0 a 360, con un reset automatico a 0 superato il valore di 360

transform.rotation: istruzione di tipo Quaternion accessibile in lettura e scrittura, essa regola la rotazione di un oggetto in minimo e massimo, con un range che va da -1 a 1.

GetComponent.<Nome>() / GetComponent(Nome): istruzione che consente l’acquisizione di una qualsivoglia estensione presente sull’oggetto (camera, collider, script ecc…), con la possibilità di ricavarne o modificarne valori.

Variabile = Mathf.MoveTowards(variabile, massimo valore, tempo) / Variabile = Mathf.Lerp(variabile, massimo valore, tempo): funzioni matematiche che consentono la transizione da un valore inizio ad uno fine, i suddetti esempi si utilizzano in caso di singola variabile, tipo: int, float o componente specifico di variabili multi-campo, quali: Vector3, Quaternion o Color. In caso di variabili multi-campo complete invece, l’utilizzo della dicitura Mathf è sostituito dal tipo della variabile.

material.GetColor(“_NomeVariabileColoreShader”): istruzione di tipo Color, che consente l’accesso ai valori RGBA di un material.

material.SetColor(“_NomeVariabileColoreShader”, NomeVariabileColoreScript): istruzione che consente la modifica dei valori RGBA di un material.

Vector3.Distance(oggetto1.transform.position, oggetto2.transform.poition): istruzione di tipo float, che consente l’acquisizione della distanza assoluta fra 2 punti.

Input.GetButton(“nomeinput”): condizione di tipo boolean, che risulta verificata se uno specifico pulsante della tastiera viene premuto.

Input.GetAxis(“nomeasseinput”) <==> 0: condizione di tipo float, che risulta verificata se uno specifico pulsante o movimento, corrisponde al valore dell’asse (minore, maggiore o uguale a 0).

Input.touchCount: condizione che consente l’acquisizione del numero di tap a schermo.

Input.GetTouch(idtap): condizione di tipo boolean, che risulta verificata quando l’id del tap eseguito corrisponde ad idtap.

oggetto.SendMessage(“nomefunzione”): istruzione che consente di richiamare una funzione presente in uno script abbinato ad un oggetto.

elementoGUI.HitTest: condizione di tipo boolean valida solo per elementi di tipo GUI, che risulta verificata se il range di un tap o di un click, corrispondono alla posizione dell’elemento nella scena.

transform.Rotate(Vector3 * tempo): istruzione di tipo Vector3, che esegue una rotazione in una specifica direzione espressa in Vector3.

transform.Translate(Vector3 * tempo): istruzione di tipo Vector3, che esegue uno spostamento in una direzione espressa in Vector3.

Vector3.forward: istruzione di tipo Vector3 accessibile in sola lettura, che restituisce una direzione partendo dalla direzione della camera.

rigidbody.AddForce(Vector3.down * forzamassima): istruzione di tipo Vector3, che applica una forze verso una specifica direzione (richiesta estensione rigidbody su oggetto)

Variabileoggetto = Instantiate(variabilemodellooprefab, transform.position, transform.rotation): istruzione per lo spawn di un oggetto in scena.

Destroy(variabilemodellooprefab): istruzione per la rimozione di un oggetto dalla scena.

Note:

Per far si che una collisione si verifichi, oltre al canonico collider è necessario anche un rigidbody.

Nel caso la scelta di aggiungere un rigidbody si dimostrasse essere troppo esosa in termini prestazionali, allora la scelta di un Trigger è la migliore. In questo caso basta rimuovere i rigidbody da tutti gli oggetti secondari, lasciandone uno solo su quello primario, flaggando la casella isTrigger su tutti gli elementi secondari, e sostituendo le funzioni OnCollision con le OnTrigger.

Indie development: Il tirocinio