Contente
A categoria mais popular na Google Play Store sempre foi Jogos. Embora todos nós provavelmente usemos aplicativos importantes de produtividade, como um navegador da Web, um cliente de email e um aplicativo de mensagens instantâneas, os jogos ainda continuam sendo uma parte importante da experiência móvel. Portanto, não é surpresa que muitas pessoas que desejam aprender a desenvolver para o Android desejem começar criando um jogo. Além disso, vamos ser honestos, escrever um jogo é muito mais divertido do que desenvolver um aplicativo de produtividade!
O idioma oficial do Android é Java e o ambiente oficial de desenvolvimento é o Android Studio. Se você quiser pesquisar sobre Java, sugiro nosso tutorial básico sobre Java e, se quiser aprender a escrever um aplicativo usando o Android Studio, sugiro que você verifique nosso tutorial sobre como escrever seu primeiro aplicativo Android. No entanto, Java e Android Studio não são as únicas maneiras de se desenvolver para Android. Você pode encontrar uma visão geral dos idiomas e SDKs disponíveis em nosso guia: Desejo desenvolver aplicativos Android - Quais idiomas devo aprender?
Um dos SDKs mencionados no guia de linguagens de programação é o Corona, um SDK de terceiros projetado principalmente para escrever jogos. Em vez de Java, o Corona usa Lua, uma linguagem de script rápida, fácil de aprender e poderosa. No entanto, Corona não é o único SDK de jogos para dispositivos móveis que usa Lua, outros exemplos conhecidos incluem Cocos2d-X, Marmalade e Gideros.
Baixar e instalar
Para começar com o Corona, você precisará baixar e instalar o SDK. Acesse o site da Corona e clique no botão de download. Você precisará criar uma conta (gratuita) antes de fazer o download do kit. Se você deseja criar um arquivo .apk real, em vez de apenas executar o programa no emulador, será necessário instalar o Java 7; no entanto, não será necessário instalar o Android SDK. Para instalar o Java 7 Development Kit, acesse o site da Oracle, procure a seção "Java SE Development Kit 7u79" e faça o download da versão para o seu PC.
Depois de instalar o Corona, você precisa ativá-lo. Este é um processo único, gratuito. Inicie o Corona Simulator e aceite a licença. Digite o endereço de e-mail e a senha que você usou para o download e clique em Login.
Iniciando o projeto
No Corona Simulator, clique em "Novo projeto". Digite um nome para o seu aplicativo no campo "Nome do aplicativo:" e deixe o restante das configurações como padrão. Clique OK."
Três janelas aparecerão agora. Os dois primeiros são o Corona Simulator e o Corona Simular Output. Corona também abrirá uma janela do explorador de arquivos mostrando os arquivos para o seu projeto.
A maioria dos arquivos (cerca de 23 deles) no diretório do projeto é para o ícone do aplicativo! O arquivo mais importante para nós agora é main.lua, pois é aqui que escreveremos o código para o nosso aplicativo.
Introdução à Lua
Antes de começarmos a escrever o código, precisamos fazer um tour inesquecível por Lua. O intérprete Lua (lembre-se de que essa é uma linguagem de script, não uma linguagem compilada) está disponível para Windows, OS X e Linux. No entanto, ele é incorporado ao Corona, portanto, neste momento, você não precisa instalar nada extra. A maneira mais fácil de jogar com Lua é usar a demonstração ao vivo online.
Você pode encontrar muitos bons tutoriais sobre Lua on-line e deve consultar o Manual de referência de Lua, Programação em Lua, The.Lua.Tutorial e The Tutorials Point Lua Tutorial.
Aqui está um pequeno programa Lua que irá mostrar alguns dos principais recursos do Lua:
função local doubleIt (x) retorna x * 2 fim para i = 1,10,1 do x = doubleIt (i) se (x == 10) então imprime ("dez") então imprime ("dez") else print (doubleIt (i)) end end
O código acima mostra três construções importantes de Lua: funções, loops e instruções if. A função doubleIt () é muito simples, apenas dobra o parâmetro passado x.
O código principal é um para loop de 1 a 10. Chama doubleIt () para cada iteração. Se o valor de retorno for 10 (ou seja, quando Eu é 5), então o código imprime “dez”, caso contrário, apenas imprime o resultado de doubleIt ().
Se você tiver alguma experiência em codificação, o código de exemplo deve ser fácil de seguir. Se você deseja aprender alguma programação básica, sugiro que você use alguns dos recursos vinculados acima para aprimorar suas habilidades.
Escrevendo o jogo
Escrever programas básicos em Corona é simples. Você só precisa se preocupar com um arquivo, main.lua, e deixe Corona fazer todo o trabalho pesado. O jogo que vamos escrever é um simples jogo de "toque". Um balão ou uma bomba irá falhar na tela. Se o jogador tocar no balão, ele marcará um ponto, se ele tocar em uma bomba, o placar será dividido por 2, como penalidade. Para escrever o código, você precisa editar main.lua. Você pode fazer isso em qualquer editor de texto.
O Corona SDK possui um mecanismo de física 2D embutido, o que facilita a criação de jogos. O primeiro passo para escrever o jogo é inicializar o mecanismo de física:
física local = require ("physics") physics.start ()
O código é bastante auto-explicativo. A física do módulo é carregada e inicializada, é atribuída à variável física. Para habilitar o mecanismophysics.start () é chamado.
Em seguida, criamos algumas variáveis úteis que serão úteis não apenas para este jogo simples, mas também para jogos mais complexos. halfW e halfH mantenha os valores para metade da largura da tela e metade da altura da tela:
halfW = display.contentWidth * 0.5 halfH = display.contentHeight * 0.5
o exibição objeto é um objeto predefinido que o Corona disponibiliza globalmente.
Agora vem o primeiro passo que realmente faz alguma coisa acontecer na tela:
local bkg = display.newImage ("night_sky.png", metadeW, metadeH)
Bem como propriedades como contentHeight e contentWidth, a exibição O objeto também possui muitas funções úteis. o nova imagem() A função lê um arquivo de imagem (neste caso, um arquivo .png) e o exibe na tela. Os objetos de exibição são renderizados em camadas, portanto, como esta é a primeira imagem que estamos colocando na tela, ela sempre será o plano de fundo (a menos que o código faça explicitamente algo para alterar isso). Os parametros halfW e halfH diga a Corona para colocar a imagem no meio.
Nesse ponto, você pode executar o código no emulador e ver a imagem de plano de fundo. Se você salvar o arquivo, o emulador notará que o arquivo foi alterado e se oferecerá para reiniciar. Se isso não acontecer, use Arquivo-> Reiniciar.
Como o usuário marcará pontos por tocar em balões, precisamos inicializar uma variável de pontuação e exibir a pontuação na tela:
score = 0 scoreText = display.newText (pontuação, metadeW, 10)
A pontuação será mantida na variável denominada imaginativamente Ponto,e scoreText é o objeto que exibe a pontuação. Gostar nova imagem(), newText () coloque algo na tela, neste caso, o texto. Desde a scoreText é uma variável global, podemos alterar o texto a qualquer momento. Mas chegaremos a isso em breve.
Você pode reiniciar o emulador e ver a pontuação 0 exibida na parte superior da tela.
Esquerda: Apenas o plano de fundo. Direita: Histórico e pontuação.
Agora vem algo um pouco mais complicado, mas não se preocupe, vou explicar linha por linha:
função local balloonTouched (event) if (event.phase == "begin") e depois Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = score + 1 scoreText.text = score end end
O código acima define uma função chamada balloonTouched () que será chamado toda vez que um balão for tocado. Ainda não dissemos a Corona para chamar essa função toda vez que o balão for tocado, isso acontecerá mais tarde, mas quando fizermos isso, a função será chamada.
Os eventos de tocar ou tocar possuem vários estágios, muitos para suportar o arrasto. O usuário coloca o dedo em um objeto, esta é a fase "iniciada". Se eles deslizarem o dedo em qualquer direção, essa é a fase "movida". Quando o usuário levanta o dedo da tela, essa é a fase "finalizada".
A primeira linha de balloonTouched () verifica que estamos na fase "iniciada". Queremos remover o balão e aumentar a pontuação o mais rápido possível. Se a função for chamada novamente para outras fases como "finalizada", a função não fará nada.
Dentro deE se declaração são quatro linhas de código. Vamos lidar com os dois últimos primeiro, pois eles são mais simples.pontuação = pontuação + 1 apenas incrementa a pontuação em um escoreText.text = score altera o texto da pontuação na tela para refletir a nova pontuação. Lembre-se de como eu disse issoscoreText era global e poderia ser acessado em qualquer lugar, bem, é isso que fazemos aqui.
Agora, para as duas primeiras linhas. Quando um balão ou bomba cai na parte inferior da tela, ele ainda existe na memória do aplicativo, é possível que você não consiga vê-lo. À medida que o jogo avança, o número desses objetos fora da tela aumenta constantemente. Portanto, precisamos ter um mecanismo que exclua os objetos quando estiverem fora de vista. Fazemos isso em uma função chamadafora da tela, que ainda não escrevemos. Essa função será chamada uma vez por quadro durante o jogo. Depois de tocar em um balão, precisamos excluí-lo e remover a chamada que verifica se o balão ficou fora da tela.
A linhaevent.target:removeSelf () apaga o balão. Quando ocorre um evento de toque, um dos parâmetros da função de ouvinte é oevento parâmetro. Ele informa a função sobre o evento e que tipo de evento é, por exemploevent.phase. Também nos diz qual balão foi tocado,event.target. oremoveSelf () função faz o que diz que faz, exclui o objeto (neste caso, um balão).
A linha anterior remove o ouvinte "enterframe", que é a função chamada todos os quadros para verificar se o balão caiu na parte inferior da tela. Veremos isso com mais detalhes quando escrevermos ofora da tela função de ouvinte.
Então, para recapitular.balloonTouched ()verifica se este é o início da sequência de toque. Em seguida, ele remove o ouvinte "enterframe", que é a função chamada de todos os quadros para verificar se o balão caiu na parte inferior da tela. Em seguida, ele exclui o balão, incrementa a pontuação e exibe a nova pontuação.
Isso foi para balões, agora precisamos de algo semelhante para bombas:
função local bombTouched (event) if (event.phase == "begin") e depois Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = math.floor (score * 0.5) scoreText.text = fim final da pontuação
Como você pode ver, o código é muito semelhante, com a exceção de que, em vez de aumentar a pontuação, a pontuação é multiplicada por 0,5 (ou seja, dividido por 2). o math.floor () A função arredonda a pontuação para o número inteiro mais próximo. Portanto, se o jogador tivesse uma pontuação de 3 e tocasse em uma bomba, a nova pontuação seria 1, e não 1,5.
Eu mencionei o fora da tela () função anterior. Essa função será chamada de cada quadro para verificar se um objeto saiu da tela. Aqui está o código:
função local offscreen (self, event) if (self.y == nil), em seguida, retorne end if (self.y> display.contentHeight + 50) e depois Runtime: removeEventListener ("enterFrame", self) self: removeSelf () end end
Na computação, existe uma situação conhecida como condição de corrida. É aqui que duas coisas vão acontecer, mas uma pode acontecer primeiro ou, às vezes, a outra pode acontecer primeiro. É uma corrida. Algumas condições de corrida são invisíveis porque uma coisa sempre parece acontecer primeiro, mas elas podem causar erros interessantes naquele dia, nas condições certas, a outra coisa acontece primeiro e depois o sistema quebra!
Há uma condição de corrida neste jogo simples, porque duas coisas podem acontecer muito próximas uma da outra: um balão sendo tocado e o fora da tela () chamada para verificar se o balão saiu da tela. O resultado é que o código para excluir o balão pode ser chamado e, em seguida, o fora da tela () A função é chamada (o que acontece 30 vezes por segundo). Para contornar essa estranha seqüência de eventos, o fora da tela () A função precisa verificar se o y valor do objeto é nada (nulo) ou não. Se for nada significa que o objeto já foi excluído. Portanto, não se trata dos dróides que procuramos.
Se o objeto ainda estiver em execução, verifique sua posição, se tiver saído 50 pixels da tela, exclua-o e remova o ouvinte para que o objeto fora da tela () a função não será chamada novamente para este objeto. O código para garantir quefora da tela () é chamado de cada quadro faz parte da próxima seção do código.
Toda a premissa deste jogo é que novos balões ou bombas continuarão caindo na tela. Portanto, precisamos de uma função que crie um novo balão ou uma nova bomba:
função local addNewBalloonOrBomb () local startX = math.random (display.contentWidth * 0.1, display.contentWidth * 0.9) if (math.random (1,5) == 1) então - BOMB! bomba local = display.newImage ("bomb.png", startX, -300) physics.addBody (bomba) bomb.enterFrame = fora da tela Runtime: addEventListener ("enterFrame", bomba) bomba: addEventListener ("touch", bombTouched) else - Balão local do balão = display.newImage ("red_balloon.png", startX, -300) physics.addBody (balão) balloon.enterFrame = off-screen Tempo de execução: addEventListener ("enterFrame", balão) balão: addEventListener ("touch", balloonTouched) end end
A primeira linha da função decide de onde o balão cairá no x avião. Se o balão ou a bomba sempre caiu no meio, isso não será muito interessante! tãostartX é um número aleatório entre 10% e 90% da largura da tela.
Em seguida, um número aleatório é escolhido entre 1 e 5.Se o número for 1, uma bomba será lançada. Se 2, 3, 4 ou 5, um balão será derrubado. Isso significa que as bombas serão lançadas cerca de 20% do tempo.
O código da bomba e do balão é bastante semelhante. Primeiro, a imagem (uma bomba ou um balão) é exibida usandonova imagem(). Está x posição é a destartX enquanto a sua y A posição está definida para -300, ou seja, na parte superior da tela. A razão para isso é que queremos que o objeto caia de fora da área da tela para a área visível e depois para baixo. Como estamos usando o mecanismo de física 2D, é bom dar uma pequena distância inicial ao objeto para que ele possa ganhar velocidade.
A chamada paraphysics.addBody () tira a imagem carregada por nova imagem() e o transforma em um objeto no mecanismo de física. Isso é muito poderoso. Qualquer arquivo de imagem pode ser transformado em um corpo que responda à gravidade e colisões apenas chamandophysics.addBody ().
As últimas três linhas do código da bomba ou balão configuram os ouvintes. Configurando oenterFrame A propriedade informa ao Corona qual função chamar todos os quadros e a chamada paraTempo de execução: addEventListener () configura. Por fim, a chamada parabalão: addEventListener () diz a Corona qual função chamar se a bomba ou o balão for tocado.
E agora o jogo está quase completo. Só precisamos de mais duas linhas de código:
addNewBalloonOrBomb () timer.performWithDelay (500, addNewBalloonOrBomb, 0)
A primeira linha faz a primeira bomba ou balão cair chamando explicitamenteaddNewBalloonOrBomb (). A segunda linha configura um temporizador que chamaráaddNewBalloonOrBomb () a cada meio segundo (500 milissegundos). Isso significa que um novo balão ou bomba cairá a cada meio segundo.
Agora você pode executar o jogo no emulador.
Aqui está a lista completa do main.lua, o código fonte completo do projeto para este jogo pode ser encontrado aqui no GitHub.
-------------------------------------------------- --------------------------------------- - - Jogo de balão e bomba caindo - Escrito por Gary Sims para - ------------------------------------------- ---------------------------------------------- -- Comece o engine de física physics local = require ("physics") physics.start () - Calcule metade da largura e altura da tela halfW = display.contentWidth * 0.5 halfH = display.contentHeight * 0.5 - defina o plano de fundo local bkg = display.newImage ("night_sky.png", metadeW, metadeH) - Pontuação da pontuação = 0 scoreText = display.newText (pontuação, metadeW, 10) - Chamado quando o balão é tocado pelo jogador - Aumentar a pontuação em 1 função local do balãoTocado ( event) if (event.phase == "begin"), então Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = score + 1 scoreText.text = score end end - Chamado quando o bomba é tocada pelo jogador - Metade da pontuação como penalidade local bombTouched (event) if (event.phase == Runtime: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = math.floor (score * 0.5) scoreText.text = score end end - Exclua os objetos que caíram do parte inferior da tela, função local fora da tela (self, evento) if (self.y == nil), em seguida, retorne end if (self.y> display.contentHeight + 50) e depois Runtime: removeEventListener ("enterFrame", self) self: removeSelf () end end - Adicione uma nova função local de balão ou bomba em queda addNewBalloonOrBomb () - Você pode encontrar red_ballon.png e bomb.png no repositório local do GitHub startX = math.random (display.contentWidth * 0.1, display.contentWidth * 0,9) if (math.random (1,5) == 1) então - BOMB! bomba local = display.newImage ("bomb.png", startX, -300) physics.addBody (bomba) bomb.enterFrame = fora da tela Runtime: addEventListener ("enterFrame", bomba) bomba: addEventListener ("touch", bombTouched) else - Balão local do balão = display.newImage ("red_balloon.png", startX, -300) physics.addBody (balão) balloon.enterFrame = off-screen Tempo de execução: addEventListener ("enterFrame", balão) balão: addEventListener ("touch", balloonTouched) end end - Adicione um novo balão ou bomba agora addNewBalloonOrBomb () - Continue adicionando um novo balão ou bomba a cada 0,5 segundos timer.performWithDelay (500, addNewBalloonOrBomb, 0)
Próximos passos
O próximo passo é jogar o jogo em um dispositivo Android real. Para criar um arquivo .apk, clique em Arquivo-> Compilar para Android… e preencha os campos. O resultado será um arquivo .apk que você pode copiar no seu dispositivo e depois instalar. Você precisará garantir que você configurou seu dispositivo para permitir a instalação do aplicativo a partir de fontes desconhecidas. A Amazon possui uma boa documentação sobre isso, pois você também precisa configurá-lo para instalar a Amazon Appstore. Corona também tem um guia sobre como assinar, criar e testar seu aplicativo em dispositivos Android.
Com o jogo instalado com sucesso no seu dispositivo, a próxima coisa a fazer é melhorar o jogo. Por exemplo, por que não tentar adicionar um som "pop" ou "bang", tudo o que um balão ou bomba é tocado? Corona tem uma API para isso:media.playEventSound ().
Ou por que não tentar adicionar um terceiro tipo de objeto, digamos um super impulso que duplique a pontuação atual, ou que tal alguma música de fundo?
Embrulhar
Escrever jogos com o Corona é bastante direto, porque o SDK lida com coisas como o OpenGL e inclui um mecanismo de física 2D embutido. Além disso, Lua é fácil de aprender e não deve ser difícil para ninguém com o mínimo de experiência em programação. O site da Coronalabs possui muita documentação, incluindo muitos guias e tutoriais.
Em menos de 100 linhas de código, temos um jogo de trabalho. OK, não vai ganhar nenhum prêmio, mas mostra o poder e a flexibilidade do Corona SDK.
