Come creare un'app Android usando Unity

Prima di iniziare, dovrei probabilmente menzionare che questo sarà un tutorial piuttosto lungo. Quindi preparatevi. Alla fine di questo tutorial sarai in grado di affrontare il mondo (in senso figurato).

Circa 2 anni fa, ho approfondito nuovi territori e ho seguito un corso di Game Design. Non avevo mai provato a fare un gioco correttamente prima di questo. Avevo provato ad entrare nella programmazione, ma non potevo impegnarmi. Ho scritto forse un paio di programmi da riga di comando molto semplici che erano lunghi poche righe e poi ho rinunciato perché non riuscivo a pensarci.

Quindi, quando ho effettivamente iniziato il mio corso, non ero assolutamente abituato. Nel corso dei due anni ho imparato molto e ho fatto ottimi progressi e persino progettato e programmato alcuni giochi e app, di cui 2 per Android.

Andando un po 'più in dettaglio. Dato che si trattava di un corso, mi è stato richiesto di imparare tutto ciò che riguarda la progettazione e lo sviluppo del gioco. Ho imparato come generare idee di gioco, come scrivere una storia per il gioco, come concettualizzare i personaggi (in realtà non ho progettato alcun personaggio), come creare un documento di progettazione del gioco (che è molto utile, non ha per essere estremamente dettagliato se sei uno sviluppatore indipendente), come utilizzare Unity Game Engine per creare effettivamente il gioco, come testarlo correttamente e come costruire un gioco per piattaforme diverse.

Passaggio 1: sommario

  1. Sommario
  2. Cose che devi sapere prima di iniziare
  3. Come configurare Unity e Android Studio
  4. Impostazione del progetto e creazione di prefabbricati in particelle
  5. Creazione e aggiunta di effetti Script
  6. Creazione e aggiunta di controlli touch
  7. analisi
  8. Creazione del menu principale e HUD
  9. Gerarchia organizzatrice
  10. Conclusione

Passaggio 2: cose che devi sapere prima di iniziare

Molte persone potrebbero avere l'idea sbagliata che la progettazione / sviluppo del gioco sia estremamente difficile e richiede molte conoscenze preliminari per realizzarne effettivamente uno. Tuttavia, questo è lontano dalla verità. L'uso di un motore di gioco ridurrà drasticamente la curva di apprendimento e ti consentirà di concentrarti maggiormente sul divertimento del gioco. Esistono vari motori di gioco diversi, le opzioni più popolari sono:

  • Unità
  • Unreal Engine
  • CryEngine

Unity e Unreal Engine sono più popolari di CryEngine. Questo perché sono rivolti agli sviluppatori Indie insieme agli sviluppatori AAA, al contrario di CryEngine, che è rivolto solo agli sviluppatori AAA. La differenza tra Indie e AAA:

Le indie sono composte da piccoli team, di solito 1-20 persone e non dispongono di grandi quantità di fondi, ecc.

Alcuni esempi di sviluppatori Indie:

  • Coffee Stain Studios
  • Halfbrick Studios
  • Mojang
  • Creazioni Ndmeic

Gli AAA sono composti da team molto più grandi e hanno molta esperienza nel settore insieme a molti fondi. Qualche esempio:

  • EA
  • Ubisoft
  • Gameloft
  • Treyarch
  • Activision

Un motore di gioco è un programma progettato per rendere molto più semplice la progettazione / sviluppo del gioco. Invece di dover codificare tu stesso ogni singolo aspetto del gioco, puoi semplicemente scrivere il comportamento usando un motore di gioco. Ciò è reso possibile dal fatto che i motori di gioco fanno molto del lavoro per te, cose come la fisica, l'illuminazione, il rendering ecc. Sono tutti fatti per te. Tutto quello che devi fare è creare gli oggetti di gioco (questi sono solo contenitori con diversi elementi collegati), impostare l'ordine e il layout, assegnare le proprietà pertinenti agli oggetti di gioco e scrivere il comportamento.

Alcuni motori di gioco in realtà ti consentono di creare un intero gioco senza alcuna codifica richiesta, il più popolare è Unreal Engine. È dotato di un sistema Blueprints, che utilizza una struttura basata su nodi (che è essenzialmente solo un sistema che utilizza caselle e frecce. Queste caselle e frecce sono collegate se fanno parte della stessa funzione). Supponiamo che tu voglia intercettare l'input da tastiera (questo significa semplicemente dire al programma di cercare un tasto premuto sulla tastiera) e quindi far muovere il giocatore finché quel tasto specifico viene tenuto premuto. Dovresti creare un nodo base, che conterrebbe le sottofunzioni necessarie. In quel nodo base dovresti dichiarare la chiave che volevi usare, quindi creare un altro nodo che dice al gioco cosa fare. Il nodo base sarebbe una casella contenente la funzione per premere il tasto.

In questo caso, il secondo nodo farebbe muovere il giocatore in una direzione (avanti, per esempio) fintanto che il tasto "W" viene tenuto premuto. Il secondo nodo sarebbe un'altra casella collegata alla prima casella. Ciò è estremamente utile, non solo per i progettisti, ma anche per i programmatori in quanto consente loro di creare rapidamente prototipi. Unity ha anche questa funzione, nota come script visivi. Tuttavia, assume la forma di un bene che è necessario acquistare.

L'unità è in realtà migliore per i principianti che desiderano creare giochi in quanto ti insegna a scrivere. Unreal Engine è molto più avanzato, anche se presenta script visivi. Ciò significa che esiste una curva di apprendimento più ampia.

Passaggio 3: Come configurare Unity e Android Studio

Quindi ora sai qualcosa in più sui motori di gioco e su come funzionano. In questa esercitazione verrà utilizzato Unity 5.3.5 che è la versione più recente in questo momento. Ti insegnerò come creare un'app Android esteticamente piacevole. Questo tutorial presuppone che tu abbia una conoscenza di base dell'utilizzo di Unity. Se sei un principiante completo e vuoi seguire questo tutorial, visita questo link per conoscere le basi di Unity: //pixelnest.io/tutorials/2d-game-unity/

Assicurati di disporre sempre dell'ultima versione di Unity in quanto contengono correzioni di bug e miglioramenti. Se si dispone di una versione precedente di Unity, è possibile che si verifichino errori. Questi errori possono di solito essere corretti aggiornando. Dovrei anche menzionare che la costruzione per qualsiasi piattaforma mobile richiede il rispettivo SDK installato sul tuo computer (per Android, è necessario Android Studio. Per iOS, è necessario un Mac con Xcode installato.) Per scaricare Android Studio, seguire questo collegamento e impostarlo utilizzando le istruzioni fornite sul sito Web: //developer.android.com/studio/index.html

Una volta installato, dovrai installare i driver per il tuo telefono aprendo Android Studio, facendo clic su Configura> Gestore SDK, quindi su Avvia Gestore SDK autonomo. Si aprirà una nuova finestra, scorrerà fino in fondo e assicurerà che entrambi i driver USB e Web di Google siano selezionati. È possibile lasciare gli altri componenti selezionati per impostazione predefinita. Quindi fare clic su Installa pacchetti in basso a destra e attendere l'installazione. Una volta fatto, vai all'app Impostazioni sul tuo telefono> Informazioni / Informazioni sul telefono> Informazioni sul software e individua l'intestazione "Numero build". Dovrebbe essere una raccolta di numeri con decimali e "chiavi di rilascio" aggiunti alla fine. Tocca il "Numero di build" più volte fino a quando dice "Congratulazioni, ora sei uno sviluppatore" o qualcosa di simile. Quindi torna alla pagina Impostazioni principali e individua "Opzioni sviluppatore". Fare clic su di esso e individuare la casella di controllo "Debug USB". Assicurarsi che sia selezionato. Quindi collega il telefono al computer e assicurati che nella barra delle notifiche sia visualizzato "Debug USB abilitato" o qualcosa di simile, dovrai probabilmente espandere la barra per visualizzare il messaggio.

Indipendentemente dal fatto che tu voglia installare i driver per il tuo telefono per usarlo in Unity, dovrai avere Android Studio installato, poiché senza di esso non puoi effettivamente creare l'app per il tuo telefono. Se l'impostazione dei driver è troppo noiosa, seguire le opzioni alternative nella sezione Test di questo tutorial. Dopo aver installato Android Studio e impostato il debug USB, puoi tornare indietro e seguire questo tutorial.

Questo tutorial è basato su un altro tutorial, ti fornirò il link se vuoi controllarlo. //pixelnest.io/tutorials/unity-touch-controls ...

Il mio tutorial copre più dell'originale (Menu, HUD e Test). Il linguaggio di programmazione che userò per questo tutorial è C #. Unity supporta anche JavaScript, tuttavia, C # ha funzionalità più avanzate, sebbene sia leggermente più difficile da imparare. Sei libero di convertire il codice C # in JS se conosci già JS ma, sfortunatamente, non sarò in grado di tenere conto di eventuali errori specifici della lingua se decidi di usarlo. Ti insegnerò anche alcuni suggerimenti e trucchi che ho imparato durante il mio tempo a creare giochi. Cominciamo.

Passaggio 4: impostazione del progetto e creazione di prefabbricati in particelle

Impostazione del progetto

Dopo aver creato correttamente il tuo progetto, assicurati di avere le seguenti cartelle nella cartella delle risorse:

  • Caratteri
  • materiale
  • Menù
  • prefabbricati
  • scene
  • Script
  • Textures

Queste sono le uniche cartelle necessarie per questo progetto. Tuttavia, se decidi di espanderlo, sei libero di aggiungere qualsiasi altra cartella come ritieni opportuno (suoni, animazioni ecc.)

Dopo aver creato le cartelle precedenti, vai su File> Impostazioni di creazione. In questa finestra fai clic sull'opzione Android sotto l'intestazione "Piattaforme", quindi fai clic su "Cambia piattaforma" nell'angolo in basso a sinistra. Questo dirà a Unity che stai costruendo per Android e imposterà il progetto rispettivamente. Avrai bisogno di Android Studio installato affinché questo funzioni. Quindi salva la scena premendo Ctrl + S o selezionando "Salva scena" nel menu File. Salvare questa scena come "Scena principale" nella cartella "Scene".

Creazione di prefabbricati in particelle

Sopra è l'immagine di una stella con uno sfondo nero. Salva questa immagine nella cartella Trame. Lo userai per il sistema particellare.

Imposta il Tipo di trama su Trama facendo clic sull'immagine nella cartella Trame e selezionando il valore appropriato in Impostazioni, quindi fai clic su Applica. Assicurati che la casella "Alpha Is Transparency" sia selezionata. Ciò renderà trasparente lo sfondo della stella.

Quindi crea un sistema particellare e impostalo utilizzando i valori mostrati nello screenshot sopra.

Sentiti libero di modificare questi valori, se lo desideri, sono solo una linea guida. Giocare con questi valori ti darà una migliore comprensione di come funziona.

Assicurati che la Trama del sistema particellare sia impostata sulla Trama stellare espandendo lo Shader e selezionando la Trama stellare nella casella a destra. Oppure puoi semplicemente trascinare e rilasciare l'immagine dalla cartella Textures nella casella. Seleziona anche Mobile / Particle / Alpha Blended Shader facendo clic sulla casella a discesa accanto a Shader, quindi Mobile> Particelle> Alpha Blended. Questo dirà al sistema particellare di rendere trasparente lo sfondo della Stella e di ottimizzarlo per Android. Cambia il nome in alto nella finestra di ispezione in "Esplosione" e fai lo stesso nella Gerarchia. Quindi trascina questo Sistema di particelle esplosive dalla Gerarchia nella cartella Prefabs nella vista Progetto. Ciò creerà un prefabbricato di quel sistema particellare.

Successivamente creeremo un Prefabbricato Trail, che traccerà una traccia fintanto che trascini il dito sullo schermo. Quando sollevi il dito, il sentiero scompare dopo un paio di secondi.

Crea un nuovo oggetto di gioco vuoto (fai clic con il tasto destro nella Gerarchia e seleziona "Crea vuoto") e chiamalo Percorsi o qualcosa di simile. Quindi aggiungere un componente Trail Renderer ad esso. Configuralo usando i valori forniti nello screenshot sopra.

Crea un nuovo materiale facendo clic sulla cartella Materiali nella vista del progetto, quindi fai clic con il pulsante destro del mouse nella vista del progetto e fai clic su Crea> Materiale. Denominare il materiale come Materiale delle piste o Tappeto delle piste.

Quindi fai clic sull'oggetto di gioco Trails nella Gerarchia e trascina il tappetino Trails dalla vista Progetto alla finestra di ispezione. Questo assegnerà il Materiale all'oggetto di gioco Trails. Quindi trascina questo oggetto di gioco Trails nella cartella Prefabs per renderlo un prefabbricato.

Infine, creeremo un altro sistema di particelle diverso dal primo. Questo esploderà lentamente verso l'esterno, non avrà gravità e svanirà lentamente. Crea un altro sistema particellare, chiamalo Pinch Explosion (useremo un gesto pizzico per inizializzarlo). Assicurati che il materiale stellare sia assegnato a questo sistema di particelle, quindi trasformalo in un prefabbricato.

Questi sono tutti gli effetti che utilizzeremo. Sentiti libero di crearne di più, se lo desideri, o di modificare quelli esistenti. Un'ultima cosa prima di poter passare alla programmazione. Fai clic sulla videocamera principale nella Gerarchia. Cambia il colore di sfondo in nero o in un altro colore scuro e modifica le sue dimensioni (sotto la casella a discesa Proiezione) da 5 a 10. Ciò ti permetterà di vedere più dello sfondo. Guarda lo screenshot finale sopra se sei confuso.

Passaggio 5: Creazione e aggiunta di effetti Script

Creare lo script

Ora che abbiamo creato tutti i prefabbricati, possiamo passare alla programmazione. Dovrai scrivere un bel po 'di codice poiché si tratta di un tutorial più avanzato. In realtà ho un documento che spiega le basi della programmazione se sei interessato. Anche questa è un'altra lettura approfondita. L'ho caricato su Dropbox, ecco il link:

//bit.ly/29qhLDx

Crea un nuovo script C # nella cartella Script (fai clic sulla cartella Script, quindi fai clic con il pulsante destro del mouse nella finestra Progetto> Crea> Script C #) ed etichetta questo script come "SpecialEffects". Aprilo nell'IDE (Integrated Development Environment) desiderato e scrivi il codice seguente, parola per parola. Il motivo per cui ti sto dicendo di scriverlo parola per parola invece di copiarlo / incollarlo è perché digitarlo ti permetterà di capire cosa fa meglio il codice. Ti porterà anche alla pratica di controllare il tuo codice per eventuali errori. Ecco il codice:

 {/ * Rende questo script uno statico privato, il che significa che le funzioni di questo script non sono accessibili al di fuori di questo script e i suoi valori non cambiano mai a meno che tu non lo dica specificamente all'istanza SpecialEffects * / private static; 
 // Questi sono i prefabbricati pubblici ParticleSystem esplosionEffect, pizzicoExplosionEffect; GameObject trail pubbliciPrefab; 
 / * Questa funzione è attivata alla prima inizializzazione dello script, prima della funzione Start. La funzione Start richiede che questo script sia abilitato ma la funzione Awake viene eseguita indipendentemente dal fatto che questo script sia abilitato * / void Awake () {// Assegnando il valore dell'istanza a questa istanza dello script = this; } 
 // Utilizzalo per l'inizializzazione void Start () {// Assicurati che tutti i prefabbricati siano attivati ​​se (exploreEffect == null) Debug.LogError ("Missing Explosion Effect"); if (pinchExplosionEffect == null) Debug.LogError ("Effetto esplosione pizzico mancante"); if (trailsPrefab == null) Debug.LogError ("Prefabbricati mancanti"); } 
 // Effetto pubblico di esplosione ParticleSystem statico MakeExplosion (posizione Vector3) {// Se questo script è disabilitato, registra un errore se (istanza == null) {Debug.LogError ("Non esiste uno script SpecialEffects sulla scena"); restituisce null; } 
 // Crea l'effetto di esplosione nella posizione specificata ParticleSystem effect = Instantiate (instance.explosionEffect) come ParticleSystem; effect.transform.position = position; // Distrugge l'effetto Explosion dopo che Effect ha completato Destroy (effect.gameObject, effect.duration); effetto di ritorno; } 
 // Pinch Explosion Effect pubblica statica ParticleSystem MakePinchExplosion (posizione Vector3) {// Se questo script è disabilitato, registra un errore se (istanza == null) {Debug.LogError ("Non ci sono script SpecialEffects nella scena"); restituisce null; } 
 // Crea un'esplosione di pizzico nella posizione specificata ParticleSystem effect = Instantiate (instance.pinchExplosionEffect) come ParticleSystem; effect.transform.position = position; effetto di ritorno; } 
 // GameObject pubblico statico Trail Effect (posizione Vector3) {// Se questo script è disabilitato, registra un errore se (istanza == null) {Debug.LogError ("Non esiste uno script SpecialEffects nella scena"); restituisce null; } // Crea una nuova traccia nella posizione impostata GameObject trail = Instantiate (instance.trailsPrefab) come GameObject; trail.transform.position = position; pista di ritorno; } 

Aggiunta dello script alla scena

Vedi, non è stato troppo difficile, vero? Ora che abbiamo questo script pronto, possiamo aggiungerlo alla scena. Crea un nuovo oggetto di gioco vuoto, etichettalo come script e trascina lo script dalla cartella Scripts sull'oggetto di gioco script.

Ora assegna le Variabili ai rispettivi Prefabbricati trascinando il Prefabbricato dalla cartella Prefabbricati nella Vista Progetto alle proprietà Script nella Finestra Ispettore. Vedi lo screenshot sopra per riferimento.

Passaggio 6: creazione e aggiunta di script per i controlli touch

Creare lo script

Ora è il momento di programmare i controlli touch per questa app. La funzione principale di questa app è quella di attivare effetti quando si tocca lo schermo. I tre gesti che utilizzeremo saranno un tocco, uno scorrimento e un pizzico per ingrandire. Puoi anche aggiungere più gesti, se lo desideri, ma dovrai farlo da solo.

Gli effetti che attiviamo varieranno in base al tipo di input tattile (tocca, scorri, pizzica per ingrandire ecc.) Ciò ci consentirà di garantire il riconoscimento del gesto corretto.

Il metodo con cui rileveremo questi gesti sta usando la classe "Input" di Unity, che consolida tutte le informazioni su ogni tipo di Input in una posizione. Alcuni esempi di altri input sono tastiera, controller di console o touch.

Unity ha una sottoclasse specifica denominata Input.touches e contiene gli eventi per i vari tipi di tocchi insieme al loro stato in un determinato frame.

Un Touch è un contenitore che contiene le informazioni sulle varie dita, che vedremo durante la programmazione dei controlli touch.

Il primo tipo di metodo touch che implementeremo è un pizzico, quindi il tocco, quindi il colpo. Un pizzico è quando lo schermo viene toccato con due dita e trascinato verso l'esterno o verso l'interno. Un tocco è quando lo schermo viene toccato per un breve periodo di tempo (di solito un secondo). È simile a un clic del mouse. Un colpo è quando lo schermo viene toccato con un dito e trascinato lungo lo schermo.

Crea un nuovo script nella cartella Script ed etichettalo come "TouchControls". Quindi digitare il seguente codice nella funzione Aggiorna.

 utilizzando UnityEngine; utilizzando System.Collections.Generic; 
 TouchControls di classe pubblica: MonoBehaviour {percorsi Dizionario privato = nuovo Dizionario (); private Touch pizzicoFinger1, pizzicoFinger2; private ParticleSystem pizzicoEsplosione; 
 // Usa questo per l'inizializzazione void Start () {} // L'aggiornamento viene chiamato una volta per frame void Update () {// Questi sono i controlli touch 
 // Utilizza un loop per cercare tutte le dita // Controlli per Pizzica per ingrandire, funziona solo con 2 dita // Se sullo schermo sono visualizzate 2 dita se (Input.touchCount == 2) {// Assegna queste 2 dita alle proprie variabili var finger1 = Input.GetTouch (0); var finger2 = Input.GetTouch (1); 
 if (finger1.phase == TouchPhase.Began && finger2.phase == TouchPhase.Began) {this.pinchFinger1 = finger1; this.pinchFinger2 = finger2; } 
 // Quando le dita si sono spostate, aggiorna lo script nella nuova posizione se (finger1.phase == TouchPhase.Moved || finger2.phase == TouchPhase.Moved) {float baseDistance = Vector2.Distance (this.pinchFinger1.position, this.pinchFinger2.position); float currentDistance = Vector2.Distance (finger1.position, finger2.position); 
 // Float purcent currentDistancePurcent = currentDistance / baseDistance; 
 // Crea l'effetto tra le dita se non esiste attualmente se (pinchExplosion == null) {Vector3 finger1Position = Camera.main.ScreenToWorldPoint (this.pinchFinger1.position); Vector3 finger2Position = Camera.main.ScreenToWorldPoint (this.pinchFinger2.position); 
 // Trova il centro tra le 2 dita Vector3 pinchExplosionPosition = Vector3.Lerp (finger1Position, finger2Position, 0.5f); pinchExplosion = SpecialEffects.MakePinchExplosion (pinchExplosionPosition); } 
 // Prende la scala di base e aumenta o diminuisce pinchExplosion.transform.localScale = Vector3.one * (currentDistancePurcent * 1.5f); }} 
 else {// Se il pizzico è stato rilasciato if (pinchExplosion! = null) {// Crea Esplosioni per (int i = 0; i <10; i ++) {var explore = SpecialEffects.MakeExplosion (pinchExplosion.transform.position); explosion.transform.localScale = pinchExplosion.transform.localScale; } 
 // Distruggi effetto esplosione Pizzica Distruggi (pinchExplosion.gameObject); } 
 // Effetto Tap // Controlla tutte le dita per (int i = 0; i <Input.touchCount; i ++) {Touch touch = Input.GetTouch (i); 
 // Un tocco è un tocco rapido e rilascio se (touch.phase == TouchPhase.Ended && touch.tapCount == 1) {// I tocchi sono posizioni dello schermo, questo li converte in posizioni del mondo Vector3 position = Camera.main. ScreenToWorldPoint (touch.position); 
 // Crea l'effetto Explosion SpecialEffects.MakeExplosion ((position)); } 
 else {// Controls for the Swipe Gesture if (touch.phase == TouchPhase.Began) {// Memorizza questo nuovo valore if (trails.ContainsKey (i) == false) {// I tocchi sono posizioni dello schermo, questo li converte nelle posizioni del mondo Vector3 position = Camera.main.ScreenToWorldPoint (touch.position); // Assicura che il percorso sia visibile position.z = 0; 
 // Crea l'effetto Trails GameObject trail = SpecialEffects.MakeTrail (position); 
 // Se la traccia è ancora abilitata if (trail! = Null) {// Registra la traccia Debug.Log (trail); // Aggiungi alcuni percorsi in più. Aggiungi (i, percorso); }}} 
 else if (touch.phase == TouchPhase.Moved) {// Sposta il percorso if (trails.ContainsKey (i)) {// Array for the Trails GameObject trail = trail [i]; 
 // Converte i tocchi nelle posizioni del mondo Camera.main.ScreenToWorldPoint (touch.position); Posizione Vector3 = Camera.main.ScreenToWorldPoint (touch.position); // Assicura che la scia sia visibile position.z = 0; 
 // Imposta la posizione dei percorsi sulla posizione del dito trail.transform.position = position; }} 
 else if (touch.phase == TouchPhase.Ended) {// Cancella tutti i percorsi visibili if (trails.ContainsKey (i)) {GameObject trail = percorsi [i]; 
 // Dissolve i percorsi Destroy (trail, trail.GetComponent (). Time); trails.Remove (i); }}}}}}} 

Per la funzione Tap, recuperiamo la posizione di tutte le dita posizionate sullo schermo, che si tratti di un dito o quattro e quindi creiamo un effetto Esplosione quando il dito è stato tolto dallo schermo, nella posizione in cui si trovava, prima che il il dito è stato tolto.

Per la funzione di trascinamento, è stata creata una nuova variabile. Abbiamo bisogno di questa variabile per creare il collegamento tra un dito e una traccia. Cosa fa il codice:

Se è stato creato un nuovo tocco, crea un nuovo Trail e collegalo al dito tramite il dizionario.

Quando il dito viene spostato, fintanto che il dito ha un Trail collegato ad esso, la posizione dell'oggetto Trail Game viene spostata insieme al dito.

Quando il dito viene sollevato, il sentiero viene distrutto.

Per la funzione Pinch sono state create altre tre nuove variabili. Queste variabili memorizzavano la prima posizione delle dita, che quindi utilizzavamo per calcolare la differenza tra la distanza delle dita. È stata inoltre creata una variabile per l'effetto Pinch Explosion in modo da poterlo aggiornare e distruggere.

La funzione Pinch era più complicata, a causa del fatto che non volevamo che fosse scambiata per qualcos'altro.

Per la funzione Pizzica, se vengono rilevate due dita sullo schermo, viene creato un nuovo effetto Esplosione pizzica tra le due posizioni. Successivamente, il gesto viene dichiarato pizzico. Se le dita vengono spostate, anche l'oggetto Gioco esplosione pizzica viene spostato e ridimensionato insieme ad esso.

Una volta completata Pinch Explosion, o se un dito viene sollevato dallo schermo, passa alla normale Tap Explosion.

Aggiunta dello script alla scena

Ora che lo script dei controlli è completo, aggiungilo alla scena allo stesso modo dello script precedente o non funzionerà.

Questa è la programmazione principale fatta. Dovremo ancora fare un po 'più di programmazione per Menu & HUD, ma sarà molto meno e più facile da capire. Ma, prima di accedere al menu, dobbiamo effettivamente testare l'app per vedere se funziona come dovrebbe.

Passaggio 7: test

I test sono cruciali quando si sviluppa qualsiasi tipo di software. Senza test, non sapresti se tutto funziona come dovrebbe.

Idealmente, dovresti testare non appena implementi una nuova funzionalità, tuttavia, ai fini di questo tutorial, stiamo testando dopo aver implementato la maggior parte delle funzionalità.

Esistono diversi metodi di test. Il più efficace è costruire ed eseguire l'app su un telefono Android mentre procedi. Unity in realtà ti consente di gestirlo facilmente, a condizione che tu abbia i driver corretti installati.

Prima di poter effettivamente creare e testare l'app, dovrai configurare un paio di cose. Vai a Modifica> Impostazioni progetto> Lettore. Nella parte superiore della finestra di Inspector vedrai "Nome azienda" e "Nome prodotto". Cambia questi in qualunque cosa tu voglia. Quindi espandi la scheda "Altre impostazioni" se non lo è già e vai su "Identificatore bundle". Cambia questo in com.CompanyNameYouSet.ProductNameYouSet. Nel mio caso il nome della mia azienda è U e il mio nome del prodotto è Instructables, quindi il mio identificatore del pacchetto è com.U.Intructables. Se non lo cambi, non sarai in grado di creare effettivamente l'app per Android.

Se hai installato i driver, vai semplicemente su Impostazioni di costruzione nel menu File. Quindi fare clic su "Aggiungi scene aperte". Dovrebbe aggiungere la "scena principale" all'elenco e dargli il numero "0". Una volta fatto, assicurati che la tua piattaforma selezionata sia Android e che il tuo telefono sia collegato al tuo computer, quindi fai clic su "Crea ed esegui". Unity inizierà a creare la tua app, tuttavia, prima che possa completare completamente la compilazione, richiederà la posizione del tuo SDK Android. Per trovare questa posizione, apri Android Studio> Configura impostazioni> Gestione SDK, quindi cerca "Posizione SDK Android" nella parte superiore. Questa è la posizione a cui devi puntare Unity. Una volta che Unity sa dove si trova l'SDK, continuerà a creare la tua app. Una volta terminata la costruzione dell'app, la eseguirà automaticamente sul tuo telefono. Sei quindi libero di giocare con l'app e goderti il ​​tuo duro lavoro. Prova tutti i gesti per assicurarti che funzionino tutti.

Un altro semplice metodo di test sarebbe quello di fare clic su "Build" anziché "Build and Run" e quindi scegliere una posizione in cui salvare .apk (l'estensione del file Android per le sue app). Una volta che questo file è stato salvato e creato, sarà necessario trasferirlo nella memoria del telefono e installarlo manualmente sul telefono. Questo metodo consente di inviare la tua app ad altre persone, se lo desideri.

Un altro modo di testare è tramite Unity Editor. Premendo il pulsante Riproduci nella parte superiore dello schermo nel mezzo, Unity costruirà ed eseguirà la tua app / gioco. Questo ti evita di dover usare il telefono per test minori. Tuttavia, se desideri utilizzare questo metodo per testare il tuo gioco su Android, dovrai scaricare Unity Remote 4 da Google Play Store o App Store iOS. Unity Remote ti consente di testare il tuo gioco in Unity, senza dover creare una build completa ogni volta. Risparmia molto tempo. Una cosa da menzionare è che riduce la qualità della grafica sul tuo telefono. Ma questo è necessario. Fa ancora un buon lavoro nel mostrarti come apparirà la tua app / gioco sul tuo telefono. Se stai costruendo per PC (Windows), puoi testare il gioco nell'editor senza strumenti aggiuntivi. Assicurati di uscire dalla modalità di riproduzione in Unity dopo aver testato il gioco poiché tutte le modifiche apportate a qualsiasi componente vengono annullate quando esci dalla modalità di riproduzione.

Questi metodi sono i più efficaci quando si tratta di testare il tuo gioco in quanto puoi effettivamente vedere se il tuo codice funziona come dovrebbe. Esistono tuttavia altri metodi che è possibile utilizzare anche questi metodi sono per Microsoft Visual Studio, che è l'IDE che utilizzo, ma dovrebbero essere sinonimi anche di altri IDE.

Un metodo sono i punti di interruzione. Supponiamo che tu scriva del codice, quindi esegui un errore. Non sai esattamente dove il tuo codice sta andando storto, ma hai un'idea generale. Quindi aggiungerei punti di interruzione sopra, sotto e sul codice difettoso. I punti di interruzione arrestano il programma quando raggiunge il punto di interruzione e forniscono informazioni sul programma fino a quel punto di interruzione.

Per creare un punto di interruzione, trova la riga in cui pensi che il codice stia andando storto e fai clic sul primo margine a sinistra. Dovrebbe essere un colore più chiaro rispetto alla pagina principale. Dovrebbe apparire un punto rosso e se passi sopra il punto rosso, ti dirà la posizione del punto di interruzione. Vedi lo screenshot per riferimento.

Nello screenshot, ho usato la riga "if (exploreEffect == null" come errore. Una volta che hai il punto di interruzione, sempre in Visual Studio, fai clic su Debug> Avvia debug o premi F5 sulla tastiera. Verrà eseguito il programma all'interno Unity e collegarlo a VS e nella parte inferiore della finestra VS apparirà una barra rossa che dice "Pronto".

Ora vai su Unity e fai clic sull'icona Riproduci. Questo eseguirà l'app / il gioco fino al punto di interruzione, a quel punto tornerà alla finestra VS con informazioni su come il programma viene eseguito fino al punto di interruzione. Se il tuo gioco / app viene eseguito correttamente fino al punto di interruzione, quella riga non è quella con l'errore. Se, tuttavia, il tuo programma genera un errore prima del punto di interruzione o non viene eseguito affatto, allora potrebbe essere quella linea o le linee sopra di esso. Per trovare la linea errata, dovrai continuare ad aggiungere punti di interruzione fino a quando non la trovi. Il metodo più rapido è aggiungere più punti di interruzione alla volta anziché uno. Questo è un ottimo modo di testare e ti permette di essere più preciso.

Dopo aver completato i test, premere Maiusc + F5 per terminare il debug in VS o tornare al menu Debug e fare clic su "Stop Debugging". Ciò interromperà quindi il debug e consentirà al progetto Unity di funzionare normalmente.

Durante il test, assicurati di utilizzare una combinazione di questi metodi anziché solo uno poiché ti consentirà di individuare esattamente dove hai sbagliato.

Fai anche attenzione all'ortografia e alla sintassi, i linguaggi di programmazione possono essere piuttosto spietati e C # è uno di questi linguaggi. Se si scrive qualcosa di sbagliato, si otterrà un errore e sarà difficile individuare questo errore in quanto né VS né Unity rappresentano gli errori di ortografia. Ho passato ore a cercare di correggere un bug, solo per scoprire che avevo scritto una funzione o una variabile sbagliata. Controllare l'ortografia e la sintassi man mano che procedi è una buona abitudine, in quanto ti farà risparmiare ore nel debug. Se arrivi al punto in cui hai quadruplicato il tuo codice e non riesci ancora a capire cosa c'è che non va, chiedi a qualcun altro di guardare il tuo codice. Idealmente, vorresti un altro programmatore o qualcuno che abbia almeno conoscenza della programmazione, ma se non hai nessuno che conosce la programmazione, chiedi a chiunque sia con te in quel momento di guardarlo. Di 'loro di cercare specificamente errori di ortografia in quanto potrebbero essere in grado di individuarli quando non puoi.

Cerca di non essere troppo frustrato se commetti un errore di ortografia e ti ci vogliono anni per trovarlo. Succede a tutti. È una delle gioie di essere un programmatore.

Ora che abbiamo coperto i test, possiamo passare a Menu & HUD.

Passaggio 8: creazione del menu principale e dell'HUD

La creazione di un menu / HUD per la tua app è in realtà piuttosto cruciale. Il menu principale fornisce al giocatore informazioni sulla tua app e di solito consente loro di controllare determinati aspetti dell'app. Per questo tutorial, non impareremo come programmare il Menu in modo che il lettore possa modificare le impostazioni perché in realtà non c'è nulla che il giocatore possa cambiare (non c'è suono, musica ecc.) Sto pensando di aggiungere alcuni effetti sonori e possibilmente musica, ma quelli arriveranno in un tutorial successivo. Il menu principale che creeremo sarà piuttosto semplice ma comunque esteticamente gradevole. Avremo un titolo e tre pulsanti (Play, Help & Exit.) Il pulsante Play ti porterà alla scena principale, il pulsante Help ti porterà in un pannello con il file Help su di esso e il pulsante Exit uscirà semplicemente il gioco. Ti mostrerò due modi per implementare il pulsante Exit, il primo metodo sarà un po 'più semplice.

Puoi usare qualsiasi tipo di carattere, immagine di sfondo ecc. Che desideri, purché si adatti al tema del gioco. Assicurati anche che le tue risorse per il tuo gioco siano libere da copyright o possano essere utilizzate commercialmente se prevedi di rilasciarle su un app store altrimenti potresti incorrere in problemi legali. Per questo tutorial, userò questa immagine della Galactic Center Region:

//bit.ly/29eP2jB

E questi caratteri:

//www.dafont.com/fineliner-script.font

//www.dafont.com/post-it-penscript.font

I caratteri sono allegati nella parte inferiore di questo passaggio e l'immagine è in alto se si desidera utilizzare queste risorse per l'app.

Dopo aver scaricato i caratteri e le immagini che si desidera utilizzare, importarli nel progetto Unity nelle rispettive cartelle (I caratteri vanno nella cartella Caratteri e l'immagine va nella cartella Menu).

Creazione del menu

Per creare il menu è necessario creare una nuova scena. Premi Ctrl + N o vai su File> Nuova scena. Salvalo come Menu o Menu principale.

Ora che abbiamo la nostra scena, dobbiamo aggiungere una tela. Questa tela ci consente di utilizzare tutte le funzionalità dell'interfaccia utente di cui abbiamo bisogno. Pensalo come un overlay che ha sempre le dimensioni esatte del tuo schermo.

Per creare una tela, fare clic con il tasto destro del mouse su Gerarchia> Interfaccia utente> Tela. Nella finestra Ispettore dell'area di disegno, assicurati che la Modalità rendering sia impostata su Spazio schermo - Sovrapponi e seleziona l'opzione Pixel perfetto. Sotto il componente Scaler tela, cambia la modalità di ridimensionamento da Dimensione pixel costante a Scala con dimensione schermo. Ciò consente a tutti i componenti della tela di ingrandirsi o di ridimensionarsi se la risoluzione dello schermo aumenta o diminuisce. Cambia la Risoluzione di riferimento in Risoluzione dello schermo del tuo telefono in Vista orizzontale (la mia è 1920 x 1080) e cambia il valore di Abbinamento da 0 a 0, 5. Ciò assicurerà che i componenti siano ridimensionati equamente in Larghezza e Altezza.

Ora è necessario modificare la vista di gioco in modo che corrisponda alla risoluzione di riferimento della tela. Per fare questo, fai clic sulla scheda Gioco in alto, dovrebbe avere un'icona di Pacman alla sua sinistra. Se non riesci a vederlo, vai su Finestra> Gioco oppure premi Ctrl + 2. Guarda in alto a sinistra nella finestra Gioco e dovresti vedere una casella a discesa che dice Aspetto gratuito. Cliccaci sopra. Nella parte inferiore, dovrebbe essere presente un'icona Plus, fai clic su di essa e modifica il Tipo da Rapporto aspetto a Risoluzione fissa. Etichetta su qualunque sia la risoluzione dello schermo del tuo telefono (il mio è 1080p) e modifica la larghezza e l'altezza in modo che corrispondano alla risoluzione desiderata. Ciò ti consentirà di ridimensionare i componenti in modo che vengano visualizzati correttamente sul telefono. Se lo mantenessi su Free Aspect, sarebbe difficile ridimensionare i componenti in modo appropriato.

Crea un pannello (allo stesso modo in cui hai creato la tela, solo che questa volta scegli il pannello). Se la tua tela è già selezionata, il pannello dovrebbe automaticamente diventare un figlio della tela.

In Unity, bambini e genitori sono estremamente importanti. Un figlio è un sottoinsieme del genitore, eredita alcune qualità dal genitore. Per distinguere tra un bambino e un genitore: un genitore avrà una freccia a sinistra del suo nome su cui puoi fare clic per mostrare o nascondere i bambini.

Per creare un figlio, devi semplicemente fare clic con il pulsante destro del mouse su un oggetto nella Gerarchia e quindi creare l'oggetto figlio dal menu che viene visualizzato oppure puoi trascinare un oggetto su un altro per renderlo figlio di quell'oggetto. Nello screenshot sopra, ho creato un oggetto di gioco vuoto e l'ho trascinato sulla tela per rendere l'oggetto di gioco vuoto un figlio della tela. Questo è estremamente utile e in alcune occasioni critico. Ad esempio, se hai creato un pannello al di fuori della tela (se il pannello era un genitore) e volevi ridimensionarlo alla stessa dimensione della tela, dovrai scoprire le dimensioni della tela e quindi impostare manualmente il le dimensioni del pannello devono essere le stesse. Tuttavia, se il pannello fosse un figlio della tela, potresti semplicemente ridimensionarlo usando le ancore (che spiegherò tra poco). Se il Pannello è stato creato per essere, per impostazione predefinita figlio della tela, il pannello verrebbe automaticamente ridimensionato sulla tela. C'è anche il leggero problema di eventuali elementi dell'interfaccia utente che non sono visibili a meno che non siano tutti elementi secondari dell'area di disegno. Genitori / figli sono anche utili per organizzare la Gerarchia, che presto ripasso.

Ora che abbiamo questo pannello, possiamo impostare l'immagine di sfondo. Prima di farlo, dobbiamo nominarli in modo appropriato, cambiare il nome dell'area di disegno nella Gerarchia in area menu e cambiare il nome del pannello in Immagine di sfondo. Ora fai clic sul pannello Immagine di sfondo e osserva la finestra di ispezione. Dovrebbe esserci un componente Image (Script) allegato. Cerca l'immagine sorgente. Per modificare questa immagine, trascina e rilascia l'immagine scaricata dalla finestra del progetto nella casella o fai clic sul simbolo di un cerchio con un piccolo punto al centro. Ciò dovrebbe aprire un'altra finestra con l'etichetta Seleziona Sprite. Da questa finestra puoi quindi scegliere il tuo sfondo. Se non riesci a vedere l'immagine assicurati che il tipo di immagine sia impostato come Sprite (2D e UI).

Dopo aver selezionato lo sfondo, dovrai aumentare l'alfa, per farlo fai clic sulla casella Colore e nella parte inferiore ci sarà una casella di scorrimento denominata A. Trascina tutto questo verso destra fino a quando non è alla fine di la sezione bianca e il suo valore sono impostati su 255. Se lo desideri, puoi anche colorare l'immagine di un certo colore da questa stessa finestra.

Per impostare il titolo, creare un oggetto Testo come figlio dell'immagine di sfondo. Rinominalo in Titolo. Cambia il colore del testo in bianco e assicurati che anche tutti gli oggetti di gioco di testo che crei siano bianchi. Nella sezione Testo, cambia da Nuovo testo a quello che vuoi che sia il tuo titolo (in questo caso è Instructables) e cambia il carattere nel tuo carattere preferito (userò il carattere Postit-Penscript). Sotto l'intestazione del paragrafo, modifica l'allineamento come desideri, centrerò il mio testo negli assi verticale e orizzontale. Quindi, fai clic su Adatta e modifica le dimensioni massime in base a ciò che si adatta meglio al tuo carattere. Il mio carattere è piuttosto sottile, quindi userò 90 come dimensione massima. Assicurati di fare clic sull'opzione Adatta per ogni successivo oggetto di gioco di testo che crei.

Quindi guarda in alto a destra sotto l'intestazione Trasforma rettangolo e dovresti vedere una casella con linee e del testo nella parte superiore e sinistra della casella. Dovrebbe essere indicato al centro in alto e al centro a sinistra. Fare clic su questa casella, tenere premuto Alt e Maiusc e fare clic sull'icona sopra l'icona centrale / centrale. Controlla lo screenshot per riferimento. Ora se chiudi la casella dovrebbe indicare il centro in alto e in alto a sinistra e il testo dovrebbe essere centrato in alto. Questa è l'ancora ed è estremamente utile quando organizzi gli oggetti di gioco. Tenendo premuto Alt si imposta la posizione dell'oggetto sul nuovo punto di ancoraggio e tenendo premuto Maiusc si imposta il perno. Ti evita di dover impostare manualmente le posizioni degli oggetti.

Se guardi a destra della casella Trasforma rettangolo dovresti vedere un mucchio di numeri. Queste sono le dimensioni e la posizione dell'oggetto. Quelle su cui vuoi concentrarti sono le caselle: Pos X, Pos Y, Larghezza e Altezza. La larghezza e l'altezza sono autoesplicative. Pos X sposta l'oggetto in orizzontale e Pos Y lo sposta in verticale. Tuttavia, queste caselle cambieranno in base all'ancoraggio utilizzato. Se usi l'ancoraggio uniforme, Pos X e Y cambieranno in Destro, Sinistro Superiore e Giù, il che fa la stessa cosa, ma ti consente un maggiore controllo. È possibile trascinare lungo l'etichetta di queste caselle per spostare l'oggetto, digitare manualmente i numeri o utilizzare gli strumenti Unity per spostarli. Cambia Pos Y da 0 a -10. Questo gli darà 10 pixel di spazio dalla parte superiore dell'immagine di sfondo, rendendolo un po 'più pulito.

Fare clic su Aggiungi componente e aggiungere un'ombra e un contorno. Aumenta l'Alfa di entrambi a 255. Questo lo farà risaltare maggiormente sullo sfondo. Assicurati di aggiungere un componente Shadow and Outline a ogni successivo oggetto di gioco di testo che crei.

Ora che abbiamo il nostro background è il momento di impostare i pulsanti. Crea un oggetto di gioco vuoto come elemento secondario del pannello Immagine di sfondo e chiamalo Gestione layout pulsanti. Nella finestra di ispezione di questo oggetto di gioco vuoto, fai clic su Aggiungi componente, cerca il gruppo di layout verticale e aggiungilo all'oggetto. Questo oggetto di gioco manterrà coerente il posizionamento dei pulsanti. Cambia l'ancora in uniforme di stiramento (si trova in basso a destra) e cambia la posizione e ruota con essa. Il Button Layout Manager dovrebbe ora occupare l'intero schermo. Trascinalo verso il basso dall'alto fino a quando non occupa 3 riquadri della griglia e trascinalo da destra fino a quando non occupa due riquadri della griglia. Se non riesci a vedere la griglia, guarda nella parte superiore della finestra Scena dove dice Gizmos. Fare clic su quello e quindi fare clic su Mostra griglia.

Ora crea un altro oggetto di gioco di testo come figlio dell'immagine di sfondo e impostalo nel modo desiderato. Etichetta Start. Se si utilizzano più caratteri, utilizzare il secondo carattere per il pulsante e conservare il primo carattere solo per i titoli. Userò il carattere Fineliner_Script per i miei pulsanti. È possibile rendere i pulsanti di qualsiasi dimensione desiderata purché siano chiaramente visibili. Una buona regola è quella di ridurre le dimensioni del pulsante di 10 o 20 pixel rispetto al titolo, quindi se il titolo è impostato sulla dimensione 90, imposti la dimensione del pulsante su 80 o 70. Imposterò la dimensione del pulsante su 70 Cambia il testo in Start e imposta l'allineamento su ciò che desideri. Aggiungi un componente Button e modifica i colori Evidenziati e Pressati con i tuoi colori preferiti, assicurati che il Colore pressato sia più scuro di quello Evidenziato. Imposterò il mio Evidenziato su un azzurro e il colore pressato su un blu più scuro. Ora aggiungi un componente Shadow e Outline ad esso e aumenta l'Alfa al massimo.

Duplica questo pulsante due volte (facendo clic con il pulsante destro del mouse sul pulsante e selezionando Duplica o facendo clic sul pulsante e premendo Ctrl + D) in modo da finire con tre pulsanti in totale, chiama uno di loro Aiuto e l'altro Esci. Cambia il testo di questi per riflettere le loro etichette. Renderli figli del Gestore layout.

Crea un pannello, chiamalo Pannello di aiuto e imposta l'immagine sorgente in modo che corrisponda all'immagine di sfondo. Dovrebbe già essere la dimensione corretta. Aumenta l'Alfa al massimo. Duplica il titolo e rendilo figlio del pannello di aiuto. Cambia il nome dell'oggetto gioco in Titolo del pannello di aiuto e il pannello Testo in pannello di aiuto. Dovrebbe già essere nella posizione corretta.

Duplica uno dei pulsanti e rinominalo in Indietro. Rendilo figlio del pannello di aiuto, quindi modifica il testo del pulsante in Indietro. Impostare l'ancoraggio, la posizione e il perno su In basso a sinistra e modificare Pos X su 10.

Crea un altro oggetto gioco di testo come elemento secondario del pannello della Guida, etichettalo come Guida del corpo del testo e imposta l'ancora su Allunga uniforme. Cambia la casella superiore da 0 a 110. Cambia le caselle sinistra, destra e inferiore su 10. Imposta il carattere, usa lo stesso carattere dei pulsanti. Cambia la dimensione massima in 80. Centra il testo su entrambi gli assi. Quindi copia e incolla il testo seguente nella casella di testo:

Questa app ti consente di creare vari effetti sul tuo telefono. Toccando lo schermo si crea un'esplosione, pizzicando lo schermo si crea un'esplosione più grande e trascinando lo schermo si crea una scia.

O crea il tuo testo di aiuto.

Ora vai su File> Impostazioni di costruzione> Aggiungi scene aperte. Ora è necessario aggiungere la scena del menu. Trascina la scena del menu in alto in modo che il suo numero sia 0 e la scena principale sia 1. Se non lo fai, non sarai in grado di visualizzare effettivamente il menu quando costruisci l'app, né sarai in grado per caricare la scena principale quando si fa clic su Avvia.

Ora che abbiamo impostato il menu, possiamo passare alla programmazione in modo che faccia effettivamente qualcosa.

Programmazione del menu

Crea un nuovo script e chiamalo Menu. Quindi digitare il seguente codice:

 utilizzando UnityEngine; // Questo spazio dei nomi è necessario per l'utilizzo di qualsiasi componente dell'interfaccia utente utilizzando UnityEngine.UI; // Questo spazio dei nomi è necessario per usare SceneManager usando UnityEngine.SceneManagement; utilizzando System.Collections; public class Menu: MonoBehaviour {// Questi sono tutti i pulsanti // ------------------------------- Pulsante Start pubblico; aiuto Button pubblico; uscita pulsante pubblico; pulsante pubblico indietro; // ------------------------------- // Questo è il pannello di aiuto pubblico GameObject helpPanel; // ------------------------------- // Utilizzalo per l'inizializzazione void Start () {// Disabilita il pannello helpPanel .SetActive (false); } // L'aggiornamento viene chiamato una volta per frame void Update () {} // Funzione per il pulsante Start, carica il vuoto pubblico della scena principale StartPress () {SceneManager.LoadScene (1); } // Funzione per il pulsante Guida, abilita il vuoto del pannello della guida HelpPress () {helpPanel.SetActive (true); } // Funzione per il pulsante Esci, esce dal vuoto pubblico dell'applicazione ExitPress () {Application.Quit (); } // Funzione per il pulsante Indietro, disabilita il pannello di aiuto pubblico void BackPress () {helpPanel.SetActive (false); }} 

Trascina questo script nell'area di menu, quindi scorri verso il basso fino alla finestra di ispezione. Avresti dovuto:

Inizio

Aiuto

Uscita

Indietro

Pannello di aiuto

Trascina gli oggetti di gioco pertinenti nei rispettivi campi. Vedi lo screenshot sopra se non sei sicuro.

Ora Ctrl fai clic sui pulsanti Start, Help, Exit e Back e scorri verso il basso fino al componente Button (Script). Nella parte inferiore di questo componente ci sarà un elenco vuoto che dice On Click (). Fai clic sul simbolo Più. Ora trascina l'oggetto di menu Menu Canvas nel campo che dice None (Object). La casella a discesa Nessuna funzione ora dovrebbe essere attiva.

Fai clic sul pulsante Start, quindi fai clic sul menu a discesa Nessuna funzione e vai in fondo all'elenco dove viene visualizzato Menu. Quindi fare clic su StartPress (). Ora dovrebbe essere visualizzato Menu. Avvia Premere nella casella a discesa. Fai lo stesso per i pulsanti Aiuto, Esci e Indietro, ma assicurati di selezionare la funzione Press corretta per loro. Il pulsante Guida dovrebbe avere HelpPress, il pulsante Exit Exit Exit e il pulsante Back BackPress. Ora fai clic sull'icona Riproduci e provalo, fai clic sul pulsante Guida e verifica se il pannello di aiuto viene caricato. Fare clic sul pulsante Esci in realtà non farà nulla a meno che tu non abbia creato l'app per Android. Dovrai testare il pulsante Esci sul telefono. Facendo clic sul pulsante Riproduci dovresti accedere alla scena principale.

Ora potrebbe essere un buon momento per testare la tua app sul telefono, quindi creala ed eseguila e assicurati che il tuo Menu sia perfettamente funzionante.

Come ho già detto, esistono diversi metodi per creare la funzione di uscita. Ti ho appena mostrato il modo più semplice. Questo è il secondo metodo

Crea un altro pannello come figlio dell'immagine di sfondo e chiamalo Exit Panel. Imposta il colore di sfondo in modo che corrisponda allo sfondo in modo che sembri fondersi (ho scelto un blu scuro) e imposta la parte superiore e inferiore a 450 e la destra e la sinistra a 760. Questo centrerà la casella sullo schermo.

Duplica il titolo e rendilo figlio del pannello di uscita. Riduci un po 'le dimensioni del testo in modo che sia visibile ma non occupi troppo spazio. Assicurarsi che sia centrato verso l'alto.

Duplica due volte il pulsante Riproduci, crea entrambi i figli duplicati del pannello di uscita e modifica l'ancoraggio, la posizione e il perno di uno dei pulsanti in basso a sinistra. Cambia l'altro in basso a destra.

Cambia il nome del pulsante in basso a destra in Sì e fai lo stesso con il testo. Cambia quello in basso a sinistra in No (nome e testo).

Apri il tuo Menu Script e aggiungi 2 pulsanti sotto il pulsante Indietro e un GameObject sotto il Pannello di aiuto usando il codice qui sotto:

 pulsante pubblico sì; pulsante pubblico no; 
 public GameObject exitPanel; 

Aggiungi il seguente codice nella funzione Start, sotto helpPanel.SetActive (false); linea:

 exitPanel.SetActive (false); 

Cambia la funzione ExitPress da

 Application.Quit (); 

per

 exitPanel.SetActive (true); 

Quindi scorrere fino alla fine dello script e sotto la funzione BackPress () aggiungere il seguente codice:

 pubblico vuoto SìPress () {Application.Quit (); } public void NoPress () {exitPanel.SetActive (false); } 

Infine, torna su Unity, fai clic sul pulsante Sì e cambia la sua funzione da StartPress () a YesPress () e cambia il pulsante No in NoPress (). Assicurati anche di assegnare le nuove variabili pubbliche nello script Menu Canvas (fai clic su Menu Canvas e trascina i pulsanti e il pannello nei rispettivi campi). Ora premi Play e prova il pulsante Exit, dovrebbe caricare il pannello Exit e chiuderlo quando premi il pulsante No. Come puoi vedere, questo metodo è leggermente più lungo ma offre protezione nel caso in cui il giocatore faccia accidentalmente clic sul pulsante Esci. Sentiti libero di usare qualsiasi metodo tu scelga.

Ora passiamo al passaggio finale, creando l'HUD, che è estremamente semplice e consiste in un solo pulsante. Potrei aggiungere un altro tutorial che copre un HUD più ampio (con un cursore di salute, un contatore di punteggi e un menu di pausa reale) ma per ora, questo sarà sufficiente.

Creazione e programmazione dell'HUD

Torna alla scena principale e crea una nuova tela. Etichetta la tela HUD e impostala allo stesso modo della tela del menu principale.

Aggiungi un oggetto di gioco di testo come figlio della tela, chiamalo di nuovo al menu principale e imposta i caratteri, le dimensioni e l'allineamento a tuo piacimento. In alternativa, è possibile rendere prefabbricato uno dei pulsanti del menu principale, quindi trascinarlo sulla tela. Dopo aver impostato il pulsante, cambia l'ancoraggio, la posizione e il perno in basso a sinistra. Crea un nuovo script chiamato HUD e digita il seguente codice:

 utilizzando UnityEngine; // Questo spazio dei nomi è necessario per l'utilizzo di qualsiasi componente dell'interfaccia utente utilizzando UnityEngine.UI; // Questo spazio dei nomi è necessario per usare SceneManager usando UnityEngine.SceneManagement; utilizzando System.Collections; public class HUD: MonoBehaviour {// Button public Button backToMainMenu; // Usa questo per l'inizializzazione void Start () {} // L'aggiornamento viene chiamato una volta per frame void Update () {} // Funzione per il pulsante BackToMainMenu, carica la scena del menu void pubblico BackToMainMenuPress () {SceneManager.LoadScene (0); }} 

Trascina questo script sulla tela HUD, imposta lo script nello stesso modo del menu principale (trascinando l'oggetto di gioco Torna al menu principale nel campo Torna al menu principale). Quindi imposta il pulsante trascinando la tela HUD nel campo Al clic (). Scegli la funzione BackToMainMenuPress e testa il pulsante facendo clic sull'icona Riproduci e vedendo se ti riporta al menu principale.

allegati

  • Scarica Fineliner_Script.ttf
  • Scarica Postit-Penscript.otf

Passaggio 9: Organizzazione della gerarchia

Ricordi come ho detto che creare oggetti di gioco vuoti ti aiuterà a organizzare la Gerarchia? Bene, lo hai già fatto usando bambini e genitori.

Tuttavia, la scena principale è ancora un po 'disorganizzata. Torna alla scena principale e crea un oggetto di gioco vuoto etichettato come effetti. Trascina tutte le Explosions and the Trails Game Objects su questo script di effetti. Quindi trascina questo oggetto gioco effetti sotto gli script. La fotocamera principale e il sistema di eventi possono rimanere come sono.

Utilizzare questo sistema per organizzare qualsiasi progetto creato. Qualunque cosa dello stesso tipo può passare sotto il proprio Oggetto di gioco vuoto (ad esempio, più nemici possono essere figli di un Oggetto di gioco nemico, più telecamere - Oggetto di gioco telecamere e così via.) Ciò manterrà la tua Gerarchia in ordine e ti impedirà di ottenere confuso se si creano molti oggetti di gioco

Passaggio 10: conclusione

Uff. È stato piuttosto il viaggio. Ma abbiamo finalmente raggiunto la fine (probabilmente ne sarete tutti contenti.) Ma ora avete un'app completamente funzionale che potete mostrare ai vostri amici e migliorare. Dovresti essere orgoglioso, come accennato in precedenza, questo era un tutorial più avanzato. Quindi prenditi un momento e goditi la tua creazione.

Spero che questo tutorial sia stato di aiuto. If you get stuck on anything, a good habit to get in to is searching Google for your error, then typing in Unity after it. Because Unity is so widely used, there is a lot of documentation available and there will most likely be at least one person who has had the same issue as you.

If you're not sure about any of the programming functions (void Update, void Start, public void etc.) then search for the function along with unity c# and check the official Unity documentation.

If you can't find an answer to your issues, you can leave a comment and i'll do my best to help you resolve the error.

If there is something you think I could add or if you want to learn how to program an actual game, feel free to leave a comment.

Thanks for taking the time to read this tutorial. Fino alla prossima volta!

Articoli Correlati