Share
Este tutorial le mostrará cómo trasladar un juego Flash / Flex al Corona SDK. Específicamente, estaremos portando de ActionScript a Lua, con el objetivo final de jugar juegos anteriormente solo para Flash en el iPhone. Además de demostrar las diferencias de idioma y API, esta serie de tutoriales también tendrá en cuenta las restricciones de hardware, como el tamaño de la pantalla y la falta de botones físicos en el iPhone..
Este tutorial retoma donde comenzó la primera parte..
Comience portando la sintaxis del archivo fuente "de / pixelate / flixelprimer / Ship.as" como se describe
En el primer día un post. Específicamente, necesitarás:
Ahora agregue la declaración del módulo en la parte superior del archivo para que podamos importar el archivo a PlayState.
Además, siga adelante y envuelva todo el código con una función constructora Ship (). Tu código ahora debería estar dispuesto de esta manera:
módulo (?, package.seeall) función Ship ()? Todo el código comentado va aquí? fin
No tenemos flixel, así que deshazte de la declaración de importación para ello. Ahora mira las líneas superiores de nuestra
Función Ship ():
función Ship () - [Embed (source = "? /? /? /? /assets/png/Ship.png")] private var ImgShip: Class - [[function Ship () -: void super (50 , 50, ImgShip) final -]]? fin
La primera línea carga la imagen del barco y la almacena en la variable ImgShip. Las siguientes líneas son
El antiguo método constructor. Cuando se creó el barco, esta función le asignó la imagen ImgShip y las coordenadas (50, 50). Podemos hacer lo mismo creando una variable de Envío que contenga una imagen. Podemos cargar la imagen usando el módulo de visualización que usamos en la lección 1. Luego, podemos establecer las propiedades de las variables x e y en 50. Reemplace las líneas anteriores para hacer lo siguiente:
Accentsconagua
función Ship () local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50? código comentado? fin Ahora hagamos que nuestra función Ship () devuelva Ship para que nuestro PlayState pueda usarlo.
función Ship () local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50? código comentado? final de envío En nuestra fuente de ActionScript, se crea un barco en PlayState al llamar "nuevo barco ()". Mientras estamos en
it, vamos a hacer una nueva función () que devuelve Ship ().
función Ship () local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50? código comentado? Función de finalización de envío nuevo () Finalización de envío posterior () final Realmente, no hay necesidad técnica para esto, pero hace que nuestro código sea un poco más legible.
Vuelve a PlayState.lua y solicita nuestro módulo de envío en la parte superior.
módulo (?, package.seeall) Local Ship = require ("Ship") function PlayState ()? Ahora podemos crear una nueva nave. Primero, mueva todas las declaraciones de variables comentadas desde la parte superior del archivo a la función create ().
módulo (?, package.seeall) Local Ship = requiere ("Enviar") la función PlayState () local PlayState = ? un montón de código comentado? function create () -: void PlayState._inGame = true --local _ship --local _aliens --local _bullets --local _scoreText --local _gameOverText --local _spawnTimer --local _spawnInterval = 2.5 PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171, 204, 125)? comentado crear () lógica? end crea () end Dejándolos comentados, hazlos propiedades de PlayState. Establezca las propiedades sin un valor en nil. Mientras estamos en esto, necesitamos hacer una declaración de fondo..
? PlayState._background = nil --PlayState._ship = nil --PlayState._aliens = nil --PlayState._bullets = nil --PlayState._scoreText = nil - PlayState._gameOverText = nil --PlayState._spawnTimer = ._spawnInterval = 2.5?
Descomente la declaración de la variable _ship y cree una nueva nave como esta:
function create () -: void - declaraciones de variables PlayState._inGame = true PlayState._background = nil PlayState._ship = nil --PlayState._aliens = nil --PlayState._bullets = nil --PlayState._scoreText = nil - PlayState._gameOverText = nil --PlayState._spawnTimer = nil --PlayState._spawnInterval = 2.5 - asignaciones de variables PlayState._background = display.newRect._background , 204, 125) PlayState._ship = Ship.new ()? comentado crear () lógica? fin
Tenga en cuenta que aquí asignamos _background primero. Esto se debe a que los objetos de visualización en Corona están ordenados.
por cuando son creados. No podríamos ver _ship si lo creamos antes de _background.
Si ejecuta el código, ahora hay un barco que se muestra en (50, 50).
Necesitamos poder mover la nave para poder jugar, pero ¿cómo podemos hacerlo? El juego original fue hecho para ser controlado por un teclado. Un iPhone no tiene teclado. ¿Cómo podemos solucionar esto? Este es uno de los muchos factores que deben tenerse en cuenta al crear una aplicación para un dispositivo móvil, ya sea que esté transfiriendo un código existente o creando una aplicación desde cero. Otro que ya estamos tratando es el tamaño de la pantalla. En una computadora, los programas vienen en muchos tamaños diferentes. La mayoría de ellos son incluso de tamaño variable. En un iPhone, las aplicaciones son todas del mismo tamaño.
Resolver estos problemas puede ser un reto. Eludir estas restricciones requiere pensar
fuera de la caja. Por ejemplo, podríamos controlar nuestra nave con botones en pantalla. También podríamos tocar la ubicación en la pantalla a la que queremos que se mueva la nave. Incluso podríamos utilizar el dispositivo
Acelerómetro para controlar la nave en función de la inclinación del dispositivo. Tal vez cambiemos un poco el juego y hagamos que la nave se controle. Entonces el jugador estaría a cargo de los disparos. Como puedes ver, hay muchas posibilidades para nuevos estilos de juego en el iPhone.
Por más nítidas que sean muchas de esas ideas, vamos a crear botones en pantalla para controlar el barco. De esta manera, el juego estará más en línea con el original. Te dejo esas otras opciones para que las explores..
Ansca Mobile ha creado una biblioteca de código abierto para crear botones virtuales. En lugar de
al construir la biblioteca en Corona, la han incluido en su sitio web como opcional. yo tengo
incluyó la versión más reciente a partir de este escrito en el código fuente de este tutorial. Añade el
archivo "ui.lua" a su carpeta de proyecto.
Dirígete a tu archivo Ship.lua para que podamos configurar algo. Vamos a añadir algunas propiedades a nuestra variable de envío. Justo debajo del código donde establecemos las coordenadas del barco en (50, 50), agregue esto:
? local Ship = display.newImage ("Ship.png") Ship.x = 50 Ship.y = 50 Ship._up = false Ship._down = false Ship._left = false Ship._right = false? Vamos a usar estos para decirle a la nave cuándo moverse. Si los valores cambian a verdadero, significa que se están presionando los botones respectivos.
De vuelta en PlayState.lua, necesitamos crear una nueva función para manejar la creación de botones. Vamos a manejar esto fuera de PlayState () porque se va a ensuciar un poco. Antes de seguir adelante,
asegúrese de tener todas las imágenes de los botones de la fuente incluida con este tutorial. Ahora, crea una función buttonHandler () debajo de PlayState ().
? Funcion PlayState ()? botón de función finalHandler (PlayState) fin
Observe que buttonHandler () toma un argumento: PlayState. Esto es porque estamos creando
buttonHandler () fuera de la función PlayState (). Si recuerdas la primera lección, esto significa
ese buttonHandler () no tiene idea de lo que es la variable PlayState, porque PlayState es local a la
Función PlayState (). Llamaremos a buttonHandler () desde PlayState (). Pasando
PlayState to buttonHandler (), estamos permitiendo que buttonHandler () vea y modifique todo PlayState y sus propiedades. Dado que _ship es propiedad de PlayState, buttonHandler () podrá configurar
_ship_up, _ship._down, etc..
Vamos a importar el módulo ui.lua en nuestra función ButtonHandler en lugar de en la parte superior de
PlayState.lua. Verás por qué más tarde.
? Funcion PlayState ()? botón de función de finHandler (PlayState) local ui = require ("ui") fin Ahora se va a poner un poco desordenado. Vamos a crear dos funciones para cada botón. Uno
para cuando se presiona el botón, y uno para cuando se suelta el botón. Cuando se llaman, se establecerán las propiedades del barco en verdadero o falso.
botón de funciónHandler (PlayState) local ui = require ("ui") función upPressed () PlayState._ship._up = true end función upReleased () PlayState._ship._up = false end función downPressed () PlayState._ship._down = true end function downReleased () PlayState._ship._down = false end function leftPressed () PlayState._ship._left = true end function leftReleased () PlayState._ship._left = false end function rightPressed () PlayState._ship._right = true end function rightReleased () PlayState._ship._right = final falso Porque estamos pasando PlayState a buttonHandler (), y _ship y todas sus propiedades pertenecen a
PlayState, podemos cambiarlos de verdadero a falso y viceversa. Ahora necesitamos crear los botones reales. Con el módulo ui importado, podemos usar uno de sus métodos: newButton. Esto tiene una sintaxis interesante, así que agárrate..
PlayState._upButton = ui.newButton defaultSrc = "up.png", defaultX = "50", defaultY = "50", overSrc = "up.png", overX = "50", overY = "50", onPress = upPressed, onRelease = upReleased, id = "_upButton"
Este código llama a newButton y asigna el resultado a _upButton (una propiedad de PlayState). Primero,
Usted se estará preguntando por qué hay corchetes. Esto no es una excepción a las reglas de lua sintaxis..
En realidad, los paréntesis contienen una serie de parámetros que se pasan al método newButton. Aquí hay muchos parámetros, así que repasemos uno a la vez. El primero, defaultSrc es la ubicación de la imagen que se utilizará cuando no se presiona el botón. defaultX y defaultY son las dimensiones de la imagen. overSrc es la ubicación de la imagen que se mostrará cuando se presiona el botón. En este caso, vamos a utilizar la misma imagen. overX y overY funcionan igual que defaultX y defaultY, pero son las dimensiones para overSrc. onPress es la función para llamar cuando se presiona el botón. Esta es una de las funciones que hicimos anteriormente. onRelease es el mismo que onPress, pero se llama al lanzamiento del botón. id es una cadena con nombre para diferenciar a este botón de otros. Cada botón tiene una propiedad x y una y igual a otros objetos de visualización que se pueden ajustar en cualquier momento.
Ahora que sabemos cómo funcionan los botones, hagamos el resto de ellos. Agrega esto al fondo de
ButtonHandler ():
botón de funciónHandler ()? 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 " defaultX = "50", defaultY = "50", overSrc = "down.png", overX = "50", overY = "50", onPress = downPressed, 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", overSrc = "left .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 Botón 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.contentHeight - 75 end
Si agregamos una llamada a buttonHandler () en la función create () de PlayState (), tendremos cuatro
Flechas posicionadas en la parte inferior derecha de la pantalla..
Funcion PlayState ()? función crear ()? PlayState._ship = Ship.new () buttonHandler (PlayState)? fin
Ahora necesitamos crear un bucle para manejar el juego. En el código original, la función update () se usó para este propósito. Haremos lo mismo con nuestro código. Al igual que hicimos con la función create (), descomente la función update () y coloque comentarios de una sola línea antes de todas las líneas internas.
function update () -: void --FlxU.overlap (_aliens, _bullets, overlapAlienBullet) --FlxU.overlap (_aliens, _ship, overlapAlienShip) --if (FlxG.keys.justPressed ("SPACE") y _ship.dead == falso) entonces - spawnBullet (_ship.getBulletSpawnPosition ()) --end --if (FlxG.keys.ENTER y _ship.dead) luego - FlxG.state = new PlayState (); --end --_ spawnTimer = _spawnTimer - FlxG.elapsed --if (_spawnTimer < 0) then -- spawnAlien() -- resetSpawnTimer() --end --super.update() end Para obtener la función update () llamada repetidamente como en flixel, necesitamos agregar un evento
oyente. Esta línea de código establecerá que update () se llame a cada nuevo marco. Agrégalo en el create ().
función.
funcion create () -: void? ButtonHandler (PlayState) Runtime: addEventListener ("enterFrame", actualizar)? fin Verifiquemos si el juego todavía se está ejecutando antes de dejar que el bucle del juego se ejecute. Recuerda esta variable
"PlayState._inGame"? Vamos a usarlo para comprobar si el juego ha terminado. Así que rodee el código de actualización () comentado con esta declaración.
función de actualización () -: anular si PlayState._inGame entonces? código comentado? final fin
Para hacer que el barco se mueva, necesitamos que la función update () de Ship.lua funcione. Como antes, cambia los comentarios para que la declaración de función ya no se comente, pero todo lo demás lo es. Agregue el mismo detector de eventos justo antes del final de Ship ().
función de la nave ()? Tiempo de ejecución: addEventListener ("enterFrame", actualizar) devolver Final de envío También debemos verificar que la variable "Envío" existe y que no es nula. Envolver lo comentado
código con esta declaración if.
función de actualización () si se envía entonces? código comentado? final fin
Ahora, comencemos a trabajar a través de las líneas comentadas. Los dos primeros ponen la velocidad de la nave a 0.
Corona no tiene velocidad como flixel, así que terminaremos trabajando con las x y y de la nave.
directamente. Las siguientes ocho líneas comprueban si las teclas de flecha izquierda o derecha están presionadas en el teclado. Nosotros
puede reemplazar esto con chequeos para las variables _left, y _right. Como no tenemos velocidad para
Trabajamos con, solo estableceremos el valor x del barco en más o menos 5.
if (Ship._left) entonces Ship.x = Ship.x - 5 elseif (Ship._right) luego Ship.x = Ship.x + 5 end
Lo mismo va para arriba y para abajo..
if (Ship._up) entonces Ship.y = Ship.y - 5 elseif (Ship._down) luego Ship.y = Ship.y + 5 end
Puede eliminar "super.update ()"
Si fueras a correr el juego ahora, la nave se movería adecuadamente. El problema es que volará.
Justo fuera de la pantalla o en los controles si lo dejamos. El juego original tuvo este problema también. Asi que,
Las siguientes líneas de código en la función update () evitan que el barco salga de un límite. Eso
logra esto al verificar si el barco está fuera del límite después de que todos los cambios de x e y
están a través de Si el barco está en el exterior, vuelve al valor máximo permitido. Haremos lo mismo, y podemos usar el mismo display.contentWidth y contentHeight como en el fondo para encontrar el tamaño de la pantalla.
si (Ship.x> display.contentWidth-Ship.contentWidth-16) entonces 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) luego Ship.y = display.contentHeight-Ship.contentHeight-150 elseif (Ship.y < Ship.contentHeight+16) then Ship.y = Ship.contentHeight+16 end
Cambié un poco los números para que la nave no se superponga con los botones.
Ahora tenemos que hacer que nuestro barco dispare. Echemos un vistazo a "de / pixelate / flixelprimer / Bullet.as". Ir
a través del proceso normal de conversión de sintaxis. Afortunadamente esta es muy fácil. Eliminar todo menos el constructor Bullet (). Agregue la declaración del módulo y guárdelo como Bullet.lua en su carpeta de proyecto.
Ahora tenemos una función Bullet () que toma un valor X y un valor Y. Crea un rectángulo verde en aquellos.
coordenadas, y establece su velocidad a 1000.
Vamos a crear el rectángulo que actúa como la bala de la misma manera que hicimos el fondo en la primera
lección.
módulo (?, package.seeall) función Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) --super (x, y) --createGraphic (16, 4, 0xFF597137) --velocity.x = 1000 final
Este código crea un cuadrado de 16 por 4 píxeles y establece sus coordenadas X e Y a los números pasados a Bullet (x, y). Ahora vamos a cambiar el color de relleno de la bala. # 587137 convertido a RGB es (89, 113, 55).
módulo (?, package.seeall) función Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) Bullet: setFillColor (89, 113, 55) --velocity.x = 1000 final
Agreguemos una nueva función () para mayor comodidad, como hicimos con Ship.lua.
módulo (?, package.seeall) función Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) Bullet: setFillColor (89, 113, 55) --velocity.x = 1000 retorno Función de finalización de la bala nueva (x, y) Retorno de la viñeta (x, y) final
Ese código solo acepta un valor de X e Y, y devuelve una nueva viñeta en esa ubicación. Asegurate que
agregue "return Bullet" al final de Bullet () para que PlayState pueda usarlo.
Ahora necesitamos recrear la velocidad. Vamos a crear una función update () como hicimos para el barco..
? función Bullet (x, y) -: void local Bullet = display.newRect (x, y, 16, 4) Bullet: setFillColor (89, 113, 55) función actualizada () si Bullet entonces Bullet.x = Bullet.x + 10 end end Runtime: addEventListener ("enterFrame", actualizar) devuelve Bullet end? Ahora la bala moverá diez píxeles a la derecha cada fotograma.
Ahora, vamos a necesitar algún método para disparar las balas. Vamos a añadir otro botón. Primero, necesitamos una variable para seguir la pista si se presiona o no el botón. En lugar de manejar esto en el archivo Ship.lua, hagamos esta variable en la función create () en PlayState.lua en la parte inferior de
declaraciones variables.
? function create () -: void - declaraciones de variables PlayState._inGame = true PlayState._background = nil 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? fin?
Continúa y configúralo en falso debajo de la nueva línea de envío en las asignaciones de variables.
? funcion create () -: void? - asignaciones variables PlayState._background = display.newRect (0, 0, display.contentWidth, display.contentHeight) PlayState._background: setFillColor (171, 204, 125) PlayState._ship = Ship.new () PlayState._shoot = false ? fin?
Ahora necesitamos agregar algunas líneas a nuestra función buttonHandler (). Necesitamos dos funciones más para manejar presionar y soltar el nuevo botón. Agrega estas dos funciones después de rightPressed () y
rightReleased ().
? botón de funciónHandler (PlayState)? function leftPressed () PlayState._ship._left = end final function leftReleased () PlayState._ship._left = false end function rightPressed () PlayState._ship._right = true end function rightReleased () PlayState._ship._right = false end function shootPressed () PlayState._shoot = true end function shootReleased () PlayState._shoot = false end? fin?
Ahora carga el botón como antes.
? botón de funciónHandler (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.contentHeight - 75 end?
Nuestro código de botón se está poniendo un poco desordenado. Movamos todos los buttonHandler () a un nuevo archivo llamado
Buttons.lua. No olvides el módulo decleration..
Importe el nuevo módulo Button en la parte superior de PlayState. Mientras estamos allí importemos Bullet también.
módulo (?, package.seeall) Local Ship = require ("Ship") local Bullet = require ("Bullet") local Buttons = require ("Buttons") PlayState ()? Modifique la línea buttonHandler () en create () para llamar a la función del módulo.
funcion create () -: void? PlayState._ship = Ship.new () PlayState._shoot = false Buttons.buttonHandler (PlayState)? fin
Ahora necesitamos recrear algunas de las funciones de manejo de bala. Veamos getBulletSpawnPosition ()
en Ship.lua.
--[[función getBulletSpawnPosition () -: FlxPoint local p = nuevo FlxPoint (x + 36, y + 12) return p end -]]
La función original era un método de instancia de envío. Devolvió un valor de X y de Y para crear una nueva viñeta. Dado que se supone que es un método de instancia, debemos hacer que funcione como uno. Hagamos la variable Ship propia..
función Envío: getBulletSpawnPosition () -: FlxPoint local p = nuevo FlxPoint (x + 36, y + 12) return p end
Dado que FlxPoint es un tipo exclusivo de Flixel, devolvemos una matriz en su lugar.
función Ship: getBulletSpawnPosition () local p = x = Ship.x + 36, y = Ship.y + 2 return p end
Este código agrega 36 al valor X de la nave y 2 (usé 2 en lugar de 12 para ajustar el valor de la bala).
posición para Corona) al valor Y de la nave. Estos se almacenan en una matriz asociativa. Ahora podemos
acceder a cada número con p.x y p.y.
En el código original, una variable en PlayState llamada _bullets contenía todas las instancias de viñetas.
Podemos hacer lo mismo con un grupo de visualización. Un grupo de visualización en Corona simplemente contiene un montón de objetos de visualización y los muestra. Esto es útil para realizar un seguimiento de un montón de el mismo tipo de
objeto. Cuando se agregan objetos a los grupos de visualización, se muestran en el orden en que se muestran
Se crean grupos. Por ejemplo, si tenemos un montón de balas y un montón de alienígenas, y queremos que todos los alienígenas estén en la parte superior, podríamos crear un grupo de visualización de viñetas y luego un grupo de pantallas alienígenas. Si agregamos todas las instancias de viñetas y alienígenas a sus grupos, siempre se mostrarán en el orden correcto. Esto sucederá incluso si, por ejemplo, se crea una bala después de un alienígena. El alienígena estará en la parte superior porque el grupo de visualización controla el orden de visualización.
Descomente la línea "--PlayState._bullets = nil" en la función create () en PlayState.lua.
function create () -: void - declaraciones de variables PlayState._inGame = true PlayState._background = nil 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? fin
Hacer _bullets un nuevo grupo de visualización en las asignaciones de variables.
funcion create () -: void? PlayState._ship = Ship.new () PlayState._shoot = false PlayState._bullets = display.newGroup () Buttons.buttonHandler (PlayState)? fin
Ahora eche un vistazo a spawnBullet ().
--[[función spawnBullet (p) -: bullet bullet local = new Bullet (p.x, p.y) _bullets.add (bullet) FlxG.play (SoundBullet) end -]]
Este código es realmente muy cercano a lo que queremos. Haz que se vea así:
función spawnBullet (p) -: void local _bullet = Bullet.new (p.x, p.y) PlayState._bullets: insert (_bullet) PlayState._shoot = false --FlxG.play (SoundBullet) end
Cuando se crea la viñeta, _shoot debe volver a establecerse en falso. De esa manera, el usuario tiene que levantar.
su dedo antes de que vuelvan a disparar.
Corona tiene una API básica para reproducir efectos de sonido cortos. Para poder utilizarlo, debemos utilizar el sonido .caf.
archivos. La versión convertida de los efectos de sonido MP3 originales se incluye en la fuente para este
tutorial.
Primero necesitamos crear variables para mantener los sonidos. Hay tres líneas en la parte superior de PlayState.
Moverlos a las declaraciones de variables en create ().
function create () -: void - declaraciones de variables PlayState._inGame = true PlayState._background = nil 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 - [Embed (source = "? /? /? /? /assets/mp3/ExplosionShip.mp3")] privado var SoundExplosionShip: Class - [Embed (source = "? /? /? /? /Assets/mp3/ExplosionAlien.mp3")] private var SoundExplosionAlien: Class - [Embed (source = "? /? /? /? / assets / mp3 / Bullet.mp3 ")] private var SoundBullet: Class? fin
Solo queremos que los nombres sean los mismos. Hazlos propiedades de PlayState y configúralos a nil.
Descomentar la última línea.
function create () -: void - declaraciones de variables PlayState._inGame = true PlayState._background = nil 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 --PlayState.SoundExplosionShip = nculón fin
Ahora usaremos el módulo multimedia para cargar un nuevo sonido. Ponga esto al final de las tareas:
funcion create () -: void? PlayState._ship = Ship.new () PlayState._shoot = false PlayState._bullets = display.newGroup () PlayState.SoundBullet = media.newEventSound ("Bullet.caf") Buttons.buttonHandler (PlayState)? fin Regresando a spawnBullet (). Podemos reemplazar la última línea para reproducir nuestro nuevo sonido..
función spawnBullet (p) -: void local _bullet = Bullet.new (p.x, p.y) PlayState._bullets: insert (_bullet) PlayState._shoot = false media.playEventSound (PlayState.SoundBullet) end
Ahora solo tenemos que modificar nuestra función update () para obtener algunos disparos. Compruebe si _shoot es
Es cierto y si existe. Si es así, llame a nuestro método de instancia getBulletSpawnPosition () para nuestro barco
y spawnBullet () en esa ubicación.
función de actualización () si PlayState._inGame entonces si PlayState._shoot == true y PlayState._ship entonces local p = PlayState._ship: getBulletSpawnPosition () spawnBullet (p) end? final fin
En Flixel, la memoria fue atendida por nosotros. En Corona, vamos a tener que limpiar los objetos que
se hacen con. Agreguemos un método de instancia kill () a cada viñeta para ayudarnos. kill () es el
función a la que flixel llama automáticamente cuando un objeto ya no es necesario. Añade esto a Bullet.lua:
Función Bullet (x, y)? función de actualización ()? función de finalización Bullet: kill () Bullet.parent: remove (Bullet) Bullet = nil end? fin
Esta es la forma correcta de limpiar un objeto en Corona. Primero, quitamos todos los lazos quitando
desde el grupo de visualización. Luego fijamos la variable Bullet a nil. Hagamos lo mismo por barco..
Agregue esto debajo de getBulletSpawnPosition () en Ship.lua:
función Ship: kill () Ship: removeSelf () Ship = nil Runtime: removeEventListener ("enterFrame", actualización) final Observe que detuvimos la llamada a la actualización en cada fotograma (ya que el envío no existe
nunca más).
De vuelta en Bullet.lua, agreguemos un cheque a cada fotograma para ver si la viñeta está fuera de la pantalla.
Actualmente, nuestro código continúa extrayendo viñetas incluso cuando no se pueden ver. Esto es un desperdicio de los recursos limitados del dispositivo. Reemplace actualizar () con esto:
función update () si Bullet entonces if (Bullet.x < display.contentWidth) then Bullet.x = Bullet.x + 10 else Bullet:kill() end end end
Ahora, la bala solo se moverá hacia la derecha si se puede ver. De lo contrario, llamará a nuestra práctica.
función kill ().
Lua tiene un recolector automático de basura que maneja la basura como las variables no utilizadas, muestra los objetos que se han eliminado de la pantalla y cualquier otra cosa que ya no sea necesaria. Podemos decirle a Lua que recolecte basura agregando esta línea al final de crear en nuestro PlayState:
función crear ()? collectgarbage ("collect") final 
Esto está empezando a parecerse a un juego ahora. Nuestro barco puede moverse por la pantalla y disparar balas. los
Las balas se cuidan cuando ya no son necesarias. Ahora solo necesitamos algunos enemigos..
