Share
Denna handledning tar en titt på att överföra ett Flash / Flex-spel till Corona SDK. Specifikt kommer vi att överföra från ActionScript till Lua, med slutmålet att spela tidigare Flash-only-spel på iPhone. Förutom att visa språk- och API-skillnader, kommer denna handledningsserie också att ta hänsyn till hårdvarubegränsningar som skärmstorlek och brist på fysiska knappar på iPhone.
Denna handledning tar upp var den första började.
Börja med att porta syntaxen från källfilen "de / pixelate / flixelprimer / Ship.as" som beskrivs
i dag ett inlägg. Specifikt måste du:
Lägg nu till moduldeklarationen längst upp i filen så att vi kan importera filen till PlayState.
Gå vidare och lägg in hela koden med en Ship () konstruktörsfunktion. Din kod ska nu ordnas så här:
modul (?, package.seeall) funktion Ship ()? alla kommenterade koden går här? slutet
Vi har inte flixel, så bli av med importdeklarationen för den. Kolla nu på våra högsta linjer
Ship () funktion:
funktion Ship () - [Inbädda (source = "? /? /? /? /assets/png/Ship.png")] privat var ImgShip: Klass - [[funktion Ship () -: void super , 50, ImgShip) slutet -]]? slutet
Den första raden lastar fartygets bild och lagrar den i variabeln ImgShip. De följande linjerna är
den gamla konstruktormetoden. När fartyget skapades tilldelade denna funktion bilden ImgShip och koordinaterna (50, 50). Vi kan göra samma sak genom att skapa en Ship-variabel som rymmer en bild. Vi kan ladda bilden med den visningsmodul vi använde i lektion 1. Då kan vi ställa in variablerna x och y egenskaper till 50. Byt ovanstående rader för att göra följande:
Accentsconagua
funktion Ship () local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50? kommenterad kod? slutet Låt oss nu göra vår Ship () -funktion tillbaka, så att vår PlayState kan använda den.
funktion Ship () local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50? kommenterad kod? returnera Ship slut I vår ActionScript-källa skapas ett skepp i PlayState genom att kalla "New Ship ()". Medan vi är på
det, låt oss skapa en ny () -funktion som returnerar Ship ().
funktion Ship () local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50? kommenterad kod? returnera Ship slutfunktion ny () returnera Ship () slut Verkligen finns det inget tekniskt behov av detta, men det gör vår kod lite mer läsbar.
Gå tillbaka till PlayState.lua och kräva vår Ship-modul högst upp.
modul (?, package.seeall) local Ship = kräver ("Ship") funktion PlayState ()? Nu kan vi skapa ett nytt skepp. Först flyttar du alla kommenterade variabla deklarationer från början av filen till funktionen create ().
modul (?, package.seeall) local Ship = kräver ("Ship") funktion PlayState () lokala PlayState = ? en hel massa kommenterad kod? funktion skapa () -: void PlayState._inGame = true - lokal _ship - lokal _aliens - lokal _bullets - lokal _scoreText - lokal _gameOverText - lokal _spawnTimer - lokal _spawnInterval = 2,5 PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171, 204, 125)? kommenterade skapa () logik? avsluta skapa () slutet Lämna dem kommenterade, gör dem egenskaper hos PlayState. Ställ in egenskaperna utan ett värde till noll. Medan vi är i det måste vi göra en _backgrounddeklaration.
? PlayState._background = nil --PlayState._ship = nil --PlayState._aliens = nil --PlayState._bullets = nil --PlayState._scoreText = nil --PlayState._gameOverText = nil --PlayState._spawnTimer = nil - Spelstat ._spawnInterval = 2.5?
Uncomment _ship-variabelns deklaration och skapa ett nytt skepp så här:
funktion skapa () -: void - variable declarations PlayState._inGame = true PlayState._background = noll PlayState._ship = nil - PlayState._aliens = nil - PlayState._bullets = nil - PlayState._scoreText = nil - PlayState._gameOverText = nil - PlayState._spawnTimer = nil - SpelaState._spawnInterval = 2.5 - variabla uppdrag PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171 , 204, 125) PlayState._ship = Ship.new ()? kommenterade skapa () logik? slutet
Notera här att vi tilldelar _background först. Detta beror på att visningsobjekt i Corona beställs
när de skapas. Vi skulle inte kunna se _ship om vi skapade det före _background.
Om du kör koden finns det nu ett skepp som visas på (50, 50).
Vi måste kunna flytta skeppet för att kunna spela, men hur kan vi? Det ursprungliga spelet skapades för att styras av ett tangentbord. En iPhone har inget tangentbord. Hur kan vi komma runt detta? Detta är en av de många faktorer som måste beaktas när du skapar en app för en mobilenhet, oavsett om du portar befintlig kod eller skapar en app från början. En annan som vi redan hanterar är skärmstorlek. På en dator finns program i många olika storlekar. De flesta av dem är även resizable. På en iPhone är programmen lika stora.
Att lösa dessa problem kan vara utmanande. Att komma runt dessa begränsningar kräver tänkande
utanför lådan. Till exempel kunde vi styra vårt skepp med knapparna på skärmen. Vi kunde också trycka på platsen på skärmen som vi vill att skeppet ska flytta till. Vi kan även använda enhetens
accelerometer för att styra fartyget baserat på enhetens lutning. Kanske ändrar vi spelspelet lite och gör fartyget självkontrollerat. Då skulle spelaren bara vara ansvarig för fotograferingen. Som du kan se finns det många möjligheter för nya spelstilar på iPhone.
Så snyggt som många av dessa idéer var, kommer vi att skapa skärmknappar för att styra skeppet. På så sätt kommer spelet att vara mest i linje med originalet. Jag lämnar de andra alternativen för dig att utforska.
Ansca Mobile har skapat ett bibliotek med öppen källkod för att skapa virtuella knappar. Istället för
bygga biblioteket i Corona, de har inkluderat det på deras hemsida som valfritt. jag har
inkluderade den senaste versionen av detta skrivande i källkoden för denna handledning. Lägg till
"ui.lua" -filen till din projektmapp.
Gå över till din Ship.lua-fil så vi kan göra vissa inställningar. Låt oss lägga till några egenskaper i vår Ship-variabel. Strax under koden där vi sätter fartygets koordinater till (50, 50) lägg till följande:
? lokalt skepp = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50 Ship._up = false Ship._down = false Ship._left = false Ship._right = false? Vi ska använda dessa för att berätta för skeppet när vi ska flytta. Om värdena ändras till sant betyder det att de respektive knapparna trycks in.
Tillbaka i PlayState.lua måste vi skapa en ny funktion för att hantera skapande knappar. Vi ska hantera detta utanför PlayState () eftersom det kommer att bli lite rörigt. Innan vi går vidare,
se till att du har alla knappbilder från källan som ingår i denna handledning. Skapa nu en knappHandler () -funktion under PlayState ().
? funktion PlayState ()? avsluta funktionsknappenHandler (PlayState) slutet
Observera att knappenHandler () tar ett argument: PlayState. Detta beror på att vi skapar
buttonHandler () utanför PlayState () -funktionen. Om du kommer ihåg från den första lektionen betyder det
den knappenHandler () har ingen aning om vilken PlayState-variabel som är, eftersom PlayState är lokal i
PlayState () -funktionen. Vi kommer att ringa knappenHandler () inuti PlayState (). Genom att passera
PlayState till buttonHandler (), tillåter vi buttonHandler () att se och ändra alla PlayState och dess egenskaper. Eftersom _ship är en egenskap hos PlayState, kommer knappenHandler () att kunna ställa in
_ship_up, _ship._down, etc.
Vi ska importera ui.lua-modulen till vår buttonHandler-funktion istället för på toppen av
PlayState.lua. Du kommer att se varför senare.
? funktion PlayState ()? avsluta funktionsknappenHandler (PlayState) local ui = kräver ("ui") slutet Nu ska det bli lite rörigt. Vi ska skapa två funktioner för varje knapp. Ett
för när knappen trycks och en för när knappen släpps. När dessa kallas kommer de att sätta fartygets egenskaper till sanna eller falska.
funktionsknappHandler (PlayState) local ui = kräver ("ui") funktion upPressed () PlayState._ship._up = sant slutfunktion upReleased () PlayState._ship._up = falsk slutfunktion nedtryckt () PlayState._ship._down = true end funktion downReleased () PlayState._ship._down = falsk slutfunktion leftPressed () PlayState._ship._left = sant slutfunktion leftReleased () PlayState._ship._left = falsk slutfunktion rightPressed () PlayState._ship._right = true endfunktion rightReleased () PlayState._ship._right = falskt slutändat Eftersom vi skickar PlayState till buttonHandler (), och _ship och alla dess egenskaper hör till
PlayState, vi kan ändra dem från sant till falskt och vice versa. Nu måste vi skapa de faktiska knapparna. Med den importerade ui-modulen kan vi använda en av dess metoder: newButton. Det här har en intressant syntax, så häng bara fast.
PlayState._upButton = ui.newButton defaultSrc = "up.png", defaultX = "50", defaultY = "50", overSrc = "up.png", overX = "50", overY = "50", onPress = upPressed, onRelease = upReleased, id = "_upButton"
Denna kod kallar newButton och tilldelar resultatet till _upButton (en egenskap av PlayState). I början,
du kanske undrar varför det finns parenteser. Detta är inget undantag från reglerna för lua-syntax.
Faktum är att parenteserna håller en rad parametrar som skickas till newButton-metoden. Det finns många parametrar här, så låt oss gå över dem en i taget. Den första, defaultSrc är placeringen av bilden som ska användas när knappen inte trycks in. defaultX och defaultY är bildens dimensioner. overSrc är placeringen av bilden som ska visas när knappen trycks in. I det här fallet kommer vi att använda samma bild. overX och overY fungerar precis som defaultX och defaultY, men de är dimensionerna för overSrc. onPress är funktionen som ska ringas när knappen trycks ned. Detta är en av de funktioner som vi gjorde tidigare. onRelease är detsamma som påPress, men det kallas på knappens release. id är en namngiven sträng för att berätta denna knapp förutom andra. Varje knapp har en x och en y-egenskap precis som andra visningsobjekt som kan justeras när som helst.
Nu när vi vet hur knapparna fungerar, låt oss göra resten av dem. Lägg till detta till botten av
buttonHandler ():
funktionsknappHandler ()? PlayState._upButton = ui.newButton defaultSrc = "up.png", defaultX = "50", defaultY = "50", overSrc = "up.png", overX = "50", overY = "50", onPress = upPressed, onRelease = upReleased, id = "_upButton" PlayState._upButton.x = display.contentWidth - 100 PlayState._upButton.y = display.contentHeight - 100 PlayState._downButton = ui.newButton defaultSrc = "down.png" defaultX = "50", defaultY = "50", overSrc = "down.png", overX = "50", overY = "50", onPress = nedtryckt, onRelease = downReleased, id = "_downButton" PlayState._downButton. x = display.contentWidth - 100 PlayState._downButton.y = display.contentHeight - 50 PlayState._leftButton = ui.newButton defaultSrc = "left.png", defaultX = "50", defaultY = "50", överSrc = "kvar .png ", overX =" 50 ", overY =" 50 ", onPress = leftPressed, onRelease = leftReleased, id =" _leftButton " PlayState._leftButton.x = display.contentWidth - 150 PlayState._leftButton.y = display.contentHeight - 75 PlayState._rightButton = ui.new Knapp defaultSrc = "right.png", defaultX = "50", defaultY = "50", overSrc = "right.png", overX = "50", overY = "50", onPress = rightPressed, onRelease = rightReleased, id = "_rightButton" PlayState._rightButton.x = display.contentWidth - 50 PlayState._rightButton.y = display.contentHight - 75 slutet
Om vi lägger till ett samtal till buttonHandler () i skapa () -funktionen i PlayState (), kommer vi att ha fyra
pilar placerade längst ned till höger på skärmen.
funktion PlayState ()? funktion skapa ()? PlayState._ship = Ship.new () buttonHandler (PlayState)? slutet
Nu måste vi skapa en slinga för att hantera gameplayen. I den ursprungliga koden användes uppdateringen () -funktionen för detta ändamål. Vi kommer att göra detsamma med vår kod. Precis som vi gjorde med create () funciton, uncomment uppdateringen () funktionen och ange enstaka kommentarer före alla inuti raderna.
funktionsuppdatering () -: void --FlxU.overlap (_aliens, _bullets, overlapAlienBullet) --FlxU.overlap (_aliens, _ship, overlapAlienShip) --if (FlxG.keys.justPressed ("SPACE") och _ship.dead == false) då - spawnBullet (_ship.getBulletSpawnPosition ()) --end --if (FlxG.keys.ENTER och _ship.dead) då - FlxG.state = new PlayState (); --end --_ spawnTimer = _spawnTimer - FlxG.elapsed --if (_spawnTimer < 0) then -- spawnAlien() -- resetSpawnTimer() --end --super.update() end För att få uppdateringen () funktionen kallad upprepade gånger som i flixel, måste vi lägga till en händelse
lyssnare. Den här koden anger att uppdateringen () ska kallas varje ny ram. Lägg till det i skapa ()
fungera.
funktion skapa () -: void? buttonHandler (PlayState) Runtime: addEventListener ("enterFrame", uppdatering)? slutet Låt oss kolla om spelet fortfarande körs innan vi släpper spelet. Kom ihåg denna variabel
"PlayState._inGame"? Vi ska använda den för att kontrollera om spelet är över. Så omger den kommenterade uppdateringen () -koden med detta uttalande.
funktionsuppdatering () -: tom om PlayState._inGame då? kommenterad kod? änden
För att få fartyget att flytta måste vi få Ship.luas uppdatering () funktion att fungera. Gilla tidigare, ändra kommentarerna så att funktionsdeklarationen inte längre kommenteras, men allt annat är. Lägg till samma händelse lyssnare strax före slutet av Ship ().
funktion Ship ()? Runtime: addEventListener ("enterFrame", uppdatering) returnera Ship end Vi måste också kontrollera att variabeln "Ship" existerar, och att den inte är noll. Wrap den kommenterade
kod med detta om uttalande.
funktionsuppdatering () om skepp då? kommenterad kod? änden
Nu, låt oss börja arbeta genom kommenterade rader. De första två ställde fartygets hastighet till 0.
Corona har ingen hastighet som flixel gör, så vi kommer att sluta arbeta med skeppets x och y
direkt. De följande åtta raderna kontrollerar om vänster eller höger piltangenter trycks på tangentbordet. Vi
kan ersätta detta med kontroller för variablerna _left och _right. Eftersom vi inte har hastighet till
arbeta med, vi ska bara ställa fartygets x-värde till plus eller minus 5.
om (Ship._left) sedan Ship.x = Ship.x - 5 elseif (Ship._right) sedan Ship.x = Ship.x + 5 slutet
Samma sak gäller upp och ner.
om (Ship._up) sedan Ship.y = Ship.y - 5 elseif (Ship._down) sedan Ship.y = Ship.y + 5 slutet
Du kan ta bort "super.update ()"
Om du skulle springa spelet nu skulle skeppet flytta sig ordentligt. Problemet är att det kommer att flyga
precis utanför skärmen eller i kontrollerna om vi släpper den. Det ursprungliga spelet hade också detta problem. Så,
Nästa rad kod i uppdateringen () -funktionen håller skeppet från att lämna en gräns. Det
uppnår detta genom att kontrollera om skeppet ligger utanför gränsen efter allt är det x och y ändras
är genom. Om fartyget är ute, flyttas det tillbaka till det maximala tillåtna värdet. Vi kommer att göra samma sak, och vi kan använda samma display.contentWidth och contentHeight som med bakgrunden för att hitta skärmstorleken.
om (Ship.x> display.contentWidth-Ship.contentWidth-16) sedan Ship.x = display.contentWidth-Ship.contentWidth-16 elseif (Ship.x < Ship.contentWidth+16) then Ship.x = Ship.contentWidth+16 end if(Ship.y > display.contentHeight-Ship.contentHeight-150) sedan Ship.y = display.contentHeight-Ship.contentHeight-150 elseif (Ship.y < Ship.contentHeight+16) then Ship.y = Ship.contentHeight+16 end
Jag bytte siffrorna lite så att skeppet inte skulle överlappa knapparna.
Nu måste vi göra vårt skeppsspel. Låt oss ta en titt på "de / pixelate / flixelprimer / Bullet.as". Gå
genom den normala syntaxomvandlingsprocessen. Lyckligtvis är det här enkelt. Ta bort allt utom Bullet () konstruktören. Lägg till moduldeklarationen och spara den som Bullet.lua i din projektmapp.
Vi har nu en Bullet () -funktion som tar ett X- och ett Y-värde. Det skapar en grön rektangel på dessa
koordinater, och det sätter sin hastighet till 1000.
Låt oss skapa rektangeln som fungerar som kula på samma sätt som vi gjorde bakgrunden i den första
lektion.
modul (?, package.seeall) funktion Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) --super (x, y) --createGraphic (16, 4, 0xFF597137) --velocity.x = 1000-änden
Den här koden skapar en kvadrat med 16 pixlar och sätter sina X- och Y-koordinater till numren som skickas till Bullet (x, y). Låt oss nu ändra kulans fyllfärg. # 587137 konverterad till RGB är (89, 113, 55).
modul (?, package.seeall) funktion Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) Bullet: setFillColor (89, 113, 55) --velocity.x = 1000-änden
Låt oss lägga till en ny () funktion för bekvämlighet som vi gjorde med Ship.lua.
modul (?, package.seeall) funktion Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) Bullet: setFillColor (89, 113, 55) --velocity.x = 1000 Retur Bullet slutfunktion ny (x, y) Retur Bullet (x, y) slutet
Den koden accepterar bara ett X- och ett Y-värde och returnerar en ny kula på den platsen. Se till att
lägg till "return Bullet" i slutet av Bullet () så PlayState kommer att kunna använda det.
Nu behöver vi återskapa hastigheten. Låt oss skapa en uppdateringsfunktion som vi gjorde för skeppet.
? funktion Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) Bullet: setFillColor (89, 113, 55) funktionsuppdatering () om Bullet Bullet.x = Bullet.x + 10 änden Runtime: addEventListener ("enterFrame", uppdatering) returnera Bullet end? Nu kommer kullen att flytta tio pixlar till höger varje ram.
Nu ska vi behöva någon metod för att avfyra kulorna. Låt oss lägga till en annan knapp. Först behöver vi en variabel för att hålla koll på om knappen trycks in eller inte. I stället för att hantera detta i Ship.lua-filen, gör vi den här variabeln i skapandet () -funktionen i PlayState.lua längst ner på
variabla deklarationer.
? funktion skapa () -: void - variable declarations PlayState._inGame = true PlayState._background = noll PlayState._ship = nil - PlayState._aliens = nil - PlayState._bullets = nil - PlayState._scoreText = nil - PlayState._gameOverText = nil - SpelaState._spawnTimer = nil - SpelaState._spawnInterval = 2.5 PlayState._shoot = nil? slutet?
Fortsätt och ställ den till falsk under den nya skeppslinjen i de variabla uppdragen.
? funktion skapa () -: void? - variabla uppdrag PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171, 204, 125) PlayState._ship = Ship.new () PlayState._shoot = false ? slutet?
Nu måste vi lägga till några rader i vår knappHandler () -funktion. Vi behöver ytterligare två funktioner för att hantera tryckning och släppa den nya knappen. Lägg till dessa två funktioner efter rightPressed () och
rightReleased ().
? funktionsknappHandler (PlayState)? funktion leftPressed () PlayState._ship._left = sanna slutfunktion leftReleased () PlayState._ship._left = falskändfunktion rightPressed () PlayState._ship._right = sanna slutfunktion rightReleased () PlayState._ship._right = false-end-funktionen shootPressed () PlayState._shoot = sanna slutfunktions shootReleased () PlayState._shoot = false end? slutet?
Ladda nu knappen som tidigare.
? funktionsknappHandler (PlayState)? PlayState._shootButton = ui.newButton defaultSrc = "shoot.png", defaultX = "100", defaultY = "100", overSrc = "shoot.png", overX = "100", overY = "100", onRelease = shootReleased, onPress = shootPressed, id = "_shootButton" PlayState._shootButton.x = 75 PlayState._shootButton.y = display.contentHight - 75 slutet?
Vår knapp kod blir lite rörig. Låt oss flytta hela knappenHandler () till en ny fil som heter
Buttons.lua. Glöm inte moduldeklarationen.
Importera den nya knappen Knapp på toppen av PlayState. Medan vi är där låt oss importera Bullet också.
modul (?, package.seeall) lokalt skepp = kräver ("skicka") lokala Bullet = kräver ("Bullet") lokala knappar = kräver ("knappar") funktion PlayState? Ändra knappen buttonHandler () i Create () för att ringa modulens funktion.
funktion skapa () -: void? PlayState._ship = Ship.new () PlayState._shoot = felaktiga knappar.buttonHandler (PlayState)? slutet
Nu behöver vi återskapa några av bullethanteringsfunktionerna. Låt oss titta på getBulletSpawnPosition ()
i Ship.lua.
--[[funktion getBulletSpawnPosition () -: FlxPoint local p = ny FlxPoint (x + 36, y + 12) returnera p end -]]
Den ursprungliga funktionen var en förekomstmetod för fartyg. Den returnerade ett X- och ett Y-värde för att skapa en ny kula. Eftersom det ska vara en förebildsmetod måste vi få det att fungera som en. Låt oss göra Ship-variabeln äga den.
funktion Ship: getBulletSpawnPosition () -: FlxPoint local p = nya FlxPoint (x + 36, y + 12) returnera p end
Eftersom FlxPoint är en exklusiv typ till Flixel, låt vi istället returnera en array.
funktion Ship: getBulletSpawnPosition () local p = x = Ship.x + 36, y = Ship.y + 2 retur p end
Denna kod lägger till 36 till fartygets X-värde och 2 (jag använde 2 istället för 12 för att justera kulaens
position för Corona) till fartygets Y-värde. Dessa lagras i en associativ array. Vi kan nu
få åtkomst till varje nummer med p.x och p.y.
I den ursprungliga koden höll en variabel i PlayState med _bullets alla bulletinstanserna.
Vi kan göra samma sak med en bildskärmsgrupp. En bildskärmsgrupp i Corona rymmer helt enkelt en massa displayobjekt och visar dem. Detta är användbart för att hålla reda på ett gäng av samma typ av
objekt. När objekt läggs till för att visa grupper, visas de i den ordning som visas
grupper skapas. Om vi till exempel har en massa kulor och en massa utlänningar, och vi vill att alla utomjordingar ska vara på toppen, kan vi skapa en kollisplaygrupp och sedan en utomjordisk visningsgrupp. Om vi lägger till alla kula och utlänningar till deras grupper, kommer de alltid att visas i rätt ordning. Detta kommer att hända även om det sägs att en kula skapas efter en utlänning. Utlänningen kommer att vara överst eftersom displaygruppen styr visningsordningen.
Ovanstående linjen "--PlayState._bullets = nil" i funktionen create () i PlayState.lua.
funktion skapa () -: void - variabeldeklarationer PlayState._inGame = true PlayState._background = noll PlayState._ship = nil - PlayState._aliens = nil PlayState._bullets = nil - PlayState._scoreText = nil --playState. _gameOverText = nil - PlayState._spawnTimer = nil - PlayState._spawnInterval = 2.5 PlayState._shoot = nil? slutet
Gör _bullets en ny bildgrupp i variabeltilldelningarna.
funktion skapa () -: void? PlayState._ship = Ship.new () PlayState._shoot = falska PlayState._bullets = display.newGroup () Knappar.buttonHandler (PlayState)? slutet
Ta en titt på spawnBullet ().
--[[funktion spawnBullet (p) -: void local bullet = ny Bullet (p.x, p.y) _bullets.add (bullet) FlxG.play (SoundBullet) end -]]
Koden är faktiskt ganska nära vad vi vill ha. Gör det så här:
funktion spawnBullet (p) -: void local _bullet = Bullet.new (p.x, p.y) PlayState._bullets: insert (_bullet) PlayState._shoot = false --FlxG.play (SoundBullet)
När kulan skapas måste _shoot ställas tillbaka till false. På så sätt måste användaren lyfta
fingret innan de eldar igen.
Corona har ett grundläggande API för att spela korta ljudeffekter. För att kunna använda det måste vi använda .caf-ljud
filer. Den konverterade versionen av de ursprungliga MP3-ljudeffekterna ingår i källan för detta
handledning.
Först måste vi skapa variabler för att hålla ljuden. Det finns tre rader högst upp på PlayState.
Flytta dem till de variabla deklarationerna i skapa ().
funktion skapa () -: void - variabeldeklarationer PlayState._inGame = true PlayState._background = noll PlayState._ship = nil - PlayState._aliens = nil PlayState._bullets = nil - PlayState._scoreText = nil --playState. _gameOverText = nil - PlayState._spawnTimer = nil - PlayState._spawnInterval = 2.5 PlayState._shoot = nil - [Bädda in (source = "? /? /? /? /assets/mp3/ExplosionShip.mp3")] privat var SoundExplosionShip: Class - [Bädda in (source = "? /? /? /? /Assets/mp3/ExplosionAlien.mp3")] privat var SoundExplosionAlien: Klass - [Bädda in (source = "? /? /? /? / tillgångar / mp3 / Bullet.mp3 ")] privat var SoundBullet: Class? slutet
Vi vill bara att namnen ska vara desamma. Gör dem egenskaper hos PlayState och ställ dem till noll.
Oöverträffad sista raden.
funktion skapa () -: void - variabeldeklarationer PlayState._inGame = true PlayState._background = noll PlayState._ship = nil - PlayState._aliens = nil PlayState._bullets = nil - PlayState._scoreText = nil --playState. _gameOverText = nil - SpelaState._spawnTimer = nil - SpelaState._spawnInterval = 2.5 PlayState._shoot = nil - SpelaState.SoundExplosionShip = nil - SpelaState.SoundExplosionAlien: Klass = noll PlayState.SoundBullet = nil? slutet
Nu använder vi mediemodulen för att ladda ett nytt ljud. Lägg det här längst ner i uppdragen:
funktion skapa () -: void? PlayState._ship = Ship.new () PlayState._shoot = false PlayState._bullets = display.newGroup () PlayState.SoundBullet = media.newEventSound ("Bullet.caf") Buttons.buttonHandler (PlayState)? slutet Rubriker tillbaka till spawnBullet (). Vi kan ersätta den sista raden för att spela vårt nya ljud.
funktion spawnBullet (p) -: void local _bullet = Bullet.new (p.x, p.y) PlayState._bullets: insert (_bullet) PlayState._shoot = felaktigt media.playEventSound (PlayState.SoundBullet) slut
Nu måste vi bara ändra vår uppdateringsfunktion () för att få några skjutbollar. Kontrollera om _shoot är
sant och om det finns existens. Om så är fallet, ring vår getBulletSpawnPosition () -metod för vårt skepp
och spawnBullet () på den platsen.
funktionsuppdatering () om PlayState._inGame då om PlayState._shoot == true and PlayState._ship då är lokala p = PlayState._ship: getBulletSpawnPosition () spawnBullet (p) slutet? änden
I Flixel togs minne för oss. I Corona måste vi städa upp saker vi
görs med. Låt oss lägga till en kill () -metod för varje kula för att hjälpa oss. döda () är
funktion som flixel ringer automatiskt när ett objekt inte längre behövs. Lägg till det här på Bullet.lua:
funktion Bullet (x, y)? funktionsuppdatering ()? slutfunktion Bullet: kill () Bullet.parent: remove (Bullet) Bullet = nil end? slutet
Det här är rätt sätt att städa upp ett föremål i Corona. Först avlägsnade vi alla band till det genom att ta bort
det från visningsgruppen. Sedan ställer vi Bullet-variabeln till noll. Låt oss göra samma sak för Ship.
Lägg till detta nedan getBulletSpawnPosition () i Ship.lua:
funktion Ship: kill () Ship: removeSelf () Ship = nil Runtime: removeEventListener ("enterFrame", uppdatering) slutet Observera att vi slutade uppdateringen från att bli kallad varje ram (eftersom fartyget inte finns
längre).
Tillbaka i Bullet.lua, låt oss lägga till en check varje ram för att se om kulan är utanför skärmen.
För närvarande fortsätter vår kod att rita kulor även när de inte kan ses. Detta är ett slöseri med enhetens begränsade resurser. Ersätt uppdatering () med detta:
funktionsuppdatering () om Bullet sedan om (Bullet.x < display.contentWidth) then Bullet.x = Bullet.x + 10 else Bullet:kill() end end end
Nu kommer kula bara att röra sig till höger om det kan ses. Annars kommer det att ringa vår praktiska
kill () funktionen.
Lua har en automatisk sopsamlare som hanterar skräp som oanvända variabler, visningsobjekt som har tagits bort från skärmen och allt annat som inte längre behövs. Vi kan berätta för Lua att samla skräp genom att lägga till den här raden i slutet av skapandet i vår PlayState:
funktion skapa ()? collectgarbage ("collect") slutet 
Det börjar se ut som ett spel nu. Vårt skepp kan flytta runt på skärmen och eldkulor. De
kulor tar hand om sig själv när de inte längre behövs. Nu behöver vi bara några fiender.
