Contenuto
La categoria più popolare sul Google Play Store è sempre stata Giochi. Sebbene probabilmente tutti utilizziamo app di produttività chiave come un browser Web, un client di posta elettronica e un'app di messaggistica istantanea, i giochi rimangono comunque una parte importante dell'esperienza mobile. Quindi non sorprende che molte persone che vogliono imparare a sviluppare per Android vogliono iniziare creando un gioco. Inoltre, siamo onesti, scrivere un gioco è molto più divertente che sviluppare un'app per la produttività!
La lingua ufficiale di Android è Java e l'ambiente di sviluppo ufficiale è Android Studio. Se vuoi esaminare Java, ti suggerisco il nostro tutorial di base su Java e se vuoi imparare a scrivere un'app usando Android Studio, ti suggerisco di dare un'occhiata al nostro tutorial su come scrivere la tua prima app per Android. Tuttavia, Java e Android Studio non sono gli unici modi per sviluppare per Android. Puoi trovare una panoramica delle lingue e degli SDK disponibili nella nostra guida: Voglio sviluppare app Android - Quali lingue dovrei imparare?
Uno degli SDK menzionati nella guida ai linguaggi di programmazione è Corona, un SDK di terze parti progettato principalmente per scrivere giochi. Invece di Java, Corona usa Lua, un linguaggio di scripting veloce che è facile da imparare ma potente. Tuttavia, Corona non è l'unico SDK di gioco mobile che utilizza Lua, altri esempi ben noti includono Cocos2d-X, Marmalade e Gideros.
Scarica e installa
Per iniziare con Corona dovrai scaricare e installare l'SDK. Vai al sito web Corona e premi il pulsante di download. Dovrai creare un account (che è gratuito) prima di poter scaricare il kit. Se vuoi creare un vero file .apk piuttosto che eseguire il tuo programma nell'emulatore, dovrai installare Java 7, tuttavia non dovrai installare Android SDK. Per installare il Java 7 Development Kit vai al sito Web di Oracle, cerca la sezione chiamata "Java SE Development Kit 7u79" e scarica la versione per il tuo PC.
Una volta installato Corona è necessario attivarlo. Questo è un processo una tantum, che è gratuito. Avviare Corona Simulator e accettare la licenza. Immettere l'indirizzo e-mail e la password utilizzati per il download e fare clic su Accesso.
Avvio del progetto
Dall'interno del Simulatore Corona fai clic su "Nuovo progetto". Inserisci un nome per la tua app nel campo "Nome applicazione:" e lascia il resto delle impostazioni ai valori predefiniti. Fai clic su "OK".
Appariranno ora tre finestre. I primi due sono Corona Simulator e Corona Simular Output. Corona aprirà anche una finestra di esplorazione dei file che mostra i file per il tuo progetto.
La maggior parte dei file (circa 23 di essi) nella directory del progetto sono per l'icona dell'applicazione! Il file più importante per noi in questo momento è main.lua, poiché è qui che scriveremo il codice per la nostra app.
Introduzione a Lua
Prima di iniziare a scrivere il codice, dobbiamo fare un giro di fischio a Lua. L'interprete Lua (ricorda che questo è un linguaggio di scripting, non un linguaggio compilato) è disponibile per Windows, OS X e Linux. Tuttavia, è integrato in Corona, quindi al momento non è necessario installare nulla in più. Il modo più semplice per giocare con Lua è usare la demo live online.
Puoi trovare molti buoni tutorial su Lua online e dovresti dare un'occhiata al Manuale di riferimento di Lua, Programmazione in Lua, The.Lua.Tutorial e The Tutorials Point Lua Tutorial.
Ecco un piccolo programma Lua che ti mostrerà alcune delle caratteristiche principali di Lua:
funzione locale doubleIt (x) return x * 2 end for i = 1,10,1 do x = doubleIt (i) if (x == 10) then print ("ten") else print (doubleIt (i)) end end
Il codice sopra mostra tre importanti costrutti Lua: funzioni, loop e istruzioni if. La funzione doubleIt () è molto semplice, raddoppia il parametro passato X.
Il codice principale è a per loop da 1 a 10. Chiama doubleIt () per ogni iterazione. Se il valore restituito è 10 (ovvero quando io è 5) quindi il codice stampa "dieci" altrimenti stampa solo il risultato di doubleIt ().
Se hai esperienza di programmazione, il codice di esempio dovrebbe essere abbastanza facile da seguire. Se stai cercando di imparare un po 'di programmazione di base, ti suggerisco di utilizzare alcune delle risorse collegate sopra per affinare le tue abilità.
Scrivere il gioco
Scrivere programmi di base in Corona è semplice. Hai solo bisogno di preoccuparti di un file, main.lua, e lascia che Corona faccia tutto il lavoro pesante. Il gioco che stiamo per scrivere è un semplice gioco "tap". Un palloncino o una bomba falliranno sullo schermo. Se il giocatore tocca il pallone, segna un punto, tocca una bomba, quindi il punteggio verrà diviso per 2, come penalità. Per scrivere il codice è necessario modificare main.lua. Puoi farlo in qualsiasi editor di testo.
Corona SDK ha un motore fisico 2D incorporato, che rende la costruzione di giochi molto semplice. Il primo passo per scrivere il gioco è inizializzare il motore fisico:
fisica locale = richiedono ("fisica") physics.start ()
Il codice è abbastanza autoesplicativo. La fisica del modulo viene caricata e inizializzata, viene assegnata alla variabile fisica. Per abilitare il motorephysics.start () è chiamato.
Successivamente creiamo alcune variabili utili che saranno utili non solo per questo semplice gioco, ma anche per giochi più complessi. halfW e halfH mantieni i valori per metà della larghezza dello schermo e metà dell'altezza dello schermo:
halfW = display.contentWidth * 0,5 halfH = display.contentHeight * 0,5
Il display L'oggetto è un oggetto predefinito che Corona rende disponibile a livello globale.
Ora arriva il primo passo che fa effettivamente accadere qualcosa sullo schermo:
local bkg = display.newImage ("night_sky.png", halfW, halfH)
Così come le proprietà simili contentHeight e contentWidth, il display L'oggetto ha anche molte funzioni utili. Il nuova immagine() La funzione legge un file di immagine (in questo caso un .png) e lo visualizza sullo schermo. Gli oggetti di visualizzazione sono resi in livelli, quindi poiché questa è la prima immagine che stiamo mettendo sullo schermo, sarà sempre lo sfondo (a meno che il codice non faccia esplicitamente qualcosa per cambiarlo). I parametri halfW e halfH dì a Corona di posizionare l'immagine al centro.
A questo punto puoi eseguire il codice nell'emulatore e vedere l'immagine di sfondo. Se si salva il file, l'emulatore noterà che il file è stato modificato e si offrirà di riavviare. Se ciò non accade, usa File-> Riavvia.
Poiché l'utente segnerà punti per toccare i palloncini, è necessario inizializzare una variabile di punteggio e visualizzare il punteggio sullo schermo:
score = 0 scoreText = display.newText (punteggio, halfW, 10)
Il punteggio verrà mantenuto nella variabile denominata in modo fantasioso Punto,e scoreText è l'oggetto che visualizza il punteggio. Piace nuova immagine(), newText () metti qualcosa sullo schermo, in questo caso testo. Da scoreText è una variabile globale, quindi possiamo modificare il testo in qualsiasi momento. Ma ci arriveremo presto.
Puoi riavviare l'emulatore e vedere il punteggio di 0 visualizzato nella parte superiore dello schermo.
A sinistra: solo lo sfondo. A destra: sfondo e punteggio.
Ora arriva qualcosa di un po 'più complicato, ma non preoccuparti, lo spiegherò riga per riga:
Balloon della funzione locale Toccato (evento) se (event.phase == "iniziato"), quindi Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = score + 1 scoreText.text = score end end
Il codice sopra definisce una funzione chiamata balloonTouched () che verrà chiamato ogni volta che si tocca un pallone. Non abbiamo ancora detto a Corona di chiamare questa funzione ogni volta che si tocca il pallone, che verrà dopo, ma quando lo facciamo è la funzione che viene chiamata.
Gli eventi di tocco o tocco hanno diverse fasi, molte per supportare il trascinamento. L'utente mette il dito su un oggetto, questa è la fase "iniziata". Se fanno scorrere il dito in qualsiasi direzione, questa è la fase "spostata". Quando l'utente solleva il dito dallo schermo, questa è la fase "terminata".
La prima linea di balloonTouched () controlla che siamo nella fase "iniziata". Vogliamo rimuovere il fumetto e incrementare il punteggio non appena possibile. Se la funzione viene richiamata di nuovo per altre fasi come "terminata", la funzione non fa nulla.
Dentro ilSe istruzione sono quattro righe di codice. Vediamo prima gli ultimi due, poiché sono più semplici.punteggio = punteggio + 1 aumenta solo il punteggio di uno escoreText.text = score cambia il testo del punteggio sullo schermo per riflettere il nuovo punteggio. Ricorda come l'ho dettoscoreText era globale e si poteva accedere ovunque, beh, ecco cosa facciamo qui.
Ora per le prime due righe. Una volta che un palloncino o una bomba cadono nella parte inferiore dello schermo esiste ancora nella memoria dell'app, è solo che non riesci a vederlo. Man mano che il gioco avanza, il numero di questi oggetti fuori schermo aumenterà costantemente. Pertanto abbiamo bisogno di un meccanismo che elimini gli oggetti una volta che sono fuori dalla vista. Lo facciamo in una funzione chiamatafuori campo, che non abbiamo ancora scritto. Quella funzione verrà chiamata una volta per frame durante il gioco. Una volta toccato un fumetto, è necessario eliminarlo e rimuovere la chiamata che controlla se il fumetto è andato fuori dallo schermo.
La lineaevent.target:removeSelf () cancella il palloncino. Quando si verifica un evento touch, uno dei parametri della funzione listener è ilevento parametro. Indica la funzione sull'evento e che tipo di evento è, ad es.event.phase. Ci dice anche quale palloncino è stato toccato,event.target. IlremoveSelf () la funzione fa quello che dice di fare, cancella l'oggetto (in questo caso un palloncino).
La riga prima rimuove l'ascoltatore "enterframe", che è la funzione che viene chiamata ogni fotogramma per vedere se il fumetto è caduto dalla parte inferiore dello schermo. Lo vedremo più in dettaglio quando arriveremo a scrivere ilfuori campo funzione di ascolto.
Quindi, per ricapitolare.balloonTouched ()controlla che questo sia l'inizio della sequenza tattile. Rimuove quindi l'ascoltatore "enterframe", che è la funzione che viene chiamata ogni fotogramma per vedere se il fumetto è caduto dalla parte inferiore dello schermo. Elimina quindi il fumetto, aumenta il punteggio e visualizza il nuovo punteggio.
Quello era per i palloncini, ora abbiamo bisogno di qualcosa di simile per le bombe:
funzione locale bombTouched (evento) if (event.phase == "iniziato"), quindi Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = math.floor (score * 0.5) scoreText.text = fine del punteggio
Come puoi vedere il codice è molto simile con l'eccezione che invece di incrementare il punteggio, il punteggio viene moltiplicato per 0,5 (cioè diviso per 2). Il Math.floor () La funzione arrotonda il punteggio all'intero più vicino. Quindi se il giocatore avesse un punteggio di 3 e avesse toccato una bomba, il nuovo punteggio sarebbe 1, e non 1,5.
Ho citato il fuori campo () funzione prima. Questa funzione verrà chiamata per ogni frame per verificare se un oggetto è uscito dallo schermo. Ecco il codice:
funzione locale offscreen (self, event) if (self.y == nil) quindi restituisce end if (self.y> display.contentHeight + 50) quindi Runtime: removeEventListener ("enterFrame", self) self: removeSelf () end end
Nell'informatica c'è una situazione nota come condizione di razza. È qui che accadranno due cose, ma una potrebbe accadere per prima o talvolta l'altra per prima. È una gara Alcune condizioni di gara sono invisibili perché una cosa sembra sempre accadere per prima, ma possono causare bug interessanti in quel giorno, nelle giuste condizioni, l'altra cosa accade per prima e poi il sistema si rompe!
C'è una condizione di gara in questo semplice gioco perché possono accadere due cose molto vicine tra loro: un pallone che viene toccato e il fuori campo () chiamata per vedere se il fumetto è uscito dallo schermo. Il risultato è che il codice per eliminare il fumetto può essere chiamato e quindi il fuori campo () viene chiamata la funzione (che avviene 30 volte al secondo). Per aggirare questa strana sequenza di eventi il fuori campo () la funzione deve verificare se il y il valore dell'oggetto è zero (null) o no. Se è zero allora significa che l'oggetto è già stato cancellato, quindi spostati, questi non sono i droidi che stiamo cercando.
Se l'oggetto è ancora in gioco, quindi controlla la sua posizione, se si è allontanato di 50 pixel dallo schermo, quindi eliminalo e rimuovi l'ascoltatore in modo che il fuori campo () la funzione non verrà richiamata per questo oggetto. Il codice per accertarsenefuori campo () viene chiamato ogni frame fa parte della prossima sezione di codice.
La premessa di questo gioco è che nuovi palloncini o bombe continueranno a cadere sullo schermo. Pertanto abbiamo bisogno di una funzione che crei un nuovo pallone o una nuova bomba:
funzione locale addNewBalloonOrBomb () local startX = math.random (display.contentWidth * 0.1, display.contentWidth * 0.9) se (math.random (1,5) == 1) allora - BOMB! local bomb = display.newImage ("bomb.png", startX, -300) physics.addBody (bomb) bomb.enterFrame = offscreen Runtime: addEventListener ("enterFrame", bomb) bomb: addEventListener ("touch", bombTouched) altro - Balloon local balloon = display.newImage ("red_balloon.png", startX, -300) physics.addBody (balloon) balloon.enterFrame = offscreen Runtime: addEventListener ("enterFrame", balloon) fumetto: addEventListener ("touch", balloonTouched) end end
La prima riga della funzione decide da dove il palloncino cadrà sul X aereo. Se il pallone o la bomba cadono sempre nel mezzo, non sarà molto interessante! Cosìstartx è un numero casuale compreso tra il 10 percento e il 90 percento della larghezza dello schermo.
Successivamente viene selezionato un numero casuale tra 1 e 5.Se il numero è 1, una bomba verrà sganciata. Se è 2, 3, 4 o 5, verrà lasciato cadere un palloncino. Ciò significa che le bombe verranno lanciate circa il 20 percento delle volte.
Il codice bomba e palloncino sono abbastanza simili. Innanzitutto l'immagine (una bomba o un pallone) viene visualizzata usandonuova immagine(). Suo X la posizione è quella distartx mentre è y la posizione è impostata su -300, ovvero dalla parte superiore dello schermo. La ragione di ciò è che vogliamo che l'oggetto cada dall'esterno dell'area dello schermo nell'area visibile e quindi dalla parte inferiore. Dal momento che stiamo usando il motore fisico 2D, è bene lasciare cadere un po 'di una distanza iniziale dell'oggetto, in modo che possa guadagnare un po' di velocità.
La chiamata aphysics.addBody () prende l'immagine caricata da nuova immagine() e lo trasforma in un oggetto nel motore fisico. Questo è molto potente. Qualsiasi file di immagine può essere trasformato in un corpo che risponde alla gravità e alle collisioni semplicemente chiamandophysics.addBody ().
Le ultime tre righe del codice bomba o palloncino hanno creato gli ascoltatori. Impostazione dienterFrame proprietà indica a Corona quale funzione chiamare ogni frame e la chiamata aDurata: addEventListener () lo imposta. Infine la chiamata apalloncino: addEventListener () dice a Corona quale funzione chiamare se viene toccata la bomba o il pallone.
E ora il gioco è quasi completo. Abbiamo solo bisogno di altre due righe di codice:
addNewBalloonOrBomb () timer.performWithDelay (500, addNewBalloonOrBomb, 0)
La prima linea fa cadere la prima bomba o palloncino chiamando esplicitamenteaddNewBalloonOrBomb (). La seconda linea imposta un timer che chiameràaddNewBalloonOrBomb () ogni mezzo secondo (500 millisecondi). Ciò significa che un nuovo pallone o bomba cadrà ogni mezzo secondo.
Ora puoi eseguire il gioco nell'emulatore.
Ecco l'elenco completo di main.lua, il codice sorgente completo del progetto per questo gioco può essere trovato qui su GitHub.
-------------------------------------------------- --------------------------------------- - - Gioco di palloncini e bombe che cadono - Scritto da Gary Sims per - ------------------------------------------- ---------------------------------------------- - Avvia il motore fisico fisica fisica = richiede ("fisica") physics.start () - Calcola metà larghezza e altezza dello schermo metà W = display.contentWidth * 0.5 halfH = display.contentHeight * 0.5 - Imposta lo sfondo locale bkg = display.newImage ("night_sky.png", halfW, halfH) - Punteggio punteggio = 0 scoreText = display.newText (punteggio, halfW, 10) - Chiamato quando il pallone viene toccato dal giocatore - Aumenta il punteggio di 1 funzione locale balloonTouched ( evento) if (event.phase == "iniziato"), quindi Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = score + 1 scoreText.text = score end end - Chiamato quando il bomba viene toccata dal giocatore - Metà del punteggio come penalità funzione locale bombTouched (evento) if (event.phase == "iniziato"), quindi Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = math.floor (score * 0.5) scoreText.text = score end end - Elimina gli oggetti caduti parte inferiore dello schermo funzione locale offscreen (self, event) if (self.y == nil) quindi restituisce end if (self.y> display.contentHeight + 50) quindi Runtime: removeEventListener ("enterFrame", self) self: removeSelf () end end - Aggiungi un nuovo fumetto in caduta o bomba funzione locale addNewBalloonOrBomb () - Puoi trovare red_ballon.png e bomb.png nel repository GitHub local startX = math.random (display.contentWidth * 0.1, display.contentWidth * 0.9) if (math.random (1,5) == 1) allora - BOMB! local bomb = display.newImage ("bomb.png", startX, -300) physics.addBody (bomb) bomb.enterFrame = offscreen Runtime: addEventListener ("enterFrame", bomb) bomb: addEventListener ("touch", bombTouched) altro - Balloon local balloon = display.newImage ("red_balloon.png", startX, -300) physics.addBody (balloon) balloon.enterFrame = offscreen Runtime: addEventListener ("enterFrame", balloon) fumetto: addEventListener ("touch", balloonTouched) end end - Aggiungi un nuovo fumetto o bomba ora aggiungi NewBalloonOrBomb () - Continua ad aggiungere un nuovo fumetto o bomba ogni 0,5 secondi timer.performWithDelay (500, addNewBalloonOrBomb, 0)
Prossimi passi
Il prossimo passo è giocare su un vero dispositivo Android. Per creare un file .apk fai clic su File-> Crea per Android ... e compila i campi. Il risultato sarà un file .apk che puoi copiare sul tuo dispositivo e quindi installare. Dovrai assicurarti di aver configurato il tuo dispositivo per consentire l'installazione di app da fonti sconosciute. Amazon ha una buona documentazione su questo in quanto è necessario anche impostarlo per installare Amazon Appstore. Corona ha anche una guida su come firmare, costruire e testare la tua app su dispositivi Android.
Con il gioco installato correttamente sul tuo dispositivo, la prossima cosa da fare è migliorare il gioco. Ad esempio, perché non provare ad aggiungere un suono "pop" o "bang" tutto ciò che viene toccato un pallone o una bomba. Corona ha un'API per questo:media.playEventSound ().
O perché non provare ad aggiungere un terzo tipo di oggetto, dire un super boost che raddoppia il punteggio attuale o che ne dici di un po 'di musica di sottofondo?
Incartare
Scrivere giochi con Corona è abbastanza semplice perché l'SDK gestisce cose come OpenGL e include un motore fisico 2D incorporato. Inoltre Lua è facile da imparare e non dovrebbe essere difficile per chiunque abbia anche il minimo di esperienza di programmazione. Il sito Web di Coronalabs ha molta documentazione tra cui molte guide ed esercitazioni.
In meno di 100 righe di codice abbiamo un gioco funzionante. OK, non vincerà alcun premio, tuttavia mostra la potenza e la flessibilità dell'SDK Corona.
