Share
Questo tutorial fornirà il porting di un gioco Flash / Flex all'SDK Corona. In particolare, eseguiremo il porting da ActionScript a Lua, con l'obiettivo finale di riprodurre in precedenza giochi solo su Flash sull'iPhone. Oltre a dimostrare differenze linguistiche e API, questa serie di tutorial terrà conto anche delle restrizioni hardware come la dimensione dello schermo e la mancanza di pulsanti fisici su iPhone.
Prima di entrare nella vera codifica, vorrei dare una rapida panoramica del software che faremo
stare usando Corona SDK è un prodotto di Ansca Mobile per la creazione di giochi per iPhone, iPod Touch, iPad e dispositivi Android. Al momento della stesura di questo articolo, è disponibile una versione di prova gratuita e illimitata del kit disponibile qui. Include tutte le funzionalità della versione a pagamento, tranne che per la pubblicazione sui rispettivi negozi di app di iPhone e dispositivi Android. Questo tutorial farà un'ottima introduzione alla potenza e all'efficienza di Corona.
In questo tutorial, porteremo un gioco a flixel di Andreas Zecher. Questo gioco è stato creato con il tutorial di Andreas sulla libreria flixel open source e sul linguaggio ActionScript. Il codice originale è disponibile qui (Andreas è stato così gentile da rilasciarlo come open source). Se sei interessato a creare giochi flash, assicurati di dare un'occhiata al tutorial originale. Ci sono alcune informazioni veramente utili lì!
Il kit di sviluppo software di Ansca Mobile utilizza il linguaggio di programmazione lua e estende le loro API. Lua è un linguaggio molto pulito. Mentre mi occupo dei principianti, ho trovato molto potente con un codice molto piccolo. Lua non è un
linguaggio orientato agli oggetti, ma può essere fatto per seguire il modello orientato agli oggetti con qualche messa a punto.
Detto questo, diamo un'occhiata al nostro primo ostacolo: Lua è sintatticamente diverso da ActionScript.
Le variabili in Lua vengono gestite in modo diverso rispetto a ActionScript. In ActionScript, le variabili sono tipizzate staticamente. Ciò significa che dichiarano il loro tipo e memorizzano solo valori di quel tipo a meno che non vengano convertiti esplicitamente.
? private var _ship: Ship; // Le variabili dichiarano il loro tipo. Questa variabile è di tipo "Ship" private var _aliens: FlxGroup; private var _bullets: FlxGroup; private var _scoreText: FlxText; private var _gameOverText: FlxText; private var _spawnTimer: Number; private var _spawnInterval: Number = 2.5;?
In lua, le variabili sono digitate dinamicamente. Una variabile Lua può contenere qualsiasi tipo in qualsiasi momento. Un altro
cosa da notare è che le variabili in Lua sono sia locali che globali. Una variabile è locale
(solo accessibile) al suo file .lua o alla sua funzione, ecc. se è preceduto da "local" nel file
dichiarazione della variabile. Altrimenti, è considerato di portata "globale". La migliore pratica in Lua è quella di usare sempre
variabili locali. Questo tutorial aderirà a questa pratica.
? _ship locale: le variabili non dichiarano il loro tipo. Questa variabile potrebbe essere una "nave" o potrebbe essere una stringa. In seguito, potrebbe essere utilizzato per memorizzare un numero intero o un array. local _aliens local _bullets local _scoreText local _gameOverText local _spawnTimer = nil - Questa variabile ha un'assegnazione e una dichiarazione sulla stessa riga. local _spawnInterval = 2.5 - Così fa questo?
Come probabilmente già notato, i commenti vengono gestiti in modo diverso in Lua che in ActionScript.
// Questo è un commento in ActionScript / * Questo è un commento multilinea in ActionScript * /
-- Questo è un commento in lua - [[Questo è un commento multilinea in lua -]]
Una cosa importante da sapere sui commenti in Lua è che tutto dopo "-" è un commento tranne
per "- [[". Ciò consente un trucco accurato. Se aggiungi un trattino in più all'inizio della multilinea
commento "--- [[", commenta la parte multilinea. Questo succede perché tutto dopo il primo
due trattini è un commento. Ora guarda il commento finale "-]]". È già un commento perché anche questo
è dopo due trattini. Questo diventa effettivamente un interruttore per spegnere e accendere bit di codice!
--[[Questo è un commento -]] --- [[Questo è un codice e sarà eseguito come tale. In questo caso, verrebbe generato un errore. -]]
I loop, le parentesi e gli operatori sono definiti da parole in Lua:
// ActionScript if (_spawnTimer < 0) spawnAlien(); resetSpawnTimer();
-- lua if (_spawnTimer < 0) then spawnAlien() resetSpawnTimer() end
Lua usa "if-then", "else", "elseif-then", "end", "and", "or", ecc. Notate anche che Lua non usa
punto e virgola per terminare ogni riga. Senza tutte le parentesi e i punti e virgola, il codice Lua sembra molto di più
come la lingua inglese rispetto ad altri linguaggi di programmazione.
Un'altra cosa da notare prima di iniziare è che Lua non ha il supporto per le scorciatoie di assegnazione.
// ActionScript _spawnInterval * = 0,95; // Questo è permesso in ActionScript
-- lua _spawnInterval * = 0.95 - Questo comporterà un errore in lua _spawnInterval = _spawnInterval * 0.95 - Questo è il codice Lua corretto
Ora che comprendiamo alcune delle differenze fondamentali tra ActionScript e Lua, possiamo iniziare
processo di trasferimento del gioco tra di loro. Il codice sorgente per questo tutorial e allegato a questo post include il
codice sorgente originale e codice finito per il progetto di oggi.
Per rendere più facile il porting, inizieremo convertendo tutta la sintassi nella nostra fonte
file, senza preoccuparci della reale logica applicativa. In questo modo, quando iniziamo a lavorare sulla logica, il
il codice sarà già formattato correttamente. Iniziamo il processo con il file Main.as, che sembra
qualcosa come questo:
pacchetto import org.flixel. *; import de.pixelate.flixelprimer. *; [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] [Frame (factoryClass = "Preloader")] public class Main estende FlxGame public function Main (): void super (640, 480, PlayState, 1);
Non c'è molto da fare qui. Non abbiamo bisogno della dichiarazione "pacchetto", quindi possiamo rimuovere le righe superiore e inferiore del codice.
import org.flixel. *; import de.pixelate.flixelprimer. *; [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] [Frame (factoryClass = "Preloader")] public class Main estende FlxGame public function Main (): void super (640, 480, PlayState, 1);
Poiché Lua non ha classi, possiamo rimuovere la riga "public class Main estende FlxGame" ed è
parentesi corrispondenti.
import org.flixel. *; import de.pixelate.flixelprimer. *; [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] [Frame (factoryClass = "Preloader")] public function Main (): void super (640, 480, PlayState, 1);
Ora possiamo lavorare sulla funzione Main (). Prima di tutto, nota la dichiarazione "pubblica" del metodo.
Lua non ha tipi di funzione separati, quindi possiamo rimuoverlo. Ricorda che in lua, funzioni
non dichiarare il loro tipo di reso. C'è una parola chiave ": void" alla fine della dichiarazione della funzione.
Ciò significa che questa funzione non restituirà un valore, che non è necessario in lua. Quindi possiamo cadere
esso. Si consiglia di commentare solo per riferimento in seguito. Infine, rimuovi le parentesi
Principale(). In lua, usiamo le parole. Aggiungi "end" alla fine della funzione.
import org.flixel. *; import de.pixelate.flixelprimer. *; [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] [Frame (factoryClass = "Preloader")] funzione Main () -: void super (640, 480, PlayState, 1); fine
Per concludere, rimuovi tutto il punto e virgola ";" e commentare tutte le righe di codice. Questo
In questo modo, possiamo iniziare a portare la logica senza ottenere errori.
--import org.flixel. * --import de.pixelate.flixelprimer. * - [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] - [Frame (factoryClass = "Preloader")] - funzione Main () -: void - super (640, 480, PlayState, 1) --end
A questo punto vorrai creare una cartella di progetto per conservare i tuoi file. Ho chiamato il mio
"Alien_shooter". Questa è la cartella che passerai a Corona quando sarai pronto per eseguire il tuo
codice. All'interno della cartella, Corona cerca il file "main.lua". Corona è case-sensitive, quindi tu
non utilizzare la prima lettera maiuscola come in "Main.as". Salva il codice sopra come main.lua.
Passiamo al prossimo file. Oggi lavoreremo solo con due dei file sorgente. Il secondo
il file si trova in "de / pixelate / flixelprimer / PlayState.as" nel codice sorgente allegato. Questo file è dove
tutto il gameplay è gestito. In quanto tale, è il file più lungo. Modificheremo la sintassi in piccoli blocchi.
Proprio come il file principale, questo codice ha una dichiarazione di pacchetto e di classe. Rimuovi le linee che iniziano
con "pacchetto" e "classe pubblica PlayState" e le loro parentesi.
Ora vediamo un elenco di variabili locali.
? private var _ship: Ship; private var _aliens: FlxGroup; private var _bullets: FlxGroup; private var _scoreText: FlxText; private var _gameOverText: FlxText; private var _spawnTimer: Number; private var _spawnInterval: Number = 2.5;?
Ricorda prima che le variabili in Lua sono locali o globali e che non ne hanno bisogno
dichiarare il loro tipo Modifica le variabili per assomigliare a questo:
? _ship locale; locali _aliens; _bullets locali; local _scoreText; local _spawnInterval = 2.5;?
Ora spostati verso il basso nell'elenco delle dichiarazioni di funzioni, a partire da create (). Rimuovi tutte le dichiarazioni del tipo di funzione, come "pubblico"
o "override pubblico". Commenta o rimuovi tutti i tipi di reso per le funzioni. Quasi tutte queste funzioni sono ": void". Sostituisci le parentesi della funzione con "end". Create () ora dovrebbe assomigliare a questo:
? function create () -: void FlxG.score = 0; bgColor = 0xFFABCC7D; _ship = new Ship (); aggiungi (_ship); _aliens = new FlxGroup (); aggiungere (_aliens); _bullets = new FlxGroup (); aggiungere (_bullets); _scoreText = new FlxText (10, 8, 200, "0"); _scoreText.setFormat (null, 32, 0xFF597137, "left"); aggiungi (_scoreText); resetSpawnTimer (); super.create (); fine?
Quando arriviamo a funzioni come update (), dobbiamo anche occuparci delle istruzioni if-then. Appena
sostituire la parentesi di apertura "" con "then" e la parentesi di chiusura "" con "end". Qualsiasi "&&" dovrebbe
essere sostituito con "e". "||" deve essere sostituito con "o".
Accentsconagua
? function update () -: void FlxU.overlap (_aliens, _bullets, overlapAlienBullet); FlxU.overlap (_aliens, _ship, overlapAlienShip); se (FlxG.keys.justPressed ("SPACE") e _ship.dead == false) spawnBullet (_ship.getBulletSpawnPosition ()); fine se (FlxG.keys.ENTER e _ship.dead) quindi FlxG.state = new PlayState (); end _spawnTimer - = FlxG.elapsed; if (_spawnTimer < 0) then spawnAlien(); resetSpawnTimer(); end super.update(); end? Alcune funzioni, come overlapAlienBullet (), accettano argomenti. In ActionScript, dobbiamo dichiarare il tipo di argomenti che passeremo. La funzione overlapAlienBullet () accetta una variabile "alien" (di tipo Alien) e una variabile denominata "bullet" (di tipo Bullet). Queste dichiarazioni di tipo dovrebbero essere rimosse. Inoltre, overlapAlienBullet () ha variabili locali. Rimuovi anche le dichiarazioni di tipo da queste. Nota: le dichiarazioni delle variabili locali devono avere la parola chiave local prima di esse.
Prima:
? funzione privata overlapAlienBullet (alien: Alien, bullet: Bullet): void var emitter: FlxEmitter = createEmitter (); emitter.at (alieno); alien.kill (); bullet.kill (); FlxG.play (SoundExplosionAlien); FlxG.score + = 1; _scoreText.text = FlxG.score.toString (); ?
Dopo:
? function overlapAlienBullet (alien, bullet) -: void local emitter = createEmitter (); emitter.at (alieno); alien.kill (); bullet.kill (); FlxG.play (SoundExplosionAlien); FlxG.score + = 1; _scoreText.text = FlxG.score.toString (); fine?
L'ultima funzione, createEmitter (), ha una dichiarazione for-do. Non useremo questa funzione
nel gioco finale, ma dovremmo dare un'occhiata a questa affermazione:
per (var i: int = 0; i < particles; i++) var particle:FlxSprite = new FlxSprite(); particle.createGraphic(2, 2, 0xFF597137); particle.exists = false; emitter.add(particle);
La prima riga di codice crea una variabile "i" con valore 0. Il codice tra parentesi si ripete
stesso mentre "i" è inferiore alla variabile "particelle". Ogni ciclo, la variabile "i" ottiene
incrementato di 1.
per i = 0, le particelle-1 fanno? fine
La precedente istruzione Lua crea una variabile "i" con un valore di 0. Il codice tra parentesi
si ripete fino a quando "i" è uguale alla variabile "particelle" meno 1 (lo stesso che controllare se "i"
è inferiore a "particelle"). Anche la variabile "i" viene incrementata di 1 ogni ciclo.
Ora possiamo concludere trattando solo sintassi. Rimuovi tutto il punto e virgola. Commenta tutto il codice come
con il file principale. Aggiungi commenti a riga singola prima delle singole righe di codice.
--local _ship --local _aliens --local _bullets --local _scoreText --local _spawnInterval = 2,5
Aggiungi commenti multilinea su funzioni e blocchi di codice.
--[[function create () -: void FlxG.score = 0 bgColor = 0xFFABCC7D _ship = new Ship () add (_ship) _aliens = new FlxGroup () add (_aliens) _bullets = new FlxGroup () add (_bullets) _scoreText = nuovo FlxText (10, 8, 200, "0") _scoreText.setFormat (null, 32, 0xFF597137, "left") add (_scoreText) resetSpawnTimer () super.create () end -]]
Vai avanti e salva questo file come PlayState.lua nella cartella del tuo progetto. Non metterlo in una sottodirectory
come il codice sorgente Corona ha problemi con i moduli nelle sottodirectory.
Ora siamo pronti per iniziare a portare la logica dietro questo gioco. Parliamo prima della logica del file.
Nella nostra sorgente ActionScript, il file Main.as viene eseguito per primo. Gli altri file, come
PlayState.as, sono chiamati pacchetti. Questi pacchetti sono importati nel file principale. A Lua, il
il file main.lua viene eseguito per primo. Gli altri file sono noti come moduli e sono richiesti in
file principale. In ActionScript, i pacchetti hanno una dichiarazione del pacchetto. In Lua, i moduli devono anche avere un
dichiarazione, o il file principale non può vederli. Ciò significa che dobbiamo modificare il nostro file PlayState.lua.
Nella parte superiore del file o in qualsiasi altro file di modulo, aggiungi questa linea in modo che main.lua possa funzionare con
modulo.
module (?, package.seeall)
Ora torna al file main.lua in modo che possiamo caricare il nostro modulo. Dovrebbe essere simile a questo:
--import org.flixel. * --import de.pixelate.flixelprimer. * - [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] - [Frame (factoryClass = "Preloader")] - funzione Main () -: void - super (640, 480, PlayState, 1) --end
Vediamo che il codice ActionScript originale ha importato tutti i pacchetti in "org / flixel" e in
"De / pixelate / flixelprimer". Sostituisci quelle linee per farlo:
local PlayState = require ("PlayState") - [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] - [Frame (factoryClass = "Preloader")] --function Main () -: void - super (640, 480, PlayState, 1) --end Questo codice crea una nuova variabile (che è locale al file principale) per contenere il modulo richiesto. Noi
ora è possibile accedere a qualsiasi codice dal file PlayState.lua dalla variabile "PlayState".
Prima di continuare con main.lua, dobbiamo apportare alcune modifiche a PlayState.lua. Se guardiamo al
file originale PlayState.as, vediamo che tutte le funzionalità sono racchiuse all'interno di una classe
chiamato PlayState. Non possiamo creare classi con lua, ma possiamo organizzare il nostro codice in un modo per farlo
è orientato agli oggetti. Riunendo tutte le funzionalità con una funzione di costruzione, possiamo ottenere
lo stesso effetto. Mantenendo tutti i commenti del tuo codice, aggiungi queste righe attorno a tutto il codice.
funzione PlayState ()? il codice va qui? fine
Ora, tutte le funzioni saranno locali per la funzione PlayState. Queste funzioni diventano private per
una sorta di istanza di PlayState che viene creata quando viene chiamato PlayState (). Se volessi imitare a
metodo di classe, potresti mettere la dichiarazione al di fuori della funzione. Impareremo nelle lezioni successive
anche qui come creare metodi di istanza.
Ecco un esempio di modulo che dimostra questa funzionalità:
module (?, package.seeall) local numberOfInstances = 0 - questa funzione mima una funzione del metodo di classe getNumberOfInstances () restituisce numberOfInstances end - questa funzione mima una funzione di classe Instance () local Instance = numberOfInstances = numberOfInstances + 1 local instanceNumber = numberOfInstances - questa funzione simula una funzione del metodo di istanza Instance: getInstanceNumber () restituisce instanceNumber end - questa funzione mima una funzione privata metodo create () restituisce l'istanza end - questo chiama il metodo privato dopo che tutte le funzioni sono state dichiarate di ritorno create () fine
Se vuoi giocare con il codice sopra, ecco un file main.lua che ne dimostra l'uso (assumendo il file
il modulo viene salvato come test.lua):
test locale = require ("test") local instance1 = test.Instance () local instance2 = test.Instance () local instance3 = test.Instance () local instance4 = test.Instance () print (test.getNumberOfInstances ()) stampa (instance2: getInstanceNumber ()) Si noti che le funzioni del modulo utilizzano la sintassi del punto, mentre tutte le altre funzioni Lua (e anche alcune di esse)
le loro dichiarazioni come abbiamo appena visto) usano i due punti (:) al posto del punto. Questo può essere fonte di confusione, come
si accede alle proprietà in Lua usando la sintassi del punto. Per questo motivo, abbiamo lasciato tutte le chiamate di funzione
da solo durante il porting della sintassi in precedenza. Decideremo se utilizzare i due punti o un punto per ogni caso
ci siamo imbattuti.
Ora che abbiamo tutte le funzionalità di PlayState.lua all'interno della funzione PlayState (), tutte
le funzioni ora imitano le funzioni private in ActionScript. Che è esattamente
ciò che vogliamo. Aggiungi una variabile PlayState locale nella parte superiore della funzione.
funzione PlayState () local PlayState = ? fine
Ora, vai avanti e decommenta la funzione create () e spostala in basso (poco prima
la fine finale). Aggiungi commenti a riga singola a tutte le linee all'interno della funzione, quindi possiamo ancora
vedere la logica, ma non genera errori.
module (?, package.seeall) function PlayState () local PlayState = ? un bel po 'di codice commentato? function create () -: void --FlxG.score = 0 --bgColor = 0xFFABCC7D --_ ship = new Ship () --add (_ship) --_ aliens = new FlxGroup () --add (_aliens) - _bullets = new FlxGroup () --add (_bullets) --_ scoreText = new FlxText (10, 8, 200, "0") --_ scoreText.setFormat (null, 32, 0xFF597137, "left") --add (_scoreText ) --resetSpawnTimer () --super.create () end-end
Il gioco ActionScript originale è stato creato utilizzando la libreria flixel discussa all'inizio di questo
lezione. Sfortunatamente, al momento della stesura di questo documento non c'è nessuna porta Lua di flixel. Quindi, lo saremo
implementando tutta la logica di flixel con l'API di Corona SDK.
Le prime cose da notare, è di nuovo nel file main.lua. In flixel, la funzione Main () automaticamente
viene chiamato quando il programma viene eseguito. In Corona, il file main.lua viene eseguito dall'alto verso il basso.
Quindi, per ottenere lo stesso effetto della fonte, aggiungi Main () alla fine di main.lua.
local PlayState = require ("PlayState") - [SWF (width = "640" ,, backgroundColor = "# ABCC7D")] - [Frame (factoryClass = "Preloader")] funzione Main () -: void - - super (640, 480, PlayState, 1) end Main () Inoltre, nella maggior parte dei giochi di flixel, viene visualizzato un preloader con il logo flixel mentre il programma è
Caricamento in corso. Non è necessario per la nostra app, quindi non creeremo un file preloader.lua. Le linee aggiungono
il preloader e l'impostazione della dimensione / sfondo del programma possono essere rimossi (non possiamo cambiare l'app
taglia).
local PlayState = require ("PlayState") function Main () -: void - super (640, 480, PlayState, 1) end Main () Mentre siamo qui, crea un nuovo PlayState in Main ().
local PlayState = require ("PlayState") function Main () -: void PlayState.PlayState () end Main () Tornando a PlayState.lua, notiamo che create () non viene chiamato. In flixel, create () e
update () vengono gestiti automaticamente. Avremo bisogno di prenderci cura di questi noi stessi a Corona. Aggiungere un
chiama a create () prima dell'ultima parte.
module (?, package.seeall) function PlayState () local PlayState = ? un bel po 'di codice commentato? function create () -: void? ha commentato la logica create ()? fine create () fine
Prima di andare avanti, diamo un'occhiata a ciò che abbiamo finora. Ora abbiamo un file main.lua che
richiede PlayState.lua e esegue PlayState (). PlayState () crea una nuova istanza di PlayState e poi
chiama create (). Create () è dove tutto il codice di installazione per il gioco va. Ora abbiamo un quadro
per costruire la nostra logica in giro.
Ora dobbiamo iniziare ad aggiungere funzionalità alla nostra funzione create () per impostare il nostro gioco. Iniziamo
creando lo sfondo colorato di verde del gioco. Nel nostro codice, abbiamo commentato questa linea nel nostro
funzione create ().
--bgColor = 0xFFABCC7D;
Questo ci dice il valore esadecimale per il colore verde originale. Un modo semplice per fare uno sfondo
in Corona è creare un rettangolo colorato della stessa dimensione dello schermo. Questo può essere fatto usando
Gli oggetti di visualizzazione di Corona. Simile a ActionScript, Corona ci fornisce un'API per la visualizzazione degli oggetti
lo schermo. Possiamo usare il modulo display per molte attività diverse. Può essere usato per creare
nuovi oggetti o gruppi di oggetti o per trovare la larghezza / altezza dello schermo. Creiamo un nuovo
rettangolo e salvarlo come proprietà della nostra variabile PlayState.
module (?, package.seeall) function PlayState () local PlayState = ? un bel po 'di codice commentato? function create () -: void PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight)? ha commentato la logica create ()? fine create () fine
Qui abbiamo creato un nuovo rettangolo da (0,0) a (la larghezza dello schermo, l'altezza dello schermo) e memorizzato
nella variabile _background. Ho messo il segno di sottolineatura lì al fine di simulare il codice originale. Tutti
delle variabili private nella versione ActionScript del gioco inizia con un trattino basso.
_background è privato per ogni istanza di PlayState, quindi l'ho formattato come le altre variabili.
Notare la sintassi del punto. Se ricordi di prima, questo significa che _background è ora una proprietà di
VisualizzarloState. Poiché abbiamo creato la variabile PlayState al di fuori della funzione create (), è disponibile
ora a tutte le funzioni. Se avessimo creato PlayState all'interno di create () in questo modo:
module (?, package.seeall) function PlayState () function create () - PlayState ora è local per create () local PlayState = - PlayState può ancora essere utilizzato in create, ma non è disponibile all'esterno. PlayState._aNumber = 10 end function otherFunction () - Questo genererà un errore. otherFunction non sa cosa sia PlayState. print (PlayState._aNumber) end create () otherFunction () end
Non saremmo stati in grado di usarlo in otherFunction (). Da quando abbiamo creato PlayState all'inizio
di PlayState (), tutte le funzioni possono usarlo.
module (?, package.seeall) function PlayState () - PlayState è ora locale per PlayState () local PlayState = function create () - PlayState (e le sue proprietà) possono essere utilizzate in create e altrove. PlayState._aNumber = 10 end function otherFunction () PlayState._aNumber = PlayState._aNumber + 4 - Questo stamperà 14 print (PlayState._aNumber) end create () otherFunction ()
Se esegui il codice con il nuovo rettangolo, vedrai uno sfondo bianco. Dobbiamo cambiarlo
riempire il colore al verde. Per fare questo abbiamo bisogno di convertire il codice esadecimale (ABCC7D) in RGB, che è cosa
Corona usa per riempire gli oggetti di visualizzazione. Puoi incollare quel codice in uno qualsiasi dei siti esadecimali RGB.
Il risultato sarà (171, 204, 125). Ora utilizzare il metodo di istanza setFillColor (notare i due punti) attivo
PlayState._background.
module (?, package.seeall) function PlayState () local PlayState = ? un bel po 'di codice commentato? function create () -: void PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171, 204, 125)? ha commentato la logica create ()? fine create () fine
Ora abbiamo l'inizio di un gioco. Facciamo qualche altro cambiamento prima di concludere la giornata.
Aggiungiamo una variabile a ciascuna istanza di PlayState per sapere se il gioco è in esecuzione o meno.
module (?, package.seeall) function PlayState () local PlayState = ? un bel po 'di codice commentato? function create () -: void PlayState._inGame = true PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171, 204, 125)? ha commentato la logica create ()? fine create () fine
Questo diventerà molto utile in seguito. Eliminiamo anche la barra di stato nella parte superiore dell'iPhone.
Vogliamo farlo solo una volta all'avvio dell'app, quindi aggiungilo a main.lua.
local PlayState = require ("PlayState") function Main () -: void display.setStatusBar (display.HiddenStatusBar) PlayState.PlayState () end Main () Un altro passo importante quando si crea un'applicazione Corona è aggiungere un file di configurazione che indicherà a Corona come
per ridimensionare la tua app su altre piattaforme. In questo tutorial, ci occupiamo solo degli iPhone
dimensioni dello schermo (anche se l'app verrà eseguita anche su Android). Crea un file chiamato config.lua e compilalo
con questo.
application = content = width = 320, height = 480, scale = "letterbox",
Ora la nostra app funzionerà anche su display retina. Nota: questo file funziona con qualsiasi app Corona.
Ora disponiamo di un quadro operativo su cui iniziare a costruire. La nostra app non sembra ancora molto, ma noi
hanno coperto molti dei passi importanti nel porting da una lingua all'altra. Nel prossimo
lezione in questa serie inizieremo a fare un gioco giocabile.
